def build_metagraph_list(self):
    ops = []
    self.ignore_unknown_dtypes = True
    for key in sorted(self.meta_params):
        value = self.convert_data_to_string(self.meta_params[key])
        if (len(value) == 0):
            continue
        if isinstance(value, str):
            ops.append(tf.contrib.summary.generic(name=key, tensor=tf.convert_to_tensor(str(value))))
        else:
            ops.append(tf.contrib.summary.generic(name=key, tensor=tf.as_string(tf.convert_to_tensor(value))))
    return ops

Convert MetaParams into TF Summary Format and create summary_op.

Returns:
Merged TF Op for TEXT summary elements, should only be executed once to reduce data duplication.


def _make_unique_slug(slug: str, language: str, is_unique: Callable[([str], bool)]) -> str:
    index = 1
    unique_slug = slug
    while (not is_unique(unique_slug, language)):
        unique_slug = ('%s-%d' % (slug, index))
        index += 1
    return unique_slug

Guarentees that the specified slug is unique by appending
a number until it is unique.

Arguments:
slug:
The slug to make unique.

is_unique:
Function that can be called to verify
whether the generate slug is unique.

Returns:
A guarenteed unique slug.


def original(self, index=None):
    if (index is None):
        try:
            return next(self.select(Original, None, False, False))
        except StopIteration:
            raise NoSuchAnnotation
    else:
        for e in self.select(Original, None, False, False):
            return e[index]
        raise NoSuchAnnotation

Get the old annotation prior to correction.

This returns only one annotation if multiple exist, use `index` to select another in the sequence.

Returns:
an annotation element (:class:`AbstractElement`)

Raises:
:class:`NoSuchAnnotation`


def get_psd(self, omega):

        w = np.asarray(omega)
        (alpha_real, beta_real, alpha_complex_real, alpha_complex_imag,
         beta_complex_real, beta_complex_imag) = self.coefficients
        p = get_psd_value(
            alpha_real, beta_real,
            alpha_complex_real, alpha_complex_imag,
            beta_complex_real, beta_complex_imag,
            w.flatten(),
        )
        return p.reshape(w.shape)

Compute the PSD of the term for an array of angular frequencies

Args:
omega (array[...]): An array of frequencies where the PSD should
be evaluated.

Returns:
The value of the PSD for each ``omega``. This will have the same
shape as ``omega``.


def read_cifar10(filename_queue):

    class CIFAR10Record(object):
        pass
    result = CIFAR10Record()
    label_bytes = 1
    result.height = 32
    result.width = 32
    result.depth = 3
    image_bytes = ((result.height * result.width) * result.depth)
    record_bytes = (label_bytes + image_bytes)
    reader = tf.FixedLengthRecordReader(record_bytes=record_bytes)
    (result.key, value) = reader.read(filename_queue)
    record_bytes = tf.decode_raw(value, tf.uint8)
    result.label = tf.cast(tf.strided_slice(record_bytes, [0], [label_bytes]), tf.int32)
    depth_major = tf.reshape(tf.strided_slice(record_bytes, [label_bytes], [(label_bytes + image_bytes)]), [result.depth, result.height, result.width])
    result.uint8image = tf.transpose(depth_major, [1, 2, 0])
    return result

Reads and parses examples from CIFAR10 data files.

Recommendation: if you want N-way read parallelism, call this function
N times.  This will give you N independent Readers reading different
files & positions within those files, which will give better mixing of
examples.

Args:
filename_queue: A queue of strings with the filenames to read from.

Returns:
An object representing a single example, with the following fields:
height: number of rows in the result (32)
width: number of columns in the result (32)
depth: number of color channels in the result (3)
key: a scalar string Tensor describing the filename & record number
for this example.
label: an int32 Tensor with the label in the range 0..9.
uint8image: a [height, width, depth] uint8 Tensor with the image data


def CreateFile(filename):

  with gcs.open(filename, 'w') as f:
    f.write('abcde\n')

  blobstore_filename = '/gs' + filename
  return blobstore.create_gs_key(blobstore_filename)

Create a GCS file with GCS client lib.

Args:
filename: GCS filename.

Returns:
The corresponding string blobkey for this GCS file.


def parse_selinux(parts):
    (owner, group) = parts[:2]
    selinux = parts[2].split(':')
    lsel = len(selinux)
    (path, link) = parse_path(parts[(- 1)])
    result = {'owner': owner, 'group': group, 'se_user': selinux[0], 'se_role': (selinux[1] if (lsel > 1) else None), 'se_type': (selinux[2] if (lsel > 2) else None), 'se_mls': (selinux[3] if (lsel > 3) else None), 'name': path}
    if link:
        result['link'] = link
    return result

Parse part of an ls output line that is selinux.

Args:
parts (list): A four element list of strings representing the initial
parts of an ls line after the permission bits. The parts are owner
group, selinux info, and the path.

Returns:
A dict containing owner, group, se_user, se_role, se_type, se_mls, and
name. If the raw name was a symbolic link, link is always included.


def poisson_ll(data, means):
    if sparse.issparse(data):
        return sparse_poisson_ll(data, means)
    (genes, cells) = data.shape
    clusters = means.shape[1]
    ll = np.zeros((cells, clusters))
    for i in range(clusters):
        means_i = np.tile(means[(:, i)], (cells, 1))
        means_i = (means_i.transpose() + eps)
        ll[(:, i)] = np.sum((xlogy(data, means_i) - means_i), 0)
    return ll

Calculates the Poisson log-likelihood.

Args:
data (array): 2d numpy array of genes x cells
means (array): 2d numpy array of genes x k

Returns:
cells x k array of log-likelihood for each cell/cluster pair


def _MergeField(self, tokenizer, message):

    message_descriptor = message.DESCRIPTOR
    if (hasattr(message_descriptor, 'syntax') and
        message_descriptor.syntax == 'proto3'):

      self._allow_multiple_scalars = True
    if tokenizer.TryConsume('['):
      name = [tokenizer.ConsumeIdentifier()]
      while tokenizer.TryConsume('.'):
        name.append(tokenizer.ConsumeIdentifier())
      name = '.'.join(name)

      if not message_descriptor.is_extendable:
        raise tokenizer.ParseErrorPreviousToken(
            'Message type "%s" does not have extensions.' %
            message_descriptor.full_name)

      field = message.Extensions._FindExtensionByName(name)

      if not field:
        if self.allow_unknown_extension:
          field = None
        else:
          raise tokenizer.ParseErrorPreviousToken(
              'Extension "%s" not registered.' % name)
      elif message_descriptor != field.containing_type:
        raise tokenizer.ParseErrorPreviousToken(
            'Extension "%s" does not extend message type "%s".' %
            (name, message_descriptor.full_name))

      tokenizer.Consume(']')

    else:
      name = tokenizer.ConsumeIdentifierOrNumber()
      if self.allow_field_number and name.isdigit():
        number = ParseInteger(name, True, True)
        field = message_descriptor.fields_by_number.get(number, None)
        if not field and message_descriptor.is_extendable:
          field = message.Extensions._FindExtensionByNumber(number)
      else:
        field = message_descriptor.fields_by_name.get(name, None)

        if not field:
          field = message_descriptor.fields_by_name.get(name.lower(), None)
          if field and field.type != descriptor.FieldDescriptor.TYPE_GROUP:
            field = None

        if (field and field.type == descriptor.FieldDescriptor.TYPE_GROUP and
            field.message_type.name != name):
          field = None

      if not field:
        raise tokenizer.ParseErrorPreviousToken(
            'Message type "%s" has no field named "%s".' %
            (message_descriptor.full_name, name))

    if field:
      if not self._allow_multiple_scalars and field.containing_oneof:

        which_oneof = message.WhichOneof(field.containing_oneof.name)
        if which_oneof is not None and which_oneof != field.name:
          raise tokenizer.ParseErrorPreviousToken(
              'Field "%s" is specified along with field "%s", another member '
              'of oneof "%s" for message type "%s".' %
              (field.name, which_oneof, field.containing_oneof.name,
               message_descriptor.full_name))

      if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:
        tokenizer.TryConsume(':')
        merger = self._MergeMessageField
      else:
        tokenizer.Consume(':')
        merger = self._MergeScalarField

      if (field.label == descriptor.FieldDescriptor.LABEL_REPEATED and
          tokenizer.TryConsume('[')):

        while True:
          merger(tokenizer, message, field)
          if tokenizer.TryConsume(']'):
            break
          tokenizer.Consume(',')

      else:
        merger(tokenizer, message, field)

    else:
      assert self.allow_unknown_extension
      _SkipFieldContents(tokenizer)

    if not tokenizer.TryConsume(','):
      tokenizer.TryConsume(';')

Merges a single protocol message field into a message.

Args:
tokenizer: A tokenizer to parse the field name and values.
message: A protocol message to record the data.

Raises:
ParseError: In case of text parsing problems.


def convert_seeded_answers(answers):
    converted = {}
    for (index, answer) in enumerate(answers):
        converted.setdefault(answer['answer'], {})
        converted[answer['answer']][('seeded' + str(index))] = answer['rationale']
    return converted

Convert seeded answers into the format that can be merged into student answers.

Args:
answers (list): seeded answers

Returns:
dict: seeded answers with student answers format:
{
0: {
'seeded0': 'rationaleA'
}
1: {
'seeded1': 'rationaleB'
}
}


def usergroups_users_update(self, *, usergroup: str, users: List[str], **kwargs) -> SlackResponse:
    self._validate_xoxp_token()
    kwargs.update({'usergroup': usergroup, 'users': users})
    return self.api_call('usergroups.users.update', json=kwargs)

Update the list of users for a User Group

Args:
usergroup (str): The encoded ID of the User Group to update.
e.g. 'S0604QSJC'
users (list): A list user IDs that represent the entire list of
users for the User Group. e.g. ['U060R4BJ4', 'U060RNRCZ']


def create(self, specify_uri=False, ignore_tombstone=False, serialization_format=None, stream=False, auto_refresh=None):
    if self.exists:
        raise Exception('resource exists attribute True, aborting')
    else:
        if specify_uri:
            verb = 'PUT'
        else:
            verb = 'POST'
        logger.debug(('creating resource %s with verb %s' % (self.uri, verb)))
        if issubclass(type(self), NonRDFSource):
            self.binary._prep_binary()
            data = self.binary.data
        else:
            if (not serialization_format):
                serialization_format = self.repo.default_serialization
            data = self.rdf.graph.serialize(format=serialization_format)
            logger.debug('Serialized graph used for resource creation:')
            logger.debug(data.decode('utf-8'))
            self.headers['Content-Type'] = serialization_format
        response = self.repo.api.http_request(verb, self.uri, data=data, headers=self.headers, stream=stream)
        return self._handle_create(response, ignore_tombstone, auto_refresh)

Primary method to create resources.

Args:
specify_uri (bool): If True, uses PUT verb and sets the URI during creation.  If False, uses POST and gets repository minted URI
ignore_tombstone (bool): If True, will attempt creation, if tombstone exists (409), will delete tombstone and retry
serialization_format(str): Content-Type header / mimetype that will be used to serialize self.rdf.graph, and set headers for PUT/POST requests
auto_refresh (bool): If True, refreshes resource after update. If left None, defaults to repo.default_auto_refresh


