def get_lonlatalts(self):

        band = self.filehandle

        (xpoints, ypoints), (gcp_lons, gcp_lats, gcp_alts), (gcps, crs) = self.get_gcps()

        longitudes = interpolate_xarray(xpoints, ypoints, gcp_lons, band.shape)
        latitudes = interpolate_xarray(xpoints, ypoints, gcp_lats, band.shape)
        altitudes = interpolate_xarray(xpoints, ypoints, gcp_alts, band.shape)

        longitudes.attrs['gcps'] = gcps
        longitudes.attrs['crs'] = crs
        latitudes.attrs['gcps'] = gcps
        latitudes.attrs['crs'] = crs
        altitudes.attrs['gcps'] = gcps
        altitudes.attrs['crs'] = crs

        return longitudes, latitudes, altitudes

Obtain GCPs and construct latitude and longitude arrays.

Args:
band (gdal band): Measurement band which comes with GCP's
array_shape (tuple) : The size of the data array
Returns:
coordinates (tuple): A tuple with longitude and latitude arrays


def distinct_values_of(self, field, count_deleted=False):
    solr_params = ('facet=true&facet.field=%s&rows=0' % field)
    result = self.riak_http_search_query(self.index_name, solr_params, count_deleted)
    facet_fields = result['facet_counts']['facet_fields'][field]
    keys = facet_fields[0::2]
    vals = facet_fields[1::2]
    return dict(zip(keys, vals))

Uses riak http search query endpoint for advanced SOLR queries.

Args:
field (str): facet field
count_deleted (bool): ignore deleted or not

Returns:
(dict): pairs of field values and number of counts


def restore_initializer(filename, name_fn=None, collection=tf.GraphKeys.GLOBAL_VARIABLES):

    def _restore_initializer(getter, name, *args, **kwargs):
        'Gets variable with restore initializer.'
        collections = kwargs['collections']
        if (collections is None):
            collections = [tf.GraphKeys.GLOBAL_VARIABLES]
        if (kwargs['trainable'] and (tf.GraphKeys.TRAINABLE_VARIABLES not in collections)):
            collections += [tf.GraphKeys.TRAINABLE_VARIABLES]
        if ((collection is None) or (collection in collections)):
            if (name_fn is not None):
                var_name_in_checkpoint = name_fn(name)
            else:
                var_name_in_checkpoint = name
            tf.logging.info("Restoring '%s' from '%s' into variable '%s'", var_name_in_checkpoint, filename, name)
            kwargs['initializer'] = snt.restore_initializer(filename, var_name_in_checkpoint, scope='')
        return getter(name, *args, **kwargs)
    return _restore_initializer

Custom getter to restore all variables with `snt.restore_initializer`.

Args:
filename: The filename of the checkpoint.
name_fn: A function which can map the name of the variable requested. This
allows restoring variables with values having different names in the
checkpoint.
collection: Only set the restore initializer for variables in this
collection. If `None`, it will attempt to restore all variables. By
default `tf.GraphKeys.GLOBAL_VARIABLES`.

Returns:
A restore_initializer custom getter, which is a function taking arguments
(getter, name, *args, **kwargs).


def cysparse_type_to_real_sum_cysparse_type(cysparse_type):

    r_type = None

    if cysparse_type in ['INT32_t', 'UINT32_t', 'INT64_t', 'UINT64_t']:
        r_type = 'FLOAT64_t'
    elif cysparse_type in ['FLOAT32_t', 'FLOAT64_t']:
        r_type = 'FLOAT64_t'
    elif cysparse_type in ['FLOAT128_t']:
        r_type = 'FLOAT128_t'
    elif cysparse_type in ['COMPLEX64_t', 'COMPLEX128_t']:
        r_type = 'FLOAT64_t'
    elif cysparse_type in ['COMPLEX256_t']:
        r_type = 'FLOAT128_t'
    else:
        raise TypeError("Not a recognized type")

    assert r_type in ['FLOAT64_t', 'FLOAT128_t']

    return r_type

Returns the best **real** type for a **real** sum for a given type.

For instance:

INT32_t -> FLOAT64_t

Args:
cysparse_type:


def report_delete(config, auth, report_id=None, name=None):
    if config.verbose:
        print('DBM DELETE:', report_id or name)
    report = report_get(config, auth, report_id, name)
    if report:
        API_DBM(config, auth).queries().delete(queryId=report['queryId']).execute()
    elif config.verbose:
        print('DBM DELETE: No Report')

Deletes a DBM report based on name or ID.

Args:
* auth: (string) Either user or service.
* report_id: (int) ID of DCm report to fetch ( either or name ).
* name: (string) Name of report to fetch ( either or report_id ).

Returns:
* None


def save(self, filepath):
    filepath = str(filepath)
    if not filepath.endswith('.weights.h5'):
        raise ValueError(f'Invalid `filepath` argument: expected a `.weights.h5` extension. Received: filepath={filepath}')
    weights_store = H5IOStore(filepath, mode='w')

    def _save(weights_dict, weights_store, inner_path):
        vars_to_create = {}
        for name, value in weights_dict.items():
            if isinstance(value, dict):
                if value:
                    _save(weights_dict[name], weights_store, inner_path=inner_path + '/' + name)
            else:
                vars_to_create[name] = value
        if vars_to_create:
            var_store = weights_store.make(inner_path)
            for name, value in vars_to_create.items():
                var_store[name] = value
    _save(self.weights_dict, weights_store, inner_path='')
    weights_store.close()

Save the edited weights file.

Args:
filepath: Path to save the file to.
Must be a `.weights.h5` file.


def get_rel_pos(q_size, k_size, rel_pos):
    max_rel_dist = int(2 * max(q_size, k_size) - 1)
    if rel_pos.shape[0] != max_rel_dist:
        rel_pos_resized = nn.functional.interpolate(rel_pos.reshape(1, rel_pos.shape[0], -1).permute(0, 2, 1), size=max_rel_dist, mode='linear')
        rel_pos_resized = rel_pos_resized.reshape(-1, max_rel_dist).permute(1, 0)
    else:
        rel_pos_resized = rel_pos
    q_coords = torch.arange(q_size)[:, None] * max(k_size / q_size, 1.0)
    k_coords = torch.arange(k_size)[None, :] * max(q_size / k_size, 1.0)
    relative_coords = q_coords - k_coords + (k_size - 1) * max(q_size / k_size, 1.0)
    return rel_pos_resized[relative_coords.long()]

Get relative positional embeddings according to the relative positions of query and key sizes.

Args:
q_size (`int`):
Size of query q.
k_size (`int`):
Size of key k.
rel_pos (`torch.Tensor`):
Relative position embeddings (num_embeddings, num_channels).

Returns:
Extracted positional embeddings according to relative positions.


def distances_from_parent(self, leaves=True, internal=True, unlabeled=False):

        if not isinstance(leaves, bool):
            raise TypeError("leaves must be a bool")
        if not isinstance(internal, bool):
            raise TypeError("internal must be a bool")
        if not isinstance(unlabeled, bool):
            raise TypeError("unlabeled must be a bool")
        if leaves or internal:
            for node in self.traverse_preorder():
                if ((leaves and node.is_leaf()) or (internal and not node.is_leaf())) and (unlabeled or node.label is not None):
                    if node.edge_length is None:
                        yield (node,0)
                    else:
                        yield (node,node.edge_length)

Generator over the node-to-parent distances of this ``Tree``; (node,distance) tuples

Args:
``terminal`` (``bool``): ``True`` to include leaves, otherwise ``False``

``internal`` (``bool``): ``True`` to include internal nodes, otherwise ``False``

``unlabeled`` (``bool``): ``True`` to include unlabeled nodes, otherwise ``False``


def r_edges(step):
    (rbot, rtop) = misc.get_rbounds(step)
    centers = (step.rprof.loc[(:, 'r')].values + rbot)
    edges = ((centers[:(- 1)] + centers[1:]) / 2)
    edges = np.insert(edges, 0, rbot)
    edges = np.append(edges, rtop)
    return (edges, edges)

Cell border.

Args:
step (:class:`~stagpy.stagyydata._Step`): a step of a StagyyData
instance.
Returns:
tuple of :class:`numpy.array`: the position of the bottom and top walls
of the cells. The two elements of the tuple are identical.


def pybel_to_json(molecule, name=None):
    atoms = [{'element': table.GetSymbol(atom.atomicnum), 'location': list(atom.coords)} for atom in molecule.atoms]
    for (json_atom, pybel_atom) in zip(atoms, molecule.atoms):
        if (pybel_atom.partialcharge != 0):
            json_atom['charge'] = pybel_atom.partialcharge
        if pybel_atom.OBAtom.HasData('_atom_site_label'):
            obatom = pybel_atom.OBAtom
            json_atom['label'] = obatom.GetData('_atom_site_label').GetValue()
        if pybel_atom.OBAtom.HasData('color'):
            obatom = pybel_atom.OBAtom
            json_atom['color'] = obatom.GetData('color').GetValue()
    bonds = [{'atoms': [b.GetBeginAtom().GetIndex(), b.GetEndAtom().GetIndex()], 'order': b.GetBondOrder()} for b in ob.OBMolBondIter(molecule.OBMol)]
    output = {'atoms': atoms, 'bonds': bonds, 'units': {}}
    if hasattr(molecule, 'unitcell'):
        uc = molecule.unitcell
        output['unitcell'] = [[v.GetX(), v.GetY(), v.GetZ()] for v in uc.GetCellVectors()]
        density = (sum((atom.atomicmass for atom in molecule.atoms)) / (uc.GetCellVolume() * 0.6022))
        output['density'] = density
        output['units']['density'] = 'kg / L'
    element_count = Counter((table.GetSymbol(a.atomicnum) for a in molecule))
    hill_count = []
    for element in ['C', 'H']:
        if (element in element_count):
            hill_count += [(element, element_count[element])]
            del element_count[element]
    hill_count += sorted(element_count.items())
    div = (reduce(gcd, (c[1] for c in hill_count)) if hasattr(molecule, 'unitcell') else 1)
    output['formula'] = ''.join(((n if ((c / div) == 1) else ('%s%d' % (n, (c / div)))) for (n, c) in hill_count))
    output['molecular_weight'] = (molecule.molwt / div)
    output['units']['molecular_weight'] = 'g / mol'
    if name:
        output['name'] = name
    return output

Converts a pybel molecule to json.

Args:
molecule: An instance of `pybel.Molecule`
name: (Optional) If specified, will save a "name" property
Returns:
A Python dictionary containing atom and bond data


def get_region(b):
    remap = {None: 'us-east-1', 'EU': 'eu-west-1'}
    region = b.get('Location', {}).get('LocationConstraint')
    return remap.get(region, region)

Tries to get the bucket region from Location.LocationConstraint

Special cases:
LocationConstraint EU defaults to eu-west-1
LocationConstraint null defaults to us-east-1

Args:
b (object): A bucket object

Returns:
string: an aws region string


def get_vocab(self) -> Dict[str, int]:
    raise NotImplementedError()

Returns the vocabulary as a dictionary of token to index.

`tokenizer.get_vocab()[token]` is equivalent to `tokenizer.convert_tokens_to_ids(token)` when `token` is in the
vocab.

Returns:
`Dict[str, int]`: The vocabulary.


def _get_expiration(self, headers: dict) -> int:
    expiration_str = headers.get('expires')
    if (not expiration_str):
        return 0
    expiration = datetime.strptime(expiration_str, '%a, %d %b %Y %H:%M:%S %Z')
    delta = (expiration - datetime.utcnow()).total_seconds()
    return math.ceil(abs(delta))

Gets the expiration time of the data from the response headers.

Args:
headers: dictionary of headers from ESI

Returns:
value of seconds from now the data expires


def reactions_add(self, *, name: str, **kwargs) -> SlackResponse:

        kwargs.update({"name": name})
        return self.api_call("reactions.add", json=kwargs)

Adds a reaction to an item.

