Search is not available for this dataset
text stringlengths 75 104k |
|---|
def expand_dims(a, axis):
"""Insert a new axis, corresponding to a given position in the array shape
Args:
a (array_like): Input array.
axis (int): Position (amongst axes) where new axis is to be inserted.
"""
if hasattr(a, 'expand_dims') and hasattr(type(a), '__array_interface__'):
... |
def concatenate(tup, axis=0):
"""Join a sequence of arrays together.
Will aim to join `ndarray`, `RemoteArray`, and `DistArray` without moving
their data, if they happen to be on different engines.
Args:
tup (sequence of array_like): Arrays to be concatenated. They must have
the same sh... |
def vstack(tup):
"""Stack arrays in sequence vertically (row wise),
handling ``RemoteArray`` and ``DistArray`` without moving data.
Args:
tup (sequence of array_like)
Returns:
res: `ndarray`, if inputs were all local
`RemoteArray`, if inputs were all on the same remote engine
... |
def hstack(tup):
"""Stack arrays in sequence horizontally (column wise),
handling ``RemoteArray`` and ``DistArray`` without moving data.
Args:
tup (sequence of array_like)
Returns:
res: `ndarray`, if inputs were all local
`RemoteArray`, if inputs were all on the same remote en... |
def dstack(tup):
"""Stack arrays in sequence depth wise (along third dimension),
handling ``RemoteArray`` and ``DistArray`` without moving data.
Args:
tup (sequence of array_like)
Returns:
res: `ndarray`, if inputs were all local
`RemoteArray`, if inputs were all on the same r... |
def _broadcast_shape(*args):
"""Return the shape that would result from broadcasting the inputs"""
#TODO: currently incorrect result if a Sequence is provided as an input
shapes = [a.shape if hasattr(type(a), '__array_interface__')
else () for a in args]
ndim = max(len(sh) for sh in shapes... |
def mean(a, axis=None, dtype=None, out=None, keepdims=False):
"""
Compute the arithmetic mean along the specified axis.
Returns the average of the array elements. The average is taken over
the flattened array by default, otherwise over the specified axis.
`float64` intermediate and return values a... |
def _fetch(self):
"""forces update of a local cached copy of the real object
(regardless of the preference setting self.cache)"""
if not self._obcache_current:
from distob import engine
ax = self._distaxis
self._obcache = concatenate([ra._ob for ra in self._su... |
def _tosubslices(self, sl):
"""Maps a slice object for whole array to slice objects for subarrays.
Returns pair (ss, ms) where ss is a list of subarrays and ms is a list
giving the slice object that should be applied to each subarray.
"""
N = self.shape[self._distaxis]
st... |
def _valid_distaxis(shapes, ax):
"""`ax` is a valid candidate for a distributed axis if the given
subarray shapes are all the same when ignoring axis `ax`"""
compare_shapes = np.vstack(shapes)
if ax < compare_shapes.shape[1]:
compare_shapes[:, ax] = -1
return np.count... |
def expand_dims(self, axis):
"""Insert a new axis, at a given position in the array shape
Args:
axis (int): Position (amongst axes) where new axis is to be inserted.
"""
if axis == -1:
axis = self.ndim
if axis <= self._distaxis:
subaxis = axis
... |
def mean(self, axis=None, dtype=None, out=None, keepdims=False):
"""Compute the arithmetic mean along the specified axis.
See np.mean() for details."""
if axis == -1:
axis = self.ndim
if axis is None:
results = vectorize(mean)(self, axis, dtype, keepdims=False)
... |
def run(*args, **kwargs):
'''Returns True if successful, False if failure'''
kwargs.setdefault('env', os.environ)
kwargs.setdefault('shell', True)
try:
subprocess.check_call(' '.join(args), **kwargs)
return True
except subprocess.CalledProcessError:
logger.debug('Error runn... |
def cmd():
'''Return a command to launch a subshell'''
if platform == 'win':
return ['cmd.exe', '/K']
elif platform == 'linux':
ppid = os.getppid()
ppid_cmdline_file = '/proc/{0}/cmdline'.format(ppid)
try:
with open(ppid_cmdline_file) as f:
cmd =... |
def prompt(prefix=None, colored=True):
'''Generate a prompt with a given prefix
linux/osx: [prefix] user@host cwd $
win: [prefix] cwd:
'''
if platform == 'win':
return '[{0}] $P$G'.format(prefix)
else:
if colored:
return (
'[{0}] ' # White pre... |
def launch(prompt_prefix=None):
'''Launch a subshell'''
if prompt_prefix:
os.environ['PROMPT'] = prompt(prompt_prefix)
subprocess.call(cmd(), env=os.environ.data) |
def add_file(self, file, **kwargs):
"""Append a file to file repository.
For file monitoring, monitor instance needs file.
Please put the name of file to `file` argument.
:param file: the name of file you want monitor.
"""
if os.access(file, os.F_OK):
if ... |
def add_files(self, filelist, **kwargs):
"""Append files to file repository.
ModificationMonitor can append files to repository using this.
Please put the list of file names to `filelist` argument.
:param filelist: the list of file nmaes
"""
# check filelist is... |
def monitor(self, sleep=5):
"""Run file modification monitor.
The monitor can catch file modification using timestamp and file body.
Monitor has timestamp data and file body data. And insert timestamp
data and file body data before into while roop. In while roop, monitor
get ... |
def init_app(self, app):
"""Initialize a :class:`~flask.Flask` application for use with
this extension.
"""
self._jobs = []
if not hasattr(app, 'extensions'):
app.extensions = {}
app.extensions['restpoints'] = self
app.restpoints_instance = self
... |
def add_status_job(self, job_func, name=None, timeout=3):
"""Adds a job to be included during calls to the `/status` endpoint.
:param job_func: the status function.
:param name: the name used in the JSON response for the given status
function. The name of the function is th... |
def status_job(self, fn=None, name=None, timeout=3):
"""Decorator that invokes `add_status_job`.
::
@app.status_job
def postgresql():
# query/ping postgres
@app.status_job(name="Active Directory")
def active_directory():
... |
def _pipepager(text, cmd, color):
"""Page through text by feeding it to another program. Invoking a
pager through this might support colors.
"""
import subprocess
env = dict(os.environ)
# If we're piping to less we might support colors under the
# condition that
cmd_detail = cmd.rsplit... |
def _get_funky(func):
"""Renvoie une fonction numpy correspondant au nom passé en paramètre,
sinon renvoie la fonction elle-même"""
if isinstance(func, str):
try:
func = getattr(np, func)
except:
raise NameError("Nom de fonction non comprise")
return func |
def profil_journalier(df, func='mean'):
"""
Calcul du profil journalier
Paramètres:
df: DataFrame de données dont l'index est une série temporelle
(cf module xair par exemple)
func: function permettant le calcul. Soit un nom de fonction numpy ('mean', 'max', ...)
soit la fonction el... |
def profil_hebdo(df, func='mean'):
"""
Calcul du profil journalier
Paramètres:
df: DataFrame de données dont l'index est une série temporelle
(cf module xair par exemple)
func: function permettant le calcul. Soit un nom de fonction numpy ('mean', 'max', ...)
soit la fonction elle-mê... |
def profil_annuel(df, func='mean'):
"""
Calcul du profil annuel
Paramètres:
df: DataFrame de données dont l'index est une série temporelle
(cf module xair par exemple)
func: function permettant le calcul. Soit un nom de fonction numpy ('mean', 'max', ...)
soit la fonction elle-même ... |
def to_date(date, dayfirst=False, format=None):
"""
Transforme un champ date vers un objet python datetime
Paramètres:
date:
- si None, renvoie la date du jour
- si de type str, renvoie un objet python datetime
- si de type datetime, le retourne sans modification
dayfirst: Si... |
def _format(noms):
"""
Formate une donnée d'entrée pour être exploitable dans les fonctions liste_*
et get_*.
Paramètres:
noms: chaîne de caractère, liste ou tuples de chaînes de caractères ou
pandas.Series de chaînes de caractères.
Retourne:
Une chaînes de caractères dont chaque éléme... |
def date_range(debut, fin, freq):
"""
Génère une liste de date en tenant compte des heures de début et fin d'une journée.
La date de début sera toujours calée à 0h, et celle de fin à 23h
Paramètres:
debut: datetime représentant la date de début
fin: datetime représentant la date de fin
freq... |
def _connect(self):
"""
Connexion à la base XAIR
"""
try:
# On passe par Oracle Instant Client avec le TNS ORA_FULL
self.conn = cx_Oracle.connect(self._ORA_FULL)
self.cursor = self.conn.cursor()
print('XAIR: Connexion établie')
exc... |
def liste_parametres(self, parametre=None):
"""
Liste des paramètres
Paramètres:
parametre: si fourni, retourne l'entrée pour ce parametre uniquement
"""
condition = ""
if parametre:
condition = "WHERE CCHIM='%s'" % parametre
_sql = """SELECT... |
def liste_mesures(self, reseau=None, station=None, parametre=None, mesure=None):
"""
Décrit les mesures:
- d'un ou des reseaux,
- d'une ou des stations,
- d'un ou des parametres
ou décrit une (des) mesures suivant son (leur) identifiant(s)
Chaque attribut peut êtr... |
def liste_stations(self, station=None, detail=False):
"""
Liste des stations
Paramètres:
station : un nom de station valide (si vide, liste toutes les stations)
detail : si True, affiche plus de détail sur la (les) station(s).
"""
condition = ""
if stati... |
def liste_campagnes(self, campagne=None):
"""
Liste des campagnes de mesure et des stations associées
Paramètres:
campagne: Si définie, liste des stations que pour cette campagne
"""
condition = ""
if campagne:
condition = "WHERE NOM_COURT_CM='%s' "... |
def get_mesures(self, mes, debut=None, fin=None, freq='H', format=None,
dayfirst=False, brut=False):
"""
Récupération des données de mesure.
Paramètres:
mes: Un nom de mesure ou plusieurs séparées par des virgules, une liste
(list, tuple, pandas.Series) d... |
def get_manuelles(self, site, code_parametre, debut, fin, court=False):
"""
Recupération des mesures manuelles (labo) pour un site
site: numéro du site (voir fonction liste_sites_prelevement)
code_parametre: code ISO du paramètre à rechercher (C6H6=V4)
debut: date de début du pr... |
def get_indices(self, res, debut, fin):
"""
Récupération des indices ATMO pour un réseau donné.
Paramètres:
res : Nom du ou des réseaux à chercher (str, list, pandas.Series)
debut: date de début, format YYYY-MM-JJ (str)
fin: Date de fin, format YYYY-MM-JJ (str)
... |
def get_indices_et_ssi(self, reseau, debut, fin, complet=True):
"""Renvoie l'indice et les sous_indices
complet: renvoyer les complets ou les prévus
reseau: nom du réseau à renvoyer
debut: date de début à renvoyer
fin: date de fin à renvoyer
Renvoi : reseau, date, Indice... |
def get_sqltext(self, format_=1):
"""retourne les requêtes actuellement lancées sur le serveur"""
if format_ == 1:
_sql = """SELECT u.sid, substr(u.username,1,12) user_name, s.sql_text
FROM v$sql s,v$session u
WHERE s.hash_value = u.sql_hash_value
AND sql... |
def run_global_hook(hook_name, *args):
'''Attempt to run a global hook by name with args'''
hook_finder = HookFinder(get_global_hook_path())
hook = hook_finder(hook_name)
if hook:
hook.run(*args) |
def status(jobs):
"""Handler that calls each status job in a worker pool, attempting to timeout.
The resulting durations/errors are written to the response
as JSON.
eg.
`{
"endpoints": [
{ "endpoint": "Jenny's Database", "duration": 1.002556324005127 },
{ "endpoint"... |
def moyennes_glissantes(df, sur=8, rep=0.75):
"""
Calcule de moyennes glissantes
Paramètres:
df: DataFrame de mesures sur lequel appliqué le calcul
sur: (int, par défaut 8) Nombre d'observations sur lequel s'appuiera le
calcul
rep: (float, défaut 0.75) Taux de réprésentativité en dessous du... |
def consecutive(df, valeur, sur=3):
"""Calcule si une valeur est dépassée durant une période donnée. Détecte
un dépassement de valeur sur X heures/jours/... consécutifs
Paramètres:
df: DataFrame de mesures sur lequel appliqué le calcul
valeur: (float) valeur à chercher le dépassement (strictement s... |
def nombre_depassement(df, valeur, freq=None):
"""
Calcule le nombre de dépassement d'une valeur sur l'intégralité du temps,
ou suivant un regroupement temporel.
Paramètres:
df: DataFrame de mesures sur lequel appliqué le calcul
valeur: (float) valeur à chercher le dépassement (strictement supé... |
def aot40_vegetation(df, nb_an):
"""
Calcul de l'AOT40 du 1er mai au 31 juillet
*AOT40 : AOT 40 ( exprimé en micro g/m³ par heure ) signifie la somme des
différences entre les concentrations horaires supérieures à 40 parties par
milliard ( 40 ppb soit 80 micro g/m³ ), durant une période donnée en
... |
def _aot(df, nb_an=1, limite=80, mois_debut=5, mois_fin=7,
heure_debut=7, heure_fin=19):
"""
Calcul de l'AOT de manière paramètrable. Voir AOT40_vegetation ou
AOT40_foret pour des paramètres préalablement fixés.
Paramètres:
df: DataFrame de mesures sur lequel appliqué le calcul
nb_an: ... |
def no2(df):
"""
Calculs réglementaires pour le dioxyde d'azote
Paramètres:
df: DataFrame contenant les mesures, avec un index temporel
(voir xair.get_mesure)
Retourne:
Une série de résultats dans un DataFrame :
******
unité (u): µg/m3 (microgramme par mètre cube)
Seuil de RI ... |
def pm10(df):
"""
Calculs réglementaires pour les particules PM10
Paramètres:
df: DataFrame contenant les mesures, avec un index temporel
(voir xair.get_mesure)
Retourne:
Une série de résultats dans un DataFrame :
******
unité (u): µg/m3 (microgramme par mètre cube)
Seuil de R... |
def so2(df):
"""
Calculs réglementaires pour le dioxyde de soufre
Paramètres:
df: DataFrame contenant les mesures, avec un index temporel
(voir xair.get_mesure)
Retourne:
Une série de résultats dans un DataFrame :
******
unité (u): µg/m3 (microgramme par mètre cube)
Seuil de R... |
def co(df):
"""
Calculs réglementaires pour le monoxyde de carbone
Paramètres:
df: DataFrame contenant les mesures, avec un index temporel
(voir xair.get_mesure)
Retourne:
Une série de résultats dans un DataFrame :
******
unité (u): µg/m3 (microgramme par mètre cube)
Valeur li... |
def o3(df):
"""
Calculs réglementaires pour l'ozone
Paramètres:
df: DataFrame contenant les mesures, avec un index temporel
(voir xair.get_mesure)
Retourne:
Une série de résultats dans un DataFrame :
******
unité (u): µg/m3 (microgramme par mètre cube)
Seuil de RI sur 1H: 180u... |
def c6h6(df):
"""
Calculs réglementaires pour le benzène
Paramètres:
df: DataFrame contenant les mesures, avec un index temporel
(voir xair.get_mesure)
Retourne:
Une série de résultats dans un DataFrame :
******
unité (u): µg/m3 (microgramme par mètre cube)
Objectif de qualité... |
def arsenic(df):
"""
Calculs réglementaires pour l'arsenic
Paramètres:
df: DataFrame contenant les mesures, avec un index temporel
(voir xair.get_mesure)
Retourne:
Une série de résultats dans un DataFrame :
******
unité (u): ng/m3 (nanogramme par mètre cube)
Valeur cible en mo... |
def print_synthese(fct, df):
"""
Présente une synthèse des calculs réglementaires en fournissant les valeurs
calculées suivant les réglementations définies dans chaque fonction de calcul
et un tableau de nombre de dépassement.
Paramètres:
fct: fonction renvoyant les éléments calculées
df: D... |
def excel_synthese(fct, df, excel_file):
"""
Enregistre dans un fichier Excel une synthèse des calculs réglementaires en
fournissant les valeurs calculées suivant les réglementations définies dans
chaque fonction de calcul et un tableau de nombre de dépassement.
Les résultats sont enregistrés
P... |
def html_synthese(fct, df):
"""
Retourne au format html une synthèse des calculs réglementaires en
fournissant les valeurs calculées suivant les réglementations définies dans
chaque fonction de calcul et un tableau de nombre de dépassement.
Paramètres:
fct: fonction renvoyant les éléments calcu... |
def show_max(df):
"""Pour chaque serie (colonne) d'un DataFrame, va rechercher la (les) valeur(s)
et la (les) date(s) du (des) max.
Paramètres:
df: DataFrame de valeurs à calculer
Retourne:
Un DataFrame montrant pour chaque serie (colonne), les valeurs maxs aux dates
d'apparition.
"""
... |
def taux_de_representativite(df):
"""Calcul le taux de représentativité d'un dataframe"""
return (df.count().astype(pd.np.float) / df.shape[0] * 100).round(1) |
def validate(self):
'''Validate all the entries in the environment cache.'''
for env in list(self):
if not env.exists:
self.remove(env) |
def load(self):
'''Load the environment cache from disk.'''
if not os.path.exists(self.path):
return
with open(self.path, 'r') as f:
env_data = yaml.load(f.read())
if env_data:
for env in env_data:
self.add(VirtualEnvironment(env['ro... |
def save(self):
'''Save the environment cache to disk.'''
env_data = [dict(name=env.name, root=env.path) for env in self]
encode = yaml.safe_dump(env_data, default_flow_style=False)
with open(self.path, 'w') as f:
f.write(encode) |
def prompt(text, default=None, hide_input=False,
confirmation_prompt=False, type=None,
value_proc=None, prompt_suffix=': ',
show_default=True, err=False):
"""Prompts a user for input. This is a convenience function that can
be used to prompt a user for input later.
If the ... |
def echo_via_pager(text, color=None):
"""This function takes a text and shows it via an environment specific
pager on stdout.
.. versionchanged:: 3.0
Added the `color` flag.
:param text: the text to page.
:param color: controls if the pager supports ANSI colors or not. The
... |
def _remote_setup_engine(engine_id, nengines):
"""(Executed on remote engine) creates an ObjectEngine instance """
if distob.engine is None:
distob.engine = distob.ObjectEngine(engine_id, nengines)
# TODO these imports should be unnecessary with improved deserialization
import numpy as np
fr... |
def setup_engines(client=None):
"""Prepare all iPython engines for distributed object processing.
Args:
client (ipyparallel.Client, optional): If None, will create a client
using the default ipyparallel profile.
"""
if not client:
try:
client = ipyparallel.Client()
... |
def _process_args(args, kwargs, prefer_local=True, recurse=True):
"""Select local or remote execution and prepare arguments accordingly.
Assumes any remote args have already been moved to a common engine.
Local execution will be chosen if:
- all args are ordinary objects or Remote instances on the loca... |
def _remote_call(f, *args, **kwargs):
"""(Executed on remote engine) convert Ids to real objects, call f """
nargs = []
for a in args:
if isinstance(a, Id):
nargs.append(distob.engine[a])
elif (isinstance(a, collections.Sequence) and
not isinstance(a, string_types... |
def call(f, *args, **kwargs):
"""Execute f on the arguments, either locally or remotely as appropriate.
If there are multiple remote arguments, they must be on the same engine.
kwargs:
prefer_local (bool, optional): Whether to return cached local results if
available, in preference to ret... |
def convert_result(r):
"""Waits for and converts any AsyncResults. Converts any Ref into a Remote.
Args:
r: can be an ordinary object, ipyparallel.AsyncResult, a Ref, or a
Sequence of objects, AsyncResults and Refs.
Returns:
either an ordinary object or a Remote instance"""
if (isin... |
def _remote_methodcall(id, method_name, *args, **kwargs):
"""(Executed on remote engine) convert Ids to real objects, call method """
obj = distob.engine[id]
nargs = []
for a in args:
if isinstance(a, Id):
nargs.append(distob.engine[a])
elif (isinstance(a, collections.Sequenc... |
def methodcall(obj, method_name, *args, **kwargs):
"""Call a method of `obj`, either locally or remotely as appropriate.
obj may be an ordinary object, or a Remote object (or Ref or object Id)
If there are multiple remote arguments, they must be on the same engine.
kwargs:
prefer_local (bool,... |
def _scan_instance(obj, include_underscore, exclude):
"""(Executed on remote or local engine) Examines an object and returns info
about any instance-specific methods or attributes.
(For example, any attributes that were set by __init__() )
By default, methods or attributes starting with an underscore a... |
def proxy_methods(base, include_underscore=None, exclude=None, supers=True):
"""class decorator. Modifies `Remote` subclasses to add proxy methods and
attributes that mimic those defined in class `base`.
Example:
@proxy_methods(Tree)
class RemoteTree(Remote, Tree)
The decorator registers ... |
def _async_scatter(obj, destination=None):
"""Distribute an obj or list to remote engines.
Return an async result or (possibly nested) lists of async results,
each of which is a Ref
"""
#TODO Instead of special cases for strings and Remote, should have a
# list of types that should not be ... |
def _ars_to_proxies(ars):
"""wait for async results and return proxy objects
Args:
ars: AsyncResult (or sequence of AsyncResults), each result type ``Ref``.
Returns:
Remote* proxy object (or list of them)
"""
if (isinstance(ars, Remote) or
isinstance(ars, numbers.Number) or
... |
def _scatter_ndarray(ar, axis=-1, destination=None, blocksize=None):
"""Turn a numpy ndarray into a DistArray or RemoteArray
Args:
ar (array_like)
axis (int, optional): specifies along which axis to split the array to
distribute it. The default is to split along the last axis. `None` means
... |
def scatter(obj, axis=-1, blocksize=None):
"""Distribute obj or list to remote engines, returning proxy objects
Args:
obj: any python object, or list of objects
axis (int, optional): Can be used if scattering a numpy array,
specifying along which axis to split the array to distribute it. The... |
def gather(obj):
"""Retrieve objects that have been distributed, making them local again"""
if hasattr(obj, '__distob_gather__'):
return obj.__distob_gather__()
elif (isinstance(obj, collections.Sequence) and
not isinstance(obj, string_types)):
return [gather(subobj) for subobj ... |
def vectorize(f):
"""Upgrade normal function f to act in parallel on distibuted lists/arrays
Args:
f (callable): an ordinary function which expects as its first argument a
single object, or a numpy array of N dimensions.
Returns:
vf (callable): new function that takes as its first argu... |
def apply(f, obj, *args, **kwargs):
"""Apply a function in parallel to each element of the input"""
return vectorize(f)(obj, *args, **kwargs) |
def call_all(sequence, method_name, *args, **kwargs):
"""Call a method on each element of a sequence, in parallel.
Returns:
list of results
"""
kwargs = kwargs.copy()
kwargs['block'] = False
results = []
for obj in sequence:
results.append(methodcall(obj, method_name, *args, **... |
def register_proxy_type(cls, real_type, proxy_type):
"""Configure engines so that remote methods returning values of type
`real_type` will instead return by proxy, as type `proxy_type`
"""
if distob.engine is None:
cls._initial_proxy_types[real_type] = proxy_type
elif... |
def _fetch(self):
"""forces update of a local cached copy of the real object
(regardless of the preference setting self.cache)"""
if not self.is_local and not self._obcache_current:
#print('fetching data from %s' % self._ref.id)
def _remote_fetch(id):
retu... |
def extract_json(fileobj, keywords, comment_tags, options):
"""
Supports: gettext, ngettext. See package README or github ( https://github.com/tigrawap/pybabel-json ) for more usage info.
"""
data=fileobj.read()
json_extractor=JsonExtractor(data)
strings_data=json_extractor.get_lines_data()
... |
def get_lines_data(self):
"""
Returns string:line_numbers list
Since all strings are unique it is OK to get line numbers this way.
Since same string can occur several times inside single .json file the values should be popped(FIFO) from the list
:rtype: list
"""
... |
def is_git_repo(path):
'''Returns True if path is a git repository.'''
if path.startswith('git@') or path.startswith('https://'):
return True
if os.path.exists(unipath(path, '.git')):
return True
return False |
def is_home_environment(path):
'''Returns True if path is in CPENV_HOME'''
home = unipath(os.environ.get('CPENV_HOME', '~/.cpenv'))
path = unipath(path)
return path.startswith(home) |
def is_redirecting(path):
'''Returns True if path contains a .cpenv file'''
candidate = unipath(path, '.cpenv')
return os.path.exists(candidate) and os.path.isfile(candidate) |
def redirect_to_env_paths(path):
'''Get environment path from redirect file'''
with open(path, 'r') as f:
redirected = f.read()
return shlex.split(redirected) |
def expandpath(path):
'''Returns an absolute expanded path'''
return os.path.abspath(os.path.expandvars(os.path.expanduser(path))) |
def unipath(*paths):
'''Like os.path.join but also expands and normalizes path parts.'''
return os.path.normpath(expandpath(os.path.join(*paths))) |
def binpath(*paths):
'''Like os.path.join but acts relative to this packages bin path.'''
package_root = os.path.dirname(__file__)
return os.path.normpath(os.path.join(package_root, 'bin', *paths)) |
def ensure_path_exists(path, *args):
'''Like os.makedirs but keeps quiet if path already exists'''
if os.path.exists(path):
return
os.makedirs(path, *args) |
def walk_dn(start_dir, depth=10):
'''
Walk down a directory tree. Same as os.walk but allows for a depth limit
via depth argument
'''
start_depth = len(os.path.split(start_dir))
end_depth = start_depth + depth
for root, subdirs, files in os.walk(start_dir):
yield root, subdirs, fil... |
def walk_up(start_dir, depth=20):
'''
Walk up a directory tree
'''
root = start_dir
for i in xrange(depth):
contents = os.listdir(root)
subdirs, files = [], []
for f in contents:
if os.path.isdir(os.path.join(root, f)):
subdirs.append(f)
... |
def preprocess_dict(d):
'''
Preprocess a dict to be used as environment variables.
:param d: dict to be processed
'''
out_env = {}
for k, v in d.items():
if not type(v) in PREPROCESSORS:
raise KeyError('Invalid type in dict: {}'.format(type(v)))
out_env[k] = PREPR... |
def _join_seq(d, k, v):
'''Add a sequence value to env dict'''
if k not in d:
d[k] = list(v)
elif isinstance(d[k], list):
for item in v:
if item not in d[k]:
d[k].insert(0, item)
elif isinstance(d[k], string_types):
v.append(d[k])
d[k] = v |
def join_dicts(*dicts):
'''Join a bunch of dicts'''
out_dict = {}
for d in dicts:
for k, v in d.iteritems():
if not type(v) in JOINERS:
raise KeyError('Invalid type in dict: {}'.format(type(v)))
JOINERS[type(v)](out_dict, k, v)
return out_dict |
def env_to_dict(env, pathsep=os.pathsep):
'''
Convert a dict containing environment variables into a standard dict.
Variables containing multiple values will be split into a list based on
the argument passed to pathsep.
:param env: Environment dict like os.environ.data
:param pathsep: Path sepa... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.