def get_individual_positions(individuals):

    ind_pos = {}
    if individuals:
        for i, ind in enumerate(individuals):
            ind_pos[ind] = i
    return ind_pos

Return a dictionary with individual positions

Args:
individuals(list): A list with vcf individuals in correct order

Returns:
ind_pos(dict): Map from ind_id -> index position


def alias_tool(self, context_name, tool_name, tool_alias):
    data = self._context(context_name)
    aliases = data['tool_aliases']
    if (tool_name in aliases):
        raise SuiteError(('Tool %r in context %r is already aliased to %r' % (tool_name, context_name, aliases[tool_name])))
    self._validate_tool(context_name, tool_name)
    aliases[tool_name] = tool_alias
    self._flush_tools()

Register an alias for a specific tool.

Note that a tool alias takes precedence over a context prefix/suffix.

Args:
context_name (str): Context containing the tool.
tool_name (str): Name of tool to alias.
tool_alias (str): Alias to give the tool.


def prepend(self, line, font_attr_segs=None):
    other = RichTextLines(line)
    if font_attr_segs:
        other.font_attr_segs[0] = font_attr_segs
    self._extend_before(other)

Prepend (i.e., add to the front) a single line of text.

Args:
line: (str) The text to be added to the front.
font_attr_segs: (list of tuples) Font attribute segments of the appended
line.


def add_answer_for_student(student_item, vote, rationale):
    answers = get_answers_for_student(student_item)
    answers.add_answer(vote, rationale)
    sub_api.create_submission(student_item, {ANSWER_LIST_KEY: answers.get_answers_as_list()})

Add an answer for a student to the backend

Args:
student_item (dict): The location of the problem this submission is
associated with, as defined by a course, student, and item.
vote (int): the option that student voted for
rationale (str): the reason why the student vote for the option


def sysctl(command):

    out = subprocess.check_output(command)
    result = out.split(b" ")[1]
    try:
        return int(result)
    except ValueError:
        return result

Run a sysctl command and parse the output.

Args:
command: A sysctl command with an argument, for example,
["sysctl", "hw.memsize"].

Returns:
The parsed output.


def get_next(self):
    raise NotImplementedError('Iterator.get_next()')

Returns the next element.

>>> dataset = tf.data.Dataset.from_tensors(42)
>>> iterator = iter(dataset)
>>> print(iterator.get_next())
tf.Tensor(42, shape=(), dtype=int32)

Returns:
A (nested) structure of values matching `tf.data.Iterator.element_spec`.

Raises:
`tf.errors.OutOfRangeError`: If the end of the iterator has been reached.


async def get_json(self, url, json_callback=None, **kwargs):

        if not json_callback:
            json_callback = json.loads
        response = await self.request(method='get', url=url, **kwargs)
        return json_callback(response)

Get a URL and return its JSON response.

Args:
url (str): URL to be requested.
json_callback (func): Custom JSON loader function. Defaults
to :meth:`json.loads`.
kwargs (dict): Additional arguments to pass through to the
request.
Returns:
response body returned by :func:`json_callback` function.


def _controller_buffer(self, port):
    address = _LIB.Controller(self._env, port)
    buffer_ = ctypes.cast(address, ctypes.POINTER(CONTROLLER_VECTOR)).contents
    return np.frombuffer(buffer_, dtype='uint8')

Find the pointer to a controller and setup a NumPy buffer.

Args:
port: the port of the controller to setup

Returns:
a NumPy buffer with the controller's binary data


def _flatten_dict(original_dict):

  flat_dict = {}
  for key, value in original_dict.items():
    if isinstance(value, dict):
      for name, tensor in value.items():
        if isinstance(tensor, dict):
          raise ValueError("flatten_dict only handles 2 levels of nesting.")
        flat_key = "__" + key + "_" + name
        flat_dict[flat_key] = tensor
    else:
      flat_dict[key] = value

  return flat_dict

Flatten dict of dicts into a single dict with appropriate prefixes.

Handles only 2 levels of nesting in the original dict.

Args:
original_dict: Dict which may contain one or more dicts.
Returns:
flat_dict: Dict without any nesting. Any dicts in the original dict have
their keys as prefixes in the new dict.
Raises:
ValueError if the original dict has more than two levels of nesting.


def stats_per_utterance(self):
    all_stats = {}
    for utterance in self.utterances.values():
        data = utterance.read_samples()
        all_stats[utterance.idx] = stats.DataStats(float(np.mean(data)), float(np.var(data)), np.min(data), np.max(data), data.size)
    return all_stats

Return statistics calculated for all samples of each utterance in the corpus.

Returns:
dict: A dictionary containing a DataStats object for each utt.


def __init__(self, runner_results):

    super(DataflowJob, self).__init__(runner_results._job.name)
    self._runner_results = runner_results

Initializes an instance of a DataFlow Job.

Args:
runner_results: a DataflowPipelineResult returned from Pipeline.run().


def _pull_out_perm_lhs(lhs, rest, out_port, in_port):

    out_inv, lhs_red = lhs._factor_lhs(out_port)
    return lhs_red << Feedback.create(SeriesProduct.create(*rest),
                                      out_port=out_inv, in_port=in_port)

Pull out a permutation from the Feedback of a SeriesProduct with itself.

Args:
lhs (CPermutation): The permutation circuit
rest (tuple): The other SeriesProduct operands
out_port (int): The feedback output port index
in_port (int): The feedback input port index

Returns:
Circuit: The simplified circuit


def __init__(self, tpu_hardware_feature_proto):
    self.tpu_hardware_feature_proto = tpu_hardware_feature_proto

Store TPU hardware feature info.

Args:
tpu_hardware_feature_proto: protobuf which describe the tpu hardware
feature.


def unsafe_peek(init):

    def peek(store, container, _stack=None):
        return init(*[ store.peek(attr, container, _stack=_stack) for attr in container ])
    return peek

Deserialize all the attributes available in the container and pass them in the same order
as they come in the container.

This is a factory function; returns the actual `peek` routine.

Arguments:

init: type constructor.

Returns:

callable: deserializer (`peek` routine).


def cross_entropy_loss(weights: Array, x: Array, y: Array) -> Array:
    pred = 1 / (1 + jnp.exp(-x.dot(weights)))
    return -jnp.mean(y * jnp.log(pred) + (1 - y) * jnp.log(1 - pred))

Calcurates a cross entropy loss with a prediction by a sigmoid function.

Args:
weights: A weight vector.
x: An input array.
y: A target output array.

Returns:
A cross entropy loss.


def _load_yaml_credentials(filename=None, yaml_key=None):
    try:
        with open(os.path.expanduser(filename)) as f:
            search_creds = yaml.safe_load(f)[yaml_key]
    except FileNotFoundError:
        logger.error('cannot read file {}'.format(filename))
        search_creds = {}
    except KeyError:
        logger.error('{} is missing the provided key: {}'.format(filename, yaml_key))
        search_creds = {}
    return search_creds

Loads and parses credentials in a YAML file. Catches common exceptions
and returns an empty dict on error, which will be handled downstream.

Returns:
dict: parsed credentials or {}


def dbmin05years(self, value=None):
    if (value is not None):
        try:
            value = float(value)
        except ValueError:
            raise ValueError('value {} need to be of type float for field `dbmin05years`'.format(value))
    self._dbmin05years = value

Corresponds to IDD Field `dbmin05years`
5-year return period values for minimum extreme dry-bulb temperature

Args:
value (float): value for IDD Field `dbmin05years`
Unit: C
if `value` is None it will not be checked against the
specification and is assumed to be a missing value

Raises:
ValueError: if `value` is not a valid value


def trace(self, predicate):
    self._handler = predicate
    if ((self.threading_support is None) or self.threading_support):
        self._threading_previous = getattr(threading, '_trace_hook', None)
        threading.settrace(self)
    self._previous = sys.gettrace()
    sys.settrace(self)
    return self

Starts tracing with the given callable.

Args:
predicate (callable that accepts a single :obj:`hunter.Event` argument):
Return:
self


def _parse_package(cls, package_string):

        pkg, arch = rsplit(package_string, cls._arch_sep(package_string))
        if arch not in KNOWN_ARCHITECTURES:
            pkg, arch = (package_string, None)
        pkg, release = rsplit(pkg, '-')
        name, version = rsplit(pkg, '-')
        epoch, version = version.split(':', 1) if ":" in version else ['0', version]

        if name.startswith('oracleasm') and name.endswith('.el5'):
            name, version2 = name.split('-', 1)
            version = version2 + '-' + version
        return {
            'name': name,
            'version': version,
            'release': release,
            'arch': arch,
            'epoch': epoch
        }

Helper method for parsing package string.

Args:
package_string (str): dash separated package string such as 'bash-4.2.39-3.el7'

Returns:
dict: dictionary containing 'name', 'version', 'release' and 'arch' keys


def _old_init(cls, fields, shape, nrows, row_partitions, internal=False):
    assert isinstance(fields, dict), fields
    assert isinstance(shape, tensor_shape.TensorShape), shape
    assert nrows is None or isinstance(nrows, tensor.Tensor), nrows
    assert row_partitions is None or isinstance(row_partitions, tuple), row_partitions
    return StructuredTensor(fields=fields, ragged_shape=_dynamic_ragged_shape_init(fields, shape, nrows, row_partitions))

Private constructor -- use factory methods to create StructuredTensors.

This constructor builds a `StructuredTensor` from the given attributes,
performing minimal validation.

Args:
fields: A dictionary mapping from string to `Tensor`, `RaggedTensor`, or
`StructuredTensor`.  (This dict is not copied, so the caller must ensure
that it does not get mutated via leaked references.)
shape: `tf.TensorShape` with statically known rank.
nrows: scalar integer `tf.Tensor`, or `None` if `shape.rank==0`.
row_partitions: tuple of `RowPartition`s, with length `shape.rank-1`.
internal: ignored argument.

Returns:
a StructuredTensor.


def mme_match(case_obj, match_type, mme_base_url, mme_token, nodes=None, mme_accepts=None):

    query_patients = []
    server_responses = []
    url = None

    query_patients = case_obj['mme_submission']['patients']
    if match_type=='internal':
        url = ''.join([mme_base_url,'/match'])
        for patient in query_patients:
            json_resp = matchmaker_request(url=url, token=mme_token, method='POST',
                content_type=mme_accepts, accept=mme_accepts, data={'patient':patient})
            resp_obj = {
                'server' : 'Local MatchMaker node',
                'patient_id' : patient['id'],
                'results' : json_resp.get('results'),
                'status_code' : json_resp.get('status_code'),
                'message' : json_resp.get('message')
            }
            server_responses.append(resp_obj)
    else:

        query_patients = [ patient['id'] for patient in query_patients]
        node_ids = [ node['id'] for node in nodes ]
        if match_type in node_ids:
            node_ids = [match_type]

        for patient in query_patients:

            for node in node_ids:
                url = ''.join([mme_base_url,'/match/external/', patient, '?node=', node])
                json_resp = matchmaker_request(url=url, token=mme_token, method='POST')
                resp_obj = {
                    'server' : node,
                    'patient_id' : patient,
                    'results' : json_resp.get('results'),
                    'status_code' : json_resp.get('status_code'),
                    'message' : json_resp.get('message')
                }
                server_responses.append(resp_obj)
    return server_responses

Initiate a MatchMaker match against either other Scout patients or external nodes

