docstring stringlengths 52 499 | function stringlengths 67 35.2k | __index_level_0__ int64 52.6k 1.16M |
|---|---|---|
Combine package specifications' limitations.
Args:
specs (list of PackageSpec): the package specifications.
Returns:
list of PackageSpec: the new, merged list of PackageSpec. | def combine(specs):
new_specs = {}
for spec in specs:
if new_specs.get(spec, None) is None:
new_specs[spec] = spec
else:
new_specs[spec].add(spec)
return list(new_specs.values()) | 891,176 |
Find method.
Args:
package (str): package to find.
**kwargs (): additional keyword arguments.
Returns:
PackageSpec: the PackageSpec corresponding to the package, or None. | def find(self, package, **kwargs):
if not exists(package):
return None
name, path = None, None
enforce_init = kwargs.pop('enforce_init', True)
if isdir(package):
if isfile(join(package, '__init__.py')) or not enforce_init:
name, path = bas... | 891,177 |
Find method.
Args:
package (str): package to find.
**kwargs (): additional keyword arguments.
Returns:
PackageSpec: the PackageSpec corresponding to the package, or None. | def find(self, package, **kwargs):
spec = find_spec(package)
if spec is None:
return None
limit = []
if '.' in package:
package, limit = package.split('.', 1)
limit = [limit]
spec = find_spec(package)
if spec is not None:
... | 891,178 |
Initialization method.
Args:
finders (list of classes):
list of package finder classes (not instances) in a specific
order. Default: [LocalPackageFinder, InstalledPackageFinder]. | def __init__(self, finders=None):
if finders is None:
self.finders = [LocalPackageFinder(), InstalledPackageFinder()]
else:
self.finders = [f() for f in finders] | 891,179 |
Find a package using package finders.
Return the first package found.
Args:
package (str): package to find.
**kwargs (): additional keyword arguments used by finders.
Returns:
PackageSpec: if package found, else None | def find(self, package, **kwargs):
for finder in self.finders:
package_spec = finder.find(package, **kwargs)
if package_spec:
return package_spec
return None | 891,180 |
Retrieves environment variables from a namespace.
Args:
prefix (str): The prefix, without a trailing underscore.
Returns:
list: A list of environment variable keys and values. | def get_environ(cls, prefix):
return ((key[len(prefix) + 1:], value)
for key, value in os.environ.items()
if key.startswith('%s_' % prefix)) | 891,361 |
Retrieves an environment variable value as a dictionary.
Args:
name (str): The case-insensitive, unprefixed variable name.
default: If provided, a default value will be returned
instead of throwing ``EnvironmentError``.
Returns:
dict: The environment... | def get_dict(self, name, default=None):
if name not in self:
if default is not None:
return default
raise EnvironmentError.not_found(self._prefix, name)
return dict(**self.get(name)) | 891,363 |
Create new storage service client.
Arguments:
environment(str): The service environment to be used for the client.
'prod' or 'dev'.
access_token(str): The access token used to authenticate with the
service
Returns:
... | def new(cls, access_token, environment='prod'):
api_client = ApiClient.new(access_token, environment)
return cls(api_client) | 891,483 |
Check if a certain path exists in the storage service.
Args:
path (str): The path to be checked
Returns:
True if the path exists, False otherwise
Raises:
StorageArgumentException: Invalid arguments
StorageForbiddenException: Server response code... | def exists(self, path):
self.__validate_storage_path(path)
try:
metadata = self.api_client.get_entity_by_query(path=path)
except StorageNotFoundException:
return False
return metadata and 'uuid' in metadata | 891,486 |
Get the parent entity of the entity pointed by the given path.
Args:
path (str): The path of the entity whose parent is needed
Returns:
A JSON object of the parent entity if found.
Raises:
StorageArgumentException: Invalid arguments
StorageForbi... | def get_parent(self, path):
self.__validate_storage_path(path, projects_allowed=False)
path_steps = [step for step in path.split('/') if step]
del path_steps[-1]
parent_path = '/{0}'.format('/'.join(path_steps))
return self.api_client.get_entity_by_query(path=parent_pat... | 891,487 |
Create a folder in the storage service pointed by the given path.
Args:
path (str): The path of the folder to be created
Returns:
None
Raises:
StorageArgumentException: Invalid arguments
StorageForbiddenException: Server response code 403
... | def mkdir(self, path):
self.__validate_storage_path(path, projects_allowed=False)
parent_metadata = self.get_parent(path)
self.api_client.create_folder(path.split('/')[-1], parent_metadata['uuid']) | 891,488 |
Delete an entity from the storage service using its path.
Args:
path(str): The path of the entity to be delete
Returns:
The uuid of created file entity as string
Raises:
StorageArgumentException: Invalid arguments
Sto... | def delete(self, path):
self.__validate_storage_path(path, projects_allowed=False)
entity = self.api_client.get_entity_by_query(path=path)
if entity['entity_type'] in self.__BROWSABLE_TYPES:
# At this point it can only be a folder
contents = self.api_client.li... | 891,490 |
Initialization method.
Args:
*packages (args): list of packages to search for.
build_tree (bool): auto-build the tree or not.
build_dependencies (bool): auto-build the dependencies or not.
enforce_init (bool):
if True, only treat directories if th... | def __init__(self,
*packages,
build_tree=True,
build_dependencies=True,
enforce_init=True):
self.finder = Finder()
self.specs = []
self.not_found = []
self.enforce_init = enforce_init
specs = []
... | 891,666 |
Return the number of dependencies of this package to the given node.
Args:
to (Package/Module): target node.
Returns:
int: number of dependencies. | def cardinal(self, to):
return sum(m.cardinal(to) for m in self.submodules) | 891,671 |
Initialization method.
Args:
name (str): name of the module.
path (str): path to the module.
dsm (DSM): parent DSM.
package (Package): parent Package. | def __init__(self, name, path, dsm=None, package=None):
super().__init__()
self.name = name
self.path = path
self.package = package
self.dsm = dsm
self.dependencies = [] | 891,672 |
Whether given item is contained inside this module.
Args:
item (Package/Module): a package or module.
Returns:
bool:
True if self is item or item is self's package and
self if an ``__init__`` module. | def __contains__(self, item):
if self is item:
return True
elif self.package is item and self.name == '__init__':
return True
return False | 891,673 |
Return all the import statements given an AST body (AST nodes).
Args:
ast_body (compiled code's body): the body to filter.
Returns:
list of dict: the import statements. | def get_imports(self, ast_body):
imports = []
for node in ast_body:
if isinstance(node, ast.Import):
imports.extend({'target': name.name, 'lineno': node.lineno}
for name in node.names)
elif isinstance(node, ast.ImportFrom):
... | 891,680 |
Return the number of dependencies of this module to the given node.
Args:
to (Package/Module): the target node.
Returns:
int: number of dependencies. | def cardinal(self, to):
return sum(1 for _ in filter(
lambda d: not d.external and d.target in to, self.dependencies)) | 891,681 |
Initialization method.
Args:
source (Module): source Module.
lineno (int): number of line at which import statement occurs.
target (str/Module/Package): the target node.
what (str): what is imported (optional). | def __init__(self, source, lineno, target, what=None):
self.source = source
self.lineno = lineno
self.target = target
self.what = what | 891,682 |
Add SSH public key to a user's profile.
Args:
username: Username to attach SSH public key to
filename: Filename containing keys to add (optional)
Raises:
ldap3.core.exceptions.LDAPNoSuchAttributeResult:
ldapPublicKey isn't attached to objectClass | def add(self, username, user_api, filename=None):
keys = API.__get_keys(filename)
user = user_api.find(username)[0]
distinguished_name = user.entry_dn
if 'ldapPublicKey' not in user.objectClass:
raise ldap3.core.exceptions.LDAPNoSuchAttributeResult(
'... | 891,829 |
Fetch keys from ldap.
Args:
username Username associated with keys to fetch (optional)
Returns:
Array of dictionaries in '{username: [public keys]}' format | def get_keys_from_ldap(self, username=None):
result_dict = {}
filter = ['(sshPublicKey=*)']
if username is not None:
filter.append('(uid={})'.format(username))
attributes = ['uid', 'sshPublicKey']
results = self.client.search(filter, attributes)
for r... | 891,832 |
Read a package list from a given file path.
Args:
filepath: file path of the package list.
Returns:
a list of package names. | def load_requires_from_file(filepath):
with open(filepath) as fp:
return [pkg_name.strip() for pkg_name in fp.readlines()] | 891,869 |
Constructor.
Args:
element: Object to add into the node. | def __init__(self, element=None):
super(TreeMapNode, self).__init__()
self._element = element
self._nodes = dict()
self._parent = None
self._depth = -1 | 892,048 |
Attach node to its parent.
Args:
node: Parent node.
Note:
``node`` can be ``None``. In that case, the node is detached from its previous parent. | def set_parent(self, node):
self._parent = node
if node is None:
# detach from parent
self._depth = 0
else:
self._depth = node.get_depth() + 1 | 892,049 |
Add one child node to this node.
Args:
name (str): Name of the child.
node (TreeMapNode): Node to add.
Warning:
No test is done to see whether or not a node was already attached with that name. If this is the case, the
new node takes the place of the old... | def set_child_node(self, name, node):
assert isinstance(node, TreeMapNode)
self._nodes[name] = node
node.set_parent(self) | 892,050 |
Add one child node to this node.
Args:
name (str): Name of the child.
node (TreeMapNode): Node to add.
Note:
The name must **not** be in use. | def set_unique_child_node(self, name, node):
try:
temp = self._nodes[name]
raise RuntimeError("Name '%s' is already used for child node" % name)
except KeyError:
pass
self.set_child_node(name, node) | 892,051 |
Constructor.
Args:
element: object to attach to this root. | def __init__(self, element=None):
super(RootTreeMapNode, self).__init__(element)
self._depth = 0 | 892,056 |
Container to store an "action".
Every file(s) generation is considered as an action.
Args:
file_pattern: fnmatch pattern.
action_function: Callback without argument. See documentation. | def __init__(self, file_pattern, action_function):
super(GeneratorAction, self).__init__()
self.__file_pattern = file_pattern
self.__action_function = action_function | 892,084 |
Return the **first** compatible :class:`GeneratorAction` for a given filename or ``None`` if none is found.
Args:
filename (str): The filename of the template to process. | def get_compatible_generator_action(self, filename):
# find first compatible generator action
for action in self.__generator_actions:
if action.act_on_file(filename):
return action
return None | 892,086 |
Constructor of a :program:`cygenja` template machine.
Args:
directory (str): Absolute or relative base directory. Everything happens in that directory and sub-directories.
jinja2_environment: :program:`Jinja2` environment.
logger: A logger (from the standard ``logging``) or ... | def __init__(self, directory, jinja2_environment, logger=None, raise_exception_on_warning=False):
super(Generator, self).__init__()
# before all the rest, prepare logging
self.__logger = logger
self.__raise_exception_on_warning = raise_exception_on_warning
# test if di... | 892,087 |
Log a warning if ``logger`` exists.
Args:
msg: Warning to log.
Warning:
Can raise a ``RuntimeError`` if this was asked in the constructor. | def log_warning(self, msg):
if self.__logger:
self.__logger.warning(msg)
if self.__raise_exception_on_warning:
raise RuntimeError(msg) | 892,088 |
Log an error and raise an exception.
Args:
msg: Error message to log.
Raises:
RuntimeError: With the message. | def log_error(self, msg):
if self.__logger:
self.__logger.error(msg)
raise RuntimeError(msg) | 892,089 |
Add/register one filter.
Args:
filter_name (str): Filter name used inside :program:`Jinja2` tags.
filter_ref: Reference to the filter itself, i.e. the corresponding :program:`Python` function.
force (bool): If set to ``True``, forces the registration of a filter no matter if... | def register_filter(self, filter_name, filter_ref, force=False):
if not force and (filter_name in self.filters_list()):
self.log_warning("Extension %s already exist, ignore redefinition." % ext_in)
return
self.__jinja2_environment.filters[filter_name] = filter_ref | 892,090 |
Add/register filters.
Args:
filters (dict): Dictionary of Python functions to use as :program:`Jinja2` filters.
force (bool): If set to ``True``, forces the registration of a filter no matter if it already exists or not. | def register_filters(self, filters, force=False):
for filter_name, filter_ref in filters.items():
self.register_filter(filter_name, filter_ref, force) | 892,091 |
Add/register a file extension.
Args:
ext_in (str): Extension of input files.
ext_out (str): Extension of corresponding output files.
force (bool): If ``force`` is set to ``True``, simply overwrite existing extensions, otherwise do nothing.
If the ``logger`` ... | def register_extension(self, ext_in, ext_out, force=False):
if not force and (ext_in in self.__extensions.keys()):
self.log_warning("Extension %s already exist, ignore redefinition." % ext_in)
return
self.__extensions[ext_in] = ext_out | 892,094 |
Add/register extensions.
Args:
exts (dict):
force (bool): If ``force`` is set to ``True``, simply overwrite existing extensions, otherwise do nothing.
If the ``logger`` is set, log a warning about the duplicate extension if ``force == False``. | def register_extensions(self, exts, force=False):
for ext_in, ext_out in exts.items():
self.register_extension(ext_in, ext_out, force) | 892,095 |
Add action into the dictionary of actions.
Args:
relative_directory:
action: | def __add_action(self, relative_directory, action):
generator_action_container = self.__actions.retrieve_element_or_default(relative_directory, None)
if generator_action_container is None:
generator_action_container = GeneratorActionContainer()
generator_action_containe... | 892,096 |
Detect if given function is really an action function.
Args:
action_function: Function to test.
Note:
We don't care if the variable refer to a function but rather if it is callable or not. | def __is_function_action(self, action_function):
# test if function returns a couple of values
is_function_action = True
if not hasattr(action_function, '__call__'):
return False
# OK, callable. Do we receive the right arguments?
try:
for end_st... | 892,097 |
Create a new storage service REST client.
Arguments:
environment: The service environment to be used for the client
access_token: The access token used to authenticate with the
service
Returns:
A storage_service.api.ApiClient ... | def new(cls, access_token, environment='prod'):
request = RequestBuilder \
.request(environment) \
.to_service(cls.SERVICE_NAME, cls.SERVICE_VERSION) \
.throw(
StorageForbiddenException,
lambda resp: 'You are forbidden to do this.'
... | 892,368 |
Delete a project. It will recursively delete all the content.
Args:
project (str): The UUID of the project to be deleted.
Returns:
None
Raises:
StorageArgumentException: Invalid arguments
StorageForbiddenException: 403
StorageNotFoun... | def delete_project(self, project):
if not is_valid_uuid(project):
raise StorageArgumentException(
'Invalid UUID for project: {0}'.format(project))
self._authenticated_request \
.to_endpoint('project/{}/'.format(project)) \
.delete() | 892,379 |
Delete a folder. It will recursively delete all the content.
Args:
folder_id (str): The UUID of the folder to be deleted.
Returns:
None
Raises:
StorageArgumentException: Invalid arguments
StorageForbiddenException: 403
StorageNotFoun... | def delete_folder(self, folder):
if not is_valid_uuid(folder):
raise StorageArgumentException(
'Invalid UUID for folder: {0}'.format(folder))
self._authenticated_request \
.to_endpoint('folder/{}/'.format(folder)) \
.delete() | 892,383 |
Copy file content from source file to target file.
Args:
file_id (str): The UUID of the file whose content is written.
source_file (str): The UUID of the file whose content is copied.
Returns:
None
Raises:
StorageArgumentException: Invalid arguments... | def copy_file_content(self, file_id, source_file):
if not is_valid_uuid(file_id):
raise StorageArgumentException(
'Invalid UUID for file_id: {0}'.format(file_id))
if not is_valid_uuid(source_file):
raise StorageArgumentException(
'Invalid... | 892,385 |
Delete a file.
Args:
file_id (str): The UUID of the file to delete.
Returns:
None
Raises:
StorageArgumentException: Invalid arguments
StorageForbiddenException: Server response code 403
StorageNotFoundException: Server response code ... | def delete_file(self, file_id):
if not is_valid_uuid(file_id):
raise StorageArgumentException(
'Invalid UUID for file_id: {0}'.format(file_id))
self._authenticated_request \
.to_endpoint('file/{}/'.format(file_id)) \
.delete() | 892,388 |
Find out equality of two SQL items.
See https://docs.djangoproject.com/en/1.8/ref/migration-operations/#runsql.
Args:
sqls1, sqls2: SQL items, have the same format as supported by Django's RunSQL operation.
Returns:
(bool) `True` if equal, otherwise `False`. | def is_sql_equal(sqls1, sqls2):
is_seq1 = isinstance(sqls1, (list, tuple))
is_seq2 = isinstance(sqls2, (list, tuple))
if not is_seq1:
sqls1 = (sqls1,)
if not is_seq2:
sqls2 = (sqls2,)
if len(sqls1) != len(sqls2):
return False
for sql1, sql2 in zip(sqls1, sqls2):
... | 892,415 |
Generate forward operations for changing/creating SQL item dependencies.
Dependencies are only in-memory and should be reflecting database dependencies, so
changing them in SQL config does not alter database. Such actions are persisted in separate
type operation - `AlterSQLState`.
Args... | def _generate_altered_sql_dependencies(self, dep_changed_keys):
for key, removed_deps, added_deps in dep_changed_keys:
app_label, sql_name = key
operation = AlterSQLState(sql_name, add_dependencies=tuple(added_deps),
remove_dependencies=tupl... | 892,421 |
Consume and process arguments and store the result.
ARGS:
argv <list str>:
The argument list to parse.
usedname <str>:
The string used by the user to invoke the option.
location <str>:
A user friendly sring describing where the parser got this
... | def parse(self, argv, usedname, location):
try:
value = self.format.parse(argv)
except formats.BadNumberOfArguments, e:
raise BadNumberOfArguments(usedname, e.required, e.supplied)
except formats.BadArgument, e:
raise BadArgument(usedname, e.argument,... | 892,460 |
Parse a string lexically and store the result.
ARGS:
argsstr <str>:
The string to parse.
usedname <str>:
The string used by the user to invoke the option.
location <str>:
A user friendly sring describing where the parser got this
data from. | def parsestr(self, argsstr, usedname, location):
try:
value = self.format.parsestr(argsstr)
except formats.BadNumberOfArguments, e:
raise BadNumberOfArguments(usedname, e.required, e.supplied)
except formats.BadArgument, e:
raise BadArgument(usedname,... | 892,461 |
Textwrap an indented paragraph.
ARGS:
width = 0 <int>:
Maximum allowed page width. 0 means use default from
self.iMaxHelpWidth. | def _wrap(self, text, indent=0, width=0):
text = _list(text)
if not width:
width = self.width
paragraph = text[0].lstrip()
s = ' ' * (len(text[0]) - len(paragraph) + indent)
wrapped = textwrap.wrap(paragraph.strip(), width, initial_indent=s, subsequent_indent... | 892,480 |
Textwrap usage instructions.
ARGS:
width = 0 <int>:
Maximum allowed page width. 0 means use default from
self.iMaxHelpWidth. | def _wrapusage(self, usage=None, width=0):
if not width:
width = self.width
return textwrap.fill('USAGE: ' + self.format_usage(usage), width=width, subsequent_indent=' ...') | 892,483 |
Return brief help containing Title and usage instructions.
ARGS:
width = 0 <int>:
Maximum allowed page width. 0 means use default from
self.iMaxHelpWidth. | def shorthelp(self, width=0):
out = []
out.append(self._wrap(self.docs['title'], width=width))
if self.docs['description']:
out.append(self._wrap(self.docs['description'], indent=2, width=width))
out.append('')
out.append(self._wrapusage(width=width))
... | 892,484 |
Get node corresponding to last location in a :class:`LocationDescriptor` object.
Args:
loc_descriptor: A :class:`LocationDescriptor` object
create_non_existing_nodes (bool): Do we create non existing nodes along the way (including last node)?
Raises:
... | def _get_node(self, loc_descriptor, create_non_existing_nodes=False):
node = self._root_node
for location in loc_descriptor.generate_all_sub_locations():
child = node.get_child_node_or_default(location, None)
if child is None:
if not create_non_existing_... | 892,496 |
Sets the service name and version the request should target
Args:
service (str): The name of the service as displayed in the services.json file
version (str): The version of the service as displayed in the services.json file
Returns:
The request builder instance in ... | def to_service(self, service, version):
service_url = self._service_locator.get_service_url(service, version)
return self.__copy_and_set('service_url', self.__strip_trailing_slashes(service_url)) | 892,932 |
Adds headers to the request
Args:
headers (dict): The headers to add the request headers
Returns:
The request builder instance in order to chain calls | def with_headers(self, headers):
copy = headers.copy()
copy.update(self._headers)
return self.__copy_and_set('headers', copy) | 892,933 |
Adds parameters to the request params
Args:
params (dict): The parameters to add to the request params
Returns:
The request builder instance in order to chain calls | def with_params(self, params):
copy = params.copy()
copy.update(self._params)
return self.__copy_and_set('params', copy) | 892,934 |
Defines if the an exception should be thrown after the request is sent
Args:
exception_class (class): The class of the exception to instantiate
should_throw (function): The predicate that should indicate if the exception
should be thrown. This function will be called wit... | def throw(self, exception_class, should_throw):
return self.__copy_and_set('throws', self._throws + [(exception_class, should_throw)]) | 892,935 |
Initialization method.
Args:
build_tree (bool): whether to immediately build the tree or not. | def __init__(self, build_tree=True):
self._target_cache = {}
self._item_cache = {}
self._contains_cache = {}
self._matrix_cache = {}
self._graph_cache = {}
self._treemap_cache = None
self.modules = []
self.packages = []
if build_tree:
... | 892,986 |
Get result of _contains, cache it and return it.
Args:
item (Package/Module): a package or module.
Returns:
bool: True if self contains item, False otherwise. | def __contains__(self, item):
if item not in self._contains_cache:
self._contains_cache[item] = self._contains(item)
return self._contains_cache[item] | 892,987 |
Return the corresponding Package or Module object.
Args:
item (str): name of the package/module, dot-separated.
Returns:
Package/Module: corresponding object. | def __getitem__(self, item):
depth = item.count('.') + 1
parts = item.split('.', 1)
for m in self.modules:
if parts[0] == m.name:
if depth == 1:
return m
for p in self.packages:
if parts[0] == p.name:
if... | 892,988 |
Whether given item is contained inside the node modules/packages.
Args:
item (Package/Module): a package or module.
Returns:
bool: True if self is item or item in self's packages/modules. | def _contains(self, item):
if self is item:
return True
for m in self.modules:
if item in m:
return True
for p in self.packages:
if item in p:
return True
return False | 892,990 |
Get item through ``__getitem__`` and cache the result.
Args:
item (str): name of package or module.
Returns:
Package/Module: the corresponding object. | def get(self, item):
if item not in self._item_cache:
try:
item = self.__getitem__(item)
except KeyError:
item = None
self._item_cache[item] = item
return self._item_cache[item] | 892,991 |
Get the result of _get_target, cache it and return it.
Args:
target (str): target to find.
Returns:
Package/Module: package containing target or corresponding module. | def get_target(self, target):
if target not in self._target_cache:
self._target_cache[target] = self._get_target(target)
return self._target_cache[target] | 892,992 |
Get the Package or Module related to given target.
Args:
target (str): target to find.
Returns:
Package/Module: package containing target or corresponding module. | def _get_target(self, target):
depth = target.count('.') + 1
parts = target.split('.', 1)
for m in self.modules:
if parts[0] == m.name:
if depth < 3:
return m
for p in self.packages:
if parts[0] == p.name:
... | 892,993 |
Print the graph for self's nodes.
Args:
format (str): output format (csv, json or text).
output (file): file descriptor on which to write.
depth (int): depth of the graph. | def print_graph(self, format=None, output=sys.stdout, depth=0, **kwargs):
graph = self.as_graph(depth=depth)
graph.print(format=format, output=output, **kwargs) | 892,995 |
Print the matrix for self's nodes.
Args:
format (str): output format (csv, json or text).
output (file): file descriptor on which to write.
depth (int): depth of the matrix. | def print_matrix(self, format=None, output=sys.stdout, depth=0, **kwargs):
matrix = self.as_matrix(depth=depth)
matrix.print(format=format, output=output, **kwargs) | 892,996 |
Print the matrix for self's nodes.
Args:
format (str): output format (csv, json or text).
output (file): file descriptor on which to write. | def print_treemap(self, format=None, output=sys.stdout, **kwargs):
treemap = self.as_treemap()
treemap.print(format=format, output=output, **kwargs) | 892,997 |
Create a graph with self as node, cache it, return it.
Args:
depth (int): depth of the graph.
Returns:
Graph: an instance of Graph. | def as_graph(self, depth=0):
if depth in self._graph_cache:
return self._graph_cache[depth]
self._graph_cache[depth] = graph = Graph(self, depth=depth)
return graph | 893,001 |
Create a matrix with self as node, cache it, return it.
Args:
depth (int): depth of the matrix.
Returns:
Matrix: an instance of Matrix. | def as_matrix(self, depth=0):
if depth in self._matrix_cache:
return self._matrix_cache[depth]
self._matrix_cache[depth] = matrix = Matrix(self, depth=depth)
return matrix | 893,002 |
Return the absolute name of the node.
Concatenate names from root to self within depth.
Args:
depth (int): maximum depth to go to.
Returns:
str: absolute name of the node (until given depth is reached). | def absolute_name(self, depth=0):
node, node_depth = self, self.depth
if depth < 1:
depth = node_depth
while node_depth > depth and node.package is not None:
node = node.package
node_depth -= 1
names = []
while node is not None:
... | 893,006 |
Returns the best **real** type for a **real** sum for a given type.
For instance:
INT32_t -> FLOAT64_t
Args:
cysparse_type: | def cysparse_type_to_real_sum_cysparse_type(cysparse_type):
r_type = None
if cysparse_type in ['INT32_t', 'UINT32_t', 'INT64_t', 'UINT64_t']:
r_type = 'FLOAT64_t'
elif cysparse_type in ['FLOAT32_t', 'FLOAT64_t']:
r_type = 'FLOAT64_t'
elif cysparse_type in ['FLOAT128_t']:
r... | 893,069 |
Returns the **real** type for the real or imaginary part of a **real** complex type.
For instance:
COMPLEX128_t -> FLOAT64_t
Args:
cysparse: | def cysparse_real_type_from_real_cysparse_complex_type(cysparse_type):
r_type = None
if cysparse_type in ['COMPLEX64_t']:
r_type = 'FLOAT32_t'
elif cysparse_type in ['COMPLEX128_t']:
r_type = 'FLOAT64_t'
elif cysparse_type in ['COMPLEX256_t']:
r_type = 'FLOAT128_t'
else... | 893,070 |
Main function.
This function is the command line entry point.
Args:
args (list of str): the arguments passed to the program.
Returns:
int: return code being 0 (OK), 1 (dsm empty) or 2 (error). | def main(args=None):
parser = get_parser()
args = parser.parse_args(args=args)
if not (args.matrix or args.dependencies or args.treemap or args.graph):
args.matrix = True
# split comma-separated args
packages = []
for arg in args.packages:
if ',' in arg:
for pa... | 893,126 |
Outputs the XML content (string) into a file.
If `output_loc` is supplied and it's a file (not directory), the output
will be saved there and the `filename` is ignored.
Args:
xml_str: string with XML document
output_loc: file or directory for saving the file
filename: file name tha... | def write_xml(xml_str, output_loc=None, filename=None):
if not xml_str:
raise Dump2PolarionException("No data to write.")
filename_fin = _get_filename(output_loc=output_loc, filename=filename)
with io.open(filename_fin, "w", encoding="utf-8") as xml_file:
xml_file.write(get_unicode_str... | 893,417 |
Outputs the XML content (from XML element) into a file.
If `output_loc` is supplied and it's a file (not directory), the output
will be saved there and the `filename` is ignored.
Args:
xml_root: root element ot the XML document
output_loc: file or directory for saving the file
file... | def write_xml_root(xml_root, output_loc=None, filename=None):
if xml_root is None:
raise Dump2PolarionException("No data to write.")
filename_fin = _get_filename(output_loc=output_loc, filename=filename)
et = etree.ElementTree(xml_root)
et.write(filename_fin, xml_declaration=True, pretty_p... | 893,418 |
Yield a list of files with their base directories, recursively or not.
Returns:
A list of (base_directory, filename)
Args:
directory: base directory to start the search.
pattern: fnmatch pattern for filenames.
complete_filename: return complete filename or not?
recursiv... | def find_files(directory, pattern, recursively=True):
for root, dirs, files in os.walk(directory):
for basename in files:
if fnmatch.fnmatch(basename, pattern):
yield root, basename
if not recursively:
break | 893,606 |
Find user with given username.
Args:
username Username of the user to search for
Raises:
ldap_tools.exceptions.NoUserFound: No users returned by LDAP
ldap_tools.exceptions.TooManyResults:
Multiple users returned by LDAP | def find(self, username):
filter = ['(uid={})'.format(username)]
results = self.client.search(filter)
if len(results) < 1:
raise ldap_tools.exceptions.NoUserFound(
'User ({}) not found'.format(username))
return # pragma: no cover
elif le... | 893,800 |
Constructor.
Args:
locations: Can be either a string with sub-strings joined by the separation character or a list of strings,
each giving a location.
separation_char: Separation character in the location string.
Raises:
TypeError: if argument is not... | def __init__(self, locations=None, separation_char=os.sep):
super(LocationDescriptor, self).__init__()
self._separation_char = separation_char
# type tests
if isinstance(locations, list):
self._locations_list = list(locations)
elif isinstance(locations, str... | 893,938 |
Return a given sub location, 0-based.
Args:
nbr:
Returns: | def sub_location(self, nbr):
assert nbr > -1, "Sub location number must be greater or equal to 0!"
assert nbr < self.nbr_of_sub_locations() - 1, "Sub location number must be lower than %d!" % self.nbr_of_sub_locations() - 1
return self._locations_list[nbr] | 893,939 |
Return the internal location list.
Args:
lower_bound:
upper_bound:
Returns: | def get_locations_list(self, lower_bound=0, upper_bound=None):
real_upper_bound = upper_bound
if upper_bound is None:
real_upper_bound = self.nbr_of_sub_locations()
try:
return self._locations_list[lower_bound:real_upper_bound]
except:
return... | 893,940 |
Create a **new** :class:`LocationDescriptor` object that is the sum of this one and another.
Args:
self: This :class:`LocationDescriptor` object.
other: Another :class:`LocationDescriptor` object.
Returns:
Sum of both :class:`LocationDescriptor` objects. | def __add__(self, other):
# sanity tests
assert isinstance(other, LocationDescriptor), "You can only add LocationDescriptor together."
assert self._separation_char == other._separation_char, \
"You can only add LocationDescriptor together if they share the same separator cha... | 893,941 |
**Extend** an existing :class:`LocationDescriptor` object by another.
Args:
self: This :class:`LocationDescriptor` object.
other: Another :class:`LocationDescriptor` object.
Returns:
The updated :class:`LocationDescriptor` object itself. | def __iadd__(self, other):
# sanity tests
assert isinstance(other, LocationDescriptor), "You can only add LocationDescriptor together."
assert self._separation_char == other._separation_char, \
"You can only add LocationDescriptor together if they share the same separator ch... | 893,942 |
Detect if another object is equal to this :class:`LocationDescriptor` object.
Args:
other: object to test. | def __eq__(self, other):
if not isinstance(other, LocationDescriptor):
return False
nbr_of_sub_locations = self.nbr_of_sub_locations()
if nbr_of_sub_locations != other.nbr_of_sub_locations():
return False
for i in range(nbr_of_sub_locations):
... | 893,943 |
String representation of :class:`LocationDescriptor` object.
Args:
other_separation_char: If needed, another separator character can be used.
Returns: | def to_string(self, other_separation_char=None):
separation_char = self._separation_char
if other_separation_char is not None:
separation_char = other_separation_char
return separation_char.join(self._locations_list) | 893,944 |
Serialize structured data into a stream in JSON, YAML, or LHA format.
If stream is None, return the produced string instead.
Parameters:
- fmt: should be 'json' (default), 'yaml', or 'lha'
- stream: if None, return string | def dump(d, fmt='json', stream=None):
if fmt == 'json':
return _dump_json(d, stream=stream)
elif fmt == 'yaml':
return yaml.dump(d, stream)
elif fmt == 'lha':
s = _dump_lha(d)
if stream is None:
return s
else:
return stream.write(s) | 893,974 |
Calculates the fraction of the correctly
classified samples over all.
Parameters:
-----------
y : vector, shape (n_samples,)
The target labels.
y_pred : vector, shape (n_samples,)
The predicted labels.
Returns:
--------
accuracy : float number, the fraction
of the ... | def accuracy_score(y, y_pred):
y, y_pred = convert_assert(y, y_pred)
return np.count_nonzero(y == y_pred) / y.size | 894,046 |
True-positives
Parameters:
-----------
y : vector, shape (n_samples,)
The target labels.
y_pred : vector, shape (n_samples,)
The predicted labels.
Returns:
--------
tp : integer, the number of true-positives | def true_positives(y, y_pred):
y, y_pred = convert_assert(y, y_pred)
assert_binary_problem(y)
return np.count_nonzero(y_pred[y == 1] == 1) | 894,047 |
False-positives
Parameters:
-----------
y : vector, shape (n_samples,)
The target labels.
y_pred : vector, shape (n_samples,)
The predicted labels.
Returns:
--------
fp : integer, the number of false-positives | def false_positives(y, y_pred):
y, y_pred = convert_assert(y, y_pred)
assert_binary_problem(y)
return np.count_nonzero(y_pred[y == 0] == 1) | 894,048 |
True-negatives
Parameters:
-----------
y : vector, shape (n_samples,)
The target labels.
y_pred : vector, shape (n_samples,)
The predicted labels.
Returns:
--------
tn : integer, the number of true-negatives | def true_negatives(y, y_pred):
y, y_pred = convert_assert(y, y_pred)
assert_binary_problem(y)
return np.count_nonzero(y_pred[y == 0] == 0) | 894,049 |
False-negatives
Parameters:
-----------
y : vector, shape (n_samples,)
The target labels.
y_pred : vector, shape (n_samples,)
The predicted labels.
Returns:
--------
fn : integer, the number of false-negatives | def false_negatives(y, y_pred):
y, y_pred = convert_assert(y, y_pred)
assert_binary_problem(y)
return np.count_nonzero(y_pred[y == 1] == 0) | 894,050 |
Precision score
precision = true_positives / (true_positives + false_positives)
Parameters:
-----------
y : vector, shape (n_samples,)
The target labels.
y_pred : vector, shape (n_samples,)
The predicted labels.
Returns:
--------
precision : float | def precision(y, y_pred):
tp = true_positives(y, y_pred)
fp = false_positives(y, y_pred)
return tp / (tp + fp) | 894,051 |
Recall score
recall = true_positives / (true_positives + false_negatives)
Parameters:
-----------
y : vector, shape (n_samples,)
The target labels.
y_pred : vector, shape (n_samples,)
The predicted labels.
Returns:
--------
recall : float | def recall(y, y_pred):
tp = true_positives(y, y_pred)
fn = false_negatives(y, y_pred)
return tp / (tp + fn) | 894,052 |
F1 score
f1_score = 2 * precision*recall / (precision + recall)
Parameters:
-----------
y : vector, shape (n_samples,)
The target labels.
y_pred : vector, shape (n_samples,)
The predicted labels.
Returns:
--------
f1_score : float | def f1_score(y, y_pred):
p = precision(y, y_pred)
r = recall(y, y_pred)
return 2*p*r / (p+r) | 894,053 |
Extract request timeout from e.g. ``Retry-After`` header.
Notes:
Per :rfc:`2616#section-14.37`, the ``Retry-After`` header can
be either an integer number of seconds or an HTTP date. This
function can handle either.
Arguments:
http_date (:py:class:`str`): The da... | def calculate_timeout(http_date):
try:
return int(http_date)
except ValueError:
date_after = parse(http_date)
utc_now = datetime.now(tz=timezone.utc)
return int((date_after - utc_now).total_seconds()) | 894,398 |
Node constructor
Args:
job:
parents:
children:
... | def __init__(self, job,
parents=None,
children=None,
pre_script=None,
pre_script_args=None,
post_script=None,
post_script_args=None,
variables=None, # VARS JobName macroname="string" [macroname="str... | 894,412 |
Calculates the mean samples per class
Parameters:
-----------
X : array-like, shape (m, n) - the samples
y : array-like, shape (m, ) - the class labels
Returns:
--------
mean_vectors : array-like, shape (k, )
Those are the mean samples from each k classes. | def calculate_mean_vectors(X, y):
return [np.mean(X[y == cl, :], axis=0) for cl in np.unique(y)] | 894,465 |
Calculates the Within-Class Scatter matrix
Parameters:
-----------
X : array-like, shape (m, n) - the samples
y : array-like, shape (m, ) - the class labels
Returns:
--------
within_class_scatter_matrix : array-like, shape (n, n) | def calculate_within_class_scatter_matrix(X, y):
mean_vectors = calculate_mean_vectors(X, y)
n_features = X.shape[1]
Sw = np.zeros((n_features, n_features))
for cl, m in zip(np.unique(y), mean_vectors):
Si = np.zeros((n_features, n_features))
m = m.reshape(n_features, 1)
... | 894,466 |
Calculates the Between-Class Scatter matrix
Parameters:
-----------
X : array-like, shape (m, n) - the samples
y : array-like, shape (m, ) - the class labels
Returns:
--------
between_class_scatter_matrix : array-like, shape (n, n) | def calculate_between_class_scatter_matrix(X, y):
mean_vectors = calculate_mean_vectors(X, y)
n_features = X.shape[1]
Sb = np.zeros((n_features, n_features))
m = np.mean(X, axis=0).reshape(n_features, 1)
for cl, m_i in zip(np.unique(y), mean_vectors):
v = m_i.reshape(n_features, 1) - ... | 894,467 |
Calculates the Variance-Covariance matrix
Parameters:
-----------
X : array-like, shape (m, n) - the data
Returns:
--------
variance_covariance_matrix : array-like, shape(n, n) | def calculate_covariance_matrix(X):
n_features = X.shape[1]
S = np.zeros((n_features, n_features))
m = np.mean(X, axis=0).reshape(n_features, 1)
for x in X:
v = x.reshape(n_features, 1) - m
S += v @ v.T
return 1/(X.shape[0]-1) * S | 894,468 |
Returns the specified parameters for the current preprocessor.
Parameters:
-----------
keys : variable sized list, containing the names of the requested parameters
Returns:
--------
values : list or dictionary, if any `keys` are specified
those named parameters'... | def get_params(self, *keys):
if len(keys) == 0:
return vars(self)
else:
return [vars(self)[k] for k in keys] | 894,494 |
Sets new values to the specified parameters.
Parameters:
-----------
params : variable sized dictionary, n key-word arguments
Example:
```
scaler.set_params(std=0.30)
```
Returns:
--------
void : void, returns nothing | def set_params(self, **params):
for k, v in params.items():
vars(self)[k] = v | 894,495 |
This function can be used to look up the EPSG spatial reference system using the web service available at:
http://prj2epsg.org
Args:
wellKnownText (str): The Well Known Text definition of the spatial reference system.
Returns:
int: Spatial Reference ID | def lookupSpatialReferenceID(wellKnownText):
payload = {'mode': 'wkt',
'terms': wellKnownText}
try:
r = requests.get('http://prj2epsg.org/search.json', params=payload)
except requests.exceptions.ConnectionError:
print("SRID Lookup Error: Could not automatically determine... | 894,596 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.