Args:
name (str): Reaction (emoji) name. e.g. 'thumbsup'
channel (str): Channel where the message to add reaction to was posted.
e.g. 'C1234567890'
timestamp (str): Timestamp of the message to add reaction to. e.g. '1234567890.123456'


class AriaCrossAttention(nn.Module):

    def __init__(self, config: AriaConfig, dropout_rate: float=0):
        super().__init__()
        hidden_size = config.vision_config.hidden_size
        num_heads = config.vision_config.num_attention_heads
        self.num_heads = num_heads
        self.q_proj = nn.Linear(hidden_size, hidden_size, bias=False)
        self.k_proj = nn.Linear(hidden_size, hidden_size, bias=False)
        self.v_proj = nn.Linear(hidden_size, hidden_size, bias=False)
        self.multihead_attn = nn.MultiheadAttention(hidden_size, num_heads, batch_first=True)
        self.linear = nn.Linear(hidden_size, hidden_size)
        self.dropout = nn.Dropout(dropout_rate)
        self.layer_norm = nn.LayerNorm(hidden_size)
        self.layer_norm_kv = nn.LayerNorm(hidden_size)

    def forward(self, key_value_states, hidden_states, attn_mask=None):

        query = self.q_proj(self.layer_norm(hidden_states))
        key_value_states = self.layer_norm_kv(key_value_states)
        key = self.k_proj(key_value_states)
        value = self.v_proj(key_value_states)
        attn_output, _ = self.multihead_attn(query, key, value, attn_mask=attn_mask)
        attn_output = self.dropout(self.linear(attn_output))
        return attn_output

Aria Cross-Attention module.

Args:
config (`AriaConfig`):
The configuration to use.


def __delete__(self, obj):

        if self.name in obj._property_values:
            old_value = obj._property_values[self.name]
            del obj._property_values[self.name]
            self.trigger_if_changed(obj, old_value)

        if self.name in obj._unstable_default_values:
            del obj._unstable_default_values[self.name]

Implement the deleter for the Python `descriptor protocol`_.

Args:
obj (HasProps) : An instance to delete this property from


def _validate_schema_and_ast(schema, ast):
    core_graphql_errors = validate(schema, ast)
    unsupported_default_directives = frozenset([frozenset(['include', frozenset(['FIELD', 'FRAGMENT_SPREAD', 'INLINE_FRAGMENT']), frozenset(['if'])]), frozenset(['skip', frozenset(['FIELD', 'FRAGMENT_SPREAD', 'INLINE_FRAGMENT']), frozenset(['if'])]), frozenset(['deprecated', frozenset(['ENUM_VALUE', 'FIELD_DEFINITION']), frozenset(['reason'])])])
    expected_directives = {frozenset([directive.name, frozenset(directive.locations), frozenset(six.viewkeys(directive.args))]) for directive in DIRECTIVES}
    actual_directives = {frozenset([directive.name, frozenset(directive.locations), frozenset(six.viewkeys(directive.args))]) for directive in schema.get_directives()}
    missing_directives = (expected_directives - actual_directives)
    if missing_directives:
        missing_message = u'The following directives were missing from the provided schema: {}'.format(missing_directives)
        core_graphql_errors.append(missing_message)
    extra_directives = ((actual_directives - expected_directives) - unsupported_default_directives)
    if extra_directives:
        extra_message = u'The following directives were supplied in the given schema, but are not not supported by the GraphQL compiler: {}'.format(extra_directives)
        core_graphql_errors.append(extra_message)
    return core_graphql_errors

Validate the supplied graphql schema and ast.

This method wraps around graphql-core's validation to enforce a stricter requirement of the
schema -- all directives supported by the compiler must be declared by the schema, regardless of
whether each directive is used in the query or not.

Args:
schema: GraphQL schema object, created using the GraphQL library
ast: abstract syntax tree representation of a graphql query

Returns:
list containing schema and/or query validation errors


async def evaluate_model(eval_model_path, target_model_path, sgf_dir, seed):
    lines = (await run('bazel-bin/cc/eval', '--flagfile={}'.format(os.path.join(FLAGS.flags_dir, 'eval.flags')), '--model={}'.format(eval_model_path), '--model_two={}'.format(target_model_path), '--sgf_dir={}'.format(sgf_dir), '--seed={}'.format(seed)))
    result = '\n'.join(lines[(- 7):])
    logging.info(result)
    (eval_stats, target_stats) = parse_win_stats_table(result, 2)
    num_games = (eval_stats.total_wins + target_stats.total_wins)
    win_rate = (eval_stats.total_wins / num_games)
    logging.info('Win rate %s vs %s: %.3f', eval_stats.model_name, target_stats.model_name, win_rate)
    return win_rate

Evaluate one model against a target.

Args:
eval_model_path: the path to the model to evaluate.
target_model_path: the path to the model to compare to.
sgf_dif: directory path to write SGF output to.
seed: random seed to use when running eval.

Returns:
The win-rate of eval_model against target_model in the range [0, 1].


def shape4d(a, data_format='NHWC'):
    s2d = shape2d(a)
    if (get_data_format(data_format, False) == 'NHWC'):
        return (([1] + s2d) + [1])
    else:
        return ([1, 1] + s2d)

Ensuer a 4D shape, to use with 4D symbolic functions.

Args:
a: a int or tuple/list of length 2

Returns:
list: of length 4. if ``a`` is a int, return ``[1, a, a, 1]``
or ``[1, 1, a, a]`` depending on data_format.


def _make_train_step_fn(model, mode, strategy, output_labels):

    def _step_fn(ctx, inputs):

        if isinstance(inputs, (tuple, list)) and len(inputs) == 2:
            inputs, targets = inputs
        else:
            targets = None
        if isinstance(inputs, dict):
            inputs = [inputs[input_name] for input_name in model._feed_input_names]
        _build_model(strategy, model, mode, inputs, targets)
        grouped_inputs, grouped_outputs, grouped_updates, grouped_session_args = strategy.extended.call_for_each_replica(_per_replica_execution_function, args=(dist_utils.get_distributed_model(model, mode), mode))
        all_inputs, all_outputs, all_updates, all_session_args = dist_utils.unwrap_values(strategy, grouped_inputs, grouped_outputs, grouped_updates, grouped_session_args)
        combined_fn = backend.function(all_inputs, all_outputs, updates=all_updates, name='distributed_' + str(mode) + '_function', **all_session_args)
        for label, output in zip(output_labels, combined_fn.outputs):
            if label == 'loss':
                reduce_op = ds_reduce_util.ReduceOp.SUM
            else:
                reduce_op = ds_reduce_util.ReduceOp.MEAN
            ctx.set_last_step_output(label, output, reduce_op)
        return combined_fn.updates_op
    return _step_fn

Create step fn.

Args:
model: a Keras Model instance.
mode: One of ModeKeys.TRAIN/ModeKeys.TEST/ModeKeys.PREDICT.
strategy: a `tf.distribute.Strategy` instance.
output_labels: the output labels for the step function.

Returns:
A step function to run by `tf.distribute.Strategy`.


def setup_spline(self, spline_options=None):
    self.spline_options = spline_options
    relative_energies = (self.energies - self.energies[0])
    if scipy_old_piecewisepolynomial:
        if self.spline_options:
            raise RuntimeError('Option for saddle point not available withold scipy implementation')
        self.spline = PiecewisePolynomial(self.r, np.array([relative_energies, (- self.forces)]).T, orders=3)
    elif (self.spline_options.get('saddle_point', '') == 'zero_slope'):
        imax = np.argmax(relative_energies)
        self.spline = CubicSpline(x=self.r[:(imax + 1)], y=relative_energies[:(imax + 1)], bc_type=((1, 0.0), (1, 0.0)))
        cspline2 = CubicSpline(x=self.r[imax:], y=relative_energies[imax:], bc_type=((1, 0.0), (1, 0.0)))
        self.spline.extend(c=cspline2.c, x=cspline2.x[1:])
    else:
        self.spline = CubicSpline(x=self.r, y=relative_energies, bc_type=((1, 0.0), (1, 0.0)))

Setup of the options for the spline interpolation

Args:
spline_options (dict): Options for cubic spline. For example,
{"saddle_point": "zero_slope"} forces the slope at the saddle to
be zero.


async def open_interface(self, client_id, conn_string, interface):
    conn_id = self._client_connection(client_id, conn_string)
    self._hook_open_interface(conn_string, interface, client_id)
    (await self.adapter.open_interface(conn_id, interface))

Open a device interface on behalf of a client.

See :meth:`AbstractDeviceAdapter.open_interface`.

Args:
client_id (str): The client we are working for.
conn_string (str): A connection string that will be
passed to the underlying device adapter.
interface (str): The name of the interface to open.

Raises:
DeviceServerError: There is an issue with your client_id such
as not being connected to the device.
DeviceAdapterError: The adapter had an issue opening the interface.


def __process_node(self, node: yaml.Node, expected_type: Type) -> yaml.Node:
    logger.info('Processing node {} expecting type {}'.format(node, expected_type))
    (recognized_types, message) = self.__recognizer.recognize(node, expected_type)
    if (len(recognized_types) != 1):
        raise RecognitionError(message)
    recognized_type = recognized_types[0]
    logger.debug('Savorizing node {}'.format(node))
    if (recognized_type in self._registered_classes.values()):
        node = self.__savorize(node, recognized_type)
    logger.debug('Savorized, now {}'.format(node))
    logger.debug('Recursing into subnodes')
    if is_generic_list(recognized_type):
        if (node.tag != 'tag:yaml.org,2002:seq'):
            raise RecognitionError('{}{}Expected a {} here'.format(node.start_mark, os.linesep, type_to_desc(expected_type)))
        for item in node.value:
            self.__process_node(item, generic_type_args(recognized_type)[0])
    elif is_generic_dict(recognized_type):
        if (node.tag != 'tag:yaml.org,2002:map'):
            raise RecognitionError('{}{}Expected a {} here'.format(node.start_mark, os.linesep, type_to_desc(expected_type)))
        for (_, value_node) in node.value:
            self.__process_node(value_node, generic_type_args(recognized_type)[1])
    elif (recognized_type in self._registered_classes.values()):
        if ((not issubclass(recognized_type, enum.Enum)) and (not issubclass(recognized_type, str)) and (not issubclass(recognized_type, UserString))):
            for (attr_name, type_, _) in class_subobjects(recognized_type):
                cnode = Node(node)
                if cnode.has_attribute(attr_name):
                    subnode = cnode.get_attribute(attr_name)
                    new_subnode = self.__process_node(subnode.yaml_node, type_)
                    cnode.set_attribute(attr_name, new_subnode)
    else:
        logger.debug('Not a generic class or a user-defined class, not recursing')
    node.tag = self.__type_to_tag(recognized_type)
    logger.debug('Finished processing node {}'.format(node))
    return node

Processes a node.

This is the main function that implements yatiml's \
functionality. It figures out how to interpret this node \
(recognition), then applies syntactic sugar, and finally \
recurses to the subnodes, if any.

Args:
node: The node to process.
expected_type: The type we expect this node to be.

Returns:
The transformed node, or a transformed copy.


def dframe(self, dimensions=None, multi_index=False):

        import pandas as pd
        if dimensions is None:
            dimensions = [d.name for d in self.dimensions()]
        else:
            dimensions = [self.get_dimension(d, strict=True).name for d in dimensions]
        column_names = dimensions
        dim_vals = OrderedDict([(dim, self.dimension_values(dim)) for dim in column_names])
        df = pd.DataFrame(dim_vals)
        if multi_index:
            df = df.set_index([d for d in dimensions if d in self.kdims])
        return df

Convert dimension values to DataFrame.

Returns a pandas dataframe of columns along each dimension,
either completely flat or indexed by key dimensions.

Args:
dimensions: Dimensions to return as columns
multi_index: Convert key dimensions to (multi-)index

Returns:
DataFrame of columns corresponding to each dimension