Args:
case_obj(dict): a scout case object already submitted to MME
match_type(str): 'internal' or 'external'
mme_base_url(str): base url of the MME server
mme_token(str): auth token of the MME server
mme_accepts(str): request content accepted by MME server (only for internal matches)

Returns:
matches(list): a list of eventual matches


def extract(self, tokens: List[Token]) -> List[Extraction]:

        results = list()

        if len(tokens) > 0:
            if self._case_sensitive:
                new_tokens = [x.orth_ if isinstance(x, Token) else x for x in tokens]
            else:
                new_tokens = [x.lower_ if isinstance(x, Token) else x.lower() for x in tokens]
        else:
            return results

        try:
            ngrams_iter = self._generate_ngrams_with_context(new_tokens)
            results.extend(map(lambda term: self._wrap_value_with_context(tokens, term[1], term[2]),
                               filter(lambda term: isinstance(term[0], str),
                                      map(lambda term: (self._glossary.get(term[0]), term[1], term[2]),
                                          map(lambda term: (
                                              self._combine_ngrams(term[0], self._joiner), term[1], term[2]),
                                              ngrams_iter)))))
        except Exception as e:
            raise ExtractorError('GlossaryExtractor: Failed to extract with ' + self.name + '. Catch ' + str(e) + '. ')
        return results

Extracts information from a string(TEXT) with the GlossaryExtractor instance

Args:
token (List[Token]): list of spaCy token to be processed.

Returns:
List[Extraction]: the list of extraction or the empty list if there are no matches.


def backup(self, backup_name, folder_key=None, folder_name=None):

        folder = self._find_or_create_folder(folder_key, folder_name)
        drive_service = self.drive_service
        try:
            source_rsrc = drive_service.files().get(fileId=self.document_key).execute()
        except Exception, e:
            logger.exception("Google API error. %s", e)
            raise e

        backup = self._create_new_or_copy(source_doc=source_rsrc,
                                        target_name=backup_name,
                                        folder=folder,
                                        sheet_description="backup")

        backup_key = backup['id']
        return backup_key

Copies the google spreadsheet to the backup_name and folder specified.

Args:
backup_name (str): The name of the backup document to create.

folder_key (Optional) (str): The key of a folder that the new copy will
be moved to.

folder_name (Optional) (str): Like folder_key, references the folder to move a
backup to. If the folder can't be found, sheetsync will create it.


def __call__(self,
            state: Sequence[tf.Tensor],
            timestep: tf.Tensor) -> Sequence[tf.Tensor]:

        action, _, _ = self._sample_actions(state)
        return action

Returns sampled action fluents for the current `state` and `timestep`.

Args:
state (Sequence[tf.Tensor]): The current state fluents.
timestep (tf.Tensor): The current timestep.

Returns:
Sequence[tf.Tensor]: A tuple of action fluents.


def connect(self, **kwargs):

        self.app = self._app.connect(**kwargs)
        try:
            self._top_window = self.app.top_window().wrapper_object()
            self.set_foreground()
        except RuntimeError:
            self._top_window = None

Connect to window and set it foreground

Args:
**kwargs: optional arguments

Returns:
None


def _find_methods(cls, *names, **kwds):
    reverse = kwds.pop('reverse', False)
    assert (not kwds), repr(kwds)
    cache = cls.__dict__.get('_find_methods_cache')
    if cache:
        hit = cache.get(names)
        if (hit is not None):
            return hit
    else:
        cls._find_methods_cache = cache = {}
    methods = []
    for c in cls.__mro__:
        for name in names:
            method = c.__dict__.get(name)
            if (method is not None):
                methods.append(method)
    if reverse:
        methods.reverse()
    cache[names] = methods
    return methods

Compute a list of composable methods.

Because this is a common operation and the class hierarchy is
static, the outcome is cached (assuming that for a particular list
of names the reversed flag is either always on, or always off).

Args:
*names: One or more method names.
reverse: Optional flag, default False; if True, the list is
reversed.

Returns:
A list of callable class method objects.


def getAsGrassAsciiGrid(self, session):
    if (type(self.raster) != type(None)):
        converter = RasterConverter(sqlAlchemyEngineOrSession=session)
        return converter.getAsGrassAsciiRaster(tableName=self.tableName, rasterIdFieldName='id', rasterId=self.id, rasterFieldName=self.rasterColumnName)

Retrieve the raster in the GRASS ASCII Grid format.

Args:
session (:mod:`sqlalchemy.orm.session.Session`): SQLAlchemy session object bound to PostGIS enabled database.

Returns:
str: GRASS ASCII string.


def Match(self, registry_key):

    key_path = registry_key.path.upper()
    if self._key_path_prefix and self._key_path_suffix:
      if (key_path.startswith(self._key_path_prefix) and
          key_path.endswith(self._key_path_suffix)):

        key_path_segment = key_path[
            len(self._key_path_prefix):-len(self._key_path_suffix)]
        if key_path_segment.startswith('ControlSet'.upper()):
          try:
            control_set = int(key_path_segment[10:], 10)
          except ValueError:
            control_set = None

          return control_set is not None

    return key_path in (self._key_path_upper, self._wow64_key_path_upper)

Determines if a Windows Registry key matches the filter.

Args:
registry_key (dfwinreg.WinRegistryKey): Windows Registry key.

Returns:
bool: True if the keys match.


def _add_weight(self, name, initial_value, dtype=None):
    variable = variable_v1.VariableV1(initial_value=initial_value, name=name, dtype=dtype, trainable=False, use_resource=True, synchronization=variables.VariableSynchronization.AUTO, aggregation=variables.VariableAggregation.NONE)
    if context.executing_eagerly():
        graph_key = None
    else:
        graph = ops.get_default_graph()
        graph_key = graph._graph_key
    key = (name, graph_key)
    self._weights[key] = variable
    self._handle_deferred_dependencies(name=name, trackable=variable)
    backend.track_variable(variable)
    return variable

Adds a weight to this loss scale.

Args:
name: Variable name.
initial_value: The variable's initial value.
dtype: The type of the variable.

Returns:
A variable.

Raises:
RuntimeError: If a weight with `name` has already been added.


def find(self, collection, query):
    obj = getattr(self.db, collection)
    result = obj.find(query)
    return result

Search a collection for the query provided. Just a raw interface to
mongo to do any query you want.

Args:
collection: The db collection. See main class documentation.
query: A mongo find query.
Returns:
pymongo Cursor object with the results.


def get_help(sakefile):

    full_string = "You can 'sake' one of the following...\n\n"
    errmes = "target '{}' is not allowed to not have help message\n"
    outerlines = []
    for target in sakefile:
        if target == "all":

            continue
        middle_lines = []
        if "formula" not in sakefile[target]:

            innerstr = "{}:\n  - {}\n\n".format(escp(target),
                                                sakefile[target]["help"])
            inner = []
            for atom_target in sakefile[target]:
                if atom_target == "help":
                    continue
                inner.append("    {}:\n      -  {}\n\n".format(escp(atom_target),
                                                               sakefile[target][atom_target]["help"]))
            if inner:
                innerstr += '\n'.join(sorted(inner))
            middle_lines.append(innerstr)
        else:
            middle_lines.append("{}:\n  - {}\n\n".format(escp(target),
                                                         sakefile[target]["help"]))
        if middle_lines:
            outerlines.append('\n'.join(sorted(middle_lines)))

    if outerlines:
        full_string += '\n'.join(sorted(outerlines))
    what_clean_does = "remove all targets' outputs and start from scratch"
    full_string += "\nclean:\n  -  {}\n\n".format(what_clean_does)
    what_visual_does = "output visual representation of project's dependencies"
    full_string += "visual:\n  -  {}\n".format(what_visual_does)
    full_string = re.sub("\n{3,}", "\n\n", full_string)
    return full_string

Returns the prettily formatted help strings (for printing)

Args:
A dictionary that is the parsed Sakefile (from sake.py)

NOTE:
the list sorting in this function is required for this
function to be deterministic


def asdim(dimension):

    if isinstance(dimension, Dimension):
        return dimension
    elif isinstance(dimension, (tuple, dict, basestring)):
        return Dimension(dimension)
    else:
        raise ValueError('%s type could not be interpreted as Dimension. '
                         'Dimensions must be declared as a string, tuple, '
                         'dictionary or Dimension type.')

Convert the input to a Dimension.

Args:
dimension: tuple, dict or string type to convert to Dimension

Returns:
A Dimension object constructed from the dimension spec. No
copy is performed if the input is already a Dimension.


def _query(queue_name=None, build_id=None, release_id=None, run_id=None,
           count=None):

    assert queue_name or build_id or release_id or run_id

    q = WorkQueue.query
    if queue_name:
        q = q.filter_by(queue_name=queue_name)
    if build_id:
        q = q.filter_by(build_id=build_id)
    if release_id:
        q = q.filter_by(release_id=release_id)
    if run_id:
        q = q.filter_by(run_id=run_id)

    q = q.order_by(WorkQueue.created.desc())

    if count is not None:
        q = q.limit(count)

    return q.all()

Queries for work items based on their criteria.

Args:
queue_name: Optional queue name to restrict to.
build_id: Optional build ID to restrict to.
release_id: Optional release ID to restrict to.
run_id: Optional run ID to restrict to.
count: How many tasks to fetch. Defaults to None, which means all
tasks are fetch that match the query.

Returns:
List of WorkQueue items.


def sanitize_git_path(self, uri, ref=None):

        if uri.endswith('.git'):
            dir_name = uri[:-4]
        else:
            dir_name = uri
        dir_name = self.sanitize_uri_path(dir_name)
        if ref is not None:
            dir_name += "-%s" % ref
        return dir_name

Take a git URI and ref and converts it to a directory safe path.

Args:
uri (string): git URI
(e.g. git@github.com:foo/bar.git)
ref (string): optional git ref to be appended to the path

Returns:
str: Directory name for the supplied uri


def get_fba_flux(self, objective):
    flux_result = self.solve_fba(objective)
    fba_fluxes = {}
    for key in self._model.reactions:
        fba_fluxes[key] = flux_result.get_value(self._v_wt[key])
    return fba_fluxes

Return a dictionary of all the fluxes solved by FBA.

Dictionary of fluxes is used in :meth:`.lin_moma` and :meth:`.moma`
to minimize changes in the flux distributions following model
perturbation.

Args:
objective: The objective reaction that is maximized.

Returns:
Dictionary of fluxes for each reaction in the model.


def trailing_stop_loss_replace(self, accountID, orderID, **kwargs):

        return self.replace(
            accountID,
            orderID,
            order=TrailingStopLossOrderRequest(**kwargs)
        )

Shortcut to replace a pending Trailing Stop Loss Order in an Account

Args:
accountID : The ID of the Account
orderID : The ID of the Take Profit Order to replace
kwargs : The arguments to create a TrailingStopLossOrderRequest

Returns:
v20.response.Response containing the results from submitting
the request


def __init__(self, host_url, username, password):

    self.host_url = host_url
    self.api_base_url = '{0:s}/api/v1'.format(self.host_url)
    self.username = username
    self.session = self._create_session(username, password)

Initialize the Timesketch API client object.

Args:
host_url (str): URL of Timesketch instance
username (str): Timesketch username
password (str): Timesketch password