def single_qubit_state_tomography(sampler: sim.Sampler, qubit: devices.GridQubit, circuit: circuits.Circuit, repetitions: int=1000) -> TomographyResult:
    circuit_z = (circuit + circuits.Circuit.from_ops(ops.measure(qubit, key='z')))
    results = sampler.run(circuit_z, repetitions=repetitions)
    rho_11 = np.mean(results.measurements['z'])
    rho_00 = (1.0 - rho_11)
    circuit_x = circuits.Circuit.from_ops(circuit, (ops.X(qubit) ** 0.5), ops.measure(qubit, key='z'))
    results = sampler.run(circuit_x, repetitions=repetitions)
    rho_01_im = (np.mean(results.measurements['z']) - 0.5)
    circuit_y = circuits.Circuit.from_ops(circuit, (ops.Y(qubit) ** (- 0.5)), ops.measure(qubit, key='z'))
    results = sampler.run(circuit_y, repetitions=repetitions)
    rho_01_re = (0.5 - np.mean(results.measurements['z']))
    rho_01 = (rho_01_re + (1j * rho_01_im))
    rho_10 = np.conj(rho_01)
    rho = np.array([[rho_00, rho_01], [rho_10, rho_11]])
    return TomographyResult(rho)

Single-qubit state tomography.

The density matrix of the output state of a circuit is measured by first
doing projective measurements in the z-basis, which determine the
diagonal elements of the matrix. A X/2 or Y/2 rotation is then added before
the z-basis measurement, which determines the imaginary and real parts of
the off-diagonal matrix elements, respectively.

See Vandersypen and Chuang, Rev. Mod. Phys. 76, 1037 for details.

Args:
sampler: The quantum engine or simulator to run the circuits.
qubit: The qubit under test.
circuit: The circuit to execute on the qubit before tomography.
repetitions: The number of measurements for each basis rotation.

Returns:
A TomographyResult object that stores and plots the density matrix.


def ParseZeitgeistEventRow(self, parser_mediator, query, row, **unused_kwargs):
    query_hash = hash(query)
    event_data = ZeitgeistActivityEventData()
    event_data.offset = self._GetRowValue(query_hash, row, 'id')
    event_data.query = query
    event_data.subject_uri = self._GetRowValue(query_hash, row, 'subj_uri')
    timestamp = self._GetRowValue(query_hash, row, 'timestamp')
    date_time = dfdatetime_java_time.JavaTime(timestamp=timestamp)
    event = time_events.DateTimeValuesEvent(date_time, definitions.TIME_DESCRIPTION_UNKNOWN)
    parser_mediator.ProduceEventWithEventData(event, event_data)

Parses a zeitgeist event row.

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


def from_file(cls, jss, filename):

        tree = ElementTree.parse(filename)
        root = tree.getroot()
        return cls(jss, root)

Create a new JSSObject from an external XML file.

Args:
jss: A JSS object.
filename: String path to an XML file.


def _copy_delpoy_scripts(self, scripts):
    if (not os.path.exists(self.paths.scripts())):
        os.makedirs(self.paths.scripts())
    new_scripts = []
    for script in scripts:
        script = os.path.expandvars(script)
        if (not os.path.exists(script)):
            raise RuntimeError(('Script %s does not exist' % script))
        sanitized_name = script.replace('/', '_')
        new_script_cur_path = os.path.expandvars(self.paths.scripts(sanitized_name))
        shutil.copy(script, new_script_cur_path)
        new_script_init_path = os.path.join('$LAGO_PREFIX_PATH', os.path.basename(self.paths.scripts()), sanitized_name)
        new_scripts.append(new_script_init_path)
    return new_scripts

Copy the given deploy scripts to the scripts dir in the prefix

Args:
scripts(list of str): list of paths of the scripts to copy to the
prefix

Returns:
list of str: list with the paths to the copied scripts, with a
prefixed with $LAGO_PREFIX_PATH so the full path is not
hardcoded


def setup(template, version=None):
    temple.check.is_git_ssh_path(template)
    temple.check.not_in_git_repo()
    repo_path = temple.utils.get_repo_path(template)
    msg = 'You will be prompted for the parameters of your new project. Please read the docs at https:
    print(msg)
    (cc_repo_dir, config) = temple.utils.get_cookiecutter_config(template, version=version)
    if (not version):
        with temple.utils.cd(cc_repo_dir):
            ret = temple.utils.shell('git rev-parse HEAD', stdout=subprocess.PIPE)
            version = ret.stdout.decode('utf-8').strip()
    _generate_files(repo_dir=cc_repo_dir, config=config, template=template, version=version)

Sets up a new project from a template

Note that the `temple.constants.TEMPLE_ENV_VAR` is set to 'setup' during the duration
of this function.

Args:
template (str): The git SSH path to a template
version (str, optional): The version of the template to use when updating. Defaults
to the latest version


def create_bird_config_files(bird_configuration):

    for ip_version in bird_configuration:

        config_file = bird_configuration[ip_version]['config_file']
        try:
            touch(config_file)
        except OSError as exc:
            raise ValueError("failed to create {f}:{e}"
                             .format(f=config_file, e=exc))
        if bird_configuration[ip_version]['keep_changes']:
            history_dir = os.path.join(os.path.dirname(config_file), 'history')
            try:
                os.mkdir(history_dir)
            except FileExistsError:
                pass
            except OSError as exc:
                raise ValueError("failed to make directory {d} for keeping a "
                                 "history of changes for {b}:{e}"
                                 .format(d=history_dir, b=config_file, e=exc))
            else:
                print("{d} is created".format(d=history_dir))

Create bird configuration files per IP version.

Creates bird configuration files if they don't exist. It also creates the
directories where we store the history of changes, if this functionality is
enabled.

Arguments:
bird_configuration (dict): A dictionary with settings for bird.

Returns:
None

Raises:
ValueError if we can't create bird configuration files and the
directory to store the history of changes in bird configuration file.


def get_videos_for_course(course_id, sort_field=None, sort_dir=SortDirection.asc, pagination_conf=None):

    return _get_videos_for_filter(
        {'courses__course_id': six.text_type(course_id), 'courses__is_hidden': False},
        sort_field,
        sort_dir,
        pagination_conf,
    )

Returns an iterator of videos for the given course id.

Args:
course_id (String)
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 call(self, inputs, state):
    original_shape = inputs.shape
    if (len(original_shape) < 2):
        inputs = tf.reshape(inputs, [1, (- 1)])
    (out, state) = self.lstm_cell(inputs, state)
    out = self.output_layer(out)
    correct_shape = tf.concat((original_shape[:(- 1)], tf.shape(input=out)[(- 1):]), 0)
    out = tf.reshape(out, correct_shape)
    loc = out[(..., :self.dimensions)]
    scale_diag = (tf.nn.softplus(out[(..., self.dimensions:)]) + 1e-05)
    return (tfd.MultivariateNormalDiag(loc=loc, scale_diag=scale_diag), state)

Runs the model to generate a distribution for a single timestep.

This generates a batched MultivariateNormalDiag distribution using
the output of the recurrent model at the current timestep to
parameterize the distribution.

Args:
inputs: The sampled value of `z` at the previous timestep, i.e.,
`z_{t-1}`, of shape [..., dimensions].
`z_0` should be set to the empty matrix.
state: A tuple containing the (hidden, cell) state.

Returns:
A tuple of a MultivariateNormalDiag distribution, and the state of
the recurrent function at the end of the current timestep. The
distribution will have event shape [dimensions], batch shape
[...], and sample shape [sample_shape, ..., dimensions].


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

        if not all([isinstance(r, Row) for r in rows]):
            raise TypeError('All elements of Grid must be Row instances')
        self.type = 'grid'
        self.rows = rows

Init method.

Args:
*rows (): the instances of Row.
**kwargs (): not used.


def get(self, url, params={}, headers={}, auth=(), certificate_path=None):
    certificate_path = (certificate_path if certificate_path else False)
    return self.session.get(url, params=params, headers=headers, verify=certificate_path, auth=auth, timeout=self.timeout)

Returns the response payload from the request to the given URL.

Args:
url (str): The URL for the WEB API that the request is being made too.
params (dict): Dictionary containing the query string parameters.
headers (dict): HTTP Headers that may be needed for the request.
auth (tuple): User ID and password for Basic Auth
certificate_path (str): Path to the ssl certificate.

Returns:
response: (HttpResponse): Response object from requests.get api request


def from_csv(input_csv, headers=None, schema_file=None):
    if (headers is not None):
        names = headers
    elif (schema_file is not None):
        with _util.open_local_or_gcs(schema_file, mode='r') as f:
            schema = json.load(f)
        names = [x['name'] for x in schema]
    else:
        raise ValueError('Either headers or schema_file is needed')
    all_files = _util.glob_files(input_csv)
    all_df = []
    for file_name in all_files:
        with _util.open_local_or_gcs(file_name, mode='r') as f:
            all_df.append(pd.read_csv(f, names=names))
    df = pd.concat(all_df, ignore_index=True)
    if (('target' not in df) or ('predicted' not in df)):
        raise ValueError('Cannot find "target" or "predicted" column')
    labels = sorted((set(df['target']) | set(df['predicted'])))
    cm = confusion_matrix(df['target'], df['predicted'], labels=labels)
    return ConfusionMatrix(cm, labels)

Create a ConfusionMatrix from a csv file.

Args:
input_csv: Path to a Csv file (with no header). Can be local or GCS path.
headers: Csv headers. If present, it must include 'target' and 'predicted'.
schema_file: Path to a JSON file containing BigQuery schema. Used if "headers" is None.
If present, it must include 'target' and 'predicted' columns.
Returns:
A ConfusionMatrix that can be plotted.
Raises:
ValueError if both headers and schema_file are None, or it does not include 'target'
or 'predicted' columns.


def create_ingress_rule(self, app, rule):
    if isinstance(rule, dict):
        start_port = rule.get('start_port')
        end_port = rule.get('end_port')
        protocol = rule.get('protocol', 'tcp')
        requested_cross_account = rule.get('env', self.env)
        if (self.env == requested_cross_account):
            cross_account_env = None
            cross_account_vpc_id = None
        else:
            cross_account_env = requested_cross_account
            cross_account_vpc_id = get_vpc_id(cross_account_env, self.region)
    else:
        start_port = rule
        end_port = rule
        protocol = 'tcp'
        cross_account_env = None
        cross_account_vpc_id = None
    created_rule = {'app': app, 'start_port': start_port, 'end_port': end_port, 'protocol': protocol, 'cross_account_env': cross_account_env, 'cross_account_vpc_id': cross_account_vpc_id}
    self.log.debug('Normalized ingress rule: %s', created_rule)
    return created_rule

Create a normalized ingress rule.

Args:
app (str): Application name
rule (dict or int): Allowed Security Group ports and protocols.

Returns:
dict: Contains app, start_port, end_port, protocol, cross_account_env and cross_account_vpc_id


def GetUsername(self, event, default_username='-'):
    username = getattr(event, 'username', None)
    if (username and (username != '-')):
        return username
    session_identifier = event.GetSessionIdentifier()
    if (session_identifier is None):
        return default_username
    user_sid = getattr(event, 'user_sid', None)
    username = self._knowledge_base.GetUsernameByIdentifier(user_sid, session_identifier=session_identifier)
    return (username or default_username)

Retrieves the username related to the event.

Args:
event (EventObject): event.
default_username (Optional[str]): default username.

Returns:
str: username.


def GetScripts(self, dest_dir):

    metadata_dict = self.watcher.GetMetadata() or {}

    try:
      instance_data = metadata_dict['instance']['attributes']
    except KeyError:
      instance_data = None
      self.logger.warning('Instance attributes were not found.')

    try:
      project_data = metadata_dict['project']['attributes']
    except KeyError:
      project_data = None
      self.logger.warning('Project attributes were not found.')

    return (self._GetAttributeScripts(instance_data, dest_dir)
            or self._GetAttributeScripts(project_data, dest_dir))