def get_header(graphs, proto_fileformat='rawproto', default_ops='NoOp:NoOp,_Recv:RecvOp,_Send:SendOp'):
    ops_and_kernels = get_ops_and_kernels(proto_fileformat, graphs, default_ops)
    if not ops_and_kernels:
        print('Error reading graph!')
        return 1
    return get_header_from_ops_and_kernels(ops_and_kernels, default_ops == 'all')

Computes a header for use with tensorflow SELECTIVE_REGISTRATION.

Args:
graphs: a list of paths to GraphDef files to include.
proto_fileformat: optional format of proto file, either 'textproto',
'rawproto' (default) or ops_list. The ops_list is the file contain the
list of ops in JSON format, Ex: "[["Transpose", "TransposeCpuOp"]]".
default_ops: optional comma-separated string of operator:kernel pairs to
always include implementation for. Pass 'all' to have all operators and
kernels included. Default: 'NoOp:NoOp,_Recv:RecvOp,_Send:SendOp'.

Returns:
the string of the header that should be written as ops_to_register.h.


def import_object_from_string_code(code, object):
    sha256 = hashlib.sha256(code.encode('UTF-8')).hexdigest()
    module = imp.new_module(sha256)
    try:
        exec_(code, module.__dict__)
    except Exception as e:
        raise exceptions.UserError('User code exception', exception_message=str(e))
    sys.modules[sha256] = module
    try:
        return getattr(module, object)
    except AttributeError:
        raise exceptions.UserError('{} not found in code'.format(object))

Used to import an object from arbitrary passed code.

Passed in code is treated as a module and is imported and added
to `sys.modules` with its SHA256 hash as key.

Args:
code (string): Python code to import as module

object (string): Name of object to extract from imported module


def batch_normalization(x, mean, var, beta, gamma, axis=-1, epsilon=0.001):
    if ndim(x) == 4:
        if axis == 1 or axis == -3:
            tf_data_format = 'NCHW'
        elif axis == 3 or axis == -1:
            tf_data_format = 'NHWC'
        else:
            tf_data_format = None
        if tf_data_format == 'NHWC' or (tf_data_format == 'NCHW' and _has_nchw_support()):
            if ndim(mean) > 1:
                mean = array_ops.reshape(mean, [-1])
            if ndim(var) > 1:
                var = array_ops.reshape(var, [-1])
            if beta is None:
                beta = zeros_like(mean)
            elif ndim(beta) > 1:
                beta = array_ops.reshape(beta, [-1])
            if gamma is None:
                gamma = ones_like(mean)
            elif ndim(gamma) > 1:
                gamma = array_ops.reshape(gamma, [-1])
        y, _, _ = nn.fused_batch_norm(x, gamma, beta, epsilon=epsilon, mean=mean, variance=var, data_format=tf_data_format, is_training=False)
        return y
    return nn.batch_normalization(x, mean, var, beta, gamma, epsilon)

Applies batch normalization on x given mean, var, beta and gamma.

I.e. returns:
`output = (x - mean) / (sqrt(var) + epsilon) * gamma + beta`

Args:
x: Input tensor or variable.
mean: Mean of batch.
var: Variance of batch.
beta: Tensor with which to center the input.
gamma: Tensor by which to scale the input.
axis: Integer, the axis that should be normalized.
(typically the features axis).
epsilon: Fuzz factor.

Returns:
A tensor.


def limit(self, count):

        return self.__class__(
            self._parent,
            projection=self._projection,
            field_filters=self._field_filters,
            orders=self._orders,
            limit=count,
            offset=self._offset,
            start_at=self._start_at,
            end_at=self._end_at,
        )

Limit a query to return a fixed number of results.

If the current query already has a limit set, this will overwrite it.

Args:
count (int): Maximum number of documents to return that match
the query.

Returns:
~.firestore_v1beta1.query.Query: A limited query. Acts as a
copy of the current query, modified with the newly added
"limit" filter.


def update_compliance(self, timeout=(- 1)):
    uri = '{}/compliance'.format(self.data['uri'])
    return self._helper.update(None, uri, timeout=timeout)

Returns logical interconnects to a consistent state. The current logical interconnect state is
compared to the associated logical interconnect group.

Any differences identified are corrected, bringing the logical interconnect back to a consistent
state. Changes are asynchronously applied to all managed interconnects. Note that if the changes detected
involve differences in the interconnect map between the logical interconnect group and the logical interconnect,
the process of bringing the logical interconnect back to a consistent state might involve automatically removing
existing interconnects from management and/or adding new interconnects for management.

Args:
timeout: Timeout in seconds. Wait for task completion by default. The timeout does not abort the operation
in OneView; it just stops waiting for its completion.

Returns:
dict: Logical Interconnect.


def dtype(self, value):

        for (dtype, string) in self._all:
            if string == value:
                return dtype

        return None

Gets the datatype for the given `value` (description).

Args:
value (str): A text description for any datatype.

Returns:
numpy.dtype: The matching datatype for the given text.
None: If no match can be found, `None` will be returned.


def transform_coords(self, width, height):

		if self.type not in {EventType.TOUCH_DOWN, EventType.TOUCH_MOTION}:
			raise AttributeError(_wrong_meth.format(self.type))
		x = self._libinput.libinput_event_touch_get_x_transformed(
			self._handle, width)
		y = self._libinput.libinput_event_touch_get_y_transformed(
			self._handle, height)
		return x, y

Return the current absolute coordinates of the touch event,
transformed to screen coordinates.

For events not of type :attr:`~libinput.constant.EventType.TOUCH_DOWN`,
:attr:`~libinput.constant.EventType.TOUCH_MOTION`, this method
raises :exc:`AttributeError`.

Args:
width (int): The current output screen width.
height (int): The current output screen height.
Returns:
(float, float): The current absolute (x, y) coordinates transformed
to screen coordinates.


def _CreateLineStringForShape(self, parent, shape):

    coordinate_list = [(longitude, latitude) for
                       (latitude, longitude, distance) in shape.points]
    return self._CreateLineString(parent, coordinate_list)

Create a KML LineString using coordinates from a shape.

Args:
parent: The parent ElementTree.Element instance.
shape: The transitfeed.Shape instance.

Returns:
The LineString ElementTree.Element instance or None if coordinate_list is
empty.


def pull_screenrecord(self, bit_rate: int = 5000000, time_limit: int = 180, remote: _PATH = '/sdcard/demo.mp4', local: _PATH = 'demo.mp4') -> None:

        self.screenrecord(bit_rate, time_limit, filename=remote)
        self.pull(remote, local)

Recording the display of devices running Android 4.4 (API level 19) and higher. Then copy it to your computer.

Args:
bit_rate:You can increase the bit rate to improve video quality, but doing so results in larger movie files.
time_limit: Sets the maximum recording time, in seconds, and the maximum value is 180 (3 minutes).


def add_role(user, roles):

    def _add_role(role):
        user_role = UserRole()
        user_role.user_id = user.user_id
        user_role.role_id = role.role_id
        db.session.add(user_role)
        db.session.commit()
    [_add_role(role) for role in roles]

Map roles for user in database

Args:
user (User): User to add roles to
roles ([Role]): List of roles to add

Returns:
None


def add_workflow_definitions(sbi_config: dict):

    registered_workflows = []
    for i in range(len(sbi_config['processing_blocks'])):
        workflow_config = sbi_config['processing_blocks'][i]['workflow']
        workflow_name = '{}:{}'.format(workflow_config['id'],
                                       workflow_config['version'])
        if workflow_name in registered_workflows:
            continue
        workflow_definition = dict(
            id=workflow_config['id'],
            version=workflow_config['version'],
            stages=[]
        )
        key = "workflow_definitions:{}:{}".format(workflow_config['id'],
                                                  workflow_config['version'])
        DB.save_dict(key, workflow_definition, hierarchical=False)
        registered_workflows.append(workflow_name)

Add any missing SBI workflow definitions as placeholders.

This is a utility function used in testing and adds mock / test workflow
definitions to the database for workflows defined in the specified
SBI config.

Args:
sbi_config (dict): SBI configuration dictionary.


def indices2nodes(self, indices):
    if (set(indices) - set(self.node_indices)):
        raise ValueError("`indices` must be a subset of the Subsystem's indices.")
    return tuple((self._index2node[n] for n in indices))

Return |Nodes| for these indices.

Args:
indices (tuple[int]): The indices in question.

Returns:
tuple[Node]: The |Node| objects corresponding to these indices.

Raises:
ValueError: If requested indices are not in the subsystem.


def create_or_update(cls, course_video, file_name=None, image_data=None, generated_images=None):
    (video_image, created) = cls.objects.get_or_create(course_video=course_video)
    if image_data:
        if ((not created) and (VideoImage.objects.filter(image=video_image.image).count() == 1)):
            video_image.image.delete()
        with closing(image_data) as image_file:
            file_name = '{uuid}{ext}'.format(uuid=uuid4().hex, ext=os.path.splitext(file_name)[1])
            try:
                video_image.image.save(file_name, image_file)
            except Exception:
                logger.exception('VAL: Video Image save failed to storage for course_id [%s] and video_id [%s]', course_video.course_id, course_video.video.edx_video_id)
                raise
    else:
        if generated_images:
            video_image.generated_images = generated_images
            if (not video_image.image.name):
                file_name = generated_images[0]
        video_image.image.name = file_name
    video_image.save()
    return (video_image, created)

Create a VideoImage object for a CourseVideo.

NOTE: If `image_data` is None then `file_name` value will be used as it is, otherwise
a new file name is constructed based on uuid and extension from `file_name` value.
`image_data` will be None in case of course re-run and export. `generated_images` list
contains names of images auto generated by VEDA. If an image is not already set then first
image name from `generated_images` list will be used.

Arguments:
course_video (CourseVideo): CourseVideo instance
file_name (str): File name of the image
image_data (InMemoryUploadedFile): Image data to be saved.
generated_images (list): auto generated image names

Returns:
Returns a tuple of (video_image, created).


def leave_module(self, node):

        for triple_quote in self._tokenized_triple_quotes.values():
            self._check_triple_quotes(triple_quote)

        self._tokenized_triple_quotes = {}

Leave module and check remaining triple quotes.

Args:
node: the module node we are leaving.


def commit_channel(self, channel_id):

        payload = {
            "channel_id":channel_id,
            "stage": config.STAGE,
        }
        response = config.SESSION.post(config.finish_channel_url(), data=json.dumps(payload))
        if response.status_code != 200:
            config.LOGGER.error("\n\nCould not activate channel: {}\n".format(response._content.decode('utf-8')))
            if response.status_code == 403:
                config.LOGGER.error("Channel can be viewed at {}\n\n".format(config.open_channel_url(channel_id, staging=True)))
                sys.exit()
        response.raise_for_status()
        new_channel = json.loads(response._content.decode("utf-8"))
        channel_link = config.open_channel_url(new_channel['new_channel'])
        return channel_id, channel_link

commit_channel: commits channel to Kolibri Studio
Args:
channel_id (str): channel's id on Kolibri Studio
Returns: channel id and link to uploadedchannel


def default_value(fieldname, datatype):

    if fieldname in tsdb_coded_attributes:
        return str(tsdb_coded_attributes[fieldname])
    else:
        return _default_datatype_values.get(datatype, '')

Return the default value for a column.

If the column name (e.g. *i-wf*) is defined to have an idiosyncratic
value, that value is returned. Otherwise the default value for the
column's datatype is returned.

Args:
fieldname: the column name (e.g. `i-wf`)
datatype: the datatype of the column (e.g. `:integer`)
Returns:
The default value for the column.

.. deprecated:: v0.7.0


def _get_cached_certs(cert_uri, cache):
    certs = cache.get(cert_uri, namespace=_CERT_NAMESPACE)
    if (certs is None):
        _logger.debug('Cert cache miss for %s', cert_uri)
        try:
            result = urlfetch.fetch(cert_uri)
        except AssertionError:
            return None
        if (result.status_code == 200):
            certs = json.loads(result.content)
            expiration_time_seconds = _get_cert_expiration_time(result.headers)
            if expiration_time_seconds:
                cache.set(cert_uri, certs, time=expiration_time_seconds, namespace=_CERT_NAMESPACE)
        else:
            _logger.error('Certs not available, HTTP request returned %d', result.status_code)
    return certs