def download_software_version(version=None, synch=False):
    if (not version):
        raise CommandExecutionError('Version option must not be none.')
    if (not isinstance(synch, bool)):
        raise CommandExecutionError('Synch option must be boolean..')
    if (synch is True):
        query = {'type': 'op', 'cmd': '<request><system><software><download><version>{0}</version></download></software></system></request>'.format(version)}
    else:
        query = {'type': 'op', 'cmd': '<request><system><software><download><sync-to-peer>yes</sync-to-peer><version>{0}</version></download></software></system></request>'.format(version)}
    return _get_job_results(query)

Download software packages by version number.

Args:
version(str): The version of the PANOS file to download.

synch (bool): If true then the file will synch to the peer unit.

CLI Example:

.. code-block:: bash

salt '*' panos.download_software_version 8.0.0
salt '*' panos.download_software_version 8.0.0 True


def _covert_to_hashable(data):
    r
    if isinstance(data, six.binary_type):
        hashable = data
        prefix = b'TXT'
    elif util_type.HAVE_NUMPY and isinstance(data, np.ndarray):
        if data.dtype.kind == 'O':
            msg = '[ut] hashing ndarrays with dtype=object is unstable'
            warnings.warn(msg, RuntimeWarning)
            hashable = data.dumps()
        else:
            hashable = data.tobytes()
        prefix = b'NDARR'
    elif isinstance(data, six.text_type):

        hashable = data.encode('utf-8')
        prefix = b'TXT'
    elif isinstance(data, uuid.UUID):
        hashable = data.bytes
        prefix = b'UUID'
    elif isinstance(data, int):

        hashable = _int_to_bytes(data)

        prefix = b'INT'

    elif util_type.HAVE_NUMPY and isinstance(data, np.int64):
        return _covert_to_hashable(int(data))
    elif util_type.HAVE_NUMPY and isinstance(data, np.float64):
        a, b = float(data).as_integer_ratio()
        hashable = (a.to_bytes(8, byteorder='big') +
                    b.to_bytes(8, byteorder='big'))
        prefix = b'FLOAT'
    else:
        raise TypeError('unknown hashable type=%r' % (type(data)))

    prefix = b''
    return prefix, hashable

r"""
Args:
data (?):

Returns:
?:

CommandLine:
python -m utool.util_hash _covert_to_hashable

Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_hash import *  # NOQA
>>> from utool.util_hash import _covert_to_hashable  # NOQA
>>> import utool as ut
>>> data = np.array([1], dtype=np.int64)
>>> result = _covert_to_hashable(data)
>>> print(result)


def get_users_by_email(cls, emails):
    users = User.objects.filter(email__in=emails)
    present_emails = users.values_list('email', flat=True)
    missing_emails = list((set(emails) - set(present_emails)))
    return (users, missing_emails)

Accept a list of emails, and separate them into users that exist on OpenEdX and users who don't.

Args:
emails: An iterable of email addresses to split between existing and nonexisting

Returns:
users: Queryset of users who exist in the OpenEdX platform and who were in the list of email addresses
missing_emails: List of unique emails which were in the original list, but do not yet exist as users


def sk_log_loss(y_true: Union[(List[List[float]], List[List[int]], np.ndarray)], y_predicted: Union[(List[List[float]], List[List[int]], np.ndarray)]) -> float:
    return log_loss(y_true, y_predicted)

Calculates log loss.

Args:
y_true: list or array of true values
y_predicted: list or array of predicted values

Returns:
Log loss


def _create_pseudo_names(tensors, prefix):

    def one_index(ele):
        if isinstance(ele, int):
            return ele + 1
        return ele
    flat_paths = list(nest.yield_flat_paths(tensors))
    flat_paths = nest.map_structure(one_index, flat_paths)
    names = []
    for path in flat_paths:
        if not path:
            name = prefix + '1'
        else:
            name = '_'.join((str(p) for p in path))
            if isinstance(path[0], int):
                name = prefix + name
        names.append(name)
    return names

Creates pseudo {input | output} names for subclassed Models.

Warning: this function should only be used to define default
names for `Metrics` and `SavedModel`. No other use cases should
rely on a `Model`'s input or output names.

Example with dict:

`{'a': [x1, x2], 'b': x3}` becomes:
`['a_1', 'a_2', 'b']`

Example with list:

`[x, y]` becomes:
`['output_1', 'output_2']`

Args:
tensors: `Model`'s outputs or inputs.
prefix: 'output_' for outputs, 'input_' for inputs.

Returns:
Flattened list of pseudo names.


def variants_export_header(case_obj):
    header = []
    header = (header + EXPORT_HEADER)
    for individual in case_obj['individuals']:
        display_name = str(individual['display_name'])
        header.append(('AD_reference_' + display_name))
        header.append(('AD_alternate_' + display_name))
        header.append(('GT_quality_' + display_name))
    return header

Returns a header for the CSV file with the filtered variants to be exported.

Args:
case_obj(scout.models.Case)

Returns:
header: includes the fields defined in scout.constants.variants_export EXPORT_HEADER
+ AD_reference, AD_alternate, GT_quality for each sample analysed for a case


def group_entities(self, entities: List[dict]) -> List[dict]:
    entity_groups = []
    entity_group_disagg = []
    for entity in entities:
        if not entity_group_disagg:
            entity_group_disagg.append(entity)
            continue
        bi, tag = self.get_tag(entity['entity'])
        last_bi, last_tag = self.get_tag(entity_group_disagg[-1]['entity'])
        if tag == last_tag and bi != 'B':
            entity_group_disagg.append(entity)
        else:
            entity_groups.append(self.group_sub_entities(entity_group_disagg))
            entity_group_disagg = [entity]
    if entity_group_disagg:
        entity_groups.append(self.group_sub_entities(entity_group_disagg))
    return entity_groups

Find and group together the adjacent tokens with the same entity predicted.

Args:
entities (`dict`): The entities predicted by the pipeline.


def clear_redis(self, variable, clear_type):
    if (variable is None):
        return
    if (variable in self._clear_redis_tracker):
        return
    if (not re.match(self._vars_match, variable)):
        return
    self.log.info('[{}] Deleting redis variable: {}.'.format(clear_type, variable))
    print('Clearing Variables: {}{}{}'.format(c.Style.BRIGHT, c.Fore.MAGENTA, variable))
    self.tcex.playbook.delete(variable)
    self._clear_redis_tracker.append(variable)

Delete Redis data for provided variable.

Args:
variable (str): The Redis variable to delete.
clear_type (str): The type of clear action.


def _bfd_multiplier(self, **kwargs):

        int_type = kwargs['int_type']
        method_name = 'interface_%s_bfd_interval_multiplier' % int_type
        bfd_multiplier = getattr(self._interface, method_name)
        config = bfd_multiplier(**kwargs)
        if kwargs['delete']:
            tag = 'multiplier'
            config.find('.
        return config

Return the BFD multiplier XML.

You should not use this method.
You probably want `BGP.bfd`.

Args:
min_tx (str): BFD transmit interval in milliseconds (300, 500, etc)
delete (bool): Remove the configuration if ``True``.

Returns:
XML to be passed to the switch.

Raises:
None


def get_stream_action_type(stream_arn):

    stream_type_map = {
        "kinesis": awacs.kinesis.Action,
        "dynamodb": awacs.dynamodb.Action,
    }

    stream_type = stream_arn.split(":")[2]
    try:
        return stream_type_map[stream_type]
    except KeyError:
        raise ValueError(
            "Invalid stream type '%s' in arn '%s'" % (stream_type, stream_arn)
        )

Returns the awacs Action for a stream type given an arn

Args:
stream_arn (str): The Arn of the stream.

Returns:
:class:`awacs.aws.Action`: The appropriate stream type awacs Action
class

Raises:
ValueError: If the stream type doesn't match kinesis or dynamodb.


def status(self, workflow_id):

        self.logger.debug('Get status of workflow: ' + workflow_id)
        url = '%(wf_url)s/%(wf_id)s' % {
            'wf_url': self.workflows_url, 'wf_id': workflow_id
        }
        r = self.gbdx_connection.get(url)
        r.raise_for_status()
        return r.json()['state']

Checks workflow status.

Args:
workflow_id (str): Workflow id.

Returns:
Workflow status (str).


def is_placeholder(x):
    try:
        if ops.executing_eagerly_outside_functions():
            return hasattr(x, '_is_backend_placeholder')
        from tensorflow.python.keras.utils import tf_utils
        if tf_utils.is_extension_type(x):
            flat_components = nest.flatten(x, expand_composites=True)
            return py_any((is_placeholder(c) for c in flat_components))
        else:
            return x.op.type == 'Placeholder'
    except AttributeError:
        return False

Returns whether `x` is a placeholder.

Args:
x: A candidate placeholder.

Returns:
Boolean.


def isloaded(self, name):

        if name is None:
            return True

        if isinstance(name, str):
            return (name in [x.__module__ for x in self])

        if isinstance(name, Iterable):
            return set(name).issubset([x.__module__ for x in self])

        return False

Checks if given hook module has been loaded

Args:
name (str): The name of the module to check

Returns:
bool.  The return code::

True -- Loaded
False -- Not Loaded


def get_key(self, key, request_only=False):

        values = {}
        requested_names = [x.name for x in self._package_requests
                           if not x.conflict]

        for pkg in self.resolved_packages:
            if (not request_only) or (pkg.name in requested_names):
                value = getattr(pkg, key)
                if value is not None:
                    values[pkg.name] = (pkg, value)

        return values

Get a data key value for each resolved package.

Args:
key (str): String key of property, eg 'tools'.
request_only (bool): If True, only return the key from resolved
packages that were also present in the request.

Returns:
Dict of {pkg-name: (variant, value)}.


def Get(self, key):
    if (key not in self._hash):
        raise KeyError(key)
    node = self._hash[key]
    self._age.Unlink(node)
    self._age.AppendNode(node)
    return node.data

Fetch the object from cache.

Objects may be flushed from cache at any time. Callers must always
handle the possibility of KeyError raised here.

Args:
key: The key used to access the object.

Returns:
Cached object.

Raises:
KeyError: If the object is not present in the cache.


def require(self, entity_type, attribute_name=None):

        if not attribute_name:
            attribute_name = entity_type
        self.requires += [(entity_type, attribute_name)]
        return self

The intent parser should require an entity of the provided type.

Args:
entity_type(str): an entity type
attribute_name(str): the name of the attribute on the parsed intent. Defaults to match entity_type.

Returns:
self: to continue modifications.


def unique_bitstrings_with_counts(bitstrings, out_idx=tf.dtypes.int32):
    y, idx, count = tf.raw_ops.UniqueWithCountsV2(x=bitstrings, axis=[0], out_idx=out_idx)
    return (y, idx, count)

Extract the unique bitstrings in the given bitstring tensor.

Args:
bitstrings: 2-D `tf.Tensor`, interpreted as a list of bitstrings.
out_idx: An optional `tf.DType` from: `tf.int32`, `tf.int64`. Defaults to
`tf.int32`.  Specifies the type of `count` output.

Returns:
y: 2-D `tf.Tensor` of same dtype as `bitstrings`, containing the unique
0-axis entries of `bitstrings`.
idx: The index of each value of the input in the unique output `y`.
count: 1-D `tf.Tensor` of dtype `out_idx` such that `count[i]` is the
number of occurences of `y[i]` in `bitstrings`.


def _add_namespace(marc_xml):
    dom = marc_xml
    if isinstance(dom, basestring):
        dom = dhtmlparser.parseString(marc_xml)
    root = dom.find('root')
    if root:
        root[0].params = {}
    for record in dom.find('record'):
        record.params = {}
    collections = dom.find('collection')
    if (not collections):
        record = dom.find('record')[0]
        return XML_TEMPLATE.replace('$CONTENT', str(record))
    for col in collections:
        col.params['xmlns'] = 'http:
        col.params['xmlns:xsi'] = 'http:
        col.params['xsi:schemaLocation'] = ('http:
    return str(dom)

Add proper XML namespace to the `marc_xml` record.

Args:
marc_xml (str): String representation of the XML record.

Returns:
str: XML with namespace.


async def do_cmd(self, *args, success=None):

        if success is None:
            success = (250,)

        cmd = " ".join(args)

        await self.writer.send_command(cmd)
        code, message = await self.reader.read_reply()

        if code not in success:
            raise SMTPCommandFailedError(code, message, cmd)

        return code, message

Sends the given command to the server.

Args:
*args: Command and arguments to be sent to the server.

Raises:
ConnectionResetError: If the connection with the server is
unexpectedely lost.
SMTPCommandFailedError: If the command fails.

Returns:
(int, str): A (code, message) 2-tuple containing the server
response.


def Deserialize(self, reader):

        usage = reader.ReadByte()
        self.Usage = usage

        if usage == TransactionAttributeUsage.ContractHash or usage == TransactionAttributeUsage.Vote or \
                (usage >= TransactionAttributeUsage.Hash1 and usage <= TransactionAttributeUsage.Hash15):
            self.Data = reader.ReadBytes(32)

        elif usage == TransactionAttributeUsage.ECDH02 or usage == TransactionAttributeUsage.ECDH03:
            self.Data = bytearray(usage) + bytearray(reader.ReadBytes(32))

        elif usage == TransactionAttributeUsage.Script:
            self.Data = reader.ReadBytes(20)

        elif usage == TransactionAttributeUsage.DescriptionUrl:

            self.Data = reader.ReadBytes(reader.ReadByte())

        elif usage == TransactionAttributeUsage.Description or usage >= TransactionAttributeUsage.Remark:
            self.Data = reader.ReadVarBytes(max=self.MAX_ATTR_DATA_SIZE)
        else:
            logger.error("format error!!!")

Deserialize full object.

Args:
reader (neo.IO.BinaryReader):


def format_level_1_memory(memory):

    formatted_memory = _list_to_complex_array(memory)

    if not 1 <= len(formatted_memory.shape) <= 2:
        raise QiskitError('Level one memory is not of correct shape.')
    return formatted_memory

Format an experiment result memory object for measurement level 1.

Args:
memory (list): Memory from experiment with `meas_level==1`. `avg` or
`single` will be inferred from shape of result memory.

Returns:
np.ndarray: Measurement level 1 complex numpy array

Raises:
QiskitError: If the returned numpy array does not have 1 (avg) or 2 (single)
indicies.


def snapped_slice(size, frac, n):
    if (size < n):
        n = size
    start = (int(((size * frac) - ceil((n / 2)))) + 1)
    stop = (int(((size * frac) + floor((n / 2)))) + 1)
    buf = 0
    if (stop >= size):
        buf = (size - stop)
    elif (start < 0):
        buf = (0 - start)
    stop += buf
    start += buf
    assert (stop <= size), ('out of bounds [%r, %r]' % (stop, start))
    sl = slice(start, stop)
    return sl

r"""
Creates a slice spanning `n` items in a list of length `size` at position
`frac`.

