def parse_args(argv):
    parser = make_parser()
    args = parser.parse_args(argv)
    t = args.tool_args
    kythe_args = kythe.Args(corpus=t.kythe_corpus, root=t.kythe_root, path=t.kythe_path, skip_stdlib=t.skip_stdlib)
    return (args.all_args, kythe_args, args.pytype_opts)

Parse command line args.

Arguments:
argv: Raw command line args, typically sys.argv[1:]

Returns:
A tuple of (
parsed_args: argparse.Namespace,
kythe_args: kythe.Args,
pytype_options: pytype.config.Options)


def predict(self, x_test):

        if self.model:
            lengths = map(len, x_test)
            x_test = self.p.transform(x_test)
            y_pred = self.model.predict(x_test)
            y_pred = self.p.inverse_transform(y_pred, lengths)
            return y_pred
        else:
            raise OSError('Could not find a model. Call load(dir_path).')

Returns the prediction of the model on the given test data.

Args:
x_test : array-like, shape = (n_samples, sent_length)
Test samples.

Returns:
y_pred : array-like, shape = (n_smaples, sent_length)
Prediction labels for x.


def is_running(process):

	if os.name == 'nt':
		process_list = get_cmd_out(['tasklist', '/v'])
		return process in process_list

	else:
		process_list = get_cmd_out('ps axw | awk \'{print $5}\'')

		for i in process_list.split('\n'):

			if not i == 'COMMAND' or i.startswith('['):
				if i == process:
					return True

				elif os.path.basename(i) == process:

					return True

	return False

Check if process is running.

Check if the given process name is running or not.

Note:
On a Linux system, kernel threads (like	``kthreadd`` etc.)
are excluded.

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

Returns:
bool: Is the process running?


def mark_all_as_done(self, **kwargs):
    result = self.gitlab.http_post('/todos/mark_as_done', **kwargs)
    try:
        return int(result)
    except ValueError:
        return 0

Mark all the todos as done.

Args:
**kwargs: Extra options to send to the server (e.g. sudo)

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

Returns:
int: The number of todos maked done


def creationlog(base, package, stackdepth=_def_stackdepth):

    @staticmethod
    def wrapnew(cls, *argl, **argd):
        global _atdepth_new, _cstack_new, streamlining
        origstream = None
        if (not (decorating or streamlining)):
            (entry, _atdepth_new) = _pre_create(cls, _atdepth_new, stackdepth, *argl, **argd)
            _cstack_new.append(cls)
            fqdn = cls.__fqdn__
            if ((fqdn in _streamlines) and _streamlines[fqdn]):
                msg.std('Streamlining {}.'.format(fqdn), 2)
                origstream = streamlining
                streamlining = True
        try:
            if six.PY2:
                result = base.__old__(cls, *argl, **argd)
            elif (base.__old__ is object.__new__):
                result = base.__old__(cls)
            else:
                result = base.__old__(cls, *argl, **argd)
        except TypeError:
            import sys
            (xcls, xerr) = sys.exc_info()[0:2]
            referral = xerr.args[0].split()[(- 1)]
            if ('.__new__()' in referral):
                t = eval(referral.split('.')[0])
                result = t.__new__(cls, *argl, **argd)
            else:
                raise
                result = None
        if ((result is not None) and hasattr(cls, '__init__')):
            try:
                cls.__init__(result, *argl, **argd)
            except:
                print(cls, argl, argd)
                raise
        else:
            msg.err('Object initialize failed for {}.'.format(base.__name__))
        if (origstream is not None):
            streamlining = origstream
        if (not (decorating or streamlining)):
            _cstack_new.pop()
            if (len(_cstack_new) == 0):
                _atdepth_new = False
            _post_create(_atdepth_new, entry, result)
        return result
    return wrapnew

Decorator for wrapping the creation of class instances that are being logged
by acorn.

Args:
base: base class used to call __new__ for the construction.
package (str): name of (global) package the class belongs to.
stackdepth (int): if the calling stack is less than this depth, than
include the entry in the log; otherwise ignore it.


def points_random_3d(count, range_x=((- 10.0), 10.0), range_y=((- 10.0), 10.0), range_z=((- 10.0), 10.0), seed=None) -> VAO:
    random.seed(seed)

    def gen():
        for _ in range(count):
            (yield random.uniform(*range_x))
            (yield random.uniform(*range_y))
            (yield random.uniform(*range_z))
    data = numpy.fromiter(gen(), count=(count * 3), dtype=numpy.float32)
    vao = VAO('geometry:points_random_3d', mode=moderngl.POINTS)
    vao.buffer(data, '3f', ['in_position'])
    return vao

Generates random positions inside a confied box.

Args:
count (int): Number of points to generate

Keyword Args:
range_x (tuple): min-max range for x axis: Example (-10.0. 10.0)
range_y (tuple): min-max range for y axis: Example (-10.0. 10.0)
range_z (tuple): min-max range for z axis: Example (-10.0. 10.0)
seed (int): The random seed

Returns:
A :py:class:`demosys.opengl.vao.VAO` instance


def load_tf_sharded_weights(model, shard_files, ignore_mismatched_sizes=False, strict=False, _prefix=None):
    unexpected_keys = set()
    saved_keys = set()
    mismatched_keys = set()
    model_keys = set()
    model_layer_map = {}
    for i, k in enumerate(model.weights):
        layer_name = k.name
        if _prefix is not None and layer_name.startswith(_prefix):
            layer_name = layer_name[len(_prefix):]
            layer_name = layer_name.lstrip('/')
        if not ('model.' in layer_name or len(layer_name.split('/')) == 1):
            layer_name = '/'.join(layer_name.split('/')[1:])
        model_keys.add(layer_name)
        model_layer_map[layer_name] = i
    for shard_file in shard_files:
        saved_weight_names_set, unexpected_keys_set, mismatched_keys_set = load_tf_shard(model, model_layer_map, shard_file, ignore_mismatched_sizes=ignore_mismatched_sizes, _prefix=_prefix)
        saved_keys.update(saved_weight_names_set)
        unexpected_keys.update(unexpected_keys_set)
        mismatched_keys.update(mismatched_keys_set)
        gc.collect()
    missing_keys = model_keys - saved_keys
    if strict and (len(missing_keys) > 0 or len(unexpected_keys) > 0):
        error_message = f'Error(s) in loading state_dict for {model.__class__.__name__}'
        if len(missing_keys) > 0:
            str_missing_keys = ','.join([f'"{k}"' for k in missing_keys])
            error_message += f'\nMissing key(s): {str_missing_keys}.'
        if len(unexpected_keys) > 0:
            str_unexpected_keys = ','.join([f'"{k}"' for k in unexpected_keys])
            error_message += f'\nMissing key(s): {str_unexpected_keys}.'
        raise RuntimeError(error_message)
    return (missing_keys, unexpected_keys, mismatched_keys)

This is the same as `load_tf_weights` but for a sharded checkpoint. Detect missing and unexpected layers and load
the TF weights from the shard file accordingly to their names and shapes.

This load is performed efficiently: each checkpoint shard is loaded one by one in RAM and deleted after being
loaded in the model.

