def encipher_vigenere(plaintext, plain_vocab, key):

  ciphertext = []

  layers = [
      ShiftEncryptionLayer(plain_vocab, i) for i in range(len(plain_vocab))
  ]

  for i, sentence in enumerate(plaintext):
    cipher_sentence = []
    for j, character in enumerate(sentence):
      key_idx = key[j % len(key)]
      encrypted_char = layers[key_idx].encrypt_character(character)
      cipher_sentence.append(encrypted_char)
    ciphertext.append(cipher_sentence)

  return ciphertext

Encrypt plain text with given key.

Args:
plaintext (list of list of Strings): a list of plain text to encrypt.
plain_vocab (list of Integer): unique vocabularies being used.
key (list of Integer): key to encrypt cipher using Vigenere table.

Returns:
ciphertext (list of Strings): encrypted plain text.


def ValidateFeedStartAndExpirationDates(self, problems, first_date, last_date, first_date_origin, last_date_origin, today):
    warning_cutoff = (today + datetime.timedelta(days=60))
    if (last_date < warning_cutoff):
        problems.ExpirationDate(time.mktime(last_date.timetuple()), last_date_origin)
    if (first_date > today):
        problems.FutureService(time.mktime(first_date.timetuple()), first_date_origin)

Validate the start and expiration dates of the feed.
Issue a warning if it only starts in the future, or if
it expires within 60 days.

Args:
problems: The problem reporter object
first_date: A date object representing the first day the feed is active
last_date: A date object representing the last day the feed is active
today: A date object representing the date the validation is being run on

Returns:
None


def tags(self, value):

        if value == self._defaults['tags'] and 'tags' in self._values:
            del self._values['tags']
        else:
            self._values['tags'] = value

The tags property.

Args:
value (hash). the property value.


def console_set_char_background(con: tcod.console.Console, x: int, y: int, col: Tuple[(int, int, int)], flag: int=BKGND_SET) -> None:
    lib.TCOD_console_set_char_background(_console(con), x, y, col, flag)

Change the background color of x,y to col using a blend mode.

Args:
con (Console): Any Console instance.
x (int): Character x position from the left.
y (int): Character y position from the top.
col (Union[Tuple[int, int, int], Sequence[int]]):
An (r, g, b) sequence or Color instance.
flag (int): Blending mode to use, defaults to BKGND_SET.


def lattice_2_lmpbox(lattice, origin=(0, 0, 0)):

    a, b, c = lattice.abc
    xlo, ylo, zlo = origin
    xhi = a + xlo
    m = lattice.matrix
    xy = np.dot(m[1], m[0] / a)
    yhi = np.sqrt(b ** 2 - xy ** 2) + ylo
    xz = np.dot(m[2], m[0] / a)
    yz = (np.dot(m[1], m[2]) - xy * xz) / (yhi - ylo)
    zhi = np.sqrt(c ** 2 - xz ** 2 - yz ** 2) + zlo
    tilt = None if lattice.is_orthogonal else [xy, xz, yz]
    rot_matrix = np.linalg.solve([[xhi - xlo, 0, 0],
                                  [xy, yhi - ylo, 0],
                                  [xz, yz, zhi - zlo]], m)
    bounds = [[xlo, xhi], [ylo, yhi], [zlo, zhi]]
    symmop = SymmOp.from_rotation_and_translation(rot_matrix, origin)
    return LammpsBox(bounds, tilt), symmop

Converts a lattice object to LammpsBox, and calculates the symmetry
operation used.

Args:
lattice (Lattice): Input lattice.
origin: A (3,) array/list of floats setting lower bounds of
simulation box. Default to (0, 0, 0).

Returns:
LammpsBox, SymmOp


def dilated_conv_stack(name, x, mid_channels, output_channels, dilation_rates, activation='relu', dropout=0.0):
    with tf.variable_scope(name, reuse=tf.AUTO_REUSE):
        output = 0.0
        for (dil_ind, dil_rate) in enumerate(dilation_rates):
            curr_out = conv_stack(('dil_%d' % dil_ind), x, mid_channels=mid_channels, output_channels=output_channels, dilations=dil_rate, activation=activation, dropout=dropout)
            output += curr_out
        return output

Dilated convolutional stack.

Features at different rates are computed independently using a 3 layer
convolutional stack and added.

Args:
name: variable scope.
x: 5-D Tensor.
mid_channels: Number of output channels of the first layer in the conv
stack.
output_channels: Number of output channels of the last layer.
dilation_rates: A list of dilation rates.
activation: Can be either "relu" or "gatu"
dropout: dropout.
Returns:
output: 5-D Tensor.


def id_token_jwt_grant(request, token_uri, assertion):
    body = {'assertion': assertion, 'grant_type': _JWT_GRANT_TYPE}
    response_data = _token_endpoint_request(request, token_uri, body)
    try:
        id_token = response_data['id_token']
    except KeyError as caught_exc:
        new_exc = exceptions.RefreshError('No ID token in response.', response_data)
        six.raise_from(new_exc, caught_exc)
    payload = jwt.decode(id_token, verify=False)
    expiry = datetime.datetime.utcfromtimestamp(payload['exp'])
    return (id_token, expiry, response_data)

Implements the JWT Profile for OAuth 2.0 Authorization Grants, but
requests an OpenID Connect ID Token instead of an access token.

This is a variant on the standard JWT Profile that is currently unique
to Google. This was added for the benefit of authenticating to services
that require ID Tokens instead of access tokens or JWT bearer tokens.

Args:
request (google.auth.transport.Request): A callable used to make
HTTP requests.
token_uri (str): The OAuth 2.0 authorization server's token endpoint
URI.
assertion (str): JWT token signed by a service account. The token's
payload must include a ``target_audience`` claim.

Returns:
Tuple[str, Optional[datetime], Mapping[str, str]]:
The (encoded) Open ID Connect ID Token, expiration, and additional
data returned by the endpoint.

Raises:
google.auth.exceptions.RefreshError: If the token endpoint returned
an error.


def id_transcripts_by_gene(self, build='37'):

        hgnc_id_transcripts = {}
        LOG.info("Fetching all id transcripts")
        for gene_obj in self.hgnc_collection.find({'build': build}):
            hgnc_id = gene_obj['hgnc_id']
            id_transcripts = self.get_id_transcripts(hgnc_id=hgnc_id, build=build)
            hgnc_id_transcripts[hgnc_id] = id_transcripts

        return hgnc_id_transcripts

Return a dictionary with hgnc_id as keys and a set of id transcripts as value

Args:
build(str)

Returns:
hgnc_id_transcripts(dict)


def _bfs_sort(self, start):

        pathstates = {}

        queue = []

        queue.append([0, start])
        pathstates[start.stateid] = 0
        while queue:

            leaf = queue.pop(0)
            node = leaf[1]
            pathlen = leaf[0]

            for arc in node.arcs:
                next_state = self.mma[arc.nextstate]
                if next_state.stateid not in pathstates:
                    queue.append([pathlen + 1, next_state])
                    pathstates[next_state.stateid] = pathlen + 1
        orderedstatesdict = OrderedDict(
            sorted(
                pathstates.items(),
                key=lambda x: x[1],
                reverse=False))
        for state in self.mma.states:
            orderedstatesdict[state.stateid] = state
        orderedstates = [x[1] for x in list(orderedstatesdict.items())]
        return orderedstates

maintain a map of states distance using BFS
Args:
start (fst state): The initial DFA state
Returns:
list: An ordered list of DFA states
using path distance


def validate_id(tx_body):

        tx_body = rapidjson.loads(rapidjson.dumps(tx_body))

        try:
            proposed_tx_id = tx_body['id']
        except KeyError:
            raise InvalidHash('No transaction id found!')

        tx_body['id'] = None

        tx_body_serialized = Transaction._to_str(tx_body)
        valid_tx_id = Transaction._to_hash(tx_body_serialized)

        if proposed_tx_id != valid_tx_id:
            err_msg = ("The transaction's id '{}' isn't equal to "
                       "the hash of its body, i.e. it's not valid.")
            raise InvalidHash(err_msg.format(proposed_tx_id))

Validate the transaction ID of a transaction

Args:
tx_body (dict): The Transaction to be transformed.


def markdown_to_safe_html(markdown_string):

  warning = ''

  if isinstance(markdown_string, six.binary_type):
    markdown_string_decoded = markdown_string.decode('utf-8')

    markdown_string = markdown_string_decoded.replace(u'\x00', u'')
    num_null_bytes = len(markdown_string_decoded) - len(markdown_string)
    if num_null_bytes:
      warning = ('<!-- WARNING: discarded %d null bytes in markdown string '
                 'after UTF-8 decoding -->\n') % num_null_bytes

  string_html = markdown.markdown(
      markdown_string, extensions=['markdown.extensions.tables'])
  string_sanitized = bleach.clean(
      string_html, tags=_ALLOWED_TAGS, attributes=_ALLOWED_ATTRIBUTES)
  return warning + string_sanitized

Convert Markdown to HTML that's safe to splice into the DOM.

Arguments:
markdown_string: A Unicode string or UTF-8--encoded bytestring
containing Markdown source. Markdown tables are supported.

Returns:
A string containing safe HTML.


def _get_example_from_properties(self, spec):

        local_spec = deepcopy(spec)

        additional_property = False
        if 'additionalProperties' in local_spec:
            additional_property = True
            if 'properties' not in local_spec:
                local_spec['properties'] = {}
            local_spec['properties'].update({
                'any_prop1': local_spec['additionalProperties'],
                'any_prop2': local_spec['additionalProperties'],
            })
            del(local_spec['additionalProperties'])
            required = local_spec.get('required', [])
            required += ['any_prop1', 'any_prop2']
            local_spec['required'] = required

        example = {}
        properties = local_spec.get('properties')
        if properties is not None:
            required = local_spec.get('required', properties.keys())

            for inner_name, inner_spec in properties.items():
                if inner_name not in required:
                    continue
                partial = self.get_example_from_prop_spec(inner_spec)

                if isinstance(partial, list):
                    partial = partial[0]
                example[inner_name] = partial

        return example, additional_property

Get example from the properties of an object defined inline.

Args:
prop_spec: property specification you want an example of.

Returns:
An example for the given spec
A boolean, whether we had additionalProperties in the spec, or not


class WhisperProcessor(ProcessorMixin):
    feature_extractor_class = 'WhisperFeatureExtractor'
    tokenizer_class = 'WhisperTokenizer'

    def __init__(self, feature_extractor, tokenizer):
        super().__init__(feature_extractor, tokenizer)
        self.current_processor = self.feature_extractor
        self._in_target_context_manager = False

    def get_decoder_prompt_ids(self, task=None, language=None, no_timestamps=True):
        return self.tokenizer.get_decoder_prompt_ids(task=task, language=language, no_timestamps=no_timestamps)

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

        if self._in_target_context_manager:
            return self.current_processor(*args, **kwargs)
        audio = kwargs.pop('audio', None)
        sampling_rate = kwargs.pop('sampling_rate', None)
        text = kwargs.pop('text', None)
        if len(args) > 0:
            audio = args[0]
            args = args[1:]
        if audio is None and text is None:
            raise ValueError('You need to specify either an `audio` or `text` input to process.')
        if audio is not None:
            inputs = self.feature_extractor(audio, *args, sampling_rate=sampling_rate, **kwargs)
        if text is not None:
            encodings = self.tokenizer(text, **kwargs)
        if text is None:
            return inputs
        elif audio is None:
            return encodings
        else:
            inputs['labels'] = encodings['input_ids']
            return inputs

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

        return self.tokenizer.batch_decode(*args, **kwargs)

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

        return self.tokenizer.decode(*args, **kwargs)

    def get_prompt_ids(self, text: str, return_tensors='np'):
        return self.tokenizer.get_prompt_ids(text, return_tensors=return_tensors)