Args:
size (int): length of the list
frac (float): position in the range [0, 1]
n (int): number of items in the slice

Returns:
slice: slice object that best fits the criteria

SeeAlso:
take_percentile_parts

Example:

Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_list import *  # NOQA
>>> import utool as ut
>>> print(snapped_slice(0, 0, 10))
>>> print(snapped_slice(1, 0, 10))
>>> print(snapped_slice(100, 0, 10))
>>> print(snapped_slice(9, 0, 10))
>>> print(snapped_slice(100, 1, 10))
pass


def num_lineages_at(self, distance):
    if ((not isinstance(distance, float)) and (not isinstance(distance, int))):
        raise TypeError('distance must be an int or a float')
    if (distance < 0):
        raise RuntimeError('distance cannot be negative')
    d = dict()
    q = deque()
    q.append(self.root)
    count = 0
    while (len(q) != 0):
        node = q.popleft()
        if node.is_root():
            d[node] = 0
        else:
            d[node] = d[node.parent]
        if (node.edge_length is not None):
            d[node] += node.edge_length
        if (d[node] < distance):
            q.extend(node.children)
        elif ((node.parent is None) or (d[node.parent] < distance)):
            count += 1
    return count

Returns the number of lineages of this ``Tree`` that exist ``distance`` away from the root

Args:
``distance`` (``float``): The distance away from the root

Returns:
``int``: The number of lineages that exist ``distance`` away from the root


def _createBitpattern(functioncode, value):
    _checkFunctioncode(functioncode, [5, 15])
    _checkInt(value, minvalue=0, maxvalue=1, description='inputvalue')
    if (functioncode == 5):
        if (value == 0):
            return '\x00\x00'
        else:
            return 'ÿ\x00'
    elif (functioncode == 15):
        if (value == 0):
            return '\x00'
        else:
            return '\x01'

Create the bit pattern that is used for writing single bits.

This is basically a storage of numerical constants.

Args:
* functioncode (int): can be 5 or 15
* value (int): can be 0 or 1

Returns:
The bit pattern (string).

Raises:
TypeError, ValueError


def _pack_sequence_as(structured_outputs, op_outputs):
    outputs_with_nones = []
    counter = 0
    for output in nest.flatten(structured_outputs, expand_composites=True):
        if output is None:
            outputs_with_nones.append(None)
        else:
            outputs_with_nones.append(op_outputs[counter])
            counter += 1
    return func_graph_module.pack_sequence_as(structured_outputs, outputs_with_nones)

Packs the outputs of the gradient If/Case op.

The branch functions may contain None's in the list of `structured_outputs`.
`op_outputs` has those outputs missing. So we need to add those Nones to the
list of `op_outputs` and then pack it in the same structure as
`structured_outputs`.

Args:
structured_outputs: structured_outputs from one of the branch functions.
op_outputs: List of output tensors of the op.

Returns:
`op_outputs` packed like `structured_outputs`.


def parse_GPL(filepath, entry_name=None, partial=None):
    gsms = {}
    gses = {}
    gpl_soft = []
    has_table = False
    gpl_name = entry_name
    database = None
    if isinstance(filepath, str):
        with utils.smart_open(filepath) as soft:
            groupper = groupby(soft, (lambda x: x.startswith('^')))
            for (is_new_entry, group) in groupper:
                if is_new_entry:
                    (entry_type, entry_name) = __parse_entry(next(group))
                    logger.debug(('%s: %s' % (entry_type.upper(), entry_name)))
                    if (entry_type == 'SERIES'):
                        (is_data, data_group) = next(groupper)
                        gse_metadata = parse_metadata(data_group)
                        gses[entry_name] = GSE(name=entry_name, metadata=gse_metadata)
                    elif (entry_type == 'SAMPLE'):
                        if (partial and (entry_name not in partial)):
                            continue
                        (is_data, data_group) = next(groupper)
                        gsms[entry_name] = parse_GSM(data_group, entry_name)
                    elif (entry_type == 'DATABASE'):
                        (is_data, data_group) = next(groupper)
                        database_metadata = parse_metadata(data_group)
                        database = GEODatabase(name=entry_name, metadata=database_metadata)
                    elif ((entry_type == 'PLATFORM') or (entry_type == 'Annotation')):
                        gpl_name = entry_name
                        (is_data, data_group) = next(groupper)
                        has_gpl_name = (gpl_name or (gpl_name is None))
                        for line in data_group:
                            if (('_table_begin' in line) or (not line.startswith(('^', '!', '
                                has_table = True
                            if (not has_gpl_name):
                                if match('!Annotation_platform\\s*=\\s*', line):
                                    gpl_name = split('\\s*=\\s*', line)[(- 1)].strip()
                                    has_gpl_name = True
                            gpl_soft.append(line)
                    else:
                        raise RuntimeError('Cannot parse {etype}. Unknown for GPL.'.format(etype=entry_type))
    else:
        for line in filepath:
            if (('_table_begin' in line) or (not line.startswith(('^', '!', '
                has_table = True
            gpl_soft.append(line.rstrip())
    columns = None
    try:
        columns = parse_columns(gpl_soft)
    except Exception:
        pass
    metadata = parse_metadata(gpl_soft)
    if has_table:
        table_data = parse_table_data(gpl_soft)
    else:
        table_data = DataFrame()
    gpl = GPL(name=gpl_name, gses=gses, gsms=gsms, table=table_data, metadata=metadata, columns=columns, database=database)
    for (gse_id, gse) in gpl.gses.items():
        for gsm_id in gse.metadata.get('sample_id', []):
            if (gsm_id in gpl.gsms):
                gpl.gses[gse_id].gsms[gsm_id] = gpl.gsms[gsm_id]
    return gpl

Parse GPL entry from SOFT file.

Args:
filepath (:obj:`str` or :obj:`Iterable`): Path to file with 1 GPL entry
or list of lines representing GPL from GSE file.
entry_name (:obj:`str`, optional): Name of the entry. By default it is
inferred from the data.
partial (:obj:'iterable', optional): A list of accession IDs of GSMs
to be partially extracted from GPL, works only if a file/accession
is a GPL.

Returns:
:obj:`GEOparse.GPL`: A GPL object.


def _VerifyExplicitPaddings(self, tensor_in_sizes, filter_in_sizes, strides, padding, data_format, dtype, use_gpu, op_name, dilations=(1, 1), test_grappler_layout_optimizer=False, tol=1e-05):
    input_tensor = self._CreateNumpyTensor(tensor_in_sizes)
    filter_tensor = self._CreateNumpyTensor(filter_in_sizes)
    input_tensor = array_ops.pad(input_tensor, [(0, 0)] + padding + [(0, 0)])
    dilations = list(dilations)
    conv2d_result = nn_ops.conv2d(input_tensor, filter_tensor, [1] + list(strides) + [1], 'VALID', dilations=[1] + dilations + [1])
    expected = list(self.evaluate(array_ops.reshape(conv2d_result, [-1])))
    self._VerifyValuesParameters(tensor_in_sizes, filter_in_sizes, strides, padding, expected, data_format, dtype, use_gpu, op_name, dilations, test_grappler_layout_optimizer=test_grappler_layout_optimizer, tol=tol)

Verifies Conv2D with explicit padding generates correct values.

It does this by comparing with Conv2D without explicit padding. This
function assumes Conv2D without explicit padding works correctly.

Args:
tensor_in_sizes: Input tensor dimensions in [batch, input_rows,
input_cols, input_depth].
filter_in_sizes: Filter tensor dimensions in [kernel_rows, kernel_cols,
input_depth, output_depth].
strides: [row_stride, col_stride] for the convolution;
padding: Explicit padding amounts.
data_format: "NCHW" or "NHWC"
dtype: data type to perform test
use_gpu: True if testing on the GPU
op_name: "Conv" or "Conv2D"
dilations: Dilation values
test_grappler_layout_optimizer: If True, allow the Grappler layout
optimizer to run, which turns NHWC Conv2Ds on the GPU to NCHW Conv2Ds.
tol: The absolute and relative tolerance.


def anonymize_column(self, col):
    column = col[self.col_name]
    generator = self.get_generator()
    original_values = column[(~ pd.isnull(column))].unique()
    new_values = [generator() for x in range(len(original_values))]
    if (len(new_values) != len(set(new_values))):
        raise ValueError('There are not enought different values on faker providerfor category {}'.format(self.category))
    value_map = dict(zip(original_values, new_values))
    column = column.apply(value_map.get)
    return column.to_frame()

Map the values of column to new ones of the same type.

It replaces the values from others generated using `faker`. It will however,
keep the original distribution. That mean that the generated `probability_map` for both
will have the same values, but different keys.

Args:
col (pandas.DataFrame): Dataframe containing the column to anonymize.

Returns:
pd.DataFrame: DataFrame with its values mapped to new ones,
keeping the original distribution.

Raises:
ValueError: A `ValueError` is raised if faker is not able to provide enought
different values.


def __init__(self, filenames, index=0, buffer_size=None, _account_id=None,
               delimiter=None, path_filter=None):

    super(GCSInputReader, self).__init__()
    self._filenames = filenames
    self._index = index
    self._buffer_size = buffer_size
    self._account_id = _account_id
    self._delimiter = delimiter
    self._bucket = None
    self._bucket_iter = None
    self._path_filter = path_filter
    self._slice_ctx = None

Initialize a GoogleCloudStorageInputReader instance.

Args:
filenames: A list of Google Cloud Storage filenames of the form
'/bucket/objectname'.
index: Index of the next filename to read.
buffer_size: The size of the read buffer, None to use default.
_account_id: Internal use only. See cloudstorage documentation.
delimiter: Delimiter used as path separator. See class doc.
path_filter: An instance of PathFilter.


def stream_stderr(self, processes, print_only_first=False):

    def _stream_stderr_single_process(process, type_string, index, print_to_stdout):

        while True:
            output = process.stderr.readline()
            if not output and process.poll() is not None:
                break
            if output and print_to_stdout:
                print('{}{} {}'.format(type_string, index, output.strip()))
                sys.stdout.flush()
    stream_threads = []
    for process_type, process_list in six.iteritems(processes):
        for i in range(len(process_list)):
            print_to_stdout = not print_only_first or i == 0
            thread = threading.Thread(target=_stream_stderr_single_process, args=(process_list[i], process_type, i, print_to_stdout))
            thread.start()
            stream_threads.append(thread)
    for thread in stream_threads:
        thread.join()

Consume stderr of all processes and print to stdout.

To reduce the amount of logging, caller can set print_only_first to True.
In that case, this function only prints stderr from the first process of
each type.

Args:
processes: A dictionary from process type string -> list of processes.
print_only_first: If true, only print output from first process of each
type.


def hdfs_path(ctx, path):

  HADOOP_SCHEMES = ['adl:
                    'file:
                    'hdfs:
                    'oss:
                    's3:
                    's3a:
                    's3n:
                    'swift:
                    'viewfs:
                    'wasb:
  if (any(path.startswith(scheme) for scheme in HADOOP_SCHEMES)):

    return path
  elif path.startswith("/"):

    return ctx.defaultFS + path
  else:

    if ctx.defaultFS.startswith("hdfs:
      return "{0}/user/{1}/{2}".format(ctx.defaultFS, getpass.getuser(), path)
    elif ctx.defaultFS.startswith("file:
      return "{0}/{1}/{2}".format(ctx.defaultFS, ctx.working_dir[1:], path)
    else:
      logging.warn("Unknown scheme {0} with relative path: {1}".format(ctx.defaultFS, path))
      return "{0}/{1}".format(ctx.defaultFS, path)

Convenience function to create a Tensorflow-compatible absolute HDFS path from relative paths

Args:
:ctx: TFNodeContext containing the metadata specific to this node in the cluster.
:path: path to convert

Returns:
An absolute path prefixed with the correct filesystem scheme.


def probe(filename, cmd='ffprobe', **kwargs):
    args = [cmd, '-show_format', '-show_streams', '-of', 'json']
    args += convert_kwargs_to_cmd_line_args(kwargs)
    args += [filename]
    p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    (out, err) = p.communicate()
    if (p.returncode != 0):
        raise Error('ffprobe', out, err)
    return json.loads(out.decode('utf-8'))

Run ffprobe on the specified file and return a JSON representation of the output.

Raises:
:class:`ffmpeg.Error`: if ffprobe returns a non-zero exit code,
an :class:`Error` is returned with a generic error message.
The stderr output can be retrieved by accessing the
``stderr`` property of the exception.


def get_info_line(self, **kwargs):
    select_date = ('%02d/%02d/%d' % (kwargs.get('day', '01'), kwargs.get('month', '01'), kwargs.get('year', '1970')))
    params = {'fecha': select_date, 'line': util.ints_to_string(kwargs.get('lines', [])), 'cultureInfo': util.language_code(kwargs.get('lang'))}
    result = self.make_request('geo', 'get_info_line', **params)
    if (not util.check_result(result, 'Line')):
        return (False, 'UNKNOWN ERROR')
    values = util.response_list(result, 'Line')
    return (True, [emtype.Line(**a) for a in values])

Obtain basic information on a bus line on a given date.

Args:
day (int): Day of the month in format DD.
The number is automatically padded if it only has one digit.
month (int): Month number in format MM.
The number is automatically padded if it only has one digit.
year (int): Year number in format YYYY.
lines (list[int] | int): Lines to query, may be empty to get
all the lines.
lang (str): Language code (*es* or *en*).

Returns:
Status boolean and parsed response (list[Line]), or message string
in case of error.


def call(self, x):
    return ops.rms_normalization(x, scale=self.scale, axis=self.axis, epsilon=self.epsilon)

Applies RMS normalization to the input tensor.

Args:
x: Input tensor of shape (batch_size, input_dim).

Returns:
The RMS-normalized tensor of the same shape (batch_size, input_dim),
scaled by the learned `scale` parameter.


def extract(self, file_path, is_drum=False):

        midi_data = pretty_midi.PrettyMIDI(file_path)
        note_tuple_list = []
        for instrument in midi_data.instruments:
            if (is_drum is False and instrument.is_drum is False) or (is_drum is True and instrument.is_drum is True):
                for note in instrument.notes:
                    note_tuple_list.append((instrument.program, note.start, note.end, note.pitch, note.velocity))
        note_df = pd.DataFrame(note_tuple_list, columns=["program", "start", "end", "pitch", "velocity"])
        note_df = note_df.sort_values(by=["program", "start", "end"])
        note_df["duration"] = note_df.end - note_df.start

        return note_df

Extract MIDI file.

Args:
file_path:    File path of MIDI.
is_drum:      Extract drum data or not.

Returns:
pd.DataFrame(columns=["program", "start", "end", "pitch", "velocity", "duration"])


def get_num_bytes(self, batch: Sequence[ExampleT]) -> int:
    return len(pickle.dumps(batch))

Returns:
The number of bytes of data for a batch.


def getVarianceComps(self, univariance=False):
    RV = sp.zeros((self.P, self.n_randEffs))
    for term_i in range(self.n_randEffs):
        RV[(:, term_i)] = self.getTraitCovar(term_i).diagonal()
    if univariance:
        RV /= RV.sum(1)[(:, sp.newaxis)]
    return RV

Return the estimated variance components

Args:
univariance:   Boolean indicator, if True variance components are normalized to sum up to 1 for each trait
Returns:
variance components of all random effects on all phenotypes [P, n_randEffs matrix]


def history(self, hash):
    txs = self._t.get(hash, max_transactions=10000)['transactions']
    tree = defaultdict(list)
    number_editions = 0
    for tx in txs:
        _tx = self._t.get(tx['txid'])
        txid = _tx['txid']
        verb_str = BlockchainSpider.check_script(_tx['vouts'])
        verb = Spoolverb.from_verb(verb_str)
        (from_address, to_address, piece_address) = BlockchainSpider._get_addresses(_tx)
        timestamp_utc = _tx['time']
        action = verb.action
        edition_number = 0
        if (action != 'EDITIONS'):
            edition_number = verb.edition_number
        else:
            number_editions = verb.num_editions
        tree[edition_number].append({'txid': txid, 'verb': verb_str, 'from_address': from_address, 'to_address': to_address, 'piece_address': piece_address, 'timestamp_utc': timestamp_utc, 'action': action, 'number_editions': number_editions, 'edition_number': edition_number})
    for (edition, chain) in tree.items():
        [d.update({'number_editions': number_editions}) for d in chain]
    return dict(tree)

Retrieve the ownership tree of all editions of a piece given the hash.

Args:
hash (str): Hash of the file to check. Can be created with the
:class:`File` class

Returns:
dict: Ownsership tree of all editions of a piece.

.. note:: For now we only support searching the blockchain by
the piece hash.


def assert_current_path(self, path, **kwargs):

        query = CurrentPathQuery(path, **kwargs)

        @self.document.synchronize
        def assert_current_path():
            if not query.resolves_for(self):
                raise ExpectationNotMet(query.failure_message)
        assert_current_path()

        return True

Asserts that the page has the given path. By default this will compare against the
path+query portion of the full URL.

Args:
path (str | RegexObject): The string or regex that the current "path" should match.
**kwargs: Arbitrary keyword arguments for :class:`CurrentPathQuery`.

Returns:
True

Raises:
ExpectationNotMet: If the assertion hasn't succeeded during the wait time.


def _create_outbound_stream(self, config=None):

        if config is None:
            raise ValueError('No stream config to create stream from.')

        name = self._get_stream_name(config)
        stream_handlers = self._get_stream_handlers(config, name)
        stream_input = config.get('input', None)
        stream_output = config.get('output', None)

        if type(stream_output) is int:
            return PortOutputStream(name,
                                    stream_input,
                                    stream_output,
                                    stream_handlers,
                                    zmq_args={'zmq_context': self.broker.context,
                                              'zmq_proxy_xsub_url': self.broker.XSUB_URL,
                                              'zmq_proxy_xpub_url': self.broker.XPUB_URL})
        else:
            if stream_output is not None:
                log.warn("Output of stream {} is not an integer port. "
                         "Stream outputs can only be ports.".format(name))
            return ZMQStream(name,
                             stream_input,
                             stream_handlers,
                             zmq_args={'zmq_context': self.broker.context,
                                       'zmq_proxy_xsub_url': self.broker.XSUB_URL,
                                       'zmq_proxy_xpub_url': self.broker.XPUB_URL})

Creates an outbound stream from its config.

Params:
config:       stream configuration as read by ait.config
Returns:
stream:       a Stream
Raises:
ValueError:   if any of the required config values are missing


def _write_class_markdown_to_file(self, f, name, cls):

    methods = dict(self.get_class_members(name, cls))

    num_methods = len(methods)
    try:
      self._write_docstring_markdown_to_file(f, "
                                             methods, {})
    except ValueError as e:
      raise ValueError(str(e) + " in class `%s`" % cls.__name__)

    any_method_called_out = (len(methods) != num_methods)
    if any_method_called_out:
      other_methods = {n: m for n, m in methods.items() if n in cls.__dict__}
      if other_methods:
        print("\n
    else:
      other_methods = methods
    for name in sorted(other_methods):
      self._write_member_markdown_to_file(f, "

Write the class doc to `f`.

Args:
f: File to write to.
prefix: Prefix for names.
cls: class object.
name: name to use.


async def send_rpc_command(self, short_name, rpc_id, payload, sender_client, timeout=1.0):
    rpc_tag = str(uuid.uuid4())
    self.rpc_results.declare(rpc_tag)
    if ((short_name in self.services) and (short_name in self.agents)):
        agent_tag = self.agents[short_name]
        rpc_message = {'rpc_id': rpc_id, 'payload': payload, 'response_uuid': rpc_tag}
        self.in_flight_rpcs[rpc_tag] = InFlightRPC(sender_client, short_name, monotonic(), timeout)
        (await self._notify_update(short_name, 'rpc_command', rpc_message, directed_client=agent_tag))
    else:
        response = dict(result='service_not_found', response=b'')
        self.rpc_results.set(rpc_tag, response)
    return rpc_tag

Send an RPC to a service using its registered agent.

Args:
short_name (str): The name of the service we would like to send
and RPC to
rpc_id (int): The rpc id that we would like to call
payload (bytes): The raw bytes that we would like to send as an
argument
sender_client (str): The uuid of the sending client
timeout (float): The maximum number of seconds before we signal a timeout
of the RPC

Returns:
str: A unique id that can used to identify the notified response of this
RPC.


def read_var_bytes(self, max_size=sys.maxsize) -> bytes:

        length = self.read_var_int(max_size)
        return self.read_bytes(length)

Read a variable length of bytes from the stream.

Args:
max_size (int): (Optional) maximum number of bytes to read.

Returns:
bytes:


def GetEventTagByIdentifier(self, storage_file, event_identifier):

    if not self._index:
      self._Build(storage_file)

    lookup_key = event_identifier.CopyToString()
    event_tag_identifier = self._index.get(lookup_key, None)
    if not event_tag_identifier:
      return None

    return storage_file.GetEventTagByIdentifier(event_tag_identifier)

Retrieves the most recently updated event tag for an event.

Args:
storage_file (BaseStorageFile): storage file.
event_identifier (AttributeContainerIdentifier): event attribute
container identifier.

Returns:
EventTag: event tag or None if the event has no event tag.


def _BuildOobLink(self, param, mode):

    code = self.rpc_helper.GetOobCode(param)
    if code:
      parsed = list(parse.urlparse(self.widget_url))

      query = dict(parse.parse_qsl(parsed[4]))
      query.update({'mode': mode, 'oobCode': code})

      try:
        parsed[4] = parse.urlencode(query)
      except AttributeError:
        parsed[4] = urllib.urlencode(query)

      return code, parse.urlunparse(parsed)
    raise errors.GitkitClientError('invalid request')

Builds out-of-band URL.

Gitkit API GetOobCode() is called and the returning code is combined
with Gitkit widget URL to building the out-of-band url.

Args:
param: dict of request.
mode: string, Gitkit widget mode to handle the oob action after user
clicks the oob url in the email.

Raises:
GitkitClientError: if oob code is not returned.

Returns:
A string of oob url.


def determinant(self, name='det'):
    if self.is_square is False:
        raise NotImplementedError('Determinant not implemented for an operator that is expected to not be square.')
    with self._name_scope(name):
        return self._determinant()

Determinant for every batch member.

Args:
name:  A name for this `Op`.

Returns:
`Tensor` with shape `self.batch_shape` and same `dtype` as `self`.

Raises:
NotImplementedError:  If `self.is_square` is `False`.


def get_service_alias_by_class(self, service_class):
    aliases = []
    for alias, service_object in self._service_objects.items():
        if isinstance(service_object, service_class):
            aliases.append(alias)
    return aliases

Gets the aslias name of a registered service.

The same service class can be registered multiple times with different
aliases. When not well managed, duplication and race conditions can arise.
One can use this API to de-duplicate as needed.

Args:
service_class: class, the class of a service type.

Returns:
list of strings, the aliases the service is registered with.


def __init__(self, statediag=[], thebiggestid=None):

        self.statediag = []
        self.quickresponse = {}
        self.quickresponse_types = {}
        self.toadd = []
        self.biggestid = 0

        if thebiggestid is None:
            for state in statediag:
                if statediag[state].id > self.biggestid:
                    self.biggestid = statediag[state].id
        else:
            self.biggestid = thebiggestid
        self.statediag = statediag

Find the biggest State ID
Args:
statediag (list): The states of the PDA
thebiggestid (int): The binggest state identifier
Returns:
None


def _list_certs(certificate_store='My'):
    ret = dict()
    blacklist_keys = ['DnsNameList', 'Thumbprint']
    ps_cmd = ['Get-ChildItem', '-Path', "'Cert:\\LocalMachine\\{0}'".format(certificate_store), '|', 'Select-Object DnsNameList, SerialNumber, Subject, Thumbprint, Version']
    cmd_ret = _srvmgr(cmd=ps_cmd, return_json=True)
    try:
        items = salt.utils.json.loads(cmd_ret['stdout'], strict=False)
    except ValueError:
        raise CommandExecutionError('Unable to parse return data as Json.')
    for item in items:
        cert_info = dict()
        for key in item:
            if (key not in blacklist_keys):
                cert_info[key.lower()] = item[key]
        cert_info['dnsnames'] = []
        if item['DnsNameList']:
            cert_info['dnsnames'] = [name['Unicode'] for name in item['DnsNameList']]
        ret[item['Thumbprint']] = cert_info
    return ret

List details of available certificates in the LocalMachine certificate
store.

Args:
certificate_store (str): The name of the certificate store on the local
machine.

Returns:
dict: A dictionary of certificates found in the store


def __init__(self, num_participants):
    self._num_participants = num_participants
    self._counter = 0
    self._flag = False
    self._local_sense = threading.local()
    self._lock = threading.Lock()
    self._condition = threading.Condition()

Initializes the barrier object.

Args:
num_participants: an integer which is the expected number of calls of
`wait` pass to through this barrier.


def resize(self, image: 'torch.Tensor', size: Dict[str, int], crop_pct: float, interpolation: PILImageResampling=PILImageResampling.BICUBIC, **kwargs) -> 'torch.Tensor':
    if not size.shortest_edge:
        raise ValueError(f"Size dictionary must contain 'shortest_edge' key. Got {size.keys()}")
    shortest_edge = size['shortest_edge']
    if shortest_edge < 384:
        resize_shortest_edge = int(shortest_edge / crop_pct)
        resize_size = get_resize_output_image_size(image, size=resize_shortest_edge, default_to_square=False, input_data_format=ChannelDimension.FIRST)
        image = F.resize(image, resize_size, interpolation=interpolation, **kwargs)
        return F.center_crop(image, (shortest_edge, shortest_edge), **kwargs)
    else:
        return F.resize(image, (shortest_edge, shortest_edge), interpolation=interpolation, **kwargs)

Resize an image.

Args:
image (`torch.Tensor`):
Image to resize.
size (`Dict[str, int]`):
Dictionary of the form `{"shortest_edge": int}`, specifying the size of the output image. If
`size["shortest_edge"]` >= 384 image is resized to `(size["shortest_edge"], size["shortest_edge"])`.
Otherwise, the smaller edge of the image will be matched to `int(size["shortest_edge"] / crop_pct)`,
after which the image is cropped to `(size["shortest_edge"], size["shortest_edge"])`.
crop_pct (`float`):
Percentage of the image to crop. Only has an effect if size < 384.
resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BICUBIC`):
Resampling filter to use when resizing the image.

Returns:
`torch.Tensor`: Resized image.


def downstream_index_dinf(dinfdir_value, i, j):

        down_dirs = DinfUtil.dinf_downslope_direction(dinfdir_value)
        down_coors = []
        for dir_code in down_dirs:
            row, col = D8Util.downstream_index(dir_code, i, j)
            down_coors.append([row, col])
        return down_coors

find downslope coordinate for Dinf of TauDEM
Args:
dinfdir_value: dinf direction value
i: current row
j: current col

Returns:
downstream (row, col)s


def _CreateExpandedDSA(client, ad_group_id):

  ad_group_ad_service = client.GetService('AdGroupAdService')

  operations = [{
      'operator': 'ADD',
      'operand': {
          'xsi_type': 'AdGroupAd',
          'adGroupId': ad_group_id,

          'ad': {
              'xsi_type': 'ExpandedDynamicSearchAd',

              'description': 'Buy your tickets now!',
              'description2': 'Discount ends soon'
          },

          'status': 'PAUSED',
      }
  }]

  ad = ad_group_ad_service.mutate(operations)['value'][0]['ad']

  print ('Expanded dynamic search ad with ID "%d", description "%s", and '
         'description 2 "%s" was added'
         % (ad['id'], ad['description'], ad['description2']))

Creates the expanded Dynamic Search Ad.

Args:
client: an AdwordsClient instance.
ad_group_id: an integer ID of the ad group in which the DSA is added.


def log_value(self, name, value, step=None):
    if isinstance(value, six.string_types):
        raise TypeError('"value" should be a number, got {}'.format(type(value)))
    value = float(value)
    self._check_step(step)
    tf_name = self._ensure_tf_name(name)
    summary = self._scalar_summary(tf_name, value, step)
    self._log_summary(tf_name, summary, value, step=step)

Log new value for given name on given step.

Args:
name (str): name of the variable (it will be converted to a valid
tensorflow summary name).
value (float): this is a real number to be logged as a scalar.
step (int): non-negative integer used for visualization: you can
log several different variables on one step, but should not log
different values of the same variable on the same step (this is
not checked).


def _ParseShVariables(self, lines):

    paths = {}
    for line in lines:
      for entry in line:
        if "=" in entry:

          target, vals = (entry.split("=", 1) + [""])[:2]
          if vals:
            path_vals = vals.split(":")
          else:
            path_vals = []
          self._ExpandPath(target, path_vals, paths)
        elif entry not in self._SH_CONTINUATION:

          break
    return paths

Extract env_var and path values from sh derivative shells.

Iterates over each line, word by word searching for statements that set the
path. These are either variables, or conditions that would allow a variable
to be set later in the line (e.g. export).

Args:
lines: A list of lines, each of which is a list of space separated words.

Returns:
a dictionary of path names and values.


def deroot(self, label='OLDROOT'):

        if self.root.edge_length is not None:
            self.root.add_child(Node(edge_length=self.root.edge_length,label=label))
            self.root.edge_length = None

If the tree has a root edge, drop the edge to be a child of the root node

Args:
``label`` (``str``): The desired label of the new child


def __init__(self, *args, **kwargs):

    self.args = args
    self.kwargs = kwargs
    self.outputs = None
    self.backoff_seconds = _DEFAULT_BACKOFF_SECONDS
    self.backoff_factor = _DEFAULT_BACKOFF_FACTOR
    self.max_attempts = _DEFAULT_MAX_ATTEMPTS
    self.target = None
    self.task_retry = False
    self._current_attempt = 0
    self._root_pipeline_key = None
    self._pipeline_key = None
    self._context = None
    self._result_status = None
    self._set_class_path()

    self.target = mr_util._get_task_target()

    if _TEST_MODE:
      self._context = _PipelineContext('', 'default', '')
      self._root_pipeline_key = _TEST_ROOT_PIPELINE_KEY
      self._pipeline_key = db.Key.from_path(
          _PipelineRecord.kind(), uuid.uuid4().hex)
      self.outputs = PipelineFuture(self.output_names)
      self._context.evaluate_test(self)

Initializer.

Args:
*args: The positional arguments for this function-object.
**kwargs: The keyword arguments for this function-object.


def implemented(cls, for_type):
    for function in cls.required():
        if (not function.implemented_for_type(for_type)):
            raise TypeError(("%r doesn't implement %r so it cannot participate in the protocol %r." % (for_type, function.func.__name__, cls)))
    cls.register(for_type)

Assert that protocol 'cls' is implemented for type 'for_type'.

This will cause 'for_type' to be registered with the protocol 'cls'.
Subsequently, protocol.isa(for_type, cls) will return True, as will
isinstance, issubclass and others.

Raises:
TypeError if 'for_type' doesn't implement all required functions.


def from_music_service(cls, music_service, content_dict):

        quoted_id = quote_url(content_dict['id'].encode('utf-8'))

        item_id = '0fffffff{}'.format(quoted_id)

        is_track = cls == get_class('MediaMetadataTrack')
        uri = form_uri(item_id, music_service, is_track)

        resources = [DidlResource(uri=uri, protocol_info="DUMMY")]
        desc = music_service.desc
        return cls(item_id, desc, resources, uri, content_dict,
                   music_service=music_service)

Return an element instantiated from the information that a music
service has (alternative constructor)

Args:
music_service (MusicService): The music service that content_dict
originated from
content_dict (OrderedDict): The data to instantiate the music
service item from

Returns:
MusicServiceItem: A MusicServiceItem instance


def delete_endpoint(self, endpoint_name):

        LOGGER.info('Deleting endpoint with name: {}'.format(endpoint_name))
        self.sagemaker_client.delete_endpoint(EndpointName=endpoint_name)

Delete an Amazon SageMaker ``Endpoint``.

Args:
endpoint_name (str): Name of the Amazon SageMaker ``Endpoint`` to delete.


def put_rpc(self, address, rpc_id, arg_payload, response):
    self._rpc_queue.put_nowait((address, rpc_id, arg_payload, response))

Place an RPC onto the RPC queue.

The rpc will be dispatched asynchronously by the background dispatch
task.  This method must be called from the event loop.  This method
does not block.

Args:
address (int): The address of the tile with the RPC
rpc_id (int): The id of the rpc you want to call
arg_payload (bytes): The RPC payload
respones (GenericResponse): The object to use to signal the result.


def read_value(self):
    raise NotImplementedError

Returns the value of this variable, read in the current context.

Can be different from value() if it's on another device, with control
dependencies, etc.

Returns:
A `Tensor` containing the value of the variable.


def _example_short_number(region_code):

    metadata = PhoneMetadata.short_metadata_for_region(region_code)
    if metadata is None:
        return U_EMPTY_STRING
    desc = metadata.short_code
    if desc.example_number is not None:
        return desc.example_number
    return U_EMPTY_STRING

Gets a valid short number for the specified region.

Arguments:
region_code -- the region for which an example short number is needed.

Returns a valid short number for the specified region. Returns an empty
string when the metadata does not contain such information.


def get_smeared_densities(self, sigma):
    from scipy.ndimage.filters import gaussian_filter1d
    diff = [(self.frequencies[(i + 1)] - self.frequencies[i]) for i in range((len(self.frequencies) - 1))]
    avgdiff = (sum(diff) / len(diff))
    smeared_dens = gaussian_filter1d(self.densities, (sigma / avgdiff))
    return smeared_dens

Returns the densities, but with a Gaussian smearing of
std dev sigma applied.

Args:
sigma: Std dev of Gaussian smearing function.

Returns:
Gaussian-smeared densities.


def process_opened_file(self, in_filename, in_file, out_filename, out_file):
    lines = in_file.readlines()
    processed_file, new_file_content, log, process_errors = self.update_string_pasta(''.join(lines), in_filename)
    if out_file and processed_file:
        out_file.write(new_file_content)
    return (processed_file, self._format_log(log, in_filename, out_filename), process_errors)

Process the given python file for incompatible changes.

This function is split out to facilitate StringIO testing from
tf_upgrade_test.py.

Args:
in_filename: filename to parse
in_file: opened file (or StringIO)
out_filename: output file to write to
out_file: opened file (or StringIO)
Returns:
A tuple representing number of files processed, log of actions, errors


def _executeMassiveMethod(path, method, args=None, classArgs = None):

		response = {}

		if args is None:
			args = {}

		if classArgs is None:
			classArgs = {}

		sys.path.append(path)
		exclude = ["__init__.py", "base.py"]
		for f in AtomShieldsScanner._getFiles(path, "*.py", exclude=exclude):
			try:
				instance = AtomShieldsScanner._getClassInstance(path = f, args = classArgs)
				if instance is not None:
					if callable(method):
						args["instance"] = instance
						output = method(**args)
						response[instance.__class__.NAME] = output
					else:
						if hasattr(instance, method):
							output = getattr(instance, method)(**args)
							response[instance.__class__.NAME] = output
						else:
							continue

			except Exception as e:
				AtomShieldsScanner._debug("[!] %s" % e)
		sys.path.remove(path)
		return response

Execute an specific method for each class instance located in path

Args:
path (str): Absolute path which contains the .py files
method (str): Method to execute into class instance

Returns:
dict: Dictionary which contains the response for every class instance.
The dictionary keys are the value of 'NAME' class variable.


def flatten(repertoire, big_endian=False):
    if (repertoire is None):
        return None
    order = ('C' if big_endian else 'F')
    return repertoire.squeeze().ravel(order=order)

Flatten a repertoire, removing empty dimensions.

By default, the flattened repertoire is returned in little-endian order.

Args:
repertoire (np.ndarray or None): A repertoire.

Keyword Args:
big_endian (boolean): If ``True``, flatten the repertoire in big-endian
order.

Returns:
np.ndarray: The flattened repertoire.


def get_compatibility_log(self):
    if not self._verified:
        raise RuntimeError("target compatibility isn't verified yet")
    return self._log_messages

Returns list of compatibility log messages.

WARNING: This method should only be used for unit tests.

Returns:
The list of log messages by the recent compatibility check.
Raises:
RuntimeError: when the compatibility was NOT checked.


def item_to_mrc(code, val):
    if isinstance(val, basestring):
        return [val_to_mrc(code, val)]
    if isinstance(val, dict):
        val = [val]
    return dicts_to_mrc(code, val)

Convert `val` to MRC, whether it is dict or string.

Args:
code (str): Code of the field.
val (str or dict): Value of the field.

Returns:
list: MRC lines for output template.


def from_hising(cls, h, J, offset=None):
    poly = {(k,): v for (k, v) in h.items()}
    poly.update(J)
    if (offset is not None):
        poly[frozenset([])] = offset
    return cls(poly, Vartype.SPIN)

Construct a binary polynomial from a higher-order Ising problem.

Args:
h (dict):
The linear biases.

J (dict):
The higher-order biases.

offset (optional, default=0.0):
Constant offset applied to the model.

Returns:
:obj:`.BinaryPolynomial`

Examples:
>>> poly = dimod.BinaryPolynomial.from_hising({'a': 2}, {'ab': -1}, 0)


def auto_batch_size(sequence_length,
                    mesh_shape,
                    layout_rules,
                    tokens_per_split=2048):

  num_splits = mtf.tensor_dim_to_mesh_dim_size(
      layout_rules, mesh_shape, mtf.Dimension("batch", 0))
  ret = max(1, tokens_per_split
  tf.logging.info(
      "AUTO_BATCH_SIZE tokens_per_split=%s num_splits=%s"
      " sequence_length=%s batch_size=%s"
      % (tokens_per_split, num_splits, sequence_length, ret))
  return ret

Automatically compute batch size.

Args:
sequence_length: an integer
mesh_shape: an input to mtf.convert_to_shape()
layout_rules: an input to mtf.convert_to_layout_rules()
tokens_per_split: an integer
Returns:
an integer


def get_global_vars(func):

    closure = getclosurevars(func)
    if closure['nonlocal']:
        raise TypeError("Can't launch a job with closure variables: %s" %
                        closure['nonlocals'].keys())
    globalvars = dict(modules={},
                      functions={},
                      vars={})
    for name, value in closure['global'].items():
        if inspect.ismodule(value):
            globalvars['modules'][name] = value.__name__
        elif inspect.isfunction(value) or inspect.ismethod(value):
            globalvars['functions'][name] = value
        else:
            globalvars['vars'][name] = value

    return globalvars

Store any methods or variables bound from the function's closure

Args:
func (function): function to inspect

Returns:
dict: mapping of variable names to globally bound VARIABLES


def usufyToGmlExport(d, fPath):
    try:
        oldData = nx.read_gml(fPath)
    except UnicodeDecodeError as e:
        print(('UnicodeDecodeError:\t' + str(e)))
        print('Something went wrong when reading the .gml file relating to the decoding of UNICODE.')
        import time as time
        fPath += ('_' + str(time.time()))
        print(((('To avoid losing data, the output file will be renamed to use the timestamp as:\n' + fPath) + '_') + str(time.time())))
        print()
        oldData = nx.Graph()
    except Exception as e:
        oldData = nx.Graph()
    newGraph = _generateGraphData(d, oldData)
    nx.write_gml(newGraph, fPath)

Workaround to export data to a .gml file.

Args:
-----
d: Data to export.
fPath: File path for the output file.


def unflatten1(flat_list, reverse_list):

    unflat_list2 = [[flat_list[index] for index in tup]
                    for tup in reverse_list]
    return unflat_list2

Rebuilds unflat list from invertible_flatten1

Args:
flat_list (list): the flattened list
reverse_list (list): the list which undoes flattenting

Returns:
unflat_list2: original nested list

SeeAlso:
invertible_flatten1
invertible_flatten2
unflatten2


def connect(self, host='localhost'):

        get_logger().info("Connecting to RabbitMQ server...")

        self._conn = pika.BlockingConnection(
            pika.ConnectionParameters(host=host))
        self._channel = self._conn.channel()

        get_logger().info("Declaring topic exchanger {}...".format(
            self.exchange))

        self._channel.exchange_declare(exchange=self.exchange, type='topic')

        get_logger().info("Creating RabbitMQ queue...")
        result = self._channel.queue_declare(exclusive=True)

        self._queue_name = result.method.queue

        if self.listen_all:
            get_logger().info(
                "Binding queue to exchanger {} (listen all)...".format(
                    self.exchange
                )
            )
            self._channel.queue_bind(
                exchange=self.exchange,
                queue=self._queue_name,
                routing_key='*'
            )
        else:
            for routing_key in self.topics:
                get_logger().info(
                    "Binding queue to exchanger {} "
                    "with routing key {}...".format(
                        self.exchange, routing_key)
                )

                self._channel.queue_bind(
                    exchange=self.exchange,
                    queue=self._queue_name,
                    routing_key=routing_key
                )

        get_logger().info("Binding callback...")
        self._channel.basic_consume(
            self._callback, queue=self._queue_name, no_ack=True)

Connect to the server and set everything up.

Args:
host: hostname to connect to


def is_valid(self, tol: float = DISTANCE_TOLERANCE) -> bool:

        if len(self.sites) == 1:
            return True
        all_dists = self.distance_matrix[np.triu_indices(len(self), 1)]
        return bool(np.min(all_dists) > tol)

True if SiteCollection does not contain atoms that are too close
together. Note that the distance definition is based on type of
SiteCollection. Cartesian distances are used for non-periodic
Molecules, while PBC is taken into account for periodic structures.

Args:
tol (float): Distance tolerance. Default is 0.5A.

Returns:
(bool) True if SiteCollection does not contain atoms that are too
close together.


def relaxed_value_for_var(value, var):

        assert isinstance(var, tf.Variable)
        name = var.op.name

        varshape = tuple(var.get_shape().as_list())
        if varshape != value.shape:

            if np.prod(varshape) != np.prod(value.shape):
                raise ValueError(
                    "Trying to load a tensor of shape {} into the variable '{}' whose shape is {}.".format(
                        value.shape, name, varshape))
            logger.warn("The tensor is reshaped from {} to {} when assigned to '{}'".format(
                value.shape, varshape, name))
            value = value.reshape(varshape)

        def upcast(vartype, valtype):

            if vartype == tf.float64 and valtype == np.float32:
                return np.float64
            if vartype in [tf.int64, tf.int32] and valtype in [np.int32, np.int16, np.int8]:
                return np.int64 if vartype == tf.int64 else np.int32
            return None

        if hasattr(value, 'dtype'):
            vartype = var.dtype.as_numpy_dtype
            if vartype != value.dtype:
                msg = "Variable {} has dtype {} but was given a value of dtype {}.".format(name, vartype, value.dtype)
                newtype = upcast(var.dtype.base_dtype, value.dtype)
                if newtype is not None:
                    value = newtype(value)
                    logger.warn(msg + " Load it after casting!")
                else:
                    assert vartype == value.dtype, msg
        return value

Returns a relaxed (possibly reshaped/upcast-ed) version of value,
to be loaded to the given variable.

Args:
value (ndarray): an numpy array to be loaded to var
var (tf.Variable):

Returns:
ndarray: a possibly reshaped or casted version of value


def _CheckStorageFile(self, storage_file_path):
    if os.path.exists(storage_file_path):
        if (not os.path.isfile(storage_file_path)):
            raise errors.BadConfigOption('Storage file: {0:s} already exists and is not a file.'.format(storage_file_path))
        logger.warning('Appending to an already existing storage file.')
    dirname = os.path.dirname(storage_file_path)
    if (not dirname):
        dirname = '.'
    if (not os.access(dirname, os.W_OK)):
        raise errors.BadConfigOption('Unable to write to storage file: {0:s}'.format(storage_file_path))

Checks if the storage file path is valid.

Args:
storage_file_path (str): path of the storage file.

Raises:
BadConfigOption: if the storage file path is invalid.


def listdir(*paths, glob=None):

    path = genpath(*paths)

    names = os.listdir(path)
    if glob is not None:
        names = fnmatch.filter(names, glob)

    retn = [os.path.join(path, name) for name in names]
    return retn

List the (optionally glob filtered) full paths from a dir.

Args:
*paths ([str,...]): A list of path elements
glob (str): An optional fnmatch glob str


def __getitem__(self, thing: Any) -> np.ndarray:

		if type(thing) is slice or type(thing) is np.ndarray or type(thing) is int:
			am = AttributeManager(None, axis=self.axis)
			for key, val in self.items():
				am[key] = val[thing]
			return am
		elif type(thing) is tuple:

			result: np.ndarray = None
			for t in thing:
				if t in self.__dict__["storage"]:
					if result is None:
						result = self.__getattr__(t)
					else:
						vals = self.__getattr__(t)
						if vals.dtype != result.dtype:
							raise AttributeError(f"Cannot stack attributes of different types ({vals.dtype} and {result.dtype})")
						result = np.vstack((result, vals)).transpose()
			if result is None:
				raise AttributeError(f"'{type(self)}' object has no attribute {thing}")
			else:
				return result
		else:
			return self.__getattr__(thing)

Return a named attribute, or a slice through all the attributes

Args:
thing:		if string, return the named attribute
if slice, np.ndarray or int, return a slice through all the attributes


def fit(self, X, y):

        self.X = X
        self.y = y

Fit

Args:
X (np.array): Array of hyperparameter values with shape (n_samples, len(tunables))
y (np.array): Array of scores with shape (n_samples, )


def Delete(self, request, global_params=None):
    config = self.GetMethodConfig('Delete')
    return self._RunMethod(config, request, global_params=global_params)

Deletes the model specified by modelId from the dataset.

Args:
request: (BigqueryModelsDeleteRequest) input message
global_params: (StandardQueryParameters, default: None) global arguments
Returns:
(BigqueryModelsDeleteResponse) The response message.


def is_flash_attention_enabled():
    from keras.src.backend.common import global_state
    return global_state.get_global_attribute('flash_attention', default=None)

Checks whether flash attention is globally enabled in Keras.

Flash attention is a performance-optimized method for computing attention
in large models, such as transformers, allowing for faster and more
memory-efficient operations. This function checks the global Keras
configuration to determine if flash attention is enabled for compatible
layers (e.g., `MultiHeadAttention`).

Note that enabling flash attention does not guarantee it will always be
used. Typically, the inputs must be in `float16` or `bfloat16` dtype, and
input layout requirements may vary depending on the backend.

Returns:
`False` if disabled; otherwise, it indicates that it is enabled.


def cancel_all(self, product_id=None):
    if (product_id is not None):
        params = {'product_id': product_id}
    else:
        params = None
    return self._send_message('delete', '/orders', params=params)

With best effort, cancel all open orders.

Args:
product_id (Optional[str]): Only cancel orders for this
product_id

Returns:
list: A list of ids of the canceled orders. Example::
[
"144c6f8e-713f-4682-8435-5280fbe8b2b4",
"debe4907-95dc-442f-af3b-cec12f42ebda",
"cf7aceee-7b08-4227-a76c-3858144323ab",
"dfc5ae27-cadb-4c0c-beef-8994936fde8a",
"34fecfbf-de33-4273-b2c6-baf8e8948be4"
]


def add_import(self, symbol, source_module_name, source_name, dest_module_name, dest_name):
    if source_module_name.endswith('python.modules_with_exports'):
        source_module_name = symbol.__module__
    import_str = self.format_import(source_module_name, source_name, dest_name)
    full_api_name = dest_name
    if dest_module_name:
        full_api_name = dest_module_name + '.' + full_api_name
    symbol_id = -1 if not symbol else id(symbol)
    self._check_already_imported(symbol_id, full_api_name)
    if not dest_module_name and dest_name.startswith('_'):
        self._underscore_names_in_root.add(dest_name)
    priority = 0
    if symbol:
        if hasattr(symbol, '__module__'):
            priority = int(source_module_name == symbol.__module__)
        if hasattr(symbol, '__name__'):
            priority += int(source_name == symbol.__name__)
    self._module_imports[dest_module_name][full_api_name].add((import_str, priority))

Adds this import to module_imports.

Args:
symbol: TensorFlow Python symbol.
source_module_name: (string) Module to import from.
source_name: (string) Name of the symbol to import.
dest_module_name: (string) Module name to add import to.
dest_name: (string) Import the symbol using this name.

Raises:
SymbolExposedTwiceError: Raised when an import with the same
dest_name has already been added to dest_module_name.


def get_list(self, **query_params):
    list_json = self.get_list_json(self.base_uri, query_params=query_params)
    return self.create_list(list_json)

Get list information for this card. Returns a List object.

Returns:
List: The list this card is attached to


def get_sonos_playlist_by_attr(self, attr_name, match):
    for sonos_playlist in self.get_sonos_playlists():
        if (getattr(sonos_playlist, attr_name) == match):
            return sonos_playlist
    raise ValueError('No match on "{0}" for value "{1}"'.format(attr_name, match))

Return the first Sonos Playlist DidlPlaylistContainer that
matches the attribute specified.

Args:
attr_name (str): DidlPlaylistContainer attribute to compare. The
most useful being: 'title' and 'item_id'.
match (str): Value to match.

Returns:
(:class:`~.soco.data_structures.DidlPlaylistContainer`): The
first matching playlist object.

Raises:
(AttributeError): If indicated attribute name does not exist.
(ValueError): If a match can not be found.

Example::

device.get_sonos_playlist_by_attr('title', 'Foo')
device.get_sonos_playlist_by_attr('item_id', 'SQ:3')


def _ParseCacheEntries(self, parser_mediator, index_table, data_block_files):

    for cache_address in index_table:
      cache_address_chain_length = 0
      while cache_address.value != 0:
        if cache_address_chain_length >= 64:
          parser_mediator.ProduceExtractionWarning(
              'Maximum allowed cache address chain length reached.')
          break

        data_block_file_object = data_block_files.get(
            cache_address.filename, None)
        if not data_block_file_object:
          message = 'Cache address: 0x{0:08x} missing data file.'.format(
              cache_address.value)
          parser_mediator.ProduceExtractionWarning(message)
          break

        try:
          cache_entry = self._data_block_file_parser.ParseCacheEntry(
              data_block_file_object, cache_address.block_offset)
        except (IOError, errors.ParseError) as exception:
          parser_mediator.ProduceExtractionWarning(
              'Unable to parse cache entry with error: {0!s}'.format(
                  exception))
          break

        event_data = ChromeCacheEntryEventData()
        event_data.original_url = cache_entry.original_url

        date_time = dfdatetime_webkit_time.WebKitTime(
            timestamp=cache_entry.creation_time)
        event = time_events.DateTimeValuesEvent(
            date_time, definitions.TIME_DESCRIPTION_LAST_VISITED)
        parser_mediator.ProduceEventWithEventData(event, event_data)

        cache_address = cache_entry.next
        cache_address_chain_length += 1

Parses Chrome Cache file entries.

Args:
parser_mediator (ParserMediator): mediates interactions between parsers
and other components, such as storage and dfvfs.
index_table (list[CacheAddress]): the cache addresses which are stored in
the index file.
data_block_files (dict[str: file]): look up table for the data block
file-like object handles.


def get_storage(request):

    storage_model = oauth2_settings.storage_model
    user_property = oauth2_settings.storage_model_user_property
    credentials_property = oauth2_settings.storage_model_credentials_property

    if storage_model:
        module_name, class_name = storage_model.rsplit('.', 1)
        module = importlib.import_module(module_name)
        storage_model_class = getattr(module, class_name)
        return storage.DjangoORMStorage(storage_model_class,
                                        user_property,
                                        request.user,
                                        credentials_property)
    else:

        return dictionary_storage.DictionaryStorage(
            request.session, key=_CREDENTIALS_KEY)

Gets a Credentials storage object provided by the Django OAuth2 Helper
object.

Args:
request: Reference to the current request object.

Returns:
An :class:`oauth2.client.Storage` object.


def save(self, resource):

        resource_type = None
        xid = None
        if isinstance(resource, dict):
            resource_type = resource.get('type')
            xid = resource.get('xid')
        else:
            resource_type = resource.type
            xid = resource.xid

        if resource_type is not None and xid is not None:
            saved = True
            if resource_type in self.tcex.group_types:
                try:

                    self.groups_shelf[xid] = resource
                except Exception:
                    saved = False

                if saved:
                    try:
                        del self._groups[xid]
                    except KeyError:

                        pass
            elif resource_type in self.tcex.indicator_types_data.keys():
                try:

                    self.indicators_shelf[xid] = resource
                except Exception:
                    saved = False

                if saved:
                    try:
                        del self._indicators[xid]
                    except KeyError:

                        pass

Save group|indicator dict or object to shelve.

Best effort to save group/indicator data to disk.  If for any reason the save fails
the data will still be accessible from list in memory.

Args:
resource (dict|obj): The Group or Indicator dict or object.