Get certs from cache if present; otherwise, gets from URI and caches them.

Args:
cert_uri: URI from which to retrieve certs if cache is stale or empty.
cache: Cache of pre-fetched certs.

Returns:
The retrieved certs.


def _and_join(self, terms):
    if (len(terms) > 1):
        return ' AND '.join([self._or_join(t) for t in terms])
    else:
        return self._or_join(terms[0])

Joins terms using AND operator.

Args:
terms (list): terms to join

Examples:
self._and_join(['term1']) -> 'term1'
self._and_join(['term1', 'term2']) -> 'term1 AND term2'
self._and_join(['term1', 'term2', 'term3']) -> 'term1 AND term2 AND term3'

Returns:
str


def __init__(self, missing_modules: Collection[str]=()):
    if os.getenv('TYPESHED_HOME'):
        self._store = ExternalTypeshedFs(missing_file=self.MISSING_FILE)
    else:
        self._store = InternalTypeshedFs(missing_file=self.MISSING_FILE)
    self._missing = self._load_missing().union(missing_modules)
    self._stdlib_versions = self._load_stdlib_versions()
    self._third_party_packages = self._load_third_party_packages()

Initializer.

Args:
missing_modules: A collection of modules in the format
'stdlib/module_name', which will be combined with the contents of
MISSING_FILE to form a set of missing modules for which pytype will not
report errors.


def NetworkFee(self):
    if (self._network_fee is None):
        input = Fixed8(0)
        for coin_ref in self.References.values():
            if (coin_ref.AssetId == GetBlockchain().SystemCoin().Hash):
                input = (input + coin_ref.Value)
        output = Fixed8(0)
        for tx_output in self.outputs:
            if (tx_output.AssetId == GetBlockchain().SystemCoin().Hash):
                output = (output + tx_output.Value)
        self._network_fee = ((input - output) - self.SystemFee())
    return self._network_fee


def populate(projects_to_filter=None, group=None):
    if (projects_to_filter is None):
        projects_to_filter = []
    import benchbuild.projects as all_projects
    all_projects.discover()
    prjs = ProjectRegistry.projects
    if projects_to_filter:
        prjs = {}
        for filter_project in set(projects_to_filter):
            try:
                prjs.update({x: y for (x, y) in ProjectRegistry.projects.items(prefix=filter_project)})
            except KeyError:
                pass
    if group:
        groupkeys = set(group)
        prjs = {name: cls for (name, cls) in prjs.items() if (cls.GROUP in groupkeys)}
    return {x: prjs[x] for x in prjs if ((prjs[x].DOMAIN != 'debug') or (x in projects_to_filter))}

Populate the list of projects that belong to this experiment.

Args:
projects_to_filter (list(Project)):
List of projects we want to assign to this experiment.
We intersect the list of projects with the list of supported
projects to get the list of projects that belong to this
experiment.
group (list(str)):
In addition to the project filter, we provide a way to filter
whole groups.


def mesh_axis_to_cumprod(self, tensor_shape):
    tensor_layout = self.tensor_layout(tensor_shape)
    ma2ta = tensor_layout.mesh_axis_to_tensor_axis(self.ndims)
    ta2cumprod = tensor_shape.cumprod
    return [(None if (ta is None) else ta2cumprod[ta]) for ta in ma2ta]

For each mesh axis, give the product of previous tensor axes.

Args:
tensor_shape: Shape.

Returns:
list with length self.ndims where each element is an integer or None.


def expand_abbreviations(txt, fields):

    def _expand(matchobj):
        s = matchobj.group('var')
        if (s not in fields):
            matches = [x for x in fields if x.startswith(s)]
            if (len(matches) == 1):
                s = matches[0]
        return ('{%s}' % s)
    return re.sub(FORMAT_VAR_REGEX, _expand, txt)

Expand abbreviations in a format string.

If an abbreviation does not match a field, or matches multiple fields, it
is left unchanged.

Example:

>>> fields = ("hey", "there", "dude")
>>> expand_abbreviations("hello {d}", fields)
'hello dude'

Args:
txt (str): Format string.
fields (list of str): Fields to expand to.

Returns:
Expanded string.


def np_dtype(dtype):

    if dtype == 'float' or dtype == float or dtype == np.float32 or dtype == tf.float32:
        return np.float32
    elif dtype == np.float64 or dtype == tf.float64:
        return np.float64
    elif dtype == np.float16 or dtype == tf.float16:
        return np.float16
    elif dtype == 'int' or dtype == int or dtype == np.int32 or dtype == tf.int32:
        return np.int32
    elif dtype == np.int64 or dtype == tf.int64:
        return np.int64
    elif dtype == np.int16 or dtype == tf.int16:
        return np.int16
    elif dtype == 'bool' or dtype == bool or dtype == np.bool_ or dtype == tf.bool:
        return np.bool_
    else:
        raise TensorForceError("Error: Type conversion from type {} not supported.".format(str(dtype)))

Translates dtype specifications in configurations to numpy data types.
Args:
dtype: String describing a numerical type (e.g. 'float') or numerical type primitive.

Returns: Numpy data type


def Matches(self, file_entry, search_depth):
    if (self._location_segments is None):
        location_match = None
    else:
        location_match = self._CheckLocation(file_entry, search_depth)
        if (not location_match):
            return (False, location_match)
        if (search_depth != self._number_of_location_segments):
            return (False, location_match)
    match = self._CheckFileEntryType(file_entry)
    if ((match is not None) and (not match)):
        return (False, location_match)
    match = self._CheckIsAllocated(file_entry)
    if ((match is not None) and (not match)):
        return (False, location_match)
    return (True, location_match)

Determines if the file entry matches the find specification.

Args:
file_entry (FileEntry): file entry.
search_depth (int): number of location path segments to compare.

Returns:
tuple: contains:

bool: True if the file entry matches the find specification, False
otherwise.
bool: True if the location matches, False if not or None if no location
specified.


def draw_arc(self, x, y, r, start, end, color):

        check_int_err(lib.arcRGBA(self._ptr, x, y, r, start, end, color[0], color[1], color[2], color[3]))

Draw an arc.

Args:
x (int): The x coordinate of the center of the arc.
y (int): The y coordinate of the center of the arc.
r (int): The radius of the arc.
start (int): The start of the arc.
end (int): The end of the arc.
color (Tuple[int, int, int, int]): The color of the circle.

Raises:
SDLError: If an error is encountered.


def update_with_token(self, token_id: int) -> bool:
    if self.status != RequestStatus.DECODING:
        return False
    is_eos = token_id == self.eos_token_id and self.eos_token_id != -1
    is_max_len = self.generated_len() >= self.max_new_tokens
    if is_eos or is_max_len:
        self.status = RequestStatus.FINISHED
        return True
    return False

Update the request with a newly generated token and check for completion.

Args:
token_id: The token ID to add to the output sequence

Returns:
bool: True if the request is now complete, False otherwise


def get_proj_info(self, token):
    r = self.remote_utils.get_url((self.url() + '{}/info/'.format(token)))
    return r.json()

Return the project info for a given token.

Arguments:
token (str): Token to return information for

Returns:
JSON: representation of proj_info


def from_file(cls, filename="CTRL", **kwargs):

        with zopen(filename, "rt") as f:
            contents = f.read()
        return LMTOCtrl.from_string(contents, **kwargs)

Creates a CTRL file object from an existing file.

Args:
filename: The name of the CTRL file. Defaults to 'CTRL'.

Returns:
An LMTOCtrl object.


def diagonalize_real_symmetric_and_sorted_diagonal_matrices(symmetric_matrix: np.ndarray, diagonal_matrix: np.ndarray, *, rtol: float=1e-05, atol: float=1e-08, check_preconditions: bool=True) -> np.ndarray:
    if check_preconditions:
        if (np.any(np.imag(symmetric_matrix)) or (not predicates.is_hermitian(symmetric_matrix, rtol=rtol, atol=atol))):
            raise ValueError('symmetric_matrix must be real symmetric.')
        if ((not predicates.is_diagonal(diagonal_matrix, atol=atol)) or np.any(np.imag(diagonal_matrix)) or np.any((diagonal_matrix[(:(- 1), :(- 1))] < diagonal_matrix[(1:, 1:)]))):
            raise ValueError('diagonal_matrix must be real diagonal descending.')
        if (not predicates.commutes(diagonal_matrix, symmetric_matrix, rtol=rtol, atol=atol)):
            raise ValueError('Given matrices must commute.')

    def similar_singular(i, j):
        return np.allclose(diagonal_matrix[(i, i)], diagonal_matrix[(j, j)], rtol=rtol)
    ranges = _contiguous_groups(diagonal_matrix.shape[0], similar_singular)
    p = np.zeros(symmetric_matrix.shape, dtype=np.float64)
    for (start, end) in ranges:
        block = symmetric_matrix[(start:end, start:end)]
        p[(start:end, start:end)] = diagonalize_real_symmetric_matrix(block, rtol=rtol, atol=atol)
    return p

Returns an orthogonal matrix that diagonalizes both given matrices.

The given matrices must commute.
Guarantees that the sorted diagonal matrix is not permuted by the
diagonalization (except for nearly-equal values).

Args:
symmetric_matrix: A real symmetric matrix.
diagonal_matrix: A real diagonal matrix with entries along the diagonal
sorted into descending order.
rtol: Relative numeric error threshold.
atol: Absolute numeric error threshold.
check_preconditions: If set, verifies that the input matrices commute
and are respectively symmetric and diagonal descending.

Returns:
An orthogonal matrix P such that P.T @ symmetric_matrix @ P is diagonal
and P.T @ diagonal_matrix @ P = diagonal_matrix (up to tolerance).

Raises:
ValueError: Matrices don't meet preconditions (e.g. not symmetric).


def asin(cls, x: 'TensorFluent') -> 'TensorFluent':
    return cls._unary_op(x, tf.asin, tf.float32)

Returns a TensorFluent for the arcsin function.

Args:
x: The input fluent.

Returns:
A TensorFluent wrapping the arcsin function.


def _all_correct_list(array):

    if type(array) not in _ITERABLE_TYPES:
        return False

    for item in array:
        if not type(item) in _ITERABLE_TYPES:
            return False

        if len(item) != 2:
            return False

    return True

Make sure, that all items in `array` has good type and size.

Args:
array (list): Array of python types.

Returns:
True/False


def print_info(info_mapping):
    if (not info_mapping):
        return
    content_format = '{:<16} : {:<}\n'
    content = '\n==================== Output ====================\n'
    content += content_format.format('Variable', 'Value')
    content += content_format.format(('-' * 16), ('-' * 29))
    for (key, value) in info_mapping.items():
        if isinstance(value, (tuple, collections.deque)):
            continue
        elif isinstance(value, (dict, list)):
            value = json.dumps(value)
        elif (value is None):
            value = 'None'
        if is_py2:
            if isinstance(key, unicode):
                key = key.encode('utf-8')
            if isinstance(value, unicode):
                value = value.encode('utf-8')
        content += content_format.format(key, value)
    content += (('-' * 48) + '\n')
    logger.log_info(content)


def assertNumpyObjectTensorsRecursivelyEqual(self, a, b, msg):
    if isinstance(a, np.ndarray) and a.dtype == object:
        self.assertEqual(a.dtype, b.dtype, msg)
        self.assertEqual(a.shape, b.shape, msg)
        self.assertLen(a, len(b), msg)
        for a_val, b_val in zip(a, b):
            self.assertNumpyObjectTensorsRecursivelyEqual(a_val, b_val, msg)
    else:
        self.assertAllEqual(a, b, msg)

Check that two numpy arrays are equal.

For arrays with dtype=object, check values recursively to see if a and b
are equal.  (c.f. `np.array_equal`, which checks dtype=object values using
object identity.)

