def transform_rest_response(self, response_body):

    body_json = json.loads(response_body)
    return json.dumps(body_json, indent=1, sort_keys=True)

Translates an apiserving REST response so it's ready to return.

Currently, the only thing that needs to be fixed here is indentation,
so it's consistent with what the live app will return.

Args:
response_body: A string containing the backend response.

Returns:
A reformatted version of the response JSON.


def listen_forever(self, timeout_ms=30000, exception_handler=None, bad_sync_timeout=5):
    _bad_sync_timeout = bad_sync_timeout
    self.should_listen = True
    while self.should_listen:
        try:
            self._sync(timeout_ms)
            _bad_sync_timeout = bad_sync_timeout
        except MatrixRequestError as e:
            logger.warning('A MatrixRequestError occured during sync.')
            if (e.code >= 500):
                logger.warning('Problem occured serverside. Waiting %i seconds', bad_sync_timeout)
                sleep(bad_sync_timeout)
                _bad_sync_timeout = min((_bad_sync_timeout * 2), self.bad_sync_timeout_limit)
            elif (exception_handler is not None):
                exception_handler(e)
            else:
                raise
        except Exception as e:
            logger.exception('Exception thrown during sync')
            if (exception_handler is not None):
                exception_handler(e)
            else:
                raise

Keep listening for events forever.

Args:
timeout_ms (int): How long to poll the Home Server for before
retrying.
exception_handler (func(exception)): Optional exception handler
function which can be used to handle exceptions in the caller
thread.
bad_sync_timeout (int): Base time to wait after an error before
retrying. Will be increased according to exponential backoff.


def get_snapshots(self, volume_id_or_uri, start=0, count=(- 1), filter='', sort=''):
    uri = self.__build_volume_snapshot_uri(volume_id_or_uri)
    return self._client.get_all(start, count, filter=filter, sort=sort, uri=uri)

Gets all snapshots of a volume. Returns a list of snapshots based on optional sorting and filtering, and
constrained by start and count parameters.

Args:
volume_id_or_uri:
Can be either the volume id or the volume uri.
start:
The first item to return, using 0-based indexing.
If not specified, the default is 0 - start with the first available item.
count:
The number of resources to return. A count of -1 requests all items.
The actual number of items in the response might differ from the requested
count if the sum of start and count exceeds the total number of items.
filter (list or str):
A general filter/query string to narrow the list of items returned. The
default is no filter; all resources are returned.
sort:
The sort order of the returned data set. By default, the sort order is based
on create time with the oldest entry first.

Returns:
list: A list of snapshots.


def add_point_feature(self, resnum, feat_type=None, feat_id=None, qualifiers=None):

        if self.feature_file:
            raise ValueError('Feature file associated with sequence, please remove file association to append '
                             'additional features.')

        if not feat_type:
            feat_type = 'Manually added protein sequence single residue feature'
        newfeat = SeqFeature(location=FeatureLocation(ExactPosition(resnum-1), ExactPosition(resnum)),
                             type=feat_type,
                             id=feat_id,
                             qualifiers=qualifiers)

        self.features.append(newfeat)

Add a feature to the features list describing a single residue.

Args:
resnum (int): Protein sequence residue number
feat_type (str, optional): Optional description of the feature type (ie. 'catalytic residue')
feat_id (str, optional): Optional ID of the feature type (ie. 'TM1')


def run(self, resources):

        if not resources['connection']._port.startswith('jlink'):
            raise ArgumentError("FlashBoardStep is currently only possible through jlink", invalid_port=args['port'])

        hwman = resources['connection']
        debug = hwman.hwman.debug(self._debug_string)
        debug.flash(self._file)

Runs the flash step

Args:
resources (dict): A dictionary containing the required resources that
we needed access to in order to perform this step.


class EvalLoopContainer:

    def __init__(self, do_nested_concat: bool=True, padding_index: int=-100):
        self.do_nested_concat = do_nested_concat
        self.padding_index = padding_index
        self.tensors = None
        self.arrays = None

    def add(self, tensors) -> None:

        if self.tensors is None:
            self.tensors = tensors if self.do_nested_concat else [tensors]
        elif self.do_nested_concat:
            self.tensors = nested_concat(self.tensors, tensors, padding_index=self.padding_index)
        else:
            self.tensors.append(tensors)

    def to_cpu_and_numpy(self) -> None:

        if self.tensors is None:
            return
        new_arrays = nested_numpify(self.tensors)
        if self.arrays is None:
            self.arrays = new_arrays
        elif self.do_nested_concat:
            self.arrays = nested_concat(self.arrays, new_arrays, padding_index=self.padding_index)
        else:
            self.arrays.extend(new_arrays)
        self.tensors = None

    def get_arrays(self):

        self.to_cpu_and_numpy()
        return self.arrays

Container to store intermediate results of evaluation loop.

Args:
do_nested_concat (`bool`, *optional*, defaults to `True`):
If set to `True`, each iteration will recursively concatenate a new object containing tensors to
the existing stored tensors, provided that the structure of the existing object and the new one
are identical. If set to `False`, all newly added tensors will be stored in a list.
padding_index (`int`, *optional*, defaults to -100):
Value used to pad tensors of different shapes when `do_nested_concat=True`.


def AddPerformanceOptions(self, argument_group):
    argument_group.add_argument('--buffer_size', '--buffer-size', '--bs', dest='buffer_size', action='store', default=0, help='The buffer size for the output (defaults to 196MiB).')
    argument_group.add_argument('--queue_size', '--queue-size', dest='queue_size', action='store', default=0, help='The maximum number of queued items per worker (defaults to {0:d})'.format(self._DEFAULT_QUEUE_SIZE))

Adds the performance options to the argument group.

Args:
argument_group (argparse._ArgumentGroup): argparse argument group.


def with_port_scanning(cls):

    def init(wsgi_app, flags):
        should_scan = (flags.port is None)
        base_port = (core_plugin.DEFAULT_PORT if (flags.port is None) else flags.port)
        max_attempts = (10 if should_scan else 1)
        if (base_port > 65535):
            raise TensorBoardServerException(('TensorBoard cannot bind to port %d > %d' % (base_port, 65535)))
        max_attempts = (10 if should_scan else 1)
        base_port = (min((base_port + max_attempts), 65536) - max_attempts)
        for port in xrange(base_port, (base_port + max_attempts)):
            subflags = argparse.Namespace(**vars(flags))
            subflags.port = port
            try:
                return cls(wsgi_app=wsgi_app, flags=subflags)
            except TensorBoardPortInUseError:
                if (not should_scan):
                    raise
        raise TensorBoardServerException(('TensorBoard could not bind to any port around %s (tried %d times)' % (base_port, max_attempts)))
    return init

Create a server factory that performs port scanning.

This function returns a callable whose signature matches the
specification of `TensorBoardServer.__init__`, using `cls` as an
underlying implementation. It passes through `flags` unchanged except
in the case that `flags.port is None`, in which case it repeatedly
instantiates the underlying server with new port suggestions.

Args:
cls: A valid implementation of `TensorBoardServer`. This class's
initializer should raise a `TensorBoardPortInUseError` upon
failing to bind to a port when it is expected that binding to
another nearby port might succeed.

The initializer for `cls` will only ever be invoked with `flags`
such that `flags.port is not None`.

Returns:
A function that implements the `__init__` contract of
`TensorBoardServer`.


def transpose(vari):
    if isinstance(vari, Poly):
        core = vari.A.copy()
        for key in vari.keys:
            core[key] = transpose(core[key])
        return Poly(core, vari.dim, vari.shape[::(- 1)], vari.dtype)
    return numpy.transpose(vari)

Transpose a shapeable quantety.

Args:
vari (chaospy.poly.base.Poly, numpy.ndarray):
Quantety of interest.

Returns:
(chaospy.poly.base.Poly, numpy.ndarray):
Same type as ``vari``.

Examples:
>>> P = chaospy.reshape(chaospy.prange(4), (2,2))
>>> print(P)
[[1, q0], [q0^2, q0^3]]
>>> print(chaospy.transpose(P))
[[1, q0^2], [q0, q0^3]]


def _activation_summary(x):

  tf.histogram_summary(x.name + '/activations', x)
  tf.scalar_summary(x.name + '/sparsity', tf.nn.zero_fraction(x))

Helper to create summaries for activations.
Creates a summary that provides a histogram of activations.
Creates a summary that measure the sparsity of activations.
Args:
x: Tensor
Returns:
nothing


def parse_table_schema_from_json(schema_string):
    try:
        json_schema = json.loads(schema_string)
    except JSONDecodeError as e:
        raise ValueError('Unable to parse JSON schema: %s - %r' % (schema_string, e))

    def _parse_schema_field(field):

        schema = bigquery.TableFieldSchema()
        schema.name = field['name']
        schema.type = field['type']
        if 'mode' in field:
            schema.mode = field['mode']
        else:
            schema.mode = 'NULLABLE'
        if 'description' in field:
            schema.description = field['description']
        if 'fields' in field:
            schema.fields = [_parse_schema_field(x) for x in field['fields']]
        return schema
    fields = [_parse_schema_field(f) for f in json_schema['fields']]
    return bigquery.TableSchema(fields=fields)

Parse the Table Schema provided as string.

Args:
schema_string: String serialized table schema, should be a valid JSON.

Returns:
A TableSchema of the BigQuery export from either the Query or the Table.


def _remove_double_brackets(text):

    def replacement_fn(s):
        if (':' in s):
            return ''
        bar_pos = s.find('|')
        if (bar_pos == (- 1)):
            return s
        return s[(bar_pos + 1):]
    return _find_and_replace(text, '[[', ']]', replacement_fn)

Remove double brackets, but leave the viewable text.

Args:
text: a string
Returns:
a string


def trace_max_buffer_capacity(self):

        cmd = enums.JLinkTraceCommand.GET_MAX_CAPACITY
        data = ctypes.c_uint32(0)
        res = self._dll.JLINKARM_TRACE_Control(cmd, ctypes.byref(data))
        if (res == 1):
            raise errors.JLinkException('Failed to get max trace buffer size.')
        return data.value

Retrieves the maximum size the trace buffer can be configured with.

Args:
self (JLink): the ``JLink`` instance.

Returns:
The maximum configurable capacity for the trace buffer.


def __init__(self, config_builder, height=1000):

    tf.logging.set_verbosity(tf.logging.WARN)
    config = config_builder.build()
    copied_config = dict(config)
    self.estimator_and_spec = (
      dict(config.get('estimator_and_spec'))
      if 'estimator_and_spec' in config else {})
    self.compare_estimator_and_spec = (
      dict(config.get('compare_estimator_and_spec'))
      if 'compare_estimator_and_spec' in config else {})
    if 'estimator_and_spec' in copied_config:
      del copied_config['estimator_and_spec']
    if 'compare_estimator_and_spec' in copied_config:
      del copied_config['compare_estimator_and_spec']

    self.custom_predict_fn = (
      config.get('custom_predict_fn')
      if 'custom_predict_fn' in config else None)
    self.compare_custom_predict_fn = (
      config.get('compare_custom_predict_fn')
      if 'compare_custom_predict_fn' in config else None)
    if 'custom_predict_fn' in copied_config:
      del copied_config['custom_predict_fn']
    if 'compare_custom_predict_fn' in copied_config:
      del copied_config['compare_custom_predict_fn']

    self._set_examples(config['examples'])
    del copied_config['examples']

    self.config = copied_config

    WitWidget.widgets.append(self)

    display.display(display.HTML(self._get_element_html()))
    display.display(display.HTML(
      WIT_HTML.format(
        examples=json.dumps(self.examples), height=height, id=WitWidget.index)))

    WitWidget.index += 1

    output.eval_js(.format(
      config=json.dumps(self.config)))
    output.eval_js('updateExamplesCallback()')
    self._generate_sprite()