Constructs a Whisper processor which wraps a Whisper feature extractor and a Whisper tokenizer into a single
processor.

[`WhisperProcessor`] offers all the functionalities of [`WhisperFeatureExtractor`] and [`WhisperTokenizer`]. See
the [`~WhisperProcessor.__call__`] and [`~WhisperProcessor.decode`] for more information.

Args:
feature_extractor (`WhisperFeatureExtractor`):
An instance of [`WhisperFeatureExtractor`]. The feature extractor is a required input.
tokenizer (`WhisperTokenizer`):
An instance of [`WhisperTokenizer`]. The tokenizer is a required input.


def add_read(
        self,
        read_tuple_id,
        bases,
        qualities,
        segments,
    ):

        assert type(bases) is str, "Wrong type of bases: '{}'".format(bases)
        assert type(qualities) is str, "Wrong type of qualities: '{}'".format(qualities)
        assert type(segments) is tuple or type(segments) is list

        if self.current_read_tuple_id != read_tuple_id:
            self.flush_read_tuple()
        self.current_read_tuple_id = read_tuple_id

        self.seqs_bases.append(bases)
        self.seqs_qualities.append(qualities)
        self.segments.extend(segments)

Add a new read to the current buffer. If it is a new read tuple (detected from ID), the buffer will be flushed.

Args:
read_tuple_id (int): ID of the read tuple.
bases (str): Sequence of bases.
qualities (str): Sequence of FASTQ qualities.
segments (list of rnftools.rnfformat.segment): List of segments constituting the read.


def bullet_base_pose_to_world_pose(self, pose_in_base):

        pose_in_base = T.pose2mat(pose_in_base)

        base_pos_in_world = np.array(p.getBasePositionAndOrientation(self.ik_robot)[0])
        base_orn_in_world = np.array(p.getBasePositionAndOrientation(self.ik_robot)[1])
        base_pose_in_world = T.pose2mat((base_pos_in_world, base_orn_in_world))

        pose_in_world = T.pose_in_A_to_pose_in_B(
            pose_A=pose_in_base, pose_A_in_B=base_pose_in_world
        )
        return T.mat2pose(pose_in_world)

Convert a pose in the base frame to a pose in the world frame.

Args:
pose_in_base: a (pos, orn) tuple.

Returns:
pose_in world: a (pos, orn) tuple.


def GetUpdates(self, source, search_base, search_filter, search_scope, since):
    if self.conf.get('ad'):
        self.attrs.append('whenChanged')
    else:
        self.attrs.append('modifyTimestamp')
    if since is not None:
        ts = self.FromTimestampToLdap(since)
        if self.conf.get('ad'):
            ts = int(ts.rstrip('.0Z')) + 1
            ts = '%s.0Z' % ts
            search_filter = '(&%s(whenChanged>=%s))' % (search_filter, ts)
        else:
            ts = int(ts.rstrip('Z')) + 1
            ts = '%sZ' % ts
            search_filter = '(&%s(modifyTimestamp>=%s))' % (search_filter, ts)
    if search_scope == 'base':
        search_scope = ldap.SCOPE_BASE
    elif search_scope in ['one', 'onelevel']:
        search_scope = ldap.SCOPE_ONELEVEL
    elif search_scope in ['sub', 'subtree']:
        search_scope = ldap.SCOPE_SUBTREE
    else:
        raise error.ConfigurationError('Invalid scope: %s' % search_scope)
    source.Search(search_base=search_base, search_filter=search_filter, search_scope=search_scope, attrs=self.attrs)
    max_ts = None
    data_map = self.CreateMap()
    for obj in source:
        for field in self.essential_fields:
            if field not in obj:
                logging.warn('invalid object passed: %r not in %r', field, obj)
                raise ValueError('Invalid object passed: %r', obj)
        if self.conf.get('ad'):
            obj_ts = self.FromLdapToTimestamp(obj['whenChanged'][0])
        else:
            try:
                obj_ts = self.FromLdapToTimestamp(obj['modifyTimestamp'][0])
            except KeyError:
                obj_ts = 0
        if max_ts is None or obj_ts > max_ts:
            max_ts = obj_ts
        try:
            if not data_map.Add(self.Transform(obj)):
                logging.info('could not add obj: %r', obj)
        except AttributeError as e:
            logging.warning('error %r, discarding malformed obj: %r', str(e), obj)
    self.PostProcess(data_map, source, search_filter, search_scope)
    data_map.SetModifyTimestamp(max_ts)
    return data_map

Get updates from a source.

Args:
source: a data source
search_base: the LDAP base of the tree
search_filter: the LDAP object filter
search_scope:  the LDAP scope filter, one of 'base', 'one', or 'sub'.
since: a timestamp to get updates since (None for 'get everything')

Returns:
a tuple containing the map of updates and a maximum timestamp

Raises:
error.ConfigurationError: scope is invalid
ValueError: an object in the source map is malformed


def hgnc_id(self, hgnc_symbol, build='37'):
    query = {'hgnc_symbol': hgnc_symbol, 'build': build}
    projection = {'hgnc_id': 1, '_id': 0}
    res = self.hgnc_collection.find(query, projection)
    if (res.count() > 0):
        return res[0]['hgnc_id']
    else:
        return None

Query the genes with a hgnc symbol and return the hgnc id

Args:
hgnc_symbol(str)
build(str)

Returns:
hgnc_id(int)


def intrusion_set(self, name, **kwargs):

        group_obj = IntrusionSet(name, **kwargs)
        return self._group(group_obj)

Add Intrusion Set data to Batch object.

Args:
name (str): The name for this Group.
date_added (str, kwargs): The date timestamp the Indicator was created.
xid (str, kwargs): The external id for this Group.

Returns:
obj: An instance of IntrusionSet.


def copy_code(source: message.Message, target: message.Message) -> None:
    if not fhir_types.is_type_or_profile_of_code(source.DESCRIPTOR):
        raise fhir_errors.InvalidFhirError(f'Source: {source.DESCRIPTOR.full_name} is not type or profile of Code.')
    if not fhir_types.is_type_or_profile_of_code(target.DESCRIPTOR):
        raise fhir_errors.InvalidFhirError(f'Target: {target.DESCRIPTOR.full_name} is not type or profile of Code.')
    if proto_utils.are_same_message_type(source.DESCRIPTOR, target.DESCRIPTOR):
        target.CopyFrom(source)
        return
    source_value_field = source.DESCRIPTOR.fields_by_name.get('value')
    target_value_field = target.DESCRIPTOR.fields_by_name.get('value')
    if source_value_field is None or target_value_field is None:
        raise fhir_errors.InvalidFhirError(f'Unable to copy code from {source.DESCRIPTOR.full_name} to {target.DESCRIPTOR.full_name}.')
    proto_utils.copy_common_field(source, target, 'id')
    proto_utils.copy_common_field(source, target, 'extension')
    if source_value_field.type not in _CODE_TYPES or target_value_field.type not in _CODE_TYPES:
        raise ValueError(f'Unable to copy from {source.DESCRIPTOR.full_name} to {target.DESCRIPTOR.full_name}. Must have a field of TYPE_ENUM or TYPE_STRING.')
    source_value = proto_utils.get_value_at_field(source, source_value_field)
    if source_value_field.type == target_value_field.type:
        proto_utils.set_value_at_field(target, target_value_field, source_value)
    elif source_value_field.type == descriptor.FieldDescriptor.TYPE_STRING:
        source_enum_value = code_string_to_enum_value_descriptor(source_value, target_value_field.enum_type)
        proto_utils.set_value_at_field(target, target_value_field, source_enum_value.number)
    elif source_value_field.type == descriptor.FieldDescriptor.TYPE_ENUM:
        source_string_value = enum_value_descriptor_to_code_string(source_value_field.enum_type.values_by_number[source_value])
        proto_utils.set_value_at_field(target, target_value_field, source_string_value)
    else:
        raise ValueError(f'Unexpected generic value field type: {source_value_field.type}. Must be a field of TYPE_ENUM or TYPE_STRING in order to copy.')

Adds all fields from source to target.

Args:
source: The FHIR Code instance to copy from.
target: The target FHIR Code instance to copy to.


def invoke_process_element(self, sdf_invoker, output_processor, element, restriction, watermark_estimator_state, *args, **kwargs):
    assert isinstance(sdf_invoker, DoFnInvoker)

    class CheckpointState(object):

        def __init__(self):
            self.checkpointed = None
            self.residual_restriction = None
    checkpoint_state = CheckpointState()

    def initiate_checkpoint():
        with self._checkpoint_lock:
            if checkpoint_state.checkpointed:
                return
            checkpoint_state.checkpointed = object()
        split = sdf_invoker.try_split(0)
        if split:
            _, checkpoint_state.residual_restriction = split
        else:
            checkpoint_state.checkpointed = None
    output_processor.reset()
    Timer(self._max_duration, initiate_checkpoint).start()
    sdf_invoker.invoke_process(element, additional_args=args, restriction=restriction, watermark_estimator_state=watermark_estimator_state)
    assert output_processor.output_iter is not None
    output_count = 0
    process_continuation = None
    for output in output_processor.output_iter:
        assert not process_continuation
        if isinstance(output, ProcessContinuation):
            initiate_checkpoint()
            process_continuation = output
            continue
        yield output
        output_count += 1
        if self._max_num_outputs and output_count >= self._max_num_outputs:
            initiate_checkpoint()
    result = SDFProcessElementInvoker.Result(residual_restriction=checkpoint_state.residual_restriction) if checkpoint_state.residual_restriction else SDFProcessElementInvoker.Result()
    yield result

Invokes `process()` method of a Splittable `DoFn` for a given element.

Args:
sdf_invoker: a `DoFnInvoker` for the Splittable `DoFn`.
element: the element to process
Returns:
a `SDFProcessElementInvoker.Result` object.


def join(table1, table2, on=None, how='inner', name=None):
    if (how not in ('inner', 'left')):
        ItsdbError("Only 'inner' and 'left' join methods are allowed.")
    on = _join_pivot(on, table1, table2)
    fields = _RelationJoin(table1.fields, table2.fields, on=on)
    get_key = (lambda rec: tuple((rec.get(k) for k in on)))
    key_indices = set((table2.fields.index(k) for k in on))
    right = defaultdict(list)
    for rec in table2:
        right[get_key(rec)].append([c for (i, c) in enumerate(rec) if (i not in key_indices)])
    rfill = [f.default_value() for f in table2.fields if (f.name not in on)]
    joined = []
    for lrec in table1:
        k = get_key(lrec)
        if ((how == 'left') or (k in right)):
            joined.extend(((lrec + rrec) for rrec in right.get(k, [rfill])))
    return Table(fields, joined)

Join two tables and return the resulting Table object.

Fields in the resulting table have their names prefixed with their
corresponding table name. For example, when joining `item` and
`parse` tables, the `i-input` field of the `item` table will be
named `item:i-input` in the resulting Table. Pivot fields (those
in *on*) are only stored once without the prefix.

Both inner and left joins are possible by setting the *how*
parameter to `inner` and `left`, respectively.

.. warning::

Both *table2* and the resulting joined table will exist in
memory for this operation, so it is not recommended for very
large tables on low-memory systems.

Args:
table1 (:class:`Table`): the left table to join
table2 (:class:`Table`): the right table to join
on (str): the shared key to use for joining; if `None`, find
shared keys using the schemata of the tables
how (str): the method used for joining (`"inner"` or `"left"`)
name (str): the name assigned to the resulting table