Args:
model (`keras.models.Model`): The model in which to load the checkpoint.
shard_files (`str` or `os.PathLike`): A list containing the sharded checkpoint names.
ignore_mismatched_sizes`bool`, *optional`, defaults to `True`):
Whether or not to ignore the mismatch between the sizes
strict (`bool`, *optional*, defaults to `True`):
Whether to strictly enforce that the keys in the model state dict match the keys in the sharded checkpoint.

Returns:
Three lists, one for the missing layers, another one for the unexpected layers, and a last one for the
mismatched layers.


def conversation(self, name=None, **kwargs):
    convo = Conversation(self, **kwargs)
    super().conversation(name, convo)
    return convo

Make a new conversation.

Arguments:
name: The key for the dictionary the conversation will be stored as
in conversations. If None the conversation will be stored as a
list instead. Mixing both types results in an error.
**kwargs: Keyword arguments to pass into the new conversation.
These accept the same arguments as Cleverbot.

Returns:
The new conversation.


def method(*args, **kwargs):
    assert (len(args) == 0)
    assert (len(kwargs) == 1)
    assert ('num_return_vals' in kwargs)
    num_return_vals = kwargs['num_return_vals']

    def annotate_method(method):
        method.__ray_num_return_vals__ = num_return_vals
        return method
    return annotate_method

Annotate an actor method.

.. code-block:: python

@ray.remote
class Foo(object):
@ray.method(num_return_vals=2)
def bar(self):
return 1, 2

f = Foo.remote()

_, _ = f.bar.remote()

Args:
num_return_vals: The number of object IDs that should be returned by
invocations of this actor method.


def GetContract(self, script_hash):

        if script_hash.ToBytes() in self._contracts.keys():
            return self._contracts[script_hash.ToBytes()]
        return None

Get contract for specified script_hash.

Args:
script_hash (UInt160): a bytearray (len 20).

Returns:
Contract: if a contract was found matching the provided script hash, otherwise None


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

    super(CelebaHQConfig, self).__init__(
        name="%d" % resolution,
        description=("CelebaHQ images in %d x %d resolution" %
                     (resolution, resolution)),
        **kwargs)
    self.resolution = resolution
    self.file_name = "data%dx%d.tar" % (resolution, resolution)

BuilderConfig for SQUAD.

Args:
resolution: Resolution of the image. Values supported: powers of 2 up to
1024.
**kwargs: keyword arguments forwarded to super.


def range(*args, prefix: str):
    return [NamedQubit((prefix + str(i))) for i in range(*args)]

Returns a range of NamedQubits.

The range returned starts with the prefix, and followed by a qubit for
each number in the range, e.g.:

NamedQubit.range(3, prefix="a") -> ["a1", "a2", "a3]
NamedQubit.range(2, 4, prefix="a") -> ["a2", "a3]

Args:
*args: Args to be passed to Python's standard range function.
prefix: A prefix for constructed NamedQubits.

Returns:
A list of NamedQubits.


def args_to_kwargs(base_type, removed_method=False, removed_args=None):

    def wrap(func):
        if removed_method:
            return func
        removed_arg_names = removed_args if removed_args is not None else []
        base_arg_spec = getfullargspec(unwrap(getattr(base_type, func.__name__)))
        base_arg_names = base_arg_spec.args
        all_possible_base_arg_names = base_arg_names + base_arg_spec.kwonlyargs
        beam_arg_names = getfullargspec(func).args
        if (not_found := (set(beam_arg_names) - set(all_possible_base_arg_names) - set(removed_arg_names))):
            raise TypeError(f'Beam definition of {func.__name__} has arguments that are not found in the base version of the function: {not_found}')

        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            if len(args) > len(base_arg_names):
                raise TypeError(f'{func.__name__} got too many positioned arguments.')
            for name, value in zip(base_arg_names, args):
                if name in kwargs:
                    raise TypeError("%s() got multiple values for argument '%s'" % (func.__name__, name))
                kwargs[name] = value
            if removed_args:
                for name in removed_args:
                    if name not in kwargs:
                        kwargs[name] = None
            return func(**kwargs)
        return wrapper
    return wrap

Convert all args to kwargs before calling the decorated function.

When applied to a function, this decorator creates a new function
that always calls the wrapped function with *only* keyword arguments. It
inspects the argspec for the identically-named method on `base_type` to
determine the name to use for arguments that are converted to keyword
arguments.

For internal use only. No backwards compatibility guarantees.

Args:
base_type: The pandas type of the method that this is trying to replicate.
removed_method: Whether this method has been removed in the running
Pandas version.
removed_args: If not empty, which arguments have been dropped in the
running Pandas version.


def tap_hold(self, x, y, duration=1.0):

        data = {'x': x, 'y': y, 'duration': duration}
        return self.http.post('/wda/touchAndHold', data=data)

Tap and hold for a moment

Args:
- x, y(int): position
- duration(float): seconds of hold time

[[FBRoute POST:@"/wda/touchAndHold"] respondWithTarget:self action:@selector(handleTouchAndHoldCoordinate:)],


def _get_object_by_name(self, object_endpoint, object_name, timeout=None):

        timeout = timeout or self._timeout
        resp = self._get(self._u(object_endpoint, object_name),
                         session=self._session, timeout=timeout)
        resp.raise_for_status()
        return resp.json()

generic function to get object (metadata, tag, ) by name from SignalFx.

Args:
object_endpoint (string): API endpoint suffix (e.g. 'v2/tag')
object_name (string): name of the object (e.g. 'jvm.cpu.load')

Returns:
dictionary of response


def count_divisors(n):

    if not isinstance(n, int):
        raise TypeError("Expecting a strictly positive integer")
    if n <= 0:
        raise ValueError("Expecting a strictly positive integer")

    number_of_divisors = 1
    remain = n

    for p in prime_generator():
        if p > n:
            return number_of_divisors

        exponent = 1
        while remain % p == 0:
            remain = remain
            exponent += 1
        number_of_divisors *= exponent

        if remain == 1:
            return number_of_divisors

Count the number of divisors of an integer n

Args:
n (int): strictly positive integer

Returns:
The number of distinct divisors of n

Raises:
TypeError: if n is not an integer
ValueError: if n is negative


def _block_orth(self, p1, p2):
    if p1.shape.as_list() != p2.shape.as_list():
        raise ValueError(f'The dimension of the matrices must be the same. Received p1.shape={p1.shape} and p2.shape={p2.shape}.')
    n = p1.shape.as_list()[0]
    kernel2x2 = {}
    eye = linalg_ops_impl.eye(n, dtype=self.dtype)
    kernel2x2[0, 0] = math_ops.matmul(p1, p2)
    kernel2x2[0, 1] = math_ops.matmul(p1, eye - p2)
    kernel2x2[1, 0] = math_ops.matmul(eye - p1, p2)
    kernel2x2[1, 1] = math_ops.matmul(eye - p1, eye - p2)
    return kernel2x2

Construct a 2 x 2 kernel.

Used to construct orthgonal kernel.

Args:
p1: A symmetric projection matrix.
p2: A symmetric projection matrix.

Returns:
A 2 x 2 kernel [[p1p2,         p1(1-p2)],
[(1-p1)p2, (1-p1)(1-p2)]].
Raises:
ValueError: If the dimensions of p1 and p2 are different.


def __str__(self):

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

Returns a string representation of the data event.

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

Returns:
A string representation of the data event.


def add_workflow_definitions(sbi_config: dict):
    registered_workflows = []
    for i in range(len(sbi_config['processing_blocks'])):
        workflow_config = sbi_config['processing_blocks'][i]['workflow']
        workflow_name = '{}:{}'.format(workflow_config['id'], workflow_config['version'])
        if (workflow_name in registered_workflows):
            continue
        workflow_definition = dict(id=workflow_config['id'], version=workflow_config['version'], stages=[])
        key = 'workflow_definitions:{}:{}'.format(workflow_config['id'], workflow_config['version'])
        DB.save_dict(key, workflow_definition, hierarchical=False)
        registered_workflows.append(workflow_name)

Add any missing SBI workflow definitions as placeholders.

This is a utility function used in testing and adds mock / test workflow
definitions to the database for workflows defined in the specified
SBI config.

Args:
sbi_config (dict): SBI configuration dictionary.


def _read_ipv4_options(self, size=None):
    counter = 0
    optkind = list()
    options = dict()
    while (counter < size):
        kind = self._read_unpack(1)
        opts = IPv4_OPT.get(kind)
        if (opts is None):
            len_ = (size - counter)
            counter = size
            options['Unknown'] = self._read_fileng(len_)
            break
        dscp = OPT_TYPE.get(kind)
        desc = dscp.name
        if opts[0]:
            byte = self._read_unpack(1)
            if byte:
                data = process_opt[opts[2]](self, byte, kind)
            else:
                data = dict(kind=kind, type=self._read_opt_type(kind), length=2, flag=True)
        else:
            byte = 1
            data = dict(kind=kind, type=self._read_opt_type(kind), length=1)
        counter += byte
        if (dscp in optkind):
            if isinstance(options[desc], tuple):
                options[desc] += (Info(data),)
            else:
                options[desc] = (Info(options[desc]), Info(data))
        else:
            optkind.append(dscp)
            options[desc] = data
        if (not kind):
            break
    if (counter < size):
        len_ = (size - counter)
        self._read_binary(len_)
    return (tuple(optkind), options)

Read IPv4 option list.

Positional arguments:
* size -- int, buffer size

Returns:
* tuple -- IPv4 option list
* dict -- extracted IPv4 option


def find_duplicates_in_array(array):
    duplicates = []
    non_duplicates = []
    if (len(array) != len(set(array))):
        for item in array:
            if (item not in non_duplicates):
                non_duplicates.append(item)
            elif ((item in non_duplicates) and (item not in duplicates)):
                duplicates.append(item)
    return duplicates

Runs through the array and returns the elements that contain
more than one duplicate

Args:
array: The array to check for duplicates.

Returns:
Array of the elements that are duplicates. Returns empty list if
there are no duplicates.


def get_figure(new_fig=True, subplot='111', params=None):

    _get_plt()

    if new_fig:
        fig = plt.figure()
    else:
        fig = plt.gcf()

    params = dict_if_none(params)

    if isinstance(subplot, (tuple, list)):
        ax = fig.add_subplot(*subplot, **params)
    else:
        ax = fig.add_subplot(subplot, **params)

    return fig, ax

Function to be used for viewing - plotting,
to initialize the matplotlib figure - axes.

Args:
new_fig(bool): Defines if a new figure will be created, if false current figure is used
subplot (tuple or matplolib subplot specifier string): Create axes with these parameters
params (dict): extra options passed to add_subplot()

Returns:
Matplotlib Figure and Axes


def summary(self, line_length=160, detailed=True, print_fn=None):
    if not self._converted:
        raise RuntimeError(f'Impossible to call `{self.__class__.__name__}.summary()` before calling {self.__class__.__name__}.convert()`.')
    if line_length < 160:
        raise ValueError(f'Invalid `line_length` value has been received: {line_length}. Minimum: 160.')
    if print_fn is None:
        print_fn = print
    columns = [('TRTEngineOP Name', 0.2), ('Device', 0.09), ('
    positions = [int(line_length * p) for _, p in columns]
    positions = np.cumsum(positions).tolist()
    headers = [h for h, _ in columns]
    _print_row(headers, positions, print_fn=print_fn)
    print_fn('=' * line_length)
    n_engines = 0
    n_ops_converted = 0
    n_ops_not_converted = 0
    graphdef = self._converted_func.graph.as_graph_def(add_shapes=True)
    trtengineops_dict = dict()
    for node in graphdef.node:
        if node.op != 'TRTEngineOp':
            n_ops_not_converted += 1
            continue
        else:
            trtengineops_dict[node.name] = node
            n_engines += 1
    for name, node in sorted(trtengineops_dict.items()):
        node_device = node.device.split('/')[-1]
        in_shapes = trt_utils.get_node_io_shapes(node, 'input_shapes')
        out_shapes = trt_utils.get_node_io_shapes(node, '_output_shapes')
        in_dtypes = trt_utils.get_trtengineop_io_dtypes(node, 'InT')
        out_dtypes = trt_utils.get_trtengineop_io_dtypes(node, 'OutT')
        in_nodes_count = trt_utils.get_trtengineop_io_nodes_count(node, 'InT')
        out_nodes_count = trt_utils.get_trtengineop_io_nodes_count(node, 'OutT')
        node_count, converted_ops_dict = trt_utils.get_trtengineop_node_op_count(graphdef, name)
        n_ops_converted += node_count
        if n_engines != 1:
            print_fn(f'\n{'-' * 40}\n')
        _print_row(fields=[name, node_device, node_count, in_nodes_count, out_nodes_count, in_dtypes, out_dtypes, in_shapes, out_shapes], positions=positions, print_fn=print_fn)
        if detailed:
            print_fn()
            for key, value in sorted(dict(converted_ops_dict).items()):
                print_fn(f'\t- {key}: {value}x')
    print_fn(f'\n{'=' * line_length}')
    print_fn(f'[*] Total number of TensorRT engines: {n_engines}')
    total_ops = n_ops_not_converted + n_ops_converted
    conversion_ratio = n_ops_converted / total_ops * 100
    print_fn(f'[*] % of OPs Converted: {conversion_ratio:.2f}% [{n_ops_converted}/{total_ops}]\n')

This method describes the results of the conversion by TF-TRT.

It includes information such as the name of the engine, the number of nodes
per engine, the input and output dtype, along with the input shape of each
TRTEngineOp.

Args:
line_length: Default line length when printing on the console. Minimum 160
characters long.
detailed: Whether or not to show the nodes inside each TRTEngineOp.
print_fn: Print function to use. Defaults to `print`. It will be called on
each line of the summary. You can set it to a custom function in order
to capture the string summary.

Raises:
RuntimeError: if the graph is not converted.


def MsgUser(msg):
    msg_tested_versions = ['xp', 'vista', '2008', '2003']
    msg_args = ['/c', '%SystemRoot%\\System32\\msg.exe', '*', '/TIME:0']
    host_version = platform.platform().lower()
    if (not msg):
        return ('Command not ran.', 'Empty message.', (- 1))
    else:
        msg_args.extend([msg])
    for version in msg_tested_versions:
        if (host_version.find(version) != (- 1)):
            res = client_utils_common.Execute('cmd', msg_args, time_limit=(- 1), bypass_whitelist=True)
            return res
    return ('', 'Command not available for this version.', (- 1))

Sends a message to a user.

Args:
msg: Message to be displaied to user.

Returns:
res which is a tuple of (stdout, stderr, exit_status, time_taken).


def top_kth_iterative(x, k):

    def next_x(cur_x, _):
        top_x = tf.reduce_max(cur_x, axis=(- 1), keep_dims=True)
        return (cur_x * to_float((cur_x < top_x)))
    fin_x = tf.foldl(next_x, tf.range((k - 1)), initializer=tf.stop_gradient(x), parallel_iterations=2, back_prop=False)
    return tf.stop_gradient(tf.reduce_max(fin_x, axis=(- 1), keep_dims=True))

Compute the k-th top element of x on the last axis iteratively.

This assumes values in x are non-negative, rescale if needed.
It is often faster than tf.nn.top_k for small k, especially if k < 30.
Note: this does not support back-propagation, it stops gradients!

Args:
x: a Tensor of non-negative numbers of type float.
k: a python integer.

Returns:
a float tensor of the same shape as x but with 1 on the last axis
that contains the k-th largest number in x.


def vectorial_decomp(self, symbols):
    try:
        symbols = [s.vec for s in symbols]
        N = sum(map((lambda s: len(s)), symbols))
        symbols_ = Vector(N)
        i = 0
        for v in symbols:
            for s in v:
                symbols_[i] = s
                i += 1
        symbols = symbols_
    except TypeError:
        pass
    return self.mba.vectorial_decomp(symbols, self.vec)

Compute the vectorial decomposition of the expression according to the given symbols.

symbols is a list that represents the input of the resulting
application. They are considerated as a flatten vector of bits.

Args:
symbols: TODO

Returns:
An :class:`pytanque.App` object

Example:
>>> mba = MBA(4)
>>> x = mba.var('x')
>>> y = mba.var('y')
>>> e = x^y^6
>>> e.vectorial_decomp([x,y])
App NL = Vec([
0,
0,
0,
0
])
AffApp matrix = Mat([
[1, 0, 0, 0, 1, 0, 0, 0]
[0, 1, 0, 0, 0, 1, 0, 0]
[0, 0, 1, 0, 0, 0, 1, 0]
[0, 0, 0, 1, 0, 0, 0, 1]
])
AffApp cst = Vec([
0,
1,
1,
0
])


def request(self, request_method, api_method, *args, **kwargs):
    url = self._build_url(api_method)
    resp = requests.request(request_method, url, *args, **kwargs)
    try:
        rv = resp.json()
    except ValueError:
        raise RequestFailedError(resp, 'not a json body')
    if (not resp.ok):
        raise RequestFailedError(resp, rv.get('error'))
    return rv

Perform a request.

Args:
request_method: HTTP method for this request.
api_method: API method name for this request.
*args: Extra arguments to pass to the request.
**kwargs: Extra keyword arguments to pass to the request.

Returns:
A dict contains the request response data.

Raises:
RequestFailedError: Raises when BearyChat's OpenAPI responses
with status code != 2xx


def must_exist(*components):
    _path = path(*components)
    if (not exists(_path)):
        raise File404(_path)
    return _path

Ensure path exists.

Arguments:
*components (str[]): Path components.

Returns:
str: File path.

Raises:
File404: If path does not exist.


def unwrap(tensor):

  while isinstance(tensor, (PrettyTensor, Loss)):
    tensor = tensor.tensor
  return tensor

Returns the underlying tensor if tensor is wrapped or tensor.

Args:
tensor: The tensor to unwrap.
Returns:
Tensor or if it is a pretty tensor, the unwrapped version.
Raises:
ValueError: if tensor holds a sequence.


def submit_job(self, job_config=None):

        job_id = self._delegator._submit_bundle(self, job_config)
        return self._instance.get_job(job_id)

Submit this Streams Application Bundle (sab file) to
its associated instance.

Args:
job_config(JobConfig): a job configuration overlay

Returns:
Job: Resulting job instance.


def log_cdf_laplace(x, name='log_cdf_laplace'):
    with tf.name_scope(name):
        x = tf.convert_to_tensor(value=x, name='x')
        lower_solution = ((- np.log(2.0)) + x)
        safe_exp_neg_x = tf.exp((- tf.abs(x)))
        upper_solution = tf.math.log1p(((- 0.5) * safe_exp_neg_x))
        return tf.where((x < 0.0), lower_solution, upper_solution)

Log Laplace distribution function.

This function calculates `Log[L(x)]`, where `L(x)` is the cumulative
distribution function of the Laplace distribution, i.e.

```L(x) := 0.5 * int_{-infty}^x e^{-|t|} dt```

For numerical accuracy, `L(x)` is computed in different ways depending on `x`,

```
x <= 0:
Log[L(x)] = Log[0.5] + x, which is exact

0 < x:
Log[L(x)] = Log[1 - 0.5 * e^{-x}], which is exact
```

Args:
x: `Tensor` of type `float32`, `float64`.
name: Python string. A name for the operation (default="log_ndtr").

Returns:
`Tensor` with `dtype=x.dtype`.

Raises:
TypeError: if `x.dtype` is not handled.


def extract_annotation(self, node, var, name, stack, allowed_type_params: set[str] | None=None):
    try:
        typ = abstract_utils.get_atomic_value(var)
    except abstract_utils.ConversionError:
        self.ctx.errorlog.ambiguous_annotation(self.ctx.vm.frames, None, name)
        return self.ctx.convert.unsolvable
    typ = self._process_one_annotation(node, typ, name, stack)
    if not typ:
        return self.ctx.convert.unsolvable
    if typ.formal and allowed_type_params is not None:
        allowed_type_params = allowed_type_params | self.get_callable_type_parameter_names(typ)
        if self.ctx.vm.frame.func and (isinstance(self.ctx.vm.frame.func.data, abstract.BoundFunction) or self.ctx.vm.frame.func.data.is_class_builder):
            allowed_type_params.add('typing.Self')
        illegal_params = []
        for x in self.get_type_parameters(typ):
            if not allowed_type_params.intersection([x.name, x.full_name]):
                illegal_params.append(x.name)
        if illegal_params:
            self._log_illegal_params(illegal_params, stack, typ, name)
            return self.ctx.convert.unsolvable
    return typ

Returns an annotation extracted from 'var'.

Args:
node: The current node.
var: The variable to extract from.
name: The annotated name.
stack: The frame stack.
allowed_type_params: Type parameters that are allowed to appear in the
annotation. 'None' means all are allowed. If non-None, the result of
calling get_callable_type_parameter_names on the extracted annotation is
also added to the allowed set.


def merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None):
    if (not isinstance(left, DataFrame)):
        raise ValueError('can not merge DataFrame with instance of type {}'.format(type(right)))
    return left.merge(right, how=how, on=on, left_on=left_on, right_on=right_on, left_index=left_index, right_index=right_index, sort=sort, suffixes=suffixes, copy=copy, indicator=indicator, validate=validate)

Database style join, where common columns in "on" are merged.

Args:
left: DataFrame.
right: DataFrame.
how: What type of join to use.
on: The common column name(s) to join on. If None, and left_on and
right_on  are also None, will default to all commonly named
columns.
left_on: The column(s) on the left to use for the join.
right_on: The column(s) on the right to use for the join.
left_index: Use the index from the left as the join keys.
right_index: Use the index from the right as the join keys.
sort: Sort the join keys lexicographically in the result.
suffixes: Add this suffix to the common names not in the "on".
copy: Does nothing in our implementation
indicator: Adds a column named _merge to the DataFrame with
metadata from the merge about each row.
validate: Checks if merge is a specific type.

Returns:
A merged Dataframe


def slice_hidden(x, hidden_size, num_blocks):
    (batch_size, latent_dim, _) = common_layers.shape_list(x)
    block_dim = (hidden_size
    x_sliced = tf.reshape(x, shape=[batch_size, latent_dim, num_blocks, block_dim])
    return x_sliced

Slice encoder hidden state under num_blocks.

Args:
x: Encoder hidden state of shape [batch_size, latent_dim, hidden_size].
hidden_size: Dimension of the latent space.
num_blocks: Number of blocks in DVQ.

Returns:
Sliced states of shape [batch_size, latent_dim, num_blocks, block_dim].


def readuntil(self, token, size=0):
    self.__append()
    i = self.buf.find(token, self.pos)
    if (i < 0):
        index = max((len(token) - 1), size)
        newpos = max((len(self.buf) - index), self.pos)
        data = self.buf[self.pos:newpos]
        self.pos = newpos
        self.__discard()
        return (False, data)
    newpos = (i + len(token))
    data = self.buf[self.pos:newpos]
    self.pos = newpos
    self.__discard()
    return (True, data)

Reads data from the FIFO until a token is encountered.

If no token is encountered as much data is read from the FIFO as
possible keeping in mind that the FIFO must retain enough data to
perform matches for the token across writes.

Args:
token: The token to read until.
size: The minimum amount of data that should be left in the FIFO.
This is only used if it is greater than the length of the
token.  When ommited this value will default to the length of
the token.

Returns: A tuple of (found, data) where found is a boolean indicating
whether the token was found, and data is all the data that could be
read from the FIFO.

Note: When a token is found the token is also read from the buffer and
returned in the data.


def decorator(wrapped_decorator):

    def helper(_func=None, **options):

        def outer_wrapper(func):

            @wrapping(func)
            def inner_wrapper(*args, **kwds):
                return wrapped_decorator(func, args, kwds, **options)
            return inner_wrapper
        if (_func is None):
            return outer_wrapper
        if options:
            raise TypeError('positional arguments not supported')
        return outer_wrapper(_func)
    helper.wrapped_decorator = wrapped_decorator
    return helper

Converts a function into a decorator that optionally accepts keyword
arguments in its declaration.

Example usage:
@utils.decorator
def decorator(func, args, kwds, op1=None):
... apply op1 ...
return func(*args, **kwds)

# Form (1), vanilla
@decorator
foo(...)
...

# Form (2), with options
@decorator(op1=5)
foo(...)
...

Args:
wrapped_decorator: A function that accepts positional args (func, args,
kwds) and any additional supported keyword arguments.

Returns:
A decorator with an additional 'wrapped_decorator' property that is set to
the original function.


def run_inference(examples, serving_bundle):
    batch_size = 64
    if (serving_bundle.estimator and serving_bundle.feature_spec):
        preds = serving_bundle.estimator.predict((lambda : tf.data.Dataset.from_tensor_slices(tf.parse_example([ex.SerializeToString() for ex in examples], serving_bundle.feature_spec)).batch(batch_size)))
        if serving_bundle.use_predict:
            preds_key = serving_bundle.predict_output_tensor
        elif (serving_bundle.model_type == 'regression'):
            preds_key = 'predictions'
        else:
            preds_key = 'probabilities'
        values = []
        for pred in preds:
            values.append(pred[preds_key])
        return common_utils.convert_prediction_values(values, serving_bundle)
    elif serving_bundle.custom_predict_fn:
        values = serving_bundle.custom_predict_fn(examples)
        return common_utils.convert_prediction_values(values, serving_bundle)
    else:
        return platform_utils.call_servo(examples, serving_bundle)

Run inference on examples given model information

Args:
examples: A list of examples that matches the model spec.
serving_bundle: A `ServingBundle` object that contains the information to
make the inference request.

Returns:
A ClassificationResponse or RegressionResponse proto.


def matmul(x1, x2):
    if any_symbolic_tensors((x1, x2)):
        return Matmul().symbolic_call(x1, x2)
    return backend.numpy.matmul(x1, x2)

Matrix product of two tensors.

- If both tensors are 1-dimensional, the dot product (scalar) is returned.
- If either tensor is N-D, N > 2, it is treated as a stack of matrices
residing in the last two indexes and broadcast accordingly.
- If the first tensor is 1-D, it is promoted to a matrix by prepending
a 1 to its dimensions. After matrix multiplication the prepended
1 is removed.
- If the second tensor is 1-D, it is promoted to a matrix by appending a 1
to its dimensions. After matrix multiplication the appended 1 is removed.

Args:
x1: First tensor.
x2: Second tensor.

Returns:
Output tensor, matrix product of the inputs.


def add_time_step(self, **create_time_step_kwargs):

    ts = time_step.TimeStep.create_time_step(**create_time_step_kwargs)
    assert isinstance(ts, time_step.TimeStep)
    self._time_steps.append(ts)

Creates a time-step and appends it to the list.

Args:
**create_time_step_kwargs: Forwarded to
time_step.TimeStep.create_time_step.


def local_set_state(self, device, state, id_override=None, type_override=None):
    if ALLOW_LOCAL_CONTROL:
        if (device.local_id() is not None):
            hub = HUBS.get(device.hub_id())
            if ((hub is None) or (hub['token'] is None)):
                return self.set_device_state(device, state, id_override, type_override)
        else:
            return self.set_device_state(device, state, id_override, type_override)
        _LOGGER.info('Setting local state')
        local_id = (id_override or device.local_id().split('.')[0])
        object_type = (type_override or device.object_type())
        LOCAL_API_HEADERS['Authorization'] = ('Bearer ' + hub['token'])
        url_string = 'https:
        try:
            arequest = requests.put(url_string, data=json.dumps(state), headers=LOCAL_API_HEADERS, verify=False, timeout=3)
        except requests.exceptions.RequestException:
            _LOGGER.error('Error sending local control request. Sending request online')
            return self.set_device_state(device, state, id_override, type_override)
        response_json = arequest.json()
        _LOGGER.debug('%s', response_json)
        temp_state = device.json_state
        for (key, value) in response_json['data']['last_reading'].items():
            temp_state['last_reading'][key] = value
        return temp_state
    else:
        return self.set_device_state(device, state, id_override, type_override)

Set device state via local API, and fall back to online API.

Args:
device (WinkDevice): The device the change is being requested for.
state (Dict): The state being requested.
id_override (String, optional): A device ID used to override the
passed in device's ID. Used to make changes on sub-devices.
i.e. Outlet in a Powerstrip. The Parent device's ID.
type_override (String, optional): Used to override the device type
when a device inherits from a device other than WinkDevice.
Returns:
response_json (Dict): The API's response in dictionary format


def get_elements_between_bands(self, band_i, band_j):
    if ((band_i < 1) or (band_i > self.nb_bands) or (band_j < 1) or (band_j > self.nb_bands)):
        raise ValueError('Band index out of bounds')
    return self.data[(:, (band_i - 1), (band_j - 1), :)]

Method returning a numpy array with elements

[cdum_x_real, cdum_x_imag, cdum_y_real, cdum_y_imag, cdum_z_real, cdum_z_imag]

between bands band_i and band_j (vasp 1-based indexing) for all kpoints.

Args:
band_i (Integer): Index of band i
band_j (Integer): Index of band j

Returns:
a numpy list of elements for each kpoint


def _get_anchor(module_to_name, fullname):

  if not _anchor_re.match(fullname):
    raise ValueError("'%s' is not a valid anchor" % fullname)
  anchor = fullname
  for module_name in module_to_name.values():
    if fullname.startswith(module_name + "."):
      rest = fullname[len(module_name)+1:]

      if len(anchor) > len(rest):
        anchor = rest
  return anchor

Turn a full member name into an anchor.

Args:
module_to_name: Dictionary mapping modules to short names.
fullname: Fully qualified name of symbol.

Returns:
HTML anchor string.  The longest module name prefix of fullname is
removed to make the anchor.

Raises:
ValueError: If fullname uses characters invalid in an anchor.


def decode_image_tokens(self, image_tokens: torch.Tensor):
    decoded_image = self.model.vqmodel.decode(image_tokens)
    decoded_image = decoded_image.permute(0, 2, 3, 1)
    return decoded_image

Decodes generated image tokens from language model to continuous pixel values
with VQGAN module via upsampling.
Args:
image_tokens (`torch.LongTensor` of shape `(batch_size, num_of_tokens)`):
The tensors corresponding to the input images.


def _bits_in_condition(self, cond):

        all_bits = []
        if cond is not None:
            all_bits.extend([(cond[0], j) for j in range(self.cregs[cond[0].name].size)])
        return all_bits

Return a list of bits in the given condition.

Args:
cond (tuple or None): optional condition (ClassicalRegister, int)

Returns:
list[(ClassicalRegister, idx)]: list of bits


def gaussian_pdf(std=10.0, mean=0.0):
    norm_const = 1.0

    def pdf(x):
        return ((norm_const * np.exp(((- 0.5) * (((x - mean) / std) ** 2)))) * np.sin(((np.pi / 180.0) * x)))
    norm_dev = quad(pdf, 0.0, 180.0)[0]
    norm_const /= norm_dev
    return pdf

Gaussian PDF for orientation averaging.

Args:
std: The standard deviation in degrees of the Gaussian PDF
mean: The mean in degrees of the Gaussian PDF.  This should be a number
in the interval [0, 180)

Returns:
pdf(x), a function that returns the value of the spherical Jacobian-
normalized Gaussian PDF with the given STD at x (degrees). It is
normalized for the interval [0, 180].


def _add_tag(self, tag):
    tags = self.data.get('tags', None)
    if tags:
        if (tag in [x['name'] for x in tags]):
            return False
    else:
        tags = list()
    tags.append({'name': tag})
    self.data['tags'] = tags
    return True

Add a tag

Args:
tag (str): Tag to add

Returns:
bool: True if tag added or False if tag already present


def fuzzUsufy(fDomains=None, fFuzzStruct=None):
    if (fFuzzStruct == None):
        fuzzingStructures = ['http:
    else:
        try:
            fuzzingStructures = fFuzzStruct.read().splitlines()
        except:
            print(('Usufy could NOT open the following file: ' + fFuzzStruct))
    res = {}
    lines = fDomains.read().splitlines()
    for l in lines:
        domain = l.split()[0]
        print((('Performing tests for' + domain) + '...'))
        nick = l.split()[1]
        possibleURL = []
        for struct in fuzzingStructures:
            urlToTry = struct.replace('<DOMAIN>', domain)
            test = urlToTry.replace('<USERNAME>', nick.lower())
            print((('Processing ' + test) + '...'))
            i3Browser = browser.Browser()
            try:
                html = i3Browser.recoverURL(test)
                if (nick in html):
                    possibleURL.append(test)
                    print(general.success('\tPossible usufy found!!!\n'))
            except:
                print('The resource could not be downloaded.')
        res[domain] = possibleURL
    print(json.dumps(res, indent=2))
    return res

Method to guess the usufy path against a list of domains or subdomains.

Args:
-----
fDomains: A list to strings containing the domains and (optionally) a
nick.
fFuzzStruct: A list to strings containing the transforms to be
performed.

Returns:
--------
dict: A dictionary of the form of `{"domain": "url"}`.


def update(self, force=False):

        if self.is_404 and not force:
            return 0

        if self._last_modified:
            headers = {'If-Modified-Since': self._last_modified}
        else:
            headers = None

        try:
            res = self._board._requests_session.get(self._api_url, headers=headers)
        except:

            return 0

        if res.status_code == 304:
            return 0

        elif res.status_code == 404:
            self.is_404 = True

            self._board._thread_cache.pop(self.id, None)
            return 0

        elif res.status_code == 200:

            if self.is_404:
                self.is_404 = False
                self._board._thread_cache[self.id] = self

            self.want_update = False
            self.omitted_images = 0
            self.omitted_posts = 0

            self._last_modified = res.headers['Last-Modified']
            posts = res.json()['posts']

            original_post_count = len(self.replies)
            self.topic = Post(self, posts[0])

            if self.last_reply_id and not force:
                self.replies.extend(Post(self, p) for p in posts if p['no'] > self.last_reply_id)
            else:
                self.replies[:] = [Post(self, p) for p in posts[1:]]

            new_post_count = len(self.replies)
            post_count_delta = new_post_count - original_post_count
            if not post_count_delta:
                return 0

            self.last_reply_id = self.replies[-1].post_number

            return post_count_delta

        else:
            res.raise_for_status()

Fetch new posts from the server.

Arguments:
force (bool): Force a thread update, even if thread has 404'd.

Returns:
int: How many new posts have been fetched.


def construct_graph(sakefile, settings):
    verbose = settings['verbose']
    sprint = settings['sprint']
    G = nx.DiGraph()
    sprint('Going to construct Graph', level='verbose')
    for target in sakefile:
        if (target == 'all'):
            continue
        if ('formula' not in sakefile[target]):
            for atomtarget in sakefile[target]:
                if (atomtarget == 'help'):
                    continue
                sprint("Adding '{}'".format(atomtarget), level='verbose')
                data_dict = sakefile[target][atomtarget]
                data_dict['parent'] = target
                G.add_node(atomtarget, **data_dict)
        else:
            sprint("Adding '{}'".format(target), level='verbose')
            G.add_node(target, **sakefile[target])
    sprint('Nodes are built\nBuilding connections', level='verbose')
    for node in G.nodes(data=True):
        sprint('checking node {} for dependencies'.format(node[0]), level='verbose')
        for (k, v) in node[1].items():
            if (v is None):
                node[1][k] = []
        if ('output' in node[1]):
            for (index, out) in enumerate(node[1]['output']):
                node[1]['output'][index] = clean_path(node[1]['output'][index])
        if ('dependencies' not in node[1]):
            continue
        sprint('it has dependencies', level='verbose')
        connects = []
        for (index, dep) in enumerate(node[1]['dependencies']):
            dep = os.path.normpath(dep)
            shrt = 'dependencies'
            node[1]['dependencies'][index] = clean_path(node[1][shrt][index])
    for node in G.nodes(data=True):
        connects = []
        if ('dependencies' not in node[1]):
            continue
        for dep in node[1]['dependencies']:
            matches = check_for_dep_in_outputs(dep, verbose, G)
            if (not matches):
                continue
            for match in matches:
                sprint('Appending {} to matches'.format(match), level='verbose')
                connects.append(match)
        if connects:
            for connect in connects:
                G.add_edge(connect, node[0])
    return G

Takes the sakefile dictionary and builds a NetworkX graph

Args:
A dictionary that is the parsed Sakefile (from sake.py)
The settings dictionary

Returns:
A NetworkX graph


def should_drop(self):
    if self._drop_if_none and self.value is None:
        return True
    if self._drop_if_default and self.value == self._default:
        return True
    return False

Return True if the item should be dropped, or False if it should not
be dropped. This depends on the drop_if_none, and drop_if_default calls.

Returns:
True or False; depending on whether the item should be dropped or kept.


def auto_convert_cell_no_flags(cell, units=None, parens_as_neg=True):
    units = (units if (units != None) else {})
    return auto_convert_cell(flagable=Flagable(), cell=cell, position=None, worksheet=0, flags={}, units=units, parens_as_neg=parens_as_neg)

Performs a first step conversion of the cell to check
it's type or try to convert if a valid conversion exists.
This version of conversion doesn't flag changes nor store
cell units.

Args:
units: The dictionary holder for cell units.
parens_as_neg: Converts numerics surrounded by parens to
negative values


def enrich_json_objects_by_object_type(request, value):

    time_start_globally = time()
    if isinstance(value, list):
        json = [x.to_json() if hasattr(x, "to_json") else x for x in value]
    else:
        if isinstance(value, dict):
            json = value
        else:
            json = value.to_json()
    objects, nested = _collect_json_objects(json, by='object_type')
    for enricher_info in _get_OBJECT_TYPE_ENRICHER_ORDER():
        if len(enricher_info['object_types']) > 0:
            enricher_objects = flatten([objects.get(object_type, []) for object_type in enricher_info['object_types']])
            enricher_nested = any([nested.get(object_type, False) for object_type in enricher_info['object_types']])
        else:
            enricher_objects = flatten(objects.values())
            enricher_nested = any(nested.values())
        if len(enricher_objects) > 0:
            time_start = time()
            enricher_info['enricher'](request, enricher_objects, enricher_nested)
            LOGGER.debug('enrichment "{}" took {} seconds'.format(enricher_info['enricher_name'], time() - time_start))
            if not enricher_info['pure']:

                objects, nested = _collect_json_objects(json, by='object_type')
    LOGGER.debug('The whole enrichment of json objects by their object_type took {} seconds.'.format(time() - time_start_globally))
    return json

Take the given value and start enrichment by object_type. The va

Args:
request (django.http.request.HttpRequest): request which is currently processed
value (dict|list|django.db.models.Model):
in case of django.db.models.Model object (or list of these
objects), to_json method is invoked

Returns:
dict|list


def handle_malformed_config(error: MalformedConfigError) -> ResponseReturnValue:
    return (DQMResponse(name='MalformedConfigError', description=str(error), code=400), 400)

DQM Malformed Config Response.

Args:
* error: Config error

Returns:
* DQMResponse for the error with a 400 status code


def start_range(self, line, membership):
    last = self._transitions[-1] if self._transitions else -1
    if line < last:
        raise ValueError('Line number less than previous start_range() call.')
    previous = len(self._transitions) % 2 == 1
    if membership == previous:
        return
    elif line == last:
        self._transitions.pop()
    else:
        self._transitions.append(line)

Start a range of lines that are either included/excluded from the set.

Args:
line: A line number.
membership: If True, lines >= line are included in the set (starting a
range), otherwise they are excluded (ending a range).

Raises:
ValueError: if line is less than that of a previous call to start_range().


def history(self, condition: Optional[Callable[['Origin'], bool]]=None) -> List['Origin']:
    condition = condition or (lambda o: True)
    current = self
    history = []
    while current is not None:
        if condition(current):
            history.append(current)
        current = getattr(current.source, 'sym_origin', None)
    history.reverse()
    return history

Returns a history of origins with an optional filter.

Args:
condition: An optional callable object with signature
(origin) -> should_list. If None, all origins will be listed.

Returns:
A list of filtered origin from the earliest (root) to the most recent.


def connect(self, db_uri, debug=False):
    kwargs = {'echo': debug, 'convert_unicode': True}
    if ('mysql' in db_uri):
        kwargs['pool_recycle'] = 3600
    elif (':
        logger.debug('detected sqlite path URI: {}'.format(db_uri))
        db_path = os.path.abspath(os.path.expanduser(db_uri))
        db_uri = 'sqlite:
    self.engine = create_engine(db_uri, **kwargs)
    logger.debug('connection established successfully')
    BASE.metadata.bind = self.engine
    self.session = scoped_session(sessionmaker(bind=self.engine))
    self.query = self.session.query
    return self

Configure connection to a SQL database.

Args:
db_uri (str): path/URI to the database to connect to
debug (Optional[bool]): whether to output logging information


def write_config(config, config_path=CONFIG_PATH):

    if not os.path.exists(config_path):
        os.makedirs(os.path.dirname(config_path))
    with open(config_path, 'w', encoding='utf-8') as f:
        config.write(f)

Write the config to the output path.
Creates the necessary directories if they aren't there.

Args:
config (configparser.ConfigParser): A ConfigParser.


def cylindrical_vert(script, radius=1.0, inside=True):
    if inside:
        function = 'sqrt(x^2+y^2)<={}'.format(radius)
    else:
        function = 'sqrt(x^2+y^2)>={}'.format(radius)
    vert_function(script, function=function)
    return None

Select all vertices within a cylindrical radius

Args:
radius (float): radius of the sphere
center_pt (3 coordinate tuple or list): center point of the sphere

Layer stack:
No impacts

MeshLab versions:
2016.12
1.3.4BETA


def GetFileEntryByPathSpec(self, path_spec):

    return encoded_stream_file_entry.EncodedStreamFileEntry(
        self._resolver_context, self, path_spec, is_root=True, is_virtual=True)

Retrieves a file entry for a path specification.

Args:
path_spec (PathSpec): a path specification.

Returns:
EncodedStreamFileEntry: a file entry or None if not available.


def __call__(self, *x_batch, **kwargs) -> Union[List, np.ndarray]:

        with self.graph.as_default():
            K.set_session(self.sess)
            return self._net.predict_on_batch(x_batch, **kwargs)

Predicts answers on batch elements.

Args:
instance: a batch to predict answers on


def json_to_entity(tc_data, value_fields, resource_type, resource_type_parent):
    if (not isinstance(tc_data, list)):
        tc_data = [tc_data]
    entity_array = []
    for d in tc_data:
        entity = {'id': d.get('id'), 'webLink': d.get('webLink')}
        values = []
        if ('summary' in d):
            values.append(d.get('summary'))
        else:
            for field in value_fields:
                if (d.get(field) is not None):
                    values.append(d.get(field))
        entity['value'] = ' : '.join(values)
        if (d.get('type') is not None):
            entity['type'] = d.get('type')
        else:
            entity['type'] = resource_type
        if (resource_type_parent in ['Indicator']):
            entity['confidence'] = d.get('confidence')
            entity['rating'] = d.get('rating')
            entity['threatAssessConfidence'] = d.get('threatAssessConfidence')
            entity['threatAssessRating'] = d.get('threatAssessRating')
            entity['dateLastModified'] = d.get('lastModified')
        if (resource_type_parent in ['Indicator', 'Group']):
            if ('owner' in d):
                entity['ownerName'] = d['owner']['name']
            else:
                entity['ownerName'] = d.get('ownerName')
            entity['dateAdded'] = d.get('dateAdded')
        if (resource_type_parent in ['Victim']):
            entity['ownerName'] = d.get('org')
        entity_array.append(entity)
    return entity_array

Convert ThreatConnect JSON response to a TCEntityArray.

.. Attention:: This method is subject to frequent changes.

Args:
tc_data (dictionary): Array of data returned from TC API call.
value_fields (list): Field names that contain the "value" data.
resource_type (string): The resource type of the tc_data provided.
resource_type_parent (string): The resource parent type of the tc_data provided.

Returns:
(list): A list representing a TCEntityArray.


def model_call_event(self) -> asyncio.Event:
    return self._model_call_event

Returns an event that is set when the wrapped processor has all parts.

The event is set when the wrapped processor has all the input parts and
is about to start generating the output.

The event starts in a cleared state when the first part of the input
stream is yielded. It is also cleared at the end of the wrappedprocessor,
when all the output parts have been yielded.

Its default value is unset and this event is set only for a short time
during the call.

Returns:
An event that is set when the model call is started, that is when all the
input parts have been sent to the wrapped processor.


def determine_git_ref(self, config):
    ref_config_keys = 0
    for i in ['commit', 'tag', 'branch']:
        if config.get(i):
            ref_config_keys += 1
    if (ref_config_keys > 1):
        raise ImportError("Fetching remote git sources failed: conflicting revisions (e.g. 'commit', 'tag', 'branch') specified for a package source")
    if config.get('commit'):
        ref = config['commit']
    elif config.get('tag'):
        ref = config['tag']
    else:
        ref = self.git_ls_remote(config['uri'], self.determine_git_ls_remote_ref(config))
    if ((sys.version_info[0] > 2) and isinstance(ref, bytes)):
        return ref.decode()
    return ref

Determine the ref to be used for 'git checkout'.

Args:
config (dict): git config dictionary

Returns:
str: A commit id or tag name


def get_ip_reports(self, ips):
    api_name = 'virustotal-ip-address-reports'
    (all_responses, ips) = self._bulk_cache_lookup(api_name, ips)
    responses = self._request_reports('ip', ips, 'ip-address/report')
    for (ip, response) in zip(ips, responses):
        if self._cache:
            self._cache.cache_value(api_name, ip, response)
        all_responses[ip] = response
    return all_responses

Retrieves the most recent VT info for a set of ips.

Args:
ips: list of IPs.
Returns:
A dict with the IP as key and the VT report as value.


def get_alignment_df(a_aln_seq, b_aln_seq, a_seq_id=None, b_seq_id=None):
    if (len(a_aln_seq) != len(b_aln_seq)):
        raise ValueError('Sequence lengths not equal - was an alignment run?')
    if (not a_seq_id):
        a_seq_id = 'a_seq'
    if (not b_seq_id):
        b_seq_id = 'b_seq'
    a_aln_seq = ssbio.protein.sequence.utils.cast_to_str(a_aln_seq)
    b_aln_seq = ssbio.protein.sequence.utils.cast_to_str(b_aln_seq)
    a_idx = 1
    b_idx = 1
    appender = []
    for (i, (a, b)) in enumerate(zip(a_aln_seq, b_aln_seq)):
        to_append = {}
        if ((a == b) and (a != '-') and (b != '-')):
            aa_flag = 'match'
        elif ((a != b) and (a == '-') and (b != '-')):
            aa_flag = 'insertion'
        elif ((a != b) and (a != '-') and (b == '-')):
            aa_flag = 'deletion'
        elif ((a != b) and (a != '-') and (b == 'X')):
            aa_flag = 'unresolved'
        elif ((a != b) and (b != '-') and (a == 'X')):
            aa_flag = 'unresolved'
        elif ((a != b) and (a != '-') and (b != '-')):
            aa_flag = 'mutation'
        to_append['id_a'] = a_seq_id
        to_append['id_b'] = b_seq_id
        to_append['type'] = aa_flag
        if ((aa_flag == 'match') or (aa_flag == 'unresolved') or (aa_flag == 'mutation')):
            to_append['id_a_aa'] = a
            to_append['id_a_pos'] = int(a_idx)
            to_append['id_b_aa'] = b
            to_append['id_b_pos'] = int(b_idx)
            a_idx += 1
            b_idx += 1
        if (aa_flag == 'deletion'):
            to_append['id_a_aa'] = a
            to_append['id_a_pos'] = int(a_idx)
            a_idx += 1
        if (aa_flag == 'insertion'):
            to_append['id_b_aa'] = b
            to_append['id_b_pos'] = int(b_idx)
            b_idx += 1
        appender.append(to_append)
    cols = ['id_a', 'id_b', 'type', 'id_a_aa', 'id_a_pos', 'id_b_aa', 'id_b_pos']
    alignment_df = pd.DataFrame.from_records(appender, columns=cols)
    alignment_df = alignment_df.fillna(value=np.nan)
    return alignment_df

Summarize two alignment strings in a dataframe.

Args:
a_aln_seq (str): Aligned sequence string
b_aln_seq (str): Aligned sequence string
a_seq_id (str): Optional ID of a_seq
b_seq_id (str): Optional ID of b_aln_seq

Returns:
DataFrame: a per-residue level annotation of the alignment


def find_gaps(self, index=False):

        return self.__find_incongruities(op=operator.lt, index=index)

Finds gaps in a striplog.

Args:
index (bool): If True, returns indices of intervals with
gaps after them.

Returns:
Striplog: A striplog of all the gaps. A sort of anti-striplog.


def write(data, file_name, worksheet_names=None):
    if re.search(XML_EXT_REGEX, file_name):
        return write_xml(data, file_name, worksheet_names=worksheet_names)
    elif re.search(XLSX_EXT_REGEX, file_name):
        return write_xlsx(data, file_name, worksheet_names=worksheet_names)
    elif re.search(XLS_EXT_REGEX, file_name):
        return write_xls(data, file_name, worksheet_names=worksheet_names)
    elif re.search(CSV_EXT_REGEX, file_name):
        return write_csv(data, file_name)
    else:
        return write_csv(data, file_name)

Writes 2D tables to file.

Args:
data: 2D list of tables/worksheets.
file_name: Name of the output file (determines type).
worksheet_names: A list of worksheet names (optional).


def _terminate_all(self, sig=None):
    sig = sig or getattr(signal, 'SIGKILL', signal.SIGTERM)
    for (task_type, task_id), p in self._processes.items():
        if p.exitcode is not None:
            logging.info('%s-%d has already exited. Not terminating.', task_type, task_id)
            continue
        try:
            os.kill(p.pid, sig)
            self._terminated.add((task_type, task_id))
            logging.info('%s-%d terminated with signal %r.', task_type, task_id, sig)
        except ProcessLookupError:
            logging.info('Attempting to kill %s-%d but it does not exist.', task_type, task_id)

Terminates all subprocesses.

The caller is required to hold self._process_lock.

Args:
sig: the signal used to terminate the process. The default is SIGKILL.


def poll_stack(self):

        logging.info('polling stack status, POLL_INTERVAL={}'.format(POLL_INTERVAL))
        time.sleep(POLL_INTERVAL)
        completed_states = [
            'CREATE_COMPLETE',
            'UPDATE_COMPLETE',
            'DELETE_COMPLETE'
        ]
        stack_name = self._config.get('environment', {}).get('stack_name', None)
        while True:
            try:
                response = self._cloudFormation.describe_stacks(StackName=stack_name)
                stack = response['Stacks'][0]
                current_status = stack['StackStatus']
                logging.info('current status of {}: {}'.format(stack_name, current_status))
                if current_status.endswith('COMPLETE') or current_status.endswith('FAILED'):
                    if current_status in completed_states:
                        return True
                    else:
                        return False

                time.sleep(POLL_INTERVAL)
            except ClientError as wtf:
                if str(wtf).find('does not exist') == -1:
                    logging.error('Exception caught in wait_for_stack(): {}'.format(wtf))
                    traceback.print_exc(file=sys.stdout)
                    return False
                else:
                    logging.info('{} is gone'.format(stack_name))
                    return True
            except Exception as wtf:
                logging.error('Exception caught in wait_for_stack(): {}'.format(wtf))
                traceback.print_exc(file=sys.stdout)
                return False

Spin in a loop while the Cloud Formation process either fails or succeeds

Args:
None

Returns:
Good or bad; True or False


def _GetClientIdFromQueue(q):

  split = q.Split()
  if not split or len(split) < 2:
    return None

  split = [s.lower() for s in split]

  str_client_id, tasks_marker = split

  if not str_client_id.startswith("c.") or tasks_marker != "tasks":
    return None

  str_client_id = "C" + str_client_id[1:]

  return str_client_id

Returns q's client id, if q is a client task queue, otherwise None.

Args:
q: rdfvalue.RDFURN

Returns:
string or None


def _ReadAttributeValueString(self, attribute_values_data, record_offset, attribute_values_data_offset, attribute_value_offset):
    if (attribute_value_offset == 0):
        return None
    data_type_map = self._GetDataTypeMap('keychain_string')
    file_offset = ((record_offset + attribute_values_data_offset) + attribute_value_offset)
    attribute_value_offset -= (attribute_values_data_offset + 1)
    attribute_value_data = attribute_values_data[attribute_value_offset:]
    try:
        string_attribute_value = self._ReadStructureFromByteStream(attribute_value_data, file_offset, data_type_map)
    except (ValueError, errors.ParseError) as exception:
        raise errors.ParseError('Unable to map string attribute value data at offset: 0x{0:08x} with error: {1!s}'.format(file_offset, exception))
    return string_attribute_value.string

Reads a string attribute value.

Args:
attribute_values_data (bytes): attribute values data.
record_offset (int): offset of the record relative to the start of
the file.
attribute_values_data_offset (int): offset of the attribute values data
relative to the start of the record.
attribute_value_offset (int): offset of the attribute relative to
the start of the record.

Returns:
str: string value or None if attribute value offset is not set.

Raises:
ParseError: if the attribute value cannot be read.


def get_occupation(self, atom_index, orbital):
    orbital_index = self.orbitals.index(orbital)
    return {spin: np.sum((d[(:, :, atom_index, orbital_index)] * self.weights[(:, None)])) for (spin, d) in self.data.items()}

Returns the occupation for a particular orbital of a particular atom.

Args:
atom_num (int): Index of atom in the PROCAR. It should be noted
that VASP uses 1-based indexing for atoms, but this is
converted to 0-based indexing in this parser to be
consistent with representation of structures in pymatgen.
orbital (str): An orbital. If it is a single character, e.g., s,
p, d or f, the sum of all s-type, p-type, d-type or f-type
orbitals occupations are returned respectively. If it is a
specific orbital, e.g., px, dxy, etc., only the occupation
of that orbital is returned.

Returns:
Sum occupation of orbital of atom.


def getUserCaPath(self, name):
    cert = self.getUserCert(name)
    if (cert is None):
        return None
    return self._getCaPath(cert)

Gets the path to the CA certificate that issued a given user keypair.

Args:
name (str): The name of the user keypair.

Examples:
Get the path to the CA cert which issue the cert for "myuser":

mypath = cdir.getUserCaPath('myuser')

Returns:
str: The path if exists.


def _configure_tls_parameters(parameters):

    cert = config.conf["tls"]["certfile"]
    key = config.conf["tls"]["keyfile"]
    if cert and key:
        _log.info(
            "Authenticating with server using x509 (certfile: %s, keyfile: %s)",
            cert,
            key,
        )
        parameters.credentials = pika.credentials.ExternalCredentials()
    else:
        cert, key = None, None

    if SSLOptions is None:
        parameters.ssl = True
        parameters.ssl_options = {
            "keyfile": key,
            "certfile": cert,
            "ca_certs": config.conf["tls"]["ca_cert"],
            "cert_reqs": ssl.CERT_REQUIRED,
            "ssl_version": ssl.PROTOCOL_TLSv1_2,
        }
    else:
        ssl_context = ssl.create_default_context()
        if config.conf["tls"]["ca_cert"]:
            try:
                ssl_context.load_verify_locations(cafile=config.conf["tls"]["ca_cert"])
            except ssl.SSLError as e:
                raise ConfigurationException(
                    'The "ca_cert" setting in the "tls" section is invalid ({})'.format(
                        e
                    )
                )
        ssl_context.options |= ssl.OP_NO_SSLv2
        ssl_context.options |= ssl.OP_NO_SSLv3
        ssl_context.options |= ssl.OP_NO_TLSv1
        ssl_context.options |= ssl.OP_NO_TLSv1_1
        ssl_context.verify_mode = ssl.CERT_REQUIRED
        ssl_context.check_hostname = True
        if cert and key:
            try:
                ssl_context.load_cert_chain(cert, key)
            except ssl.SSLError as e:
                raise ConfigurationException(
                    'The "keyfile" setting in the "tls" section is invalid ({})'.format(
                        e
                    )
                )
        parameters.ssl_options = SSLOptions(
            ssl_context, server_hostname=parameters.host
        )

Configure the pika connection parameters for TLS based on the configuration.

This modifies the object provided to it. This accounts for whether or not
the new API based on the standard library's SSLContext is available for
pika.

Args:
parameters (pika.ConnectionParameters): The connection parameters to apply
TLS connection settings to.


def new(self, injection_site_fn):
    return _InjectionContext(injection_site_fn, binding_stack=[], scope_id=scoping.UNSCOPED, is_scope_usable_from_scope_fn=self._is_scope_usable_from_scope_fn)

Creates a _InjectionContext.

Args:
injection_site_fn: the initial function being injected into
Returns:
a new empty _InjectionContext in the default scope


def ExtractEvents(self, parser_mediator, registry_key, **kwargs):

    values_dict = {}

    if registry_key.number_of_values > 0:
      for registry_value in registry_key.GetValues():
        value_name = registry_value.name or '(default)'

        if registry_value.DataIsString():
          value_string = '[{0:s}] {1:s}'.format(
              registry_value.data_type_string, registry_value.GetDataAsObject())

        elif registry_value.DataIsInteger():
          value_string = '[{0:s}] {1:d}'.format(
              registry_value.data_type_string, registry_value.GetDataAsObject())

        elif registry_value.DataIsMultiString():
          value_string = '[{0:s}] {1:s}'.format(
              registry_value.data_type_string, ''.join(
                  registry_value.GetDataAsObject()))

        else:
          value_string = '[{0:s}]'.format(registry_value.data_type_string)

        values_dict[value_name] = value_string

    event_data = windows_events.WindowsRegistryEventData()
    event_data.key_path = registry_key.path
    event_data.offset = registry_key.offset
    event_data.regvalue = values_dict
    event_data.urls = self.URLS

    event = time_events.DateTimeValuesEvent(
        registry_key.last_written_time, definitions.TIME_DESCRIPTION_WRITTEN)
    parser_mediator.ProduceEventWithEventData(event, event_data)

    if registry_key.number_of_subkeys == 0:
      error_string = 'Key: {0:s} missing subkeys.'.format(registry_key.path)
      parser_mediator.ProduceExtractionWarning(error_string)
      return

    for zone_key in registry_key.GetSubkeys():

      path = '{0:s}\\{1:s}'.format(
          registry_key.path, self._ZONE_NAMES[zone_key.name])

      values_dict = {}

      for value in zone_key.GetValues():

        if not value.name:
          continue

        if value.DataIsString():
          value_string = value.GetDataAsObject()

        elif value.DataIsInteger():
          value_integer = value.GetDataAsObject()
          if value.name in self._KNOWN_PERMISSIONS_VALUE_NAMES:
            value_string = self._CONTROL_VALUES_PERMISSIONS.get(
                value_integer, 'UNKNOWN')
          elif value.name == '1A00':
            value_string = self._CONTROL_VALUES_1A00.get(
                value_integer, 'UNKNOWN')
          elif value.name == '1C00':
            value_string = self._CONTROL_VALUES_1C00.get(
                value_integer, 'UNKNOWN')
          elif value.name == '1E05':
            value_string = self._CONTROL_VALUES_SAFETY.get(
                value_integer, 'UNKNOWN')
          else:
            value_string = '{0:d}'.format(value_integer)

        else:
          value_string = '[{0:s}]'.format(value.data_type_string)

        if len(value.name) == 4 and value.name != 'Icon':
          value_description = self._FEATURE_CONTROLS.get(value.name, 'UNKNOWN')
        else:
          value_description = self._FEATURE_CONTROLS.get(value.name, '')

        if value_description:
          feature_control = '[{0:s}] {1:s}'.format(
              value.name, value_description)
        else:
          feature_control = '[{0:s}]'.format(value.name)

        values_dict[feature_control] = value_string

      event_data = windows_events.WindowsRegistryEventData()
      event_data.key_path = path
      event_data.offset = zone_key.offset
      event_data.regvalue = values_dict
      event_data.urls = self.URLS

      event = time_events.DateTimeValuesEvent(
          zone_key.last_written_time, definitions.TIME_DESCRIPTION_WRITTEN)
      parser_mediator.ProduceEventWithEventData(event, event_data)

Extracts events from a Windows Registry key.

Args:
parser_mediator (ParserMediator): mediates interactions between parsers
and other components, such as storage and dfvfs.
registry_key (dfwinreg.WinRegistryKey): Windows Registry key.


def generate_support_dump(self, information, timeout=(- 1)):
    uri = '{}/support-dumps'.format(self.data['uri'])
    return self._helper.create(information, uri=uri, timeout=timeout)

Generates a support dump for the logical enclosure with the specified ID. A logical enclosure support dump
includes content for logical interconnects associated with that logical enclosure. By default, it also contains
appliance support dump content.

Args:
information (dict): Information to generate support dump.
timeout: Timeout in seconds. Wait for task completion by default. The timeout does not abort the operation
in OneView; it just stops waiting for its completion.

Returns:
dict: Support dump.


def bind(self, extension: Extension) -> 'DictMentor':

        if not Extension.is_valid_extension(extension):
            raise ValueError("Cannot bind extension due to missing interface requirements")
        self._extensions.append(extension)

        return self

Add any predefined or custom extension.

Args:
extension: Extension to add to the processor.

Returns:
The DictMentor itself for chaining.


def describe(self, version_name):

    version_yaml = yaml.safe_dump(self.get_version_details(version_name),
                                  default_flow_style=False)
    print(version_yaml)

Print information of a specified model.

Args:
version: the name of the version in short form, such as "v1".


def split(s, posix=True):
    if isinstance(s, six.binary_type):
        s = s.decode('utf-8')
    return shlex.split(s, posix=posix)

Split the string s using shell-like syntax.

Args:
s (str): String to split
posix (bool): Use posix split

Returns:
list of str: List of string parts


def oxide_type(structure, relative_cutoff=1.1, return_nbonds=False):

    ox_obj = OxideType(structure, relative_cutoff)
    if return_nbonds:
        return ox_obj.oxide_type, ox_obj.nbonds
    else:
        return ox_obj.oxide_type

Determines if an oxide is a peroxide/superoxide/ozonide/normal oxide

Args:
structure (Structure): Input structure.
relative_cutoff (float): Relative_cutoff * act. cutoff stipulates the
max distance two O atoms must be from each other.
return_nbonds (bool): Should number of bonds be requested?


def while_loop(self, context, step_method):
    logger.debug('starting')
    context['whileCounter'] = 0
    if ((self.stop is None) and (self.max is None)):
        logger.error(f'while decorator missing both max and stop.')
        raise PipelineDefinitionError('the while decorator must have either max or stop, or both. But not neither.')
    error_on_max = context.get_formatted_as_type(self.error_on_max, out_type=bool)
    sleep = context.get_formatted_as_type(self.sleep, out_type=float)
    if (self.max is None):
        max = None
        logger.info(f'while decorator will loop until {self.stop} evaluates to True at {sleep}s intervals.')
    else:
        max = context.get_formatted_as_type(self.max, out_type=int)
        if (max < 1):
            logger.info(f'max {self.max} is {max}. while only runs when max > 0.')
            logger.debug('done')
            return
        if (self.stop is None):
            logger.info(f'while decorator will loop {max} times at {sleep}s intervals.')
        else:
            logger.info(f'while decorator will loop {max} times, or until {self.stop} evaluates to True at {sleep}s intervals.')
    if (not poll.while_until_true(interval=sleep, max_attempts=max)(self.exec_iteration)(context=context, step_method=step_method)):
        if error_on_max:
            logger.error(f'exhausted {max} iterations of while loop, and errorOnMax is True.')
            if (self.stop and max):
                raise LoopMaxExhaustedError(f'while loop reached {max} and {self.stop} never evaluated to True.')
            else:
                raise LoopMaxExhaustedError(f'while loop reached {max}.')
        elif (self.stop and max):
            logger.info(f'while decorator looped {max} times, and {self.stop} never evaluated to True.')
        logger.debug('while loop done')
    else:
        logger.info(f'while loop done, stop condition {self.stop} evaluated True.')
    logger.debug('done')

Run step inside a while loop.

Args:
context: (pypyr.context.Context) The pypyr context. This arg will
mutate - after method execution will contain the new
updated context.
step_method: (method/function) This is the method/function that
will execute on every loop iteration. Signature is:
function(context)


def generate_output(line='0', short=None, name=None, value=None, is_parent=False, colorize=True):
    output = '{0}{1}{2}{3}{4}{5}{6}{7}\n'.format((LINES['{0}{1}'.format(line, ('C' if colorize else ''))] if (line in LINES.keys()) else ''), (COLOR_DEPTH[line] if (colorize and (line in COLOR_DEPTH)) else ''), ANSI['b'], (short if (short is not None) else (name if (name is not None) else '')), ('' if ((name is None) or (short is None)) else ' ({0})'.format(name)), ('' if ((name is None) and (short is None)) else ': '), (ANSI['end'] if colorize else ''), ('' if is_parent else value))
    return output

The function for formatting CLI output results.

Args:
line (:obj:`str`): The line number (0-4). Determines indentation.
Defaults to '0'.
short (:obj:`str`): The optional abbreviated name for a field.
See hr.py for values.
name (:obj:`str`): The optional name for a field. See hr.py for values.
value (:obj:`str`): The field data (required).
is_parent (:obj:`bool`): Set to True if the field value has sub-items
(dicts/lists). Defaults to False.
colorize (:obj:`bool`): Colorize the console output with ANSI colors.
Defaults to True.

Returns:
str: The generated output.


def run_using_threadpool(fn_to_execute, inputs, pool_size):
    if not hasattr(threading.current_thread(), '_children'):
        threading.current_thread()._children = weakref.WeakKeyDictionary()
    pool = ThreadPool(min(pool_size, len(inputs)))
    try:
        old_level = logging.getLogger().level
        return pool.map(fn_to_execute, inputs)
    finally:
        pool.terminate()
        logging.getLogger().setLevel(old_level)

For internal use only; no backwards-compatibility guarantees.

Runs the given function on given inputs using a thread pool.

Args:
fn_to_execute: Function to execute
inputs: Inputs on which given function will be executed in parallel.
pool_size: Size of thread pool.
Returns:
Results retrieved after executing the given function on given inputs.


def _GetPlistRootKey(self, file_entry):
    file_object = file_entry.GetFileObject()
    try:
        plist_file = plist.PlistFile()
        plist_file.Read(file_object)
    except IOError as exception:
        location = getattr(file_entry.path_spec, 'location', '')
        raise errors.PreProcessFail('Unable to read plist file: {0:s} with error: {1!s}'.format(location, exception))
    finally:
        file_object.close()
    return plist_file.root_key

Retrieves the root key of a plist file.

Args:
file_entry (dfvfs.FileEntry): file entry of the plist.

Returns:
dict[str, object]: plist root key.

Raises:
errors.PreProcessFail: if the preprocessing fails.


def cli_print(msg, color='', end=None, file=sys.stdout, logger=_LOG):
    if logger:
        logger.debug('-> {}'.format(msg))
    if CLI_QUIET:
        return
    if (end is None):
        end = _linesep_for_file(file)
    file.write('{color}{msg}{reset}{end}'.format(color=color, msg=msg, reset=colorama.Style.RESET_ALL, end=end))

Print the message to file and also log it.

This function is intended as a 'tee' mechanism to enable the CLI interface as
a first-class citizen, while ensuring that everything the operator sees also
has an analogous logging entry in the test record for later inspection.

Args:
msg: The message to print/log.
color: Optional colorama color string to be applied to the message. You can
concatenate colorama color strings together in order to get any set of
effects you want.
end: A custom line-ending string to print instead of newline.
file: A file object to which the baracketed text will be written. Intended
for use with CLI output file objects like sys.stdout.
logger: A logger to use, or None to disable logging.


def get_uid(prefix=''):
    object_name_uids = global_state.get_global_attribute('object_name_uids', default=collections.defaultdict(int), set_to_default=True)
    object_name_uids[prefix] += 1
    return object_name_uids[prefix]

Associates a string prefix with an integer counter.

Args:
prefix: String prefix to index.

Returns:
Unique integer ID.

Example:

>>> get_uid('dense')
1
>>> get_uid('dense')
2


def generate_hdate(date: str, subtract_year: str) -> str:
    try:
        input_date = datetime.datetime.strptime(date, '%Y-%m-%d')
        if input_date.month == 2 and input_date.day == 29:
            input_date = input_date - datetime.timedelta(days=1)
        subtract_year = int(subtract_year)
    except (ValueError, TypeError):
        logger.error('Invalid input.')
        raise
    hdate = input_date - relativedelta(years=subtract_year)
    return hdate.strftime('%Y-%m-%d')

Generate a historical date by subtracting a specified number of years from the given date.
If input date is leap day (Feb 29), return Feb 28 even if target hdate is also a leap year.
This is expected in ECMWF API.

Args:
date (str): The input date in the format 'YYYY-MM-DD'.
subtract_year (str): The number of years to subtract.

Returns:
str: The historical date in the format 'YYYY-MM-DD'.


def add(self, value, date=None, return_value=False, key=None):

        data = {}
        if self._metric_id is None:
            self.tcex.handle_error(715, [self._metric_name])

        body = {'value': value}
        if date is not None:
            body['date'] = self.tcex.utils.format_datetime(date, date_format='%Y-%m-%dT%H:%M:%SZ')
        if key is not None:
            body['name'] = key
        self.tcex.log.debug('metric data: {}'.format(body))
        params = {}
        if return_value:
            params = {'returnValue': 'true'}
        url = '/v2/customMetrics/{}/data'.format(self._metric_id)
        r = self.tcex.session.post(url, json=body, params=params)
        if r.status_code == 200 and 'application/json' in r.headers.get('content-type', ''):
            data = r.json()
        elif r.status_code == 204:
            pass
        else:
            self.tcex.handle_error(710, [r.status_code, r.text])

        return data

Add metrics data to collection.

Args:
value (str): The value of the metric.
date (str, optional): The optional date of the metric.
return_value (bool, default:False): Tell the API to return the updates metric value.
key (str, optional): The key value for keyed metrics.

Return:
dict: If return_value is True a dict with the current value for the time period
is returned.


def html_to_xhtml(html_unicode_string):

    try:
        assert isinstance(html_unicode_string, basestring)
    except AssertionError:
        raise TypeError
    root = BeautifulSoup(html_unicode_string, 'html.parser')

    try:
        assert root.html is not None
    except AssertionError:
        raise ValueError(''.join(['html_unicode_string cannot be a fragment.',
                         'string is the following: %s', unicode(root)]))

    root.html['xmlns'] = 'http:
    unicode_string = unicode(root.prettify(encoding='utf-8', formatter='html'), encoding='utf-8')

    for tag in constants.SINGLETON_TAG_LIST:
        unicode_string = unicode_string.replace(
                '<' + tag + '/>',
                '<' + tag + ' />')
    return unicode_string

Converts html to xhtml

Args:
html_unicode_string: A (possible unicode) string representing HTML.

Returns:
A (possibly unicode) string representing XHTML.

Raises:
TypeError: Raised if input_string isn't a unicode string or string.


def cumprod(x, axis=0):
    return math_ops.cumprod(x, axis=axis)

Cumulative product of the values in a tensor, alongside the specified axis.

Args:
x: A tensor or variable.
axis: An integer, the axis to compute the product.

Returns:
A tensor of the cumulative product of values of `x` along `axis`.


def revert_to(self):

		response = self.resource.repo.api.http_request('PATCH', self.uri)

		if response.status_code == 204:
			logger.debug('reverting to previous version of resource, %s' % self.uri)

			self._current_resource.refresh()

		else:
			raise Exception('HTTP %s, could not revert to resource version, %s' % (response.status_code, self.uri))

method to revert resource to this version by issuing PATCH

Args:
None

Returns:
None: sends PATCH request, and refreshes parent resource


def _zeros_slot(self, var, slot_name, op_name):
    named_slots = self._slot_dict(slot_name)
    if _var_key(var) not in named_slots:
        new_slot_variable = slot_creator.create_zeros_slot(var, op_name, copy_xla_sharding=True)
        self._restore_slot_variable(slot_name=slot_name, variable=var, slot_variable=new_slot_variable)
        named_slots[_var_key(var)] = new_slot_variable
    return named_slots[_var_key(var)]

Find or create a slot initialized with 0.0.

Args:
var: A `Variable` object.
slot_name: Name for the slot.
op_name: Name to use when scoping the Variable that
needs to be created for the slot.

Returns:
A `Variable` object.


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

        if args:
            for arg in args:
                if arg is not None:
                    for name in self.__slots__:
                        self._set(name, getattr(arg, name, UNSET))
        for name in kwargs:
            self._set(name, kwargs.get(name, UNSET))

Conveniently set one or more fields at a time.

Args:
*args: Optionally set from other objects, available fields from the passed object are used in order
**kwargs: Set from given key/value pairs (only names defined in __slots__ are used)


def asdim(dimension):
    if isinstance(dimension, Dimension):
        return dimension
    elif isinstance(dimension, (tuple, dict, basestring)):
        return Dimension(dimension)
    else:
        raise ValueError('%s type could not be interpreted as Dimension. Dimensions must be declared as a string, tuple, dictionary or Dimension type.')

Convert the input to a Dimension.

Args:
dimension: tuple, dict or string type to convert to Dimension

Returns:
A Dimension object constructed from the dimension spec. No
copy is performed if the input is already a Dimension.


def ajax(cls, url, param={}, method='get'):
    param = urllib.parse.urlencode(param)
    if (method.lower() == 'get'):
        req = urllib.request.Request(((url + '?') + param))
    elif (method.lower() == 'post'):
        param = param.encode('utf-8')
        req = urllib.request.Request(url, data=param)
    else:
        raise Exception("invalid method '{}' (GET/POST)".format(method))
    rsp = urllib.request.urlopen(req)
    if rsp:
        rsp_json = rsp.read().decode('utf-8')
        rsp_dict = json.loads(rsp_json)
        return rsp_dict
    return None

Get info by ajax

Args:
url: string
Returns:
dict: json decoded into a dict


def WMITimeStrToRDFDatetime(self, timestr):
    offset_minutes = timestr[21:]
    year = timestr[:4]
    month = timestr[4:6]
    day = timestr[6:8]
    hours = timestr[8:10]
    minutes = timestr[10:12]
    seconds = timestr[12:14]
    microseconds = timestr[15:21]
    unix_seconds = calendar.timegm(tuple(map(int, [year, month, day, hours, minutes, seconds])))
    unix_seconds -= (int(offset_minutes) * 60)
    return rdfvalue.RDFDatetime(((unix_seconds * 1000000.0) + int(microseconds)))

Return RDFDatetime from string like 20140825162259.000000-420.

Args:
timestr: WMI time string

Returns:
rdfvalue.RDFDatetime

We have some timezone manipulation work to do here because the UTC offset is
in minutes rather than +-HHMM


def copy_course_videos(source_course_id, destination_course_id):
    if (source_course_id == destination_course_id):
        return
    course_videos = CourseVideo.objects.select_related('video', 'video_image').filter(course_id=six.text_type(source_course_id))
    for course_video in course_videos:
        (destination_course_video, __) = CourseVideo.objects.get_or_create(video=course_video.video, course_id=destination_course_id)
        if hasattr(course_video, 'video_image'):
            VideoImage.create_or_update(course_video=destination_course_video, file_name=course_video.video_image.image.name)

Adds the destination_course_id to the videos taken from the source_course_id

Args:
source_course_id: The original course_id
destination_course_id: The new course_id where the videos will be copied


def set_property(property_map, name, value, exclude_from_indexes=None):
    set_value(property_map[name], value, exclude_from_indexes)

Set property value in the given datastore.Property proto message.

Args:
property_map: a string->datastore.Value protobuf map.
name: name of the property.
value: python object or datastore.Value.
exclude_from_indexes: if the value should be exclude from indexes. None
leaves indexing as is (defaults to False if value is not a Value message).

Usage:
>>> set_property(property_proto, 'foo', u'a')

Raises:
TypeError: if the given value type is not supported.


def interpolate(features, hparams, decode_hp):

  inputs, targets = features["inputs"], features["targets"]
  inputs = tf.unstack(inputs, axis=1)
  targets = tf.unstack(targets, axis=1)
  coeffs = np.linspace(0.0, 1.0, decode_hp.num_interp)

  first_frame, last_frame = inputs[0], targets[-1]
  first_top_z, first_level_eps = frame_to_latents(first_frame, hparams)
  last_top_z, last_level_eps = frame_to_latents(last_frame, hparams)

  first_lats = first_level_eps + [first_top_z]
  last_lats = last_level_eps + [last_top_z]
  interp_lats = []
  lat_iterator = enumerate(zip(first_lats, last_lats))
  for level_ind, (first_lat, last_lat) in lat_iterator:
    if level_ind in decode_hp.level_interp:
      if decode_hp.channel_interp == "all":
        interp_lat = glow_ops.linear_interpolate(first_lat, last_lat, coeffs)
      else:
        interp_lat = glow_ops.linear_interpolate_rank(
            first_lat, last_lat, coeffs, decode_hp.rank_interp)
    else:
      interp_lat = tf.tile(first_lat, [decode_hp.num_interp, 1, 1, 1])
    interp_lats.append(interp_lat)

  level_eps_interp = interp_lats[:hparams.n_levels-1]
  z_top_interp = interp_lats[-1]
  images = latents_to_frames(z_top_interp, level_eps_interp, hparams)
  return images, first_frame, last_frame

Interpolate between the first input frame and last target frame.

Args:
features: dict of tensors
hparams: HParams, training hparams.
decode_hp: HParams, decode hparams.
Returns:
images: interpolated images, 4-D Tensor, shape=(num_interp, H, W, C)
first_frame: image, 3-D Tensor, shape=(1, H, W, C)
last_frame: image, 3-D Tensor, shape=(1, H, W, C)


def dbmax50years(self, value=None):

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

        self._dbmax50years = value

Corresponds to IDD Field `dbmax50years`
50-year return period values for maximum extreme dry-bulb temperature

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

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


def __init__(self, rr, table='services'):

        self.rr = rr
        self.table = table
        self._ensure_table()

Initialize the service registry.

Creates the database table if it does not exist.

Args:
rr (doublethink.Rethinker): a doublethink.Rethinker, which must
have `dbname` set


def PrepareMergeTaskStorage(self, task):

    if task.identifier not in self._task_storage_writers:
      raise IOError('Storage writer for task: {0:s} does not exist.'.format(
          task.identifier))

Prepares a task storage for merging.

Args:
task (Task): task.

Raises:
IOError: if the task storage does not exist.
OSError: if the task storage does not exist.


def dump_artifact(obj, path, filename=None):
    p_sha1 = None
    if (not os.path.exists(path)):
        os.makedirs(path, mode=448)
    else:
        p_sha1 = hashlib.sha1()
        p_sha1.update(obj.encode(encoding='UTF-8'))
    if (filename is None):
        (fd, fn) = tempfile.mkstemp(dir=path)
    else:
        fn = os.path.join(path, filename)
    if os.path.exists(fn):
        c_sha1 = hashlib.sha1()
        with open(fn) as f:
            contents = f.read()
        c_sha1.update(contents.encode(encoding='UTF-8'))
    if ((not os.path.exists(fn)) or (p_sha1.hexdigest() != c_sha1.hexdigest())):
        lock_fp = os.path.join(path, '.artifact_write_lock')
        lock_fd = os.open(lock_fp, (os.O_RDWR | os.O_CREAT), (stat.S_IRUSR | stat.S_IWUSR))
        fcntl.lockf(lock_fd, fcntl.LOCK_EX)
        try:
            with open(fn, 'w') as f:
                os.chmod(fn, stat.S_IRUSR)
                f.write(str(obj))
        finally:
            fcntl.lockf(lock_fd, fcntl.LOCK_UN)
            os.close(lock_fd)
            os.remove(lock_fp)
    return fn

Write the artifact to disk at the specified path

Args:
obj (string): The string object to be dumped to disk in the specified
path.  The artifact filename will be automatically created

path (string): The full path to the artifacts data directory.

filename (string, optional): The name of file to write the artifact to.
If the filename is not provided, then one will be generated.

Returns:
string: The full path filename for the artifact that was generated


def process(i: int, sentence: str, sep_indices: typing.Set[int], scale: int) -> str:
    feature = get_feature(sentence[i - 3] if i > 2 else INVALID, sentence[i - 2] if i > 1 else INVALID, sentence[i - 1], sentence[i] if i < len(sentence) else INVALID, sentence[i + 1] if i + 1 < len(sentence) else INVALID, sentence[i + 2] if i + 2 < len(sentence) else INVALID)
    positive = i in sep_indices
    line = '\t'.join(['%d' % scale if positive else '%d' % -scale] + feature)
    return line

Outputs an encoded line of features from the given index.

Args:
i (int): index
sentence (str): A sentence
sep_indices (typing.Set[int]): A set of separator indices.
scale (int): A weight scale for the entries.


def plot_rb_data(xdata, ydatas, yavg, yerr, fit, survival_prob, ax=None, show_plt=True):
    if (not HAS_MATPLOTLIB):
        raise ImportError('The function plot_rb_data needs matplotlib. Run "pip install matplotlib" before.')
    if (ax is None):
        plt.figure()
        ax = plt.gca()
    for ydata in ydatas:
        ax.plot(xdata, ydata, color='gray', linestyle='none', marker='x')
    ax.errorbar(xdata, yavg, yerr=yerr, color='r', linestyle='--', linewidth=3)
    ax.plot(xdata, survival_prob(xdata, *fit), color='blue', linestyle='-', linewidth=2)
    ax.tick_params(labelsize=14)
    ax.set_xlabel('Clifford Length', fontsize=16)
    ax.set_ylabel('Z', fontsize=16)
    ax.grid(True)
    if show_plt:
        plt.show()

Plot randomized benchmarking data.

Args:
xdata (list): list of subsequence lengths
ydatas (list): list of lists of survival probabilities for each
sequence
yavg (list): mean of the survival probabilities at each sequence
length
yerr (list): error of the survival
fit (list): fit parameters
survival_prob (callable): function that computes survival probability
ax (Axes or None): plot axis (if passed in)
show_plt (bool): display the plot.

Raises:
ImportError: If matplotlib is not installed.


def update_all(cls, *criterion, **kwargs):
    try:
        r = cls.query.filter(*criterion).update(kwargs, 'fetch')
        cls.session.commit()
        return r
    except:
        cls.session.rollback()
        raise

Batch method for updating all instances obeying the criterion

Args:
*criterion: SQLAlchemy query criterion for filtering what
instances to update
**kwargs: The parameters to be updated

Examples:

>>> User.update_all(active=True)

>>> Customer.update_all(Customer.country=='India', active=True)

The second example sets active=True for all customers with
country India.


def push_stack(stack, substack, op_id):
    if ((substack is not None) and (not isinstance(substack, Stack))):
        raise ValueError(('Substack should be type tangent.Stack or None, instead found %s' % type(substack)))
    if __debug__:
        stack.append((substack, op_id))
    else:
        stack.append(substack)

Proxy of push, where we know we're pushing a stack onto a stack.

Used when differentiating call trees,where sub-functions get their own stack.
See push() for more.

Args:
stack: The stack object, which must support appending values.
substack: The stack to append.
op_id: A unique variable that is also passed into the corresponding pop.
Allows optimization passes to track pairs of pushes and pops.

Raises:
ValueError: If a non-stack value for `substack` is passed.


def input(self):
    return self._get_node_attribute_at_index(0, 'input_tensors', 'input')

Retrieves the input tensor(s) of a symbolic operation.

Only returns the tensor(s) corresponding to the *first time*
the operation was called.

Returns:
Input tensor or list of input tensors.


def _show_status_for_work(self, work):

    work_count = len(work.work)
    work_completed = {}
    work_completed_count = 0
    for v in itervalues(work.work):
      if v['is_completed']:
        work_completed_count += 1
        worker_id = v['claimed_worker_id']
        if worker_id not in work_completed:
          work_completed[worker_id] = {
              'completed_count': 0,
              'last_update': 0.0,
          }
        work_completed[worker_id]['completed_count'] += 1
        work_completed[worker_id]['last_update'] = max(
            work_completed[worker_id]['last_update'],
            v['claimed_worker_start_time'])
    print('Completed {0}/{1} work'.format(work_completed_count,
                                          work_count))
    for k in sorted(iterkeys(work_completed)):
      last_update_time = time.strftime(
          '%Y-%m-%d %H:%M:%S',
          time.localtime(work_completed[k]['last_update']))
      print('Worker {0}: completed {1}   last claimed work at {2}'.format(
          k, work_completed[k]['completed_count'], last_update_time))

Shows status for given work pieces.

Args:
work: instance of either AttackWorkPieces or DefenseWorkPieces


def _convert_values_to_tf_tensors(sample: rd.RepresentativeSample) -> Mapping[str, core.Tensor]:
    tensor_mapping = {}
    for name, tensorlike_value in sample.items():
        if isinstance(tensorlike_value, core.Tensor):
            tensor_value = tensorlike_value
        else:
            tensor_value = tensor_conversion.convert_to_tensor_v2_with_dispatch(tensorlike_value)
        tensor_mapping[name] = tensor_value
    return tensor_mapping

Converts TensorLike values of `sample` to Tensors.

Creates a copy of `sample`, where each value is converted to Tensors
unless it is already a Tensor.
The values are not converted in-place (i.e. `sample` is not mutated).

Args:
sample: A representative sample, which is a map of {name -> tensorlike
value}.

Returns:
Converted map of {name -> tensor}.


def from_config(cls, config):
    return cls(**config)

Creates a regularizer from its config.

This method is the reverse of `get_config`,
capable of instantiating the same regularizer from the config
dictionary.

This method is used by saving and loading models to HDF5 formats,
Keras model cloning, some visualization utilities,
and exporting models to and from JSON.

Args:
config: A Python dictionary, typically the output of get_config.

Returns:
A regularizer instance.