Constructor for colab notebook WitWidget.

Args:
config_builder: WitConfigBuilder object containing settings for WIT.
height: Optional height in pixels for WIT to occupy. Defaults to 1000.


def is_auth(self):
    if (self.user_id is None):
        self.user_id = self.session.get('user_id')
    return bool(self.user_id)

A property that indicates if current user is logged in or not.

Returns:
Boolean.


def __init__(self, func, argnames, func_name=None, grad_func=None, python_grad_func=None, out_names=None, **kwargs):
    self._func = func
    self._argnames = argnames
    self._func_name = func_name
    assert grad_func is None or isinstance(grad_func, _OverloadedFunction)
    self._grad_func = grad_func
    self._python_grad_func = python_grad_func
    self._out_names = out_names
    self._extra_kwargs = kwargs
    self._overload = {}

Creates _DefinedFunction.

Args:
func:  A python callable which constructs a tf function body.
argnames: A list of strings for function argument names.
func_name: The function name. Defaults to None, in which derives from
'func'.
grad_func: This function's gradient function, if not None. Defaults
to None.
python_grad_func: A python callable implementing the gradient of
the function python-side.
out_names: A list of strings for the function return value names.
**kwargs: The keyword arguments. **kwargs is passed to every call
site of this function.

Raises:
ValueError: The function definition is invalid.


def dstack(tup):

    arrays = list(tup)
    for i in range(len(arrays)):
        if arrays[i].ndim is 1:
            arrays[i] = arrays[i][np.newaxis, :]
        if arrays[i].ndim is 2:
            arrays[i] = arrays[i][:, :, np.newaxis]
    return concatenate(arrays, axis=2)

Stack arrays in sequence depth wise (along third dimension),
handling ``RemoteArray`` and ``DistArray`` without moving data.

Args:
tup (sequence of array_like)

Returns:
res: `ndarray`, if inputs were all local
`RemoteArray`, if inputs were all on the same remote engine
`DistArray`, if inputs were already scattered on different engines


def close(self, virtual_account_id, data={}, **kwargs):

        url = "{}/{}".format(self.base_url, virtual_account_id)
        data['status'] = 'closed'
        return self.patch_url(url, data, **kwargs)

Close Virtual Account from given Id

Args:
virtual_account_id :
Id for which Virtual Account objects has to be Closed


def query(self, query, additional_locals=None, safe_mode=False):
    logger.debug('Attempting to execute database query: %s', query)
    if (safe_mode and (not isinstance(query, dict))):
        raise SafetyViolationError(context=self.error_context)
    if isinstance(query, dict):
        logger.debug('Executing query in safe mode (MLAlchemy)')
        return mlalchemy.parse_query(query).to_sqlalchemy(self.session, self.tables).all()
    else:
        logger.debug('Executing unsafe query (Python exec())')
        if (additional_locals is not None):
            for (k, v) in iteritems(additional_locals):
                locals()[k] = v
        exec(compile(('result = %s' % query.strip()), '<string>', 'exec'), globals(), locals())
        return locals()['result']

Executes the given SQLAlchemy query string.

Args:
query: The SQLAlchemy ORM query (or Python code) to be executed.
additional_locals: Any additional local variables to inject into the execution context
when executing the query.
safe_mode: Boolean value indicating whether or not to execute queries in safe mode
only. If True, this only allows MLAlchemy-style queries. If False, this allows
both exec() and MLAlchemy-style queries. Default: False.

Returns:
The result of executing the query.


def order_by(self, key_selector=identity):
    if self.closed():
        raise ValueError('Attempt to call order_by() on a closed Queryable.')
    if (not is_callable(key_selector)):
        raise TypeError('order_by() parameter key_selector={key_selector} is not callable'.format(key_selector=repr(key_selector)))
    return self._create_ordered(iter(self), (- 1), key_selector)

Sorts by a key in ascending order.

Introduces a primary sorting order to the sequence. Additional sort
criteria should be specified by subsequent calls to then_by() and
then_by_descending().  Calling order_by() or order_by_descending() on
the results of a call to order_by() will introduce a new primary
ordering which will override any already established ordering.

This method performs a stable sort. The order of two elements with the
same key will be preserved.

Note: This method uses deferred execution.

Args:
key_selector: A unary function which extracts a key from each
element using which the result will be ordered.

Returns:
An OrderedQueryable over the sorted elements.

Raises:
ValueError: If the Queryable is closed.
TypeError: If the key_selector is not callable.


def get_metrics_namespace(self) -> str:
    return 'BeamML_TF_Numpy'

Returns:
A namespace for metrics collected by the RunInference transform.


def defaultStorable(self, python_type=None, storable_type=None, version=None, **kwargs):
    if (python_type is None):
        python_type = lookup_type(storable_type)
    if self.verbose:
        print('generating storable instance for type: {}'.format(python_type))
    self.storables.registerStorable(default_storable(python_type, version=version, storable_type=storable_type), **kwargs)
    return self.byPythonType(python_type, True).asVersion(version)

Generate a default storable instance.

Arguments:

python_type (type): Python type of the object.

storable_type (str): storable type name.

version (tuple): version number of the storable handler.

Returns:

StorableHandler: storable instance.

Extra keyword arguments are passed to :meth:`registerStorable`.


def copy_pkg(self, filename, id_=-1):

        for repo in self._children:
            repo.copy_pkg(filename, id_)

Copy a pkg, dmg, or zip to all repositories.

Args:
filename: String path to the local file to copy.
id_: Integer ID you wish to associate package with for a JDS
or CDP only. Default is -1, which is used for creating
a new package object in the database.


def en004(self, value=None):

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

        self._en004 = value

Corresponds to IDD Field `en004`
mean coincident dry-bulb temperature to
Enthalpy corresponding to 0.4% annual cumulative frequency of occurrence

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

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


def sendMessage(self, exchange, routing_key, message, properties=None, UUID=None):
    if (properties is None):
        properties = pika.BasicProperties(content_type=self.content_type, delivery_mode=1, headers={})
    if (UUID is not None):
        if (properties.headers is None):
            properties.headers = {}
        properties.headers['UUID'] = UUID
    self.channel.basic_publish(exchange=exchange, routing_key=routing_key, properties=properties, body=message)

With this function, you can send message to `exchange`.

Args:
exchange (str): name of exchange you want to message to be
delivered
routing_key (str): which routing key to use in headers of message
message (str): body of message
properties (dict ,optional): properties of message - if not used,
or set to ``None``, ``self.content_type``
and ``delivery_mode=2`` (persistent) is
used
UUID (str, optional): UUID of the message. If set, it is included
into ``properties`` of the message.


def where_function(function: _evaluation.WhereFunction, operand_result: Optional[_sql_data_types.Select], params_result: Collection[_sql_data_types.Select]) -> _sql_data_types.Select:
    del function
    if not operand_result:
        return _sql_data_types.Select(select_part=_sql_data_types.RawExpression('NULL', _sql_alias='where_clause_', _sql_data_type=_sql_data_types.Undefined), from_part=None, sql_dialect=_sql_data_types.SqlDialect.SPARK)
    criteria = list(params_result)[0]
    where_part = f'{operand_result.where_part} AND {criteria.as_operand()}' if operand_result.where_part else criteria.as_operand()
    if operand_result.from_part:
        from_part = operand_result.from_part
    elif isinstance(operand_result.sql_data_type, _sql_data_types.Struct):
        from_part = f'(SELECT {operand_result.select_part}.*) AS {operand_result.sql_alias}'
    return _sql_data_types.Select(select_part=operand_result.select_part, from_part=from_part, where_part=where_part, sql_dialect=_sql_data_types.SqlDialect.SPARK)

Returns a collection of all the items that match the criteria expression.

This function takes one param (`criteria`) in addition to the operand.

If the operand is not provided the matches function returns the empty set
which in this function translates to NULL.

Returns an error in the event that the `criteria` param is not provided or its
data type is not bool.

Args:
function: The FHIRPath AST `WhereFunction` node
operand_result: The expression which is being evaluated
params_result: The parameter passed in to function

Returns:
A compiled Spark SQL expression.


def install_napp(cls, mgr):
    try:
        LOG.info('    Searching local NApp...')
        mgr.install_local()
        LOG.info('    Found and installed.')
    except FileNotFoundError:
        LOG.info('    Not found. Downloading from NApps Server...')
        try:
            mgr.install_remote()
            LOG.info('    Downloaded and installed.')
            return
        except HTTPError as exception:
            if (exception.code == 404):
                LOG.error('    NApp not found.')
            else:
                LOG.error('    NApps Server error: %s', exception)
        except URLError as exception:
            LOG.error('    NApps Server error: %s', str(exception.reason))
        raise KytosException('NApp not found.')

Install a NApp.

Raises:
KytosException: If a NApp hasn't been found.


def read_meta_graph_file(filename):
    meta_graph_def = meta_graph_pb2.MetaGraphDef()
    if not file_io.file_exists(filename):
        raise IOError(f'File does not exist. Received: {filename}.')
    with file_io.FileIO(filename, 'rb') as f:
        file_content = f.read()
    try:
        meta_graph_def.ParseFromString(file_content)
        if sys.byteorder == 'big':
            bst.swap_tensor_content_in_graph_function(meta_graph_def, 'little', 'big')
        return meta_graph_def
    except Exception:
        pass
    try:
        text_format.Merge(file_content.decode('utf-8'), meta_graph_def)
        if sys.byteorder == 'big':
            bst.swap_tensor_content_in_graph_function(meta_graph_def, 'little', 'big')
    except text_format.ParseError as e:
        raise IOError(f'Cannot parse file {filename}: {str(e)}.')
    return meta_graph_def

Reads a file containing `MetaGraphDef` and returns the protocol buffer.

Args:
filename: `meta_graph_def` filename including the path.

Returns:
A `MetaGraphDef` protocol buffer.

Raises:
IOError: If the file doesn't exist, or cannot be successfully parsed.


def __init__(self, form, features):

        self.form = form
        self.features = features

Construct Segment objectself.

Args:
form (string): the segment as ipa
features (list): the segment as feature_names


def __getitem__(self, id):

        if id == slice(None, None):
            return list(self)
        response = backend.spreadsheet(self._sheets, id)
        result = models.SpreadSheet._from_response(response, self._sheets)
        result._api = self
        return result

Fetch and return the spreadsheet with the given id.

Args:
id (str): unique alphanumeric id of the spreadsheet
Returns:
SpreadSheet: new SpreadSheet instance
Raises:
KeyError: if no spreadsheet with the given ``id`` is found


def GetMessages(self, formatter_mediator, event):

    if self.DATA_TYPE != event.data_type:
      raise errors.WrongFormatter('Unsupported data type: {0:s}.'.format(
          event.data_type))

    event_values = event.CopyToDict()
    return self._ConditionalFormatMessages(event_values)