def sample(input_placeholder, logits, seed=None, max_length=1024, temperature=1.0):
    assert (temperature > 0), 'Temperature must be greater than 0.'
    if (not seed):
        seed = chr((ord('A') + random.randint(0, 25)))
    result = ''
    recurrent_runner = pt.train.RecurrentRunner()
    recurrent_runner.reset()
    for c in seed[:(- 1)]:
        recurrent_runner.run([logits], {input_placeholder: data_utils.convert_to_int(c)})
        result += c
    ci = ord(seed[(- 1)])
    while ((len(result) < max_length) and (ci != data_utils.EOS)):
        result += chr(ci)
        logit_result = recurrent_runner.run([logits], {input_placeholder: ci})[0][0]
        logit_result /= temperature
        logit_result -= logit_result.max()
        distribution = numpy.exp(logit_result)
        distribution /= distribution.sum()
        distribution -= 1e-08
        ci = numpy.argmax(numpy.random.multinomial(1, distribution))
    result += chr(ci)
    return result

Samples from the LSTM model.

Sampling is done by first running either the seed or an arbitrary character
through the model and then drawing the next character from the probability
distribution definted by `softmax`.

Args:
input_placeholder: A placeholder that expects a scalar feed.
logits: The logits.  This works with the logits so that it can apply the
temperature.
seed: Either a string of characters to prime the network or None.
max_length: The maximum length to draw in case EOS is not reached.
temperature: A value that is used to renormalize the inputs.  A higher value
selects less likely choices.
Returns:
A string that was sampled from the model.


def aside_view_declaration(self, view_name):
    if (view_name in self._combined_asides):
        return getattr(self, self._combined_asides[view_name])
    else:
        return None

Find and return a function object if one is an aside_view for the given view_name

Aside methods declare their view provision via @XBlockAside.aside_for(view_name)
This function finds those declarations for a block.

Arguments:
view_name (string): the name of the view requested.

Returns:
either the function or None


def get_suffixes(arr):

    arr = tuple(arr)
    return [arr]
    return (arr[i:] for i in range(len(arr)))

Returns all possible suffixes of an array (lazy evaluated)
Args:
arr: input array
Returns:
Array of all possible suffixes (as tuples)


def sql_column_like_drug(self, column_name: str) -> str:
    clauses = ['{col} LIKE {fragment}'.format(col=column_name, fragment=sql_string_literal(f)) for f in self.sql_like_fragments]
    return '({})'.format(' OR '.join(clauses))

Returns SQL like

.. code-block:: sql

(column_name LIKE '%drugname1%' OR
column_name LIKE '%drugname2%')

for the drug names that this Drug object knows about.

Args:
column_name: column name, pre-escaped if necessary

Returns:
SQL fragment as above


def main():
    parser = argparse.ArgumentParser(description='Cherry picking automation.')
    parser.add_argument('--version', help='<new_major_ver>.<new_minor_ver>.<new_patch_ver>', default='')
    parser.add_argument('--nightly', help='disable the service provisioning step', action='store_true')
    args = parser.parse_args()
    check_all_files()
    old_version = get_current_semver_version()
    if args.nightly:
        if args.version:
            new_version = Version.parse_from_string(args.version, NIGHTLY_VERSION)
            new_version.set_identifier_string('-dev' + time.strftime('%Y%m%d'))
        else:
            new_version = Version(old_version.major, str(old_version.minor), old_version.patch, '-dev' + time.strftime('%Y%m%d'), NIGHTLY_VERSION)
    else:
        new_version = Version.parse_from_string(args.version, SNAPSHOT_VERSION)
    update_tf_version_bzl(old_version, new_version)
    update_bazelrc(old_version, new_version)
    update_readme(old_version, new_version)
    print('Major: %s -> %s' % (old_version.major, new_version.major))
    print('Minor: %s -> %s' % (old_version.minor, new_version.minor))
    print('Patch: %s -> %s\n' % (old_version.patch, new_version.patch))
    check_for_old_version(old_version, new_version)

This script updates all instances of version in the tensorflow directory.

Requirements:
version: The version tag
OR
nightly: Create a nightly tag with current date

Raises:
RuntimeError: If the script is not being run from tf source dir


def validate(self, institute, case, user, link, variant, validate_type):

        if not validate_type in SANGER_OPTIONS:
            LOG.warning("Invalid validation string: %s", validate_type)
            LOG.info("Validation options: %s", ', '.join(SANGER_OPTIONS))
            return

        updated_variant = self.variant_collection.find_one_and_update(
            {'_id': variant['_id']},
            {'$set': {'validation': validate_type}},
            return_document=pymongo.ReturnDocument.AFTER
        )

        self.create_event(
            institute=institute,
            case=case,
            user=user,
            link=link,
            category='variant',
            verb='validate',
            variant=variant,
            subject=variant['display_name'],
        )
        return updated_variant

Mark validation status for a variant.

Arguments:
institute (dict): A Institute object
case (dict): Case object
user (dict): A User object
link (str): The url to be used in the event
variant (dict): A variant object
validate_type(str): The outcome of validation.
choices=('True positive', 'False positive')

Returns:
updated_variant(dict)


def parse(cls, args):

        parsed = {}

        try:
            (options, args) = cls.optparser.parse_args(args)
        except OptionParsingError as e:
            raise ParseError(e.msg, cls.optparser.format_help())
        except OptionParsingExit as e:
            return None

        parsed['label'] = options.label
        parsed['can_notify'] = options.can_notify
        parsed['name'] = options.name
        parsed['tags'] = options.tags
        parsed["command_type"] = "HadoopCommand"
        parsed['print_logs'] = options.print_logs
        parsed['print_logs_live'] = options.print_logs_live
        parsed['pool'] = options.pool

        if len(args) < 2:
            raise ParseError("Need at least two arguments", cls.usage)

        subcmd = args.pop(0)
        if subcmd not in cls.subcmdlist:
            raise ParseError("First argument must be one of <%s>" %
                             "|".join(cls.subcmdlist))

        parsed["sub_command"] = subcmd
        parsed["sub_command_args"] = " ".join("'" + str(a) + "'" for a in args)

        return parsed

Parse command line arguments to construct a dictionary of command
parameters that can be used to create a command

Args:
`args`: sequence of arguments

Returns:
Dictionary that can be used in create method

Raises:
ParseError: when the arguments are not correct


def filter_by_analysis_period(self, analysis_period):

        self._check_analysis_period(analysis_period)
        _filtered_data = self.filter_by_doys(analysis_period.doys_int)
        _filtered_data.header._analysis_period = analysis_period
        return _filtered_data

Filter the Data Collection based on an analysis period.

Args:
analysis period: A Ladybug analysis period

Return:
A new Data Collection with filtered data


def from_data(cls, data):
    obj = cls()
    with contextlib.closing(BytesIO(data)) as file_handle:
        obj.load_file(file_handle)
    return obj

Load an FCS file from a bytes-like object.

Args:
data: buffer containing contents of an FCS file.

Returns:
FCSParser instance with data loaded


def restrict_with(self, expr: str, error_tag: str = None,
                      error_message: str = None) -> None:

        def parse(x: str) -> Number:
            res = self.parser(x)
            if res is None:
                raise InvalidArgument(expr)
            return res

        def simpl(rng: List[Number]) -> List[Number]:
            return ([rng[0]] if rng[0] == rng[1] else rng)

        def to_num(xs): return [parse(x) for x in xs]
        lo = self.intervals[0][0]
        hi = self.intervals[-1][-1]
        ran = []
        for p in [p.strip() for p in expr.split("|")]:
            r = [i.strip() for i in p.split("..")]
            if len(r) > 2:
                raise InvalidArgument(expr)
            ran.append(r)
        if ran[0][0] != "min":
            lo = parse(ran[0][0])
        if ran[-1][-1] != "max":
            hi = parse(ran[-1][-1])
        self.intervals = (
            [simpl([lo, hi])] if len(ran) == 1 else (
                [simpl([lo, parse(ran[0][-1])])] +
                [to_num(r) for r in ran[1:-1]] +
                [simpl([parse(ran[-1][0]), hi])]))
        if error_tag:
            self.error_tag = error_tag
        if error_message:
            self.error_message = error_message

Combine the receiver with new intervals.

Args:
expr: "range" or "length" expression.
error_tag: error tag of the new expression.
error_message: error message for the new expression.

Raises:
InvalidArgument: If parsing of `expr` fails.


def from_pandas(cls, df, block_partitions_cls):

        new_index = df.index
        new_columns = df.columns
        new_dtypes = df.dtypes
        new_data = block_partitions_cls.from_pandas(df)
        return cls(new_data, new_index, new_columns, dtypes=new_dtypes)

Improve simple Pandas DataFrame to an advanced and superior Modin DataFrame.

Args:
cls: DataManger object to convert the DataFrame to.
df: Pandas DataFrame object.
block_partitions_cls: BlockParitions object to store partitions

Returns:
Returns DataManager containing data from the Pandas DataFrame.


def sharded_filename(filename_tensor: tensor_lib.Tensor, shard: int, num_shards: tensor_lib.Tensor) -> tensor_lib.Tensor:
    return gen_io_ops.sharded_filename(filename_tensor, shard, num_shards)

Append sharding information to a filename.

Args:
filename_tensor: A string tensor.
shard: Integer.  The shard for the filename.
num_shards: An int Tensor for the number of shards.

Returns:
A string tensor.


def _contains_nd(nodes, point):
    min_vals = np.min(nodes, axis=1)
    if (not np.all((min_vals <= point))):
        return False
    max_vals = np.max(nodes, axis=1)
    if (not np.all((point <= max_vals))):
        return False
    return True

