def patch_fromText(self, textline):

    if type(textline) == unicode:

      textline = textline.encode("ascii")
    patches = []
    if not textline:
      return patches
    text = textline.split('\n')
    while len(text) != 0:
      m = re.match("^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$", text[0])
      if not m:
        raise ValueError("Invalid patch string: " + text[0])
      patch = patch_obj()
      patches.append(patch)
      patch.start1 = int(m.group(1))
      if m.group(2) == '':
        patch.start1 -= 1
        patch.length1 = 1
      elif m.group(2) == '0':
        patch.length1 = 0
      else:
        patch.start1 -= 1
        patch.length1 = int(m.group(2))

      patch.start2 = int(m.group(3))
      if m.group(4) == '':
        patch.start2 -= 1
        patch.length2 = 1
      elif m.group(4) == '0':
        patch.length2 = 0
      else:
        patch.start2 -= 1
        patch.length2 = int(m.group(4))

      del text[0]

      while len(text) != 0:
        if text[0]:
          sign = text[0][0]
        else:
          sign = ''
        line = urllib.unquote(text[0][1:])
        line = line.decode("utf-8")
        if sign == '+':

          patch.diffs.append((self.DIFF_INSERT, line))
        elif sign == '-':

          patch.diffs.append((self.DIFF_DELETE, line))
        elif sign == ' ':

          patch.diffs.append((self.DIFF_EQUAL, line))
        elif sign == '@':

          break
        elif sign == '':

          pass
        else:

          raise ValueError("Invalid patch mode: '%s'\n%s" % (sign, line))
        del text[0]
    return patches

Parse a textual representation of patches and return a list of patch
objects.

Args:
textline: Text representation of patches.

Returns:
Array of Patch objects.

Raises:
ValueError: If invalid input.


def extract_channel(k, cdim):

    n = cdim
    perm = tuple(list(range(k)) + [n - 1] + list(range(k, n - 1)))
    return CPermutation.create(perm)

Create a :class:`CPermutation` that extracts channel `k`

Return a permutation circuit that maps the k-th (zero-based)
input to the last output, while preserving the relative order of all other
channels.

Args:
k (int): Extracted channel index
cdim (int): The circuit dimension (number of channels)

Returns:
Circuit: Permutation circuit


def install_requirements(self, path, index=None):
    cmd = 'install -r {0}'.format(path)
    if index:
        cmd = 'install --index-url {0} -r {1}'.format(index, path)
    self.pip(cmd)

Install packages from a requirements.txt file.

Args:
path (str): The path to the requirements file.
index (str): The URL for a pypi index to use.


def eulers_totient(n):
    if (not isinstance(n, int)):
        raise TypeError('Expecting a strictly positive integer')
    if (n <= 0):
        raise ValueError('Expecting a strictly positive integer')
    if (n == 1):
        return 1
    result = 0
    for i in range(1, n):
        if (gcd(i, n) == 1):
            result += 1
    return result

Calculate the value of Euler's totient for a given integer

Args:
n (int): strictly positive integer

Returns:
The value of Euler's totient for n

Raises:
TypeError: If either n or k is not an integer
ValueError: If either n or k is negative, or if k is strictly greater than n


def parse_arguments(*args, **options):
    days = options.get('days', 1)
    enterprise_customer_uuid = options.get('enterprise_customer_uuid')
    enterprise_customer = None
    if enterprise_customer_uuid:
        try:
            enterprise_customer = EnterpriseCustomer.objects.get(uuid=enterprise_customer_uuid)
        except EnterpriseCustomer.DoesNotExist:
            raise CommandError('Enterprise customer with uuid "{enterprise_customer_uuid}" does not exist.'.format(enterprise_customer_uuid=enterprise_customer_uuid))
    return (days, enterprise_customer)

Parse and validate arguments for send_course_enrollments command.

Arguments:
*args: Positional arguments passed to the command
**options: optional arguments passed to the command

Returns:
A tuple containing parsed values for
1. days (int): Integer showing number of days to lookup enterprise enrollments,
course completion etc and send to xAPI LRS
2. enterprise_customer_uuid (EnterpriseCustomer): Enterprise Customer if present then
send xAPI statements just for this enterprise.


def post_message(self, level, message, count=1, timestamp=None, now_reference=None):
    if ((len(self.messages) > 0) and (self.messages[(- 1)].message == message)):
        self.messages[(- 1)].count += 1
    else:
        msg_object = ServiceMessage(level, message, self._last_message_id, timestamp, now_reference)
        msg_object.count = count
        self.messages.append(msg_object)
        self._last_message_id += 1
    return self.messages[(- 1)]

Post a new message for service.

Args:
level (int): The level of the message (info, warning, error)
message (string): The message contents
count (int): The number of times the message has been repeated
timestamp (float): An optional monotonic value in seconds for when the message was created
now_reference (float): If timestamp is not relative to monotonic() as called from this
module then this should be now() as seen by whoever created the timestamp.

Returns:
ServiceMessage: The posted message


def get_sample(self, md5):

        sample = self.data_store.get_sample(md5)
        if not sample:
            return {'sample_set': {'md5_list': self.get_sample_set(md5)}}
        return {'sample': sample}

Get a sample from the DataStore.
Args:
md5: the md5 of the sample
Returns:
A dictionary of meta data about the sample which includes
a ['raw_bytes'] key that contains the raw bytes.
Raises:
Workbench.DataNotFound if the sample is not found.


def make_list_of_op(tops, check_graph=True, allow_graph=True, ignore_ts=False):
    if isinstance(tops, ops.Graph):
        if allow_graph:
            return tops.get_operations()
        else:
            raise TypeError('allow_graph is False: cannot convert a tf.Graph.')
    else:
        if not is_iterable(tops):
            tops = [tops]
        if not tops:
            return []
        if check_graph:
            check_types = None if ignore_ts else ops.Operation
            get_unique_graph(tops, check_types=check_types)
        return [op for op in tops if isinstance(op, ops.Operation)]

Convert ops to a list of `tf.Operation`.

Args:
tops: can be an iterable of `tf.Operation`, a `tf.Graph` or a single
operation.
check_graph: if `True` check if all the operations belong to the same graph.
allow_graph: if `False` a `tf.Graph` cannot be converted.
ignore_ts: if True, silently ignore `tf.Tensor`.
Returns:
A newly created list of `tf.Operation`.
Raises:
TypeError: if tops cannot be converted to a list of `tf.Operation` or,
if `check_graph` is `True`, if all the ops do not belong to the
same graph.


def isdir(path):

    system = get_instance(path)

    return system.isdir(system.ensure_dir_path(path))

Return True if path is an existing directory.

Equivalent to "os.path.isdir".

Args:
path (path-like object): Path or URL.

Returns:
bool: True if directory exists.


def create_base_for_fuse_batchnorm(self, pattern_match_mode='MATCH_ALL'):
    with self.cached_session() as sess:
        data_format = 'NHWC'
        if pattern_match_mode == 'MISMATCH_FORMAT':
            data_format = 'NCHW'
        inputs = [1, 4, 2, 5, 3, 6, -1, -4, -2, -5, -3, -6]
        input_op = constant_op.constant(np.array(inputs), shape=[1, 1, 6, 2] if data_format == 'NHWC' else [1, 2, 1, 6], dtype=dtypes.float32)
        weights = [1, 2, 3, 4, 0.1, 0.2, 0.3, 0.4]
        weights_op = constant_op.constant(np.array(weights), shape=[1, 2, 2, 2], dtype=dtypes.float32)
        conv_op = nn_ops.conv2d(input_op, weights_op, [1, 1, 1, 1], data_format=data_format, padding='SAME', name='conv_op')
        const_op_1 = None
        const_op_2 = constant_op.constant(1e-05, dtype=dtypes.float32)
        const_op_3 = None
        const_op_4 = None
        const_op_5 = None
        const_op_6 = None
        if data_format == 'NHWC':
            const_op_1 = constant_op.constant(np.array([0.25, 0.5]), shape=[2], dtype=dtypes.float32)
            const_op_3 = constant_op.constant(np.array([10, 20]), shape=[2], dtype=dtypes.float32)
            const_op_4 = constant_op.constant(np.array([0.1, 0.6]), shape=[2], dtype=dtypes.float32)
            const_op_5 = constant_op.constant(np.array([1.0, 2.0]), shape=[2], dtype=dtypes.float32)
            const_op_6 = constant_op.constant(np.array([0.2, 0.5]), shape=[2], dtype=dtypes.float32)
        else:
            const_op_1 = constant_op.constant(np.array([0.25, 0.5, 0.6, 0.7, 0.8, 0.9]), shape=[6], dtype=dtypes.float32)
            const_op_3 = constant_op.constant(np.array([10, 20, 30, 40, 50, 60]), shape=[6], dtype=dtypes.float32)
            const_op_4 = constant_op.constant(np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6]), shape=[6], dtype=dtypes.float32)
            const_op_5 = constant_op.constant(np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]), shape=[6], dtype=dtypes.float32)
            const_op_6 = constant_op.constant(np.array([0.2, 0.4, 0.5, 0.6, 0.7, 0.8]), shape=[6], dtype=dtypes.float32)
        add_op_1 = gen_math_ops.add(const_op_1, const_op_2)
        rsqrt_op = math_ops.rsqrt(add_op_1)
        variable_op = None
        if pattern_match_mode == 'MATCH_NO_GAMMA':
            variable_op = rsqrt_op
        else:
            variable_op = math_ops.multiply(rsqrt_op, const_op_5)
        mul_op_1 = math_ops.multiply(conv_op, variable_op)
        mul_op_2 = None
        if pattern_match_mode == 'MISMATCH_PATTERN':
            mul_op_2 = math_ops.multiply(const_op_3, const_op_6)
        else:
            mul_op_2 = math_ops.multiply(const_op_3, variable_op)
        sub_op = math_ops.subtract(const_op_4, mul_op_2)
        if pattern_match_mode == 'MATCH_SWITCH_ORDER':
            gen_math_ops.add(sub_op, mul_op_1, name='output')
        else:
            gen_math_ops.add(mul_op_1, sub_op, name='output')
        test_util.set_producer_version(ops.get_default_graph(), 8)
        original_graph = sess.graph_def
        original_result = sess.run(['output:0'])
        return (original_graph, original_result)

Create testing graph and compute the result from original graph.

Args:
pattern_match_mode: A label string to indicate which batchnorm composition
pattern to create in the resulting graph. "MATCH_ALL" - Create a graph
matching the decomposed batchnorm pattern with full set of primitive
ops. "MATCH_NO_GAMMA" - Create a graph matching the decomposed batchnorm
pattern when gamma factor is 1 and multiplication with gamma is omitted.
"MATCH_SWITCH_ORDER" - Create a graph matching the decomposed batchnorm
pattern with a different order of inputs to the root Add node.
"MISMATCH_PATTERN" - Create a graph with same set of primitive ops which
makes up the decomposed batchnorm, but not matching the pattern.
"MISMATCH_FORMAT" - Create a graph with NCHW format as input.

Returns:
A GraphDef as original graph to run the decomposed batchnorm test cases.
Computation result from executing the original graph defined by GraphDef.


def _run_query(client, query, job_config=None):
    start_time = time.time()
    query_job = client.query(query, job_config=job_config)
    print('Executing query with job ID: {}'.format(query_job.job_id))
    while True:
        print('\rQuery executing: {:0.2f}s'.format((time.time() - start_time)), end='')
        try:
            query_job.result(timeout=0.5)
            break
        except futures.TimeoutError:
            continue
    print('\nQuery complete after {:0.2f}s'.format((time.time() - start_time)))
    return query_job

Runs a query while printing status updates

Args:
client (google.cloud.bigquery.client.Client):
Client to bundle configuration needed for API requests.
query (str):
SQL query to be executed. Defaults to the standard SQL dialect.
Use the ``job_config`` parameter to change dialects.
job_config (google.cloud.bigquery.job.QueryJobConfig, optional):
Extra configuration options for the job.