Determines the formatted message strings for an event object.

Args:
formatter_mediator (FormatterMediator): mediates the interactions
between formatters and other components, such as storage and Windows
EventLog resources.
event (EventObject): event.

Returns:
tuple(str, str): formatted message string and short message string.

Raises:
WrongFormatter: if the event object cannot be formatted by the formatter.


def write_model(model_object, output_tflite_file):
    if sys.byteorder == 'big':
        model_object = copy.deepcopy(model_object)
        byte_swap_tflite_model_obj(model_object, 'big', 'little')
    model_bytearray = convert_object_to_bytearray(model_object)
    with gfile.GFile(output_tflite_file, 'wb') as output_file_handle:
        output_file_handle.write(model_bytearray)

Writes the tflite model, a python object, into the output file.

NOTE: This API only works for TFLite generated with
_experimental_use_buffer_offset=false

Args:
model_object: A tflite model as a python object
output_tflite_file: Full path name to the output tflite file.

Raises:
IOError: If output_tflite_file path is invalid or cannot be opened.


def _pre_run(self):
    stage_name = STAGE_NAME_PRE_RUN
    record = records.TestResultRecord(stage_name, self.TAG)
    record.test_begin()
    self.current_test_info = runtime_test_info.RuntimeTestInfo(stage_name, self.log_path, record)
    try:
        with self._log_test_stage(stage_name):
            self.pre_run()
        return True
    except Exception as e:
        logging.exception('%s failed for %s.', stage_name, self.TAG)
        record.test_error(e)
        self.results.add_class_error(record)
        self.summary_writer.dump(record.to_dict(), records.TestSummaryEntryType.RECORD)
        return False

Proxy function to guarantee the base implementation of `pre_run` is
called.

Returns:
True if setup is successful, False otherwise.


def approve(self, sha=None, **kwargs):

        path = '%s/%s/approve' % (self.manager.path, self.get_id())
        data = {}
        if sha:
            data['sha'] = sha

        server_data = self.manager.gitlab.http_post(path, post_data=data,
                                                    **kwargs)
        self._update_attrs(server_data)

Approve the merge request.

Args:
sha (str): Head SHA of MR
**kwargs: Extra options to send to the server (e.g. sudo)

Raises:
GitlabAuthenticationError: If authentication is not correct
GitlabMRApprovalError: If the approval failed


def get_text_features(self, input_ids: tf.Tensor | None=None, attention_mask: tf.Tensor | None=None, position_ids: tf.Tensor | None=None, return_dict: Optional[bool]=None) -> tf.Tensor:
    return_dict = return_dict if return_dict is not None else self.config.use_return_dict
    text_outputs = self.blip.text_model(input_ids=input_ids, attention_mask=attention_mask, position_ids=position_ids, return_dict=return_dict)
    pooled_output = text_outputs[1]
    text_features = self.blip.text_projection(pooled_output)
    return text_features

Returns:
text_features (`tf.Tensor` of shape `(batch_size, output_dim`): The text embeddings obtained by applying
the projection layer to the pooled output of [`TFBlipTextModel`].

Examples:

```python
>>> from transformers import AutoProcessor, TFBlipModel

>>> model = TFBlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")

>>> inputs = processor(text=["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="tf")
>>> text_features = model.get_text_features(**inputs)
```


def _Read(self, input_file, schema, raw_binary=False):
    raw_binary = ['--raw-binary'] if raw_binary else []
    with TemporaryDirectoryResource() as tempdir:
        basename = os.path.basename(input_file)
        basename_no_extension, extension = os.path.splitext(basename)
        if extension in ['.bin', '.tflite']:
            returncode = subprocess.call([self._flatc_path, '-t', '--strict-json', '--defaults-json'] + raw_binary + ['-o', tempdir, schema, '--', input_file])
            if returncode != 0:
                raise RuntimeError('flatc failed to convert from binary to json.')
            json_file = os.path.join(tempdir, basename_no_extension + '.json')
            if not os.path.exists(json_file):
                raise RuntimeError('Could not find %r' % json_file)
        elif extension == '.json':
            json_file = input_file
        else:
            raise ValueError('Invalid extension on input file %r' % input_file)
        return json.load(open(json_file))

Read a tflite model assuming the given flatbuffer schema.

If `input_file` is in bin, then we must use flatc to convert the schema
from binary to json.

Args:
input_file: a binary (flatbuffer) or json file to read from. Extension
must  be `.tflite`, `.bin`, or `.json` for FlatBuffer Binary or
FlatBuffer JSON.
schema: which schema to use for reading
raw_binary: whether to assume raw_binary (versions previous to v3)
that lacked file_identifier require this.

Raises:
RuntimeError: 1. When flatc cannot be invoked.
2. When json file does not exists.
ValueError: When the extension is not json or bin.

Returns:
A dictionary representing the read tflite model.


def register_converter(src_type: Union[Type[Any], Tuple[Type[Any], ...]], dest_type: Union[Type[Any], Tuple[Type[Any], ...]], convert_fn: Callable[[Any], Any]) -> None:
    _TYPE_CONVERTER_REGISTRY.register(src_type, dest_type, convert_fn)

Register converter from source type to destination type.

Examples::

# Add converter from int to float.
pg.typing.register_converter(int, float, float)

assert pg.typing.Float().apply(1) is 1.0

# Add converter from a dict to class A.
def from_dict(d):
return A(**d)

assert isinstance(pg.typing.Object(A).apply({'x': 1, 'y': 2}), A)

Args:
src_type: Source value type.
dest_type: Target value type.
convert_fn: Function that performs the conversion, in signature
(src_type) -> dest_type.


def _RemoveForwardedIps(self, forwarded_ips, interface):

    for address in forwarded_ips:
      self.ip_forwarding_utils.RemoveForwardedIp(address, interface)

Remove the forwarded IP addresses from the network interface.

Args:
forwarded_ips: list, the forwarded IP address strings to delete.
interface: string, the output device to use.


def assets(self, asset_type=None):
    if (not self.can_update()):
        self._tcex.handle_error(910, [self.type])
    if (not asset_type):
        return self.tc_requests.adversary_assets(self.api_type, self.api_sub_type, self.unique_id)
    if (asset_type == 'PHONE'):
        return self.tc_requests.adversary_phone_assets(self.api_type, self.api_sub_type, self.unique_id)
    if (asset_type == 'HANDLER'):
        return self.tc_requests.adversary_handle_assets(self.api_type, self.api_sub_type, self.unique_id)
    if (asset_type == 'URL'):
        return self.tc_requests.adversary_url_assets(self.api_type, self.api_sub_type, self.unique_id)
    self._tcex.handle_error(925, ['asset_type', 'assets', 'asset_type', 'asset_type', asset_type])
    return None

Retrieves all of the assets of a given asset_type

Args:
asset_type: (str) Either None, PHONE, HANDLER, or URL

Returns:


def inference(images):

  with tf.variable_scope('conv1') as scope:
    kernel = _variable_with_weight_decay('weights',
                                         shape=[5, 5, 3, 64],
                                         stddev=5e-2,
                                         wd=0.0)
    conv = tf.nn.conv2d(images, kernel, [1, 1, 1, 1], padding='SAME')
    biases = _variable_on_cpu('biases', [64], tf.constant_initializer(0.0))
    pre_activation = tf.nn.bias_add(conv, biases)
    conv1 = tf.nn.relu(pre_activation, name=scope.name)
    _activation_summary(conv1)

  pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
                         padding='SAME', name='pool1')

  norm1 = tf.nn.lrn(pool1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75,
                    name='norm1')

  with tf.variable_scope('conv2') as scope:
    kernel = _variable_with_weight_decay('weights',
                                         shape=[5, 5, 64, 64],
                                         stddev=5e-2,
                                         wd=0.0)
    conv = tf.nn.conv2d(norm1, kernel, [1, 1, 1, 1], padding='SAME')
    biases = _variable_on_cpu('biases', [64], tf.constant_initializer(0.1))
    pre_activation = tf.nn.bias_add(conv, biases)
    conv2 = tf.nn.relu(pre_activation, name=scope.name)
    _activation_summary(conv2)

  norm2 = tf.nn.lrn(conv2, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75,
                    name='norm2')

  pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1],
                         strides=[1, 2, 2, 1], padding='SAME', name='pool2')

  with tf.variable_scope('local3') as scope:

    reshape = tf.reshape(pool2, [FLAGS.batch_size, -1])
    dim = reshape.get_shape()[1].value
    weights = _variable_with_weight_decay('weights', shape=[dim, 384],
                                          stddev=0.04, wd=0.004)
    biases = _variable_on_cpu('biases', [384], tf.constant_initializer(0.1))
    local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)
    _activation_summary(local3)

  with tf.variable_scope('local4') as scope:
    weights = _variable_with_weight_decay('weights', shape=[384, 192],
                                          stddev=0.04, wd=0.004)
    biases = _variable_on_cpu('biases', [192], tf.constant_initializer(0.1))
    local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name=scope.name)
    _activation_summary(local4)

  with tf.variable_scope('softmax_linear') as scope:
    weights = _variable_with_weight_decay('weights', [192, NUM_CLASSES],
                                          stddev=1/192.0, wd=0.0)
    biases = _variable_on_cpu('biases', [NUM_CLASSES],
                              tf.constant_initializer(0.0))
    softmax_linear = tf.add(tf.matmul(local4, weights), biases, name=scope.name)
    _activation_summary(softmax_linear)

  return softmax_linear

Build the CIFAR-10 model.

Args:
images: Images returned from distorted_inputs() or inputs().

Returns:
Logits.


def __init__(self, parent, module_name, module_ui):

        super(ModuleUIBaseFrame, self).__init__(parent, padding=8)
        self.columnconfigure(0, weight=1)
        self.rowconfigure(1, weight=1)

        if module_ui is not None:

            module_ui.ModuleUIFrame(self).grid(row=0, column=0, sticky="W E N S")
        else:
            logger.debug("No _ui.py found for '{}'".format(module_name))

        help_frame = ttk.LabelFrame(self, padding=8, text="Help")
        help_frame.grid(row=1, column=0, sticky="W E N S")
        help_frame.columnconfigure(0, weight=1)
        help_frame.rowconfigure(0, weight=1)

        _dir = os.path.realpath(
            os.path.join(os.getcwd(), os.path.dirname(__file__)))
        help_path = "{}/modules/{}/{}".format(_dir, module_name, "_help.json")
        if os.path.isfile(help_path):

            helptools.add_help_text(help_frame, help_path)
        else:

            tk.Label(help_frame, text="No _help.json file found for '{}'".format(module_name)).grid(row=0, column=0,
                                                                                sticky="W E N S")

Create a new base for a module UI

Args:
parent: A tk or ttk object
module_name (str): The name of the module
module_ui: The _ui.py file to add for the module


def parse_latitude(latitude, hemisphere):

    latitude = int(latitude[:2]) + float(latitude[2:]) / 60
    if hemisphere == 'S':
        latitude = -latitude
    elif not hemisphere == 'N':
        raise ValueError('Incorrect North/South value %r' % hemisphere)
    return latitude

Parse a NMEA-formatted latitude pair.

Args:
latitude (str): Latitude in DDMM.MMMM
hemisphere (str): North or South

Returns:
float: Decimal representation of latitude


