def _verifyClusterSpecEquality(self, cluster_spec, expected_proto):
    self.assertProtoEquals(expected_proto, cluster_spec.as_cluster_def())
    self.assertProtoEquals(expected_proto, server_lib.ClusterSpec(cluster_spec).as_cluster_def())
    self.assertProtoEquals(expected_proto, server_lib.ClusterSpec(cluster_spec.as_cluster_def()).as_cluster_def())
    self.assertProtoEquals(expected_proto, server_lib.ClusterSpec(cluster_spec.as_dict()).as_cluster_def())

Verifies that the ClusterSpec generates the correct proto.

We are testing this four different ways to ensure that the ClusterSpec
returned by the TPUClusterResolver behaves identically to a normal
ClusterSpec when passed into the generic ClusterSpec libraries.

Args:
cluster_spec: ClusterSpec returned by the TPUClusterResolver
expected_proto: Expected protobuf


def construct_policy(app='coreforrest', env='dev', group='forrest', region='us-east-1', pipeline_settings=None):

    LOG.info('Create custom IAM Policy for %s.', app)

    services = pipeline_settings.get('services', {})
    LOG.debug('Found requested services: %s', services)

    services = auto_service(pipeline_settings=pipeline_settings, services=services)

    if services:
        credential = get_env_credential(env=env)
        account_number = credential['accountId']

    statements = []
    for service, value in services.items():
        if value is True:
            items = []
        elif isinstance(value, str):
            items = [value]
        else:
            items = value

        rendered_statements = render_policy_template(
            account_number=account_number,
            app=app,
            env=env,
            group=group,
            items=items,
            pipeline_settings=pipeline_settings,
            region=region,
            service=service)

        statements.extend(rendered_statements)

    if statements:
        policy_json = get_template('infrastructure/iam/wrapper.json.j2', statements=json.dumps(statements))
    else:
        LOG.info('No services defined for %s.', app)
        policy_json = None

    return policy_json

Assemble IAM Policy for _app_.

Args:
app (str): Name of Spinnaker Application.
env (str): Environment/Account in AWS
group (str):A Application group/namespace
region (str): AWS region
pipeline_settings (dict): Settings from *pipeline.json*.

Returns:
json: Custom IAM Policy for _app_.
None: When no *services* have been defined in *pipeline.json*.


def _RDFClass(cls, table):

    rdf_cls_name = "OsqueryTable{}".format(hash(table.query))
    try:
      return cls._rdf_cls_cache[rdf_cls_name]
    except KeyError:
      pass

    rdf_cls = compatibility.MakeType(rdf_cls_name,
                                     (rdf_structs.RDFProtoStruct,), {})

    rdf_cls.AddDescriptor(
        rdf_structs.ProtoEmbedded(
            name="metadata", field_number=1, nested=ExportedMetadata))

    rdf_cls.AddDescriptor(
        rdf_structs.ProtoString(name="__query__", field_number=2))

    for idx, column in enumerate(table.header.columns):

      if column.name == "metadata":
        name = "__metadata__"
      else:
        name = column.name

      descriptor = rdf_structs.ProtoString(name=name, field_number=idx + 3)
      rdf_cls.AddDescriptor(descriptor)

    cls._rdf_cls_cache[rdf_cls_name] = rdf_cls
    return rdf_cls

Creates a dynamic RDF proto struct class for given osquery table.

The fields of the proto will correspond to the columns of the table.

Args:
table: An osquery table for which the class is about to be generated.

Returns:
A class object corresponding to the given table.


def QA_fetch_user(user_cookie, db=DATABASE):

    collection = DATABASE.account

    return [res for res in collection.find({'user_cookie': user_cookie}, {"_id": 0})]

get the user

Arguments:
user_cookie : str the unique cookie_id for a user
Keyword Arguments:
db: database for query

Returns:
list ---  [ACCOUNT]


def load_chkpt_vars(model_path):

    model_path = get_checkpoint_path(model_path)
    reader = tfv1.train.NewCheckpointReader(model_path)
    var_names = reader.get_variable_to_shape_map().keys()
    result = {}
    for n in var_names:
        result[n] = reader.get_tensor(n)
    return result

Load all variables from a checkpoint to a dict.

Args:
model_path(str): path to a checkpoint.

Returns:
dict: a name:value dict


def unstack(df, level=(- 1), reset_index=True):
    df = df.unstack(level=level)
    if reset_index:
        df = df.reset_index()
        df.columns = df.columns.map(_join_names)
    return df

pd.DataFrame.unstack adapter.

Call the `df.unstack` method using the indicated level and afterwards
join the column names using an underscore.

Args:
df (pandas.DataFrame): DataFrame to unstack.
level (str, int or list): Level(s) of index to unstack, can pass level name
reset_index (bool): Whether to reset the index after unstacking

Returns:
pandas.Dataframe: unstacked dataframe


def Mean(self):
    old_p = 0
    total = 0.0
    for (x, new_p) in zip(self.xs, self.ps):
        p = (new_p - old_p)
        total += (p * x)
        old_p = new_p
    return total

Computes the mean of a CDF.

Returns:
float mean


def speed_info(self):

        speed_info = structs.JLinkSpeedInfo()
        self._dll.JLINKARM_GetSpeedInfo(ctypes.byref(speed_info))
        return speed_info

Retrieves information about supported target interface speeds.

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

Returns:
The ``JLinkSpeedInfo`` instance describing the supported target
interface speeds.


def value_of(
            self,
            value: Union[sympy.Basic, float, str]
    ) -> Union[sympy.Basic, float]:

        if isinstance(value, str):
            return self.param_dict.get(value, sympy.Symbol(value))
        if isinstance(value, sympy.Basic):
            if sys.version_info.major < 3:

                d = {k.encode(): v for k, v in self.param_dict.items()}
                v = value.subs(d)
            else:
                v = value.subs(self.param_dict)
            return v if v.free_symbols else float(v)
        return value

Attempt to resolve a Symbol or name or float to its assigned value.

If unable to resolve a sympy.Symbol, returns it unchanged.
If unable to resolve a name, returns a sympy.Symbol with that name.

Args:
value: The sympy.Symbol or name or float to try to resolve into just
a float.

Returns:
The value of the parameter as resolved by this resolver.


def add_features(self, features, append=True, merge='outer', duplicates='ignore', min_studies=0.0, threshold=0.001):
    if ((not append) or (not hasattr(self, 'feature_table'))):
        self.feature_table = FeatureTable(self)
    self.feature_table.add_features(features, merge=merge, duplicates=duplicates, min_studies=min_studies, threshold=threshold)

Construct a new FeatureTable from file.

Args:
features: Feature data to add. Can be:
(a) A text file containing the feature data, where each row is
a study in the database, with features in columns. The first
column must contain the IDs of the studies to match up with the
image data.
(b) A pandas DataFrame, where studies are in rows, features are
in columns, and the index provides the study IDs.
append (bool): If True, adds new features to existing ones
incrementally. If False, replaces old features.
merge, duplicates, min_studies, threshold: Additional arguments
passed to FeatureTable.add_features().


def get_flat_tensor_specs(element_spec):
    return list(itertools.chain.from_iterable((spec._flat_tensor_specs for spec in nest.flatten(element_spec))))

Returns a list `tf.TypeSpec`s for the element tensor representation.

Args:
element_spec: A nested structure of `tf.TypeSpec` objects representing to
element type specification.

Returns:
A list `tf.TypeSpec`s for the element tensor representation.


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 self.bos_token_id + token_ids_0 + self.eos_token_id
    return self.bos_token_id + token_ids_0 + token_ids_1 + self.eos_token_id

Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and
adding special tokens. The special tokens depend on calling set_lang.

An NLLB sequence has the following format, where `X` represents the sequence:

- `input_ids` (for encoder) `X [eos, src_lang_code]`
- `decoder_input_ids`: (for decoder) `X [eos, tgt_lang_code]`

BOS is never used. Pairs of sequences are not the expected use case, but they will be handled without a
separator.

Args:
token_ids_0 (`List[int]`):
List of IDs to which the special tokens will be added.
token_ids_1 (`List[int]`, *optional*):
Optional second list of IDs for sequence pairs.

Returns:
`List[int]`: list of [input IDs](../glossary#input-ids) with the appropriate special tokens.


def __init__(self, value=HashingAlgorithmEnum.SHA_256):

        super(HashingAlgorithm, self).__init__(
            enums.HashingAlgorithm, value, Tags.HASHING_ALGORITHM)

Construct a HashingAlgorithm object.

Args:
value (HashingAlgorithm): A HashingAlgorithm enumeration value,
(e.g., HashingAlgorithm.MD5). Optional, defaults to
HashingAlgorithm.SHA_256.


async def _create_remote_user(self, **payload):

        read_action = get_crud_action(method='create', model='user')

        user_data = await self.event_broker.ask(
            action_type=read_action,
            payload=payload
        )

        return json.loads(user_data)

This method creates a service record in the remote user service
with the given email.
Args:
uid (str): the user identifier to create
Returns:
(dict): a summary of the user that was created


def _init_metadata_service(self, version):
    metadata_cfg = self._load_config_section(CONFIG_METADATA_SECTION)
    self._token_metadata = metadata_cfg[CONFIG_TOKEN]
    proto = metadata_cfg[CONFIG_PROTOCOL]
    host = metadata_cfg[CONFIG_HOST]
    self._metadata = MetadataService(host, version)
    self._metadata.base_protocol = proto
    self._metadata.set_auth(self._token_metadata)

Method to initialize the Metadata Service from the config data

Args:
version (string): Version of Boss API to use.

Returns:
None

Raises:
(KeyError): if given invalid version.


class SeamlessM4TProcessor(ProcessorMixin):
    feature_extractor_class = 'SeamlessM4TFeatureExtractor'
    tokenizer_class = ('SeamlessM4TTokenizer', 'SeamlessM4TTokenizerFast')

    def __init__(self, feature_extractor, tokenizer):
        super().__init__(feature_extractor, tokenizer)

    def __call__(self, text=None, audios=None, src_lang=None, tgt_lang=None, **kwargs):

        sampling_rate = kwargs.pop('sampling_rate', None)
        if text is None and audios is None:
            raise ValueError('You have to specify either text or audios. Both cannot be none.')
        elif text is not None and audios is not None:
            raise ValueError('Text and audios are mututally exclusive when passed to `SeamlessM4T`. Specify one or another.')
        elif text is not None:
            if tgt_lang is not None:
                self.tokenizer.tgt_lang = tgt_lang
            if src_lang is not None:
                self.tokenizer.src_lang = src_lang
            encoding = self.tokenizer(text, **kwargs)
            return encoding
        else:
            encoding = self.feature_extractor(audios, sampling_rate=sampling_rate, **kwargs)
            return encoding

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

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

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

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

    @property
    def model_input_names(self):
        tokenizer_input_names = self.tokenizer.model_input_names
        feature_extractor_input_names = self.feature_extractor.model_input_names
        return list(dict.fromkeys(tokenizer_input_names + feature_extractor_input_names))

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

[`SeamlessM4TProcessor`] offers all the functionalities of [`SeamlessM4TFeatureExtractor`] and
[`SeamlessM4TTokenizerFast`]. See the [`~SeamlessM4TProcessor.__call__`] and [`~SeamlessM4TProcessor.decode`] for
more information.

Args:
feature_extractor ([`SeamlessM4TFeatureExtractor`]):
The audio processor is a required input.
tokenizer ([`SeamlessM4TTokenizerFast`]):
The tokenizer is a required input.


def _update_task(self, task):

        self.task = task
        self.task.data.update(self.task_data)
        self.task_type = task.task_spec.__class__.__name__
        self.spec = task.task_spec
        self.task_name = task.get_name()
        self.activity = getattr(self.spec, 'service_class', '')
        self._set_lane_data()

Assigns current task step to self.task
then updates the task's data with self.task_data

Args:
task: Task object.


def update_context(self, context, app=None):
    if ((app is None) and (self._context is _CONTEXT_MISSING) and (not in_app_context())):
        raise RuntimeError('Attempted to update component context without a bound app context or eager app set! Please pass the related app you want to update the context for!')
    if (self._context is not _CONTEXT_MISSING):
        self._context = ImmutableDict(context)
    else:
        key = self._get_context_name(app=app)
        setattr(_CONTEXT_LOCALS, key, ImmutableDict(context))

Replace the component's context with a new one.

Args:
context (dict): The new context to set this component's context to.

Keyword Args:
app (flask.Flask, optional): The app to update this context for. If
not provided, the result of ``Component.app`` will be used.


def _term(self, term):
    term = str(term)
    if term:
        self.__query['q'] += term
    return self

Add a term to the query.

Arguments:
term (str): The term to add.

Returns:
SearchHelper: Self


def subtract(inputs, **kwargs):
    return Subtract(**kwargs)(inputs)

Functional interface to the `Subtract` layer.

Args:
inputs: A list of input tensors (exactly 2).
**kwargs: Standard layer keyword arguments.

Returns:
A tensor, the difference of the inputs.

Examples:

```python
import keras

input1 = keras.layers.Input(shape=(16,))
x1 = keras.layers.Dense(8, activation='relu')(input1)
input2 = keras.layers.Input(shape=(32,))
x2 = keras.layers.Dense(8, activation='relu')(input2)
subtracted = keras.layers.subtract([x1, x2])

out = keras.layers.Dense(4)(subtracted)
model = keras.models.Model(inputs=[input1, input2], outputs=out)
```


def _update_explicit_bucket_count(a_float, dist):
    buckets = dist.explicitBuckets
    if (buckets is None):
        raise ValueError((_BAD_UNSET_BUCKETS % u'explicit buckets'))
    bucket_counts = dist.bucketCounts
    bounds = buckets.bounds
    if (len(bucket_counts) < (len(bounds) + 1)):
        raise ValueError(_BAD_LOW_BUCKET_COUNT)
    bucket_counts[bisect.bisect(bounds, a_float)] += 1

Adds `a_float` to `dist`, updating its explicit buckets.

Args:
a_float (float): a new value
dist (:class:`endpoints_management.gen.servicecontrol_v1_messages.Distribution`):
the Distribution being updated

Raises:
ValueError: if `dist` does not already have explict buckets defined
ValueError: if there are not enough bucket count fields in `dist`


def eval(self, feed_dict=None, session=None):
    return _eval_using_default_session(self, feed_dict, self.graph, session)

Evaluates this tensor in a `Session`.

Note: If you are not using `compat.v1` libraries, you should not need this,
(or `feed_dict` or `Session`).  In eager execution (or within `tf.function`)
you do not need to call `eval`.

Calling this method will execute all preceding operations that
produce the inputs needed for the operation that produces this
tensor.

*N.B.* Before invoking `Tensor.eval()`, its graph must have been
launched in a session, and either a default session must be
available, or `session` must be specified explicitly.

Args:
feed_dict: A dictionary that maps `Tensor` objects to feed values. See
`tf.Session.run` for a description of the valid feed values.
session: (Optional.) The `Session` to be used to evaluate this tensor. If
none, the default session will be used.

Returns:
A numpy array corresponding to the value of this tensor.


def clear_events(self, event_name):

        self.lock.acquire()
        try:
            q = self.get_event_q(event_name)
            q.queue.clear()
        except queue.Empty:
            return
        finally:
            self.lock.release()

Clear all events of a particular name.

Args:
event_name: Name of the events to be popped.


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

Lists previously requested builds. Previously requested builds may still be in-progress, or may have finished successfully or unsuccessfully.

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


def get_statistics(self, id_or_uri, port_name=''):

        uri = self._client.build_uri(id_or_uri) + "/statistics"

        if port_name:
            uri = uri + "/" + port_name

        return self._client.get(uri)

Gets the statistics from an interconnect.

Args:
id_or_uri:  Can be either the interconnect id or the interconnect uri.
port_name (str): A specific port name of an interconnect.

Returns:
dict: The statistics for the interconnect that matches id.


def CheckKeyCompatibility(cls, key_path):

    key_path_upper = key_path.upper()
    for key_path_prefix in cls._COMPATIBLE_REGISTRY_KEY_PATH_PREFIXES:
      if key_path_upper.startswith(key_path_prefix):
        return True

    logger.warning('Key path: "{0:s}" is currently not supported'.format(
        key_path))
    return False

Checks if a Windows Registry key path is supported by dfWinReg.

Args:
key_path (str): path of the Windows Registry key.

Returns:
bool: True if key is compatible or False if not.


def previous_weekday(date):
    weekday = date.weekday()
    if (weekday == 0):
        n_days = 3
    elif (weekday == 6):
        n_days = 2
    else:
        n_days = 1
    return (date - datetime.timedelta(days=n_days))

Returns the last weekday before date

Args:
date (datetime or datetime.date)
Returns:
(datetime or datetime.date)
Raises:
-


def add_filter(ds, patterns):
    if (not plugins.is_datasource(ds)):
        raise Exception('Filters are applicable only to datasources.')
    delegate = dr.get_delegate(ds)
    if delegate.raw:
        raise Exception("Filters aren't applicable to raw datasources.")
    if (not delegate.filterable):
        raise Exception(("Filters aren't applicable to %s." % dr.get_name(ds)))
    if (ds in _CACHE):
        del _CACHE[ds]
    if isinstance(patterns, six.string_types):
        FILTERS[ds].add(patterns)
    elif isinstance(patterns, list):
        FILTERS[ds] |= set(patterns)
    elif isinstance(patterns, set):
        FILTERS[ds] |= patterns
    else:
        raise TypeError('patterns must be string, list, or set.')

Add a filter or list of filters to a datasource. A filter is a simple
string, and it matches if it is contained anywhere within a line.

Args:
ds (@datasource component): The datasource to filter
patterns (str, [str]): A string, list of strings, or set of strings to
add to the datasource's filters.


def put(self, closure, tag=None):
    closure.tag = tag
    if tag is not None:
        with self._queue_lock:
            self._tagged_queue[tag].put(closure, block=False)
            self._closures_queued_condition.notify_all()
    else:
        with self._put_wait_lock, self._queue_lock:
            self._queue_free_slot_condition.wait_for(lambda: not self._queue.full())
            self._queue.put(closure, block=False)
            metric_utils.monitor_int('queued_closures', self._queue.qsize())
            self._raise_if_error()
            self._closures_queued_condition.notify()

Put a closure into the queue for later execution.

If `mark_failed` was called before `put`, the error from the first
invocation of `mark_failed` will be raised.

Args:
closure: The `Closure` to put into the queue.
tag: if not None, put into a queue with the given tag.


def pymmh3_hash128_x86(key: Union[bytes, bytearray], seed: int) -> int:

    def fmix(h):
        h ^= h >> 16
        h = (h * 0x85ebca6b) & 0xFFFFFFFF
        h ^= h >> 13
        h = (h * 0xc2b2ae35) & 0xFFFFFFFF
        h ^= h >> 16
        return h

    length = len(key)
    nblocks = int(length / 16)

    h1 = seed
    h2 = seed
    h3 = seed
    h4 = seed

    c1 = 0x239b961b
    c2 = 0xab0e9789
    c3 = 0x38b34ae5
    c4 = 0xa1e38b93

    for block_start in range(0, nblocks * 16, 16):
        k1 = (
            key[block_start + 3] << 24 |
            key[block_start + 2] << 16 |
            key[block_start + 1] << 8 |
            key[block_start + 0]
        )
        k2 = (
            key[block_start + 7] << 24 |
            key[block_start + 6] << 16 |
            key[block_start + 5] << 8 |
            key[block_start + 4]
        )
        k3 = (
            key[block_start + 11] << 24 |
            key[block_start + 10] << 16 |
            key[block_start + 9] << 8 |
            key[block_start + 8]
        )
        k4 = (
            key[block_start + 15] << 24 |
            key[block_start + 14] << 16 |
            key[block_start + 13] << 8 |
            key[block_start + 12]
        )

        k1 = (c1 * k1) & 0xFFFFFFFF
        k1 = (k1 << 15 | k1 >> 17) & 0xFFFFFFFF
        k1 = (c2 * k1) & 0xFFFFFFFF
        h1 ^= k1

        h1 = (h1 << 19 | h1 >> 13) & 0xFFFFFFFF
        h1 = (h1 + h2) & 0xFFFFFFFF
        h1 = (h1 * 5 + 0x561ccd1b) & 0xFFFFFFFF

        k2 = (c2 * k2) & 0xFFFFFFFF
        k2 = (k2 << 16 | k2 >> 16) & 0xFFFFFFFF
        k2 = (c3 * k2) & 0xFFFFFFFF
        h2 ^= k2

        h2 = (h2 << 17 | h2 >> 15) & 0xFFFFFFFF
        h2 = (h2 + h3) & 0xFFFFFFFF
        h2 = (h2 * 5 + 0x0bcaa747) & 0xFFFFFFFF

        k3 = (c3 * k3) & 0xFFFFFFFF
        k3 = (k3 << 17 | k3 >> 15) & 0xFFFFFFFF
        k3 = (c4 * k3) & 0xFFFFFFFF
        h3 ^= k3

        h3 = (h3 << 15 | h3 >> 17) & 0xFFFFFFFF
        h3 = (h3 + h4) & 0xFFFFFFFF
        h3 = (h3 * 5 + 0x96cd1c35) & 0xFFFFFFFF

        k4 = (c4 * k4) & 0xFFFFFFFF
        k4 = (k4 << 18 | k4 >> 14) & 0xFFFFFFFF
        k4 = (c1 * k4) & 0xFFFFFFFF
        h4 ^= k4

        h4 = (h4 << 13 | h4 >> 19) & 0xFFFFFFFF
        h4 = (h1 + h4) & 0xFFFFFFFF
        h4 = (h4 * 5 + 0x32ac3b17) & 0xFFFFFFFF

    tail_index = nblocks * 16
    k1 = 0
    k2 = 0
    k3 = 0
    k4 = 0
    tail_size = length & 15

    if tail_size >= 15:
        k4 ^= key[tail_index + 14] << 16
    if tail_size >= 14:
        k4 ^= key[tail_index + 13] << 8
    if tail_size >= 13:
        k4 ^= key[tail_index + 12]

    if tail_size > 12:
        k4 = (k4 * c4) & 0xFFFFFFFF
        k4 = (k4 << 18 | k4 >> 14) & 0xFFFFFFFF
        k4 = (k4 * c1) & 0xFFFFFFFF
        h4 ^= k4

    if tail_size >= 12:
        k3 ^= key[tail_index + 11] << 24
    if tail_size >= 11:
        k3 ^= key[tail_index + 10] << 16
    if tail_size >= 10:
        k3 ^= key[tail_index + 9] << 8
    if tail_size >= 9:
        k3 ^= key[tail_index + 8]

    if tail_size > 8:
        k3 = (k3 * c3) & 0xFFFFFFFF
        k3 = (k3 << 17 | k3 >> 15) & 0xFFFFFFFF
        k3 = (k3 * c4) & 0xFFFFFFFF
        h3 ^= k3

    if tail_size >= 8:
        k2 ^= key[tail_index + 7] << 24
    if tail_size >= 7:
        k2 ^= key[tail_index + 6] << 16
    if tail_size >= 6:
        k2 ^= key[tail_index + 5] << 8
    if tail_size >= 5:
        k2 ^= key[tail_index + 4]

    if tail_size > 4:
        k2 = (k2 * c2) & 0xFFFFFFFF
        k2 = (k2 << 16 | k2 >> 16) & 0xFFFFFFFF
        k2 = (k2 * c3) & 0xFFFFFFFF
        h2 ^= k2

    if tail_size >= 4:
        k1 ^= key[tail_index + 3] << 24
    if tail_size >= 3:
        k1 ^= key[tail_index + 2] << 16
    if tail_size >= 2:
        k1 ^= key[tail_index + 1] << 8
    if tail_size >= 1:
        k1 ^= key[tail_index + 0]

    if tail_size > 0:
        k1 = (k1 * c1) & 0xFFFFFFFF
        k1 = (k1 << 15 | k1 >> 17) & 0xFFFFFFFF
        k1 = (k1 * c2) & 0xFFFFFFFF
        h1 ^= k1

    h1 ^= length
    h2 ^= length
    h3 ^= length
    h4 ^= length

    h1 = (h1 + h2) & 0xFFFFFFFF
    h1 = (h1 + h3) & 0xFFFFFFFF
    h1 = (h1 + h4) & 0xFFFFFFFF
    h2 = (h1 + h2) & 0xFFFFFFFF
    h3 = (h1 + h3) & 0xFFFFFFFF
    h4 = (h1 + h4) & 0xFFFFFFFF

    h1 = fmix(h1)
    h2 = fmix(h2)
    h3 = fmix(h3)
    h4 = fmix(h4)

    h1 = (h1 + h2) & 0xFFFFFFFF
    h1 = (h1 + h3) & 0xFFFFFFFF
    h1 = (h1 + h4) & 0xFFFFFFFF
    h2 = (h1 + h2) & 0xFFFFFFFF
    h3 = (h1 + h3) & 0xFFFFFFFF
    h4 = (h1 + h4) & 0xFFFFFFFF

    return h4 << 96 | h3 << 64 | h2 << 32 | h1

Implements 128-bit murmur3 hash for x86, as per ``pymmh3``, with some
bugfixes.

Args:
key: data to hash
seed: seed

Returns:
integer hash


def GetCampaigns(self, client_customer_id):

    self.client.SetClientCustomerId(client_customer_id)

    max_tries = 3
    today = time.strftime('%Y%m%d', time.localtime())
    for i in xrange(1, max_tries + 1):
      try:
        selector = {
            'fields': ['Id', 'Name', 'Status', 'BudgetId', 'Amount'],
            'predicates': [
                {
                    'field': 'Status',
                    'operator': 'NOT_EQUALS',
                    'values': ['REMOVED']
                }
            ],
            'dateRange': {
                'min': today,
                'max': today
            }
        }
        campaigns = self.client.GetService('CampaignService').get(selector)
        if int(campaigns['totalNumEntries']) > 0:
          return campaigns['entries']
        else:
          return None
      except Exception, e:
        if i == max_tries:
          raise GoogleAdsError(e)
        continue

Returns a client account's Campaigns that haven't been removed.

Args:
client_customer_id: str Client Customer Id used to retrieve Campaigns.

Returns:
list List of Campaign data objects.


def convert_reduce_sum(params, w_name, scope_name, inputs, layers, weights, names):

    print('Converting reduce_sum ...')

    keepdims = params['keepdims'] > 0
    axis = params['axes']

    def target_layer(x, keepdims=keepdims, axis=axis):
        import keras.backend as K
        return K.sum(x, keepdims=keepdims, axis=axis)

    lambda_layer = keras.layers.Lambda(target_layer)
    layers[scope_name] = lambda_layer(layers[inputs[0]])

Convert reduce_sum layer.

Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers


def create_pipeline(gcp_project_id, region, pipeline_name, pipeline_root, csv_file, module_file, beam_runner, metadata_file):
    example_gen = tfx.components.CsvExampleGen(input_base=csv_file)
    statistics_gen = tfx.components.StatisticsGen(examples=example_gen.outputs['examples'])
    schema_gen = tfx.components.SchemaGen(statistics=statistics_gen.outputs['statistics'], infer_feature_shape=True)
    transform = tfx.components.Transform(examples=example_gen.outputs['examples'], schema=schema_gen.outputs['schema'], module_file=module_file)
    trainer = tfx.components.Trainer(module_file=module_file, examples=transform.outputs['transformed_examples'], transform_graph=transform.outputs['transform_graph'])
    components = [example_gen, statistics_gen, schema_gen, transform, trainer]
    beam_pipeline_args_by_runner = {'DirectRunner': [], 'DataflowRunner': ['--runner=DataflowRunner', '--project=' + gcp_project_id, '--temp_location=' + os.path.join(pipeline_root, 'tmp'), '--region=' + region]}
    return tfx.dsl.Pipeline(pipeline_name=pipeline_name, pipeline_root=pipeline_root, components=components, enable_cache=True, metadata_connection_config=tfx.orchestration.metadata.sqlite_metadata_connection_config(metadata_file), beam_pipeline_args=beam_pipeline_args_by_runner[beam_runner])

Create the TFX pipeline.

Args:
gcp_project_id (str): ID for the google cloud project to deploy the pipeline to.
region (str): Region in which to deploy the pipeline.
pipeline_name (str): Name for the Beam pipeline
pipeline_root (str): Path to artifact repository where TFX
stores a pipeline’s artifacts.
csv_file (str): Path to the csv input file.
module_file (str): Path to module file containing the preprocessing_fn and run_fn.
beam_runner (str): Beam runner: DataflowRunner or DirectRunner.
metadata_file (str): Path to store a metadata file as a mock metadata database.


def bool(name, execute_bool=True, default=None):

    def wrapped(func):
        @functools.wraps(func)
        def _decorator(*args, **kwargs):
            if core.isset(name) and core.bool(name) == execute_bool:
                return func(*args, **kwargs)
            elif default is not None and default == execute_bool:
                return func(*args, **kwargs)
        return _decorator
    return wrapped

Only execute the function if the boolean variable is set.

Args:
name: The name of the environment variable
execute_bool: The boolean value to execute the function on
default: The default value if the environment variable is not set (respects `execute_bool`)

Returns:
The function return value or `None` if the function was skipped.


def get_subscription_from_cli(name=None):

    home = os.path.expanduser('~')
    azure_profile_path = home + os.sep + '.azure' + os.sep + 'azureProfile.json'
    if os.path.isfile(azure_profile_path) is False:
        print('Error from get_subscription_from_cli(): Cannot find ' +
              azure_profile_path)
        return None
    with io.open(azure_profile_path, 'r', encoding='utf-8-sig') as azure_profile_fd:
        azure_profile = json.load(azure_profile_fd)
    for subscription_info in azure_profile['subscriptions']:
        if (name is None and subscription_info['isDefault'] is True) or \
                                            subscription_info['name'] == name:
            return subscription_info['id']
    return None

Get the default, or named, subscription id from CLI's local cache.

Args:
name (str): Optional subscription name. If this is set, the subscription id of the named
subscription is returned from the CLI cache if present. If not set, the subscription id
of the default subscription is returned.

Returns:
Azure subscription ID string.

Requirements:
User has run 'az login' once, or is in Azure Cloud Shell.


def intersects(self, rect, edges=False):

        if (self.bottom > rect.top or \
            self.top < rect.bottom or \
            self.left > rect.right or \
            self.right < rect.left):
            return False

        if not edges:
            if (self.bottom == rect.top or \
                self.top == rect.bottom or \
                self.left == rect.right or \
                self.right == rect.left):
                return False

        if (self.left == rect.right and self.bottom == rect.top or \
            self.left == rect.right and rect.bottom == self.top or \
            rect.left == self.right and self.bottom == rect.top or \
            rect.left == self.right and rect.bottom == self.top):
            return False

        return True

Detect intersections between this rectangle and rect.

Args:
rect (Rectangle): Rectangle to test for intersections.
edges (bool): Accept edge touching rectangles as intersects or not

Returns:
bool: True if the rectangles intersect, False otherwise


def add_field_with_label(self, key, label_description, field):

        self.inputs[key] = field
        label = Label(label_description)
        label.style['margin'] = '0px 5px'
        label.style['min-width'] = '30%'
        container = HBox()
        container.style.update({'justify-content':'space-between', 'overflow':'auto', 'padding':'3px'})
        container.append(label, key='lbl' + key)
        container.append(self.inputs[key], key=key)
        self.container.append(container, key=key)

Adds a field to the dialog together with a descriptive label and a unique identifier.

Note: You can access to the fields content calling the function GenericDialog.get_field(key).

Args:
key (str): The unique identifier for the field.
label_description (str): The string content of the description label.
field (Widget): The instance of the field Widget. It can be for example a TextInput or maybe
a custom widget.


def _isValidQuery(self, query, mode='phonefy'):
    try:
        validator = self.modes[mode].get('query_validator')
        if validator:
            try:
                compiledRegexp = re.compile('^{expr}$'.format(expr=validator))
                return compiledRegexp.match(query)
            except AttributeError as e:
                return True
    except AttributeError as e:
        compiledRegexp = re.compile('^{r}$'.format(r=self.validQuery[mode]))
        return compiledRegexp.match(query)

Method to verify if a given query is processable by the platform.

The system looks for the forbidden characters in self.Forbidden list.

Args:
-----
query: The query to be launched.
mode: To be chosen amongst mailfy, phonefy, usufy, searchfy.
Return:
-------
True | False


def get_gene_info(ensembl_ids=None, hgnc_symbols=None):
    uniq_ensembl_ids = set((ensembl_id for ensembl_id in (ensembl_ids or [])))
    uniq_hgnc_symbols = set((hgnc_symbol for hgnc_symbol in (hgnc_symbols or [])))
    genes = []
    gene_data = []
    if uniq_ensembl_ids:
        for ensembl_id in uniq_ensembl_ids:
            for res in query_gene(ensembl_id=ensembl_id):
                gene_data.append(res)
    elif uniq_hgnc_symbols:
        for hgnc_symbol in uniq_hgnc_symbols:
            query_res = query_gene(hgnc_symbol=hgnc_symbol)
            if query_res:
                for res in query_res:
                    gene_data.append(res)
            else:
                gene_data.append({'hgnc_symbol': hgnc_symbol, 'hgnc_id': None, 'ensembl_id': None, 'description': None, 'chrom': 'unknown', 'start': 0, 'stop': 0, 'hi_score': None, 'constraint_score': None})
    for gene in gene_data:
        genes.append(Gene(symbol=gene['hgnc_symbol'], hgnc_id=gene['hgnc_id'], ensembl_id=gene['ensembl_id'], description=gene['description'], chrom=gene['chrom'], start=gene['start'], stop=gene['stop'], location=get_cytoband_coord(gene['chrom'], gene['start']), hi_score=gene['hi_score'], constraint_score=gene['constraint_score'], omim_number=get_omim_number(gene['hgnc_symbol'])))
    return genes

Return the genes info based on the transcripts found

Args:
ensembl_ids (Optional[list]): list of Ensembl gene ids
hgnc_symbols (Optional[list]): list of HGNC gene symbols

Returns:
iterable: an iterable with `Gene` objects


def get_min_instability(self, min_voltage=None, max_voltage=None):

        data = []
        for pair in self._select_in_voltage_range(min_voltage, max_voltage):
            if pair.decomp_e_charge is not None:
                data.append(pair.decomp_e_charge)
            if pair.decomp_e_discharge is not None:
                data.append(pair.decomp_e_discharge)
        return min(data) if len(data) > 0 else None

The minimum instability along a path for a specific voltage range.

Args:
min_voltage: The minimum allowable voltage.
max_voltage: The maximum allowable voltage.

Returns:
Minimum decomposition energy of all compounds along the insertion
path (a subset of the path can be chosen by the optional arguments)


def get_group(self, name, user_name=None):

        return self.service.get_group(
            name, user_name, self.url_prefix, self.auth, self.session,
            self.session_send_opts)

Get owner of group and the resources it's attached to.

Args:
name (string): Name of group to query.
user_name (optional[string]): Supply None if not interested in determining if user is a member of the given group.

Returns:
(dict): Keys include 'owner', 'name', 'resources'.

Raises:
requests.HTTPError on failure.


def load_pyfile(self, path):
    with open(path) as config_file:
        contents = config_file.read()
        try:
            exec(compile(contents, path, 'exec'), self)
        except Exception as e:
            raise MalformedConfig(path, six.text_type(e))

Load python file as config.

Args:
path (string): path to the python file


def tf_step(self, x, iteration, deltas, improvement, last_improvement, estimated_improvement):

        x, next_iteration, deltas, improvement, last_improvement, estimated_improvement = super(LineSearch, self).tf_step(
            x, iteration, deltas, improvement, last_improvement, estimated_improvement
        )

        next_x = [t + delta for t, delta in zip(x, deltas)]

        if self.mode == 'linear':
            next_deltas = deltas
            next_estimated_improvement = estimated_improvement + self.estimated_incr

        elif self.mode == 'exponential':
            next_deltas = [delta * self.parameter for delta in deltas]
            next_estimated_improvement = estimated_improvement * self.parameter

        target_value = self.fn_x(next_deltas)

        next_improvement = tf.divide(
            x=(target_value - self.base_value),
            y=tf.maximum(x=next_estimated_improvement, y=util.epsilon)
        )

        return next_x, next_iteration, next_deltas, next_improvement, improvement, next_estimated_improvement

Iteration loop body of the line search algorithm.

Args:
x: Current solution estimate $x_t$.
iteration: Current iteration counter $t$.
deltas: Current difference $x_t - x'$.
improvement: Current improvement $(f(x_t) - f(x')) / v'$.
last_improvement: Last improvement $(f(x_{t-1}) - f(x')) / v'$.
estimated_improvement: Current estimated value $v'$.

Returns:
Updated arguments for next iteration.


def decode_list(self, ids):

    decoded_ids = []
    for id_ in ids:
      if 0 <= id_ < self._num_reserved_ids:
        decoded_ids.append(RESERVED_TOKENS[int(id_)])
      else:
        decoded_ids.append(id_ - self._num_reserved_ids)
    return [str(d) for d in decoded_ids]

Transform a sequence of int ids into a their string versions.

This method supports transforming individual input/output ids to their
string versions so that sequence to/from text conversions can be visualized
in a human readable format.

Args:
ids: list of integers to be converted.

Returns:
strs: list of human-readable string.


def generate_exact(self, model, vcpu_num, host_cpu):

        nested = {'Intel': 'vmx', 'AMD': 'svm'}
        cpu = ET.Element('cpu', match='exact')
        ET.SubElement(cpu, 'model').text = model
        cpu.append(self.generate_topology(vcpu_num))

        vendor = host_cpu.findtext('vendor')
        if not nested.get(vendor):
            LOGGER.debug(
                'Unknown vendor: {0}, did not configure nested '
                'virtualization cpu flag on guest.'.format(vendor)
            )
            return cpu

        model_vendor = LibvirtCPU.get_cpu_vendor(family=model)
        if vendor != model_vendor:
            LOGGER.debug(
                (
                    'Not enabling nested virtualization feature, host '
                    'vendor is: {0}, guest vendor: '
                    '{1}'.format(vendor, model_vendor)
                )
            )
            return cpu

        flag = nested[vendor]
        if host_cpu.find('feature/[@name="{0}"]'.format(flag)) is not None:
            cpu.append(self.generate_feature(name=flag))
        else:
            LOGGER.debug(
                (
                    'missing {0} cpu flag on host, nested '
                    'virtualization will probably not '
                    'work.'
                ).format(flag)
            )

        return cpu

Generate exact CPU model with nested virtualization CPU feature.

Args:
model(str): libvirt supported CPU model
vcpu_num(int): number of virtual cpus
host_cpu(lxml.etree.Element): the host CPU model

Returns:
lxml.etree.Element: CPU XML node


def explain(self, entry):

        d = self.get_explanation_dict(entry)
        print("The uncorrected value of the energy of %s is %f eV" %
              (entry.composition, d["uncorrected_energy"]))
        print("The following corrections / screening are applied for %s:\n" %
              d["compatibility"])
        for c in d["corrections"]:
            print("%s correction: %s\n" % (c["name"],
                                           c["description"]))
            print("For the entry, this correction has the value %f eV." % c[
                "value"])
            print("-" * 30)

        print("The final energy after corrections is %f" % d[
            "corrected_energy"])

Prints an explanation of the corrections that are being applied for a
given compatibility scheme. Inspired by the "explain" methods in many
database methodologies.

Args:
entry: A ComputedEntry.


def print_fhir_to_json_string_for_analytics(fhir_proto: message.Message) -> str:
    printer = _json_printer.JsonPrinter.compact_printer_for_analytics(_PRIMITIVE_HANDLER)
    return printer.print(fhir_proto)

Returns an Analytic FHIR JSON representation with no spaces or newlines.

Args:
fhir_proto: The proto to serialize into a JSON string.

Returns:
An Analytic FHIR JSON representation with no spaces or newlines.


def get_stability_criteria(self, s, n):

        n = get_uvec(n)
        stress = s * np.outer(n, n)
        sym_wallace = self.get_symmetric_wallace_tensor(stress)
        return np.linalg.det(sym_wallace.voigt)

Gets the stability criteria from the symmetric
Wallace tensor from an input vector and stress
value.

Args:
s (float): Stress value at which to evaluate
the stability criteria
n (3x1 array-like): direction of the applied
stress


def get_videos_for_ids(edx_video_ids, sort_field=None, sort_dir=SortDirection.asc):
    (videos, __) = _get_videos_for_filter({'edx_video_id__in': edx_video_ids}, sort_field, sort_dir)
    return videos

Returns an iterator of videos that match the given list of ids.

Args:
edx_video_ids (list)
sort_field (VideoSortField)
sort_dir (SortDirection)

Returns:
A generator expression that contains the videos found, sorted by the
given field and direction, with ties broken by edx_video_id to ensure a
total order


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

Deletes the routine specified by routineId from the dataset.

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


def serialize_keras_object(obj):
    if obj is None:
        return obj
    if isinstance(obj, PLAIN_TYPES):
        return obj
    if isinstance(obj, (list, tuple)):
        config_arr = [serialize_keras_object(x) for x in obj]
        return tuple(config_arr) if isinstance(obj, tuple) else config_arr
    if isinstance(obj, dict):
        return serialize_dict(obj)
    if isinstance(obj, bytes):
        return {'class_name': '__bytes__', 'config': {'value': obj.decode('utf-8')}}
    if isinstance(obj, slice):
        return {'class_name': '__slice__', 'config': {'start': serialize_keras_object(obj.start), 'stop': serialize_keras_object(obj.stop), 'step': serialize_keras_object(obj.step)}}
    if isinstance(obj, type(Ellipsis)):
        return {'class_name': '__ellipsis__', 'config': {}}
    if isinstance(obj, backend.KerasTensor):
        history = getattr(obj, '_keras_history', None)
        if history:
            history = list(history)
            history[0] = history[0].name
        return {'class_name': '__keras_tensor__', 'config': {'shape': obj.shape, 'dtype': obj.dtype, 'keras_history': history}}
    if tf.available and isinstance(obj, tf.TensorShape):
        return obj.as_list() if obj._dims is not None else None
    if backend.is_tensor(obj):
        return {'class_name': '__tensor__', 'config': {'value': backend.convert_to_numpy(obj).tolist(), 'dtype': backend.standardize_dtype(obj.dtype)}}
    if type(obj).__module__ == np.__name__:
        if isinstance(obj, np.ndarray) and obj.ndim > 0:
            return {'class_name': '__numpy__', 'config': {'value': obj.tolist(), 'dtype': backend.standardize_dtype(obj.dtype)}}
        else:
            return obj.item()
    if tf.available and isinstance(obj, tf.DType):
        return obj.name
    if isinstance(obj, types.FunctionType) and obj.__name__ == '<lambda>':
        warnings.warn(f'The object being serialized includes a `lambda`. This is unsafe. In order to reload the object, you will have to pass `safe_mode=False` to the loading function. Please avoid using `lambda` in the future, and use named Python functions instead. This is the `lambda` being serialized: {inspect.getsource(obj)}', stacklevel=2)
        return {'class_name': '__lambda__', 'config': {'value': python_utils.func_dump(obj)}}
    if tf.available and isinstance(obj, tf.TypeSpec):
        ts_config = obj._serialize()
        ts_config = list(map(lambda x: x.as_list() if isinstance(x, tf.TensorShape) else x.name if isinstance(x, tf.DType) else x, ts_config))
        return {'class_name': '__typespec__', 'spec_name': obj.__class__.__name__, 'module': obj.__class__.__module__, 'config': ts_config, 'registered_name': None}
    inner_config = _get_class_or_fn_config(obj)
    config_with_public_class = serialize_with_public_class(obj.__class__, inner_config)
    if config_with_public_class is not None:
        get_build_and_compile_config(obj, config_with_public_class)
        record_object_after_serialization(obj, config_with_public_class)
        return config_with_public_class
    if isinstance(obj, types.FunctionType):
        module = obj.__module__
    else:
        module = obj.__class__.__module__
    class_name = obj.__class__.__name__
    if module == 'builtins':
        registered_name = None
    elif isinstance(obj, types.FunctionType):
        registered_name = object_registration.get_registered_name(obj)
    else:
        registered_name = object_registration.get_registered_name(obj.__class__)
    config = {'module': module, 'class_name': class_name, 'config': inner_config, 'registered_name': registered_name}
    get_build_and_compile_config(obj, config)
    record_object_after_serialization(obj, config)
    return config

Retrieve the config dict by serializing the Keras object.

`serialize_keras_object()` serializes a Keras object to a python dictionary
that represents the object, and is a reciprocal function of
`deserialize_keras_object()`. See `deserialize_keras_object()` for more
information about the config format.

Args:
obj: the Keras object to serialize.

Returns:
A python dict that represents the object. The python dict can be
deserialized via `deserialize_keras_object()`.


def main(raw_args=None):
    if (raw_args is None):
        raw_args = sys.argv[1:]
    parser = build_parser()
    args = parser.parse_args(raw_args)
    if ((args.firmware_image is None) and (args.gdb is None)):
        print('You must specify either a firmware image or attach a debugger with --gdb <PORT>')
        return 1
    test_args = ['qemu-system-gnuarmeclipse', '-verbose', '-verbose', '-board', 'STM32F0-Discovery', '-nographic', '-monitor', 'null', '-serial', 'null', '--semihosting-config', 'enable=on,target=native', '-d', 'unimp,guest_errors']
    if args.firmware_image:
        test_args += ['-image', args.firmware_image]
    if args.gdb:
        test_args += ['--gdb', ('tcp::%d' % args.gdb)]
    proc = subprocess.Popen(test_args, stdout=sys.stdout, stderr=sys.stderr)
    try:
        proc.communicate()
    except KeyboardInterrupt:
        proc.terminate()
    return 0

Run the iotile-emulate script.

Args:
raw_args (list): Optional list of commmand line arguments.  If not
passed these are pulled from sys.argv.


def _quadratic_sum_cost(self, state: _STATE) -> float:
    cost = 0.0
    total_len = float(len(self._c))
    (seqs, _) = state
    for seq in seqs:
        cost += ((len(seq) / total_len) ** 2)
    return (- cost)

Cost function that sums squares of lengths of sequences.

Args:
state: Search state, not mutated.

Returns:
Cost which is minus the normalized quadratic sum of each linear
sequence section in the state. This promotes single, long linear
sequence solutions and converges to number -1. The solution with a
lowest cost consists of every node being a single sequence and is
always less than 0.


def get_python_version():
    ver = str(sys.version_info)
    mmm = re.search('.*major=([\\d]), minor=([\\d]), micro=([\\d]+),.*', ver)
    return mmm.group(1) + '.' + mmm.group(2) + '.' + mmm.group(3)

Retrieves default Python version.

Returns:
String that is the version of default Python.
e.g. '2.7.4'


def inverse_removing(self, words_to_remove):
    mask = np.ones(self.as_np.shape[0], dtype='bool')
    mask[self.__get_idxs(words_to_remove)] = False
    if (not self.bow):
        return ''.join([(self.as_list[i] if mask[i] else 'UNKWORDZ') for i in range(mask.shape[0])])
    return ''.join([self.as_list[v] for v in mask.nonzero()[0]])

Returns a string after removing the appropriate words.

If self.bow is false, replaces word with UNKWORDZ instead of removing
it.

Args:
words_to_remove: list of ids (ints) to remove

Returns:
original raw string with appropriate words removed.


def top_rated(self, **kwargs):
    path = self._get_path('top_rated')
    response = self._GET(path, kwargs)
    self._set_attrs_to_values(response)
    return response

Get the list of top rated movies. By default, this list will only
include movies that have 10 or more votes. This list refreshes every
day.

Args:
page: (optional) Minimum value of 1.  Expected value is an integer.
language: (optional) ISO 639-1 code.

Returns:
A dict representation of the JSON returned from the API.


def add_exac_info(genes, alias_genes, exac_lines):

    LOG.info("Add exac pli scores")
    for exac_gene in parse_exac_genes(exac_lines):
        hgnc_symbol = exac_gene['hgnc_symbol'].upper()
        pli_score = exac_gene['pli_score']

        for hgnc_id in get_correct_ids(hgnc_symbol, alias_genes):
            genes[hgnc_id]['pli_score'] = pli_score

Add information from the exac genes

Currently we only add the pLi score on gene level

The exac resource only use HGNC symbol to identify genes so we need
our alias mapping.

Args:
genes(dict): Dictionary with all genes
alias_genes(dict): Genes mapped to all aliases
ensembl_lines(iteable): Iteable with raw ensembl info


def data(self, index, role=Qt.DisplayRole):
    if (not index.isValid()):
        return None
    col = index.column()
    columnName = self._dataFrame.columns[index.row()]
    columnDtype = self._dataFrame[columnName].dtype
    if ((role == Qt.DisplayRole) or (role == Qt.EditRole)):
        if (col == 0):
            if (columnName == index.row()):
                return index.row()
            return columnName
        elif (col == 1):
            return SupportedDtypes.description(columnDtype)
    elif (role == DTYPE_ROLE):
        if (col == 1):
            return columnDtype
        else:
            return None

Retrieve the data stored in the model at the given `index`.

Args:
index (QtCore.QModelIndex): The model index, which points at a
data object.
role (Qt.ItemDataRole, optional): Defaults to `Qt.DisplayRole`. You
have to use different roles to retrieve different data for an
`index`. Accepted roles are `Qt.DisplayRole`, `Qt.EditRole` and
`DTYPE_ROLE`.

Returns:
None if an invalid index is given, the role is not accepted by the
model or the column is greater than `1`.
The column name will be returned if the given column number equals `0`
and the role is either `Qt.DisplayRole` or `Qt.EditRole`.
The datatype will be returned, if the column number equals `1`. The
`Qt.DisplayRole` or `Qt.EditRole` return a human readable, translated
string, whereas the `DTYPE_ROLE` returns the raw data type.


def save(hdf5_filename, array):

    hdf5_filename = os.path.expanduser(hdf5_filename)

    try:
        h = h5py.File(hdf5_filename, "w")
        h.create_dataset('CUTOUT', data=array)
        h.close()
    except Exception as e:
        raise ValueError("Could not save HDF5 file {0}.".format(hdf5_filename))

    return hdf5_filename

Export a numpy array to a HDF5 file.

Arguments:
hdf5_filename (str): A filename to which to save the HDF5 data
array (numpy.ndarray): The numpy array to save to HDF5

Returns:
String. The expanded filename that now holds the HDF5 data


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

Returns a TensorFluent for the exp function.

Args:
x: The input fluent.

Returns:
A TensorFluent wrapping the exp function.


def on_run_start(self, request):
    self._is_run_start = True
    self._update_run_calls_state(request.run_call_count, request.fetches, request.feed_dict, is_callable_runner=request.is_callable_runner)
    if self._active_tensor_filter:
        return self._active_tensor_filter_run_start_response
    self._exit_if_requested_by_user()
    if self._run_call_count > 1 and (not self._skip_debug):
        if self._run_through_times > 0:
            return framework.OnRunStartResponse(framework.OnRunStartAction.NON_DEBUG_RUN, [])
        elif self._run_through_times == 0:
            return self._run_start_response or framework.OnRunStartResponse(framework.OnRunStartAction.DEBUG_RUN, self._get_run_debug_urls())
    if self._run_start_response is None:
        self._prep_cli_for_run_start()
        self._run_start_response = self._launch_cli()
        if self._active_tensor_filter:
            self._active_tensor_filter_run_start_response = self._run_start_response
        if self._run_through_times > 1:
            self._run_through_times -= 1
    self._exit_if_requested_by_user()
    return self._run_start_response

Overrides on-run-start callback.

Args:
request: An instance of `OnRunStartRequest`.

Returns:
An instance of `OnRunStartResponse`.


def decrypt_block(self, cipherText):

    if not self.initialized:
      raise TypeError("CamCrypt object has not been initialized")
    if len(cipherText) != BLOCK_SIZE:
      raise ValueError("cipherText must be %d bytes long (received %d bytes)" %
                       (BLOCK_SIZE, len(cipherText)))
    plain = ctypes.create_string_buffer(BLOCK_SIZE)
    self.decblock(self.bitlen, cipherText, self.keytable, plain)
    return plain.raw

Decrypt a 16-byte block of data.

NOTE: This function was formerly called `decrypt`, but was changed when
support for decrypting arbitrary-length strings was added.

Args:
cipherText (str): 16-byte data.

Returns:
16-byte str.

Raises:
TypeError if CamCrypt object has not been initialized.
ValueError if `cipherText` is not BLOCK_SIZE (i.e. 16) bytes.


def fstat(self, file_des):

        file_object = self.filesystem.get_open_file(file_des).get_object()
        return file_object.stat_result.copy()

Return the os.stat-like tuple for the FakeFile object of file_des.

Args:
file_des: The file descriptor of filesystem object to retrieve.

Returns:
The FakeStatResult object corresponding to entry_path.

Raises:
OSError: if the filesystem object doesn't exist.


def __init__(self, xcli, product_name, product_version):

        self.xcli = xcli
        self.product_name = product_name
        self.product_version = product_version
        self.server_name = getfqdn()
        self.platform = get_platform_details()

        if not self.product_name:
            raise ValueError('product_name is empty')
        if not self.product_version:
            raise ValueError('product_version is empty')

init an EventsManager
Args:
xcli (XCLIClient): xcli client to send the event
product_name (string): the sending product's name
product_version (string): the sending product's version
Raises:
ValueError: if missing product_name or product_version


def _expected_exercise_fn(design, calibration_indices, continuation_value, exercise_value):
    mask = exercise_value > 0
    design_t = tf.transpose(design, [0, 2, 1])
    masked = tf.where(tf.expand_dims(tf.transpose(mask), axis=-1), design_t, tf.zeros_like(design_t))
    if calibration_indices is None:
        submask = masked
        mask_cont_value = continuation_value
    else:
        submask = tf.gather(masked, calibration_indices, axis=1)
        mask_cont_value = tf.gather(continuation_value, calibration_indices)
    lhs = tf.matmul(submask, submask, transpose_a=True)
    lhs_pinv = tf.linalg.pinv(lhs)
    rhs = tf.matmul(submask, tf.expand_dims(tf.transpose(mask_cont_value), axis=-1), transpose_a=True)
    beta = tf.matmul(lhs_pinv, rhs)
    continuation = tf.matmul(design_t, beta)
    return tf.nn.relu(tf.transpose(tf.squeeze(continuation, axis=-1)))

Returns the expected continuation value for each path.

Args:
design: A real `Tensor` of shape `[batch_size, basis_size, num_samples]`.
calibration_indices: A rank 1 integer `Tensor` denoting indices of samples
used for regression.
continuation_value: A `Tensor` of shape `[num_samples, batch_size]` and of
the same dtype as `design`. The optimal value of the option conditional on
not exercising now or earlier, taking future information into account.
exercise_value: A `Tensor` of the same shape and dtype as
`continuation_value`. Value of the option if exercised immideately at
the current time

Returns:
A `Tensor` of the same shape and dtype as `continuation_value` whose
`(n, v)`-th entry represents the expected continuation value of sample path
`n` under the `v`-th payoff scheme.


def _ReadOperatingSystemArtifactValues(self, operating_system_values):

    if not operating_system_values:
      raise errors.MalformedPresetError('Missing operating system values.')

    family = operating_system_values.get('family', None)
    product = operating_system_values.get('product', None)
    version = operating_system_values.get('version', None)

    if not family and not product:
      raise errors.MalformedPresetError(
          'Invalid operating system missing family and product.')

    return artifacts.OperatingSystemArtifact(
        family=family, product=product, version=version)

Reads an operating system artifact from a dictionary.

Args:
operating_system_values (dict[str, object]): operating system values.

Returns:
OperatingSystemArtifact: an operating system artifact attribute container.

Raises:
MalformedPresetError: if the format of the operating system values are
not set or incorrect.


def load_parent_implems(self, parent_implems):

        for trname, attr, implem in parent_implems.get_custom_implementations():
            self.implementations[trname] = implem.copy()
            self.transitions_at[trname] = attr
            self.custom_implems.add(trname)

Import previously defined implementations.

Args:
parent_implems (ImplementationList): List of implementations defined
in a parent class.


def _validate_at_hash(claims, access_token, algorithm):
    if (('at_hash' not in claims) and (not access_token)):
        return
    elif (('at_hash' in claims) and (not access_token)):
        msg = 'No access_token provided to compare against at_hash claim.'
        raise JWTClaimsError(msg)
    elif (access_token and ('at_hash' not in claims)):
        msg = 'at_hash claim missing from token.'
        raise JWTClaimsError(msg)
    try:
        expected_hash = calculate_at_hash(access_token, ALGORITHMS.HASHES[algorithm])
    except (TypeError, ValueError):
        msg = 'Unable to calculate at_hash to verify against token claims.'
        raise JWTClaimsError(msg)
    if (claims['at_hash'] != expected_hash):
        raise JWTClaimsError('at_hash claim does not match access_token.')

Validates that the 'at_hash' parameter included in the claims matches
with the access_token returned alongside the id token as part of
the authorization_code flow.

Args:
claims (dict): The claims dictionary to validate.
access_token (str): The access token returned by the OpenID Provider.
algorithm (str): The algorithm used to sign the JWT, as specified by
the token headers.


def _load_credentials_file(credentials_file):
    try:
        credentials_file.seek(0)
        data = json.load(credentials_file)
    except Exception:
        logger.warning('Credentials file could not be loaded, will ignore and overwrite.')
        return {}
    if (data.get('file_version') != 2):
        logger.warning('Credentials file is not version 2, will ignore and overwrite.')
        return {}
    credentials = {}
    for (key, encoded_credential) in iteritems(data.get('credentials', {})):
        try:
            credential_json = base64.b64decode(encoded_credential)
            credential = client.Credentials.new_from_json(credential_json)
            credentials[key] = credential
        except:
            logger.warning('Invalid credential {0} in file, ignoring.'.format(key))
    return credentials

Load credentials from the given file handle.

The file is expected to be in this format:

{
"file_version": 2,
"credentials": {
"key": "base64 encoded json representation of credentials."
}
}

This function will warn and return empty credentials instead of raising
exceptions.

Args:
credentials_file: An open file handle.

Returns:
A dictionary mapping user-defined keys to an instance of
:class:`oauth2client.client.Credentials`.


def _normalize_array(array, domain=(0, 1)):

  array = np.array(array)

  array = np.squeeze(array)
  assert len(array.shape) <= 3
  assert np.issubdtype(array.dtype, np.number)
  assert not np.isnan(array).any()

  low, high = np.min(array), np.max(array)
  if domain is None:
    message = "No domain specified, normalizing from measured (~%.2f, ~%.2f)"
    log.debug(message, low, high)
    domain = (low, high)

  if low < domain[0] or high > domain[1]:
    message = "Clipping domain from (~{:.2f}, ~{:.2f}) to (~{:.2f}, ~{:.2f})."
    log.info(message.format(low, high, domain[0], domain[1]))
    array = array.clip(*domain)

  min_value, max_value = np.iinfo(np.uint8).min, np.iinfo(np.uint8).max

  if np.issubdtype(array.dtype, np.inexact):
    offset = domain[0]
    if offset != 0:
      array -= offset
      log.debug("Converting inexact array by subtracting -%.2f.", offset)
    scalar = max_value / (domain[1] - domain[0])
    if scalar != 1:
      array *= scalar
      log.debug("Converting inexact array by scaling by %.2f.", scalar)

  return array.clip(min_value, max_value).astype(np.uint8)

Given an arbitrary rank-3 NumPy array, produce one representing an image.

This ensures the resulting array has a dtype of uint8 and a domain of 0-255.

Args:
array: NumPy array representing the image
domain: expected range of values in array,
defaults to (0, 1), if explicitly set to None will use the array's
own range of values and normalize them.

Returns:
normalized PIL.Image


def _sanitize_slices(slices, intended_shape, deficient_shape):
    sanitized_slices = []
    idx = 0
    for slc in slices:
        if slc is Ellipsis:
            if idx < 0:
                raise ValueError('Found multiple `...` in slices {}'.format(slices))
            num_remaining_non_newaxis_slices = sum((s is not array_ops.newaxis for s in slices[slices.index(Ellipsis) + 1:]))
            idx = -num_remaining_non_newaxis_slices
        elif slc is array_ops.newaxis:
            pass
        else:
            is_broadcast = intended_shape[idx] > deficient_shape[idx]
            if isinstance(slc, slice):
                start, stop, step = (slc.start, slc.stop, slc.step)
                if start is not None:
                    start = _prefer_static_where(is_broadcast, 0, start)
                if stop is not None:
                    stop = _prefer_static_where(is_broadcast, 1, stop)
                if step is not None:
                    step = _prefer_static_where(is_broadcast, 1, step)
                slc = slice(start, stop, step)
            else:
                slc = _prefer_static_where(is_broadcast, 0, slc)
            idx += 1
        sanitized_slices.append(slc)
    return sanitized_slices

Restricts slices to avoid overflowing size-1 (broadcast) dimensions.

Args:
slices: iterable of slices received by `__getitem__`.
intended_shape: int `Tensor` shape for which the slices were intended.
deficient_shape: int `Tensor` shape to which the slices will be applied.
Must have the same rank as `intended_shape`.
Returns:
sanitized_slices: Python `list` of slice objects.


def enter(self, layer, inputs, build_graph, training, saving=None):
    state = {'layer': layer, 'inputs': inputs, 'build_graph': build_graph, 'training': training, 'saving': saving}
    return CallContextManager(self, state)

Push a Layer and its inputs and state onto the current call context.

Args:
layer: The `Layer` whose `call` is currently active.
inputs: The inputs to the currently active `Layer`.
build_graph: Whether currently inside a Graph or FuncGraph.
training: Whether currently executing in training or inference mode.
saving: Whether currently saving to SavedModel.

Returns:
Context manager.


def search_groups(self, group):

        group_url = "%s/%s/%s" % (self.url, "group", group)
        response = self.jss.get(group_url)
        return LDAPGroupsResults(self.jss, response)

Search for LDAP groups.

Args:
group: Group to search for. It is not entirely clear how the
JSS determines the results- are regexes allowed, or
globbing?

Returns:
LDAPGroupsResult object.

Raises:
JSSGetError if no results are found.


def convert_padding(padding, expected_length=4):
    explicit_paddings = []
    if padding == 'EXPLICIT':
        raise ValueError("'EXPLICIT' is not a valid value for `padding`. To use explicit padding, `padding` must be a list.")
    if isinstance(padding, (list, tuple)):
        for i, dim_paddings in enumerate(padding):
            if not isinstance(dim_paddings, (list, tuple)):
                raise ValueError(f'When `padding` is a list, each element of `padding` must be a list/tuple of size 2. Received: padding={padding} with element at index {i} of type {type(dim_paddings)}')
            if len(dim_paddings) != 2:
                raise ValueError(f'When `padding` is a list, each element of `padding` must be a list/tuple of size 2. Received: padding={padding} with element at index {i} of size {len(dim_paddings)}')
            explicit_paddings.extend(dim_paddings)
        if len(padding) != expected_length:
            raise ValueError(f'When padding is a list, it must be of size {expected_length}. Received: padding={padding} of size {len(padding)}')
        padding = 'EXPLICIT'
    return (padding, explicit_paddings)

Converts Python padding to C++ padding for ops which take EXPLICIT padding.

Args:
padding: the `padding` argument for a Python op which supports EXPLICIT
padding.
expected_length: Expected number of entries in the padding list when
explicit padding is used.

Returns:
(padding, explicit_paddings) pair, which should be passed as attributes to a
C++ op.

Raises:
ValueError: If padding is invalid.


def extract(self, text: str) -> List[Extraction]:
    doc = self._tokenizer.tokenize_to_spacy_doc(text)
    self._load_matcher()
    matches = [x for x in self._matcher(doc) if (x[1] != x[2])]
    pos_filtered_matches = []
    neg_filtered_matches = []
    for (idx, start, end) in matches:
        span_doc = self._tokenizer.tokenize_to_spacy_doc(doc[start:end].text)
        this_spacy_rule = self._matcher.get(idx)
        relations = self._find_relation(span_doc, this_spacy_rule)
        (rule_id, _) = self._hash_map[idx]
        this_rule = self._rule_lst[rule_id]
        if self._filter_match(doc[start:end], relations, this_rule.patterns):
            value = self._form_output(doc[start:end], this_rule.output_format, relations, this_rule.patterns)
            if this_rule.polarity:
                pos_filtered_matches.append((start, end, value, rule_id, relations))
            else:
                neg_filtered_matches.append((start, end, value, rule_id, relations))
    return_lst = []
    if pos_filtered_matches:
        longest_lst_pos = self._get_longest(pos_filtered_matches)
        if neg_filtered_matches:
            longest_lst_neg = self._get_longest(neg_filtered_matches)
            return_lst = self._reject_neg(longest_lst_pos, longest_lst_neg)
        else:
            return_lst = longest_lst_pos
    extractions = []
    for (start, end, value, rule_id, relation) in return_lst:
        this_extraction = Extraction(value=value, extractor_name=self.name, start_token=start, end_token=end, start_char=doc[start].idx, end_char=(doc[(end - 1)].idx + len(doc[(end - 1)])), rule_id=rule_id.split('rule_id
        extractions.append(this_extraction)
    return extractions

Extract from text

Args:
text (str): input str to be extracted.

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


def bearing(self, format='numeric'):
    bearings = []
    for segment in self:
        if (len(segment) < 2):
            bearings.append([])
        else:
            bearings.append(segment.bearing(format))
    return bearings

Calculate bearing between locations in segments.

Args:
format (str): Format of the bearing string to return

Returns:
list of list of float: Groups of bearings between points in
segments


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

Retrieves the most recently updated event tag for an event.

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

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


def dialog_open(self, *, dialog: dict, trigger_id: str, **kwargs) -> SlackResponse:
    kwargs.update({'dialog': dialog, 'trigger_id': trigger_id})
    return self.api_call('dialog.open', json=kwargs)

Open a dialog with a user.

Args:
dialog (dict): A dictionary of dialog arguments.
{
"callback_id": "46eh782b0",
"title": "Request something",
"submit_label": "Request",
"state": "Max",
"elements": [
{
"type": "text",
"label": "Origin",
"name": "loc_origin"
},
{
"type": "text",
"label": "Destination",
"name": "loc_destination"
}
]
}
trigger_id (str): The trigger id of a recent message interaction.
e.g. '12345.98765.abcd2358fdea'


def _get_executor_init(self, workers):
    raise NotImplementedError

Gets the Pool initializer for multiprocessing.

Args:
workers: Number of workers.

Returns:
Function, a Function to initialize the pool


def get_type_name_in_language(cls, type_name, sub_type, language):

        if language in cls.type_methods_cache:
            m = cls.type_methods_cache[language]
            if not m:
                return type_name
            return m(type_name)

        found, method = load_language_plugins(language, 'get_type_name')
        if found:
            cls.type_methods_cache[language] = method
            if method:
                return method(type_name, sub_type)
            else:
                return type_name

        module = importlib.import_module('.lang.%s' % language, package="monolithe.generators")

        if not hasattr(module, 'get_type_name'):
            cls.type_methods_cache[language] = None
            return type_name

        method = getattr(module, 'get_type_name')
        cls.type_methods_cache[language] = method
        return method(type_name, sub_type)

Get the type for the given language

Args:
type_name (str): the type to convert
language (str): the language to use

Returns:
a type name in the given language

Example:
get_type_name_in_language("Varchar", "python")
>>> str


def sort_edge(edges):
    return sorted(edges, key=(lambda x: (x.L, x.R)))

Sort iterable of edges first by left node indices then right.

Args:
edges(list[Edge]): List of edges to be sorted.

Returns:
list[Edge]: Sorted list by left and right node indices.


def laid_out_pcoord(self, mesh_axis):

    divisor = list_product(self.shape.to_integer_list[mesh_axis + 1:])
    modulus = self.shape[mesh_axis].size
    def my_fn(pnum):
      return (pnum
    return self.slicewise(my_fn, self.laid_out_pnum())

Returns a LaidOutTensor containing the processor coordinate.

Args:
mesh_axis: int.

Returns:
LaidOutTensor where each slice is an integer scalar.


def fetch(self, invoice_id, data={}, **kwargs):

        return super(Invoice, self).fetch(invoice_id, data, **kwargs)

Fetch Invoice for given Id

Args:
invoice_id : Id for which invoice object has to be retrieved

Returns:
Invoice dict for given invoice Id


def autocorrelation(ts, normalized=False, unbiased=False):
    ts = np.squeeze(ts)
    if (ts.ndim <= 1):
        if normalized:
            ts = ((ts - ts.mean()) / ts.std())
        N = ts.shape[0]
        ar = np.asarray(ts)
        acf = np.correlate(ar, ar, mode='full')
        outlen = ((acf.shape[0] + 1) / 2)
        acf = acf[(outlen - 1):]
        if unbiased:
            factor = np.array([(1.0 / (N - m)) for m in range(0, outlen)])
            acf = (acf * factor)
        dt = ((ts.tspan[(- 1)] - ts.tspan[0]) / (len(ts) - 1.0))
        lags = (np.arange(outlen) * dt)
        return Timeseries(acf, tspan=lags, labels=ts.labels)
    else:
        lastaxis = (ts.ndim - 1)
        m = ts.shape[lastaxis]
        acfs = [ts[(..., i)].autocorrelation(normalized, unbiased)[(..., np.newaxis)] for i in range(m)]
        res = distob.concatenate(acfs, axis=lastaxis)
        res.labels[lastaxis] = ts.labels[lastaxis]
        return res

Returns the discrete, linear convolution of a time series with itself,
optionally using unbiased normalization.

N.B. Autocorrelation estimates are necessarily inaccurate for longer lags,
as there are less pairs of points to convolve separated by that lag.
Therefore best to throw out the results except for shorter lags, e.g.
keep lags from tau=0 up to one quarter of the total time series length.

Args:
normalized (boolean): If True, the time series will first be normalized
to a mean of 0 and variance of 1. This gives autocorrelation 1 at
zero lag.

unbiased (boolean): If True, the result at each lag m will be scaled by
1/(N-m). This gives an unbiased estimation of the autocorrelation of a
stationary process from a finite length sample.

Ref: S. J. Orfanidis (1996) "Optimum Signal Processing", 2nd Ed.


def switch_to_line_in(self, source=None):
    if source:
        uid = source.uid
    else:
        uid = self.uid
    self.avTransport.SetAVTransportURI([('InstanceID', 0), ('CurrentURI', 'x-rincon-stream:{0}'.format(uid)), ('CurrentURIMetaData', '')])

Switch the speaker's input to line-in.

Args:
source (SoCo): The speaker whose line-in should be played.
Default is line-in from the speaker itself.


def topics(self):
    cluster = self._client.cluster
    if (self._client._metadata_refresh_in_progress and self._client._topics):
        future = cluster.request_update()
        self._client.poll(future=future)
    stash = cluster.need_all_topic_metadata
    cluster.need_all_topic_metadata = True
    future = cluster.request_update()
    self._client.poll(future=future)
    cluster.need_all_topic_metadata = stash
    return cluster.topics()

Get all topics the user is authorized to view.

Returns:
set: topics


def deepnn(x):
    with tf.name_scope('reshape'):
        x_image = tf.reshape(x, [(- 1), 28, 28, 1])
    with tf.name_scope('conv1'):
        W_conv1 = weight_variable([5, 5, 1, 32])
        b_conv1 = bias_variable([32])
        h_conv1 = tf.nn.relu((conv2d(x_image, W_conv1) + b_conv1))
    with tf.name_scope('pool1'):
        h_pool1 = max_pool_2x2(h_conv1)
    with tf.name_scope('conv2'):
        W_conv2 = weight_variable([5, 5, 32, 64])
        b_conv2 = bias_variable([64])
        h_conv2 = tf.nn.relu((conv2d(h_pool1, W_conv2) + b_conv2))
    with tf.name_scope('pool2'):
        h_pool2 = max_pool_2x2(h_conv2)
    with tf.name_scope('fc1'):
        W_fc1 = weight_variable([((7 * 7) * 64), 1024])
        b_fc1 = bias_variable([1024])
        h_pool2_flat = tf.reshape(h_pool2, [(- 1), ((7 * 7) * 64)])
        h_fc1 = tf.nn.relu((tf.matmul(h_pool2_flat, W_fc1) + b_fc1))
    with tf.name_scope('dropout'):
        keep_prob = tf.placeholder(tf.float32)
        h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
    with tf.name_scope('fc2'):
        W_fc2 = weight_variable([1024, 10])
        b_fc2 = bias_variable([10])
        y_conv = (tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
    return (y_conv, keep_prob)

deepnn builds the graph for a deep net for classifying digits.

Args:
x: an input tensor with the dimensions (N_examples, 784), where 784 is
the number of pixels in a standard MNIST image.

Returns:
A tuple (y, keep_prob). y is a tensor of shape (N_examples, 10), with
values equal to the logits of classifying the digit into one of 10
classes (the digits 0-9). keep_prob is a scalar placeholder for the
probability of dropout.


def _get_countdown_for_next_slice(self, spec):
    countdown = 0
    if (self._processing_limit(spec) != (- 1)):
        countdown = max(int((parameters.config._SLICE_DURATION_SEC - (self._time() - self._start_time))), 0)
    return countdown

Get countdown for next slice's task.

When user sets processing rate, we set countdown to delay task execution.

Args:
spec: model.MapreduceSpec

Returns:
countdown in int.


def find_many(self, url, type, resource):

        return [type(item) for item in RestClient.get(url)[resource]]

Get a list of resources

Args:
url (string): URL to invoke
type (class): Class type
resource (string): The REST Resource
Returns:
list of object: List of resource instances


def job_history(backend):
    year = widgets.Output(layout=widgets.Layout(display='flex-inline', align_items='center', min_height='400px'))
    month = widgets.Output(layout=widgets.Layout(display='flex-inline', align_items='center', min_height='400px'))
    week = widgets.Output(layout=widgets.Layout(display='flex-inline', align_items='center', min_height='400px'))
    tabs = widgets.Tab(layout=widgets.Layout(max_height='620px'))
    tabs.children = [year, month, week]
    tabs.set_title(0, 'Year')
    tabs.set_title(1, 'Month')
    tabs.set_title(2, 'Week')
    tabs.selected_index = 1
    _build_job_history(tabs, backend)
    return tabs

Widget for displaying job history

Args:
backend (IBMQbackend): The backend.

Returns:
Tab: A tab widget for history images.


def get_msms_df(model, pdb_id, outfile=None, outdir=None, outext='_msms.df', force_rerun=False):

    outfile = ssbio.utils.outfile_maker(inname=pdb_id, outname=outfile, outdir=outdir, outext=outext)

    if ssbio.utils.force_rerun(flag=force_rerun, outfile=outfile):

        try:
            rd = PDB.ResidueDepth(model)
        except AssertionError:
            log.error('{}: unable to run MSMS'.format(pdb_id))
            return pd.DataFrame()

        appender = []
        for k in rd.property_keys:
            x = rd.property_dict[k]
            chain = k[0]
            residue = k[1]
            het = residue[0]
            resnum = residue[1]
            icode = residue[2]
            resdepth = x[0]
            cadepth = x[1]
            appender.append((chain, resnum, icode, resdepth, cadepth))

        df = pd.DataFrame.from_records(appender, columns=['chain', 'resnum', 'icode', 'res_depth', 'ca_depth'])
        df.to_csv(outfile)
    else:
        log.debug('{}: already ran MSMS and force_rerun={}, loading results'.format(outfile, force_rerun))
        df = pd.read_csv(outfile, index_col=0)

    return df

Run MSMS (using Biopython) on a Biopython Structure Model.

Depths are in units Angstroms. 1A = 10^-10 m = 1nm. Returns a dictionary of::

{
chain_id:{
resnum1_id: (res_depth, ca_depth),
resnum2_id: (res_depth, ca_depth)
}
}

Args:
model: Biopython Structure Model

Returns:
Pandas DataFrame: ResidueDepth property_dict, reformatted


def run(self, module, post_check):

        try:

            _cwd = os.getcwd()
            _sys_path = list(sys.path)
            _sys_argv = list(sys.argv)
            sys.path.insert(0, os.path.dirname(self._path))
            sys.argv = [os.path.basename(self._path)] + self._argv

            exec(self._code, module.__dict__)
            post_check()

        except Exception as e:
            self._failed = True
            self._error_detail = traceback.format_exc()

            _exc_type, _exc_value, exc_traceback = sys.exc_info()
            filename, line_number, func, txt = traceback.extract_tb(exc_traceback)[-1]

            self._error = "%s\nFile \"%s\", line %d, in %s:\n%s" % (str(e), os.path.basename(filename), line_number, func, txt)

        finally:

            os.chdir(_cwd)
            sys.path = _sys_path
            sys.argv = _sys_argv
            self.ran = True

Execute the configured source code in a module and run any post
checks.

Args:
module (Module) : a module to execute the configured code in.

post_check(callable) : a function that can raise an exception
if expected post-conditions are not met after code execution.


def _ScanVolume(self, scan_context, scan_node, base_path_specs):
    if ((not scan_node) or (not scan_node.path_spec)):
        raise errors.ScannerError('Invalid or missing scan node.')
    if scan_context.IsLockedScanNode(scan_node.path_spec):
        self._ScanEncryptedVolume(scan_context, scan_node)
        if scan_context.IsLockedScanNode(scan_node.path_spec):
            return
    if scan_node.IsVolumeSystemRoot():
        self._ScanVolumeSystemRoot(scan_context, scan_node, base_path_specs)
    elif scan_node.IsFileSystem():
        self._ScanFileSystem(scan_node, base_path_specs)
    elif (scan_node.type_indicator == definitions.TYPE_INDICATOR_VSHADOW):
        path_spec = path_spec_factory.Factory.NewPathSpec(definitions.TYPE_INDICATOR_TSK, location='/', parent=scan_node.path_spec)
        base_path_specs.append(path_spec)
    else:
        for sub_scan_node in scan_node.sub_nodes:
            self._ScanVolume(scan_context, sub_scan_node, base_path_specs)

Scans a volume scan node for volume and file systems.

Args:
scan_context (SourceScannerContext): source scanner context.
scan_node (SourceScanNode): volume scan node.
base_path_specs (list[PathSpec]): file system base path specifications.

Raises:
ScannerError: if the format of or within the source
is not supported or the scan node is invalid.


def insert(self, **fields):
    if (self.conflict_target or self.conflict_action):
        compiler = self._build_insert_compiler([fields])
        rows = compiler.execute_sql(return_id=True)
        pk_field_name = self.model._meta.pk.name
        return rows[0][pk_field_name]
    return super().create(**fields).pk

Creates a new record in the database.

This allows specifying custom conflict behavior using .on_conflict().
If no special behavior was specified, this uses the normal Django create(..)

Arguments:
fields:
The fields of the row to create.

Returns:
The primary key of the record that was created.


def _request(self, method, url, body):
    if ((method != 'POST') and (method != 'PUT')):
        body = None
    s = Session()
    LOGGER.debug('Method: {0}, Url: {1}, Body: {2}.'.format(method, url, body))
    req = Request(method, url, json=body)
    prepped = s.prepare_request(req)
    res = s.send(prepped, timeout=(self._timeout or None))
    res.raise_for_status()
    return res.json()

Internal method to send request to the remote server.

Args:
method(str): HTTP Method(GET/POST/PUT/DELET/HEAD).
url(str): The request url.
body(dict): The JSON object to be sent.

Returns:
A dict represent the json body from server response.

Raises:
ConnectionError: Meet network problem (e.g. DNS failure,
refused connection, etc).
Timeout: A request times out.
HTTPError: HTTP request returned an unsuccessful status code.


def normalize_attr_values(a: Any) -> np.ndarray:

	scalar = False
	if np.isscalar(a):
		a = np.array([a])
		scalar = True
	arr = normalize_attr_array(a)
	if np.issubdtype(arr.dtype, np.integer) or np.issubdtype(arr.dtype, np.floating):
		pass
	elif np.issubdtype(arr.dtype, np.character) or np.issubdtype(arr.dtype, np.object_):
		arr = normalize_attr_strings(arr)
	elif np.issubdtype(arr.dtype, np.bool_):
		arr = arr.astype('ubyte')
	if scalar:
		return arr[0]
	else:
		return arr

Take all kinds of input values and validate/normalize them.

Args:
a	List, tuple, np.matrix, np.ndarray or sparse matrix
Elements can be strings, numbers or bools

Returns
a_normalized    An np.ndarray with elements conforming to one of the valid Loom attribute types

Remarks:
This method should be used to prepare the values to be stored in the HDF5 file. You should not
return the values to the caller; for that, use materialize_attr_values()


def bartlett(x):
    if any_symbolic_tensors((x,)):
        return Bartlett().symbolic_call(x)
    return backend.numpy.bartlett(x)

Bartlett window function.
The Bartlett window is a triangular window that rises then falls linearly.

Args:
x: Scalar or 1D Tensor. Window length.

Returns:
A 1D tensor containing the Bartlett window values.

Example:
>>> x = keras.ops.convert_to_tensor(5)
>>> keras.ops.bartlett(x)
array([0. , 0.5, 1. , 0.5, 0. ], dtype=float32)


def _make_projcet_list(path):

    from collections import OrderedDict
    from matplotlib.colors import LinearSegmentedColormap
    from matplotlib.colors import rgb2hex as r2h
    from numpy import linspace

    proj = []
    projects = OrderedDict()
    file_list = os.listdir(path)
    for files in file_list:
        if files.split(".")[0] not in proj and 'json' in files and "
            proj.append(files.split(".")[0])

    colors = _get_colors(len(proj))
    p_c = 0

    for p in proj:
        tasks = OrderedDict()
        temp = [x.split(".")[1] for x in file_list if p in x and "
        cmspace = linspace(0.95, 0.25, len(temp))
        cm = LinearSegmentedColormap.from_list("acorn.{}".format(p),
                                               ['
                                               N=max((len(temp), 25)))
        hues = [r2h(cm(cmi)) for cmi in cmspace]
        h_c = 0
        for t in temp:
            tasks[t] = [hues[h_c],p+"."+t+".json"]
            h_c += 1
        tasks["hex_color"] = colors[p_c]
        projects[p] = tasks
        p_c += 1

    return projects

Returns a dictionaries in which each project is a key and the
tasks are stored as a list within that dictionaly element.

Args:
path (str): The path to the folder containing the *.json files.

Returns:
projects (list of dict): A dictionary in which each project is a key
containing a list of it's tasks.


def _preprocess_movie_lens(ratings_df):

  ratings_df["data"] = 1.0
  num_timestamps = ratings_df[["userId", "timestamp"]].groupby(
      "userId").nunique()
  last_user_timestamp = ratings_df[["userId", "timestamp"]].groupby(
      "userId").max()

  ratings_df["numberOfTimestamps"] = ratings_df["userId"].apply(
      lambda x: num_timestamps["timestamp"][x])
  ratings_df["lastTimestamp"] = ratings_df["userId"].apply(
      lambda x: last_user_timestamp["timestamp"][x])

  ratings_df = ratings_df[ratings_df["numberOfTimestamps"] > 2]

  ratings_df = _create_row_col_indices(ratings_df)

  train_ratings_df = ratings_df[
      ratings_df["timestamp"] < ratings_df["lastTimestamp"]]
  test_ratings_df = ratings_df[
      ratings_df["timestamp"] == ratings_df["lastTimestamp"]]

  return ratings_df, train_ratings_df, test_ratings_df

Separate the rating datafram into train and test sets.

Filters out users with less than two distinct timestamps. Creates train set
and test set. The test set contains all the last interactions of users with
more than two distinct timestamps.

Args:
ratings_df: pandas dataframe with columns 'userId', 'movieId', 'rating',
'timestamp'.

Returns:
tuple of dataframes (filtered_ratings, train_ratings, test_ratings).


def write_fixed_str(self, value, length):

        towrite = value.encode('utf-8')
        slen = len(towrite)
        if slen > length:
            raise SDKException(ErrorCode.param_err('string longer than fixed length: %s' % length))
        self.write_bytes(towrite)
        diff = length - slen

        while diff > 0:
            self.write_byte(0)
            diff -= 1

Write a string value to the stream.

Args:
value (str): value to write to the stream.
length (int): length of the string to write.


def fetch_layout(self, dtensor: Any) -> layout_lib.Layout:
    if not context.executing_eagerly():
        raise RuntimeError('`fetch_layout` must be called eagerly.')
    if _pywrap_utils.IsVariable(dtensor):
        dtensor = dtensor.read_value()
    try:
        layout_string = _pywrap_dtensor_device.FetchLayout(context.context()._handle, dtensor, self._device_info)
    except core._NotOkStatusException as e:
        raise core._status_to_exception(e) from None
    if layout_string is None:
        return None
    return layout_lib.Layout.from_string(layout_string)

Fetches the layout of the DTensor.

Args:
dtensor: The DTensor whose layout is to be fetched.

Returns:
The `Layout` of this DTensor.

Raises:
RuntimeError: When not called eagerly.


def symmetric_linear_quantization_params(num_bits, saturation_min, saturation_max, per_channel=False):
    with torch.no_grad():
        n = 2 ** (num_bits - 1) - 1
        if per_channel:
            scale, _ = torch.max(torch.stack([saturation_min.abs(), saturation_max.abs()], dim=1), dim=1)
            scale = torch.clamp(scale, min=1e-08) / n
        else:
            scale = max(saturation_min.abs(), saturation_max.abs())
            scale = torch.clamp(scale, min=1e-08) / n
    return scale

Compute the scaling factor with the given quantization range for symmetric quantization.

Args:
saturation_min (`torch.Tensor`):
Lower bound for quantization range.
saturation_max (`torch.Tensor`):
Upper bound for quantization range.
per_channel (`bool`, *optional*, defaults to `False`):
Whether to or not use channel-wise quantization.

Returns:
`torch.Tensor`: Scaling factor that linearly quantizes the given range between *saturation_min* and
*saturation_max*.


def generate(store, report_format, path):

    success = False
    if report_format in ['html']:
        rendered_content = {
            'html': generate_html
        }[report_format](store)

        if not os.path.isdir(path):
            os.makedirs(path)

        if rendered_content is not None:

            with open(os.path.join(path, 'pipeline.' + report_format), 'w') as handle:
                handle.write(rendered_content)
            success = True
    else:
        Logger.get_logger(__name__).error("Unknown report format %s", report_format)
    return success

Generate file in defined format representing the report of pipeline(s).

Args:
store (Store): report data.
report_format (str): currently "html" is supported only.
path (str): path where to write the report to. Missing sub folders will be created.


class PatchTSTPatchify(nn.Module):

    def __init__(self, config: PatchTSTConfig):
        super().__init__()
        self.sequence_length = config.context_length
        self.patch_length = config.patch_length
        self.patch_stride = config.patch_stride
        if self.sequence_length <= self.patch_length:
            raise ValueError(f'Sequence length ({self.sequence_length}) has to be greater than the patch length ({self.patch_length})')
        self.num_patches = (max(self.sequence_length, self.patch_length) - self.patch_length)
        new_sequence_length = self.patch_length + self.patch_stride * (self.num_patches - 1)
        self.sequence_start = self.sequence_length - new_sequence_length

    def forward(self, past_values: torch.Tensor):

        sequence_length = past_values.shape[-2]
        if sequence_length != self.sequence_length:
            raise ValueError(f"Input sequence length ({sequence_length}) doesn't match model configuration ({self.sequence_length}).")
        output = past_values[:, self.sequence_start:, :]
        output = output.unfold(dimension=-2, size=self.patch_length, step=self.patch_stride)
        output = output.transpose(-2, -3).contiguous()
        return output

A class to patchify the time series sequence into different patches

Returns:
`torch.Tensor` of shape `(batch_size, num_channels, num_patches, patch_length)`


def ContainsKey(self, public_key):

        return self.ContainsKeyHash(Crypto.ToScriptHash(public_key.encode_point(True), unhex=True))

Test if the wallet contains the supplied public key.

Args:
public_key (edcsa.Curve.point): a public key to test for its existance. e.g. KeyPair.PublicKey

Returns:
bool: True if exists, False otherwise.


def load_image(image: Union[str, 'PIL.Image.Image'], timeout: Optional[float]=None) -> 'PIL.Image.Image':
    requires_backends(load_image, ['vision'])
    if isinstance(image, str):
        if image.startswith('http:
            image = PIL.Image.open(BytesIO(requests.get(image, timeout=timeout).content))
        elif os.path.isfile(image):
            image = PIL.Image.open(image)
        else:
            if image.startswith('data:image/'):
                image = image.split(',')[1]
            try:
                b64 = base64.decodebytes(image.encode())
                image = PIL.Image.open(BytesIO(b64))
            except Exception as e:
                raise ValueError(f'Incorrect image source. Must be a valid URL starting with `http:
    elif isinstance(image, PIL.Image.Image):
        image = image
    else:
        raise TypeError('Incorrect format used for image. Should be an url linking to an image, a base64 string, a local path, or a PIL image.')
    image = PIL.ImageOps.exif_transpose(image)
    image = image.convert('RGB')
    return image

Loads `image` to a PIL Image.

Args:
image (`str` or `PIL.Image.Image`):
The image to convert to the PIL Image format.
timeout (`float`, *optional*):
The timeout value in seconds for the URL request.

Returns:
`PIL.Image.Image`: A PIL Image.


def summary_computed(self, sess, summary, global_step=None):
    if not self._summary_writer:
        raise RuntimeError('Writing a summary requires a summary writer.')
    if global_step is None and self.global_step is not None:
        global_step = training_util.global_step(sess, self.global_step)
    self._summary_writer.add_summary(summary, global_step)

Indicate that a summary was computed.

Args:
sess: A `Session` object.
summary: A Summary proto, or a string holding a serialized summary proto.
global_step: Int. global step this summary is associated with. If `None`,
it will try to fetch the current step.

Raises:
TypeError: if 'summary' is not a Summary proto or a string.
RuntimeError: if the Supervisor was created without a `logdir`.


def create_position_ids_from_input_ids(input_ids, padding_idx):
    mask = (input_ids != padding_idx).astype('i4')
    if mask.ndim > 2:
        mask = mask.reshape((-1, mask.shape[-1]))
        incremental_indices = jnp.cumsum(mask, axis=1).astype('i4') * mask
        incremental_indices = incremental_indices.reshape(input_ids.shape)
    else:
        incremental_indices = jnp.cumsum(mask, axis=1).astype('i4') * mask
    return incremental_indices.astype('i4') + padding_idx

Replace non-padding symbols with their position numbers. Position numbers begin at padding_idx+1. Padding symbols
are ignored. This is modified from fairseq's `utils.make_positions`.

Args:
input_ids: jnp.ndarray
padding_idx: int

Returns: jnp.ndarray


def matrices_compliance(dsm, complete_mediation_matrix):

        matrix = dsm.data
        rows_dep_matrix = len(matrix)
        cols_dep_matrix = len(matrix[0])
        rows_med_matrix = len(complete_mediation_matrix)
        cols_med_matrix = len(complete_mediation_matrix[0])

        if (rows_dep_matrix != rows_med_matrix or
                cols_dep_matrix != cols_med_matrix):
            raise DesignStructureMatrixError(
                'Matrices are NOT compliant '
                '(number of rows/columns not equal)')

        discrepancy_found = False
        message = []
        for i in range(0, rows_dep_matrix):
            for j in range(0, cols_dep_matrix):
                if ((complete_mediation_matrix[i][j] == 0 and
                        matrix[i][j] > 0) or
                        (complete_mediation_matrix[i][j] == 1 and
                         matrix[i][j] < 1)):
                    discrepancy_found = True
                    message.append(
                        'Untolerated dependency at %s:%s (%s:%s): '
                        '%s instead of %s' % (
                            i, j, dsm.entities[i], dsm.entities[j],
                            matrix[i][j], complete_mediation_matrix[i][j]))

        message = '\n'.join(message)

        return not discrepancy_found, message

Check if matrix and its mediation matrix are compliant.

Args:
dsm (:class:`DesignStructureMatrix`): the DSM to check.
complete_mediation_matrix (list of list of int): 2-dim array

Returns:
bool: True if compliant, else False


def __init__(
            self,
            network_retries: int = DEFAULT_NETWORK_RETRIES,
            network_timeout: int = DEFAULT_NETWORK_TIMEOUT
    ) -> None:

        self._plugins_repository = PluginsRepository()

        SslConnection.set_global_network_settings(network_retries, network_timeout)

Create a scanner for running scanning commands synchronously.

Args:
network_retries: How many times SSLyze should retry a connection that timed out.
network_timeout: The time until an ongoing connection times out.


def run(self):

        import behave.__main__ as behave

        for d in self.firmware_dirs:
            original_dir = os.getcwd()
            os.chdir(d)

            output = ''
            try:
                output = subprocess.check_output('make', shell=True, stderr=subprocess.STDOUT)
            except subprocess.CalledProcessError as e:
                if output:
                    sys.stdout.write('Captured Output:%s%s%s' % (os.linesep, output, os.linesep))
                os.chdir(original_dir)
                raise e

            os.chdir(original_dir)

        return behave.main([self.features_dir])

Runs the command.

Args:
self (BDDTestCommand): the ``BDDTestCommand`` instance

Returns:
``True`` on success, otherwise ``False``.

Raises:
ValueError: if a build fails


def add_status_parser(subparsers, parent_parser):

    parser = subparsers.add_parser(
        'status',
        help='Displays information about validator status',
        description="Provides a subcommand to show a validator\'s status")

    grand_parsers = parser.add_subparsers(title='subcommands',
                                          dest='subcommand')
    grand_parsers.required = True
    add_status_show_parser(grand_parsers, parent_parser)

Adds argument parser for the status command

Args:
subparsers: Add parsers to this subparser object
parent_parser: The parent argparse.ArgumentParser object