Args:
a: A numpy array.
b: A numpy array.
msg: Message to display if a != b.


def load_schema(schema_path):
    try:
        with open(schema_path) as schema_file:
            schema = json.load(schema_file)
    except ValueError as e:
        raise SchemaInvalidError(('Invalid JSON in schema or included schema: %s\n%s' % (schema_file.name, str(e))))
    return schema

Load the JSON schema at the given path as a Python object.

Args:
schema_path: A filename for a JSON schema.

Returns:
A Python object representation of the schema.


def create_profile(profile_name):

    try:
        profile = Profile(profile_name=profile_name)
        profile.full_clean()
        profile.save()
    except ValidationError as err:
        raise ValCannotCreateError(err.message_dict)

Used to create Profile objects in the database

A profile needs to exists before an EncodedVideo object can be created.

Args:
profile_name (str): ID of the profile

Raises:
ValCannotCreateError: Raised if the profile name is invalid or exists


def from_http(cls, raw_body: MutableMapping, verification_token: Optional[str]=None, team_id: Optional[str]=None) -> 'Event':
    if (verification_token and (raw_body['token'] != verification_token)):
        raise exceptions.FailedVerification(raw_body['token'], raw_body['team_id'])
    if (team_id and (raw_body['team_id'] != team_id)):
        raise exceptions.FailedVerification(raw_body['token'], raw_body['team_id'])
    if raw_body['event']['type'].startswith('message'):
        return Message(raw_body['event'], metadata=raw_body)
    else:
        return Event(raw_body['event'], metadata=raw_body)

Create an event with data coming from the HTTP Event API.

If the event type is a message a :class:`slack.events.Message` is returned.

Args:
raw_body: Decoded body of the Event API request
verification_token: Slack verification token used to verify the request came from slack
team_id: Verify the event is for the correct team

Returns:
:class:`slack.events.Event` or :class:`slack.events.Message`

Raises:
:class:`slack.exceptions.FailedVerification`: when `verification_token` or `team_id` does not match the
incoming event's.


def decrypt(key, ciphertext):

    key = ''.join(key)
    alphabet = string.ascii_letters
    cipher_alphabet = key.lower() + key.upper()
    return ciphertext.translate(str.maketrans(cipher_alphabet, alphabet))

Decrypt Simple Substitution enciphered ``ciphertext`` using ``key``.

Example:
>>> decrypt("PQSTUVWXYZCODEBRAKINGFHJLM", "XUOOB")
HELLO

Args:
key (iterable): The key to use
ciphertext (str): The text to decrypt

Returns:
Decrypted ciphertext


def shape_rb_data(raw_rb):
    rb_data = []
    rb_data.append(np.mean(raw_rb, 0))
    rb_data.append(np.std(raw_rb, 0))
    return rb_data

Take the raw rb data and convert it into averages and std dev

Args:
raw_rb (numpy.array): m x n x l list where m is the number of seeds, n
is the number of Clifford sequences and l is the number of qubits

Return:
numpy_array: 2 x n x l list where index 0 is the mean over seeds, 1 is
the std dev overseeds


def is_installed(name):
    out = __salt__['cmd.run_all'](((FLATPAK_BINARY_NAME + ' info ') + name))
    if (out['retcode'] and out['stderr']):
        return False
    else:
        return True

Determine if a package or runtime is installed.

Args:
name (str): The name of the package or the runtime.

Returns:
bool: True if the specified package or runtime is installed.

CLI Example:

.. code-block:: bash

salt '*' flatpak.is_installed org.gimp.GIMP


def bonds(lines, atoms):
    conv_stereo_table = {0: 0, 1: 1, 3: 3, 4: 3, 6: 2}
    results = {a: {} for a in atoms}
    for line in lines:
        bond = Bond()
        first = int(line[0:3])
        second = int(line[3:6])
        if (first > second):
            bond.is_lower_first = 0
        order = int(line[6:9])
        if (order < 4):
            bond.order = order
        bond.type = conv_stereo_table[int(line[9:12])]
        results[first][second] = {'bond': bond}
        results[second][first] = {'bond': bond}
    return results

Parse bond block into bond objects

Returns:
dict: networkx adjacency dict


def CopyFromDateTimeString(self, time_string):

    date_time_values = self._CopyDateTimeFromString(time_string)

    year = date_time_values.get('year', 0)
    month = date_time_values.get('month', 0)
    day_of_month = date_time_values.get('day_of_month', 0)
    hours = date_time_values.get('hours', 0)
    minutes = date_time_values.get('minutes', 0)
    seconds = date_time_values.get('seconds', 0)

    self._normalized_timestamp = None
    self._number_of_seconds = self._GetNumberOfSecondsFromElements(
        year, month, day_of_month, hours, minutes, seconds)
    self._microseconds = date_time_values.get('microseconds', None)

    self.is_local_time = False

Copies a fake timestamp from a date and time string.

Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##

Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.


def config_stdio(self, log_configurations: Optional[List[LogConfiguration]] = None, default_level=logging.INFO) -> None:

        if not log_configurations:
            for logger in self.loggers.values():
                self._restrict_output(logger, default_level)

        else:
            for component, level in log_configurations:
                try:
                    logger = self.loggers[self.root + component]
                except KeyError:
                    raise ValueError("Failed to configure component. Invalid name: {}".format(component))
                self._restrict_output(logger, level)

Configure the stdio `StreamHandler` levels on the specified loggers.
If no log configurations are specified then the `default_level` will be applied to all handlers.

Args:
log_configurations: a list of (component name, log level) tuples
default_level: logging level to apply when no log_configurations are specified


def add_behaviour(self, behaviour, template=None):
    behaviour.set_agent(self)
    if issubclass(type(behaviour), FSMBehaviour):
        for (_, state) in behaviour.get_states().items():
            state.set_agent(self)
    behaviour.set_template(template)
    self.behaviours.append(behaviour)
    if self.is_alive():
        behaviour.start()

Adds and starts a behaviour to the agent.
If template is not None it is used to match
new messages and deliver them to the behaviour.

Args:
behaviour (spade.behaviour.CyclicBehaviour): the behaviour to be started
template (spade.template.Template, optional): the template to match messages with (Default value = None)


def wait(self, timeout_ms=None):
    closed = timeouts.loop_until_timeout_or_true(timeouts.PolledTimeout.from_millis(timeout_ms), self.stream.is_closed, 0.1)
    if closed:
        if hasattr(self.stdout, 'getvalue'):
            return self.stdout.getvalue()
        return True
    return None

Block until this command has completed.

Args:
timeout_ms: Timeout, in milliseconds, to wait.

Returns:
Output of the command if it complete and self.stdout is a StringIO
object or was passed in as None.  Returns True if the command completed but
stdout was provided (and was not a StringIO object).  Returns None if the
timeout expired before the command completed.  Be careful to check the
return value explicitly for None, as the output may be ''.


def _backspaced_single_line_animation(animation_, *args, **kwargs):
    animation_gen = animation_(*args, **kwargs)
    (yield next(animation_gen))
    (yield from util.concatechain(util.BACKSPACE_GEN(kwargs['width']), animation_gen))

Turn an animation into an automatically backspaced animation.

Args:
animation: A function that returns a generator that yields
strings for animation frames.
args: Arguments for the animation function.
kwargs: Keyword arguments for the animation function.
Returns:
the animation generator, with backspaces applied to each but the first
frame.


def rms_forward(hidden_states, variance_epsilon=1e-06):
    input_dtype = hidden_states.dtype
    hidden_states = hidden_states.to(torch.float32)
    variance = hidden_states.pow(2).mean(-1, keepdim=True)
    hidden_states = hidden_states * torch.rsqrt(variance + variance_epsilon)
    return hidden_states.to(input_dtype)

Calculates simple RMSNorm with no learnable weights. `MambaRMSNorm` will
leverage this in order to multiply the final result with the RMSNorm weight

Args:
hidden_states (`torch.Tensor`):
Hidden states to normalize
variance_epsilon (`float`):
The eps value to add in the square root scaling factor


def _find_max_under_constraint(self, constrained, dependent, predicate):
    feasible = ops.nonzero(predicate(constrained, self.value))
    feasible_exists = ops.greater(ops.size(feasible), 0)
    max_dependent = ops.max(ops.take(dependent, feasible), initial=0)
    return ops.where(feasible_exists, max_dependent, 0.0)

Returns the maximum of dependent_statistic that satisfies the
constraint.

Args:
constrained: Over these values the constraint is specified. A rank-1
tensor.
dependent: From these values the maximum that satiesfies the
constraint is selected. Values in this tensor and in
`constrained` are linked by having the same threshold at each
position, hence this tensor must have the same shape.
predicate: A binary boolean functor to be applied to arguments
`constrained` and `self.value`, e.g. `ops.greater`.

Returns:
maximal dependent value, if no value satisfies the constraint 0.0.


def __init__(self, graph, run_metadata):
    self._graph = graph
    self._run_metadata = run_metadata
    self._string_table = StringTable()
    self._functions = Functions(self._string_table)
    self._locations = Locations(self._functions)

Constructor.

Args:
graph: A `Graph` instance.
run_metadata: A list of `RunMetadata` objects.


def parse_yaml_file(self, yaml_file: Union[str, os.PathLike], allow_extra_keys: bool=False) -> tuple[DataClass, ...]:
    outputs = self.parse_dict(yaml.safe_load(Path(yaml_file).read_text()), allow_extra_keys=allow_extra_keys)
    return tuple(outputs)

Alternative helper method that does not use `argparse` at all, instead loading a yaml file and populating the
dataclass types.

Args:
yaml_file (`str` or `os.PathLike`):
File name of the yaml file to parse
allow_extra_keys (`bool`, *optional*, defaults to `False`):
Defaults to False. If False, will raise an exception if the json file contains keys that are not
parsed.

Returns:
Tuple consisting of:

- the dataclass instances in the same order as they were passed to the initializer.


def strip_strings(model):
    model.description = None
    for subgraph in model.subgraphs:
        subgraph.name = None
        for tensor in subgraph.tensors:
            tensor.name = None
    model.signatureDefs = None

Strips all nonessential strings from the model to reduce model size.

We remove the following strings:
(find strings by searching ":string" in the tensorflow lite flatbuffer schema)
1. Model description
2. SubGraph name
3. Tensor names
We retain OperatorCode custom_code and Metadata name.

Args:
model: The model from which to remove nonessential strings.


def __item_descriptor(self, config):

    descriptor = {
        'kind': 'discovery
        'icons': {
            'x16': 'https:
                   'googleg_16dp.png',
            'x32': 'https:
                   'googleg_32dp.png',
        },
        'preferred': True,
    }

    description = config.get('description')
    root_url = config.get('root')
    name = config.get('name')
    version = config.get('api_version')
    relative_path = '/apis/{0}/{1}/rest'.format(name, version)

    if description:
      descriptor['description'] = description

    descriptor['name'] = name
    descriptor['version'] = version
    descriptor['discoveryLink'] = '.{0}'.format(relative_path)

    root_url_port = urlparse.urlparse(root_url).port

    original_path = self.__request.reconstruct_full_url(
        port_override=root_url_port)
    descriptor['discoveryRestUrl'] = '{0}/{1}/{2}/rest'.format(
        original_path, name, version)

    if name and version:
      descriptor['id'] = '{0}:{1}'.format(name, version)

    return descriptor

Builds an item descriptor for a service configuration.

Args:
config: A dictionary containing the service configuration to describe.

Returns:
A dictionary that describes the service configuration.


def circuit_to_image(circ: Circuit, qubits: Qubits=None) -> PIL.Image:
    latex = circuit_to_latex(circ, qubits)
    img = render_latex(latex)
    return img

Create an image of a quantum circuit.

A convenience function that calls circuit_to_latex() and render_latex().

Args:
circ:       A quantum Circuit
qubits:     Optional qubit list to specify qubit order

Returns:
Returns: A PIL Image (Use img.show() to display)