def container(self, container_name):
    original_container = self._container
    with ops.init_scope():
        original_init_container = ops.get_default_graph()._container
    try:
        self._container = container_name
        with ops.init_scope():
            ops.get_default_graph()._container = container_name
        yield self._container
    finally:
        self._container = original_container
        with ops.init_scope():
            ops.get_default_graph()._container = original_init_container

Returns a context manager that specifies the resource container to use.

Overridden from `tf.Graph` to update both the init_scope container
and the present inner container. This is necessary to make sure setting
containers applies correctly both to created variables and to stateful
ops.

Args:
container_name: container name string.

Returns:
A context manager for defining resource containers for stateful ops,
yields the container name.


def get_atten(self):
    return self.attenuation_device.get_atten(self.idx)

Gets the current attenuation setting of Attenuator.

Returns:
A float that is the current attenuation value. Unit is db.


def setup_keyword(dist, _, value):

    if value is not True:
        return
    dist.entry_points = _ensure_entry_points_is_dict(dist.entry_points)

    for command, subcommands in six.iteritems(_get_commands(dist)):
        entry_point = '{command} = rcli.dispatcher:main'.format(
            command=command)
        entry_points = dist.entry_points.setdefault('console_scripts', [])
        if entry_point not in entry_points:
            entry_points.append(entry_point)
        dist.entry_points.setdefault('rcli', []).extend(subcommands)

Add autodetected commands as entry points.

Args:
dist: The distutils Distribution object for the project being
installed.
_: The keyword used in the setup function. Unused.
value: The value set to the keyword in the setup function. If the value
is not True, this function will do nothing.


def convert_to_tensor_or_indexed_slices(value, dtype=None, name=None):
    return internal_convert_to_tensor_or_indexed_slices(value=value, dtype=dtype, name=name, as_ref=False)

Converts the given object to a `Tensor` or an `IndexedSlices`.

If `value` is an `IndexedSlices` or `SparseTensor` it is returned
unmodified. Otherwise, it is converted to a `Tensor` using
`convert_to_tensor()`.

Args:
value: An `IndexedSlices`, `SparseTensor`, or an object that can be consumed
by `convert_to_tensor()`.
dtype: (Optional.) The required `DType` of the returned `Tensor` or
`IndexedSlices`.
name: (Optional.) A name to use if a new `Tensor` is created.

Returns:
A `Tensor`, `IndexedSlices`, or `SparseTensor` based on `value`.

Raises:
ValueError: If `dtype` does not match the element type of `value`.


def modify_module(channel, module_name, module_state):

    gui = ui_embed.UI(
        channel,
        "{} updated".format(module_name),
        "{} is now {}".format(module_name, "activated" if module_state else "deactivated"),
        modulename=modulename
    )

    return gui

Creates an embed UI containing the module modified message

Args:
channel (discord.Channel): The Discord channel to bind the embed to
module_name (str): The name of the module that was updated
module_state (bool): The current state of the module

Returns:
embed: The created embed


def _SetBlankLinesBetweenCommentAndClassFunc(self, node):
    index = 0
    while pytree_utils.IsCommentStatement(node.children[index]):
        self.Visit(node.children[index].children[0])
        if not self.last_was_decorator:
            _SetNumNewlines(node.children[index].children[0], _ONE_BLANK_LINE)
        index += 1
    if index and node.children[index].lineno - 1 == node.children[index - 1].children[0].lineno:
        _SetNumNewlines(node.children[index], _NO_BLANK_LINES)
    else:
        if self.last_comment_lineno + 1 == node.children[index].lineno:
            num_newlines = _NO_BLANK_LINES
        else:
            num_newlines = self._GetNumNewlines(node)
        _SetNumNewlines(node.children[index], num_newlines)
    return index

Set the number of blanks between a comment and class or func definition.

Class and function definitions have leading comments as children of the
classdef and functdef nodes.

Arguments:
node: (pytree.Node) The classdef or funcdef node.

Returns:
The index of the first child past the comment nodes.


def add_help_text(parent, filepath, prefix="!"):

    import tkinter as tk
    import tkinter.ttk as ttk

    help_contents = get_help_data(filepath)

    text = tk.Text(parent, wrap='word', font=("Helvetica", 10))
    text.grid(row=0, column=0, sticky="W E N S")
    text.tag_config("heading", font=("Helvetica", 14))
    text.tag_config("command", font=("Courier", 10))
    text.tag_config("param", font=("Courier", 10))
    text.tag_config("description")

    scrollbar = ttk.Scrollbar(parent, orient="vertical", command=text.yview)
    scrollbar.grid(column=1, row=0, sticky="N S")
    text['yscrollcommand'] = scrollbar.set

    for d in help_contents:
        text.insert('end', d, "heading")
        text.insert('end', '\n')

        if "commands" in d.lower():
            for c in help_contents[d]:
                if "name" not in c:
                    continue

                command = prefix + c["name"]
                text.insert('end', command, ("command", "description"))
                if "params" in c:
                    for param in c["params"]:
                        text.insert('end', " [{}]".format(param), ("param", "description"))
                text.insert('end', ": ")
                if "description" in c:
                    text.insert('end', c["description"], "description")

                text.insert('end', '\n')

            text.insert('end', '\n')
        else:
            text.insert('end', help_contents[d], "description")
            text.insert('end', '\n\n')

    text.config(state=tk.DISABLED)

Load help text from a file and adds it to the parent

Args:
parent: A tk or ttk object
filepath (str): The file to load help text from
prefix (str): The prefix to use for commands


def get_structure_from_mp(formula):
    m = MPRester()
    entries = m.get_entries(formula, inc_structure='final')
    if (len(entries) == 0):
        raise ValueError(('No structure with formula %s in Materials Project!' % formula))
    elif (len(entries) > 1):
        warnings.warn(('%d structures with formula %s found in Materials Project. The lowest energy structure will be returned.' % (len(entries), formula)))
    return min(entries, key=(lambda e: e.energy_per_atom)).structure

Convenience method to get a crystal from the Materials Project database via
the API. Requires PMG_MAPI_KEY to be set.

Args:
formula (str): A formula

Returns:
(Structure) The lowest energy structure in Materials Project with that
formula.


def save_binary(self, data: Union[dict, List[dict]]) -> str:
    path, _ = os.path.splitext(self.output_path)
    binary_path = os.path.extsep.join((path, 'pickle'))
    with open(binary_path, 'wb+') as f_output:
        pickle.dump(data, f_output)
    return binary_path

Save the provided data object as a pickle-formatted binary data on the disk.

Args:
data (`dict` or list of `dict`): The data to store.

Returns:
`str`: Path where the data has been saved.


def write_wav(path, samples, sr=16000):

    max_value = np.abs(np.iinfo(np.int16).min)
    data = (samples * max_value).astype(np.int16)
    scipy.io.wavfile.write(path, sr, data)

Write to given samples to a wav file.
The samples are expected to be floating point numbers
in the range of -1.0 to 1.0.

Args:
path (str): The path to write the wav to.
samples (np.array): A float array .
sr (int): The sampling rate.


def SelectArtifacts(cls, os_name=None, cpe=None, labels=None, restrict_checks=None):
    results = set()
    for condition in cls.Conditions(None, os_name, cpe, labels):
        trigger = condition[1:]
        for chk in itervalues(cls.checks):
            if (restrict_checks and (chk.check_id not in restrict_checks)):
                continue
            results.update(chk.triggers.Artifacts(*trigger))
    return results

Takes targeting info, identifies artifacts to fetch.

Args:
os_name: 0+ OS names.
cpe: 0+ CPE identifiers.
labels: 0+ GRR labels.
restrict_checks: A list of check ids whose artifacts should be fetched.

Returns:
the artifacts that should be collected.


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

		if type(thing) is str:
			return self.__getattr__(thing)
		else:

			lm = LayerManager(None)
			for key, layer in self.items():
				lm[key] = loompy.MemoryLoomLayer(key, layer[thing])
			return lm

Access a layer by name, or slice through all the layers

Args:
thing:		if string, return the specified layer ("" is the default layer)
if slice 2-tuple, return a new LayerManager with all layers sliced


def _create_variables_and_slots(self) -> Dict[str, Dict[str, tf_variables.Variable]]:
    self._track_restore_info_for_cpu()
    variables = {}
    stacked_variables = self._create_variables_from_stacked_tables()
    for table in self._table_config:
        if table.name in stacked_variables:
            variables[table.name] = {'parameters': stacked_variables[table.name]}
        else:
            variables[table.name] = self._create_variables(table, trainable=True)
    return variables

Create variables for TPU embeddings.

Returns:
A dict of dicts. The outer dict is keyed by the table names and the inner
dicts are keyed by 'parameters' and the slot variable names.


def DeregisterHelper(cls, helper_class):

    helper_name = helper_class.NAME.lower()
    if helper_name not in cls._helper_classes:
      raise KeyError('Helper class not set for name: {0:s}.'.format(
          helper_class.NAME))

    del cls._helper_classes[helper_name]

Deregisters a helper class.

The helper classes are identified based on their lower case name.

Args:
helper_class (type): class object of the argument helper.

Raises:
KeyError: if helper class is not set for the corresponding name.


def _GetFileSystemCacheIdentifier(self, path_spec):

    string_parts = []

    string_parts.append(getattr(path_spec.parent, 'comparable', ''))
    string_parts.append('type: {0:s}'.format(path_spec.type_indicator))

    return ''.join(string_parts)

Determines the file system cache identifier for the path specification.

Args:
path_spec (PathSpec): path specification.

Returns:
str: identifier of the VFS object.


def penalize_boundary_complexity(shp, w=20, mask=None, C=0.5):

  def inner(T):
    arr = T("input")

    if mask is None:
      mask_ = np.ones(shp)
      mask_[:, w:-w, w:-w] = 0
    else:
      mask_ = mask

    blur = _tf_blur(arr, w=5)
    diffs = (blur-arr)**2
    diffs += 0.8*(arr-C)**2

    return -tf.reduce_sum(diffs*mask_)
  return inner

Encourage the boundaries of an image to have less variation and of color C.

Args:
shp: shape of T("input") because this may not be known.
w: width of boundary to penalize. Ignored if mask is set.
mask: mask describing what area should be penalized.

Returns:
Objective.


def modify_prefix(channel, new_prefix):
    gui = ui_embed.UI(channel, 'Prefix updated', 'Modis prefix is now `{}`'.format(new_prefix), modulename=modulename)
    return gui

Creates an embed UI containing the prefix modified message

Args:
channel (discord.Channel): The Discord channel to bind the embed to
new_prefix (str): The value of the new prefix

Returns:
embed: The created embed


def load_json(task: Task, file: str) -> Result:
    kwargs: Dict[(str, Type[MutableMapping[(str, Any)]])] = {}
    with open(file, 'r') as f:
        data = json.loads(f.read(), **kwargs)
    return Result(host=task.host, result=data)

Loads a json file.

Arguments:
file: path to the file containing the json file to load

Examples:

Simple example with ``ordered_dict``::

> nr.run(task=load_json,
file="mydata.json")

file: path to the file containing the json file to load

Returns:
Result object with the following attributes set:
* result (``dict``): dictionary with the contents of the file


def FindStartOfExpressionInLine(line, endpos, stack):

  i = endpos
  while i >= 0:
    char = line[i]
    if char in ')]}':

      stack.append(char)
    elif char == '>':

      if (i > 0 and
          (line[i - 1] == '-' or
           Match(r'\s>=\s', line[i - 1:]) or
           Search(r'\boperator\s*$', line[0:i]))):
        i -= 1
      else:
        stack.append('>')
    elif char == '<':

      if i > 0 and line[i - 1] == '<':

        i -= 1
      else:

        if stack and stack[-1] == '>':
          stack.pop()
          if not stack:
            return (i, None)
    elif char in '([{':

      while stack and stack[-1] == '>':
        stack.pop()
      if not stack:
        return (-1, None)
      if ((char == '(' and stack[-1] == ')') or
          (char == '[' and stack[-1] == ']') or
          (char == '{' and stack[-1] == '}')):
        stack.pop()
        if not stack:
          return (i, None)
      else:

        return (-1, None)
    elif char == ';':

      while stack and stack[-1] == '>':
        stack.pop()
      if not stack:
        return (-1, None)

    i -= 1

  return (-1, stack)

Find position at the matching start of current expression.

This is almost the reverse of FindEndOfExpressionInLine, but note
that the input position and returned position differs by 1.

Args:
line: a CleansedLines line.
endpos: start searching at this position.
stack: nesting stack at endpos.

Returns:
On finding matching start: (index at matching start, None)
On finding an unclosed expression: (-1, None)
Otherwise: (-1, new stack at beginning of this line)


def __init__(self, app=None, env=None, region='us-east-1', prop_path=None):

        self.app_name = app
        self.env = env
        self.region = region
        self.properties = get_properties(prop_path, env=self.env, region=self.region)
        self.datapipeline_data = self.properties['datapipeline']
        generated = get_details(app=self.app_name)
        self.group = generated.data['project']

        session = boto3.Session(profile_name=self.env, region_name=self.region)
        self.client = session.client('datapipeline')
        self.pipeline_id = None

AWS Data Pipeline object.

Args:
app (str): Application name
env (str): Environment/Account
region (str): AWS Region
prop_path (str): Path of environment property file


def get_image_tokens(self, pixel_values: torch.FloatTensor):
    batch_size = pixel_values.shape[0]
    _, _, image_toks = self.vqmodel.encode(pixel_values)
    bpe_toks = self.vocabulary_mapping.convert_img2bpe(image_toks)
    bpe_toks = bpe_toks.view(batch_size, -1)
    return bpe_toks

Tokenizes images into discrete tokens with VQGAN module. Converts
obtained image tokens into BPE tokens and wraps with "boi" and "eoi"
special tokens.

Args:
pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)):
The tensors corresponding to the input images.


def FindFirst(cls, setting_matcher, device_matcher=None, **kwargs):

        try:
            return next(cls.FindDevices(
                setting_matcher, device_matcher=device_matcher, **kwargs))
        except StopIteration:
            raise usb_exceptions.DeviceNotFoundError(
                'No device available, or it is in the wrong configuration.')

Find and return the first matching device.

Args:
setting_matcher: See cls.FindDevices.
device_matcher: See cls.FindDevices.
**kwargs: See cls.FindDevices.

Returns:
An instance of UsbHandle.

Raises:
DeviceNotFoundError: Raised if the device is not available.


def set_snippet_client_verbose_logging(self, verbose):
    self._ad.log.info('Set verbose logging to %s.', verbose)
    self.verbose_logging = verbose

Switches verbose logging. True for logging full RPC response.

By default it will only write max_rpc_return_value_length for Rpc return
strings. If you need to see full message returned from Rpc, please turn
on verbose logging.

max_rpc_return_value_length will set to 1024 by default, the length
contains full Rpc response in Json format, included 1st element "id".

Args:
verbose: bool. If True, turns on verbose logging, if False turns off


def interface_required(interface):

        def _interface_required(func):

            @functools.wraps(func)
            def wrapper(self, *args, **kwargs):

                if self.tif != interface:
                    raise errors.JLinkException('Unsupported for current interface.')
                return func(self, *args, **kwargs)
            return wrapper
        return _interface_required

Decorator to specify that a particular interface type is required
for the given method to be used.

Args:
interface (int): attribute of ``JLinkInterfaces``

Returns:
A decorator function.


def set_attr_text(self, attr_key, attr_val, el_idx=0):

        self.get_element_by_attr_key(attr_key, el_idx).attrib[attr_key] = attr_val

Set the value of the selected attribute of the selected element.

Args:
attr_key : str
Name of attribute for which to search

attr_val : str
Text to set for the attribute.

el_idx : int
Index of element to use in the event that there are multiple sibling
elements with the same name.


def data_groups(self, groups, entity_count):
    data = []
    for xid in groups.keys():
        assoc_group_data = self.data_group_association(xid)
        data += assoc_group_data
        entity_count += len(assoc_group_data)
        if (entity_count >= self._batch_max_chunk):
            break
    return (data, entity_count)

Process Group data.

Args:
groups (list): The list of groups to process.

Returns:
list: A list of groups including associations


def _publish_to_subscribers(event: Event):

    subscribers = get_subscribers(event.object_type)

    for sub in subscribers:
        DB.prepend_to_list(_keys.published(event.object_type, sub),
                           event.id, pipeline=True)
        event_dict = deepcopy(event.config)
        event_dict.pop('id')
        DB.set_hash_value(_keys.data(event.object_type, sub), event.id,
                          str(event_dict), pipeline=True)
    DB.publish(event.object_type, event.id, pipeline=True)

Publish and event to all subscribers.

- Adds the event id to the published event list for all subscribers.
- Adds the event data to the published event data for all subscribers.
- Publishes the event id notification to all subscribers.

Args:
event (Event): Event object to publish.


def _FormatDateTime(self, event):
    try:
        datetime_object = datetime.datetime(1970, 1, 1, 0, 0, 0, 0, tzinfo=pytz.UTC)
        datetime_object += datetime.timedelta(microseconds=event.timestamp)
        datetime_object.astimezone(self._output_mediator.timezone)
        return datetime_object.replace(tzinfo=None)
    except (OverflowError, ValueError) as exception:
        self._ReportEventError(event, 'unable to copy timestamp: {0!s} to a human readable date and time with error: {1!s}. Defaulting to: "ERROR"'.format(event.timestamp, exception))
        return 'ERROR'

Formats the date to a datetime object without timezone information.

Note: timezone information must be removed due to lack of support
by xlsxwriter and Excel.

Args:
event (EventObject): event.

Returns:
datetime.datetime|str: date and time value or a string containing
"ERROR" on OverflowError.


def issuperset(self, other):
    other = self._cast_to_frameset(other)
    if (other is NotImplemented):
        return NotImplemented
    return (self.items >= other.items)

Check if the contents of `self` is a superset of the contents of
`other.`

Args:
other (:class:`FrameSet`):

Returns:
bool:
:class:`NotImplemented`: if `other` fails to convert to a :class:`FrameSet`


def select(self, field_paths):
    query = query_mod.Query(self)
    return query.select(field_paths)

Create a "select" query with this collection as parent.

See
:meth:`~.firestore_v1beta1.query.Query.select` for
more information on this method.

Args:
field_paths (Iterable[str, ...]): An iterable of field paths
(``.``-delimited list of field names) to use as a projection
of document fields in the query results.

Returns:
~.firestore_v1beta1.query.Query: A "projected" query.


def get_candidates(self, input_ids: torch.LongTensor) -> Tuple[torch.LongTensor, Optional[torch.FloatTensor]]:
    input_ids = input_ids.to(self.assistant_model.device)
    min_new_tokens, max_new_tokens = self._calculate_new_tokens(input_ids)
    if max_new_tokens == 0:
        return (input_ids, None)
    self._update_past_and_masks(input_ids)
    generation_args = self._prepare_generation_args(input_ids, min_new_tokens, max_new_tokens)
    candidate_ids, candidate_logits = self._generate_candidates(generation_args)
    return (candidate_ids, candidate_logits)

Fetches the candidates to be tried for the current input.