r"""Predicate indicating if a point is within a bounding box.

.. note::

There is also a Fortran implementation of this function, which
will be used if it can be built.

Args:
nodes (numpy.ndarray): A set of points.
point (numpy.ndarray): A 1D NumPy array representing a point
in the same dimension as ``nodes``.

Returns:
bool: Indicating containment.


def dropout(inputs, keep_prob=0.5, is_training=True, scope=None):

  if is_training and keep_prob > 0:
    with tf.name_scope(scope, 'Dropout', [inputs]):
      return tf.nn.dropout(inputs, keep_prob)
  else:
    return inputs

Returns a dropout layer applied to the input.

Args:
inputs: the tensor to pass to the Dropout layer.
keep_prob: the probability of keeping each input unit.
is_training: whether or not the model is in training mode. If so, dropout is
applied and values scaled. Otherwise, inputs is returned.
scope: Optional scope for name_scope.

Returns:
a tensor representing the output of the operation.


def AddCustomJsonFieldMapping(message_type, python_name, json_name, package=None):
    if (not issubclass(message_type, messages.Message)):
        raise exceptions.TypecheckError(('Cannot set JSON field mapping for non-message "%s"' % message_type))
    try:
        _ = message_type.field_by_name(python_name)
    except KeyError:
        raise exceptions.InvalidDataError(('Field %s not recognized for type %s' % (python_name, message_type)))
    field_mappings = _JSON_FIELD_MAPPINGS.setdefault(message_type, {})
    _CheckForExistingMappings('field', message_type, python_name, json_name)
    field_mappings[python_name] = json_name

Add a custom wire encoding for a given message field.

This is primarily used in generated code, to handle enum values
which happen to be Python keywords.

Args:
message_type: (messages.Message) A message type
python_name: (basestring) Python name for this value.
json_name: (basestring) JSON name to be used on the wire.
package: (NoneType, optional) No effect, exists for legacy compatibility.


def times_update(self, factor):
    if (factor < 0):
        raise ValueError('The factor must not be negative.')
    elif (factor == 0):
        self.clear()
    else:
        _elements = self._elements
        for element in _elements:
            _elements[element] *= factor
        self._total *= factor

Update each this multiset by multiplying each element's multiplicity with the given scalar factor.

>>> ms = Multiset('aab')
>>> ms.times_update(2)
>>> sorted(ms)
['a', 'a', 'a', 'a', 'b', 'b']

You can also use the ``*=`` operator for the same effect:

>>> ms = Multiset('ac')
>>> ms *= 3
>>> sorted(ms)
['a', 'a', 'a', 'c', 'c', 'c']

For a variant of the operation which does not modify the multiset, but returns a new
multiset instead see :meth:`times`.

Args:
factor: The factor to multiply each multiplicity with.


def build_inputs_with_special_tokens(self, token_ids_0: List[int], token_ids_1: Optional[List[int]]=None) -> List[int]:
    if token_ids_1 is None:
        return token_ids_0
    return token_ids_0 + token_ids_1

Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and
adding special tokens.

This implementation does not add special tokens and this method should be overridden in a subclass.

Args:
token_ids_0 (`List[int]`): The first tokenized sequence.
token_ids_1 (`List[int]`, *optional*): The second tokenized sequence.

Returns:
`List[int]`: The model input with special tokens.


def channel_ready_future(channel):
    fut = channel._loop.create_future()

    def _set_result(state):
        if ((not fut.done()) and (state is _grpc.ChannelConnectivity.READY)):
            fut.set_result(None)
    fut.add_done_callback((lambda f: channel.unsubscribe(_set_result)))
    channel.subscribe(_set_result, try_to_connect=True)
    return fut

Creates a Future that tracks when a Channel is ready.

Cancelling the Future does not affect the channel's state machine.
It merely decouples the Future from channel state machine.

Args:
channel: A Channel object.

Returns:
A Future object that matures when the channel connectivity is
ChannelConnectivity.READY.


def transitive_inputs(self, node_name, include_control=True, include_reversed_ref=False, device_name=None):
    if not self._debug_graphs:
        raise LookupError('Node inputs are not loaded from partition graphs yet.')
    device_name = self._infer_device_name(device_name, node_name)
    input_lists = [self._debug_graphs[device_name].node_inputs]
    if include_control:
        input_lists.append(self._debug_graphs[device_name].node_ctrl_inputs)
    if include_reversed_ref:
        input_lists.append(self._debug_graphs[device_name].node_reversed_ref_inputs)
    tracer = debug_graphs.DFSGraphTracer(input_lists, skip_node_names=self._get_merge_node_names(device_name))
    tracer.trace(node_name)
    return tracer.inputs()

Get the transitive inputs of given node according to partition graphs.

Args:
node_name: Name of the node.
include_control: Include control inputs (True by default).
include_reversed_ref: Whether a ref input, say from A to B, is to be also
considered as an input from B to A. The rationale is that ref inputs
generally let the recipient (e.g., B in this case) mutate the value of
the source (e.g., A in this case). So the reverse direction of the ref
edge reflects the direction of information flow.
device_name: (`str`) name of the device. If there is only one device or if
node_name exists on only one device, this argument is optional.

Returns:
(`list` of `str`) all transitive inputs to the node, as a list of node
names.

Raises:
LookupError: If node inputs and control inputs have not been loaded
from partition graphs yet.


def handle_range(schema, field, validator, parent_schema):
    if (not isinstance(field, fields.Number)):
        return schema
    if validator.min:
        schema['minimum'] = validator.min
        schema['exclusiveMinimum'] = True
    else:
        schema['minimum'] = 0
        schema['exclusiveMinimum'] = False
    if validator.max:
        schema['maximum'] = validator.max
        schema['exclusiveMaximum'] = True
    return schema

Adds validation logic for ``marshmallow.validate.Range``, setting the
values appropriately ``fields.Number`` and it's subclasses.

Args:
schema (dict): The original JSON schema we generated. This is what we
want to post-process.
field (fields.Field): The field that generated the original schema and
who this post-processor belongs to.
validator (marshmallow.validate.Length): The validator attached to the
passed in field.
parent_schema (marshmallow.Schema): The Schema instance that the field
belongs to.

Returns:
dict: A, possibly, new JSON Schema that has been post processed and
altered.


def OpenFile(self, windows_path):
    path_spec = self._path_resolver.ResolvePath(windows_path)
    if (path_spec is None):
        return None
    return self._file_system.GetFileObjectByPathSpec(path_spec)

Opens the file specificed by the Windows path.

Args:
windows_path (str): Windows path to the file.

Returns:
FileIO: file-like object or None if the file does not exist.


def random_uniform(shape, minval=None, maxval=None, dtype=dtypes.float32, seed=None):
    dtype = dtypes.as_dtype(dtype)
    with ops.name_scope('random_uniform'):
        samples = random_ops.random_uniform(shape, dtype=dtype.real_dtype, minval=minval, maxval=maxval, seed=seed)
        if dtype.is_complex:
            if seed is not None:
                seed += 12345
            more_samples = random_ops.random_uniform(shape, dtype=dtype.real_dtype, minval=minval, maxval=maxval, seed=seed)
            samples = math_ops.complex(samples, more_samples)
        return samples

Tensor with (possibly complex) Uniform entries.

Samples are distributed like

```
Uniform[minval, maxval], if dtype is real,
X + iY,  where X, Y ~ Uniform[minval, maxval], if dtype is complex.
```

Args:
shape:  `TensorShape` or Python list.  Shape of the returned tensor.
minval:  `0-D` `Tensor` giving the minimum values.
maxval:  `0-D` `Tensor` giving the maximum values.
dtype:  `TensorFlow` `dtype` or Python dtype
seed:  Python integer seed for the RNG.

Returns:
`Tensor` with desired shape and dtype.


def interpolate_beat_times(self, beat_times: numpy.ndarray, steps_per_beat: numpy.ndarray, n_extend: numpy.ndarray):
    requires_backends(self, ['scipy'])
    beat_times_function = scipy.interpolate.interp1d(np.arange(beat_times.size), beat_times, bounds_error=False, fill_value='extrapolate')
    ext_beats = beat_times_function(np.linspace(0, beat_times.size + n_extend - 1, beat_times.size * steps_per_beat + n_extend))
    return ext_beats

This method takes beat_times and then interpolates that using `scipy.interpolate.interp1d` and the output is
then used to convert raw audio to log-mel-spectrogram.

Args:
beat_times (`numpy.ndarray`):
beat_times is passed into `scipy.interpolate.interp1d` for processing.
steps_per_beat (`int`):
used as an parameter to control the interpolation.
n_extend (`int`):
used as an parameter to control the interpolation.


def model_to_dot(model, show_shapes=False, show_dtype=False, show_layer_names=True, rankdir='TB', expand_nested=False, dpi=200, subgraph=False, show_layer_activations=False, show_trainable=False, **kwargs):
    from keras.src.ops.function import make_node_key
    if not model.built:
        raise ValueError('This model has not yet been built. Build the model first by calling `build()` or by calling the model on a batch of data.')
    from keras.src.models import functional
    from keras.src.models import sequential
    if not check_pydot():
        raise ImportError('You must install pydot (`pip install pydot`) for model_to_dot to work.')
    if subgraph:
        dot = pydot.Cluster(style='dashed', graph_name=model.name)
        dot.set('label', model.name)
        dot.set('labeljust', 'l')
    else:
        dot = pydot.Dot()
        dot.set('rankdir', rankdir)
        dot.set('concentrate', True)
        dot.set('dpi', dpi)
        dot.set('splines', 'ortho')
        dot.set_node_defaults(shape='record')
    if kwargs.pop('layer_range', None) is not None:
        raise ValueError('Argument `layer_range` is no longer supported.')
    if kwargs:
        raise ValueError(f'Unrecognized keyword arguments: {kwargs}')
    kwargs = {'show_layer_names': show_layer_names, 'show_layer_activations': show_layer_activations, 'show_dtype': show_dtype, 'show_shapes': show_shapes, 'show_trainable': show_trainable}
    if isinstance(model, sequential.Sequential):
        layers = model.layers
    elif not isinstance(model, functional.Functional):
        node = make_node(model, **kwargs)
        dot.add_node(node)
        return dot
    else:
        layers = model._operations
    for i, layer in enumerate(layers):
        if expand_nested and isinstance(layer, (functional.Functional, sequential.Sequential)):
            submodel = model_to_dot(layer, show_shapes, show_dtype, show_layer_names, rankdir, expand_nested, subgraph=True, show_layer_activations=show_layer_activations, show_trainable=show_trainable)
            dot.add_subgraph(submodel)
        else:
            node = make_node(layer, **kwargs)
            dot.add_node(node)
    if isinstance(model, sequential.Sequential):
        if not expand_nested:
            for i in range(len(layers) - 1):
                add_edge(dot, layers[i], layers[i + 1])
            return dot
        else:
            layers = model.layers[1:]
    for layer in layers:
        for inbound_index, inbound_node in enumerate(layer._inbound_nodes):
            if isinstance(model, functional.Functional) and make_node_key(layer, inbound_index) not in model._nodes:
                continue
            for input_index, input_tensor in enumerate(inbound_node.input_tensors):
                input_history = input_tensor._keras_history
                if input_history.operation is None:
                    continue
                input_node = input_history.operation._inbound_nodes[input_history.node_index]
                output_index = input_history.tensor_index
                source = input_node.operation
                destination = layer
                if not expand_nested:
                    add_edge(dot, source, layer)
                    continue
                while isinstance(source, (functional.Functional, sequential.Sequential)):
                    source, _, output_index = source.outputs[output_index]._keras_history
                while isinstance(destination, (functional.Functional, sequential.Sequential)):
                    if isinstance(destination, functional.Functional):
                        destination = destination.inputs[input_index]._keras_history.operation
                    else:
                        destination = destination.layers[0]
                add_edge(dot, source, destination)
    return dot

Convert a Keras model to dot format.

Args:
model: A Keras model instance.
show_shapes: whether to display shape information.
show_dtype: whether to display layer dtypes.
show_layer_names: whether to display layer names.
rankdir: `rankdir` argument passed to PyDot,
a string specifying the format of the plot: `"TB"`
creates a vertical plot; `"LR"` creates a horizontal plot.
expand_nested: whether to expand nested Functional models
into clusters.
dpi: Image resolution in dots per inch.
subgraph: whether to return a `pydot.Cluster` instance.
show_layer_activations: Display layer activations (only for layers that
have an `activation` property).
show_trainable: whether to display if a layer is trainable.

Returns:
A `pydot.Dot` instance representing the Keras model or
a `pydot.Cluster` instance representing nested model if
`subgraph=True`.


def plot_generated_images(images, fname):

  fig = plt.figure(figsize=(4, 4))
  canvas = backend_agg.FigureCanvasAgg(fig)

  for i, image in enumerate(images):
    ax = fig.add_subplot(4, 4, i + 1)
    plt.axis('off')
    ax.set_xticklabels([])
    ax.set_yticklabels([])
    ax.imshow(image.reshape(IMAGE_SHAPE[:-1]), cmap='Greys_r')

  fig.tight_layout()
  plt.subplots_adjust(wspace=0.05, hspace=0.05)
  canvas.print_figure(fname, format='png')

Save a synthetic image as a PNG file.

Args:
images: samples of synthetic images generated by the generative network.
fname: Python `str`, filename to save the plot to.


def compute_output_signature(self, input_signature):

    def check_type_return_shape(s):
        if not isinstance(s, tensor.TensorSpec):
            raise TypeError('Only TensorSpec signature types are supported, but saw signature entry: {}.'.format(s))
        return s.shape
    input_shape = nest.map_structure(check_type_return_shape, input_signature)
    output_shape = self.compute_output_shape(input_shape)
    dtype = self._compute_dtype
    if dtype is None:
        input_dtypes = [s.dtype for s in nest.flatten(input_signature)]
        dtype = input_dtypes[0]
    return nest.map_structure(lambda s: tensor.TensorSpec(dtype=dtype, shape=s), output_shape)

Compute the output tensor signature of the layer based on the inputs.

Unlike a TensorShape object, a TensorSpec object contains both shape
and dtype information for a tensor. This method allows layers to provide
output dtype information if it is different from the input dtype.
For any layer that doesn't implement this function,
the framework will fall back to use `compute_output_shape`, and will
assume that the output dtype matches the input dtype.

Args:
input_signature: Single TensorSpec or nested structure of TensorSpec
objects, describing a candidate input for the layer.

Returns:
Single TensorSpec or nested structure of TensorSpec objects, describing
how the layer would transform the provided input.

Raises:
TypeError: If input_signature contains a non-TensorSpec object.


def filter(self, cls, recursive=False):

        source = self.walk_preorder if recursive else self._children
        return [
            codeobj
            for codeobj in source()
            if isinstance(codeobj, cls)
        ]

Retrieves all descendants (including self) that are instances
of a given class.

Args:
cls (class): The class to use as a filter.

Kwargs:
recursive (bool): Whether to descend recursively down the tree.


def opcode_to_name(model, op_code):
    op = model.operatorCodes[op_code]
    code = max(op.builtinCode, op.deprecatedBuiltinCode)
    for name, value in vars(schema_fb.BuiltinOperator).items():
        if value == code:
            return name
    return None

Converts a TFLite op_code to the human readable name.

Args:
model: The input tflite model.
op_code: The op_code to resolve to a readable name.

Returns:
A string containing the human readable op name, or None if not resolvable.


def pyc_load(fp):
    magic_1 = U16(fp.read(2), target=MARSHAL_TARGET)
    magic_2 = U16(fp.read(2), target=MARSHAL_TARGET)
    internals = MAGIC_MAP.get(magic_1)
    if (internals is None):
        raise ValueError(('Invalid or unknown magic (%d).' % magic_1))
    if (magic_2 != 2573):
        raise ValueError(('Invalid secondary magic (%d).' % magic_2))
    timestamp = datetime.datetime.fromtimestamp(U32(fp.read(4), target=MARSHAL_TARGET))
    if (internals['version'] >= 33):
        file_size = U32(fp.read(4))
    else:
        file_size = None
    code_object = marshal_load(fp, internals)
    return PycFile(magic_1, internals, timestamp, file_size, code_object)

Load a .pyc file from a file-like object.

Arguments:
fp(file): The file-like object to read.

Returns:
PycFile: The parsed representation of the .pyc file.


def duration(self):
    duration = 0.0
    if (len(self.events) > 0):
        first = datetime.fromtimestamp(self.events[0]['timestamp'])
        last = datetime.fromtimestamp(self.events[(- 1)]['timestamp'])
        duration = (last - first).total_seconds()
    return duration

Calculate how long the stage took.

Returns:
float: (current) duration of the stage


def _prepare_socket_file(self, socket_path, default_prefix):
    if (socket_path is not None):
        if os.path.exists(socket_path):
            raise Exception('Socket file {} exists!'.format(socket_path))
        socket_dir = os.path.dirname(socket_path)
        try_to_create_directory(socket_dir)
        return socket_path
    return self._make_inc_temp(prefix=default_prefix, directory_name=self._sockets_dir)

Prepare the socket file for raylet and plasma.

This method helps to prepare a socket file.
1. Make the directory if the directory does not exist.
2. If the socket file exists, raise exception.

Args:
socket_path (string): the socket file to prepare.


def _VerifyValues(self, input_sizes=None, filter_sizes=None, out_backprop_sizes=None, strides=None, dilations=None, padding=None, data_format_src='NHWC', data_format_dst='NHWC', expected=None):
    total_size_1 = np.prod(input_sizes)
    total_size_2 = np.prod(out_backprop_sizes)
    x1 = np.arange(1, total_size_1 + 1, dtype=np.float32).reshape(input_sizes)
    x2 = np.arange(1, total_size_2 + 1, dtype=np.float32).reshape(out_backprop_sizes)
    strides = [1] + strides + [1]
    if dilations is not None:
        dilations = [1] + dilations + [1]
    expected = np.reshape(expected, filter_sizes)
    x1 = test_utils.ConvertBetweenDataFormats(x1, data_format_src, data_format_dst)
    x2 = test_utils.ConvertBetweenDataFormats(x2, data_format_src, data_format_dst)
    input_sizes = test_utils.PermuteDimsBetweenDataFormats(input_sizes, data_format_src, data_format_dst)
    out_backprop_sizes = test_utils.PermuteDimsBetweenDataFormats(out_backprop_sizes, data_format_src, data_format_dst)
    strides = test_utils.PermuteDimsBetweenDataFormats(strides, data_format_src, data_format_dst)
    if dilations is not None:
        dilations = test_utils.PermuteDimsBetweenDataFormats(dilations, data_format_src, data_format_dst)
    with self.session() as sess:
        t1 = array_ops.placeholder(dtypes.float32, shape=input_sizes)
        t2 = array_ops.placeholder(dtypes.float32, shape=out_backprop_sizes)
        with self.test_scope():
            tensor = gen_nn_ops.conv2d_backprop_filter(input=t1, filter_sizes=filter_sizes, out_backprop=t2, strides=strides, dilations=dilations, padding=padding, data_format=data_format_dst)
        value = sess.run(tensor, {t1: x1, t2: x2})
        self.assertAllEqual(filter_sizes, value.shape)
        self.assertAllClose(expected, value, 0.001)

Tests that gen_nn_ops.conv2d_backprop_filter produces the right output.

Args:
input_sizes: Input tensor dimensions in
[batch, input_rows, input_cols, input_depth].
filter_sizes: Filter tensor dimensions in
[kernel_rows, kernel_cols, input_depth, output_depth].
out_backprop_sizes: Output gradients tensor dimensions.
strides: Stride.
dilations: Dilations.
padding: Padding type.
data_format_src: Data format input is in.
data_format_dst: Data format verification will run and input is converted
to.
expected: Expected output.


def check(cls, status):
    assert (cls.trigger is not None), 'Invalid ErrorTrap, trigger not set'
    assert (cls.error is not None), 'Invalid ErrorTrap, error not set'
    if (status == cls.trigger):
        raise cls.error()

Checks if a status enum matches the trigger originally set, and
if so, raises the appropriate error.

Args:
status (int, enum): A protobuf enum response status to check.

Raises:
AssertionError: If trigger or error were not set.
_ApiError: If the statuses don't match. Do not catch. Will be
caught automatically and sent back to the client.


def _process_list_value(name, parse_fn, var_type, m_dict, values, results_dictionary):
    if (m_dict['index'] is not None):
        raise ValueError('Assignment of a list to a list index.')
    elements = filter(None, re.split('[ ,]', m_dict['vals']))
    if (name in results_dictionary):
        raise _reuse_fail(name, values)
    try:
        results_dictionary[name] = [parse_fn(e) for e in elements]
    except ValueError:
        _parse_fail(name, var_type, m_dict['vals'], values)

Update results_dictionary from a list of values.

Used to update results_dictionary to be returned by parse_values when
encountering a clause with a list RHS (e.g.  "arr=[1,2,3]".)

Mutates results_dictionary.

Args:
name: Name of variable in assignment ("arr").
parse_fn: Function for parsing individual values.
var_type: Type of named variable.
m_dict: Dictionary constructed from regex parsing.
m_dict['val']: RHS value (scalar)
values: Full expression being parsed
results_dictionary: The dictionary being updated for return by the parsing
function.

Raises:
ValueError: If the name has an index or the values cannot be parsed.


def chat_delete(self, *, channel: str, ts: str, **kwargs) -> SlackResponse:
    kwargs.update({'channel': channel, 'ts': ts})
    return self.api_call('chat.delete', json=kwargs)

Deletes a message.

Args:
channel (str): Channel containing the message to be deleted. e.g. 'C1234567890'
ts (str): Timestamp of the message to be deleted. e.g. '1234567890.123456'


def __init__(self, dllpath=None):

        self._lib = None
        self._winlib = None
        self._path = None
        self._windows = sys.platform.startswith('win')
        self._cygwin = sys.platform.startswith('cygwin')
        self._temp = None

        if self._windows or self._cygwin:
            self._sdk = self.get_appropriate_windows_sdk_name()
        else:
            self._sdk = self.JLINK_SDK_NAME

        if dllpath is not None:
            self.load(dllpath)
        else:
            self.load_default()

Initializes an instance of a ``Library``.

Loads the default J-Link DLL if ``dllpath`` is ``None``, otherwise
loads the DLL specified by the given ``dllpath``.

Args:
self (Library): the ``Library`` instance
dllpath (str): the DLL to load into the library

Returns:
``None``


def _init_from_converter(self, options: QuantizationDebugOptions, converter: TFLiteConverter, calibrated_model: Optional[bytes]=None, float_model: Optional[bytes]=None) -> None:
    self.quant_model = convert.mlir_quantize(calibrated_model, disable_per_channel=converter._experimental_disable_per_channel, fully_quantize=options.fully_quantize, enable_numeric_verify=True, denylisted_ops=options.denylisted_ops, denylisted_nodes=options.denylisted_nodes)
    self._quant_interpreter = _interpreter.Interpreter(model_content=self.quant_model)
    self._float_interpreter = None
    if float_model is not None:
        self._float_interpreter = _interpreter.Interpreter(model_content=float_model)

Convert the model and apply options.

Converts the quantized model and initializes a quantized model interpreter
with the quantized model. Returns a float model interpreter if float model
is provided.

Args:
options: a QuantizationDebugOptions object.
converter: an initialized tf.lite.TFLiteConverter.
calibrated_model: Calibrated model bytes.
float_model: Float model bytes.


def writeline(self, line, line_number):

        tmp_file = tempfile.TemporaryFile('w+')
        if not line.endswith(os.linesep):

            line += os.linesep
        try:

            with open(self.path, 'r') as file_handle:

                for count, new_line in enumerate(file_handle):

                    if count == line_number:

                        new_line = line

                    tmp_file.write(new_line)

            tmp_file.seek(0)
            with open(self.path, 'w') as file_handle:

                for new_line in tmp_file:

                    file_handle.write(new_line)
        finally:

            tmp_file.close()

Rewrite a single line in the file.

Args:
line (str): The new text to write to the file.
line_number (int): The line of the file to rewrite. Numbering
starts at 0.


def unregister_peer(self, connection_id):

        public_key = self.peer_to_public_key(connection_id)
        if public_key:
            self._consensus_notifier.notify_peer_disconnected(public_key)

        with self._lock:
            if connection_id in self._peers:
                del self._peers[connection_id]
                LOGGER.debug("Removed connection_id %s, "
                             "connected identities are now %s",
                             connection_id, self._peers)
                self._topology.set_connection_status(connection_id,
                                                     PeerStatus.TEMP)
            else:
                LOGGER.warning("Connection unregister failed as connection "
                               "was not registered: %s",
                               connection_id)

Removes a connection_id from the registry.

Args:
connection_id (str): A unique identifier which identifies an
connection on the network server socket.


class FlaxForcedBOSTokenLogitsProcessor(FlaxLogitsProcessor):

    def __init__(self, bos_token_id: int):
        self.bos_token_id = bos_token_id

    def __call__(self, input_ids: jnp.ndarray, scores: jnp.ndarray, cur_len: int) -> jnp.ndarray:
        new_scores = jnp.full(scores.shape, -float('inf'))
        apply_penalty = 1 - jnp.bool_(cur_len - 1)
        scores = jnp.where(apply_penalty, new_scores.at[:, self.bos_token_id].set(0), scores)
        return scores

[`FlaxLogitsProcessor`] that enforces the specified token as the first generated token.

Args:
bos_token_id (`int`):
The id of the token to force as the first generated token.


def forward(self, inference_args, input_tangents):
    if self._forward is None:
        self._forward, self._forward_graph, self._backward, self._forwardprop_output_indices, self._num_forwardprop_outputs = self._forward_and_backward_functions(inference_args, input_tangents)
    return self._forward

Construct or fetch a forward function with side-outputs.

When graph building without a tape active, symbolic gradients rely on
regenerating the backward function for higher-order gradients (to account
for new side outputs of the rewritten forward function call). Thus there is
no fixed backward function for this case. However, when a tape is active
(eager or graph building), we generate fixed backward and forward functions
at forward function call time.

This difference between the tape and non-tape cases is to avoid building
unneeded backward functions while graph building (where we may or may not
eventually need gradients).

Args:
inference_args: A flat list of Tensors, arguments to the inference
function.
input_tangents: A flat list of Tensors, jvps associated with
`inference_args`.

Returns:
A forward atomic_function.AtomicFunction.


def _build(self, inputs, memory, treat_input_as_matrix=False):

    if treat_input_as_matrix:
      inputs = basic.BatchFlatten(preserve_dims=2)(inputs)
      inputs_reshape = basic.BatchApply(
          basic.Linear(self._mem_size), n_dims=2)(inputs)
    else:
      inputs = basic.BatchFlatten()(inputs)
      inputs = basic.Linear(self._mem_size)(inputs)
      inputs_reshape = tf.expand_dims(inputs, 1)

    memory_plus_input = tf.concat([memory, inputs_reshape], axis=1)
    next_memory = self._attend_over_memory(memory_plus_input)

    n = inputs_reshape.get_shape().as_list()[1]
    next_memory = next_memory[:, :-n, :]

    if self._gate_style == 'unit' or self._gate_style == 'memory':
      self._input_gate, self._forget_gate = self._create_gates(
          inputs_reshape, memory)
      next_memory = self._input_gate * tf.tanh(next_memory)
      next_memory += self._forget_gate * memory

    output = basic.BatchFlatten()(next_memory)
    return output, next_memory

Adds relational memory to the TensorFlow graph.

Args:
inputs: Tensor input.
memory: Memory output from the previous time step.
treat_input_as_matrix: Optional, whether to treat `input` as a sequence
of matrices. Defaulta to False, in which case the input is flattened
into a vector.

Returns:
output: This time step's output.
next_memory: The next version of memory to use.


def minimize_peak_memory(graph, scheduler_alg):
    if (scheduler_alg == 'NAIVE'):
        return _minimize_peak_memory_naive(graph)
    elif (scheduler_alg == 'LIST'):
        return _minimize_peak_memory_list(graph)
    else:
        raise NotImplementedError('{} is not a scheduler algorithm. It should be one of NAIVE or LIST.'.format(scheduler_alg))

Computes a schedule to minimize peak memory.

Args:
graph: an mtf.auto_mtf.graph_interface.GraphInterface.
scheduler_alg: a string, one of 'NAIVE' or 'LIST'

Returns:
an iterable of integers representing the schedule.


def scaled_wulff(self, wulffshape, r):
    r_ratio = (r / wulffshape.effective_radius)
    miller_list = wulffshape.miller_energy_dict.keys()
    se_list = np.array(list(wulffshape.miller_energy_dict.values()))
    scaled_se = (se_list * r_ratio)
    return WulffShape(wulffshape.lattice, miller_list, scaled_se, symprec=self.symprec)

Scales the Wulff shape with an effective radius r. Note that the resulting
Wulff does not neccesarily have the same effective radius as the one
provided. The Wulff shape is scaled by its surface energies where first
the surface energies are scale by the minimum surface energy and then
multiplied by the given effective radius.

Args:
wulffshape (WulffShape): Initial, unscaled WulffShape
r (float): Arbitrary effective radius of the WulffShape

Returns:
WulffShape (scaled by r)


def load_yaml_config(conf_file):
    global g_config
    with open(conf_file) as fp:
        g_config = util.yaml_load(fp)
        src_dir = get_path('src_dir', None)
        if (src_dir is not None):
            sys.path.insert(0, src_dir)
        for cmd in get('commands', []):
            _import(cmd)

Load a YAML configuration.

This will not update the configuration but replace it entirely.

Args:
conf_file (str):
Path to the YAML config. This function will not check the file name
or extension and will just crash if the given file does not exist or
is not a valid YAML file.


def _parse_description(html_chunk):

    description_tag = html_chunk.match(
        ["div", {"class": "kniha_detail_text"}],
        "p"
    )

    if not description_tag:
        return None

    description = get_first_content(description_tag)
    description = description.replace("
", "\n")
    description = description.replace("
", "\n")

    return dhtmlparser.removeTags(description).strip()

Parse description of the book.

Args:
html_chunk (obj): HTMLElement containing slice of the page with details.

Returns:
str/None: Description as string or None if not found.


def _subtoken_ids_to_tokens(self, subtokens):

    concatenated = "".join(
        [self._subtoken_id_to_subtoken_string(s) for s in subtokens])
    split = concatenated.split("_")
    ret = []
    for t in split:
      if t:
        unescaped = _unescape_token(t + "_")
        if unescaped:
          ret.append(unescaped)
    return ret

Converts a list of subtoken ids to a list of tokens.

Args:
subtokens: a list of integers in the range [0, vocab_size)
Returns:
a list of strings.


def default_filename(ext):

    if ext == "py":
        raise RuntimeError("asked for a default filename with 'py' extension")

    filename = detect_current_filename()

    if filename is None:
        return temp_filename(ext)

    basedir = dirname(filename) or getcwd()

    if _no_access(basedir) or _shares_exec_prefix(basedir):
        return temp_filename(ext)

    name, _ = splitext(basename(filename))
    return join(basedir, name + "." + ext)

Generate a default filename with a given extension, attempting to use
the filename of the currently running process, if possible.

If the filename of the current process is not available (or would not be
writable), then a temporary file with the given extension is returned.

Args:
ext (str) : the desired extension for the filename

Returns:
str

Raises:
RuntimeError
If the extensions requested is ".py"


class RealmScorerOutput(ModelOutput):
    relevance_score: Optional[torch.FloatTensor] = None
    query_score: Optional[torch.FloatTensor] = None
    candidate_score: Optional[torch.FloatTensor] = None

Outputs of [`RealmScorer`] models.

Args:
relevance_score (`torch.FloatTensor` of shape `(batch_size, config.num_candidates)`):
The relevance score of document candidates (before softmax).
query_score (`torch.FloatTensor` of shape `(batch_size, config.retriever_proj_size)`):
Query score derived from the query embedder.
candidate_score (`torch.FloatTensor` of shape `(batch_size, config.num_candidates, config.retriever_proj_size)`):
Candidate score derived from the embedder.


def get_package_from_string(txt, paths=None):
    o = VersionedObject(txt)
    return get_package(o.name, o.version, paths=paths)

Get a package given a string.

Args:
txt (str): String such as 'foo', 'bah-1.3'.
paths (list of str, optional): paths to search for package, defaults
to `config.packages_path`.

Returns:
`Package` instance, or None if no package was found.


def _replace_sparse_with_values(value, sparse_list):
    flat_vals = nest.flatten(value, expand_composites=False)
    new_vals = []
    for v in flat_vals:
        if isinstance(v, sparse_tensor.SparseTensor):
            sparse_list.append(v)
            new_vals.append(v.values)
        else:
            new_vals.append(v)
    return nest.pack_sequence_as(value, new_vals, expand_composites=False)

Replace `SparseTensor`s with their values in `value`

Each `SparseTensor` in `value` is replaced by its `values` tensor, and
collects all `SparseTensor`s in `sparse_list`.

Args:
value: A structure of `Tensor`s and `SparseTensor`s
sparse_list: A list. Output parameter that collects all `SparseTensor`s in
`value`.

Returns:
`value` with each SparseTensor replaced by its `.value` attribute.


def _project_TH2(self, hist: Hist) -> Any:

        if len(self.projection_axes) != 1:
            raise ValueError(len(self.projection_axes), "Invalid number of axes")

        projection_func_map = {
            TH1AxisType.x_axis.value: hist.ProjectionX,
            TH1AxisType.y_axis.value: hist.ProjectionY
        }

        try:

            axis_type = self.projection_axes[0].axis_type.value
        except ValueError:

            axis_type = self.axis_type

        projection_func = projection_func_map[axis_type]

        logger.info(f"Projecting onto axis range {self.projection_axes[0].name} from hist {hist.GetName()}")
        projected_hist = projection_func()

        return projected_hist

Perform the actual TH2 -> TH1 projection.

This projection can only be to 1D.

Args:
hist (ROOT.TH2): Histogram from which the projections should be performed.
Returns:
ROOT.TH1: The projected histogram.


async def _connect_and_read(self):
    while (not self._stopped):
        try:
            self._connection_attempts += 1
            async with aiohttp.ClientSession(loop=self._event_loop, timeout=aiohttp.ClientTimeout(total=self.timeout)) as session:
                self._session = session
                (url, data) = (await self._retreive_websocket_info())
                async with session.ws_connect(url, heartbeat=self.ping_interval, ssl=self.ssl, proxy=self.proxy) as websocket:
                    self._logger.debug('The Websocket connection has been opened.')
                    self._websocket = websocket
                    self._dispatch_event(event='open', data=data)
                    (await self._read_messages())
        except (client_err.SlackClientNotConnectedError, client_err.SlackApiError) as exception:
            self._logger.debug(str(exception))
            self._dispatch_event(event='error', data=exception)
            if (self.auto_reconnect and (not self._stopped)):
                (await self._wait_exponentially(exception))
                continue
            self._logger.exception('The Websocket encountered an error. Closing the connection...')
            self._close_websocket()
            raise

Retreives and connects to Slack's RTM API.

Makes an authenticated call to Slack's RTM API to retrieve
a websocket URL. Then connects to the message server and
reads event messages as they come in.

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

Raises:
SlackApiError: Unable to retreive RTM URL from Slack.
websockets.exceptions: Errors thrown by the 'websockets' library.


def gather(self, indices, name=None):
    return self._implementation.gather(indices, name=name)

Return selected values in the TensorArray as a packed `Tensor`.

All of selected values must have been written and their shapes
must all match.

Args:
indices: A `1-D` `Tensor` taking values in `[0, max_value)`.  If the
`TensorArray` is not dynamic, `max_value=size()`.
name: A name for the operation (optional).

Returns:
The tensors in the `TensorArray` selected by `indices`, packed into one
tensor.


def get_time_of_day_description(self):
    seconds_expression = self._expression_parts[0]
    minute_expression = self._expression_parts[1]
    hour_expression = self._expression_parts[2]
    description = StringBuilder()
    if ((any(((exp in minute_expression) for exp in self._special_characters)) is False) and (any(((exp in hour_expression) for exp in self._special_characters)) is False) and (any(((exp in seconds_expression) for exp in self._special_characters)) is False)):
        description.append(_('At '))
        description.append(self.format_time(hour_expression, minute_expression, seconds_expression))
    elif (('-' in minute_expression) and (',' not in minute_expression) and (any(((exp in hour_expression) for exp in self._special_characters)) is False)):
        minute_parts = minute_expression.split('-')
        description.append(_('Every minute between {0} and {1}').format(self.format_time(hour_expression, minute_parts[0]), self.format_time(hour_expression, minute_parts[1])))
    elif ((',' in hour_expression) and ('-' not in hour_expression) and (any(((exp in minute_expression) for exp in self._special_characters)) is False)):
        hour_parts = hour_expression.split(',')
        description.append(_('At'))
        for (i, hour_part) in enumerate(hour_parts):
            description.append(' ')
            description.append(self.format_time(hour_part, minute_expression))
            if (i < (len(hour_parts) - 2)):
                description.append(',')
            if (i == (len(hour_parts) - 2)):
                description.append(_(' and'))
    else:
        seconds_description = self.get_seconds_description()
        minutes_description = self.get_minutes_description()
        hours_description = self.get_hours_description()
        description.append(seconds_description)
        if description:
            description.append(', ')
        description.append(minutes_description)
        if description:
            description.append(', ')
        description.append(hours_description)
    return str(description)

Generates a description for only the TIMEOFDAY portion of the expression

Returns:
The TIMEOFDAY description


def drive_enclosures(self):
    if (not self.__drive_enclures):
        self.__drive_enclures = DriveEnclosures(self.__connection)
    return self.__drive_enclures

Gets the Drive Enclosures API client.

Returns:
DriveEnclosures:


def _hexdecode(hexstring):

    _checkString(hexstring, description='hexstring')

    if len(hexstring) % 2 != 0:
        raise ValueError('The input hexstring must be of even length. Given: {!r}'.format(hexstring))

    if sys.version_info[0] > 2:
        by = bytes(hexstring, 'latin1')
        try:
            return str(binascii.unhexlify(by), encoding='latin1')
        except binascii.Error as err:
            new_error_message = 'Hexdecode reported an error: {!s}. Input hexstring: {}'.format(err.args[0], hexstring)
            raise TypeError(new_error_message)

    else:
        try:
            return hexstring.decode('hex')
        except TypeError as err:
            raise TypeError('Hexdecode reported an error: {}. Input hexstring: {}'.format(err.message, hexstring))

Convert a hex encoded string to a byte string.

For example '4A' will return 'J', and '04' will return ``'\\x04'`` (which has length 1).

Args:
hexstring (str): Can be for example 'A3' or 'A3B4'. Must be of even length.
Allowed characters are '0' to '9', 'a' to 'f' and 'A' to 'F' (not space).

Returns:
A string of half the length, with characters corresponding to all 0-255 values for each byte.

Raises:
TypeError, ValueError


def str_to_mac(mac_string):

    sp = mac_string.split(':')
    mac_string = ''.join(sp)
    return binascii.unhexlify(mac_string)

Convert a readable string to a MAC address

Args:
mac_string (str): a readable string (e.g. '01:02:03:04:05:06')
Returns:
str: a MAC address in hex form


def indicator_arrays(tc_entity_array):

        type_dict = {}
        for ea in tc_entity_array:
            type_dict.setdefault(ea['type'], []).append(ea['value'])
        return type_dict

Convert TCEntityArray to Indicator Type dictionary.

Args:
tc_entity_array (dictionary): The TCEntityArray to convert.

Returns:
(dictionary): Dictionary containing arrays of indicators for each indicator type.


def ray_get_and_free(object_ids):

    global _last_free_time
    global _to_free

    result = ray.get(object_ids)
    if type(object_ids) is not list:
        object_ids = [object_ids]
    _to_free.extend(object_ids)

    now = time.time()
    if (len(_to_free) > MAX_FREE_QUEUE_SIZE
            or now - _last_free_time > FREE_DELAY_S):
        ray.internal.free(_to_free)
        _to_free = []
        _last_free_time = now

    return result

Call ray.get and then queue the object ids for deletion.

This function should be used whenever possible in RLlib, to optimize
memory usage. The only exception is when an object_id is shared among
multiple readers.

Args:
object_ids (ObjectID|List[ObjectID]): Object ids to fetch and free.

Returns:
The result of ray.get(object_ids).


def _BuildKeyHierarchy(self, subkeys, values):

    if subkeys:
      for registry_key in subkeys:
        name = registry_key.name.upper()
        if name in self._subkeys:
          continue
        self._subkeys[name] = registry_key

        registry_key._key_path = key_paths.JoinKeyPath([
            self._key_path, registry_key.name])

    if values:
      for registry_value in values:
        name = registry_value.name.upper()
        if name in self._values:
          continue
        self._values[name] = registry_value

Builds the Windows Registry key hierarchy.

Args:
subkeys (list[FakeWinRegistryKey]): list of subkeys.
values (list[FakeWinRegistryValue]): list of values.


def expect_no_raises(message=None, extras=None):

    try:
        yield
    except Exception as e:
        e_record = records.ExceptionRecord(e)
        if extras:
            e_record.extras = extras
        msg = message or 'Got an unexpected exception'
        details = '%s: %s' % (msg, e_record.details)
        logging.exception(details)
        e_record.details = details
        recorder.add_error(e_record)

Expects no exception is raised in a context.

If the expectation is not met, the test is marked as fail after its
execution finishes.

A default message is added to the exception `details`.

Args:
message: string, custom message to add to exception's `details`.
extras: An optional field for extra information to be included in test
result.


def _compute_attention(self, query, key, value, attention_mask=None, training=None, return_attention_scores=False):
    if self._flash_attention and return_attention_scores:
        raise ValueError('Returning attention scores is not supported when flash attention is enabled. Please disable flash attention to access attention scores.')
    use_dot_product_attention = not (self._dropout > 0.0 or return_attention_scores or len(query.shape) != 4)
    if use_dot_product_attention:
        if attention_mask is not None:
            mask_expansion_axis = -len(self._attention_axes) * 2 - 1
            len_attention_scores_shape = 4
            for _ in range(len_attention_scores_shape - len(attention_mask.shape)):
                attention_mask = ops.expand_dims(attention_mask, axis=mask_expansion_axis)
            attention_mask = ops.cast(attention_mask, dtype='bool')
        attention_output = ops.dot_product_attention(query=query, key=key, value=value, bias=None, mask=attention_mask, scale=self._inverse_sqrt_key_dim, is_causal=False, flash_attention=self._flash_attention)
        return (attention_output, None)
    query = ops.multiply(query, ops.cast(self._inverse_sqrt_key_dim, query.dtype))
    attention_scores = ops.einsum(self._dot_product_equation, key, query)
    attention_scores = self._masked_softmax(attention_scores, attention_mask)
    if self._dropout > 0.0:
        final_attn_scores = self._dropout_layer(attention_scores, training=training)
    else:
        final_attn_scores = attention_scores
    attention_output = ops.einsum(self._combine_equation, final_attn_scores, value)
    return (attention_output, attention_scores)

Applies Dot-product attention with query, key, value tensors.

This function defines the computation inside `call` with projected
multi-head Q, K, V inputs. Users can override this function for
customized attention implementation.

Args:
query: Projected query tensor of shape `(B, T, N, key_dim)`.
key: Projected key tensor of shape `(B, S, N, key_dim)`.
value: Projected value tensor of shape `(B, S, N, value_dim)`.
attention_mask: a boolean mask of shape `(B, T, S)`, that prevents
attention to certain positions. It is generally not needed if
the `query` and `value` (and/or `key`) are masked.
training: Python boolean indicating whether the layer should behave
in training mode (adding dropout) or in inference mode (doing
nothing).

Returns:
attention_output: Multi-headed outputs of attention computation.
attention_scores: Multi-headed attention weights.


def install_dependencies(package: str) -> None:
    subprocess.check_call([sys.executable, '-m', 'pip', 'install', package])

Install Python dependencies

Args:
package (string): The package to install


def message_upperbound(self, tree, spins, subtheta):

        energy_sources = set()
        for v, subtree in tree.items():

            assert all(u in spins for u in self._ancestors[v])

            def energy_contributions():
                yield subtheta.linear[v]

                for u, bias in subtheta.adj[v].items():
                    if u in spins:
                        yield Times(limitReal(spins[u]), bias)

            energy = Plus(energy_contributions())

            if subtree:
                spins[v] = 1.
                plus = self.message_upperbound(subtree, spins, subtheta)
                spins[v] = -1.
                minus = self.message_upperbound(subtree, spins, subtheta)
                del spins[v]
            else:
                plus = minus = limitReal(0.0)

            m = FreshSymbol(REAL)

            self.assertions.update({LE(m, Plus(energy, plus)),
                                    LE(m, Plus(Times(energy, limitReal(-1.)), minus))})

            energy_sources.add(m)

        return Plus(energy_sources)

Determine an upper bound on the energy of the elimination tree.

Args:
tree (dict): The current elimination tree
spins (dict): The current fixed spins
subtheta (dict): Theta with spins fixed.

Returns:
The formula for the energy of the tree.


def intersection(self, other):
    if (not hasattr(other, '__iter__')):
        other = [other]
    bounds = self.bounds
    for range in other:
        bounds = self._intersection(bounds, range.bounds)
        if (not bounds):
            return None
    range = VersionRange(None)
    range.bounds = bounds
    return range

AND together version ranges.

Calculates the intersection of this range with one or more other ranges.

Args:
other: VersionRange object (or list of) to AND with.

Returns:
New VersionRange object representing the intersection, or None if
no ranges intersect.


def results(self, use_cache=True, dialect=None, billing_tier=None):
    return self._materialization.results(use_cache=use_cache, dialect=dialect, billing_tier=billing_tier)

Materialize the view synchronously.

If you require more control over the execution, use execute() or execute_async().

Args:
use_cache: whether to use cached results or not.
dialect : {'legacy', 'standard'}, default 'legacy'
'legacy' : Use BigQuery's legacy SQL dialect.
'standard' : Use BigQuery's standard SQL (beta), which is
compliant with the SQL 2011 standard.
billing_tier: Limits the billing tier for this job. Queries that have resource
usage beyond this tier will fail (without incurring a charge). If unspecified, this
will be set to your project default. This can also be used to override your
project-wide default billing tier on a per-query basis.
Returns:
A QueryResultsTable containing the result set.
Raises:
Exception if the query could not be executed or query response was malformed.


def write(self, file_name):

        try:
            assert file_name[-6:] == '.xhtml'
        except (AssertionError, IndexError):
            raise ValueError('filename must end with .xhtml')
        with open(file_name, 'wb') as f:
            f.write(self.content.encode('utf-8'))

Writes the chapter object to an xhtml file.

Args:
file_name (str): The full name of the xhtml file to save to.


def register_write(self, reg_index, value):
    res = self._dll.JLINKARM_WriteReg(reg_index, value)
    if (res != 0):
        raise errors.JLinkException(('Error writing to register %d' % reg_index))
    return value

Writes into an ARM register.

Note:
The data is not immediately written, but is cached before being
transferred to the CPU on CPU start.

Args:
self (JLink): the ``JLink`` instance
reg_index (int): the ARM register to write to
value (int): the value to write to the register

Returns:
The value written to the ARM register.

Raises:
JLinkException: on write error.


def scatter_div(self, sparse_delta, use_locking=False, name=None):
    if not isinstance(sparse_delta, indexed_slices.IndexedSlices):
        raise TypeError(f'Argument `sparse_delta` must be a `tf.IndexedSlices`. Received arg: {sparse_delta}')
    return self._lazy_read(gen_resource_variable_ops.resource_scatter_div(self.handle, sparse_delta.indices, ops.convert_to_tensor(sparse_delta.values, self.dtype), name=name))

Divide this variable by `tf.IndexedSlices`.

Args:
sparse_delta: `tf.IndexedSlices` to divide this variable by.
use_locking: If `True`, use locking during the operation.
name: the name of the operation.

Returns:
The updated variable.

Raises:
TypeError: if `sparse_delta` is not an `IndexedSlices`.


def load_database(adapter, variant_file=None, sv_file=None, family_file=None, family_type='ped', skip_case_id=False, gq_treshold=None, case_id=None, max_window=3000, profile_file=None, hard_threshold=0.95, soft_threshold=0.9):
    vcf_files = []
    nr_variants = None
    vcf_individuals = None
    if variant_file:
        vcf_info = check_vcf(variant_file)
        nr_variants = vcf_info['nr_variants']
        variant_type = vcf_info['variant_type']
        vcf_files.append(variant_file)
        vcf_individuals = vcf_info['individuals']
    nr_sv_variants = None
    sv_individuals = None
    if sv_file:
        vcf_info = check_vcf(sv_file, 'sv')
        nr_sv_variants = vcf_info['nr_variants']
        vcf_files.append(sv_file)
        sv_individuals = vcf_info['individuals']
    profiles = None
    matches = None
    if profile_file:
        profiles = get_profiles(adapter, profile_file)
        matches = profile_match(adapter, profiles, hard_threshold=hard_threshold, soft_threshold=soft_threshold)
    for _vcf_file in vcf_files:
        vcf = get_vcf(_vcf_file)
        if gq_treshold:
            if (not vcf.contains('GQ')):
                LOG.warning('Set gq-treshold to 0 or add info to vcf {0}'.format(_vcf_file))
                raise SyntaxError('GQ is not defined in vcf header')
    family = None
    family_id = None
    if family_file:
        LOG.info('Loading family from %s', family_file)
        with open(family_file, 'r') as family_lines:
            family = get_case(family_lines=family_lines, family_type=family_type)
            family_id = family.family_id
    case_id = (case_id or family_id)
    case_obj = build_case(case=family, case_id=case_id, vcf_path=variant_file, vcf_individuals=vcf_individuals, nr_variants=nr_variants, vcf_sv_path=sv_file, sv_individuals=sv_individuals, nr_sv_variants=nr_sv_variants, profiles=profiles, matches=matches, profile_path=profile_file)
    load_case(adapter=adapter, case_obj=case_obj)
    nr_inserted = 0
    for file_type in ['vcf_path', 'vcf_sv_path']:
        variant_type = 'snv'
        if (file_type == 'vcf_sv_path'):
            variant_type = 'sv'
        if (case_obj.get(file_type) is None):
            continue
        vcf_obj = get_vcf(case_obj[file_type])
        try:
            nr_inserted += load_variants(adapter=adapter, vcf_obj=vcf_obj, case_obj=case_obj, skip_case_id=skip_case_id, gq_treshold=gq_treshold, max_window=max_window, variant_type=variant_type)
        except Exception as err:
            LOG.warning(err)
            delete(adapter=adapter, case_obj=case_obj)
            raise err
    return nr_inserted

Load the database with a case and its variants

Args:
adapter: Connection to database
variant_file(str): Path to variant file
sv_file(str): Path to sv variant file
family_file(str): Path to family file
family_type(str): Format of family file
skip_case_id(bool): If no case information should be added to variants
gq_treshold(int): If only quality variants should be considered
case_id(str): If different case id than the one in family file should be used
max_window(int): Specify the max size for sv windows
check_profile(bool): Does profile check if True
hard_threshold(float): Rejects load if hamming distance above this is found
soft_threshold(float): Stores similar samples if hamming distance above this is found

Returns:
nr_inserted(int)


def multi_interpolation_basis(n_objectives=6, n_interp_steps=5, width=128, channels=3):
    (N, M, W, Ch) = (n_objectives, n_interp_steps, width, channels)
    const_term = sum([lowres_tensor([W, W, Ch], [(W
    const_term = tf.reshape(const_term, [1, 1, 1, W, W, Ch])
    example_interps = [sum([lowres_tensor([M, W, W, Ch], [2, (W
    example_basis = []
    for n in range(N):
        col = []
        for m in range(N):
            interp = (example_interps[n] + example_interps[m][::(- 1)])
            col.append(interp)
        example_basis.append(col)
    interp_basis = []
    for n in range(N):
        col = [interp_basis[m][(N - n)][::(- 1)] for m in range(n)]
        col.append(tf.zeros([M, W, W, 3]))
        for m in range((n + 1), N):
            interp = sum([lowres_tensor([M, W, W, Ch], [M, (W
            col.append(interp)
        interp_basis.append(col)
    basis = []
    for n in range(N):
        col_ex = tf.stack(example_basis[n])
        col_in = tf.stack(interp_basis[n])
        basis.append((col_ex + col_in))
    basis = tf.stack(basis)
    return (basis + const_term)

A paramaterization for interpolating between each pair of N objectives.

Sometimes you want to interpolate between optimizing a bunch of objectives,
in a paramaterization that encourages images to align.

Args:
n_objectives: number of objectives you want interpolate between
n_interp_steps: number of interpolation steps
width: width of intepolated images
channel

Returns:
A [n_objectives, n_objectives, n_interp_steps, width, width, channel]
shaped tensor, t, where the final [width, width, channel] should be
seen as images, such that the following properties hold:

t[a, b]    = t[b, a, ::-1]
t[a, i, 0] = t[a, j, 0] for all i, j
t[a, a, i] = t[a, a, j] for all i, j
t[a, b, i] = t[b, a, -i] for all i


def sort(self, cmp=None, key=None, reverse=False):

        def _DefaultKey(value):

            result = []
            for key in self.header:

                try:
                    result.append(float(value[key]))
                except ValueError:
                    result.append(value[key])
            return result

        key = key or _DefaultKey

        new_table = self._table[1:]

        if cmp is not None:
            key = cmp_to_key(cmp)

        new_table.sort(key=key, reverse=reverse)

        self._table = [self.header]
        self._table.extend(new_table)

        for index, row in enumerate(self._table):
            row.row = index

Sorts rows in the texttable.

Args:
cmp: func, non default sort algorithm to use.
key: func, applied to each element before sorting.
reverse: bool, reverse order of sort.


def reduce_by_device(parallelism, data, reduce_fn):
    unique_devices = []
    device_to_data = {}
    for (dev, datum) in zip(parallelism.devices, data):
        if (dev not in device_to_data):
            unique_devices.append(dev)
            device_to_data[dev] = [datum]
        else:
            device_to_data[dev].append(datum)
    device_parallelism = Parallelism(unique_devices)
    grouped_data = [device_to_data[dev] for dev in unique_devices]
    return (device_parallelism, device_parallelism(reduce_fn, grouped_data))

Reduces data per device.

This can be useful, for example, if we want to all-reduce n tensors on k<n
devices (like during eval when we have only one device).  We call
reduce_by_device() to first sum the tensors per device, then call our usual
all-reduce operation to create one sum per device, followed by
expand_by_device, to create the appropriate number of pointers to these
results.  See all_reduce_ring() below for an example of how this is used.

Args:
parallelism: a expert_utils.Parallelism object
data: a list of Tensors with length parallelism.n
reduce_fn: a function taking a list of Tensors.  e.g. tf.add_n

Returns:
device_parallelism: a Parallelism object with each device listed only once.
reduced_data: A list of Tensors, one per device.


def record_corrected_value(self, value, expected_interval, count=1):
    while True:
        if (not self.record_value(value, count)):
            return False
        if ((value <= expected_interval) or (expected_interval <= 0)):
            return True
        value -= expected_interval

Record a new value into the histogram and correct for
coordinated omission if needed

Args:
value: the value to record (must be in the valid range)
expected_interval: the expected interval between 2 value samples
count: incremental count (defaults to 1)


def update_endpoint(self, endpoint_name, endpoint_config_name):
    if (not _deployment_entity_exists((lambda : self.sagemaker_client.describe_endpoint(EndpointName=endpoint_name)))):
        raise ValueError('Endpoint with name "{}" does not exist; please use an existing endpoint name'.format(endpoint_name))
    self.sagemaker_client.update_endpoint(EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name)
    return endpoint_name

Update an Amazon SageMaker ``Endpoint`` according to the endpoint configuration specified in the request

Raise an error if endpoint with endpoint_name does not exist.

Args:
endpoint_name (str): Name of the Amazon SageMaker ``Endpoint`` to update.
endpoint_config_name (str): Name of the Amazon SageMaker endpoint configuration to deploy.

Returns:
str: Name of the Amazon SageMaker ``Endpoint`` being updated.


def plot(self):
    plt.rcParams['xtick.major.pad'] = '6'
    plt.rcParams['ytick.major.pad'] = '6'
    plt.rcParams['axes.linewidth'] = 2
    npoint = 1000
    xs = np.linspace(0, 1, npoint)
    xs_reverse_converted = InterfacialReactivity._reverse_convert(xs, self.factor1, self.factor2)
    energies = [self._get_energy(x) for x in xs_reverse_converted]
    plt.plot(xs, energies, 'k-')
    kinks = self.get_kinks()
    (_, x_kink, energy_kink, _, _) = zip(*kinks)
    plt.scatter(x_kink, energy_kink, marker='o', c='blue', s=20)
    plt.scatter(self.minimum()[0], self.minimum()[1], marker='*', c='red', s=300)
    for (index, x, energy, _, _) in kinks:
        plt.annotate(index, xy=(x, energy), xytext=(5, 30), textcoords='offset points', ha='right', va='bottom', arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0')).draggable()
    plt.xlim([(- 0.05), 1.05])
    if self.norm:
        plt.ylabel('Energy (eV/atom)')
    else:
        plt.ylabel('Energy (eV/f.u.)')
    plt.xlabel('$x$ in $x$ {} + $(1-x)$ {}'.format(self.c1.reduced_formula, self.c2.reduced_formula))
    return plt

Plots reaction energy as a function of mixing ratio x in
self.c1 - self.c2 tie line using pylab.

Returns:
Pylab object that plots reaction energy as a function of
mixing ratio x.


def run_without_time_limit(self, cmd):
    cmd = ([DOCKER_BINARY, 'run', DOCKER_NVIDIA_RUNTIME] + cmd)
    logging.info('Docker command: %s', ' '.join(cmd))
    start_time = time.time()
    retval = subprocess.call(cmd)
    elapsed_time_sec = int((time.time() - start_time))
    logging.info('Elapsed time of attack: %d', elapsed_time_sec)
    logging.info('Docker retval: %d', retval)
    if (retval != 0):
        logging.warning('Docker returned non-zero retval: %d', retval)
        raise WorkerError(('Docker returned non-zero retval ' + str(retval)))
    return elapsed_time_sec

Runs docker command without time limit.

Args:
cmd: list with the command line arguments which are passed to docker
binary

Returns:
how long it took to run submission in seconds

Raises:
WorkerError: if error occurred during execution of the submission


def matrix(self) -> np.ndarray:
    num_qubits = self.num_qubits()
    if (num_qubits is None):
        raise ValueError('Unknown number of qubits')
    num_dim = (2 ** num_qubits)
    result = np.zeros((num_dim, num_dim), dtype=np.complex128)
    for (gate, coefficient) in self.items():
        result += (protocols.unitary(gate) * coefficient)
    return result

Reconstructs matrix of self using unitaries of underlying gates.

Raises:
TypeError: if any of the gates in self does not provide a unitary.


def quality(self, tests, alias=None):
    this_tests = ((((tests.get('each', []) + tests.get('Each', [])) + tests.get('EACH', [])) + tests.get(self.mnemonic, [])) + utils.flatten_list([tests.get(a) for a in self.get_alias(alias=alias)]))
    this_tests = filter(None, this_tests)
    if (not tests.get(self.mnemonic, 1)):
        this_tests = []
    return {test.__name__: test(self) for test in this_tests}

Run a series of tests and return the corresponding results.

Args:
tests (list): a list of functions.
alias (dict): a dictionary mapping mnemonics to lists of mnemonics.

Returns:
list. The results. Stick to booleans (True = pass) or ints.


def update(self, iterable):

        for pair in pairwise_longest(iterable, fillvalue=_FILL):
            self._edges.append(pair)
            self._results = None

Update with an ordered iterable of items.

Args:
iterable: An ordered iterable of items. The relative
order of the items in this iterable will be respected
in the TopoSet (in the absence of cycles).