Raises:
NotImplementedError: For unsupported gates.
OSError: If an external dependency is not installed.


def mach60(msg):

    d = hex2bin(data(msg))

    if d[23] == '0':
        return None

    mach = bin2int(d[24:34]) * 2.048 / 512.0
    return round(mach, 3)

Aircraft MACH number

Args:
msg (String): 28 bytes hexadecimal message (BDS60) string

Returns:
float: MACH number


def output_file_for(window, shard, pane):
    filename = '%s/LOG-%s-%s-%03d-%s' % (output_path, window.max_timestamp(), shard, pane.index, pane.timing) if output_path else None
    return OutputFile(window.max_timestamp(), shard, pane.index, pane.timing, filename)

Returns:
an OutputFile object constructed with pane, window and shard.


def on_modified(self, event):
    self._logger.debug('Detected modify event on watched path: %s', event.src_path)
    self._process_event(event)

Function called everytime a new file is modified.

Args:
event: Event to process.


def __init__(self, default: typing.Optional[int]=MISSING_VALUE, min_value: typing.Optional[int]=None, max_value: typing.Optional[int]=None, is_noneable: bool=False, frozen: bool=False):
    super().__init__(int, default, min_value, max_value, is_noneable, frozen)

Constructor.

Args:
default: (Optional) default value for this spec.
min_value: (Optional) minimum value of acceptable values.
max_value: (Optional) maximum value of acceptable values.
is_noneable: If True, None is acceptable.
frozen: If True, values other than the default value is not accceptable.


def recipe_dt(config, auth_read, auth_write, bucket, paths, days, hours, dataset):
    dt(config, {'auth': auth_read, 'from': {'bucket': bucket, 'paths': paths, 'days': days, 'hours': hours}, 'to': {'auth': auth_write, 'dataset': dataset}})

Move data from a DT bucket into a BigQuery table.

Args:
auth_read (authentication) - Credentials used for reading data.
auth_write (authentication) - Credentials used for writing data.
bucket (string) - Name of bucket where DT files are stored.
paths (string_list) - List of prefixes to pull specific DT files.
days (integer) - Number of days back to synchronize.
hours (integer) - Number of hours back to synchronize.
dataset (string) - Existing dataset in BigQuery.


def _FormatValue(self, value, level=0):

    def FormatDictItem(key_value):

      key, value = key_value
      return (self._FormatValue(key, level + 1) +
              ': ' +
              self._FormatValue(value, level + 1))

    def LimitedEnumerate(items, formatter, level=0):

      count = 0
      limit = self.max_sublist_items if level > 0 else self.max_list_items
      for item in items:
        if count == limit:
          yield '...'
          break

        yield formatter(item)
        count += 1

    def FormatList(items, formatter, level=0):

      return ', '.join(LimitedEnumerate(items, formatter, level=level))

    if isinstance(value, _PRIMITIVE_TYPES):
      return _TrimString(repr(value),
                         self.max_value_len)

    if isinstance(value, _DATE_TYPES):
      return str(value)

    if level > self.max_depth:
      return str(type(value))

    if isinstance(value, dict):
      return '{' + FormatList(six.iteritems(value), FormatDictItem) + '}'

    if isinstance(value, _VECTOR_TYPES):
      return _ListTypeFormatString(value).format(FormatList(
          value, lambda item: self._FormatValue(item, level + 1), level=level))

    if isinstance(value, types.FunctionType):
      return 'function ' + value.__name__

    if hasattr(value, '__dict__') and value.__dict__:
      return self._FormatValue(value.__dict__, level)

    return str(type(value))

Pretty-prints an object for a logger.

This function is very similar to the standard pprint. The main difference
is that it enforces limits to make sure we never produce an extremely long
string or take too much time.

Args:
value: Python object to print.
level: current recursion level.

Returns:
Formatted string.


def softplus(x, scale=1.0, name=None):
    if (scale == 1):
        return tf.nn.softplus(x)
    else:
        with tf.name_scope(name, 'softplus', [x]):
            scale = tf.convert_to_tensor(scale, dtype=x.dtype.base_dtype)
            return (tf.nn.softplus((x * scale)) / scale)

Computes softplus with a scale factor to sharpen of the hinge.

This is an alternate non-linearity to relu. It has a similar shape, but
it has a smooth transition from the linear part to 0.

Args:
x: A tensor.
scale: A float that sharpens the curve.
name: Optional name.
Returns:
y = log(1 + exp(scale * x)) / scale


def read_binary(self, key, b64decode=True, decode=False):
    data = None
    if (key is not None):
        data = self.db.read(key.strip())
        if (data is not None):
            data = json.loads(data)
            if b64decode:
                data = base64.b64decode(data)
                if decode:
                    try:
                        data = data.decode('utf-8')
                    except UnicodeDecodeError:
                        data = data.decode('latin-1')
    else:
        self.tcex.log.warning(u'The key field was None.')
    return data

Read method of CRUD operation for binary data.

Args:
key (string): The variable to read from the DB.
b64decode (bool): If true the data will be base64 decoded.
decode (bool): If true the data will be decoded to a String.

Returns:
(bytes|string): Results retrieved from DB.


def initialize_tpu_system_impl(cluster_resolver, tpu_cluster_resolver_cls):
    if tpu_cluster_resolver_cls is None or not issubclass(tpu_cluster_resolver_cls, cluster_resolver_lib.ClusterResolver) or (not hasattr(tpu_cluster_resolver_cls, 'tpu_hardware_feature')):
        raise TypeError('tpu_cluster_resolver_cls is not tf.distribute.cluster_resolver.TPUClusterResolver.')
    logging.info('Deallocate tpu buffers before initializing tpu system.')
    context.context()._clear_caches()
    context.context().clear_kernel_cache()
    gc.collect()
    job = None
    if cluster_resolver is None:
        if context.executing_eagerly():
            curr_device = device.DeviceSpec.from_string(context.context().device_name)
            if curr_device.job is not None:
                job = '{}/replica:0/task:0'.format(curr_device.job)
        cluster_resolver = tpu_cluster_resolver_cls('')
    assert isinstance(cluster_resolver, tpu_cluster_resolver_cls)
    tpu_name = compat.as_text(cluster_resolver._tpu)
    if tpu_name in _INITIALIZED_TPU_SYSTEMS:
        logging.warning('TPU system %s has already been initialized. Reinitializing the TPU can cause previously created variables on TPU to be lost.', tpu_name)
    logging.info('Initializing the TPU system: %s', tpu_name)
    if tpu_name not in _LOCAL_MASTERS:
        job = '{}/replica:0/task:0'.format(cluster_resolver.get_job_name())
    if context.executing_eagerly():

        @def_function.function(autograph=False)
        def _tpu_init_fn():
            return tpu.initialize_system(job=job, compilation_failure_closes_chips=False, tpu_cancellation_closes_chips=False)
        run_eagerly = def_function.functions_run_eagerly()
        if run_eagerly:
            logging.warning('It looks like tf.function behavior was disabled, perhaps using tf.config.run_functions_eagerly. tf.tpu.experimental.initialize_tpu_system requires tf.function to work. This primitive will override the disable.')
            def_function.run_functions_eagerly(False)
        try:
            with ops.device(tpu._tpu_system_device_name(job)):
                output = _tpu_init_fn()
            context.async_wait()
        except errors.InvalidArgumentError as e:
            raise errors.NotFoundError(None, None, 'TPUs not found in the cluster. Failed in initialization: ' + str(e))
        finally:
            if run_eagerly is not None:
                def_function.run_functions_eagerly(run_eagerly)
        context.context()._initialize_logical_devices()
        serialized_topology = output.numpy()
    elif not ops.executing_eagerly_outside_functions():
        master = cluster_resolver.master()
        cluster_spec = cluster_resolver.cluster_spec()
        session_config = config_pb2.ConfigProto(allow_soft_placement=True)
        if cluster_spec:
            session_config.cluster_def.CopyFrom(cluster_spec.as_cluster_def())
        with ops.Graph().as_default():
            with session_lib.Session(config=session_config, target=master) as sess:
                serialized_topology = sess.run(tpu.initialize_system())
    else:
        with ops.device(tpu._tpu_system_device_name(job)):
            serialized_topology = tpu.initialize_system(job=job, compilation_failure_closes_chips=False)
            return serialized_topology
    logging.info('Finished initializing TPU system.')
    tpu_topology = topology.Topology(serialized=serialized_topology)
    cluster_resolver.set_tpu_topology(serialized_topology)
    _INITIALIZED_TPU_SYSTEMS[tpu_name] = tpu_topology
    _tpu_worker_address.get_cell('address').set(cluster_resolver.get_master())
    return tpu_topology

Implementation for tpu.experimental.initialize_tpu_system.

Kept separate to avoid tpu_oss code duplication.

Initialize the TPU devices.

Args:
cluster_resolver: A tf.distribute.cluster_resolver.TPUClusterResolver,
which provides information about the TPU cluster.
tpu_cluster_resolver_cls: a reference to
tf.distribute.cluster_resolver.TPUClusterResolver so that an instance
of it can be initialized if cluster_resolver is None.
Returns:
The tf.tpu.Topology object for the topology of the TPU cluster. If called
inside tf.function, it returns the serialized topology object instead.

Raises:
RuntimeError: If running inside a tf.function.
NotFoundError: If no TPU devices found in eager mode.
TypeError: If tpu_cluster_resolver_cls is
not tf.distribute.cluster_resolver.TPUClusterResolver.


def _flatten_subsection(subsection, _type, offset, parent):
    for row in subsection:
        if (row in ('Low', 'Generated', 'High')):
            continue
        elif isinstance(row[0], StringType):
            if (len(row) in (4, 5)):
                if (len(row) == 5):
                    assert (row[4][0] == 'S'), ('Only known usage of a fifth member is Sn, found: %s' % row[4][0])
                (yield (float(row[0]), float(row[1]), float(row[2]), (float(row[3]) / 2.0), _type, offset, parent))
                parent = offset
                offset += 1
        elif isinstance(row[0], list):
            split_parent = (offset - 1)
            start_offset = 0
            slices = []
            start = 0
            for (i, value) in enumerate(row):
                if (value == '|'):
                    slices.append(slice((start + start_offset), i))
                    start = (i + 1)
            slices.append(slice((start + start_offset), len(row)))
            for split_slice in slices:
                for _row in _flatten_subsection(row[split_slice], _type, offset, split_parent):
                    offset += 1
                    (yield _row)

Flatten a subsection from its nested version

Args:
subsection: Nested subsection as produced by _parse_section, except one level in
_type: type of section, ie: AXON, etc
parent: first element has this as it's parent
offset: position in the final array of the first element

Returns:
Generator of values corresponding to [X, Y, Z, R, TYPE, ID, PARENT_ID]


def plot(self, figsize=None, rotation=45):
    (fig, ax) = plt.subplots(figsize=figsize)
    plt.imshow(self._cm, interpolation='nearest', cmap=plt.cm.Blues, aspect='auto')
    plt.title('Confusion matrix')
    plt.colorbar()
    tick_marks = np.arange(len(self._labels))
    plt.xticks(tick_marks, self._labels, rotation=rotation)
    plt.yticks(tick_marks, self._labels)
    if isinstance(self._cm, list):
        thresh = (max(max(self._cm)) / 2.0)
        for (i, j) in itertools.product(range(len(self._labels)), range(len(self._labels))):
            plt.text(j, i, self._cm[i][j], horizontalalignment='center', color=('white' if (self._cm[i][j] > thresh) else 'black'))
    else:
        thresh = (self._cm.max() / 2.0)
        for (i, j) in itertools.product(range(len(self._labels)), range(len(self._labels))):
            plt.text(j, i, self._cm[(i, j)], horizontalalignment='center', color=('white' if (self._cm[(i, j)] > thresh) else 'black'))
    plt.tight_layout()
    plt.ylabel('True label')
    plt.xlabel('Predicted label')

Plot the confusion matrix.