Returns:
google.cloud.bigquery.job.QueryJob: the query job created

Example:
>>> client = bigquery.Client()
>>> _run_query(client, "SELECT 17")
Executing query with job ID: bf633912-af2c-4780-b568-5d868058632b
Query executing: 1.66s
Query complete after 2.07s
'bf633912-af2c-4780-b568-5d868058632b'


def get_video_transcript_data(video_id, language_code):
    video_transcript = VideoTranscript.get_or_none(video_id, language_code)
    if video_transcript:
        try:
            return dict(file_name=video_transcript.filename, content=video_transcript.transcript.file.read())
        except Exception:
            logger.exception('[edx-val] Error while retrieving transcript for video=%s -- language_code=%s', video_id, language_code)
            raise

Get video transcript data

Arguments:
video_id(unicode): An id identifying the Video.
language_code(unicode): it will be the language code of the requested transcript.

Returns:
A dict containing transcript file name and its content.


def _JoinKeyPath(self, path_segments):

    path_segments = [
        segment.split(definitions.KEY_PATH_SEPARATOR)
        for segment in path_segments]

    path_segments = [
        element for sublist in path_segments for element in sublist]

    path_segments = filter(None, path_segments)

    return definitions.KEY_PATH_SEPARATOR.join(path_segments)

Joins the path segments into key path.

Args:
path_segments (list[str]): Windows Registry key path segments.

Returns:
str: key path.


def from_label(cls, label):
    z = np.zeros(len(label), dtype=np.bool)
    x = np.zeros(len(label), dtype=np.bool)
    for (i, char) in enumerate(label):
        if (char == 'X'):
            x[((- i) - 1)] = True
        elif (char == 'Z'):
            z[((- i) - 1)] = True
        elif (char == 'Y'):
            z[((- i) - 1)] = True
            x[((- i) - 1)] = True
        elif (char != 'I'):
            raise QiskitError("Pauli string must be only consisted of 'I', 'X', 'Y' or 'Z' but you have {}.".format(char))
    return cls(z=z, x=x)

r"""Take pauli string to construct pauli.

The qubit index of pauli label is q_{n-1} ... q_0.
E.g., a pauli is $P_{n-1} \otimes ... \otimes P_0$

Args:
label (str): pauli label

Returns:
Pauli: the constructed pauli

Raises:
QiskitError: invalid character in the label


def GetName(self):
    if (self.AssetType == AssetType.GoverningToken):
        return 'NEO'
    elif (self.AssetType == AssetType.UtilityToken):
        return 'NEOGas'
    if (type(self.Name) is bytes):
        return self.Name.decode('utf-8')
    return self.Name

Get the asset name based on its type.

Returns:
str: 'NEO' or 'NEOGas'


def box(self, x0, y0, width, height):

        assert width > 1
        assert height > 1

        width -= 1
        height -= 1

        for x in range(x0, x0 + width):
            self.point(x, y0, "-")
            self.point(x, y0 + height, "-")

        for y in range(y0, y0 + height):
            self.point(x0, y, "|")
            self.point(x0 + width, y, "|")

        self.point(x0, y0, "+")
        self.point(x0 + width, y0, "+")
        self.point(x0, y0 + height, "+")
        self.point(x0 + width, y0 + height, "+")

Create a box on ASCII canvas.

Args:
x0 (int): x coordinate of the box corner.
y0 (int): y coordinate of the box corner.
width (int): box width.
height (int): box height.


def Process(self, parser_mediator, root_item=None, **kwargs):

    super(SummaryInformationOLECFPlugin, self).Process(
        parser_mediator, **kwargs)

    if not root_item:
      raise ValueError('Root item not set.')

    root_creation_time, root_modification_time = self._GetTimestamps(root_item)

    for item_name in self.REQUIRED_ITEMS:
      item = root_item.get_sub_item_by_name(item_name)
      if not item:
        continue

      summary_information = OLECFSummaryInformation(item)
      event_data = summary_information.GetEventData(
          data_type='olecf:summary_info')
      event_data.name = 'Summary Information'

      for property_name, date_time in iter(
          summary_information.date_time_properties.items()):
        date_time_description = self._DATE_TIME_DESCRIPTIONS.get(
            property_name, definitions.TIME_DESCRIPTION_UNKNOWN)
        event = OLECFSummaryInformationEvent(date_time, date_time_description)
        parser_mediator.ProduceEventWithEventData(event, event_data)

      if root_creation_time:
        date_time = dfdatetime_filetime.Filetime(
            timestamp=root_creation_time)
        event = OLECFSummaryInformationEvent(
            date_time, definitions.TIME_DESCRIPTION_CREATION)
        parser_mediator.ProduceEventWithEventData(event, event_data)

      if root_modification_time:
        date_time = dfdatetime_filetime.Filetime(
            timestamp=root_modification_time)
        event = OLECFSummaryInformationEvent(
            date_time, definitions.TIME_DESCRIPTION_MODIFICATION)
        parser_mediator.ProduceEventWithEventData(event, event_data)

Parses a summary information OLECF item.

Args:
parser_mediator (ParserMediator): mediates interactions between parsers
and other components, such as storage and dfvfs.
root_item (Optional[pyolecf.item]): root item of the OLECF file.

Raises:
ValueError: If the root item is not set.


def rollaxis(a, axis, start=0):

    if isinstance(a, np.ndarray):
        return np.rollaxis(a, axis, start)
    if axis not in range(a.ndim):
        raise ValueError(
                'rollaxis: axis (%d) must be >=0 and < %d' % (axis, a.ndim))
    if start not in range(a.ndim + 1):
        raise ValueError(
                'rollaxis: start (%d) must be >=0 and < %d' % (axis, a.ndim+1))
    axes = list(range(a.ndim))
    axes.remove(axis)
    axes.insert(start, axis)
    return transpose(a, axes)

Roll the specified axis backwards, until it lies in a given position.

Args:
a (array_like): Input array.
axis (int): The axis to roll backwards.  The positions of the other axes
do not change relative to one another.
start (int, optional): The axis is rolled until it lies before this
position.  The default, 0, results in a "complete" roll.

Returns:
res (ndarray)


obtain cubic symmetric eqivalents of the list of vectors.

Args:
matrix (lattice matrix, n by 3 array/matrix)

Return:
cubic symmetric eqivalents of the list of vectors.


def __init__(self, line, line_num=-1, var_map=None):

    self.match = ''
    self.regex = ''
    self.regex_obj = None
    self.line_op = ''
    self.record_op = ''
    self.new_state = ''
    self.line_num = line_num

    line = line.strip()
    if not line:
      raise TextFSMTemplateError('Null data in FSMRule. Line: %s'
                                 % self.line_num)

    match_action = self.MATCH_ACTION.match(line)
    if match_action:
      self.match = match_action.group('match')
    else:
      self.match = line

    self.regex = self.match
    if var_map:
      try:
        self.regex = string.Template(self.match).substitute(var_map)
      except (ValueError, KeyError):
        raise TextFSMTemplateError(
            "Duplicate or invalid variable substitution: '%s'. Line: %s." %
            (self.match, self.line_num))

    try:

      self.regex_obj = CopyableRegexObject(self.regex)
    except re.error:
      raise TextFSMTemplateError(
          "Invalid regular expression: '%s'. Line: %s." %
          (self.regex, self.line_num))

    if not match_action:
      return

    action_re = self.ACTION_RE.match(match_action.group('action'))
    if not action_re:

      action_re = self.ACTION2_RE.match(match_action.group('action'))
      if not action_re:

        action_re = self.ACTION3_RE.match(match_action.group('action'))
        if not action_re:

          raise TextFSMTemplateError("Badly formatted rule '%s'. Line: %s." %
                                     (line, self.line_num))

    if 'ln_op' in action_re.groupdict() and action_re.group('ln_op'):
      self.line_op = action_re.group('ln_op')

    if 'rec_op' in action_re.groupdict() and action_re.group('rec_op'):
      self.record_op = action_re.group('rec_op')

    if 'new_state' in action_re.groupdict() and action_re.group('new_state'):
      self.new_state = action_re.group('new_state')

    if self.line_op == 'Continue' and self.new_state:
      raise TextFSMTemplateError(
          "Action '%s' with new state %s specified. Line: %s."
          % (self.line_op, self.new_state, self.line_num))

    if self.line_op != 'Error' and self.new_state:
      if not re.match(r'\w+', self.new_state):
        raise TextFSMTemplateError(
            'Alphanumeric characters only in state names. Line: %s.'
            % (self.line_num))

Initialise a new rule object.

Args:
line: (str), a template rule line to parse.
line_num: (int), Optional line reference included in error reporting.
var_map: Map for template (${var}) substitutions.

Raises:
TextFSMTemplateError: If 'line' is not a valid format for a Value entry.


def __init__(self, dataset, class_weight=None, distribution=None):
    from keras.src.utils.module_utils import tensorflow as tf
    if not isinstance(dataset, (tf.data.Dataset, tf.distribute.DistributedDataset)):
        raise ValueError(f'Expected argument `dataset` to be a tf.data.Dataset. Received: {dataset}')
    if class_weight is not None:
        dataset = dataset.map(make_class_weight_map_fn(class_weight)).prefetch(tf.data.AUTOTUNE)
    if distribution is not None:
        dataset = distribution.distribute_dataset(dataset)
    self._dataset = dataset

Initialize the TFDatasetAdapter.

Args:
dataset: The input `tf.data.Dataset` instance.
class_weight: A map where the keys are integer class ids and values
are the class weights, e.g. `{0: 0.2, 1: 0.6, 2: 0.3}`.
distribution: A `keras.distribution.Distribution` instance. Used to
shard the input dataset into per worker/process dataset
instance.


def increase_volume(percentage):
    if ((percentage > 100) or (percentage < 0)):
        raise ValueError('percentage must be an integer between 0 and 100')
    if (system.get_name() == 'windows'):
        pass
    elif (system.get_name() == 'mac'):
        volume_int = (percentage / 10)
        old_volume = get()
        new_volume = (old_volume + volume_int)
        if (new_volume > 10):
            new_volume = 10
        set_volume((new_volume * 10))
    else:
        formatted = ('%d%%+' % percentage)
        sp.Popen(['amixer', '--quiet', 'sset', 'Master', formatted]).wait()

Increase the volume.

Increase the volume by a given percentage.

Args:
percentage (int): The percentage (as an integer between 0 and 100) to increase the volume by.

Raises:
ValueError: if the percentage is >100 or <0.


def filesizes(images):

    while True:
        img = yield marv.pull(images)
        if img is None:
            break
        yield marv.push(img.size)

Stat filesize of files.

Args:
images: stream of marv image files

Returns:
Stream of filesizes


def _print_results(file, status):

        file_color = c.Fore.GREEN
        status_color = c.Fore.RED
        if status == 'Success':
            status_color = c.Fore.GREEN
        elif status == 'Skipped':
            status_color = c.Fore.YELLOW
        print(
            '{}{!s:<13}{}{!s:<35}{}{!s:<8}{}{}'.format(
                c.Fore.CYAN,
                'Downloading:',
                file_color,
                file,
                c.Fore.CYAN,
                'Status:',
                status_color,
                status,
            )
        )

Print the download results.

Args:
file (str): The filename.
status (str): The file download status.


def exception(self, timeout=None):
    if (not self._completed.wait(timeout=timeout)):
        raise exceptions.TimeoutError('Timed out waiting for result.')
    if (self._result != self._SENTINEL):
        return None
    return self._exception

Return the exception raised by the call, if any.

This blocks until the message has successfully been published, and
returns the exception. If the call succeeded, return None.

Args:
timeout (Union[int, float]): The number of seconds before this call
times out and raises TimeoutError.

Raises:
TimeoutError: If the request times out.

Returns:
Exception: The exception raised by the call, if any.


def summarize_dist_params(dist, name, name_scope="dist_params"):

  with tf.compat.v1.name_scope(name_scope):
    tf.compat.v2.summary.histogram(
        name="{}/{}".format(name, "mean"),
        data=dist.mean(),
        step=tf.compat.v1.train.get_or_create_global_step())
    tf.compat.v2.summary.histogram(
        name="{}/{}".format(name, "stddev"),
        data=dist.stddev(),
        step=tf.compat.v1.train.get_or_create_global_step())

Summarize the parameters of a distribution.

Args:
dist: A Distribution object with mean and standard deviation
parameters.
name: The name of the distribution.
name_scope: The name scope of this summary.


def exists(self, filename):
    result = True
    for repo in self._children:
        if (not repo.exists(filename)):
            result = False
    return result

Report whether a file exists on all distribution points.

Determines file type by extension.

Args:
filename: Filename you wish to check. (No path! e.g.:
"AdobeFlashPlayer-14.0.0.176.pkg")

Returns:
Boolean


def _set_mtu_to_nics(self, conf):
    for (dom_name, dom_spec) in conf.get('domains', {}).items():
        for (idx, nic) in enumerate(dom_spec.get('nics', [])):
            net = self._get_net(conf, dom_name, nic)
            mtu = net.get('mtu', 1500)
            if (mtu != 1500):
                nic['mtu'] = mtu

For all the nics of all the domains in the conf that have MTU set,
save the MTU on the NIC definition.

Args:
conf (dict): Configuration spec to extract the domains from

Returns:
None


def transform_framerate(self, in_fps, out_fps):

        if in_fps <= 0 or out_fps <= 0:
            raise ValueError("Framerates must be positive, cannot transform %f -> %f" % (in_fps, out_fps))

        ratio = in_fps / out_fps
        for line in self:
            line.start = int(round(line.start * ratio))
            line.end = int(round(line.end * ratio))

Rescale all timestamps by ratio of in_fps/out_fps.

Can be used to fix files converted from frame-based to time-based
with wrongly assumed framerate.

Arguments:
in_fps (float)
out_fps (float)

Raises:
ValueError: Non-positive framerate given.


def AssertIterableType(iterable, expected_item_type):
    if isinstance(iterable, collections.Iterator):
        message = 'Expected iterable container but got iterator `%s` instead'
        message %= iterable
        raise TypeError(message)
    AssertType(iterable, collections.Iterable)
    for item in iterable:
        AssertType(item, expected_item_type)

Ensures that given iterable container has certain type.

Args:
iterable: An iterable container to assert the type for.
expected_item_type: An expected type of the container items.

Raises:
TypeError: If given container does is not an iterable or its items do not
have the expected type.


def builtin(cls, name):
    names = {'nsdoe': LEGEND__NSDOE, 'canstrat': LEGEND__Canstrat, 'nagmdm__6_2': LEGEND__NAGMDM__6_2, 'nagmdm__6_1': LEGEND__NAGMDM__6_1, 'nagmdm__4_3': LEGEND__NAGMDM__4_3, 'sgmc': LEGEND__SGMC}
    return cls.from_csv(text=names[name.lower()])

Generate a default legend.

Args:
name (str): The name of the legend you want. Not case sensitive.
'nsdoe': Nova Scotia Dept. of Energy
'canstrat': Canstrat
'nagmdm__6_2': USGS N. Am. Geol. Map Data Model 6.2
'nagmdm__6_1': USGS N. Am. Geol. Map Data Model 6.1
'nagmdm__4_3': USGS N. Am. Geol. Map Data Model 4.3
'sgmc': USGS State Geologic Map Compilation

Default 'nagmdm__6_2'.

Returns:
Legend: The legend stored in `defaults.py`.


def GetAttributeValuesString(self):
    attributes = []
    for (attribute_name, attribute_value) in sorted(self.__dict__.items()):
        if ((attribute_name[0] == '_') or (attribute_value is None)):
            continue
        if isinstance(attribute_value, dict):
            attribute_value = sorted(attribute_value.items())
        elif isinstance(attribute_value, py2to3.BYTES_TYPE):
            attribute_value = repr(attribute_value)
        attribute_string = '{0:s}: {1!s}'.format(attribute_name, attribute_value)
        attributes.append(attribute_string)
    return ', '.join(attributes)

Retrieves a comparable string of the attribute values.

Returns:
str: comparable string of the attribute values.


def prepare_for_translation(localization_bundle_path):
    logging.info('Preparing for translation..')
    for strings_file in os.listdir(os.path.join(localization_bundle_path, DEFAULT_LANGUAGE_DIRECTORY_NAME)):
        if (not strings_file.endswith('.strings')):
            continue
        strings_path = os.path.join(localization_bundle_path, DEFAULT_LANGUAGE_DIRECTORY_NAME, strings_file)
        for lang_dir in os.listdir(localization_bundle_path):
            if ((lang_dir == DEFAULT_LANGUAGE_DIRECTORY_NAME) or lang_dir.startswith('.')):
                continue
            dest_strings_path = os.path.join(localization_bundle_path, lang_dir, strings_file)
            pending_path = (dest_strings_path + '.pending')
            excluded_path = (dest_strings_path + '.excluded')
            if (not os.path.exists(dest_strings_path)):
                open_strings_file(dest_strings_path, 'a').close()
            logging.info('Preparing diff for %s in %s', lang_dir, pending_path)
            localization_diff(strings_path, dest_strings_path, excluded_path, pending_path)

Prepares the localization bundle for translation.

This means, after creating the strings files using genstrings.sh, this will produce '.pending' files, that contain
the files that are yet to be translated.

Args:
localization_bundle_path (str): The path to the localization bundle.


def __call__(self, environ, start_response):

        start_response('200 OK', [('Content-type', 'text/plain')])
        self.last_request_uri = wsgiref.util.request_uri(environ)
        return [self._success_message.encode('utf-8')]

WSGI Callable.

Args:
environ (Mapping[str, Any]): The WSGI environment.
start_response (Callable[str, list]): The WSGI start_response
callable.

Returns:
Iterable[bytes]: The response body.


def flipcheck(content):

    punct =
    tamperdict = str.maketrans('', '', punct)
    tamperproof = content.translate(tamperdict)

    if "(╯°□°）╯︵" in tamperproof:

        if "┻┻" in tamperproof:

            length = 0
            for letter in content:
                if letter == "━":
                    length += 1.36
                elif letter == "─":
                    length += 1
                elif letter == "-":
                    length += 0.50

            putitback = "┬"

            for i in range(int(length)):
                putitback += "─"

            putitback += "┬ ノ( ゜-゜ノ)"

            return putitback

        else:

            flipdict = str.maketrans(
                'abcdefghijklmnopqrstuvwxyzɐqɔpǝɟbɥıظʞןɯuodbɹsʇnʌʍxʎz😅🙃😞😟😠😡☹🙁😱😨😰😦😧😢😓😥😭',
                'ɐqɔpǝɟbɥıظʞןɯuodbɹsʇnʌʍxʎzabcdefghijklmnopqrstuvwxyz😄🙂🙂🙂🙂🙂🙂😀😀🙂😄🙂🙂😄😄😄😁'
            )

            flipstart = content.index('︵')
            flipped = content[flipstart+1:]
            flipped = str.lower(flipped).translate(flipdict)

            putitback = ''.join(list(reversed(list(flipped))))

            putitback += "ノ( ゜-゜ノ)"

            return putitback
    else:
        return False

Checks a string for anger and soothes said anger

Args:
content (str): The message to be flipchecked

Returns:
putitback (str): The righted table or text


def get_metalpdb_info(metalpdb_lig_file):

    pdb_metals = ['CU', 'ZN', 'MN', 'FE', 'MG', 'CO', 'SE', 'YB', 'SF4', 'FES', 'F3S', 'NI', 'FE2']

    coordination_number = 0
    endogenous_ligands = []
    exogenous_ligands = []

    ss = StructProp(ident='metalpdb', structure_path=metalpdb_lig_file, file_type='pdb')

    chain_id = op.basename(metalpdb_lig_file)[5]
    metal_id = (op.basename(metalpdb_lig_file).split('_')[2], op.basename(metalpdb_lig_file).split('_')[3])

    for r in ss.parse_structure().first_model.get_residues():
        return_id = (r.get_id(), r.get_resname())

        if r.get_id()[0] != ' ':
            if not r.resname.strip() in pdb_metals and r.resname != 'HOH':

                exogenous_ligands.append(return_id)
        else:
            endogenous_ligands.append(return_id)

        for a in r.get_atom():
            if not a.element in pdb_metals:
                coordination_number += 1

    infodict = {metal_id: {'endogenous_ligands' : endogenous_ligands,
                           'exogenous_ligands'  : exogenous_ligands,
                           'coordination_number': coordination_number}}

    return chain_id, infodict

Parse a MetalPDB .lig file and return a tuple of the chain ID it represents, along with metal binding information.

Args:
metalpdb_lig_file (str): Path to .lig file

Returns:
tuple: (str, dict) of the chain ID and the parsed metal binding site information


def create_html_from_fragment(tag):
    try:
        assert isinstance(tag, bs4.element.Tag)
    except AssertionError:
        raise TypeError
    try:
        assert (tag.find_all('body') == [])
    except AssertionError:
        raise ValueError
    soup = BeautifulSoup('', 'html.parser')
    soup.body.append(tag)
    return soup

Creates full html tree from a fragment. Assumes that tag should be wrapped in a body and is currently not

Args:
tag: a bs4.element.Tag

Returns:"
bs4.element.Tag: A bs4 tag representing a full html document


def repository_blob(self, sha, **kwargs):

        path = '/projects/%s/repository/blobs/%s' % (self.get_id(), sha)
        return self.manager.gitlab.http_get(path, **kwargs)

Return a file by blob SHA.

Args:
sha(str): ID of the blob
**kwargs: Extra options to send to the server (e.g. sudo)

Raises:
GitlabAuthenticationError: If authentication is not correct
GitlabGetError: If the server failed to perform the request

Returns:
dict: The blob content and metadata


def add_unref(self, timestamp: int) -> None:
    self._unref_times.append(timestamp)

Adds an unref to this tensor with the specified timestamp.

Args:
timestamp:  Timestamp of object unreference as an integer.


def run_scratch(self, path_to_scratch, num_cores=1, outname=None, outdir=None, force_rerun=False):

        if not outname:
            outname = self.project_name
        if not outdir:
            outdir = ''

        outname = op.join(outdir, outname)

        self.out_sspro = '{}.ss'.format(outname)
        self.out_sspro8 = '{}.ss8'.format(outname)
        self.out_accpro = '{}.acc'.format(outname)
        self.out_accpro20 = '{}.acc20'.format(outname)

        ssbio.utils.command_runner(
            shell_command='{} {} {} {}'.format(path_to_scratch, self.seq_file, outname, num_cores),
            force_rerun_flag=force_rerun, outfile_checker='{}.ss'.format(outname))

Run SCRATCH on the sequence_file that was loaded into the class.

Args:
path_to_scratch: Path to the SCRATCH executable, run_SCRATCH-1D_predictors.sh
outname: Prefix to name the output files
outdir: Directory to store the output files
force_rerun: Flag to force rerunning of SCRATCH even if the output files exist

Returns:


def _post(self, url, data, scope):

        self._create_session(scope)
        response = self.session.post(url, data=data)
        return response.status_code, response.text

Make a POST request using the session object to a Degreed endpoint.

Args:
url (str): The url to send a POST request to.
data (str): The json encoded payload to POST.
scope (str): Must be one of the scopes Degreed expects:
- `CONTENT_PROVIDER_SCOPE`
- `COMPLETION_PROVIDER_SCOPE`


def extract_changelog_items(text, tags):

    patterns = {x['header']: tag_re(x['tag']) for x in tags}
    items = {x['header']: [] for x in tags}
    curr_tag = None
    curr_text = ''

    for line in text.splitlines():
        if not line.strip():
            if curr_tag is not None:
                items[curr_tag].append(curr_text)
                curr_text = ''
            curr_tag = None

        for tag in tags:
            m = patterns[tag['header']].match(line)
            if m:
                if curr_tag is not None:
                    items[curr_tag].append(curr_text)
                    curr_text = ''

                curr_tag = tag['header']
                line = m.group('text')
                break

        if curr_tag is not None:
            curr_text = '{} {}'.format(curr_text.strip(), line.strip()).strip()

    if curr_tag is not None:
        items[curr_tag].append(curr_text)

    return items

Extract all tagged items from text.

Args:
text (str):
Text to extract the tagged items from. Each tagged item is a
paragraph that starts with a tag. It can also be a text list item.

Returns:
tuple[list[str], list[str], list[str]]:
A tuple of `(features, changes, fixes)` extracted from the given
text.

The tagged items are usually features/changes/fixes but it can be configured
through `pelconf.yaml`.


def initialize_from_assignments(assignments, k, max_assign_weight=0.75):
    cells = len(assignments)
    init_W = np.zeros((k, cells))
    for (i, a) in enumerate(assignments):
        init_W[(a, i)] = max_assign_weight
        for a2 in range(k):
            if (a2 != a):
                init_W[(a2, i)] = ((1 - max_assign_weight) / (k - 1))
    return (init_W / init_W.sum(0))

Creates a weight initialization matrix from Poisson clustering assignments.

Args:
assignments (array): 1D array of integers, of length cells
k (int): number of states/clusters
max_assign_weight (float, optional): between 0 and 1 - how much weight to assign to the highest cluster. Default: 0.75

Returns:
init_W (array): k x cells


def ParseContainersTable(self, parser_mediator, database=None, table=None, **unused_kwargs):
    if (database is None):
        raise ValueError('Missing database value.')
    if (table is None):
        raise ValueError('Missing table value.')
    for esedb_record in table.records:
        if parser_mediator.abort:
            break
        record_values = self._GetRecordValues(parser_mediator, table.name, esedb_record)
        event_data = MsieWebCacheContainersEventData()
        event_data.container_identifier = record_values.get('ContainerId', None)
        event_data.directory = record_values.get('Directory', None)
        event_data.name = record_values.get('Name', None)
        event_data.set_identifier = record_values.get('SetId', None)
        timestamp = record_values.get('LastScavengeTime', None)
        if timestamp:
            date_time = dfdatetime_filetime.Filetime(timestamp=timestamp)
            event = time_events.DateTimeValuesEvent(date_time, 'Last Scavenge Time')
            parser_mediator.ProduceEventWithEventData(event, event_data)
        timestamp = record_values.get('LastAccessTime', None)
        if timestamp:
            date_time = dfdatetime_filetime.Filetime(timestamp=timestamp)
            event = time_events.DateTimeValuesEvent(date_time, definitions.TIME_DESCRIPTION_LAST_ACCESS)
            parser_mediator.ProduceEventWithEventData(event, event_data)
        container_identifier = record_values.get('ContainerId', None)
        container_name = record_values.get('Name', None)
        if ((not container_identifier) or (not container_name)):
            continue
        table_name = 'Container_{0:d}'.format(container_identifier)
        esedb_table = database.get_table_by_name(table_name)
        if (not esedb_table):
            parser_mediator.ProduceExtractionWarning('Missing table: {0:s}'.format(table_name))
            continue
        self._ParseContainerTable(parser_mediator, esedb_table, container_name)

Parses the Containers table.

Args:
parser_mediator (ParserMediator): mediates interactions between parsers
and other components, such as storage and dfvfs.
database (Optional[pyesedb.file]): ESE database.
table (Optional[pyesedb.table]): table.

Raises:
ValueError: if the database or table value is missing.


def profile_update(self, profile):
    if (profile.get('install_json') is None):
        print('{}{}Missing install_json parameter for profile {}.'.format(c.Style.BRIGHT, c.Fore.YELLOW, profile.get('profile_name')))
    self.profile_update_args_v2(profile)
    self.profile_update_args_v3(profile)
    self.profile_update_schema(profile)

Update an existing profile with new parameters or remove deprecated parameters.

Args:
profile (dict): The dictionary containting the profile settings.


def exponential(x):
    return ops.exp(x)

Exponential activation function.

Args:
x: Input tensor.


def ensure_dir_path(self, path, relative=False):

        if not relative:
            rel_path = self.relpath(path)
        else:
            rel_path = path

        if self.is_locator(rel_path, relative=True):
            path = path.rstrip('/')

        elif rel_path:
            path = path.rstrip('/') + '/'

        return path

Ensure the path is a dir path.

Should end with '/' except for schemes and locators.

Args:
path (str): Path or URL.
relative (bool): Path is relative to current root.

Returns:
path: dir path


def get_items_for_config_file_output(self, source_to_settings,
                                         parsed_namespace):

        config_file_items = OrderedDict()
        for source, settings in source_to_settings.items():
            if source == _COMMAND_LINE_SOURCE_KEY:
                _, existing_command_line_args = settings['']
                for action in self._actions:
                    config_file_keys = self.get_possible_config_keys(action)
                    if config_file_keys and not action.is_positional_arg and \
                        already_on_command_line(existing_command_line_args,
                                                action.option_strings):
                        value = getattr(parsed_namespace, action.dest, None)
                        if value is not None:
                            if isinstance(value, bool):
                                value = str(value).lower()
                            config_file_items[config_file_keys[0]] = value

            elif source == _ENV_VAR_SOURCE_KEY:
                for key, (action, value) in settings.items():
                    config_file_keys = self.get_possible_config_keys(action)
                    if config_file_keys:
                        value = getattr(parsed_namespace, action.dest, None)
                        if value is not None:
                            config_file_items[config_file_keys[0]] = value
            elif source.startswith(_CONFIG_FILE_SOURCE_KEY):
                for key, (action, value) in settings.items():
                    config_file_items[key] = value
            elif source == _DEFAULTS_SOURCE_KEY:
                for key, (action, value) in settings.items():
                    config_file_keys = self.get_possible_config_keys(action)
                    if config_file_keys:
                        value = getattr(parsed_namespace, action.dest, None)
                        if value is not None:
                            config_file_items[config_file_keys[0]] = value
        return config_file_items

Converts the given settings back to a dictionary that can be passed
to ConfigFormatParser.serialize(..).

Args:
source_to_settings: the dictionary described in parse_known_args()
parsed_namespace: namespace object created within parse_known_args()
Returns:
an OrderedDict where keys are strings and values are either strings
or lists


def save(tiff_filename, numpy_data):

    tiff_filename = os.path.expanduser(tiff_filename)

    if type(numpy_data) is str:
        fp = open(png_filename, "wb")
        fp.write(numpy_data)
        fp.close()
        return png_filename

    try:
        img = tiff.imsave(tiff_filename, numpy_data)
    except Exception as e:
        raise ValueError("Could not save TIFF file {0}.".format(tiff_filename))

    return tiff_filename

Export a numpy array to a TIFF file.

Arguments:
tiff_filename:  A filename to which to save the TIFF data
numpy_data:     The numpy array to save to TIFF

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


def _ReadParserPresetValues(self, preset_definition_values):
    if (not preset_definition_values):
        raise errors.MalformedPresetError('Missing preset definition values.')
    name = preset_definition_values.get('name', None)
    if (not name):
        raise errors.MalformedPresetError('Invalid preset definition missing name.')
    parsers = preset_definition_values.get('parsers', None)
    if (not parsers):
        raise errors.MalformedPresetError('Invalid preset definition missing parsers.')
    parser_preset = ParserPreset(name, parsers)
    for operating_system_values in preset_definition_values.get('operating_systems', []):
        operating_system = self._ReadOperatingSystemArtifactValues(operating_system_values)
        parser_preset.operating_systems.append(operating_system)
    return parser_preset

Reads a parser preset from a dictionary.

Args:
preset_definition_values (dict[str, object]): preset definition values.

Returns:
ParserPreset: a parser preset.

Raises:
MalformedPresetError: if the format of the preset definition is not set
or incorrect, or the preset of a specific operating system has already
been set.


def compute_inv_covariance(L_aug, Y, k, p):
    return np.linalg.inv(compute_covariance(L_aug, Y, k, p))

Given label matrix L and labels Y, compute the covariance.

Args:
L: (np.array) [n, d] The augmented (indicator) label matrix
Y: (np.array int) [n] The true labels in {1,...,k}


def enhance_pubmed_annotations(pubmed: Mapping[str, Any]) -> Mapping[str, Any]:

    text = pubmed["title"] + pubmed["abstract"]

    annotations = {}

    for nsarg in pubmed["annotations"]:
        url = f'{config["bel_api"]["servers"]["api_url"]}/terms/{url_path_param_quoting(nsarg)}'
        log.info(f"URL: {url}")
        r = get_url(url)
        log.info(f"Result: {r}")
        new_nsarg = ""
        if r and r.status_code == 200:
            term = r.json()
            new_nsarg = bel_utils.convert_nsarg(term["id"], decanonicalize=True)

            pubmed["annotations"][nsarg]["name"] = term["name"]
            pubmed["annotations"][nsarg]["label"] = term["label"]
            pubmed["annotations"][nsarg]["entity_types"] = list(
                set(
                    pubmed["annotations"][nsarg]["entity_types"]
                    + term.get("entity_types", [])
                )
            )
            pubmed["annotations"][nsarg]["annotation_types"] = list(
                set(
                    pubmed["annotations"][nsarg]["annotation_types"]
                    + term.get("annotation_types", [])
                )
            )

        if new_nsarg != nsarg:
            annotations[new_nsarg] = copy.deepcopy(pubmed["annotations"][nsarg])
        else:
            annotations[nsarg] = copy.deepcopy(pubmed["annotations"][nsarg])

    for nsarg in annotations:
        for idx, span in enumerate(annotations[nsarg]["spans"]):
            string = text[span["begin"] - 1 : span["end"] - 1]
            annotations[nsarg]["spans"][idx]["text"] = string

    pubmed["annotations"] = copy.deepcopy(annotations)

    return pubmed

Enhance pubmed namespace IDs

Add additional entity and annotation types to annotations
Use preferred id for namespaces as needed
Add strings from Title, Abstract matching Pubtator BioConcept spans

NOTE - basically duplicated code with bel_api:api.services.pubmed

Args:
pubmed

Returns:
pubmed object


def set_server_def_retries(retries):
    context().set_server_def_retries(retries)

Set the number of retries to use when calling SetServerDef.

In cases where many servers run in high-preemption environments, jobs could
be preempted during startup and initial connection via SetServerDef. Retries
allow for more robust connection in these environments.

Args:
retries: int specifying the number of connection retries before failing.
Retries follow an exponential backoff waiting period with min value 1ms,
max value 10s, and exponent 1.3.


def create_sns_event(app_name, env, region, rules):

    session = boto3.Session(profile_name=env, region_name=region)
    sns_client = session.client('sns')

    topic_name = rules.get('topic')
    lambda_alias_arn = get_lambda_alias_arn(app=app_name, account=env, region=region)
    topic_arn = get_sns_topic_arn(topic_name=topic_name, account=env, region=region)
    protocol = 'lambda'

    statement_id = '{}_sns_{}'.format(app_name, topic_name)
    principal = 'sns.amazonaws.com'
    add_lambda_permissions(
        function=lambda_alias_arn,
        statement_id=statement_id,
        action='lambda:InvokeFunction',
        principal=principal,
        source_arn=topic_arn,
        env=env,
        region=region)

    sns_client.subscribe(TopicArn=topic_arn, Protocol=protocol, Endpoint=lambda_alias_arn)
    LOG.debug("SNS Lambda event created")

    LOG.info("Created SNS event subscription on topic %s", topic_name)

Create SNS lambda event from rules.

Args:
app_name (str): name of the lambda function
env (str): Environment/Account for lambda function
region (str): AWS region of the lambda function
rules (str): Trigger rules from the settings


def phase_crossings(ts, phi=0.0):
    ts = ts.squeeze()
    if (ts.ndim is not 1):
        raise ValueError('Currently can only use on single variable timeseries')
    ts = mod2pi((ts - phi))
    tsa = ts[0:(- 1)]
    tsb = ts[1:]
    p2 = (np.pi / 2)
    zc = (np.nonzero((((((tsa > (- p2)) & (tsa < 0)) & (tsb >= 0)) & (tsb < p2)) | ((((tsa < p2) & (tsa > 0)) & (tsb <= 0)) & (tsb > (- p2)))))[0] + 1)
    va = ts[(zc - 1)]
    vb = ts[zc]
    ct = (((np.abs(vb) * ts.tspan[(zc - 1)]) + (np.abs(va) * ts.tspan[zc])) / np.abs((vb - va)))
    if (ts[0] == 0.0):
        zc = np.r_[(np.array([0]), zc)]
        ct = np.r_[(np.array([ts.tspan[0]]), ct)]
    pc = (np.nonzero((((tsa > p2) & (tsb < (- p2))) | ((tsa < (- p2)) & (tsb > p2))))[0] + 1)
    splice = np.searchsorted(pc, zc)
    which_zc = np.r_[(np.array([0]), (np.nonzero((splice[0:(- 1)] - splice[1:]))[0] + 1))]
    if (ct.shape[0] is 0):
        return ct
    else:
        return ct[which_zc]

For a single variable timeseries representing the phase of an oscillator,
find the times at which the phase crosses angle phi,
with the condition that the phase must visit phi+pi between crossings.

(Thus if noise causes the phase to wander back and forth across angle phi
without the oscillator doing a full revolution, then this is recorded as
a single crossing event, giving the time of the earliest arrival.)

If the timeseries begins (or ends) exactly at phi, then time zero
(or the ending time) is also included as a crossing event,
so that the boundaries of the first and last oscillations are included.

If the actual crossing time falls between two time steps, linear
interpolation is used to estimate the crossing time.

Arguments:
ts: Timeseries (single variable)
The timeseries of an angle variable (radians)

phi (float): Critical phase angle (radians) at which to report crossings.

Returns:
array of float


def get_processors(processor_cat, prop_defs, data_attr=None):
    processor_defs = prop_defs.get(processor_cat, [])
    processor_list = []
    for processor in processor_defs:
        proc_class = PropertyProcessor[processor['rdf_type'][0]]
        processor_list.append(proc_class(processor.get('kds_params', [{}]), data_attr))
    return processor_list

reads the prop defs and adds applicable processors for the property

Args:
processor_cat(str): The category of processors to retreive
prop_defs: property defintions as defined by the rdf defintions
data_attr: the attr to manipulate during processing.

Returns:
list: a list of processors


def load(self, cellpy_file, parent_level="CellpyData"):

        try:
            self.logger.debug("loading cellpy-file (hdf5):")
            self.logger.debug(cellpy_file)
            new_datasets = self._load_hdf5(cellpy_file, parent_level)
            self.logger.debug("cellpy-file loaded")
        except AttributeError:
            new_datasets = []
            self.logger.warning("This cellpy-file version is not supported by"
                                "current reader (try to update cellpy).")

        if new_datasets:
            for dataset in new_datasets:
                self.datasets.append(dataset)
        else:

            self.logger.warning("Could not load")
            self.logger.warning(str(cellpy_file))

        self.number_of_datasets = len(self.datasets)
        self.status_datasets = self._validate_datasets()
        self._invent_a_name(cellpy_file)
        return self

Loads a cellpy file.

Args:
cellpy_file (path, str): Full path to the cellpy file.
parent_level (str, optional): Parent level


def format_info(variant, variant_type='snv'):

    observations = variant.get('observations',0)

    homozygotes = variant.get('homozygote')
    hemizygotes = variant.get('hemizygote')

    vcf_info = f"Obs={observations}"
    if homozygotes:
        vcf_info += f";Hom={homozygotes}"
    if hemizygotes:
        vcf_info += f";Hem={hemizygotes}"

    if variant_type == 'sv':
        end = int((variant['end_left'] + variant['end_right'])/2)

        vcf_info += f";SVTYPE={variant['sv_type']};END={end};SVLEN={variant['length']}"

    return vcf_info

Format the info field for SNV variants

Args:
variant(dict)
variant_type(str): snv or sv

Returns:
vcf_info(str): A VCF formated info field


def default(self, obj):
    if isinstance(obj, datetime):
        return obj.isoformat()
    if issubclass(obj.__class__, Enum.__class__):
        return obj.value
    to_json = getattr(obj, 'to_json', None)
    if to_json:
        out = obj.to_json()
        if issubclass(obj.__class__, Model):
            out.update({'__type': obj.__class__.__name__})
        return out
    return JSONEncoder.default(self, obj)

Default object encoder function

Args:
obj (:obj:`Any`): Object to be serialized

Returns:
JSON string


def umask(self, new_mask):

        if not is_int_type(new_mask):
            raise TypeError('an integer is required')
        old_umask = self.filesystem.umask
        self.filesystem.umask = new_mask
        return old_umask

Change the current umask.

Args:
new_mask: (int) The new umask value.

Returns:
The old umask.

Raises:
TypeError: if new_mask is of an invalid type.


def write_int8(self, value, little_endian=True):

        if little_endian:
            endian = "<"
        else:
            endian = ">"
        return self.pack('%sb' % endian, value)

Pack the value as a signed byte and write 1 byte to the stream.

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

Returns:
int: the number of bytes written.


def absent(name):

    ret = {'name': name, 'changes': {}, 'result': False, 'comment': ''}

    comment_bridge_deleted = 'Bridge {0} deleted.'.format(name)
    comment_bridge_notdeleted = 'Unable to delete bridge: {0}.'.format(name)
    comment_bridge_notexists = 'Bridge {0} does not exist.'.format(name)
    changes_bridge_deleted = {name: {'old': 'Bridge {0} exists.'.format(name),
                                     'new': 'Bridge {0} deleted.'.format(name),
                                     }
                              }

    bridge_exists = __salt__['openvswitch.bridge_exists'](name)

    if __opts__['test']:
        if not bridge_exists:
            ret['result'] = True
            ret['comment'] = comment_bridge_notexists
        else:
            ret['result'] = None
            ret['comment'] = comment_bridge_deleted

        return ret

    if not bridge_exists:
        ret['result'] = True
        ret['comment'] = comment_bridge_notexists
    else:
        bridge_delete = __salt__['openvswitch.bridge_delete'](name)
        if bridge_delete:
            ret['result'] = True
            ret['comment'] = comment_bridge_deleted
            ret['changes'] = changes_bridge_deleted
        else:
            ret['result'] = False
            ret['comment'] = comment_bridge_notdeleted

    return ret

Ensures that the named bridge does not exist, eventually deletes it.

Args:
name: The name of the bridge.


def downsample(data, percent):
    n_genes = data.shape[0]
    n_cells = data.shape[1]
    new_data = data.copy()
    total_count = float(data.sum())
    to_remove = (total_count * percent)
    cell_sums = data.sum(0).astype(float)
    cell_gene_probs = (data / cell_sums)
    cell_probs = np.array((cell_sums / total_count)).flatten()
    cells_selected = np.random.multinomial(to_remove, pvals=cell_probs)
    for (i, num_selected) in enumerate(cells_selected):
        cell_gene = np.array(cell_gene_probs[(:, i)]).flatten()
        genes_selected = np.random.multinomial(num_selected, pvals=cell_gene)
        if sparse.issparse(data):
            genes_selected = sparse.csc_matrix(genes_selected).T
        new_data[(:, i)] -= genes_selected
    new_data[(new_data < 0)] = 0
    return new_data

downsample the data by removing a given percentage of the reads.

Args:
data: genes x cells array or sparse matrix
percent: float between 0 and 1


def read_header(self, file_handle, nextdata_offset=0):
    header = {'FCS format': file_handle.read(6)}
    file_handle.read(4)
    for field in ('text start', 'text end', 'data start', 'data end', 'analysis start', 'analysis end'):
        s = file_handle.read(8)
        try:
            field_value = int(s)
        except ValueError:
            field_value = 0
        header[field] = (field_value + nextdata_offset)
    for k in ('text start', 'text end'):
        if (header[k] == 0):
            raise ValueError(u'The FCS file "{}" seems corrupted. (Parser cannot locate information about the "{}" segment.)'.format(self.path, k))
        elif (header[k] > self._file_size):
            raise ValueError(u'The FCS file "{}" is corrupted. "{}" segment is larger than file size'.format(self.path, k))
        else:
            pass
    self._data_start = header['data start']
    self._data_end = header['data start']
    if ((header['analysis end'] - header['analysis start']) != 0):
        warnings.warn(u'There appears to be some information in the ANALYSIS segment of file {0}. However, it might not be read correctly.'.format(self.path))
    self.annotation['__header__'] = header

Read the header of the FCS file.

The header specifies where the annotation, data and analysis are located inside the binary
file.

Args:
file_handle: buffer containing FCS file.
nextdata_offset: byte offset of a set header from file start specified by $NEXTDATA


def _flatten_beam_dim(tensor):

  shape = _shape_list(tensor)
  shape[0] *= shape[1]
  shape.pop(1)
  return tf.reshape(tensor, shape)

Reshapes first two dimensions in to single dimension.

Args:
tensor: Tensor to reshape of shape [A, B, ...]

Returns:
Reshaped tensor of shape [A*B, ...]


def update_hash(a_hash, mv):

    if mv.labels:
        signing.add_dict_to_hash(a_hash, encoding.MessageToPyValue(mv.labels))
    money_value = mv.get_assigned_value(u'moneyValue')
    if money_value is not None:
        a_hash.update(b'\x00')
        a_hash.update(money_value.currencyCode.encode('utf-8'))

Adds ``mv`` to ``a_hash``

Args:
a_hash (`Hash`): the secure hash, e.g created by hashlib.md5
mv (:class:`MetricValue`): the instance to add to the hash


def CheckTaskToMerge(self, task):
    with self._lock:
        is_abandoned = (task.identifier in self._tasks_abandoned)
        is_processing = (task.identifier in self._tasks_processing)
        is_queued = (task.identifier in self._tasks_queued)
        if ((not is_queued) and (not is_processing) and (not is_abandoned)):
            raise KeyError('Status of task {0:s} is unknown.'.format(task.identifier))
        return (is_queued or is_processing or (is_abandoned and (not task.has_retry)))

Checks if the task should be merged.

Args:
task (Task): task.

Returns:
bool: True if the task should be merged.

Raises:
KeyError: if the task was not queued, processing or abandoned.


def timestamp(method='iso8601'):

    if method == 'iso8601':

        tz_hour = time.timezone
        utc_offset = str(tz_hour) if tz_hour < 0 else '+' + str(tz_hour)
        stamp = time.strftime('%Y-%m-%dT%H%M%S') + utc_offset
        return stamp
    else:
        raise ValueError('only iso8601 is accepted for now')

make an iso8601 timestamp

Args:
method (str): type of timestamp

Example:
>>> stamp = timestamp()
>>> print('stamp = {!r}'.format(stamp))
stamp = ...-...-...T...


def collapse_phenotypes(self, input_phenotype_labels, output_phenotype_label, verbose=True):
    if isinstance(input_phenotype_labels, str):
        input_phenotype_labels = [input_phenotype_labels]
    bad_phenotypes = (set(input_phenotype_labels) - set(self.phenotypes))
    if (len(bad_phenotypes) > 0):
        raise ValueError((('Error phenotype(s) ' + str(bad_phenotypes)) + ' are not in the data.'))
    data = self.copy()
    if (len(input_phenotype_labels) == 0):
        return data

    def _swap_in(d, inputs, output):
        overlap = set(d.keys()).intersection(inputs)
        if (len(overlap) == 0):
            return d
        keepers = [(k, v) for (k, v) in d.items() if (k not in inputs)]
        return dict((keepers + [(output_phenotype_label, max([d[x] for x in overlap]))]))
    data['phenotype_calls'] = data.apply((lambda x: _swap_in(x['phenotype_calls'], input_phenotype_labels, output_phenotype_label)), 1)

    def _set_label(d):
        vals = [k for (k, v) in d.items() if (v == 1)]
        return (np.nan if (len(vals) == 0) else vals[0])
    data['phenotype_label'] = data.apply((lambda x: _set_label(x['phenotype_calls'])), 1)
    return data

Rename one or more input phenotypes to a single output phenotype

Args:
input_phenotype_labels (list): A str name or list of names to combine
output_phenotype_label (list): A str name to change the phenotype names to
verbose (bool): output more details

Returns:
CellDataFrame: The CellDataFrame modified.


def track_metric(self, name, value, type=None, count=None, min=None, max=None, std_dev=None, properties=None):
    dataPoint = channel.contracts.DataPoint()
    dataPoint.name = (name or NULL_CONSTANT_STRING)
    dataPoint.value = (value or 0)
    dataPoint.kind = (type or channel.contracts.DataPointType.aggregation)
    dataPoint.count = count
    dataPoint.min = min
    dataPoint.max = max
    dataPoint.std_dev = std_dev
    data = channel.contracts.MetricData()
    data.metrics.append(dataPoint)
    if properties:
        data.properties = properties
    self.track(data, self._context)

Send information about a single metric data point that was captured for the application.

Args:
name (str). the name of the metric that was captured.\n
value (float). the value of the metric that was captured.\n
type (:class:`channel.contracts.DataPointType`). the type of the metric. (defaults to: :func:`channel.contracts.DataPointType.aggregation`)\n
count (int). the number of metrics that were aggregated into this data point. (defaults to: None)\n
min (float). the minimum of all metrics collected that were aggregated into this data point. (defaults to: None)\n
max (float). the maximum of all metrics collected that were aggregated into this data point. (defaults to: None)\n
std_dev (float). the standard deviation of all metrics collected that were aggregated into this data point. (defaults to: None)\n
properties (dict). the set of custom properties the client wants attached to this data item. (defaults to: None)


def get_cytoband_coord(chrom, pos):

    chrom = chrom.strip('chr')
    pos = int(pos)
    result = None
    logger.debug("Finding Cytoband for chrom:{0} pos:{1}".format(chrom, pos))
    if chrom in CYTOBANDS:
        for interval in CYTOBANDS[chrom][pos]:
            result = "{0}{1}".format(chrom, interval.data)

    return result

Get the cytoband coordinate for a position

Args:
chrom(str): A chromosome
pos(int): The position

Returns:
cytoband


def run_one_step(self, eig_init_vec_val, eig_num_iter_val, smooth_val,
                   penalty_val, learning_rate_val):

    step_feed_dict = {self.eig_init_vec_placeholder: eig_init_vec_val,
                      self.eig_num_iter_placeholder: eig_num_iter_val,
                      self.smooth_placeholder: smooth_val,
                      self.penalty_placeholder: penalty_val,
                      self.learning_rate: learning_rate_val}

    if self.params['eig_type'] == 'SCIPY':
      current_eig_vector, self.current_eig_val_estimate = self.get_scipy_eig_vec()
      step_feed_dict.update({
          self.eig_vec_estimate: current_eig_vector
      })
    elif self.params['eig_type'] == 'LZS':
      step_feed_dict.update({
          self.dual_object.m_min_vec_ph: self.dual_object.m_min_vec_estimate
      })

    self.sess.run(self.train_step, feed_dict=step_feed_dict)

    [
        _, self.dual_object.m_min_vec_estimate, self.current_eig_val_estimate
    ] = self.sess.run([
        self.proj_step,
        self.eig_vec_estimate,
        self.eig_val_estimate
    ], feed_dict=step_feed_dict)

    if self.current_step % self.params['print_stats_steps'] == 0:
      [self.current_total_objective, self.current_unconstrained_objective,
       self.dual_object.m_min_vec_estimate,
       self.current_eig_val_estimate,
       self.current_nu] = self.sess.run(
           [self.total_objective,
            self.dual_object.unconstrained_objective,
            self.eig_vec_estimate,
            self.eig_val_estimate,
            self.dual_object.nu], feed_dict=step_feed_dict)

      stats = {
          'total_objective':
              float(self.current_total_objective),
          'unconstrained_objective':
              float(self.current_unconstrained_objective),
          'min_eig_val_estimate':
              float(self.current_eig_val_estimate)
      }
      tf.logging.info('Current inner step: %d, optimization stats: %s',
                      self.current_step, stats)
      if self.params['stats_folder'] is not None:
        stats = json.dumps(stats)
        filename = os.path.join(self.params['stats_folder'],
                                str(self.current_step) + '.json')
        with tf.gfile.Open(filename) as file_f:
          file_f.write(stats)

    if self.current_step % self.params['projection_steps'] == 0 and self.current_unconstrained_objective < 0:
      nu = self.sess.run(self.dual_object.nu)
      dual_feed_dict = {
          self.dual_object.h_min_vec_ph: self.dual_object.h_min_vec_estimate
      }
      _, min_eig_val_h_lz = self.dual_object.get_lanczos_eig(compute_m=False, feed_dict=dual_feed_dict)
      projected_dual_feed_dict = {
          self.dual_object.projected_dual.nu: nu,
          self.dual_object.projected_dual.min_eig_val_h: min_eig_val_h_lz
      }
      if self.dual_object.projected_dual.compute_certificate(self.current_step, projected_dual_feed_dict):
        return True

    return False

Run one step of gradient descent for optimization.

Args:
eig_init_vec_val: Start value for eigen value computations
eig_num_iter_val: Number of iterations to run for eigen computations
smooth_val: Value of smoothness parameter
penalty_val: Value of penalty for the current step
learning_rate_val: Value of learning rate
Returns:
found_cert: True is negative certificate is found, False otherwise


async def complete_task(context, result):

    args = [get_task_id(context.claim_task), get_run_id(context.claim_task)]
    reversed_statuses = get_reversed_statuses(context)
    try:
        if result == 0:
            log.info("Reporting task complete...")
            response = await context.temp_queue.reportCompleted(*args)
        elif result != 1 and result in reversed_statuses:
            reason = reversed_statuses[result]
            log.info("Reporting task exception {}...".format(reason))
            payload = {"reason": reason}
            response = await context.temp_queue.reportException(*args, payload)
        else:
            log.info("Reporting task failed...")
            response = await context.temp_queue.reportFailed(*args)
        log.debug("Task status response:\n{}".format(pprint.pformat(response)))
    except taskcluster.exceptions.TaskclusterRestFailure as exc:
        if exc.status_code == 409:
            log.info("409: not reporting complete/failed.")
        else:
            raise

Mark the task as completed in the queue.

Decide whether to call reportCompleted, reportFailed, or reportException
based on the exit status of the script.

If the task has expired or been cancelled, we'll get a 409 status.

Args:
context (scriptworker.context.Context): the scriptworker context.

Raises:
taskcluster.exceptions.TaskclusterRestFailure: on non-409 error.


def Filter(fn, *args, **kwargs):
    if not callable(fn):
        raise TypeError('Filter can be used only with callable objects. Received %r instead.' % fn)
    wrapper = lambda x, *args, **kwargs: [x] if fn(x, *args, **kwargs) else []
    label = 'Filter(%s)' % ptransform.label_from_callable(fn)
    if hasattr(fn, '__name__'):
        wrapper.__name__ = fn.__name__
    fn_type_hints = typehints.decorators.IOTypeHints.from_callable(fn)
    if fn_type_hints is not None:
        fn_type_hints = fn_type_hints.with_output_types()
    type_hints = get_type_hints(fn).with_defaults(fn_type_hints)
    if type_hints.input_types is not None:
        wrapper = with_input_types(*type_hints.input_types[0], **type_hints.input_types[1])(wrapper)
    output_hint = type_hints.simple_output_type(label)
    if output_hint is None and get_type_hints(wrapper).input_types and get_type_hints(wrapper).input_types[0]:
        output_hint = get_type_hints(wrapper).input_types[0][0]
    if output_hint:
        wrapper = with_output_types(typehints.Iterable[_strip_output_annotations(output_hint)])(wrapper)
    wrapper._argspec_fn = fn
    pardo = FlatMap(wrapper, *args, **kwargs)
    pardo.label = label
    return pardo

:func:`Filter` is a :func:`FlatMap` with its callable filtering out
elements.

Filter accepts a function that keeps elements that return True, and filters
out the remaining elements.

Args:
fn (``Callable[..., bool]``): a callable object. First argument will be an
element.
*args: positional arguments passed to the transform callable.
**kwargs: keyword arguments passed to the transform callable.

Returns:
~apache_beam.pvalue.PCollection:
A :class:`~apache_beam.pvalue.PCollection` containing the
:func:`Filter` outputs.

Raises:
TypeError: If the **fn** passed as argument is not a callable.
Typical error is to pass a :class:`DoFn` instance which is supported only
for :class:`ParDo`.


def build_relative_position(query_size, key_size, bucket_size=-1, max_position=-1, device=None):
    q_ids = torch.arange(0, query_size, device=device)
    k_ids = torch.arange(0, key_size, device=device)
    rel_pos_ids = q_ids[:, None] - k_ids[None, :]
    if bucket_size > 0 and max_position > 0:
        rel_pos_ids = make_log_bucket_position(rel_pos_ids, bucket_size, max_position)
    rel_pos_ids = rel_pos_ids.to(torch.long)
    rel_pos_ids = rel_pos_ids[:query_size, :]
    rel_pos_ids = rel_pos_ids.unsqueeze(0)
    return rel_pos_ids

Build relative position according to the query and key

We assume the absolute position of query \(P_q\) is range from (0, query_size) and the absolute position of key
\(P_k\) is range from (0, key_size), The relative positions from query to key is \(R_{q \rightarrow k} = P_q -
P_k\)

Args:
query_size (int): the length of query
key_size (int): the length of key
bucket_size (int): the size of position bucket
max_position (int): the maximum allowed absolute position
device (`torch.device`): the device on which tensors will be created.

Return:
`torch.LongTensor`: A tensor with shape [1, query_size, key_size]


def __init__(self, coord, timer_interval_secs, target=None, args=None, kwargs=None):
    if not isinstance(coord, Coordinator):
        raise ValueError("'coord' argument must be a Coordinator: %s" % coord)
    super(LooperThread, self).__init__()
    self.daemon = True
    self._coord = coord
    self._timer_interval_secs = timer_interval_secs
    self._target = target
    if self._target:
        self._args = args or ()
        self._kwargs = kwargs or {}
    elif args or kwargs:
        raise ValueError("'args' and 'kwargs' argument require that you also pass 'target'")
    self._coord.register_thread(self)

Create a LooperThread.

Args:
coord: A Coordinator.
timer_interval_secs: Time boundaries at which to call Run(), or None
if it should be called back to back.
target: Optional callable object that will be executed in the thread.
args: Optional arguments to pass to `target` when calling it.
kwargs: Optional keyword arguments to pass to `target` when calling it.

Raises:
ValueError: If one of the arguments is invalid.


def nearest_neighbors(self, word, top_k=10):
    point = self[word]
    diff = (self.vectors - point)
    distances = np.linalg.norm(diff, axis=1)
    top_ids = distances.argsort()[1:(top_k + 1)]
    return [self.vocabulary.id_word[i] for i in top_ids]

Return the nearest k words to the given `word`.

Args:
word (string): single word.
top_k (integer): decides how many neighbors to report.

Returns:
A list of words sorted by the distances. The closest is the first.

Note:
L2 metric is used to calculate distances.


def load_pickled_model(filename, dirname=None):

    if dirname is None:
        pkg_filename = pkgutil.get_loader('dragnet').get_filename('dragnet')
        pkg_dirname = os.path.dirname(pkg_filename)
        dirname = os.path.join(pkg_dirname, 'pickled_models', model_path)
    filepath = os.path.join(dirname, filename)
    return joblib.load(filepath)

Load a pickled ``Extractor`` model from disk.

Args:
filename (str): Name of pickled model file under ``dirname``.
dirname (str): Name of directory on disk containing the pickled model.
If None, dragnet's default pickled model directory is used:
/path/to/dragnet/pickled_models/[PY_VERSION]_[SKLEARN_VERSION]

Returns:
:class:`dragnet.extractor.Extractor`


def start_vm(access_token, subscription_id, resource_group, vm_name):
    endpoint = ''.join([get_rm_endpoint(), '/subscriptions/', subscription_id, '/resourceGroups/', resource_group, '/providers/Microsoft.Compute/virtualMachines/', vm_name, '/start', '?api-version=', COMP_API])
    return do_post(endpoint, '', access_token)

Start a virtual machine.

Args:
access_token (str): A valid Azure authentication token.
subscription_id (str): Azure subscription id.
resource_group (str): Azure resource group name.
vm_name (str): Name of the virtual machine.

Returns:
HTTP response.


def _padded_shape_to_tensor(padded_shape, input_component_shape):
    try:
        padded_shape_as_shape = tensor_shape.as_shape(padded_shape)
        ret = ops.convert_to_tensor([dim if dim is not None else -1 for dim in padded_shape_as_shape.as_list()], dtype=dtypes.int64)
    except (TypeError, ValueError) as e:
        ret = ops.convert_to_tensor(padded_shape, preferred_dtype=dtypes.int64)
        if ret.shape.dims is not None and len(ret.shape.dims) != 1:
            raise ValueError(f'Padded shape {padded_shape} must be a `tf.int64` vector tensor, but its shape was {ret.shape}.') from e
        if ret.dtype != dtypes.int64:
            raise TypeError(f'Padded shape {padded_shape} must be a `tf.int64` vector tensor, but its element type was {ret.dtype.name}.') from e
        padded_shape_as_shape = tensor_util.constant_value_as_shape(ret)
    if not _is_padded_shape_compatible_with(padded_shape_as_shape, input_component_shape):
        raise ValueError(f'The padded shape {padded_shape_as_shape} is not compatible with the shape {input_component_shape} of the corresponding input component.')
    return ret

Converts `padded_shape` to a `tf.Tensor` representing that shape.

Args:
padded_shape: A shape-like object, which may be a `tf.TensorShape`, a Python
sequence, or a 1-D `tf.Tensor` of `tf.int64` elements.
input_component_shape: A `tf.TensorShape`, with which `padded_shape` must be
compatible.

Returns:
A 1-D `tf.Tensor` of `tf.int64` elements, representing `padded_shape`.

Raises:
ValueError: If `padded_shape` is not a shape or not compatible with
`input_component_shape`.
TypeError: If `padded_shape` is not convertible to a `tf.int64` tensor.


def env_problem(env_problem_name, **kwargs):
    ep_cls = Registries.env_problems[env_problem_name]
    ep = ep_cls()
    ep.initialize(**kwargs)
    return ep

Get and initialize the `EnvProblem` with the given name and batch size.

Args:
env_problem_name: string name of the registered env problem.
**kwargs: forwarded to env problem's initialize method.

Returns:
an initialized EnvProblem with the given batch size.


def get_host(self, retry_count=3):
    try:
        default_timeout_set = False
        if (not socket.getdefaulttimeout()):
            socket.setdefaulttimeout(self.timeout)
            default_timeout_set = True
        log.debug('Host query for {0}'.format(self.address_str))
        ret = socket.gethostbyaddr(self.address_str)
        if default_timeout_set:
            socket.setdefaulttimeout(None)
        results = namedtuple('get_host_results', 'hostname, aliaslist, ipaddrlist')
        return results(ret)
    except (socket.timeout, socket.error) as e:
        log.debug('Host query socket error: {0}'.format(e))
        if (retry_count > 0):
            log.debug('Host query retrying (count: {0})'.format(str(retry_count)))
            return self.get_host((retry_count - 1))
        else:
            raise HostLookupError('Host lookup failed for {0}.'.format(self.address_str))
    except:
        raise HostLookupError('Host lookup failed for {0}.'.format(self.address_str))

The function for retrieving host information for an IP address.

Args:
retry_count (:obj:`int`): The number of times to retry in case
socket errors, timeouts, connection resets, etc. are
encountered. Defaults to 3.

Returns:
namedtuple:

:hostname (str): The hostname returned mapped to the given IP
address.
:aliaslist (list): Alternate names for the given IP address.
:ipaddrlist (list): IPv4/v6 addresses mapped to the same hostname.

Raises:
HostLookupError: The host lookup failed.


def visit(self, node):

    method = 'visit_' + node.__class__.__name__
    if not hasattr(self, method):
      raise ValueError('Unknown node type: %s' % node.__class__.__name__)
    visitor = getattr(self, method)

    if anno.hasanno(node, 'active_in'):
      self.active_variables = anno.getanno(node, 'active_in')
    pri, adj = visitor(node)

    if isinstance(pri, gast.AST):
      anno.setdefaultanno(pri, 'adj', adj)
    else:
      for node in pri:
        anno.setdefaultanno(node, 'adj', adj)
    if isinstance(adj, gast.AST):
      anno.setdefaultanno(adj, 'pri', pri)
    else:
      for node in adj:
        anno.setdefaultanno(node, 'pri', pri)

    return pri, adj

Visit a node.

This method is largely modelled after the ast.NodeTransformer class.

Args:
node: The node to visit.

Returns:
A tuple of the primal and adjoint, each of which is a node or a list of
nodes.


def PopTask(self):
    try:
        (_, task) = heapq.heappop(self._heap)
    except IndexError:
        return None
    self._task_identifiers.remove(task.identifier)
    return task

Retrieves and removes the first task from the heap.

Returns:
Task: the task or None if the heap is empty.


def linear_set_layer(layer_size, inputs, context=None, activation_fn=tf.nn.relu, dropout=0.0, name=None):
    with tf.variable_scope(name, default_name='linear_set_layer', values=[inputs]):
        outputs = conv1d(inputs, layer_size, 1, activation=None, name='set_conv')
        if (context is not None):
            if (len(context.get_shape().as_list()) == 2):
                context = tf.expand_dims(context, axis=1)
            cont_tfm = conv1d(context, layer_size, 1, activation=None, name='cont_conv')
            outputs += cont_tfm
        if (activation_fn is not None):
            outputs = activation_fn(outputs)
        if (dropout != 0.0):
            outputs = tf.nn.dropout(outputs, (1.0 - dropout))
        return outputs

Basic layer type for doing funky things with sets.

Applies a linear transformation to each element in the input set.
If a context is supplied, it is concatenated with the inputs.
e.g. One can use global_pool_1d to get a representation of the set which
can then be used as the context for the next layer.

TODO: Add bias add (or control the biases used).

Args:
layer_size: Dimension to transform the input vectors to.
inputs: A tensor of shape [batch_size, sequence_length, input_dims]
containing the sequences of input vectors.
context: A tensor of shape [batch_size, context_dims] containing a global
statistic about the set.
activation_fn: The activation function to use.
dropout: Dropout probability.
name: name.

Returns:
Tensor of shape [batch_size, sequence_length, output_dims] containing the
sequences of transformed vectors.


def complete(self, stream):
    assert (not self.is_complete())
    self._marker.addInputPort(outputPort=stream.oport)
    self.stream.oport.schema = stream.oport.schema
    self._pending_schema._set(self.stream.oport.schema)
    stream.oport.operator._start_op = True

Complete the pending stream.

Any connections made to :py:attr:`stream` are connected to `stream` once
this method returns.

Args:
stream(Stream): Stream that completes the connection.


def square(x):
    return math_ops.square(x)

Element-wise square.

Args:
x: Tensor or variable.

Returns:
A tensor.


def __init__(self, cluster_resolver=None, communication_options=None):
    if communication_options is None:
        communication_options = collective_util.Options()
    super(CollectiveAllReduceStrategy, self).__init__(CollectiveAllReduceExtended(self, cluster_resolver=cluster_resolver, communication_options=communication_options))
    distribute_lib.distribution_strategy_gauge.get_cell('V2').set('MultiWorkerMirroredStrategy')
    distribute_lib.distribution_strategy_replica_gauge.get_cell('num_workers').set(self.extended._num_workers)
    distribute_lib.distribution_strategy_replica_gauge.get_cell('num_replicas_per_worker').set(self.extended._num_devices_per_worker)

Creates the strategy.

Args:
cluster_resolver: optional
`tf.distribute.cluster_resolver.ClusterResolver`. If `None`,
`tf.distribute.cluster_resolver.TFConfigClusterResolver` is used.
communication_options: optional
`tf.distribute.experimental.CommunicationOptions`. This configures the
default options for cross device communications. It can be overridden by
options provided to the communication APIs like
`tf.distribute.ReplicaContext.all_reduce`. See
`tf.distribute.experimental.CommunicationOptions` for details.


def inversion(origin=(0, 0, 0)):

        mat = -np.eye(4)
        mat[3, 3] = 1
        mat[0:3, 3] = 2 * np.array(origin)
        return SymmOp(mat)

Inversion symmetry operation about axis.

Args:
origin (3x1 array): Origin of the inversion operation. Defaults
to [0, 0, 0].

Returns:
SymmOp representing an inversion operation about the origin.


def __init__(self,
                 tensor: bk.TensorLike,
                 qubits: Qubits = None,
                 memory: Dict[Addr, Any] = None) -> None:

        if qubits is None:
            tensor = bk.astensorproduct(tensor)
            bits = bk.rank(tensor)
            qubits = range(bits)

        self.vec = QubitVector(tensor, qubits)
        self._memory = memory if memory is not None else {}

Create a new State from a tensor of qubit amplitudes

Args:
tensor: A vector or tensor of state amplitudes
qubits: A sequence of qubit names.
(Defaults to integer indices, e.g. [0, 1, 2] for 3 qubits)
memory: Classical memory.


def __init__(self, actions=None):

        super().__init__(InstructionType.OFPIT_WRITE_ACTIONS)
        self.actions = actions if actions else []

Create a InstructionWriteAction with the optional parameters below.

Args:
actions (:class:`~.actions.ListOfActions`):
Actions associated with OFPIT_WRITE_ACTIONS.


def reply(self, text):

        data = {'text': text, 'vchannel_id': self['vchannel_id']}
        if self.is_p2p():
            data['type'] = RTMMessageType.P2PMessage
            data['to_uid'] = self['uid']
        else:
            data['type'] = RTMMessageType.ChannelMessage
            data['channel_id'] = self['channel_id']
        return RTMMessage(data)

Replys a text message

Args:
text(str): message content

Returns:
RTMMessage


def taper_rate(p0, p1):
    return ((2 * abs((p0[COLS.R] - p1[COLS.R]))) / point_dist(p0, p1))

Compute the taper rate between points p0 and p1

Args:
p0, p1: iterables with first 4 components containing (x, y, z, r)

Returns:
The taper rate, defined as the absolute value of the difference in
the diameters of p0 and p1 divided by the euclidian distance
between them.


def profile_update_schema(profile):

        if profile.get('autoclear') is None:
            print(
                '{}{}Profile Update: Adding new "autoclear" parameter.'.format(
                    c.Style.BRIGHT, c.Fore.YELLOW
                )
            )
            profile['autoclear'] = True

        for validation in profile.get('validations') or []:
            if validation.get('data_type') is None:
                print(
                    '{}{}Profile Update: Adding new "data_type" parameter.'.format(
                        c.Style.BRIGHT, c.Fore.YELLOW
                    )
                )
                validation['data_type'] = 'redis'

        if profile.get('install_json') is not None and profile.get('script') is not None:
            print(
                '{}{}Removing deprecated "script" parameter.'.format(c.Style.BRIGHT, c.Fore.YELLOW)
            )
            profile.pop('script')

Update profile to latest schema.

Args:
profile (dict): The dictionary containting the profile settings.


def __init__(self, api_key: str, model: str, config: genai_types.GenerateContentConfig, output_dict: dict[EventTransition, content_api.ProcessorContentTypes | None], sensitivity: Optional[dict[EventTransition, int]]=None, max_images: int=5):
    self._client = genai.Client(api_key=api_key)
    self._model = model
    self._config = config
    if not config.response_schema:
        raise ValueError('Response schema is required for event detection.')
    self._sensitivity = sensitivity
    self._output_dict = {}
    self._init_output_dict(output_dict)
    self._last_transition = (START_STATE, START_STATE)
    self._transition_counter = (self._last_transition, 0)
    self._images = collections.deque[tuple[ProcessorPart, float]](maxlen=max_images)

Initializes the event detection processor.

Args:
api_key: The API key to use for the event detection model.
model: The model to use for the event detection.
config: The configuration to use for the event detection model. This
configuration should contain the response schema for the event detection
model.
output_dict: A dictionary of transitions between events to the output to
return when the transition is detected. A transition is a pair of event
names `(from_event_state, to_event_state)`, where `from_event_state` can
be the start state `START_STATE`, an event name, or the wild card `"*"`
to define all transitions from any state (including the start state) to
the event state. When the output is None, the transition is detected but
no output is returned.
sensitivity: A dictionary of transitions to the number of detection in a
row that should happen before the event detection processor sends a
detection output. By default, the sensitivity is 1 for a transition.
max_images: The maximum number of images to keep in the input stream.


def predict(self, df_data, graph=None, **kwargs):
    if (graph is None):
        return self.create_graph_from_data(df_data, **kwargs)
    elif isinstance(graph, nx.DiGraph):
        return self.orient_directed_graph(df_data, graph, **kwargs)
    elif isinstance(graph, nx.Graph):
        return self.orient_undirected_graph(df_data, graph, **kwargs)
    else:
        print('Unknown Graph type')
        raise ValueError

Orient a graph using the method defined by the arguments.

Depending on the type of `graph`, this function process to execute
different functions:

1. If ``graph`` is a ``networkx.DiGraph``, then ``self.orient_directed_graph`` is executed.
2. If ``graph`` is a ``networkx.Graph``, then ``self.orient_undirected_graph`` is executed.
3. If ``graph`` is a ``None``, then ``self.create_graph_from_data`` is executed.

Args:
df_data (pandas.DataFrame): DataFrame containing the observational data.
graph (networkx.DiGraph or networkx.Graph or None): Prior knowledge on the causal graph.

.. warning::
Requirement : Name of the nodes in the graph must correspond to the
name of the variables in df_data


async def get_mailbox(self, name: str, selected: SelectedMailbox = None) \
            -> Tuple[MailboxInterface, Optional[SelectedMailbox]]:

        ...

Retrieves a :class:`~pymap.interfaces.mailbox.MailboxInterface`
object corresponding to an existing mailbox owned by the user. Raises
an exception if the mailbox does not yet exist.

Args:
name: The name of the mailbox.
selected: If applicable, the currently selected mailbox name.

Raises:
:class:`~pymap.exceptions.MailboxNotFound`


def _GetApprovals(self,
                    approval_type,
                    offset,
                    count,
                    filter_func=None,
                    token=None):

    approvals_base_urn = aff4.ROOT_URN.Add("users").Add(
        token.username).Add("approvals").Add(approval_type)

    all_children = aff4.FACTORY.RecursiveMultiListChildren([approvals_base_urn])

    approvals_urns = []
    for subject, children in all_children:

      if children:
        continue
      approvals_urns.append(subject)

    approvals_urns.sort(key=lambda x: x.age, reverse=True)
    approvals = list(
        aff4.FACTORY.MultiOpen(
            approvals_urns,
            mode="r",
            aff4_type=aff4_security.Approval,
            age=aff4.ALL_TIMES,
            token=token))
    approvals_by_urn = {}
    for approval in approvals:
      approvals_by_urn[approval.symlink_urn or approval.urn] = approval

    cur_offset = 0
    sorted_approvals = []
    for approval_urn in approvals_urns:
      try:
        approval = approvals_by_urn[approval_urn]
      except KeyError:
        continue

      if filter_func is not None and not filter_func(approval):
        continue
      cur_offset += 1
      if cur_offset <= offset:
        continue
      if count and len(sorted_approvals) >= count:
        break
      sorted_approvals.append(approval)

    subjects_urns = [a.Get(a.Schema.SUBJECT) for a in approvals]
    subjects_by_urn = {}
    for subject in aff4.FACTORY.MultiOpen(subjects_urns, mode="r", token=token):
      subjects_by_urn[subject.urn] = subject

    return sorted_approvals, subjects_by_urn

Gets all approvals for a given user and approval type.

Args:
approval_type: The type of approvals to get.
offset: The starting index within the collection.
count: The number of items to return.
filter_func: A predicate function, returning True if a specific approval
should be included in the result and False otherwise.
token: The token identifying the user.

Returns:
A list of approvals of the given approval type.


def get_avro_schema_from_table_schema(schema):
    dict_table_schema = get_dict_table_schema(schema)
    return bigquery_avro_tools.get_record_schema_from_dict_table_schema('root', dict_table_schema)

Transform the table schema into an Avro schema.

Args:
schema (str, dict, ~apache_beam.io.gcp.internal.clients.bigquery.bigquery_v2_messages.TableSchema):
The TableSchema to convert to Avro schema. This can either be a dict or
string or in the TableSchema format.

Returns:
Dict[str, Any]: An Avro schema, which can be used by fastavro.


def zip_file(self, app_path, app_name, tmp_path):
    zip_file = os.path.join(app_path, self.args.outdir, app_name)
    zip_file_zip = '{}.zip'.format(zip_file)
    zip_file_tcx = '{}.tcx'.format(zip_file)
    shutil.make_archive(zip_file, 'zip', tmp_path, app_name)
    shutil.move(zip_file_zip, zip_file_tcx)
    self._app_packages.append(zip_file_tcx)
    self.package_data['package'].append({'action': 'App Package:', 'output': zip_file_tcx})

Zip the App with tcex extension.

Args:
app_path (str): The path of the current project.
app_name (str): The name of the App.
tmp_path (str): The temp output path for the zip.


def extend(self, table, keys=None):

        if keys:
            for k in keys:
                if k not in self._Header():
                    raise IndexError("Unknown key: '%s'", k)

        extend_with = []
        for column in table.header:
            if column not in self.header:
                extend_with.append(column)

        if not extend_with:
            return

        for column in extend_with:
            self.AddColumn(column)

        if not keys:
            for row1, row2 in zip(self, table):
                for column in extend_with:
                    row1[column] = row2[column]
            return

        for row1 in self:
            for row2 in table:
                for k in keys:
                    if row1[k] != row2[k]:
                        break
                else:
                    for column in extend_with:
                        row1[column] = row2[column]
                    break

Extends all rows in the texttable.

The rows are extended with the new columns from the table.

Args:
table: A texttable, the table to extend this table by.
keys: A set, the set of columns to use as the key. If None, the
row index is used.

Raises:
IndexError: If key is not a valid column name.


def write_journal(self, journal_file_path):

        with open(journal_file_path, "w") as jrn_file:
            jrn_file.write(self._journal_contents)

Write the constructed journal in to the provided file.

Args:
journal_file_path (str): full path to output journal file


def import_aliases(alias_source):
    alias_table = get_alias_table()
    if is_url(alias_source):
        alias_source = retrieve_file_from_url(alias_source)
        alias_table.read(alias_source)
        os.remove(alias_source)
    else:
        alias_table.read(alias_source)
    _commit_change(alias_table)

Import aliases from a file or an URL.

Args:
alias_source: The source of the alias. It can be a filepath or an URL.


def _prepare_feed_values(model, inputs, targets, sample_weights, mode):
    if model._distribution_strategy:
        if isinstance(inputs, (data_types.DatasetV1, data_types.DatasetV2)):
            inputs = distributed_training_utils_v1.get_iterator(inputs, model._distribution_strategy)

        def get_distributed_inputs():
            return distributed_training_utils_v1._prepare_feed_values(model, inputs, targets, sample_weights, mode)
        if context.executing_eagerly():
            return get_distributed_inputs
        else:
            return get_distributed_inputs()
    if isinstance(inputs, (data_types.DatasetV1, data_types.DatasetV2, iterator_ops.Iterator)):
        inputs, targets, sample_weights = model._standardize_user_data(inputs, extract_tensors_from_dataset=True)
    inputs = training_utils_v1.ModelInputs(inputs).as_list()
    targets = list(targets or [])
    sample_weights = list(sample_weights or [])
    ins = inputs + targets + sample_weights
    if mode == ModeKeys.TRAIN and (not isinstance(backend.symbolic_learning_phase(), int)):
        ins += [True]
    return ins

Prepare feed values to the model execution function.

Args:
model: Model to prepare feed values for.
inputs: List or dict of model inputs.
targets: Optional list of model targets.
sample_weights: Optional list of sample weight arrays.
mode: One of ModeKeys.TRAIN/ModeKeys.TEST/ModeKeys.PREDICT.

Returns:
Feed values for the model in the given mode.


def xray_driver_removed_handler(self, unused_channel, data):

        gcs_entries = ray.gcs_utils.GcsTableEntry.GetRootAsGcsTableEntry(
            data, 0)
        driver_data = gcs_entries.Entries(0)
        message = ray.gcs_utils.DriverTableData.GetRootAsDriverTableData(
            driver_data, 0)
        driver_id = message.DriverId()
        logger.info("Monitor: "
                    "XRay Driver {} has been removed.".format(
                        binary_to_hex(driver_id)))
        self._xray_clean_up_entries_for_driver(driver_id)

Handle a notification that a driver has been removed.

Args:
unused_channel: The message channel.
data: The message data.


def accept_alert(self, text=None, wait=None):
    wait = (wait or capybara.default_max_wait_time)
    with self.driver.accept_modal('alert', text=text, wait=wait):
        (yield)

Execute the wrapped code, accepting an alert.

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

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


def check_for_missing_options(config):

    for section_name, section in config:

        for option_name, option in section:

            if option.required and option.value is None:

                raise exc.MissingRequiredOption(
                    "Option {0} in namespace {1} is required.".format(
                        option_name,
                        section_name,
                    )
                )

    return config

Iter over a config and raise if a required option is still not set.

Args:
config (confpy.core.config.Configuration): The configuration object
to validate.

Raises:
MissingRequiredOption: If any required options are not set in the
configuration object.

Required options with default values are considered set and will not cause
this function to raise.


def condensed(network, state):
    result = []
    covered_nodes = set()
    for c in reversed(sorted(complexes(network, state))):
        if (not any(((n in covered_nodes) for n in c.subsystem.node_indices))):
            result.append(c)
            covered_nodes = (covered_nodes | set(c.subsystem.node_indices))
    return result

Return a list of maximal non-overlapping complexes.

Args:
network (Network): The |Network| of interest.
state (tuple[int]): The state of the network (a binary tuple).

Returns:
list[SystemIrreducibilityAnalysis]: A list of |SIA| for non-overlapping
complexes with maximal |big_phi| values.


def issubset(self, other):

        other = self._cast_to_frameset(other)
        if other is NotImplemented:
            return NotImplemented
        return self.items <= other.items

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

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

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


def turtle_to_texture(turtle_program, turn_amount=DEFAULT_TURN, initial_angle=DEFAULT_INITIAL_ANGLE, resolution=1):
    generator = branching_turtle_generator(turtle_program, turn_amount, initial_angle, resolution)
    return texture_from_generator(generator)

Makes a texture from a turtle program.

Args:
turtle_program (str): a string representing the turtle program; see the
docstring of `branching_turtle_generator` for more details
turn_amount (float): amount to turn in degrees
initial_angle (float): initial orientation of the turtle
resolution (int): if provided, interpolation amount for visible lines

Returns:
texture: A texture.