Retrieve the scripts to execute.

Args:
dest_dir: string, the path to a directory for storing metadata scripts.

Returns:
dict, a dictionary mapping set metadata keys with associated scripts.


def _build(self, inputs):
    if nest.is_sequence(inputs):
        merged_tensors = [self._merge(tensor) for tensor in nest.flatten(inputs)]
        return nest.pack_sequence_as(inputs, merged_tensors)
    return self._merge(inputs)

Connects the MergeDims module into the graph.

Args:
inputs: Tensor or a nested list of Tensors to merge. Its rank must be
greater than or equal to `start` + `size`.

Returns:
The merged Tensor or a nested list of merged Tensors.

Raises:
ValueError: If any of the `inputs` tensors has insufficient rank.


def __init__(self, asynchronous_correlation_value=None):

        super(PollRequestPayload, self).__init__(
            enums.Tags.REQUEST_PAYLOAD
        )

        self._asynchronous_correlation_value = None
        self.asynchronous_correlation_value = asynchronous_correlation_value

Construct a Poll request payload struct.

Args:
asynchronous_correlation_value (bytes): The ID of a pending
operation to poll the status of, in bytes. Optional, defaults
to None.


def unpackVersion(ver):
    major = ((ver >> (20 * 2)) & mask20)
    minor = ((ver >> 20) & mask20)
    patch = (ver & mask20)
    return (major, minor, patch)

Unpack a system normalized integer representing a softare version into its component parts.

Args:
ver (int): System normalized integer value to unpack into a tuple.

Returns:
(int, int, int): A tuple containing the major, minor and patch values shifted out of the integer.


def __init__(self, cache_folder, genome_build):

        self.cache = EnsemblCache(cache_folder, genome_build)

        self.prior_time = time.time() - 1
        self.rate_limit = 0.067

        server_dict = {"grch37": "grch37.", "grch38": ""}

        self.server = "http:

        self.check_ensembl_api_version()

obtain the sequence for a transcript from ensembl

Args:
cache_folder: path to folder for caching data requested from Ensembl
genome_build: string indicating the genome build ("grch37" or "grch38")


def parse_cytoband(lines):

    cytobands = {}
    for line in lines:
        line = line.rstrip()
        splitted_line = line.split('\t')
        chrom = splitted_line[0].lstrip('chr')
        start = int(splitted_line[1])
        stop = int(splitted_line[2])
        name = splitted_line[3]
        if chrom in cytobands:

            cytobands[chrom][start:stop] = name
        else:

            new_tree = intervaltree.IntervalTree()

            new_tree[start:stop] = name

            cytobands[chrom] = new_tree

    return cytobands

Parse iterable with cytoband coordinates

Args:
lines(iterable): Strings on format "chr1\t2300000\t5400000\tp36.32\tgpos25"

Returns:
cytobands(dict): Dictionary with chromosome names as keys and
interval trees as values


def check_phonefy(self, query, kwargs={}):

        data = self.launchQueryForMode(query=query, mode="phonefy")
        if self._somethingFound(data, mode="phonefy"):
            return data
        return None

Verifying a mailfy query in this platform.

This might be redefined in any class inheriting from Platform. The only
condition is that any of this should return a dictionary as defined.

Args:
-----
query: The element to be searched.
kwargs: Dictionary with extra parameters. Just in case.

Return:
-------
Returns the collected data if exists or None if not.


def _VerifyValues(self, image, kernel, strides, rates, padding, out, use_gpu):
    strides = [1] + strides + [1]
    rates = [1] + rates + [1]
    with self.cached_session(use_gpu=use_gpu):
        out_tensor = nn_ops.erosion2d(constant_op.constant(image), constant_op.constant(kernel), strides=strides, rates=rates, padding=padding, name='erosion2d')
        self.assertAllClose(out, self.evaluate(out_tensor))

Verifies the output values of the erosion function.

Args:
image: Input tensor with shape: [batch, in_height, in_width, channels].
kernel: Filter tensor with shape: [filter_height, filter_width, channels].
strides: Output strides, specified as [stride_height, stride_width].
rates: Atrous rates, specified as [rate_height, rate_width].
padding: Padding type.
out: Expected output.
use_gpu: Whether we are running on GPU.


def export_as_file(self, file_path, cv_source):

        if os.path.exists(file_path):
            raise exceptions.UserError('{} already exists'.format(file_path))

        with open(file_path, 'wb') as f:
            f.write(self.export_as_code(cv_source).encode('utf8'))

Export the ensemble as a single Python file and saves it to `file_path`.

This is EXPERIMENTAL as putting different modules together would probably wreak havoc
especially on modules that make heavy use of global variables.

Args:
file_path (str, unicode): Absolute/local path of place to save file in

cv_source (str, unicode): String containing actual code for base learner
cross-validation used to generate secondary meta-features.


def iter_package_families(paths=None):
    for path in (paths or config.packages_path):
        repo = package_repository_manager.get_repository(path)
        for resource in repo.iter_package_families():
            (yield PackageFamily(resource))

Iterate over package families, in no particular order.

Note that multiple package families with the same name can be returned.
Unlike packages, families later in the searchpath are not hidden by earlier
families.

Args:
paths (list of str, optional): paths to search for package families,
defaults to `config.packages_path`.

Returns:
`PackageFamily` iterator.


def add_table(self, table):

        import astropy

        table_array = table.__array__()
        self.table_keys= table.keys()
        table_columns= []
        for i in range(0,len(table.columns[0])):
            row_data = []

            for item in table_array[i]:
                if isinstance(item, bytes):
                    row_data.append(item.decode('utf-8'))
                else:
                    row_data.append(item)
            table_columns.append(row_data)

        self.table_columns = table_columns
        self.table_flag= not self.table_flag

load a VOTable -already accessible on the python side- into the widget
Args:
table: votable object


def generate(self, model_len=None, model_width=None):

        if model_len is None:
            model_len = Constant.MODEL_LEN
        if model_width is None:
            model_width = Constant.MODEL_WIDTH
        if isinstance(model_width, list) and not len(model_width) == model_len:
            raise ValueError("The length of 'model_width' does not match 'model_len'")
        elif isinstance(model_width, int):
            model_width = [model_width] * model_len

        graph = Graph(self.input_shape, False)
        output_node_id = 0
        n_nodes_prev_layer = self.input_shape[0]
        for width in model_width:
            output_node_id = graph.add_layer(
                StubDense(n_nodes_prev_layer, width), output_node_id
            )
            output_node_id = graph.add_layer(
                StubDropout1d(Constant.MLP_DROPOUT_RATE), output_node_id
            )
            output_node_id = graph.add_layer(StubReLU(), output_node_id)
            n_nodes_prev_layer = width

        graph.add_layer(StubDense(n_nodes_prev_layer, self.n_output_node), output_node_id)
        return graph

Generates a Multi-Layer Perceptron.
Args:
model_len: An integer. Number of hidden layers.
model_width: An integer or a list of integers of length `model_len`. If it is a list, it represents the
number of nodes in each hidden layer. If it is an integer, all hidden layers have nodes equal to this
value.
Returns:
An instance of the class Graph. Represents the neural architecture graph of the generated model.


def delete_course_completion(self, user_id, payload):
    return self._delete(urljoin(self.enterprise_configuration.degreed_base_url, self.global_degreed_config.completion_status_api_path), payload, self.COMPLETION_PROVIDER_SCOPE)

Delete a completion status previously sent to the Degreed Completion Status endpoint

Args:
user_id: Unused.
payload: JSON encoded object (serialized from DegreedLearnerDataTransmissionAudit)
containing the required completion status fields for deletion per Degreed documentation.

Returns:
A tuple containing the status code and the body of the response.
Raises:
HTTPError: if we received a failure response code from Degreed


def _list_all_concrete_functions_for_serialization(self):
    seen_signatures = []
    if self.input_signature is not None:
        seen_signatures.append((self.input_signature, {}))
    else:
        concrete_functions = self._list_all_concrete_functions()
        for concrete_function in concrete_functions:
            signature = concrete_function.structured_input_signature
            flattened = nest.flatten(signature)
            if any((isinstance(arg, func_graph_module.UnknownArgument) for arg in flattened)):
                logging.info('Unsupported signature for serialization: %s.', signature)
                continue
            equal_to_signature = functools.partial(function_type_utils.is_same_structure, signature, check_values=True)
            if not any((equal_to_signature(s) for s in seen_signatures)):
                seen_signatures.append(signature)
    concrete_functions = []
    for args, kwargs in seen_signatures:
        concrete_functions.append(self.get_concrete_function(*args, **kwargs))
    return concrete_functions

Returns all concrete functions for serialization.

Returns:
A list of instances of `ConcreteFunction`.


def whoami(self) -> dict:

        if not self.access_token:
            return {}
        self._try_refresh_access_token()
        return self.session.get(self.WHOAMI_URL).json()

Returns the basic information about the authenticated character.

Obviously doesn't do anything if this Preston instance is not
authenticated, so it returns an empty dict.

Args:
None

Returns:
character info if authenticated, otherwise an empty dict


def clean(self, force: bool=False):

        with (yield from self._lock):
            for connection in tuple(self.ready):
                if force or connection.closed():
                    connection.close()
                    self.ready.remove(connection)

Clean closed connections.

Args:
force: Clean connected and idle connections too.

Coroutine.


def markdown_to_safe_html(markdown_string):
    warning = ''
    if isinstance(markdown_string, six.binary_type):
        markdown_string_decoded = markdown_string.decode('utf-8')
        markdown_string = markdown_string_decoded.replace(u'\x00', u'')
        num_null_bytes = (len(markdown_string_decoded) - len(markdown_string))
        if num_null_bytes:
            warning = ('<!-- WARNING: discarded %d null bytes in markdown string after UTF-8 decoding -->\n' % num_null_bytes)
    string_html = markdown.markdown(markdown_string, extensions=['markdown.extensions.tables'])
    string_sanitized = bleach.clean(string_html, tags=_ALLOWED_TAGS, attributes=_ALLOWED_ATTRIBUTES)
    return (warning + string_sanitized)

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

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

Returns:
A string containing safe HTML.


def __intervals_from_tops(self,
                              tops,
                              values,
                              basis,
                              components,
                              field=None,
                              ignore_nan=True):

        length = float(basis.size)
        start, stop = basis[0], basis[-1]
        tops = [start + (p/(length-1)) * (stop-start) for p in tops]
        bases = tops[1:] + [stop]

        list_of_Intervals = []
        for i, t in enumerate(tops):

            v, c, d = values[i], [], {}

            if ignore_nan and np.isnan(v):
                continue

            if (field is not None):
                d = {field: v}

            if components is not None:
                try:
                    c = [deepcopy(components[int(v)])]
                except IndexError:
                    c = []

                if c and (c[0] is None):
                    c = []

            interval = Interval(t, bases[i], data=d, components=c)
            list_of_Intervals.append(interval)

        return list_of_Intervals

Private method. Take a sequence of tops in an arbitrary dimension,
and provide a list of intervals from which a striplog can be made.

This is only intended to be used by ``from_image()``.

Args:
tops (iterable). A list of floats.
values (iterable). A list of values to look up.
basis (iterable). A list of components.
components (iterable). A list of Components.

Returns:
List. A list of Intervals.


def __str__(self):

        name = self.__class__.__name__
        return '%s(Handle %d, Address %d)' % (name, self.Handle, self.Addr)

Returns a formatted string describing the breakpoint.

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

Returns:
Stirng representation of the breakpoint.


def put(self, rid, data, raise_on_error=True):

        response_data = None
        headers = {'Content-Type': 'application/json', 'DB-Method': 'PUT'}
        url = '/v2/exchange/db/{}/{}/{}'.format(self.domain, self.data_type, rid)
        r = self.tcex.session.post(url, json=data, headers=headers)
        self.tcex.log.debug('datastore put status code: {}'.format(r.status_code))
        if r.ok and 'application/json' in r.headers.get('content-type', ''):
            response_data = r.json()
        else:
            error = r.text or r.reason
            self.tcex.handle_error(805, ['put', r.status_code, error], raise_on_error)
        return response_data

Update the data for the provided Id.

Args:
rid (str): The record identifier.
data (dict): A search query
raise_on_error (bool): If True and not r.ok this method will raise a RunTimeError.

Returns:
object : Python request response.


def sunrise(self, date=None, zenith=None):
    return (segment.sunrise(date, zenith) for segment in self)

Calculate sunrise times for locations.

Args:
date (datetime.date): Calculate rise or set for given date
zenith (str): Calculate sunrise events, or end of twilight
Returns:
list of list of datetime.datetime: The time for the sunrise for
each point in each segment


def clean_df(df, header=None, **read_csv_kwargs):

    df = read_csv(df, header=header, **read_csv_kwargs)
    df = df.fillna(' ')
    for col in df.columns:
        df[col] = df[col].apply(unicode2ascii)
    return df

Convert UTF8 characters in a CSV file or dataframe into ASCII

Args:
df (DataFrame or str): DataFrame or path or url to CSV


def register_handler(self, handler, event_name, args):
    if self.started:
        raise IllegalStateError("Can't register service after polling is started")
    self.lock.acquire()
    try:
        if (event_name in self.handlers):
            raise DuplicateError('A handler for {} already exists'.format(event_name))
        self.handlers[event_name] = (handler, args)
    finally:
        self.lock.release()

Registers an event handler.

One type of event can only have one event handler associated with it.

Args:
handler: The event handler function to be registered.
event_name: Name of the event the handler is for.
args: User arguments to be passed to the handler when it's called.

Raises:
IllegalStateError: Raised if attempts to register a handler after
the dispatcher starts running.
DuplicateError: Raised if attempts to register more than one
handler for one type of event.


def change_extension(self, filepath, new_extension):
    (filename, ext) = os.path.splitext(filepath)
    return '.'.join([filename, new_extension])

Change final filename extension.

Args:
filepath (str): A file path (relative or absolute).
new_extension (str): New extension name (without leading dot) to
apply.

Returns:
str: Filepath with new extension.


def from_json(data):

        memfiles = InMemoryFiles()
        memfiles.files = json.loads(data)
        return memfiles

Convert JSON into a in memory file storage.

Args:
data (str): valid JSON with path and filenames and
the base64 encoding of the file content.

Returns:
InMemoryFiles: in memory file storage


def write(self, name, **data):
    data['name'] = name
    if (not ('timestamp' in data)):
        data['timestamp'] = datetime.utcnow()
    try:
        self.producer.send(topic=self.topic, value=data)
        self.producer.flush()
    except (KafkaTimeoutError, NoBrokersAvailable) as exc:
        logger.warning('writing metric %r failure %r', data, exc)

Write the metric to kafka

Args:
name (str): The name of the metric to write
data (dict): Additional data to store with the metric


def tap(self, locator, x_offset=None, y_offset=None, count=1):

        driver = self._current_application()
        el = self._element_find(locator, True, True)
        action = TouchAction(driver)
        action.tap(el,x_offset,y_offset, count).perform()

Tap element identified by ``locator``.

Args:
- ``x_offset`` - (optional) x coordinate to tap, relative to the top left corner of the element.
- ``y_offset`` - (optional) y coordinate. If y is used, x must also be set, and vice versa
- ``count`` - can be used for multiple times of tap on that element


def subscribe_registration_ids_to_topic(self, registration_ids, topic_name):
    url = 'https:
    payload = {'to': ('/topics/' + topic_name), 'registration_tokens': registration_ids}
    response = self.requests_session.post(url, json=payload)
    if (response.status_code == 200):
        return True
    elif (response.status_code == 400):
        error = response.json()
        raise InvalidDataError(error['error'])
    else:
        raise FCMError()

Subscribes a list of registration ids to a topic

Args:
registration_ids (list): ids to be subscribed
topic_name (str): name of topic

Returns:
True: if operation succeeded

Raises:
InvalidDataError: data sent to server was incorrectly formatted
FCMError: an error occured on the server


def to_dataframe(self, start_row=0, max_rows=None):

    fetcher = self._get_row_fetcher(start_row=start_row, max_rows=max_rows)
    count = 0
    page_token = None
    df = None
    while True:
      page_rows, page_token = fetcher(page_token, count)
      if len(page_rows):
        count += len(page_rows)
        if df is None:
          df = pandas.DataFrame.from_records(page_rows)
        else:
          df = df.append(page_rows, ignore_index=True)
      if not page_token:
        break

    ordered_fields = [field.name for field in self.schema]
    return df[ordered_fields] if df is not None else pandas.DataFrame()

Exports the table to a Pandas dataframe.

Args:
start_row: the row of the table at which to start the export (default 0)
max_rows: an upper limit on the number of rows to export (default None)
Returns:
A Pandas dataframe containing the table data.


def is_value_type_valid_for_exact_conditions(self, value):
    if (isinstance(value, string_types) or isinstance(value, (numbers.Integral, float))):
        return True
    return False

Method to validate if the value is valid for exact match type evaluation.

Args:
value: Value to validate.

Returns:
Boolean: True if value is a string, boolean, or number. Otherwise False.


def get_end_time_metric(result: PipelineResult, namespace: str, name: str) -> int:
    distributions = result.metrics().query(MetricsFilter().with_namespace(namespace).with_name(name))['distributions']
    max_list = list(map(lambda m: m.result.max, distributions))
    return max(max_list) if len(max_list) > 0 else -1

get the end time out of all times recorded by the specified distribution
metric

Args:
result: the PipelineResult which metrics are read from
namespace: a string representing the namespace of wanted metric
name: a string representing the  name of the wanted metric

Returns:
the largest time in the metric or -1 if it doesn't exist


def as_tuning_range(self, name):

        return {'Name': name,
                'MinValue': to_str(self.min_value),
                'MaxValue': to_str(self.max_value),
                'ScalingType': self.scaling_type}

Represent the parameter range as a dicionary suitable for a request to
create an Amazon SageMaker hyperparameter tuning job.

Args:
name (str): The name of the hyperparameter.

Returns:
dict[str, str]: A dictionary that contains the name and values of the hyperparameter.


def clean_channel_worker_username(self):
    channel_worker_username = self.cleaned_data['channel_worker_username'].strip()
    try:
        User.objects.get(username=channel_worker_username)
    except User.DoesNotExist:
        raise ValidationError(ValidationMessages.INVALID_CHANNEL_WORKER.format(channel_worker_username=channel_worker_username))
    return channel_worker_username

Clean enterprise channel worker user form field

Returns:
str: the cleaned value of channel user username for transmitting courses metadata.


def _build_trial_meta(cls, expr_dir):

        meta_file = os.path.join(expr_dir, EXPR_META_FILE)
        meta = parse_json(meta_file)

        if not meta:
            job_id = expr_dir.split("/")[-2]
            trial_id = expr_dir[-8:]
            params = parse_json(os.path.join(expr_dir, EXPR_PARARM_FILE))
            meta = {
                "trial_id": trial_id,
                "job_id": job_id,
                "status": "RUNNING",
                "type": "TUNE",
                "start_time": os.path.getctime(expr_dir),
                "end_time": None,
                "progress_offset": 0,
                "result_offset": 0,
                "params": params
            }

        if not meta.get("start_time", None):
            meta["start_time"] = os.path.getctime(expr_dir)

        if isinstance(meta["start_time"], float):
            meta["start_time"] = timestamp2date(meta["start_time"])

        if meta.get("end_time", None):
            meta["end_time"] = timestamp2date(meta["end_time"])

        meta["params"] = parse_json(os.path.join(expr_dir, EXPR_PARARM_FILE))

        return meta

Build meta file for trial.

Args:
expr_dir (str): Directory path of the experiment.

Return:
A dict of trial meta info.


def parse_expression(src):
    src = STANDARD_PREAMBLE + src.strip()
    node = parse(src, preamble_len=STANDARD_PREAMBLE_LEN, single_node=True)
    if __debug__:
        if not isinstance(node, gast.Expr):
            raise ValueError('expected exactly one node of type Expr, got {}'.format(node))
    return node.value

Returns the AST of given identifier.

Args:
src: A piece of code that represents a single Python expression
Returns:
A gast.AST object.
Raises:
ValueError: if src does not consist of a single Expression.


def transpose(vari):

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

    return numpy.transpose(vari)

Transpose a shapeable quantety.

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

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

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


def read_nose(in_file):
    suites = {}
    doc_xml = minidom.parse(in_file)
    suite_xml = doc_xml.getElementsByTagName('testsuite')[0]
    for case_xml in suite_xml.getElementsByTagName('testcase'):
        classname = case_xml.getAttribute('classname')
        if (classname not in suites):
            suites[classname] = []
        case = {'name': case_xml.getAttribute('name'), 'time': float(case_xml.getAttribute('time'))}
        skipped_xml = case_xml.getElementsByTagName('skipped')
        if skipped_xml:
            if skipped_xml[0].hasAttribute('type'):
                type = skipped_xml[0].getAttribute('type')
            else:
                type = ''
            case['skipped'] = {'type': type, 'message': skipped_xml[0].getAttribute('message'), 'text': ''.join([child.nodeValue for child in skipped_xml[0].childNodes])}
        failure_xml = case_xml.getElementsByTagName('failure')
        if failure_xml:
            if failure_xml[0].hasAttribute('type'):
                type = failure_xml[0].getAttribute('type')
            else:
                type = ''
            case['failure'] = {'type': type, 'message': failure_xml[0].getAttribute('message'), 'text': ''.join([child.nodeValue for child in failure_xml[0].childNodes])}
        error_xml = case_xml.getElementsByTagName('error')
        if error_xml:
            if error_xml[0].hasAttribute('type'):
                type = error_xml[0].getAttribute('type')
            else:
                type = ''
            case['error'] = {'type': type, 'message': error_xml[0].getAttribute('message'), 'text': ''.join([child.nodeValue for child in error_xml[0].childNodes])}
        suites[classname].append(case)
    return suites

Parse nose-style test reports into a `dict`

Args:
in_file (:obj:`str`): path to nose-style test report

Returns:
:obj:`dict`: dictionary of test suites


def add(self, index):
    if ((index - self.flush_at) < self.interval):
        return
    now = time.time()
    elapsed = (now - self.lap)
    elapsed_total = (now - self.start)
    it = (index - self.flush_at)
    self.lap = now
    if self.verbose:
        logger.info('iter={} {{{}}}={}[sec/{}iter] {}[sec]'.format(index, self.name, elapsed, it, elapsed_total))
    if (self.fd is not None):
        print('{} {} {} {}'.format(index, elapsed, it, elapsed_total), file=self.fd)
    self.flush_at = index

Calculate time elapsed from the point previously called
this method or this object is created to this is called.

Args:
index (int): Index to be displayed, and be used to take intervals.


def _convert_and_export_metrics(self, convert_func, *args, **kwargs):
    self._increase_conversion_attempt_metric()
    self._save_conversion_params_metric()
    start_time = time.process_time()
    result = convert_func(self, *args, **kwargs)
    elapsed_time_ms = (time.process_time() - start_time) * 1000
    if result:
        self._increase_conversion_success_metric()
    self._set_conversion_latency_metric(round(elapsed_time_ms))
    self._tflite_metrics.export_metrics()
    if self.exclude_conversion_metadata or self._experimental_use_buffer_offset:
        return result
    model_object = flatbuffer_utils.convert_bytearray_to_object(result)
    if _check_model_use_buffer_offset(model_object):
        return result
    sparsity_modes = _get_sparsity_modes(model_object)
    model_hash = _get_model_hash(model_object)
    self._metadata.options.modelOptimizationModes.extend(sparsity_modes)
    self._metadata.environment.modelHash = model_hash
    model_object = _populate_conversion_metadata(model_object, self._metadata)
    return flatbuffer_utils.convert_object_to_bytearray(model_object)

Wraps around convert function to export metrics.

Args:
convert_func: The convert function to wrap.
*args: Positional arguments of the convert function.
**kwargs: The keyword arguments of the convert function.

Returns:
The decorator to wrap the convert function.


def values(self, *args):

        return [dict(zip(args, values_list))
                for values_list in self.values_list(flatten=False, *args)]

Returns list of dicts (field names as keys) for given fields.

Args:
\*args: List of fields to be returned as dict.

Returns:
list of dicts for given fields.

Example:
>>> Person.objects.filter(age__gte=16, name__startswith='jo').values('name', 'lastname')


def _get_path_for_op_id(self, id: str) -> Optional[str]:

        for path_key, path_value in self._get_spec()['paths'].items():
            for method in self.METHODS:
                if method in path_value:
                    if self.OPERATION_ID_KEY in path_value[method]:
                        if path_value[method][self.OPERATION_ID_KEY] == id:
                            return path_key
        return None

Searches the spec for a path matching the operation id.

Args:
id: operation id

Returns:
path to the endpoint, or None if not found


def guid(valu=None):

    if valu is None:
        return binascii.hexlify(os.urandom(16)).decode('utf8')

    byts = s_msgpack.en(valu)
    return hashlib.md5(byts).hexdigest()

Get a 16 byte guid value.

By default, this is a random guid value.

Args:
valu: Object used to construct the guid valu from.  This must be able
to be msgpack'd.

Returns:
str: 32 character, lowercase ascii string.


def get_preprocessor(model_name: str) -> Optional[Union['AutoTokenizer', 'AutoFeatureExtractor', 'AutoProcessor']]:
    from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer
    try:
        return AutoProcessor.from_pretrained(model_name)
    except (ValueError, OSError, KeyError):
        tokenizer, feature_extractor = (None, None)
        try:
            tokenizer = AutoTokenizer.from_pretrained(model_name)
        except (OSError, KeyError):
            pass
        try:
            feature_extractor = AutoFeatureExtractor.from_pretrained(model_name)
        except (OSError, KeyError):
            pass
        if tokenizer is not None and feature_extractor is not None:
            raise ValueError(f"Couldn't auto-detect preprocessor for {model_name}. Found both a tokenizer and a feature extractor.")
        elif tokenizer is None and feature_extractor is None:
            return None
        elif tokenizer is not None:
            return tokenizer
        else:
            return feature_extractor

Gets a preprocessor (tokenizer, feature extractor or processor) that is available for `model_name`.

Args:
model_name (`str`): Name of the model for which a preprocessor are loaded.

Returns:
`Optional[Union[AutoTokenizer, AutoFeatureExtractor, AutoProcessor]]`:
If a processor is found, it is returned. Otherwise, if a tokenizer or a feature extractor exists, it is
returned. If both a tokenizer and a feature extractor exist, an error is raised. The function returns
`None` if no preprocessor is found.


def _maybe_repeat(self, x):

    if isinstance(x, list):
      assert len(x) == self.n
      return x
    else:
      return [x] * self.n

Utility function for processing arguments that are singletons or lists.

Args:
x: either a list of self.n elements, or not a list.

Returns:
a list of self.n elements.


def __set_unkown_effect(self, hgvs_string):

        unknown_effect_list = ['?', '(=)', '=']
        if hgvs_string in unknown_effect_list:
            self.unknown_effect = True
        elif "(" in hgvs_string:

            self.unknown_effect = True
        else:
            self.unknown_effect = False

        if "?" in hgvs_string:
            self.is_missing_info = True
        else:
            self.is_missing_info = False

Sets a flag for unkown effect according to HGVS syntax. The
COSMIC database also uses unconventional questionmarks to denote
missing information.

Args:
hgvs_string (str): hgvs syntax with "p." removed


def CreateKey(self, private_key=None):
    if (private_key is None):
        private_key = bytes(Random.get_random_bytes(32))
    key = KeyPair(priv_key=private_key)
    self._keys[key.PublicKeyHash.ToBytes()] = key
    return key

Create a KeyPair

Args:
private_key (iterable_of_ints): (optional) 32 byte private key

Returns:
KeyPair: a KeyPair instance


def transform_tensor(self, tensor):

        dim = tensor.shape
        rank = len(dim)
        assert all([i == 3 for i in dim])

        lc = string.ascii_lowercase
        indices = lc[:rank], lc[rank:2 * rank]
        einsum_string = ','.join([a + i for a, i in zip(*indices)])
        einsum_string += ',{}->{}'.format(*indices[::-1])
        einsum_args = [self.rotation_matrix] * rank + [tensor]

        return np.einsum(einsum_string, *einsum_args)

Applies rotation portion to a tensor. Note that tensor has to be in
full form, not the Voigt form.

Args:
tensor (numpy array): a rank n tensor

Returns:
Transformed tensor.