Args:
input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
Indices of input sequence tokens in the vocabulary. [What are input IDs?](../glossary#input-ids)

Return:
`torch.LongTensor` of shape `(batch_size, candidate_length)` containing the candidate sequences to be
assessed by the model and a `torch.FloatTensor` of shape `(batch_size, candidate_length,
vocabulary_size)` containing the logits associated to each candidate.


def _conv_general_param_type_converter(window_strides, lhs_dilation, rhs_dilation, dim):

    def _as_list_of_size(item, size):
        if item is None:
            return None
        return [item] * size if isinstance(item, int) else list(item)
    return (_as_list_of_size(window_strides, dim), _as_list_of_size(lhs_dilation, dim), _as_list_of_size(rhs_dilation, dim))

Convert strides, lhs_dilation, rhs_dilation to match TF convention.

For example,
in the 3D case, if lhs_dilation = 2, then convert it to [2, 2, 2]
if lhs_dilation = (2, 2, 2), convert it also to [2, 2, 2]

Args:
window_strides: window_strides to be converted
lhs_dilation: lhs_dilation to be converted
rhs_dilation: rhs_dilation to be converted
dim: dim to be converted

Returns:
The updated window_strides, lhs_dilation and rhs_dilation


def call_later(self, delay, callback):
    if hasattr(self._connection.ioloop, 'call_later'):
        self._connection.ioloop.call_later(delay, callback)
    else:
        self._connection.ioloop.add_timeout(delay, callback)

Schedule a one-shot timeout given delay seconds.

This method is only useful for compatibility with older versions of pika.

Args:
delay (float): Non-negative number of seconds from now until
expiration
callback (method): The callback method, having the signature
`callback()`


def add_one(self, url: str, url_properties: Optional[URLProperties]=None, url_data: Optional[URLData]=None):
    self.add_many([AddURLInfo(url, url_properties, url_data)])

Add a single URL to the table.

Args:
url: The URL to be added
url_properties: Additional values to be saved
url_data: Additional data to be saved


def __init__(self, session, max_retries, retry_backoff_base):

        self.on_connect = event.Event('Channel.on_connect')

        self.on_reconnect = event.Event('Channel.on_reconnect')

        self.on_disconnect = event.Event('Channel.on_disconnect')

        self.on_receive_array = event.Event('Channel.on_receive_array')

        self._max_retries = max_retries
        self._retry_backoff_base = retry_backoff_base

        self._is_connected = False

        self._on_connect_called = False

        self._chunk_parser = None

        self._session = session

        self._sid_param = None
        self._gsessionid_param = None

Create a new channel.

Args:
session (http_utils.Session): Request session.
max_retries (int): Number of retries for long-polling request.
retry_backoff_base (int): The base term for the long-polling
exponential backoff.


def save_counter(self):
    self._maybe_create_save_counter()
    return self._save_counter

An integer variable which starts at zero and is incremented on save.

Used to number checkpoints.

Returns:
The save counter variable.


def deterministic_shuffle(list_, seed=0, rng=None):
    r
    rng = ensure_rng(seed if rng is None else rng)
    rng.shuffle(list_)
    return list_

r"""
Args:
list_ (list):
seed (int):

Returns:
list: list_

CommandLine:
python -m utool.util_numpy --test-deterministic_shuffle

Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_numpy import *  # NOQA
>>> list_ = [1, 2, 3, 4, 5, 6]
>>> seed = 1
>>> list_ = deterministic_shuffle(list_, seed)
>>> result = str(list_)
>>> print(result)
[3, 2, 5, 1, 4, 6]


def truepath_relative(path, otherpath=None):
    if (otherpath is None):
        otherpath = os.getcwd()
    otherpath = truepath(otherpath)
    path_ = normpath(relpath(path, otherpath))
    return path_

Normalizes and returns absolute path with so specs

Args:
path (str):  path to file or directory
otherpath (None): (default = None)

Returns:
str: path_

CommandLine:
python -m utool.util_path --exec-truepath_relative --show

Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_path import *  # NOQA
>>> import utool as ut
>>> path = 'C:/foobar/foobiz'
>>> otherpath = 'C:/foobar'
>>> path_ = truepath_relative(path, otherpath)
>>> result = ('path_ = %s' % (ut.repr2(path_),))
>>> print(result)
path_ = 'foobiz'


def remove(self, node, dirty=True):
    if (node.id in self._children):
        self._children[node.id].parent = None
        del self._children[node.id]
    if dirty:
        self.touch()

Remove the given child node.

Args:
node (gkeepapi.Node): Node to remove.
dirty (bool): Whether this node should be marked dirty.


def _get_child_class(self, path):

        if self._child_entity is None:
            return BIDSNode

        for i, child_ent in enumerate(listify(self._child_entity)):
            template = self.available_entities[child_ent].directory
            if template is None:
                return BIDSNode
            template = self.root_path + template

            to_rep = re.findall(r'\{(.*?)\}', template)
            for ent in to_rep:
                patt = self.available_entities[ent].pattern
                template = template.replace('{%s}' % ent, patt)
            template += r'[^\%s]*$' % os.path.sep
            if re.match(template, path):
                return listify(self._child_class)[i]

        return BIDSNode

Return the appropriate child class given a subdirectory path.

Args:
path (str): The path to the subdirectory.

Returns: An uninstantiated BIDSNode or one of its subclasses.


def line_starts_subpgm(line: str) -> Tuple[bool, Optional[str]]:

    match = RE_SUB_START.match(line)
    if match != None:
        f_name = match.group(1)
        return (True, f_name)

    match = RE_FN_START.match(line)
    if match != None:
        f_name = match.group(1)
        return (True, f_name)

    return (False, None)

Indicates whether a line in the program is the first line of a subprogram
definition.

Args:
line
Returns:
(True, f_name) if line begins a definition for subprogram f_name;
(False, None) if line does not begin a subprogram definition.


def hpo_terms(self, query=None, hpo_term=None, text=None, limit=None):

        query_dict = {}
        search_term = None
        if query:
            query_dict = {'$or':
                [
                    {'hpo_id': {'$regex': query, '$options':'i'}},
                    {'description': {'$regex': query, '$options':'i'}},
                ]
            }
            search_term = query
        elif text:
            new_string = ''
            for i,word in enumerate(text.split(' ')):
                if i == 0:
                    new_string += word
                else:
                    new_string += ' \"{0}\"'.format(word)
            LOG.info("Search HPO terms with %s", new_string)
            query_dict['$text'] = {'$search': new_string}
            search_term = text
        elif hpo_term:
            query_dict['hpo_id'] = hpo_term
            search_term = hpo_term

        limit = limit or int(10e10)
        res = self.hpo_term_collection.find(query_dict).limit(limit).sort('hpo_number',ASCENDING)

        LOG.info("Found {0} terms with search word {1}".format(res.count(), search_term))
        return res

Return all HPO terms

If a query is sent hpo_terms will try to match with regex on term or
description.

Args:
query(str): Part of a hpoterm or description
hpo_term(str): Search for a specific hpo term
limit(int): the number of desired results

Returns:
result(pymongo.Cursor): A cursor with hpo terms


def release_client(self, client):

        if isinstance(client, Client):
            if not self._is_expired_client(client):
                LOG.debug('Client is not expired. Adding back to pool')
                self.__pool.append(client)
            elif client.is_connected():
                LOG.debug('Client is expired and connected. Disconnecting')
                client.disconnect()
        if self.__sem is not None:
            self.__sem.release()

Releases a client object to the pool.

Args:
client: Client object.


def dismiss_confirm(self, text=None, wait=None):
    with self.driver.dismiss_modal('confirm', text=text, wait=wait):
        (yield)

Execute the wrapped code, dismissing a confirm.

Args:
text (str | RegexObject, optional): Text to match against the text in the modal.
wait (int | float, optional): Maximum time to wait for the modal to appear after
executing the wrapped code.

Raises:
ModalNotFound: If a modal dialog hasn't been found.


def xslt_transformation(xml, template):

    transformer = ET.XSLT(
        _read_template(template)
    )
    newdom = transformer(
        _read_marcxml(xml)
    )

    return ET.tostring(newdom, pretty_print=True, encoding="utf-8")

Transform `xml` using XSLT `template`.

Args:
xml (str): Filename or XML string. Don't use ``\\n`` in case of
filename.
template (str): Filename or XML string. Don't use ``\\n`` in case of
filename.

Returns:
str: Transformed `xml` as string.


def extract_response(self, extractors):

        if not extractors:
            return {}

        logger.log_debug("start to extract from response object.")
        extracted_variables_mapping = OrderedDict()
        extract_binds_order_dict = utils.ensure_mapping_format(extractors)

        for key, field in extract_binds_order_dict.items():
            extracted_variables_mapping[key] = self.extract_field(field)

        return extracted_variables_mapping

extract value from requests.Response and store in OrderedDict.

Args:
extractors (list):

[
{"resp_status_code": "status_code"},
{"resp_headers_content_type": "headers.content-type"},
{"resp_content": "content"},
{"resp_content_person_first_name": "content.person.name.first_name"}
]

Returns:
OrderDict: variable binds ordered dict


def merge_all_models_into_first_model(biop_structure):

    from string import ascii_uppercase
    idx = 1
    first_model = biop_structure[0]

    for m in biop_structure.get_models():

        if first_model.id == m.id:
            continue
        for c in m.get_chains():
            c.id = ascii_uppercase[idx]
            first_model.add(c)
        idx += 1

Merge all existing models into a Structure's first_model attribute.

This directly modifies the Biopython Structure object. Chains IDs will start from A and increment for each new
chain (model that is converted).

Args:
biop_structure (Structure): Structure with multiple models that should be merged


def __init__(self, **kwargs):

        super(functionTagProcessor, self).__init__(**kwargs)

        self.include_function_signatures = kwargs.get(
            'include_function_signatures', False)

Initializer.

Args:
**include_function_signatures: bool. See get_name() for more info.


def get_many(self, query: Mapping[(str, Any)], context: PipelineContext=None, streaming: bool=False) -> Iterable[T]:
    result = self._source.get_many(self._source_type, deepcopy(query), context)
    LOGGER.info('Got results "{result}" from query "{query}" of source "{source}"'.format(result=result, query=query, source=self._source))
    if (not streaming):
        LOGGER.info('Non-streaming get_many request. Ensuring results "{result}" are a Iterable'.format(result=result))
        result = list(result)
        LOGGER.info('Sending results "{result}" to sinks before converting'.format(result=result))
        for sink in self._before_transform:
            sink.put_many(result, context)
        LOGGER.info('Converting results "{result}" to request type'.format(result=result))
        result = [self._transform(data=item, context=context) for item in result]
        LOGGER.info('Sending results "{result}" to sinks after converting'.format(result=result))
        for sink in self._after_transform:
            sink.put_many(result, context)
        return result
    else:
        LOGGER.info('Streaming get_many request. Returning result generator for results "{result}"'.format(result=result))
        return self._get_many_generator(result)

Gets a query from the data source, where the query contains multiple elements to be extracted.

1) Extracts the query from the data source.
2) Inserts the result into any data sinks.
3) Transforms the results into the requested type if it wasn't already.
4) Inserts the transformed result into any data sinks.

Args:
query: The query being requested.
context: The context for the extraction (mutable).
streaming: Specifies whether the results should be returned as a generator (default False).

Returns:
The requested objects or a generator of the objects if streaming is True.


def __init__(self, channel):

        self.ListInstanceConfigs = channel.unary_unary(
            "/google.spanner.admin.instance.v1.InstanceAdmin/ListInstanceConfigs",
            request_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_instance__v1_dot_proto_dot_spanner__instance__admin__pb2.ListInstanceConfigsRequest.SerializeToString,
            response_deserializer=google_dot_cloud_dot_spanner_dot_admin_dot_instance__v1_dot_proto_dot_spanner__instance__admin__pb2.ListInstanceConfigsResponse.FromString,
        )
        self.GetInstanceConfig = channel.unary_unary(
            "/google.spanner.admin.instance.v1.InstanceAdmin/GetInstanceConfig",
            request_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_instance__v1_dot_proto_dot_spanner__instance__admin__pb2.GetInstanceConfigRequest.SerializeToString,
            response_deserializer=google_dot_cloud_dot_spanner_dot_admin_dot_instance__v1_dot_proto_dot_spanner__instance__admin__pb2.InstanceConfig.FromString,
        )
        self.ListInstances = channel.unary_unary(
            "/google.spanner.admin.instance.v1.InstanceAdmin/ListInstances",
            request_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_instance__v1_dot_proto_dot_spanner__instance__admin__pb2.ListInstancesRequest.SerializeToString,
            response_deserializer=google_dot_cloud_dot_spanner_dot_admin_dot_instance__v1_dot_proto_dot_spanner__instance__admin__pb2.ListInstancesResponse.FromString,
        )
        self.GetInstance = channel.unary_unary(
            "/google.spanner.admin.instance.v1.InstanceAdmin/GetInstance",
            request_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_instance__v1_dot_proto_dot_spanner__instance__admin__pb2.GetInstanceRequest.SerializeToString,
            response_deserializer=google_dot_cloud_dot_spanner_dot_admin_dot_instance__v1_dot_proto_dot_spanner__instance__admin__pb2.Instance.FromString,
        )
        self.CreateInstance = channel.unary_unary(
            "/google.spanner.admin.instance.v1.InstanceAdmin/CreateInstance",
            request_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_instance__v1_dot_proto_dot_spanner__instance__admin__pb2.CreateInstanceRequest.SerializeToString,
            response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString,
        )
        self.UpdateInstance = channel.unary_unary(
            "/google.spanner.admin.instance.v1.InstanceAdmin/UpdateInstance",
            request_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_instance__v1_dot_proto_dot_spanner__instance__admin__pb2.UpdateInstanceRequest.SerializeToString,
            response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString,
        )
        self.DeleteInstance = channel.unary_unary(
            "/google.spanner.admin.instance.v1.InstanceAdmin/DeleteInstance",
            request_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_instance__v1_dot_proto_dot_spanner__instance__admin__pb2.DeleteInstanceRequest.SerializeToString,
            response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
        )
        self.SetIamPolicy = channel.unary_unary(
            "/google.spanner.admin.instance.v1.InstanceAdmin/SetIamPolicy",
            request_serializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.SetIamPolicyRequest.SerializeToString,
            response_deserializer=google_dot_iam_dot_v1_dot_policy__pb2.Policy.FromString,
        )
        self.GetIamPolicy = channel.unary_unary(
            "/google.spanner.admin.instance.v1.InstanceAdmin/GetIamPolicy",
            request_serializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.GetIamPolicyRequest.SerializeToString,
            response_deserializer=google_dot_iam_dot_v1_dot_policy__pb2.Policy.FromString,
        )
        self.TestIamPermissions = channel.unary_unary(
            "/google.spanner.admin.instance.v1.InstanceAdmin/TestIamPermissions",
            request_serializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsRequest.SerializeToString,
            response_deserializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsResponse.FromString,
        )

Constructor.

Args:
channel: A grpc.Channel.


def remove_from_list(self, key: str, value, count: int = 0,
                         pipeline: bool = False):

        if pipeline:
            if redis.__version__ == '2.10.6':
                self._pipeline.lrem(name=key, value=value, num=count)
            else:
                self._pipeline.lrem(key, count, value)
        else:
            if self._db.exists(key):
                if redis.__version__ == '2.10.6':
                    self._db.lrem(name=key, value=value, num=count)
                else:
                    self._db.lrem(key, count, value)

Remove specified value(s) from the list stored at key.

Args:
key (str): Key where the list is stored.
value: value to remove
count (int): Number of entries to remove, default 0 == all
pipeline(bool): If True, start a transaction block. Default False.


def delete_project(self, resource):

        self.project_service.set_auth(self._token_project)
        self.project_service.delete(resource)

Deletes the entity described by the given resource.

Args:
resource (intern.resource.boss.BossResource)

Raises:
requests.HTTPError on a failure.


def mock(self, slot, rpc_id, value):
    address = slot.address
    if (address not in self.mock_rpcs):
        self.mock_rpcs[address] = {}
    self.mock_rpcs[address][rpc_id] = value

Store a mock return value for an RPC

Args:
slot (SlotIdentifier): The slot we are mocking
rpc_id (int): The rpc we are mocking
value (int): The value that should be returned
when the RPC is called.


def extract_signature(func, ignore_first=False):
    sig_params = get_signature_params(func)
    if ignore_first:
        if (len(sig_params) == 0):
            raise Exception("Methods must take a 'self' argument, but the method '{}' does not have one.".format(func.__name__))
        sig_params = sig_params[1:]
    arg_names = []
    arg_defaults = []
    arg_is_positionals = []
    keyword_names = set()
    for (arg_name, parameter) in sig_params:
        arg_names.append(arg_name)
        arg_defaults.append(parameter.default)
        arg_is_positionals.append((parameter.kind == parameter.VAR_POSITIONAL))
        if (parameter.kind == Parameter.POSITIONAL_OR_KEYWORD):
            keyword_names.add(arg_name)
    return FunctionSignature(arg_names, arg_defaults, arg_is_positionals, keyword_names, func.__name__)

Extract the function signature from the function.

Args:
func: The function whose signature should be extracted.
ignore_first: True if the first argument should be ignored. This should
be used when func is a method of a class.

Returns:
A function signature object, which includes the names of the keyword
arguments as well as their default values.


def _supervised_signature_def(method_name, inputs, loss=None, predictions=None, metrics=None):
    if inputs is None or not inputs:
        raise ValueError(f'{method_name} `inputs` cannot be None or empty.')
    signature_inputs = {key: utils.build_tensor_info(tensor) for key, tensor in inputs.items()}
    signature_outputs = {}
    for output_set in (loss, predictions, metrics):
        if output_set is not None:
            sig_out = {key: utils.build_tensor_info(tensor) for key, tensor in output_set.items()}
            signature_outputs.update(sig_out)
    signature_def = build_signature_def(signature_inputs, signature_outputs, method_name)
    return signature_def

Creates a signature for training and eval data.

This function produces signatures that describe the inputs and outputs
of a supervised process, such as training or evaluation, that
results in loss, metrics, and the like. Note that this function only requires
inputs to be not None.

Args:
method_name: Method name of the SignatureDef as a string.
inputs: dict of string to `Tensor`.
loss: dict of string to `Tensor` representing computed loss.
predictions: dict of string to `Tensor` representing the output predictions.
metrics: dict of string to `Tensor` representing metric ops.

Returns:
A train- or eval-flavored signature_def.

Raises:
ValueError: If inputs or outputs is `None`.


def __init__(self, endpoint, project, token, api_base="api/v1",
                 is_skipped_an_issue=True, verify_ssl=True):

        super(ReportPortalService, self).__init__()
        self.endpoint = endpoint
        self.api_base = api_base
        self.project = project
        self.token = token
        self.is_skipped_an_issue = is_skipped_an_issue
        self.base_url = uri_join(self.endpoint,
                                 self.api_base,
                                 self.project)

        self.session = requests.Session()
        self.session.headers["Authorization"] = "bearer {0}".format(self.token)
        self.stack = [None]
        self.launch_id = None
        self.verify_ssl = verify_ssl

Init the service class.

Args:
endpoint: endpoint of report portal service.
project: project name to use for launch names.
token: authorization token.
api_base: defaults to api/v1, can be changed to other version.
is_skipped_an_issue: option to mark skipped tests as not
'To Investigate' items on Server side.
verify_ssl: option to not verify ssl certificates


def record_markdown(text, cellid):
    from acorn.logging.database import record
    from time import time
    ekey = 'nb-{}'.format(cellid)
    global _cellid_map
    if (cellid not in _cellid_map):
        from acorn.logging.database import active_db
        from difflib import SequenceMatcher
        from acorn.logging.diff import cascade
        taskdb = active_db()
        if (ekey not in taskdb.entities):
            possible = [k for k in taskdb.entities if (k[0:3] == 'nb-')]
            (maxkey, maxvalue) = (None, 0.0)
            for pkey in possible:
                sequence = [e['c'] for e in taskdb.entities[pkey]]
                state = ''.join(cascade(sequence))
                matcher = SequenceMatcher(a=state, b=text)
                ratio = matcher.quick_ratio()
                if ((ratio > maxvalue) and (ratio > 0.5)):
                    (maxkey, maxvalue) = (pkey, ratio)
            if (maxkey is not None):
                ekey = pkey
        _cellid_map[cellid] = ekey
    ekey = _cellid_map[cellid]
    entry = {'m': 'md', 'a': None, 's': time(), 'r': None, 'c': text}
    record(ekey, entry, diff=True)

Records the specified markdown text to the acorn database.

Args:
text (str): the *raw* markdown text entered into the cell in the ipython
notebook.


def validate_env(app):

    if not hasattr(app.env, 'javalink_config_cache'):
        app.env.javalink_config_cache = {}

    for conf_attr, (_, _, env_attr) in ref.CONFIG_VALUES.iteritems():
        if not env_attr:
            continue

        value = getattr(app.config, conf_attr)
        cached = app.env.javalink_config_cache.get(conf_attr, value)

        app.env.javalink_config_cache[conf_attr] = value
        if value != cached:
            app.verbose('[javalink] config.%s has changed, clearing related env', conf_attr)
            delattr(app.env, env_attr)

Purge expired values from the environment.

When certain configuration values change, related values in the
environment must be cleared. While Sphinx can rebuild documents on
configuration changes, it does not notify extensions when this
happens. Instead, cache relevant values in the environment in order
to detect when they change.

Args:
app: The Sphinx application.


def convert(self):
    return super(TFLiteConverter, self).convert()

Converts a TensorFlow GraphDef based on instance variables.

Returns:
The converted data in serialized format, either a TFLite Flatbuffer or
a Graphviz graph depending on value in `output_format`.

Raises:
ValueError:
Input shape is not specified.
None value for dimension in input_tensor.


def touch(self, key, expire=0, noreply=None):

        if noreply is None:
            noreply = self.default_noreply
        key = self.check_key(key)
        cmd = b'touch ' + key + b' ' + six.text_type(expire).encode('ascii')
        if noreply:
            cmd += b' noreply'
        cmd += b'\r\n'
        results = self._misc_cmd([cmd], b'touch', noreply)
        if noreply:
            return True
        return results[0] == b'TOUCHED'

The memcached "touch" command.

Args:
key: str, see class docs for details.
expire: optional int, number of seconds until the item is expired
from the cache, or zero for no expiry (the default).
noreply: optional bool, True to not wait for the reply (defaults to
self.default_noreply).

Returns:
True if the expiration time was updated, False if the key wasn't
found.


def _is_quantized_function(self, func: function_pb2.FunctionDef) -> bool:
    return func.signature.name.startswith('quantized_')

Determine whether a FunctionDef is quantized.

Args:
func: A FunctionDef object.

Returns:
True iff `func` is quantized.


def FoldByteStream(self, mapped_value, context=None, **unused_kwargs):

    elements_data_size = self._CalculateElementsDataSize(context)
    if elements_data_size is not None:
      if elements_data_size != len(mapped_value):
        raise errors.FoldingError(
            'Mismatch between elements data size and mapped value size')

    elif not self._HasElementsTerminator():
      raise errors.FoldingError('Unable to determine elements data size')

    else:
      elements_terminator = self._data_type_definition.elements_terminator
      elements_terminator_size = len(elements_terminator)
      if mapped_value[-elements_terminator_size:] != elements_terminator:
        mapped_value = b''.join([mapped_value, elements_terminator])

    return mapped_value

Folds the data type into a byte stream.

Args:
mapped_value (object): mapped value.
context (Optional[DataTypeMapContext]): data type map context.

Returns:
bytes: byte stream.

Raises:
FoldingError: if the data type definition cannot be folded into
the byte stream.


def _GetStringValue(self, data_dict, name, default_value=None):
    values = data_dict.get(name, None)
    if (not values):
        return default_value
    for (index, value) in enumerate(values):
        if (',' in value):
            values[index] = '"{0:s}"'.format(value)
    return ', '.join(values)

Retrieves a specific string value from the data dict.

Args:
data_dict (dict[str, list[str]): values per name.
name (str): name of the value to retrieve.
default_value (Optional[object]): value to return if the name has no value
set in data_dict.

Returns:
str: value represented as a string.


def _insert_back_keep_dims(x, axis):

  for i in sorted(axis):
    x = tf.expand_dims(x, axis=i)
  return x

Insert the dims in `axis` back as singletons after being removed.

Args:
x:  `Tensor`.
axis:  Python list of integers.

Returns:
`Tensor` with same values as `x`, but additional singleton dimensions.


def read_uint16(self, little_endian=True):
    if little_endian:
        endian = '<'
    else:
        endian = '>'
    return self.unpack(('%sH' % endian), 2)

Read 2 byte as an unsigned integer value from the stream.

Args:
little_endian (bool): specify the endianness. (Default) Little endian.

Returns:
int:


def start_time_distance(item_a, item_b, max_value):
    start_time_diff = np.abs((item_a.times[0] - item_b.times[0]))
    return (np.minimum(start_time_diff, max_value) / float(max_value))

Absolute difference between the starting times of each item.

Args:
item_a: STObject from the first set in TrackMatcher
item_b: STObject from the second set in TrackMatcher
max_value: Maximum distance value used as scaling value and upper constraint.

Returns:
Distance value between 0 and 1.


def __parse(self, function_meta):
    self._func = get_mapping_function(function_meta['func_name'], self.functions_mapping)
    self.func_name = self._func.__name__
    self._args = prepare_lazy_data(function_meta.get('args', []), self.functions_mapping, self.check_variables_set)
    self._kwargs = prepare_lazy_data(function_meta.get('kwargs', {}), self.functions_mapping, self.check_variables_set)
    if (self.func_name == 'load_csv_file'):
        if ((len(self._args) != 1) or self._kwargs):
            raise exceptions.ParamsError('P() should only pass in one argument!')
        self._args = [self._args[0]]
    elif (self.func_name == 'get_os_environ'):
        if ((len(self._args) != 1) or self._kwargs):
            raise exceptions.ParamsError('ENV() should only pass in one argument!')
        self._args = [self._args[0]]

init func as lazy functon instance

Args:
function_meta (dict): function meta including name, args and kwargs


def ParseCall(self, parser_mediator, query, row, **unused_kwargs):

    query_hash = hash(query)

    guid = self._GetRowValue(query_hash, row, 'guid')
    is_incoming = self._GetRowValue(query_hash, row, 'is_incoming')
    videostatus = self._GetRowValue(query_hash, row, 'videostatus')

    try:
      aux = guid
      if aux:
        aux_list = aux.split('-')
        src_aux = aux_list[0]
        dst_aux = aux_list[1]
      else:
        src_aux = 'Unknown [no GUID]'
        dst_aux = 'Unknown [no GUID]'
    except IndexError:
      src_aux = 'Unknown [{0:s}]'.format(guid)
      dst_aux = 'Unknown [{0:s}]'.format(guid)

    if is_incoming == '0':
      user_start_call = True
      source = src_aux

      ip_address = self._GetRowValue(query_hash, row, 'ip_address')
      if ip_address:
        destination = '{0:s} <{1:s}>'.format(dst_aux, ip_address)
      else:
        destination = dst_aux
    else:
      user_start_call = False
      source = src_aux
      destination = dst_aux

    call_identifier = self._GetRowValue(query_hash, row, 'id')

    event_data = SkypeCallEventData()
    event_data.dst_call = destination
    event_data.offset = call_identifier
    event_data.query = query
    event_data.src_call = source
    event_data.user_start_call = user_start_call
    event_data.video_conference = videostatus == '3'

    timestamp = self._GetRowValue(query_hash, row, 'try_call')
    event_data.call_type = 'WAITING'
    date_time = dfdatetime_posix_time.PosixTime(timestamp=timestamp)
    event = time_events.DateTimeValuesEvent(date_time, 'Call from Skype')
    parser_mediator.ProduceEventWithEventData(event, event_data)

    try:
      timestamp = self._GetRowValue(query_hash, row, 'accept_call')
      timestamp = int(timestamp)
    except (ValueError, TypeError):
      timestamp = None

    if timestamp:
      event_data.call_type = 'ACCEPTED'
      date_time = dfdatetime_posix_time.PosixTime(timestamp=timestamp)
      event = time_events.DateTimeValuesEvent(date_time, 'Call from Skype')
      parser_mediator.ProduceEventWithEventData(event, event_data)

      try:
        call_duration = self._GetRowValue(query_hash, row, 'call_duration')
        call_duration = int(call_duration)
      except (ValueError, TypeError):
        parser_mediator.ProduceExtractionWarning(
            'unable to determine when call: {0:s} was finished.'.format(
                call_identifier))
        call_duration = None

      if call_duration:
        timestamp += call_duration
        event_data.call_type = 'FINISHED'
        date_time = dfdatetime_posix_time.PosixTime(timestamp=timestamp)
        event = time_events.DateTimeValuesEvent(date_time, 'Call from Skype')
        parser_mediator.ProduceEventWithEventData(event, event_data)

Parses a call.

Args:
parser_mediator (ParserMediator): mediates interactions between parsers
and other components, such as storage and dfvfs.
query (str): query that created the row.
row (sqlite3.Row): row resulting from query.
query (Optional[str]): query.


def order_by(self, *args):

        if self._solr_locked:
            raise Exception("Query already executed, no changes can be made."
                            "%s %s" % (self._solr_query, self._solr_params)
                            )

        for arg in args:
            if arg.startswith('-'):
                self._solr_params['sort'][arg[1:]] = 'desc'
            else:
                self._solr_params['sort'][arg] = 'asc'

Applies query ordering.

New parameters are appended to current ones, overwriting existing ones.

Args:
**args: Order by fields names.
Defaults to ascending, prepend with hypen (-) for desecending ordering.


def write_label_list(path, label_list):

    entries = []
    for label in label_list:
        entries.append([label.start, label.end, label.value])

    textfile.write_separated_lines(path, entries, separator='\t')

Writes the given `label_list` to an audacity label file.

Args:
path (str): Path to write the file to.
label_list (audiomate.annotations.LabelList): Label list


def get_info(
        self,
        userSpecifier,
        **kwargs
    ):

        request = Request(
            'GET',
            '/v3/users/{userSpecifier}'
        )

        request.set_path_param(
            'userSpecifier',
            userSpecifier
        )

        response = self.ctx.request(request)

        if response.content_type is None:
            return response

        if not response.content_type.startswith("application/json"):
            return response

        jbody = json.loads(response.raw_body)

        parsed_body = {}

        if str(response.status) == "200":
            if jbody.get('userInfo') is not None:
                parsed_body['userInfo'] = \
                    self.ctx.user.UserInfo.from_dict(
                        jbody['userInfo'],
                        self.ctx
                    )

        elif str(response.status) == "401":
            if jbody.get('errorCode') is not None:
                parsed_body['errorCode'] = \
                    jbody.get('errorCode')

            if jbody.get('errorMessage') is not None:
                parsed_body['errorMessage'] = \
                    jbody.get('errorMessage')

        elif str(response.status) == "403":
            if jbody.get('errorCode') is not None:
                parsed_body['errorCode'] = \
                    jbody.get('errorCode')

            if jbody.get('errorMessage') is not None:
                parsed_body['errorMessage'] = \
                    jbody.get('errorMessage')

        elif str(response.status) == "405":
            if jbody.get('errorCode') is not None:
                parsed_body['errorCode'] = \
                    jbody.get('errorCode')

            if jbody.get('errorMessage') is not None:
                parsed_body['errorMessage'] = \
                    jbody.get('errorMessage')

        else:
            parsed_body = jbody

        response.body = parsed_body

        return response

Fetch the user information for the specified user. This endpoint is
intended to be used by the user themself to obtain their own
information.

Args:
userSpecifier:
The User Specifier

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


def _GetPathSegmentIndexForOccurrenceWeights(
      self, occurrence_weights, value_weights):

    largest_weight = occurrence_weights.GetLargestWeight()

    if largest_weight > 0:
      occurrence_weight_indexes = occurrence_weights.GetIndexesForWeight(
          largest_weight)
      number_of_occurrence_indexes = len(occurrence_weight_indexes)
    else:
      number_of_occurrence_indexes = 0

    path_segment_index = None
    if number_of_occurrence_indexes == 0:
      path_segment_index = self._GetPathSegmentIndexForValueWeights(
          value_weights)

    elif number_of_occurrence_indexes == 1:
      path_segment_index = occurrence_weight_indexes[0]

    else:
      largest_weight = 0

      for occurrence_index in occurrence_weight_indexes:
        value_weight = value_weights.GetWeightForIndex(occurrence_index)

        if not path_segment_index or largest_weight < value_weight:
          largest_weight = value_weight
          path_segment_index = occurrence_index

    return path_segment_index

Retrieves the index of the path segment based on occurrence weights.

Args:
occurrence_weights: the occurrence weights object (instance of
_PathSegmentWeights).
value_weights: the value weights object (instance of _PathSegmentWeights).

Returns:
An integer containing the path segment index.


def get_nested_streams(dmap):

    return list({s for dmap in get_nested_dmaps(dmap) for s in dmap.streams})

Recurses supplied DynamicMap to find all streams

Args:
dmap: DynamicMap to recurse to look for streams

Returns:
List of streams that were found


def __init__(self, cache_folder, genome_build):

        self.api_version = ('1')
        self.genome_build = genome_build
        self.today = datetime.today()

        if not os.path.exists(cache_folder):
            os.mkdir(cache_folder)

        path = os.path.join(cache_folder, "ensembl_cache.db")
        if not os.path.exists(path):
            try:
                with sqlite3.connect(path) as conn:
                    with conn as cursor:
                        cursor.execute("CREATE TABLE ensembl " \
                            "(key text PRIMARY KEY, genome_build text, " \
                            "cache_date text, api_version text, data blob)")
            except sqlite3.OperationalError:
                time.sleep(random.uniform(1, 5))

        self.conn = sqlite3.connect(path)
        self.conn.row_factory = sqlite3.Row

initialise the class with the local cache folder

Args:
cache_folder: path to the cache


def get_historical_data(nmr_problems):
    observations = np.tile(np.array([[10, 256, 202, 97]]), (nmr_problems, 1))
    nmr_tanks_ground_truth = (np.ones((nmr_problems,)) * 276)
    return (observations, nmr_tanks_ground_truth)

Get the historical tank data.

Args:
nmr_problems (int): the number of problems

Returns:
tuple: (observations, nmr_tanks_ground_truth)


def force_rerun(flag, outfile):
    if flag:
        return True
    elif ((not flag) and (not op.exists(outfile))):
        return True
    elif ((not flag) and (not is_non_zero_file(outfile))):
        return True
    else:
        return False

Check if we should force rerunning of a command if an output file exists.

Args:
flag (bool): Flag to force rerun.
outfile (str): Path to output file which may already exist.

Returns:
bool: If we should force rerunning of a command

Examples:
>>> force_rerun(flag=True, outfile='/not/existing/file.txt')
True

>>> force_rerun(flag=False, outfile='/not/existing/file.txt')
True

>>> force_rerun(flag=True, outfile='./utils.py')
True

>>> force_rerun(flag=False, outfile='./utils.py')
False


def quantile_for_single_value(self, **kwargs):
    if self._is_transposed:
        kwargs['axis'] = (kwargs.get('axis', 0) ^ 1)
        return self.transpose().quantile_for_single_value(**kwargs)
    axis = kwargs.get('axis', 0)
    q = kwargs.get('q', 0.5)
    assert (type(q) is float)

    def quantile_builder(df, **kwargs):
        try:
            return pandas.DataFrame.quantile(df, **kwargs)
        except ValueError:
            return pandas.Series()
    func = self._build_mapreduce_func(quantile_builder, **kwargs)
    result = self._full_axis_reduce(axis, func)
    if (axis == 0):
        result.index = [q]
    else:
        result.columns = [q]
    return result

Returns quantile of each column or row.

Returns:
A new QueryCompiler object containing the quantile of each column or row.


def guaranteed_no_diff(modular_file_path, dependencies, models_in_diff):
    model_name = modular_file_path.rsplit('modular_', 1)[1].replace('.py', '')
    if model_name in models_in_diff:
        return False
    for dep in dependencies[modular_file_path]:
        dependency_model_name = dep.split('.')[-2]
        if dependency_model_name in models_in_diff:
            return False
    return True

Returns whether it is guaranteed to have no differences between the modular file and the modeling file.

Model is in the diff -> not guaranteed to have no differences
Dependency is in the diff -> not guaranteed to have no differences
Otherwise -> guaranteed to have no differences

Args:
modular_file_path: The path to the modular file.
dependencies: A dictionary containing the dependencies of each modular file.
models_in_diff: A set containing the names of the models that have been modified.

Returns:
A boolean indicating whether the model (code and tests) is guaranteed to have no differences.