Args:
figsize: tuple (x, y) of ints. Sets the size of the figure
rotation: the rotation angle of the labels on the x-axis.


def authenticate(self, auth_token, auth_info, service_name):
    try:
        jwt_claims = self.get_jwt_claims(auth_token)
    except Exception as error:
        raise suppliers.UnauthenticatedException(u'Cannot decode the auth token', error)
    _check_jwt_claims(jwt_claims)
    user_info = UserInfo(jwt_claims)
    issuer = user_info.issuer
    if (issuer not in self._issuers_to_provider_ids):
        raise suppliers.UnauthenticatedException((u'Unknown issuer: ' + issuer))
    provider_id = self._issuers_to_provider_ids[issuer]
    if (not auth_info.is_provider_allowed(provider_id)):
        raise suppliers.UnauthenticatedException((u'The requested method does not allow provider id: ' + provider_id))
    audiences = user_info.audiences
    has_service_name = (service_name in audiences)
    allowed_audiences = auth_info.get_allowed_audiences(provider_id)
    intersected_audiences = set(allowed_audiences).intersection(audiences)
    if ((not has_service_name) and (not intersected_audiences)):
        raise suppliers.UnauthenticatedException(u'Audiences not allowed')
    return user_info

Authenticates the current auth token.

Args:
auth_token: the auth token.
auth_info: the auth configurations of the API method being called.
service_name: the name of this service.

Returns:
A constructed UserInfo object representing the identity of the caller.

Raises:
UnauthenticatedException: When
* the issuer is not allowed;
* the audiences are not allowed;
* the auth token has already expired.


def insert(self, fields, typecast=False):

        return self._post(self.url_table, json_data={"fields": fields, "typecast": typecast})

Inserts a record

>>> record = {'Name': 'John'}
>>> airtable.insert(record)

Args:
fields(``dict``): Fields to insert.
Must be dictionary with Column names as Key.
typecast(``boolean``): Automatic data conversion from string values.

Returns:
record (``dict``): Inserted record