def createResourceMapFromStream(in_stream, base_url=d1_common.const.URL_DATAONE_ROOT):
    pids = []
    for line in in_stream:
        pid = line.strip()
        if ((pid == '
            continue
    if (len(pids) < 2):
        raise ValueError('Insufficient numbers of identifiers provided.')
    logging.info('Read {} identifiers'.format(len(pids)))
    ore = ResourceMap(base_url=base_url)
    logging.info('ORE PID = {}'.format(pids[0]))
    ore.initialize(pids[0])
    logging.info('Metadata PID = {}'.format(pids[1]))
    ore.addMetadataDocument(pids[1])
    ore.addDataDocuments(pids[2:], pids[1])
    return ore

Create a simple OAI-ORE Resource Map with one Science Metadata document and any
number of Science Data objects, using a stream of PIDs.

Args:
in_stream:
The first non-blank line is the PID of the resource map itself. Second line is
the science metadata PID and remaining lines are science data PIDs.

Example stream contents:

::

PID_ORE_value
sci_meta_pid_value
data_pid_1
data_pid_2
data_pid_3

base_url : str
Root of the DataONE environment in which the Resource Map will be used.

Returns:
ResourceMap : OAI-ORE Resource Map


def from_rotation_and_translation_and_time_reversal(rotation_matrix=((1, 0, 0), (0, 1, 0), (0, 0, 1)), translation_vec=(0, 0, 0), time_reversal=1, tol=0.1):
    symmop = SymmOp.from_rotation_and_translation(rotation_matrix=rotation_matrix, translation_vec=translation_vec, tol=tol)
    return MagSymmOp.from_symmop(symmop, time_reversal)

Creates a symmetry operation from a rotation matrix, translation
vector and time reversal operator.

Args:
rotation_matrix (3x3 array): Rotation matrix.
translation_vec (3x1 array): Translation vector.
time_reversal (int): Time reversal operator, +1 or -1.
tol (float): Tolerance to determine if rotation matrix is valid.

Returns:
MagSymmOp object


def _ParsePropertiesXMLFile(self, xml_data):
    xml_root = ElementTree.fromstring(xml_data)
    properties = {}
    for xml_element in xml_root.iter():
        if (not xml_element.text):
            continue
        (_, _, name) = xml_element.tag.partition('}')
        if (name == 'lpstr'):
            continue
        property_name = self._PROPERTY_NAMES.get(name, None)
        if (not property_name):
            property_name = self._FormatPropertyName(name)
        properties[property_name] = xml_element.text
    return properties

Parses a properties XML file.

Args:
xml_data (bytes): data of a _rels/.rels XML file.

Returns:
dict[str, object]: properties.

Raises:
zipfile.BadZipfile: if the properties XML file cannot be read.


def __eq__(self, rhs):

    return (isinstance(rhs, MockMethod) and
            self._name == rhs._name and
            self._params == rhs._params and
            self._named_params == rhs._named_params)

Test whether this MockMethod is equivalent to another MockMethod.

Args:
# rhs: the right hand side of the test
rhs: MockMethod


def load_glossary(file_path: str, read_json=False) -> List[str]:
    if read_json:
        if file_path.endswith('.gz'):
            return json.load(gzip.open(file_path))
        return json.load(open(file_path))
    return open(file_path).read().splitlines()

A glossary is a text file, one entry per line.

Args:
file_path (str): path to a text file containing a glossary.
read_json (bool): set True if the glossary is in json format
Returns: List of the strings in the glossary.


def wait(fs, timeout=None, return_when=ALL_COMPLETED):
    with _AcquireFutures(fs):
        done = set((f for f in fs if (f._state in [CANCELLED_AND_NOTIFIED, FINISHED])))
        not_done = (set(fs) - done)
        if ((return_when == FIRST_COMPLETED) and done):
            return DoneAndNotDoneFutures(done, not_done)
        elif ((return_when == FIRST_EXCEPTION) and done):
            if any((f for f in done if ((not f.cancelled()) and (f.exception() is not None)))):
                return DoneAndNotDoneFutures(done, not_done)
        if (len(done) == len(fs)):
            return DoneAndNotDoneFutures(done, not_done)
        waiter = _create_and_install_waiters(fs, return_when)
    waiter.event.wait(timeout)
    for f in fs:
        with f._condition:
            f._waiters.remove(waiter)
    done.update(waiter.finished_futures)
    return DoneAndNotDoneFutures(done, (set(fs) - done))

Wait for the futures in the given sequence to complete.

Args:
fs: The sequence of Futures (possibly created by different Executors) to
wait upon.
timeout: The maximum number of seconds to wait. If None, then there
is no limit on the wait time.
return_when: Indicates when this function should return. The options
are:

FIRST_COMPLETED - Return when any future finishes or is
cancelled.
FIRST_EXCEPTION - Return when any future finishes by raising an
exception. If no future raises an exception
then it is equivalent to ALL_COMPLETED.
ALL_COMPLETED -   Return when all futures finish or are cancelled.

Returns:
A named 2-tuple of sets. The first set, named 'done', contains the
futures that completed (is finished or cancelled) before the wait
completed. The second set, named 'not_done', contains uncompleted
futures.


def ellipse_distance(item_a, time_a, item_b, time_b, max_value):
    ts = np.array([0, np.pi])
    ell_a = item_a.get_ellipse_model(time_a)
    ell_b = item_b.get_ellipse_model(time_b)
    ends_a = ell_a.predict_xy(ts)
    ends_b = ell_b.predict_xy(ts)
    distances = np.sqrt((((ends_a[(:, 0:1)] - ends_b[(:, 0:1)].T) ** 2) + ((ends_a[(:, 1:)] - ends_b[(:, 1:)].T) ** 2)))
    return (np.minimum(distances[(0, 1)], max_value) / float(max_value))

Calculate differences in the properties of ellipses fitted to each object.

Args:
item_a: STObject from the first set in ObjectMatcher
time_a: Time integer being evaluated
item_b: STObject from the second set in ObjectMatcher
time_b: Time integer being evaluated
max_value: Maximum distance value used as scaling value and upper constraint.

Returns:
Distance value between 0 and 1.


def get_subscribers(object_type: str) -> List[str]:
    return DB.get_list(_keys.subscribers(object_type))

Get the list of subscribers to events of the object type.

Args:
object_type (str): Type of object.

Returns:
List[str], list of subscriber names.


def expand_recurring(number, repeat=5):

    if "[" in number:
        pattern_index = number.index("[")
        pattern = number[pattern_index + 1:-1]
        number = number[:pattern_index]
        number = number + pattern * (repeat + 1)
    return number

Expands a recurring pattern within a number.

Args:
number(tuple): the number to process in the form:
(int, int, int, ... ".", ... , int int int)
repeat: the number of times to expand the pattern.

Returns:
The original number with recurring pattern expanded.

Example:
>>> expand_recurring((1, ".", 0, "[", 9, "]"), repeat=3)
(1, '.', 0, 9, 9, 9, 9)


def result_code(self, value):

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

The result_code property.

Args:
value (string). the property value.


def __init__(self, name, number, aliases=None, description=None):

    super(EnumerationValue, self).__init__()
    self.aliases = aliases or []
    self.description = description
    self.name = name
    self.number = number

Initializes an enumeration value.

Args:
name (str): name.
number (int): number.
aliases (Optional[list[str]]): aliases.
description (Optional[str]): description.


def __delitem__(self, obj, sync=True):

        if self._is_item:
            raise TypeError("This an item of the parent ListNode")
        list(self._generate_instances())
        _lnk_key = None
        if isinstance(obj, six.string_types):
            _lnk_key = obj
            _obj = self.node_dict[obj]
        elif not isinstance(obj, self.__class__):
            _lnk_key = obj.key
            _obj = self.node_dict[obj.key]
            del self.node_dict[obj.key]
        else:
            _obj = obj
        self.node_stack.remove(_obj)
        if _lnk_key and sync:

            rel_name = "%s.%s" % (_obj.__class__.__name__,
                                  _obj.get_link()['field'])
            remote_node_name = self._root_node.get_link(field=rel_name)['reverse']
            _lnk_obj = getattr(_obj, _obj.get_link()['field'])
            getattr(_lnk_obj, remote_node_name).__delitem__(self._root_node.key, sync=False)

            self._root_node.on_save.append(_lnk_obj.save)

Allow usage of "del" statement on ListNodes with bracket notation.

Args:
obj: ListNode item or relation key.

Raises:
TypeError: If it's called on a ListNode item (intstead of ListNode's itself)


def parse_rfc3339_utc_string(rfc3339_utc_string):
    m = re.match('(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2}).?(\\d*)Z', rfc3339_utc_string)
    if (not m):
        return None
    groups = m.groups()
    if (len(groups[6]) not in (0, 3, 6, 9)):
        return None
    g = [int(val) for val in groups[:6]]
    fraction = groups[6]
    if (not fraction):
        micros = 0
    elif (len(fraction) == 3):
        micros = (int(fraction) * 1000)
    elif (len(fraction) == 6):
        micros = int(fraction)
    elif (len(fraction) == 9):
        micros = int(round((int(fraction) / 1000)))
    else:
        assert False, 'Fraction length not 0, 6, or 9: {}'.len(fraction)
    try:
        return datetime(g[0], g[1], g[2], g[3], g[4], g[5], micros, tzinfo=pytz.utc)
    except ValueError as e:
        assert False, 'Could not parse RFC3339 datestring: {} exception: {}'.format(rfc3339_utc_string, e)

Converts a datestamp from RFC3339 UTC to a datetime.

Args:
rfc3339_utc_string: a datetime string in RFC3339 UTC "Zulu" format

Returns:
A datetime.


def output(self, filename):
    info = 'Inheritance\n'
    if (not self.contracts):
        return
    info += (blue('Child_Contract -> ') + green('Immediate_Base_Contracts'))
    info += green(' [Not_Immediate_Base_Contracts]')
    for child in self.contracts:
        info += blue(f)
        if child.inheritance:
            immediate = child.immediate_inheritance
            not_immediate = [i for i in child.inheritance if (i not in immediate)]
            info += (' -> ' + green(', '.join(map(str, immediate))))
            if not_immediate:
                info += ((', [' + green(', '.join(map(str, not_immediate)))) + ']')
    info += (green('\n\nBase_Contract -> ') + blue('Immediate_Child_Contracts'))
    info += blue(' [Not_Immediate_Child_Contracts]')
    for base in self.contracts:
        info += green(f)
        children = list(self._get_child_contracts(base))
        if children:
            immediate = [child for child in children if (base in child.immediate_inheritance)]
            not_immediate = [child for child in children if (not (child in immediate))]
            info += (' -> ' + blue(', '.join(map(str, immediate))))
            if not_immediate:
                info += ((', [' + blue(', '.join(map(str, not_immediate)))) + ']')
    self.info(info)

Output the inheritance relation

_filename is not used
Args:
_filename(string)


def build_sanitiser_node_dict(
    cfg,
    sinks_in_file
):

    sanitisers = list()
    for sink in sinks_in_file:
        sanitisers.extend(sink.sanitisers)

    sanitisers_in_file = list()
    for sanitiser in sanitisers:
        for cfg_node in cfg.nodes:
            if sanitiser in cfg_node.label:
                sanitisers_in_file.append(Sanitiser(sanitiser, cfg_node))

    sanitiser_node_dict = dict()
    for sanitiser in sanitisers:
        sanitiser_node_dict[sanitiser] = list(find_sanitiser_nodes(
            sanitiser,
            sanitisers_in_file
        ))
    return sanitiser_node_dict

Build a dict of string -> TriggerNode pairs, where the string
is the sanitiser and the TriggerNode is a TriggerNode of the sanitiser.

Args:
cfg(CFG): cfg to traverse.
sinks_in_file(list[TriggerNode]): list of TriggerNodes containing
the sinks in the file.

Returns:
A string -> TriggerNode dict.


def most_exposes(python_type):
    _exposes = set()
    try:
        do_not_expose = set((python_type.__dir__(object) + ['__slots__', '__module__', '__weakref__']))
        empty = python_type.__new__(python_type)
    except AttributeError:
        try:
            _exposes = python_type.__slots__
        except AttributeError:
            pass
    except TypeError:
        for _workaround in storable_workarounds:
            try:
                _exposes = _workaround(python_type)
            except (SystemExit, KeyboardInterrupt):
                raise
            except:
                pass
            else:
                break
    else:
        all_members = empty.__dir__()
        for attr in all_members:
            if (attr in do_not_expose):
                continue
            try:
                getattr(empty, attr)
            except AttributeError as e:
                if e.args:
                    msg = e.args[0]
                    if ((msg == attr) or msg.endswith("' object has no attribute '{}'".format(attr))):
                        _exposes.add(attr)
            except (SystemExit, KeyboardInterrupt):
                raise
            except:
                pass
        for attr in ('__dict__',):
            if (attr in all_members):
                _exposes.add(attr)
    return list(_exposes)

Core engine for the automatic generation of storable instances.

Finds the attributes exposed by the objects of a given type.

Mostly Python3-only.
Does not handle types which `__new__` method requires extra arguments either.

Arguments:

python_type (type): object type.

Returns:

list: attributes exposed.


def InspectZipFile(self, parser_mediator, zip_file):

    try:
      xml_data = zip_file.read('_rels/.rels')
      property_files = self._ParseRelationshipsXMLFile(xml_data)
    except (IndexError, IOError, KeyError, OverflowError, ValueError,
            zipfile.BadZipfile) as exception:
      parser_mediator.ProduceExtractionWarning((
          'Unable to parse relationships XML file: _rels/.rels with error: '
          '{0!s}').format(exception))
      return

    metadata = {}

    for path in property_files:
      try:
        xml_data = zip_file.read(path)
        properties = self._ParsePropertiesXMLFile(xml_data)
      except (IndexError, IOError, KeyError, OverflowError, ValueError,
              zipfile.BadZipfile) as exception:
        parser_mediator.ProduceExtractionWarning((
            'Unable to parse properties XML file: {0:s} with error: '
            '{1!s}').format(path, exception))
        continue

      metadata.update(properties)

    event_data = OpenXMLEventData()
    event_data.app_version = self._GetPropertyValue(
        parser_mediator, metadata, 'app_version')
    event_data.app_version = self._GetPropertyValue(
        parser_mediator, metadata, 'app_version')
    event_data.author = self._GetPropertyValue(
        parser_mediator, metadata, 'author')
    event_data.creating_app = self._GetPropertyValue(
        parser_mediator, metadata, 'creating_app')
    event_data.doc_security = self._GetPropertyValue(
        parser_mediator, metadata, 'doc_security')
    event_data.hyperlinks_changed = self._GetPropertyValue(
        parser_mediator, metadata, 'hyperlinks_changed')
    event_data.i4 = self._GetPropertyValue(
        parser_mediator, metadata, 'i4')
    event_data.last_saved_by = self._GetPropertyValue(
        parser_mediator, metadata, 'last_saved_by')
    event_data.links_up_to_date = self._GetPropertyValue(
        parser_mediator, metadata, 'links_up_to_date')
    event_data.number_of_characters = self._GetPropertyValue(
        parser_mediator, metadata, 'number_of_characters')
    event_data.number_of_characters_with_spaces = self._GetPropertyValue(
        parser_mediator, metadata, 'number_of_characters_with_spaces')
    event_data.number_of_lines = self._GetPropertyValue(
        parser_mediator, metadata, 'number_of_lines')
    event_data.number_of_pages = self._GetPropertyValue(
        parser_mediator, metadata, 'number_of_pages')
    event_data.number_of_paragraphs = self._GetPropertyValue(
        parser_mediator, metadata, 'number_of_paragraphs')
    event_data.number_of_words = self._GetPropertyValue(
        parser_mediator, metadata, 'number_of_words')
    event_data.revision_number = self._GetPropertyValue(
        parser_mediator, metadata, 'revision_number')
    event_data.scale_crop = self._GetPropertyValue(
        parser_mediator, metadata, 'scale_crop')
    event_data.shared_doc = self._GetPropertyValue(
        parser_mediator, metadata, 'shared_doc')
    event_data.template = self._GetPropertyValue(
        parser_mediator, metadata, 'template')
    event_data.total_time = self._GetPropertyValue(
        parser_mediator, metadata, 'total_time')

    self._ProduceEvent(
        parser_mediator, event_data, metadata, 'created',
        definitions.TIME_DESCRIPTION_CREATION, 'creation time')
    self._ProduceEvent(
        parser_mediator, event_data, metadata, 'modified',
        definitions.TIME_DESCRIPTION_MODIFICATION, 'modification time')
    self._ProduceEvent(
        parser_mediator, event_data, metadata, 'last_printed',
        definitions.TIME_DESCRIPTION_LAST_PRINTED, 'last printed time')

Parses an OXML file-like object.

Args:
parser_mediator (ParserMediator): mediates interactions between parsers
and other components, such as storage and dfvfs.
zip_file (zipfile.ZipFile): the zip file containing OXML content. It is
not be closed in this method, but will be closed by the parser logic
in czip.py.

Raises:
UnableToParseFile: when the file cannot be parsed.


def GetUserByEmail(self, email):

    user = self.rpc_helper.GetAccountInfoByEmail(email)
    return GitkitUser.FromApiResponse(user)

Gets user info by email.

Args:
email: string, the user email.

Returns:
GitkitUser, containing the user info.


def deserialize_subject_info(subject_info_xml):
    try:
        return d1_common.xml.deserialize(subject_info_xml)
    except ValueError as e:
        raise d1_common.types.exceptions.InvalidToken(0, 'Could not deserialize SubjectInfo. subject_info="{}", error="{}"'.format(subject_info_xml, str(e)))

Deserialize SubjectInfo XML doc to native object.

Args:
subject_info_xml: str
SubjectInfo XML doc

Returns:
SubjectInfo PyXB object


def url_is_project(url, default='not_a_func'):

    try:
        u = resolve(url)
        if u and u.func != default:
            return True
    except Resolver404:
        static_url = settings.STATIC_URL
        static_url_wd = static_url.lstrip('/')
        if url.startswith(static_url):
            url = url[len(static_url):]
        elif url.startswith(static_url_wd):
            url = url[len(static_url_wd):]
        else:
            return False
        if finders.find(url):
            return True
    return False

Check if URL is part of the current project's URLs.

Args:
url (str): URL to check.
default (callable): used to filter out some URLs attached to function.

Returns:


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

    query_hash = hash(query)

    event_data = LsQuarantineEventData()
    event_data.agent = self._GetRowValue(query_hash, row, 'Agent')
    event_data.data = self._GetRowValue(query_hash, row, 'Data')
    event_data.query = query
    event_data.url = self._GetRowValue(query_hash, row, 'URL')

    timestamp = self._GetRowValue(query_hash, row, 'Time')
    date_time = dfdatetime_cocoa_time.CocoaTime(timestamp=timestamp)
    event = time_events.DateTimeValuesEvent(
        date_time, definitions.TIME_DESCRIPTION_FILE_DOWNLOADED)
    parser_mediator.ProduceEventWithEventData(event, event_data)

Parses a launch services quarantine event row.

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


def get_tracks_for_album(self, artist, album, full_album_art_uri=False):
    subcategories = [artist, album]
    result = self.get_album_artists(full_album_art_uri=full_album_art_uri, subcategories=subcategories, complete_result=True)
    result._metadata['search_type'] = 'tracks_for_album'
    return result

Get the tracks of an artist's album.

Args:
artist (str): an artist's name.
album (str): an album name.
full_album_art_uri: whether the album art URI should be
absolute (i.e. including the IP address). Default `False`.

Returns:
A `SearchResult` instance.


def port(self, value):

        self._port = value

        if value is None:
            try:
                del self._connectionXML.attrib['port']
            except KeyError:
                pass
        else:
            self._connectionXML.set('port', value)

Set the connection's port property.

Args:
value:  New port value. String.

Returns:
Nothing.


def _parse_query_key(self, key, val, is_escaped):
    if key.endswith('__contains'):
        key = key[:(- 10)]
        val = self._parse_query_modifier('contains', val, is_escaped)
    elif key.endswith('__range'):
        key = key[:(- 7)]
        val = self._parse_query_modifier('range', val, is_escaped)
    elif key.endswith('__startswith'):
        key = key[:(- 12)]
        val = self._parse_query_modifier('startswith', val, is_escaped)
    elif key.endswith('__endswith'):
        key = key[:(- 10)]
        val = self._parse_query_modifier('endswith', val, is_escaped)
    elif key.endswith('__lt'):
        key = key[:(- 4)]
        val = self._parse_query_modifier('lt', val, is_escaped)
    elif key.endswith('__gt'):
        key = key[:(- 4)]
        val = self._parse_query_modifier('gt', val, is_escaped)
    elif key.endswith('__lte'):
        key = key[:(- 5)]
        val = self._parse_query_modifier('lte', val, is_escaped)
    elif key.endswith('__gte'):
        key = key[:(- 5)]
        val = self._parse_query_modifier('gte', val, is_escaped)
    elif ((key != 'NOKEY') and (not is_escaped)):
        val = self._escape_query(val)
    return (key, val)

Strips query modifier from key and call's the appropriate value modifier.

Args:
key (str): Query key
val: Query value

Returns:
Parsed query key and value.


def run(self):
    while self.should_run:
        try:
            self.logger.debug(('Sending heartbeat, seq ' + last_sequence))
            self.ws.send(json.dumps({'op': 1, 'd': last_sequence}))
        except Exception as e:
            self.logger.error(f'Got error in heartbeat: {str(e)}')
        finally:
            elapsed = 0.0
            while ((elapsed < self.interval) and self.should_run):
                time.sleep(self.TICK_INTERVAL)
                elapsed += self.TICK_INTERVAL

Runs the thread

This method handles sending the heartbeat to the Discord websocket server, so the connection
can remain open and the bot remain online for those commands that require it to be.

Args:
None


def Erase(self, partition, timeout_ms=None):

        self._SimpleCommand(b'erase', arg=partition, timeout_ms=timeout_ms)

Erases the given partition.

Args:
partition: Partition to clear.


def stage_tc_batch_xid(xid_type, xid_value, owner):

        xid_string = '{}-{}-{}'.format(xid_type, xid_value, owner)
        hash_object = hashlib.sha256(xid_string.encode('utf-8'))
        return hash_object.hexdigest()

Create an xid for a batch job.

Args:
xid_type (str): [description]
xid_value (str): [description]
owner (str): [description]

Returns:
[type]: [description]


def set_save_handler(save_handler: Optional[Callable[..., Any]]) -> Optional[Callable[..., Any]]:
    if save_handler and (not callable(save_handler)):
        raise ValueError('`save_handler` must be callable.')
    global _SAVE_HANDLER
    old_handler = _SAVE_HANDLER
    _SAVE_HANDLER = save_handler
    return old_handler

Sets global save handler.

Args:
save_handler: A callable object that takes at least one argument as value to
save. `symbolic.save` method will pass through all arguments to this
handler and return its return value.

Returns:
Previous global save handler.


def _SetHeader(self, new_values):

        row = self.row_class()
        row.row = 0
        for v in new_values:
            row[v] = v
        self._table[0] = row

Sets header of table to the given tuple.

Args:
new_values: Tuple of new header values.


def estimate_motion(self, time, intensity_grid, max_u, max_v):
    ti = np.where((time == self.times))[0][0]
    mask_vals = np.where((self.masks[ti].ravel() == 1))
    i_vals = self.i[ti].ravel()[mask_vals]
    j_vals = self.j[ti].ravel()[mask_vals]
    obj_vals = self.timesteps[ti].ravel()[mask_vals]
    u_shifts = np.arange((- max_u), (max_u + 1))
    v_shifts = np.arange((- max_v), (max_v + 1))
    min_error = 99999999999.0
    best_u = 0
    best_v = 0
    for u in u_shifts:
        j_shift = (j_vals - u)
        for v in v_shifts:
            i_shift = (i_vals - v)
            if np.all(((((0 <= i_shift) & (i_shift < intensity_grid.shape[0])) & (0 <= j_shift)) & (j_shift < intensity_grid.shape[1]))):
                shift_vals = intensity_grid[(i_shift, j_shift)]
            else:
                shift_vals = np.zeros(i_shift.shape)
            error = np.abs((shift_vals - obj_vals)).mean()
            if (error < min_error):
                min_error = error
                best_u = (u * self.dx)
                best_v = (v * self.dx)
    self.u[ti] = best_u
    self.v[ti] = best_v
    return (best_u, best_v, min_error)

Estimate the motion of the object with cross-correlation on the intensity values from the previous time step.

Args:
time: time being evaluated.
intensity_grid: 2D array of intensities used in cross correlation.
max_u: Maximum x-component of motion. Used to limit search area.
max_v: Maximum y-component of motion. Used to limit search area

Returns:
u, v, and the minimum error.


def ipv4_is_defined(address):

    query_ip = IPv4Address(str(address))

    results = namedtuple('ipv4_is_defined_results', 'is_defined, ietf_name, '
                                                    'ietf_rfc')

    if query_ip in IPv4Network('0.0.0.0/8'):

        return results(True, 'This Network', 'RFC 1122, Section 3.2.1.3')

    elif query_ip.is_loopback:

        return results(True, 'Loopback', 'RFC 1122, Section 3.2.1.3')

    elif query_ip.is_link_local:

        return results(True, 'Link Local', 'RFC 3927')

    elif query_ip in IPv4Network('192.0.0.0/24'):

        return results(True, 'IETF Protocol Assignments', 'RFC 5736')

    elif query_ip in IPv4Network('192.0.2.0/24'):

        return results(True, 'TEST-NET-1', 'RFC 5737')

    elif query_ip in IPv4Network('192.88.99.0/24'):

        return results(True, '6to4 Relay Anycast', 'RFC 3068')

    elif query_ip in IPv4Network('198.18.0.0/15'):

        return (results(True,
                'Network Interconnect Device Benchmark Testing',
                        'RFC 2544'))

    elif query_ip in IPv4Network('198.51.100.0/24'):

        return results(True, 'TEST-NET-2', 'RFC 5737')

    elif query_ip in IPv4Network('203.0.113.0/24'):

        return results(True, 'TEST-NET-3', 'RFC 5737')

    elif query_ip.is_multicast:

        return results(True, 'Multicast', 'RFC 3171')

    elif query_ip in IPv4Network('255.255.255.255/32'):

        return results(True, 'Limited Broadcast', 'RFC 919, Section 7')

    elif query_ip.is_private:

        return results(True, 'Private-Use Networks', 'RFC 1918')

    elif query_ip in IPv4Network('198.97.38.0/24'):

        return results(True, 'IANA Reserved', '')

    return results(False, '', '')

The function for checking if an IPv4 address is defined (does not need to
be resolved).

Args:
address (:obj:`str`): An IPv4 address.

Returns:
namedtuple:

:is_defined (bool): True if given address is defined, otherwise
False
:ietf_name (str): IETF assignment name if given address is
defined, otherwise ''
:ietf_rfc (str): IETF assignment RFC if given address is defined,
otherwise ''


def fit_gaussian(samples, ddof=0):
    if (len(samples.shape) == 1):
        return (np.mean(samples), np.std(samples, ddof=ddof))
    return (np.mean(samples, axis=1), np.std(samples, axis=1, ddof=ddof))

Calculates the mean and the standard deviation of the given samples.

Args:
samples (ndarray): a one or two dimensional array. If one dimensional we calculate the fit using all
values. If two dimensional, we fit the Gaussian for every set of samples over the first dimension.
ddof (int): the difference degrees of freedom in the std calculation. See numpy.


def timestamp(value, fmt=None):
    if fmt:
        return _timestamp_formats.get(fmt, (lambda v: timestamp_fmt(v, fmt)))(value)
    l = len(value)
    if ((19 <= l <= 24) and (value[3] == ' ')):
        try:
            return timestamp_d_b_Y_H_M_S(value)
        except (KeyError, ValueError, OverflowError):
            pass
    if (30 <= l <= 31):
        try:
            return timestamp_a__d_b_Y_H_M_S_z(value)
        except (KeyError, ValueError, OverflowError):
            pass
    if (l == 14):
        try:
            return timestamp_YmdHMS(value)
        except (ValueError, OverflowError):
            pass
    try:
        return timestamp_epoch(value)
    except ValueError:
        pass
    return timestamp_any(value)

Parse a datetime to a unix timestamp.

Uses fast custom parsing for common datetime formats or the slow dateutil
parser for other formats. This is a trade off between ease of use and speed
and is very useful for fast parsing of timestamp strings whose format may
standard but varied or unknown prior to parsing.

Common formats include:
1 Feb 2010 12:00:00 GMT
Mon, 1 Feb 2010 22:00:00 +1000
20100201120000
1383470155 (seconds since epoch)

See the other timestamp_*() functions for more details.

Args:
value: A string representing a datetime.
fmt: A timestamp format string like for time.strptime().

Returns:
The time in seconds since epoch as and integer for the value specified.


def has_relationship(self, left_id, left_type, right_id, right_type,
                         rel_type='Related To'):

        data = self.get_object(left_id, left_type)
        if not data:
            raise CRITsOperationalError('Crits Object not found with id {}'
                                        'and type {}'.format(left_id,
                                                             left_type))
        if 'relationships' not in data:
            return False
        for relationship in data['relationships']:
            if relationship['relationship'] != rel_type:
                continue
            if relationship['value'] != right_id:
                continue
            if relationship['type'] != right_type:
                continue
            return True
        return False

Checks if the two objects are related

Args:
left_id: The CRITs ID of the first indicator
left_type: The CRITs TLO type of the first indicator
right_id: The CRITs ID of the second indicator
right_type: The CRITs TLO type of the second indicator
rel_type: The relationships type ("Related To", etc)
Returns:
True or False if the relationship exists or not.


def __init__(self, identifier):

    super(FormatSpecification, self).__init__()
    self.identifier = identifier
    self.signatures = []

Initializes a specification.

Args:
identifier (str): unique name for the format.


class Mean(Metric):

    def __init__(self, name='mean', dtype=None):
        super().__init__(name=name, dtype=dtype)
        self.total = self.add_variable(shape=(), initializer=initializers.Zeros(), dtype=self.dtype, name='total')
        self.count = self.add_variable(shape=(), initializer=initializers.Zeros(), dtype=self.dtype, name='count')

    def update_state(self, values, sample_weight=None):
        values, sample_weight = reduce_to_samplewise_values(values, sample_weight, reduce_fn=ops.mean, dtype=self.dtype)
        self.total.assign_add(ops.sum(values))
        if sample_weight is not None:
            num_samples = ops.sum(sample_weight)
        elif len(values.shape) >= 1:
            num_samples = ops.shape(values)[0]
        else:
            num_samples = 1
        self.count.assign_add(ops.cast(num_samples, dtype=self.dtype))

    def reset_state(self):
        self.total.assign(0)
        self.count.assign(0)

    def result(self):
        return ops.divide_no_nan(self.total, ops.cast(self.count, dtype=self.dtype))

Compute the (weighted) mean of the given values.

For example, if values is `[1, 3, 5, 7]` then the mean is 4.
If `sample_weight` was specified as `[1, 1, 0, 0]` then the mean would be 2.

This metric creates two variables, `total` and `count`.
The mean value returned is simply `total` divided by `count`.

Args:
name: (Optional) string name of the metric instance.
dtype: (Optional) data type of the metric result.

Example:

>>> m = Mean()
>>> m.update_state([1, 3, 5, 7])
>>> m.result()
4.0

>>> m.reset_state()
>>> m.update_state([1, 3, 5, 7], sample_weight=[1, 1, 0, 0])
>>> m.result()
2.0


def end_before(self, document_fields):
    return self._cursor_helper(document_fields, before=True, start=False)

End query results before a particular document value.

The result set will **exclude** the document specified by
``document_fields``.

If the current query already has specified an end cursor -- either
via this method or
:meth:`~.firestore_v1beta1.query.Query.end_at` -- this will
overwrite it.

When the query is sent to the server, the ``document_fields`` will
be used in the order given by fields set by
:meth:`~.firestore_v1beta1.query.Query.order_by`.

Args:
document_fields (Union[~.firestore_v1beta1.\
document.DocumentSnapshot, dict, list, tuple]): a document
snapshot or a dictionary/list/tuple of fields representing a
query results cursor. A cursor is a collection of values that
represent a position in a query result set.

Returns:
~.firestore_v1beta1.query.Query: A query with cursor. Acts as
a copy of the current query, modified with the newly added
"end before" cursor.


def request(self, request):

        url = "{}{}".format(self._base_url, request.path)

        timeout = self.poll_timeout

        if request.stream is True:
            timeout = self.stream_timeout

        try:
            http_response = self._session.request(
                request.method,
                url,
                headers=self._headers,
                params=request.params,
                data=request.body,
                stream=request.stream,
                timeout=timeout
            )
        except requests.exceptions.ConnectionError:
            raise V20ConnectionError(url)
        except requests.exceptions.ConnectTimeout:
            raise V20Timeout(url, "connect")
        except requests.exceptions.ReadTimeout:
            raise V20Timeout(url, "read")

        request.headers = http_response.request.headers

        response = Response(
            request,
            request.method,
            http_response.url,
            http_response.status_code,
            http_response.reason,
            http_response.headers
        )

        if request.stream:
            response.set_line_parser(
                request.line_parser
            )

            response.set_lines(
                http_response.iter_lines(
                    self.stream_chunk_size
                )
            )
        else:
            response.set_raw_body(http_response.text)

        return response

Perform an HTTP request through the context

Args:
request: A v20.request.Request object

Returns:
A v20.response.Response object


def represent_as_tuple(string):

    keep = (".", "[", "]")
    return tuple(str_digit_to_int(c) if c not in keep else c for c in string)

Represent a number-string in the form of a tuple of digits.
"868.0F" -> (8, 6, 8, '.', 0, 15)

Args:
string - Number represented as a string of digits.
Returns:
Number represented as an iterable container of digits

>>> represent_as_tuple('868.0F')
(8, 6, 8, '.', 0, 15)


def _call_for_each_replica(distribution, fn, args, kwargs):
    run_concurrently = False
    if not context.executing_eagerly():
        ops.get_default_graph().switch_to_thread_local()
    coord = coordinator.Coordinator(clean_stop_exception_types=(_RequestedStop,))
    shared_variable_store = {}
    devices = distribution.extended.worker_devices
    thread_local_callables = _get_thread_local_configuration_callable()
    threads = []
    for index in range(len(devices)):
        variable_creator_fn = shared_variable_creator.make_fn(shared_variable_store, index)
        t = _MirroredReplicaThread(distribution, coord, index, devices, variable_creator_fn, fn, distribute_utils.caching_scope_local, distribute_utils.select_replica(index, args), distribute_utils.select_replica(index, kwargs), thread_local_callables)
        threads.append(t)
    for t in threads:
        t.start()
    try:
        with coord.stop_on_exception():
            all_done = False
            while not all_done and (not coord.should_stop()):
                done = []
                if run_concurrently:
                    for t in threads:
                        t.should_run.set()
                    for t in threads:
                        t.has_paused.wait()
                        t.has_paused.clear()
                        if coord.should_stop():
                            return None
                        done.append(t.done)
                else:
                    for t in threads:
                        t.should_run.set()
                        t.has_paused.wait()
                        t.has_paused.clear()
                        if coord.should_stop():
                            return None
                        done.append(t.done)
                if coord.should_stop():
                    return None
                all_done = all(done)
                if not all_done:
                    if any(done):
                        raise RuntimeError('Some replicas made a different number of replica_context().merge_call() calls.')
                    merge_args = distribute_utils.regroup(tuple((t.merge_args for t in threads)))
                    merge_kwargs = distribute_utils.regroup(tuple((t.merge_kwargs for t in threads)))
                    mtt_captured_name_scope = threads[0].captured_name_scope
                    mtt_captured_var_scope = threads[0].captured_var_scope
                    mtt_captured_control_deps = set()
                    for t in threads:
                        mtt_captured_control_deps.update(t.captured_control_deps)
                    with ops.name_scope(mtt_captured_name_scope), ops.control_dependencies(mtt_captured_control_deps), variable_scope.variable_scope(mtt_captured_var_scope), _maybe_enter_eager_mode(threads[0].merge_call_entered_in_eager):
                        merge_result = threads[0].merge_fn(distribution, *merge_args, **merge_kwargs)
                    for r, t in enumerate(threads):
                        t.merge_result = distribute_utils.select_replica(r, merge_result)
    finally:
        for t in threads:
            t.should_run.set()
        coord.join(threads)
    return distribute_utils.regroup(tuple((t.main_result for t in threads)))

Run `fn` in separate threads, once per replica/worker device.

Args:
distribution: the DistributionStrategy object.
fn: function to run (will be run once per replica, each in its own thread).
args: positional arguments for `fn`
kwargs: keyword arguments for `fn`.

Returns:
Merged return value of `fn` across all replicas.

Raises:
RuntimeError: If fn() calls get_replica_context().merge_call() a different
number of times from the available devices.


def parse_vlq(self, segment):
    values = []
    (cur, shift) = (0, 0)
    for c in segment:
        val = B64[ord(c)]
        (val, cont) = ((val & 31), (val >> 5))
        cur += (val << shift)
        shift += 5
        if (not cont):
            (cur, sign) = ((cur >> 1), (cur & 1))
            if sign:
                cur = (- cur)
            values.append(cur)
            (cur, shift) = (0, 0)
    if (cur or shift):
        raise SourceMapDecodeError('leftover cur/shift in vlq decode')
    return values

Parse a string of VLQ-encoded data.

Returns:
a list of integers.


def dump_package_data(data, buf, format_=FileFormat.py, skip_attributes=None):

    if format_ == FileFormat.txt:
        raise ValueError("'txt' format not supported for packages.")

    data_ = dict((k, v) for k, v in data.iteritems() if v is not None)
    data_ = package_serialise_schema.validate(data_)
    skip = set(skip_attributes or [])

    items = []
    for key in package_key_order:
        if key not in skip:
            value = data_.pop(key, None)
            if value is not None:
                items.append((key, value))

    for key, value in data_.iteritems():
        if key not in skip:
            items.append((key, value))

    dump_func = dump_functions[format_]
    dump_func(items, buf)

Write package data to `buf`.

Args:
data (dict): Data source - must conform to `package_serialise_schema`.
buf (file-like object): Destination stream.
format_ (`FileFormat`): Format to dump data in.
skip_attributes (list of str): List of attributes to not print.


def _GetLoadConfigTimestamp(self, pefile_object):
    if (not hasattr(pefile_object, 'DIRECTORY_ENTRY_LOAD_CONFIG')):
        return None
    timestamp = getattr(pefile_object.DIRECTORY_ENTRY_LOAD_CONFIG.struct, 'TimeDateStamp', 0)
    return timestamp

Retrieves the timestamp from the Load Configuration directory.

Args:
pefile_object (pefile.PE): pefile object.

Returns:
int: load configuration timestamps or None if there are none present.


def on_connected(self, connection):
    log.info('PikaClient: connected to RabbitMQ')
    self.connected = True
    self.in_channel = self.connection.channel(self.on_channel_open)

AMQP connection callback.
Creates input channel.

Args:
connection: AMQP connection


def count(cls, cur, table: str, where_keys: list=None):
    if where_keys:
        (where_clause, values) = cls._get_where_clause_with_values(where_keys)
        query = cls._count_query_where.format(table, where_clause)
        (q, t) = (query, values)
    else:
        query = cls._count_query.format(table)
        (q, t) = (query, ())
    (yield from cur.execute(q, t))
    result = (yield from cur.fetchone())
    return int(result[0])

gives the number of records in the table

Args:
table: a string indicating the name of the table

Returns:
an integer indicating the number of records in the table