def get_image_features(self, pixel_values: torch.FloatTensor, image_grid_thw: Optional[torch.LongTensor]=None):
    pixel_values = pixel_values.type(self.visual.dtype)
    image_embeds = self.visual(pixel_values, grid_thw=image_grid_thw)
    split_sizes = (image_grid_thw.prod(-1)
    image_embeds = torch.split(image_embeds, split_sizes)
    return image_embeds

Encodes images into continuous embeddings that can be forwarded to the language model.

Args:
pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
The tensors corresponding to the input images.
image_grid_thw (`torch.LongTensor` of shape `(num_images, 3)`, *optional*):
The temporal, height and width of feature shape of each image in LLM.


def _AddExtractionProcessStatusTableRow(self, process_status, table_view):
    used_memory = self._FormatSizeInUnitsOf1024(process_status.used_memory)
    sources = ''
    if ((process_status.number_of_produced_sources is not None) and (process_status.number_of_produced_sources_delta is not None)):
        sources = '{0:d} ({1:d})'.format(process_status.number_of_produced_sources, process_status.number_of_produced_sources_delta)
    events = ''
    if ((process_status.number_of_produced_events is not None) and (process_status.number_of_produced_events_delta is not None)):
        events = '{0:d} ({1:d})'.format(process_status.number_of_produced_events, process_status.number_of_produced_events_delta)
    table_view.AddRow([process_status.identifier, process_status.pid, process_status.status, used_memory, sources, events, process_status.display_name])

Adds an extraction process status table row.

Args:
process_status (ProcessStatus): processing status.
table_view (CLITabularTableView): table view.


def __init__(self, points, joggle=False):

        self.points = points
        dim = [len(i) for i in self.points]
        if max(dim) != min(dim):
            raise ValueError("Input points must all have the same dimension!")
        self.dim = dim[0]
        if joggle:
            options = "i QJ"
        else:
            options = "i Qt"
        output = qdelaunay(options, points)
        output.pop(0)
        self.vertices = [[int(i)for i in row.strip().split()] for row in output]

Initializes a DelaunayTri from points.

Args:
points ([[float]]): All the points as a sequence of sequences.
e.g., [[-0.5, -0.5], [-0.5, 0.5], [0.5, -0.5], [0.5, 0.5]]
joggle (bool): Use qhull option to joggle inputs until simplical
result is obtained instead of merging facets.


def render_trees(trees, path_composer):
    trees = list(trees)

    def create_pub_cache(trees):
        "\n        Create uuid -> DBPublication cache from all uuid's linked from `trees`.\n\n        Args:\n            trees (list): List of :class:`.Tree`.\n\n        Returns:\n            dict: {uuid: DBPublication}\n        "
        sub_pubs_uuids = sum((x.collect_publications() for x in trees), [])
        uuid_mapping = {uuid: search_pubs_by_uuid(uuid) for uuid in set(sub_pubs_uuids)}
        return {uuid: pub[0] for (uuid, pub) in uuid_mapping.iteritems() if pub}
    pub_cache = create_pub_cache(trees)

    def render_tree(tree, ind=1):
        '\n        Render the tree into HTML using :attr:`TREE_TEMPLATE`. Private trees\n        are ignored.\n\n        Args:\n            tree (obj): :class:`.Tree` instance.\n            ind (int, default 1): Indentation. This function is called\n                recursively.\n\n        Returns:\n            str: Rendered string.\n        '
        if (not tree.is_public):
            return ''
        rendered_tree = SimpleTemplate(TREE_TEMPLATE).render(tree=tree, render_tree=render_tree, ind=ind, path_composer=path_composer, pub_cache=pub_cache)
        ind_txt = (ind * '  ')
        return (ind_txt + ('\n' + ind_txt).join(rendered_tree.splitlines()))
    parent = tree_handler().get_parent(trees[0])
    link_up = (path_composer(parent) if parent else None)
    return SimpleTemplate(TREES_TEMPLATE).render(trees=trees, render_tree=render_tree, link_up=link_up)

Render list of `trees` to HTML.

Args:
trees (list): List of :class:`.Tree`.
path_composer (fn reference): Function used to compose paths from UUID.
Look at :func:`.compose_tree_path` from :mod:`.web_tools`.

Returns:
str: HTML representation of trees.


def _AddSerializedEvent(self, event):

    identifier = identifiers.SQLTableIdentifier(
        self._CONTAINER_TYPE_EVENT,
        self._serialized_event_heap.number_of_events + 1)
    event.SetIdentifier(identifier)

    serialized_data = self._SerializeAttributeContainer(event)

    self._serialized_event_heap.PushEvent(event.timestamp, serialized_data)

    if self._serialized_event_heap.data_size > self._maximum_buffer_size:
      self._WriteSerializedAttributeContainerList(self._CONTAINER_TYPE_EVENT)

Adds an serialized event.

Args:
event (EventObject): event.

Raises:
IOError: if the event cannot be serialized.
OSError: if the event cannot be serialized.


def add_comment(self, line):

        if not isinstance(self.last_item, Comment):
            comment = Comment(self._structure)
            self._structure.append(comment)
        self.last_item.add_line(line)
        return self

Add a Comment object to the section

Used during initial parsing mainly

Args:
line (str): one line in the comment


def start(self) -> asyncio.Future:
    if (os.name != 'nt'):
        signals = (signal.SIGHUP, signal.SIGTERM, signal.SIGINT)
        for s in signals:
            self._event_loop.add_signal_handler(s, self.stop)
    future = asyncio.ensure_future(self._connect_and_read(), loop=self._event_loop)
    if (self.run_async or self._event_loop.is_running()):
        return future
    return self._event_loop.run_until_complete(future)

Starts an RTM Session with Slack.

Makes an authenticated call to Slack's RTM API to retrieve
a websocket URL and then connects to the message server.
As events stream-in we run any associated callbacks stored
on the client.

If 'auto_reconnect' is specified we
retrieve a new url and reconnect any time the connection
is lost unintentionally or an exception is thrown.

Raises:
SlackApiError: Unable to retreive RTM URL from Slack.


def bottom(self, features):
    if (not self._problem_hparams):
        log_warn('Without a Problem, T2TModel.bottom is a passthrough.')
        return features
    transformed_features = collections.OrderedDict()
    all_previous_modalities = []
    target_modality = _create_target_modality(self._problem_hparams.modality)
    for (feature_name, modality) in sorted(six.iteritems(self._problem_hparams.modality)):
        if (feature_name not in features):
            tf.logging.warning(('Missing feature %s - ignoring.' % feature_name))
            continue
        vocab_size = self._problem_hparams.vocab_size[feature_name]
        if ((vocab_size is not None) and hasattr(self._hparams, 'vocab_divisor')):
            vocab_size += ((- vocab_size) % self._hparams.vocab_divisor)
        modality_name = self._hparams.name.get(feature_name, modalities.get_name(modality))(self._hparams, vocab_size)
        if (feature_name in target_modality):
            if (len(target_modality) > 1):
                variable_scope_name = ('%s/%s' % (modality_name, feature_name))
            else:
                variable_scope_name = modality_name
            bottom = self._hparams.bottom.get(feature_name, modalities.get_targets_bottom(modality))
            with tf.variable_scope(variable_scope_name) as vs:
                self._add_variable_scope(variable_scope_name, vs)
                log_info("Transforming feature '%s' with %s.targets_bottom", feature_name, modality_name)
                transformed_features[feature_name] = bottom(features[feature_name], self._hparams, vocab_size)
        else:
            bottom = self._hparams.bottom.get(feature_name, modalities.get_bottom(modality))
            do_reuse = (modality_name in all_previous_modalities)
            with tf.variable_scope(modality_name, reuse=do_reuse) as vs:
                self._add_variable_scope(modality_name, vs)
                log_info("Transforming feature '%s' with %s.bottom", feature_name, modality_name)
                transformed_features[feature_name] = bottom(features[feature_name], self._hparams, vocab_size)
            all_previous_modalities.append(modality_name)
    for key in features:
        if (key not in transformed_features):
            transformed_features[key] = features[key]
        else:
            transformed_features[(key + '_raw')] = features[key]
    return transformed_features

Transforms features to feed into body.

Args:
features: dict of str to Tensor. Typically it is the preprocessed data
batch after Problem's preprocess_example().

Returns:
transformed_features: dict of same key-value pairs as features. The value
Tensors are newly transformed.


def to_event(self, event_type, field_name=None, depth=None):

        if self.ion_event is None:
            value = self
            if isinstance(self, IonPyNull):
                value = None
            self.ion_event = IonEvent(event_type, ion_type=self.ion_type, value=value, field_name=field_name,
                                      annotations=self.ion_annotations, depth=depth)
        return self.ion_event

Constructs an IonEvent from this _IonNature value.

Args:
event_type (IonEventType): The type of the resulting event.
field_name (Optional[text]): The field name associated with this value, if any.
depth (Optional[int]): The depth of this value.

Returns:
An IonEvent with the properties from this value.


def convert2wavenumber(rsr):
    retv = {}
    for chname in rsr.keys():
        retv[chname] = {}
        for det in rsr[chname].keys():
            retv[chname][det] = {}
            if ('wavenumber' in rsr[chname][det].keys()):
                retv[chname][det] = rsr[chname][det].copy()
                LOG.debug('RSR data already in wavenumber space. No conversion needed.')
                continue
            for sat in rsr[chname][det].keys():
                if (sat == 'wavelength'):
                    wnum = (1.0 / (0.0001 * rsr[chname][det][sat]))
                    retv[chname][det]['wavenumber'] = wnum[::(- 1)]
                elif (sat == 'response'):
                    if (type(rsr[chname][det][sat]) is dict):
                        retv[chname][det][sat] = {}
                        for name in rsr[chname][det][sat].keys():
                            resp = rsr[chname][det][sat][name]
                            retv[chname][det][sat][name] = resp[::(- 1)]
                    else:
                        resp = rsr[chname][det][sat]
                        retv[chname][det][sat] = resp[::(- 1)]
    unit = 'cm-1'
    si_scale = 100.0
    return (retv, {'unit': unit, 'si_scale': si_scale})

Take rsr data set with all channels and detectors for an instrument
each with a set of wavelengths and normalised responses and
convert to wavenumbers and responses

:rsr: Relative Spectral Response function (all bands)
Returns:
:retv: Relative Spectral Responses in wave number space
:info: Dictionary with scale (to go convert to SI units) and unit


def copy_modified_gene(self, modified_gene, ignore_model_attributes=True):
    ignore = ['_model', '_reaction', '_functional', 'model', 'reaction', 'functional']
    for attr in filter((lambda a: ((not a.startswith('__')) and (not isinstance(getattr(type(self), a, None), property)) and (not callable(getattr(self, a))))), dir(modified_gene)):
        if ((attr not in ignore) and ignore_model_attributes):
            setattr(self, attr, getattr(modified_gene, attr))

Copy attributes of a Gene object over to this Gene, given that the modified gene has the same ID.

Args:
modified_gene (Gene, GenePro): Gene with modified attributes that you want to copy over.
ignore_model_attributes (bool): If you want to ignore copying over attributes related to metabolic models.


def get_month_description(self):
    return self.get_segment_description(self._expression_parts[4], '', (lambda s: datetime.date(datetime.date.today().year, int(s), 1).strftime('%B')), (lambda s: _(', every {0} months').format(s)), (lambda s: _(', {0} through {1}')), (lambda s: _(', only in {0}')))

Generates a description for only the MONTH portion of the expression

Returns:
The MONTH description


def model_loader(gem_file_path, gem_file_type):
    if ((gem_file_type.lower() == 'xml') or (gem_file_type.lower() == 'sbml')):
        model = read_sbml_model(gem_file_path)
    elif (gem_file_type.lower() == 'mat'):
        model = load_matlab_model(gem_file_path)
    elif (gem_file_type.lower() == 'json'):
        model = load_json_model(gem_file_path)
    else:
        raise ValueError('File type must be "sbml", "xml", "mat", or "json".')
    return model

Consolidated function to load a GEM using COBRApy. Specify the file type being loaded.

Args:
gem_file_path (str): Path to model file
gem_file_type (str): GEM model type - ``sbml`` (or ``xml``), ``mat``, or ``json`` format

Returns:
COBRApy Model object.


def convert_to_dimension(d):

  if d is None:
    return None
  if isinstance(d, Dimension):
    if not isinstance(d.name, str) or not isinstance(d.size, int):
      raise ValueError("Bad dimension %s" % (d,))
    return d
  name, size = d
  if isinstance(name, str) and isinstance(size, int):
    return Dimension(name, size)
  else:
    raise ValueError("could not convert %s to Dimension" % (d,))

Converts input to a Dimension.

Args:
d: Dimension, tuple (string, int), or None.

Returns:
Dimension or None.

Raises:
ValueError: If d cannot be converted to a Dimension.


async def updateCronJob(self, iden, query):
    cron = self.cell.agenda.appts.get(iden)
    if (cron is None):
        raise s_exc.NoSuchIden()
    self._trig_auth_check(cron.useriden)
    (await self.cell.agenda.mod(iden, query))

Change an existing cron job's query

Args:
iden (bytes):  The iden of the cron job to be changed


def WriteSessionCompletion(self, aborted=False):
    self._RaiseIfNotWritable()
    if (self._storage_type != definitions.STORAGE_TYPE_SESSION):
        raise IOError('Unsupported storage type.')
    self._session.aborted = aborted
    session_completion = self._session.CreateSessionCompletion()
    self._storage_file.WriteSessionCompletion(session_completion)

Writes session completion information.

Args:
aborted (Optional[bool]): True if the session was aborted.

Raises:
IOError: if the storage type is not supported or
when the storage writer is closed.
OSError: if the storage type is not supported or
when the storage writer is closed.


def delete(self):
    self.manager.session.delete(self._uri)
    self.manager._name_uri_cache.delete(self.properties.get(self.manager._name_prop, None))

Delete this NIC.

Authorization requirements:

* Object-access permission to the Partition containing this HBA.
* Task permission to the "Partition Details" task.

Raises:

:exc:`~zhmcclient.HTTPError`
:exc:`~zhmcclient.ParseError`
:exc:`~zhmcclient.AuthError`
:exc:`~zhmcclient.ConnectionError`


def MakeSelfExtractingZip(self, payload_data, output_path):

    context = self.context + ["Client Context"]

    src_zip = zipfile.ZipFile(io.BytesIO(payload_data), mode="r")
    zip_data = io.BytesIO()
    output_zip = zipfile.ZipFile(
        zip_data, mode="w", compression=zipfile.ZIP_DEFLATED)

    config_file_name = config.CONFIG.Get(
        "ClientBuilder.config_filename", context=context)

    for template_file in src_zip.namelist():
      if template_file != config_file_name:

        CopyFileInZip(src_zip, template_file, output_zip)

    client_config_content = self.GetClientConfig(context)

    output_zip.writestr(
        config_file_name,
        client_config_content.encode("utf-8"),
        compress_type=zipfile.ZIP_STORED)

    output_zip.comment = b"$AUTORUN$>%s" % config.CONFIG.Get(
        "ClientBuilder.autorun_command_line", context=context).encode("utf-8")

    output_zip.close()

    utils.EnsureDirExists(os.path.dirname(output_path))
    with open(output_path, "wb") as fd:

      stub_data = io.BytesIO()
      unzipsfx_stub = config.CONFIG.Get(
          "ClientBuilder.unzipsfx_stub", context=context)
      stub_raw = open(unzipsfx_stub, "rb").read()

      if b"level=\"requireAdministrator" not in stub_raw:
        raise RuntimeError("Bad unzip binary in use. Not compiled with the"
                           "requireAdministrator manifest option.")

      stub_data.write(stub_raw)

      SetPeSubsystem(
          stub_data,
          console=config.CONFIG.Get("ClientBuilder.console", context=context))

      end_of_file = zip_data.tell() + stub_data.tell()

      offset_to_rsrc = stub_data.getvalue().find(b".rsrc")

      stub_data.seek(offset_to_rsrc + 20)
      start_of_rsrc_section = struct.unpack("<I", stub_data.read(4))[0]

      stub_data.seek(offset_to_rsrc + 16)
      stub_data.write(struct.pack("<I", end_of_file - start_of_rsrc_section))

      out_data = io.BytesIO()
      out_data.write(stub_data.getvalue())
      out_data.write(zip_data.getvalue())

      fd.write(out_data.getvalue())

    if self.signer:
      self.signer.SignFile(output_path)

    logging.info("Deployable binary generated at %s", output_path)

    return output_path

Repack the installer into the payload.

Args:
payload_data: data payload for zip file
output_path: filename for the zip output

Raises:
RuntimeError: if the ClientBuilder.unzipsfx_stub doesn't require admin.
Returns:
output_path: filename string of zip output file


def do_get(self, uri):

        self.validate_resource_uri(uri)
        return self._connection.get(uri)

Helps to make get requests

Args:
uri: URI of the resource

Returns:
Returns: Returns the resource data


def line_plot(df, xypairs, mode, layout={}, config=_BASE_CONFIG):

        if df.empty:
            return {
                "x": [],
                "y": [],
                "mode": mode
            }

        _data = []
        for x, y in xypairs:
            if (x in df.columns) and (y in df.columns):
                _data.append(
                    {
                        "x": df[x].values.tolist(),
                        "y": df[y].values.tolist(),
                        "mode": mode
                    }
                )

        return {
            "data": _data,
            "layout": layout,
            "config": config
            }

basic line plot

dataframe to json for a line plot

Args:
df (pandas.DataFrame): input dataframe
xypairs (list): list of tuples containing column names
mode (str): plotly.js mode (e.g. lines)
layout (dict): layout parameters
config (dict): config parameters


def use(self, middleware, path=None):
    self.log.info(' Using middleware {}', middleware)
    if (path is None):
        path = MiddlewareChain.ROOT_PATTERN
    self.add(HTTPMethod.ALL, path, middleware)
    return self

Call the provided middleware upon requests matching the path.
If path is not provided or None, all requests will match.

Args:
middleware (callable): Callable with the signature
``(res, req) -> None``
path (Optional[str or regex]): a specific path the
request must match for the middleware to be called.
Returns:
This router


def temp_shell_task(cls, inp, mpi_procs=1, workdir=None, manager=None):
    import tempfile
    workdir = (tempfile.mkdtemp() if (workdir is None) else workdir)
    if (manager is None):
        manager = TaskManager.from_user_config()
    task = cls.from_input(inp, workdir=workdir, manager=manager.to_shell_manager(mpi_procs=mpi_procs))
    task.set_name('temp_shell_task')
    return task

Build a Task with a temporary workdir. The task is executed via the shell with 1 MPI proc.
Mainly used for invoking Abinit to get important parameters needed to prepare the real task.

Args:
mpi_procs: Number of MPI processes to use.


def _prompt_split_image(self, num_patches):
    img_patches_per_tile = (self.img_size
    img_string = f'{self.start_of_img_token}'
    if num_patches > 1:
        for idx in range(1, num_patches):
            img_string += f'{self.tile_token}_{idx}' + f'{self.img_patch_token}' * img_patches_per_tile
    img_string += f'{self.tile_global_token}' + f'{self.img_patch_token}' * img_patches_per_tile
    img_string += f'{self.end_of_img_token}'
    return img_string

Create a structured string representation of image tokens

Args:
num_patches: Number of patches in the image

Returns:
String with appropriate image tokens


def flag_last(o):
    it = o.__iter__()
    try:
        e = next(it)
    except StopIteration:
        return
    while True:
        try:
            nxt = next(it)
            yield (False, e)
            e = nxt
        except StopIteration:
            yield (True, e)
            break

Flags the last loop of an iterator.

Consumes an iterator, buffers one instance so it can look ahead.
Returns True on last iteration.

Args:
* o: An iterator instance.

Returns:
* A tuple of (True/False, iteration). Returns True, next on StopIteration.


def get_vmss_vm(access_token, subscription_id, resource_group, vmss_name, instance_id):
    endpoint = ''.join([get_rm_endpoint(), '/subscriptions/', subscription_id, '/resourceGroups/', resource_group, '/providers/Microsoft.Compute/virtualMachineScaleSets/', vmss_name, '/virtualMachines/', str(instance_id), '?api-version=', COMP_API])
    return do_get(endpoint, access_token)

Get individual VMSS VM details.

Args:
access_token (str): A valid Azure authentication token.
subscription_id (str): Azure subscription id.
resource_group (str): Azure resource group name.
vmss_name (str): Name of the virtual machine scale set.
instance_id (int): VM ID of the scale set VM.

Returns:
HTTP response. JSON body of VMSS VM model view.


def chat_meMessage(self, *, channel: str, text: str, **kwargs) -> SlackResponse:
    kwargs.update({'channel': channel, 'text': text})
    return self.api_call('chat.meMessage', json=kwargs)

Share a me message into a channel.

Args:
channel (str): The channel id. e.g. 'C1234567890'
text (str): The message you'd like to share. e.g. 'Hello world'


def writeCmdMsg(self, msg):

        ekm_log("(writeCmdMsg | " + self.getContext() + ") " + msg)
        self.m_command_msg = msg

Internal method to set the command result string.

Args:
msg (str): Message built during command.


def generate(cache_fn):

    if not os.path.exists(cache_fn):
        print >> sys.stderr, "Can't access `%s`!" % cache_fn
        sys.exit(1)

    with SqliteDict(cache_fn) as db:
        for item in _pick_keywords(db):
            yield item

Go thru `cache_fn` and filter keywords. Store them in `keyword_list.json`.

Args:
cache_fn (str): Path to the file with cache.

Returns:
list: List of :class:`KeywordInfo` objects.


def labels(self):
    if (not self.__labels):
        self.__labels = Labels(self.__connection)
    return self.__labels

Gets the Labels API client.

Returns:
Labels: