def GetValueLength(rd, pos):
    rd = bytearray(rd)
    key = rd[pos]
    if (key == LONG_ITEM_ENCODING):
        if ((pos + 1) < len(rd)):
            return (3, rd[(pos + 1)])
        else:
            raise errors.HidError('Malformed report descriptor')
    else:
        code = (key & 3)
        if (code <= 2):
            return (1, code)
        elif (code == 3):
            return (1, 4)
    raise errors.HidError('Cannot happen')

Get value length for a key in rd.

For a key at position pos in the Report Descriptor rd, return the length
of the associated value.  This supports both short and long format
values.

Args:
rd: Report Descriptor
pos: The position of the key in rd.

Returns:
(key_size, data_len) where key_size is the number of bytes occupied by
the key and data_len is the length of the value associated by the key.


def on_message(self, message):

        try:
            self.log.debug("Got message %s", message)
            d = json_decode(message)
            response = deserialize_object(d, Response)
            if isinstance(response, (Return, Error)):
                request = self._request_lookup.pop(response.id)
                if isinstance(response, Error):

                    response.message = ResponseError(response.message)
            else:
                request = self._request_lookup[response.id]

            cothread.Callback(request.callback, response)
        except Exception:

            self.log.exception("on_message(%r) failed", message)

Pass response from server to process receive queue

Args:
message(str): Received message


def __init__(self,
               initializer=None,
               age=None,
               base="aff4:/flows",
               queue=DEFAULT_FLOW_QUEUE,
               flow_name=None):

    if initializer is None:

      if flow_name is None:
        flow_name = random.UInt32()

      if isinstance(flow_name, int):
        initializer = RDFURN(base).Add("%s:%X" % (queue.Basename(), flow_name))
      else:
        initializer = RDFURN(base).Add("%s:%s" % (queue.Basename(), flow_name))
    else:
      if isinstance(initializer, RDFURN):
        try:
          self.ValidateID(initializer.Basename())
        except ValueError as e:
          raise InitializeError(
              "Invalid URN for SessionID: %s, %s" % (initializer, e))

    super(SessionID, self).__init__(initializer=initializer, age=age)

Constructor.

Args:
initializer: A string or another RDFURN.
age: The age of this entry.
base: The base namespace this session id lives in.
queue: The queue to use.
flow_name: The name of this flow or its random id.

Raises:
InitializeError: The given URN cannot be converted to a SessionID.


def NewFromJSON(data):

        return Comment(
            body=data.get('body', None),
            posted_at=data.get('posted_at', None),
            user=User.NewFromJSON(data.get('user', None))
        )

Create a new Comment instance from a JSON dict.

Args:
data (dict): JSON dictionary representing a Comment.

Returns:
A Comment instance.


def from_coffeescript(cls, func, v_func, args={}):
    compiled = nodejs_compile(func, lang='coffeescript', file='???')
    if ('error' in compiled):
        raise CompilationError(compiled.error)
    v_compiled = nodejs_compile(v_func, lang='coffeescript', file='???')
    if ('error' in v_compiled):
        raise CompilationError(v_compiled.error)
    return cls(func=compiled.code, v_func=v_compiled.code, args=args)

Create a ``CustomJSTransform`` instance from a pair of CoffeeScript
snippets. The function bodies are translated to JavaScript functions
using node and therefore require return statements.

The ``func`` snippet namespace will contain the variable ``x`` (the
untransformed value) at render time. The ``v_func`` snippet namespace
will contain the variable ``xs`` (the untransformed vector) at render
time.

Example:

.. code-block:: coffeescript

func = "return Math.cos(x)"
v_func = "return [Math.cos(x) for x in xs]"

transform = CustomJSTransform.from_coffeescript(func, v_func)

Args:
func (str) : a coffeescript snippet to transform a single ``x`` value

v_func (str) : a coffeescript snippet function to transform a vector ``xs``

Returns:
CustomJSTransform


def GenerateDateTripsDeparturesList(self, date_start, date_end):

    service_id_to_trips = defaultdict(lambda: 0)
    service_id_to_departures = defaultdict(lambda: 0)
    for trip in self.GetTripList():
      headway_start_times = trip.GetFrequencyStartTimes()
      if headway_start_times:
        trip_runs = len(headway_start_times)
      else:
        trip_runs = 1

      service_id_to_trips[trip.service_id] += trip_runs
      service_id_to_departures[trip.service_id] += (
          (trip.GetCountStopTimes() - 1) * trip_runs)

    date_services = self.GetServicePeriodsActiveEachDate(date_start, date_end)
    date_trips = []

    for date, services in date_services:
      day_trips = sum(service_id_to_trips[s.service_id] for s in services)
      day_departures = sum(
          service_id_to_departures[s.service_id] for s in services)
      date_trips.append((date, day_trips, day_departures))
    return date_trips

Return a list of (date object, number of trips, number of departures).

The list is generated for dates in the range [date_start, date_end).

Args:
date_start: The first date in the list, a date object
date_end: The first date after the list, a date object

Returns:
a list of (date object, number of trips, number of departures) tuples


def __init__(self, config=None):

        self.driver = get_database_instance(config)
        self.logger = logging.getLogger('Plugin')
        logging.basicConfig(level=logging.INFO)

Initialize a :class:`~.Plugin` instance and connect to MongoDB.
Args:
*nodes (str): One or more URLs of MongoDB nodes to
connect to as the persistence layer


def state_range_type(self) -> Sequence[str]:
    fluents = self.domain.state_fluents
    ordering = self.domain.state_fluent_ordering
    return self._fluent_range_type(fluents, ordering)

The range type of each state fluent in canonical order.

Returns:
Sequence[str]: A tuple of range types representing
the range of each fluent.


def _percentile(self, values, percent, key=lambda x: x):

        vals = sorted(values)
        k = (len(vals) - 1) * (percent / 100)
        f = math.floor(k)
        c = math.ceil(k)
        if f == c:
            return key(vals[int(k)])
        d0 = key(vals[int(f)]) * (c - k)
        d1 = key(vals[int(c)]) * (k - f)
        return d0 + d1

Find the percentile of a list of values.

Args:
values: A list of values for which percentiles are desired
percent: A float value from 0 to 100 representing the requested percentile.
key: optional key function to compute value from each element of N.

Return:
The percentile of the values


def load_function_def_library(library, saved_object_graph=None, load_shared_name_suffix=None, wrapper_function=None):
    library_function_names = set((fdef.signature.name for fdef in library.function))
    functions = {}
    renamed_functions = {}
    if ops.executing_eagerly_outside_functions():
        graph = ops.Graph()
    else:
        graph = ops.get_default_graph()
    if load_shared_name_suffix is None:
        load_shared_name_suffix = '_load_{}'.format(ops.uid())
    library_gradient_names = {}
    new_gradient_op_types = {}
    gradients_to_register = {}
    for gdef in library.registered_gradients:
        if gdef.registered_op_type:
            new_op_type = custom_gradient.generate_name()
            old_op_type = compat.as_bytes(gdef.registered_op_type)
            library_gradient_names[old_op_type] = gdef.gradient_func
            new_gradient_op_types[old_op_type] = new_op_type
            gradients_to_register[gdef.gradient_func] = new_op_type
    function_deps = {}
    for fdef in library.function:
        function_deps[fdef.signature.name] = _list_function_deps(fdef, library_function_names, library_gradient_names)
    loaded_gradients = {}
    for fdef in _sort_function_defs(library, function_deps):
        orig_name = _fix_fdef_in_place(fdef, functions, load_shared_name_suffix, new_gradient_op_types)
        structured_input_signature = None
        structured_outputs = None
        if saved_object_graph is not None and orig_name in saved_object_graph.concrete_functions:
            proto = saved_object_graph.concrete_functions[orig_name]
            structured_input_signature = nested_structure_coder.decode_proto(proto.canonicalized_input_signature)
            structured_outputs = nested_structure_coder.decode_proto(proto.output_signature)
        with graph.as_default():
            func_graph = function_def_lib.function_def_to_graph(fdef, structured_input_signature=structured_input_signature, structured_outputs=structured_outputs)
        _restore_gradient_functions(func_graph, renamed_functions, loaded_gradients)
        for dep in function_deps[orig_name]:
            functions[dep].add_to_graph(func_graph)
        if '_input_shapes' in fdef.attr:
            del fdef.attr['_input_shapes']
        function_type = function_type_lib.from_structured_signature(func_graph.structured_input_signature, func_graph.structured_outputs, func_graph.function_captures.capture_types)
        func = function_lib.ConcreteFunction.from_func_graph(func_graph, function_type, attrs=fdef.attr)
        if wrapper_function:
            func = wrapper_function(func)
        func.add_to_graph(graph)
        functions[orig_name] = func
        renamed_functions[func.name] = func
        if any((op.type == 'TRTEngineOp' for op in func_graph.get_operations())):
            func.add_to_graph(ops.get_default_graph())
        if orig_name in gradients_to_register:
            gradient_op_type = gradients_to_register[orig_name]
            loaded_gradients[compat.as_bytes(gradient_op_type)] = func
            ops.RegisterGradient(gradient_op_type)(_gen_gradient_func(func))
    return functions

Load a set of functions as concrete functions without captured inputs.

Functions names are manipulated during load such that they do not overlap
with previously created ones.

Gradients are re-registered under new names. Ops that reference the gradients
are updated to reflect the new registered names.

Args:
library: FunctionDefLibrary proto message.
saved_object_graph: SavedObjectGraph proto message. If not passed in,
concrete function structured signatures and outputs will not be set.
load_shared_name_suffix: If specified, used to uniquify shared names.
Otherwise, a unique name is generated.
wrapper_function: An object that will be wrapped on newly created functions.

Returns:
Map of original function names in the library to instances of
`ConcreteFunction` without captured inputs.

Raises:
ValueError: if functions dependencies have a cycle.


def rename(self, source_file_names, destination_file_names):
    if not len(source_file_names) == len(destination_file_names):
        message = 'Unable to rename unequal number of sources and destinations.'
        raise BeamIOError(message)
    src_dest_pairs = list(zip(source_file_names, destination_file_names))
    results = self._blobstorageIO().rename_files(src_dest_pairs)
    exceptions = {(src, dest): error for src, dest, error in results if error is not None}
    if exceptions:
        raise BeamIOError('Rename operation failed.', exceptions)

Rename the files at the source list to the destination list.
Source and destination lists should be of the same size.

Args:
source_file_names: List of file paths that need to be moved
destination_file_names: List of destination_file_names for the files

Raises:
``BeamIOError``: if any of the rename operations fail


def get_by_uri(self, uri):

        self._helper.validate_resource_uri(uri)
        data = self._helper.do_get(uri)

        if data:
            new_resource = self.new(self._connection, data)
        else:
            new_resource = None

        return new_resource

Retrieves a resource by its URI

Args:
uri: URI of the resource

Returns:
Resource object


def get_provider_fn_decorations(provider_fn, default_arg_names):

    if hasattr(provider_fn, _IS_WRAPPER_ATTR):
        provider_decorations = getattr(provider_fn, _PROVIDER_DECORATIONS_ATTR)
        if provider_decorations:
            expanded_provider_decorations = []
            for provider_decoration in provider_decorations:

                if provider_decoration.in_scope_id is None:
                    provider_decoration.in_scope_id = scoping.DEFAULT_SCOPE
                if provider_decoration.arg_name is not None:
                    expanded_provider_decorations.append(provider_decoration)
                else:
                    expanded_provider_decorations.extend(
                        [ProviderDecoration(default_arg_name,
                                            provider_decoration.annotated_with,
                                            provider_decoration.in_scope_id)
                         for default_arg_name in default_arg_names])
            return expanded_provider_decorations
    return [ProviderDecoration(default_arg_name,
                               annotated_with=None,
                               in_scope_id=scoping.DEFAULT_SCOPE)
            for default_arg_name in default_arg_names]

Retrieves the provider method-relevant info set by decorators.

If any info wasn't set by decorators, then defaults are returned.

Args:
provider_fn: a (possibly decorated) provider function
default_arg_names: the (possibly empty) arg names to use if none were
specified via @provides()
Returns:
a sequence of ProviderDecoration


def shape(self):
    raise NotImplementedError

The `TensorShape` of this variable.

Returns:
A `TensorShape`.


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

Expects no exception is raised in a context.

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

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

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


def owner_set(self):
    owners = set()
    if self.has_attr() or self.has_subscript():
        owners.add(self.parent)
        owners.update(self.parent.owner_set)
    return owners

Returns all the symbols (simple or composite) that own this QN.

In other words, if this symbol was modified, the symbols in the owner set
may also be affected.

Examples:
'a.b[c.d]' has two owners, 'a' and 'a.b'


def _ImportPythonModule(module_name):
    try:
        module_object = list(map(__import__, [module_name]))[0]
    except ImportError:
        return None
    if ('.' in module_name):
        for submodule_name in module_name.split('.')[1:]:
            module_object = getattr(module_object, submodule_name, None)
    return module_object

Imports a Python module.

Args:
module_name (str): name of the module.

Returns:
module: Python module or None if the module cannot be imported.


def get_layer(self, name=None, index=None):
    if index is not None and name is not None:
        raise ValueError('Provide only a layer name or a layer index.')
    if index is not None:
        if len(self.layers) <= index:
            raise ValueError('Was asked to retrieve layer at index ' + str(index) + ' but model only has ' + str(len(self.layers)) + ' layers.')
        else:
            return self.layers[index]
    if name is not None:
        for layer in self.layers:
            if layer.name == name:
                return layer
        raise ValueError('No such layer: ' + name + '.')
    raise ValueError('Provide either a layer name or layer index.')

Retrieves a layer based on either its name (unique) or index.

If `name` and `index` are both provided, `index` will take precedence.
Indices are based on order of horizontal graph traversal (bottom-up).

Args:
name: String, name of layer.
index: Integer, index of layer.

Returns:
A layer instance.

Raises:
ValueError: In case of invalid layer name or index.


async def _grab_connection(self, url):
    (scheme, host, _, _, _, _) = urlparse(url)
    host_loc = urlunparse((scheme, host, '', '', '', ''))
    sock = self._checkout_connection(host_loc)
    if (sock is None):
        sock = (await self._make_connection(host_loc))
    return sock

The connection pool handler. Returns a connection
to the caller. If there are no connections ready, and
as many connections checked out as there are available total,
we yield control to the event loop.

If there is a connection ready or space to create a new one, we
pop/create it, register it as checked out, and return it.

Args:
url (str): breaks the url down and uses the top level location
info to see if we have any connections to the location already
lying around.


def execute(self, asm_instr):

        self.ir_emulator.registers[self.ip] = asm_instr.address + asm_instr.size

        if self.arch_info.instr_is_syscall(asm_instr):
            raise Syscall()

        return self.__execute(asm_instr)

Execute an assembler instruction.

Args:
asm_instr (X86Instruction): A instruction to execute.

Returns:
A int. The address of the next instruction to execute.


def get_device_locations(mesh: layout_lib.Mesh, client_id: Optional[int]=None) -> List[Dict[str, int]]:
    if mesh.device_type() != _TPU_DEVICE_TYPE:
        raise ValueError('The mesh must be a TPU mesh')
    if client_id is None or client_id == config.client_id():
        return mesh.local_device_locations()
    raise NotImplementedError("Looking up other clients' device locations is not supported")

Returns the device locations of all TPU cores local to the given client.

A device location is a dictionary from dimension names to indices on those
dimensions. For example, for a 2x2 mesh ('x', 'y'), this function returns a
permutation of this list:

[{'x': 0, 'y': 0},
{'x': 0, 'y': 1},
{'x': 1, 'y': 0},
{'x': 1, 'y': 1}].

Note that device IDs and device locations are equivalent. The former is a
linearization of the latter along mesh dimensions.

Args:
mesh: A TPU mesh.
client_id: Optional; A DTensor client ID. If empty, query this client.


def _get_typed_list_value(self, key, target_type, type_convert, is_optional=False, is_secret=False, is_local=False, default=None, options=None):
    value = self._get_typed_value(key=key, target_type=list, type_convert=json.loads, is_optional=is_optional, is_secret=is_secret, is_local=is_local, default=default, options=options)
    if (not value):
        return default
    raise_type = ('dict' if (target_type == Mapping) else target_type)
    if (not isinstance(value, list)):
        raise RheaError('Cannot convert value `{}` (key: `{}`) to `{}`'.format(value, key, raise_type))
    result = []
    for v in value:
        if isinstance(v, six.string_types):
            try:
                result.append(type_convert(v))
            except ValueError:
                raise RheaError('Cannot convert value `{}` (found in list key: `{}`) to `{}`'.format(v, key, raise_type))
        elif isinstance(v, target_type):
            result.append(v)
        else:
            raise RheaError('Cannot convert value `{}` (found in list key: `{}`) to `{}`'.format(v, key, raise_type))
    return result

Return the value corresponding to the key converted first to list
than each element to the given type.

Args:
key: the dict key.
target_type: The type we expect the variable or key to be in.
type_convert: A lambda expression that converts the key to the desired type.
is_optional: To raise an error if key was not found.
is_secret: If the key is a secret.
is_local: If the key is a local to this service.
default: default value if is_optional is True.
options: list/tuple if provided, the value must be one of these values.


def nCr(n, r):

    f = math.factorial
    return int(f(n) / f(r) / f(n-r))

Calculates nCr.

Args:
n (int): total number of items.
r (int): items to choose

Returns:
nCr.


def prepare_adiabatic_limit(slh, k=None):

    if k is None:
        k = symbols('k', positive=True)
    Ld = slh.L.dag()
    LdL = (Ld * slh.L)[0, 0]
    K = (-LdL / 2 + I * slh.H).expand().simplify_scalar()
    N = slh.S.dag()
    B, A, Y = K.series_expand(k, 0, 2)
    G, F = Ld.series_expand(k, 0, 1)

    return Y, A, B, F, G, N

Prepare the adiabatic elimination on an SLH object

Args:
slh: The SLH object to take the limit for
k: The scaling parameter $k \rightarrow \infty$. The default is a
positive symbol 'k'

Returns:
tuple: The objects ``Y, A, B, F, G, N``
necessary to compute the limiting system.


def assert_stmt(expression1, expression2):
    if not callable(expression2):
        raise ValueError('{} must be a callable'.format(expression2))
    args, _, keywords, _ = tf_inspect.getargspec(expression2)
    if args or keywords:
        raise ValueError('{} may not have any arguments'.format(expression2))
    if tensor_util.is_tf_type(expression1):
        return _tf_assert_stmt(expression1, expression2)
    else:
        return _py_assert_stmt(expression1, expression2)

Functional form of an assert statement.

This follows the semantics of the Python assert statement, however the
concrete implementations may deviate from it. See the respective
implementation for details.

In general, the assert statement should not be used for control flow.
Furthermore, it is encouraged that the assertion expressions should not have
side effects.

Args:
expression1: Any
expression2: Callable[[], Any], returns the expression to include in the
error message when expression1 evaluates to False. When expression1 is
True, the result of expression2 will not be evaluated, however,
expression2 itself may be evaluated in some implementations.

Returns:
Any, implementation-dependent.

Raises:
ValueError: if any arguments are illegal.


def find_library_linux(cls):

        dll = Library.JLINK_SDK_NAME
        root = os.path.join('/', 'opt', 'SEGGER')

        for (directory_name, subdirs, files) in os.walk(root):
            fnames = []
            x86_found = False
            for f in files:
                path = os.path.join(directory_name, f)
                if os.path.isfile(path) and f.startswith(dll):
                    fnames.append(f)
                    if '_x86' in path:
                        x86_found = True

            for fname in fnames:
                fpath = os.path.join(directory_name, fname)
                if util.is_os_64bit():
                    if '_x86' not in fname:
                        yield fpath
                elif x86_found:
                    if '_x86' in fname:
                        yield fpath
                else:
                    yield fpath

Loads the SEGGER DLL from the root directory.

On Linux, the SEGGER tools are installed under the ``/opt/SEGGER``
directory with versioned directories having the suffix ``_VERSION``.

Args:
cls (Library): the ``Library`` class

Returns:
The paths to the J-Link library files in the order that they are
found.


def generate_nb_state_data(means, weights, R):

    cells = weights.shape[1]

    x_true = np.dot(means, weights)

    R_ = np.tile(R, (cells, 1)).T
    P_true = x_true/(R_ + x_true)
    sample = np.random.negative_binomial(np.tile(R, (cells, 1)).T, P_true)
    return sample.astype(float)

Generates data according to the Negative Binomial Convex Mixture Model.

Args:
means (array): Cell types- genes x clusters
weights (array): Cell cluster assignments- clusters x cells
R (array): dispersion parameter - 1 x genes

Returns:
data matrix - genes x cells


def validate_arg_values(ast, bo):

    if not bo.api_url:
        log.info("No API endpoint defined")
        return bo

    log.debug(f"AST: {ast}")

    if isinstance(ast, NSArg):
        term_id = "{}:{}".format(ast.namespace, ast.value)
        value_types = ast.value_types
        log.debug(f"Value types: {value_types}  AST value: {ast.value}")

        if ast.namespace == "DEFAULT":
            for value_type in value_types:
                default_namespace = [
                    ns["name"] for ns in bo.spec["namespaces"][value_type]["info"]
                ] + [
                    ns["abbreviation"]
                    for ns in bo.spec["namespaces"][value_type]["info"]
                ]

                if ast.value in default_namespace:
                    log.debug("Default namespace valid term: {}".format(term_id))
                    break
            else:
                log.debug("Default namespace invalid term: {}".format(term_id))
                bo.validation_messages.append(
                    ("WARNING", f"Default Term: {term_id} not found")
                )

        else:
            request_url = bo.api_url + "/terms/{}".format(
                url_path_param_quoting(term_id)
            )
            log.info(f"Validate Arg Values url {request_url}")
            r = get_url(request_url)
            if r and r.status_code == 200:
                result = r.json()

                log.debug(
                    f'AST.value_types  {ast.value_types}  Entity types {result.get("entity_types", [])}'
                )

                if (
                    len(
                        set(ast.value_types).intersection(
                            result.get("entity_types", [])
                        )
                    )
                    == 0
                ):
                    log.debug(
                        "Invalid Term - statement term {} allowable entity types: {} do not match API term entity types: {}".format(
                            term_id, ast.value_types, result.get("entity_types", [])
                        )
                    )
                    bo.validation_messages.append(
                        (
                            "WARNING",
                            "Invalid Term - statement term {} allowable entity types: {} do not match API term entity types: {}".format(
                                term_id, ast.value_types, result.get("entity_types", [])
                            ),
                        )
                    )

                if term_id in result.get("obsolete_ids", []):
                    bo.validation_messages.append(
                        (
                            "WARNING",
                            f'Obsolete term: {term_id}  Current term: {result["id"]}',
                        )
                    )

            elif r.status_code == 404:
                bo.validation_messages.append(
                    ("WARNING", f"Term: {term_id} not found in namespace")
                )
            else:
                log.error(f"Status {r.status_code} - Bad URL: {request_url}")

    if isinstance(ast, StrArg):
        log.debug(f"  Check String Arg: {ast.value}  {ast.value_types}")
        for value_type in ast.value_types:

            if re.match("/", value_type):
                value_type = re.sub("^/", "", value_type)
                value_type = re.sub("/$", "", value_type)
                match = re.match(value_type, ast.value)
                if match:
                    break
            if value_type in bo.spec["namespaces"]:
                default_namespace = [
                    ns["name"] for ns in bo.spec["namespaces"][value_type]["info"]
                ] + [
                    ns["abbreviation"]
                    for ns in bo.spec["namespaces"][value_type]["info"]
                ]
                if ast.value in default_namespace:
                    break
        else:
            bo.validation_messages.append(
                (
                    "WARNING",
                    f"String value {ast.value} does not match default namespace value or regex pattern: {ast.value_types}",
                )
            )

    if hasattr(ast, "args"):
        for arg in ast.args:
            validate_arg_values(arg, bo)

    return bo

Recursively validate arg (NSArg and StrArg) values

Check that NSArgs are found in BELbio API and match appropriate entity_type.
Check that StrArgs match their value - either default namespace or regex string

Generate a WARNING if not.

Args:
bo: bel object

Returns:
bel object


def sspro8_summary(self):
    summary = {}
    records = ssbio.protein.sequence.utils.fasta.load_fasta_file(self.out_sspro8)
    for r in records:
        seq_summary = {}
        seq_summary['percent_H-sspro8'] = (r.seq.count('H') / float(len(r)))
        seq_summary['percent_G-sspro8'] = (r.seq.count('G') / float(len(r)))
        seq_summary['percent_I-sspro8'] = (r.seq.count('I') / float(len(r)))
        seq_summary['percent_E-sspro8'] = (r.seq.count('E') / float(len(r)))
        seq_summary['percent_B-sspro8'] = (r.seq.count('B') / float(len(r)))
        seq_summary['percent_T-sspro8'] = (r.seq.count('T') / float(len(r)))
        seq_summary['percent_S-sspro8'] = (r.seq.count('S') / float(len(r)))
        seq_summary['percent_C-sspro8'] = (r.seq.count('C') / float(len(r)))
        summary[r.id] = seq_summary
    return summary

Parse the SSpro8 output file and return a summary of secondary structure composition.

The output file is just a FASTA formatted file, so you can get residue level
information by parsing it like a normal sequence file.

Returns:
dict: Percentage of:
H: alpha-helix
G: 310-helix
I: pi-helix (extremely rare)
E: extended strand
B: beta-bridge
T: turn
S: bend
C: the rest


def _sort_scores_and_boxes(scores, boxes):
    with ops.name_scope('sort_scores_and_boxes'):
        sorted_scores_indices = sort_ops.argsort(scores, axis=1, direction='DESCENDING')
        sorted_scores = array_ops.gather(scores, sorted_scores_indices, axis=1, batch_dims=1)
        sorted_boxes = array_ops.gather(boxes, sorted_scores_indices, axis=1, batch_dims=1)
    return (sorted_scores, sorted_boxes, sorted_scores_indices)

Sort boxes based their score from highest to lowest.

Args:
scores: a tensor with a shape of [batch_size, num_boxes] representing
the scores of boxes.
boxes: a tensor with a shape of [batch_size, num_boxes, 4] representing
the boxes.
Returns:
sorted_scores: a tensor with a shape of [batch_size, num_boxes]
representing the sorted scores.
sorted_boxes: a tensor representing the sorted boxes.
sorted_scores_indices: a tensor with a shape of [batch_size, num_boxes]
representing the index of the scores in a sorted descending order.


def update(self, **kwargs):
    kwargs = self._preprocess_params(kwargs)
    kwargs = self.preprocess_kwargs_before_update(kwargs)
    for (key, value) in kwargs.iteritems():
        cls = type(self)
        if ((not hasattr(cls, key)) or isinstance(getattr(cls, key), property)):
            continue
        if (key not in self._no_overwrite_):
            setattr(self, key, value)
        if isinstance(getattr(self, key), OrderingList):
            getattr(self, key).reorder()
        elif isinstance(getattr(cls, key), AssociationProxyInstance):
            target_name = getattr(cls, key).target_collection
            target_rel = getattr(self, target_name)
            if isinstance(target_rel, OrderingList):
                target_rel.reorder()
    try:
        self.session.commit()
        return self
    except Exception as e:
        self.session.rollback()
        raise e

Updates an instance.

Args:
**kwargs  :  Arbitrary keyword arguments. Column names are
keywords and their new values are the values.

Examples:

>>> customer.update(email="newemail@x.com", name="new")


def get_voltage(self, cycle=None, dataset_number=None, full=True):

        dataset_number = self._validate_dataset_number(dataset_number)
        if dataset_number is None:
            self._report_empty_dataset()
            return
        cycle_index_header = self.headers_normal.cycle_index_txt
        voltage_header = self.headers_normal.voltage_txt

        test = self.datasets[dataset_number].dfdata
        if cycle:
            self.logger.debug("getting voltage curve for cycle")
            c = test[(test[cycle_index_header] == cycle)]
            if not self.is_empty(c):
                v = c[voltage_header]
                return v
        else:
            if not full:
                self.logger.debug(
                    "getting list of voltage-curves for all cycles"
                )
                v = []
                no_cycles = np.amax(test[cycle_index_header])
                for j in range(1, no_cycles + 1):
                    txt = "Cycle  %i:  " % j
                    self.logger.debug(txt)
                    c = test[(test[cycle_index_header] == j)]
                    v.append(c[voltage_header])
            else:
                self.logger.debug("getting frame of all voltage-curves")
                v = test[voltage_header]
            return v

Returns voltage (in V).

Args:
cycle: cycle number (all cycles if None)
dataset_number: first dataset if None
full: valid only for cycle=None (i.e. all cycles), returns the full
pandas.Series if True, else a list of pandas.Series

Returns:
pandas.Series (or list of pandas.Series if cycle=None og full=False)


def library_line(self, file_name):
    gulplib_set = (lambda : ('GULP_LIB' in os.environ.keys()))
    readable = (lambda f: (os.path.isfile(f) and os.access(f, os.R_OK)))
    gin = ''
    (dirpath, fname) = os.path.split(file_name)
    if (dirpath and readable(file_name)):
        gin = ('library ' + file_name)
    else:
        fpath = os.path.join(os.getcwd(), file_name)
        if readable(fpath):
            gin = ('library ' + fpath)
        elif gulplib_set():
            fpath = os.path.join(os.environ['GULP_LIB'], file_name)
            if readable(fpath):
                gin = ('library ' + file_name)
    if gin:
        return (gin + '\n')
    else:
        raise GulpError('GULP Library not found')

Specifies GULP library file to read species and potential parameters.
If using library don't specify species and potential
in the input file and vice versa. Make sure the elements of
structure are in the library file.

Args:
file_name: Name of GULP library file

Returns:
GULP input string specifying library option


def worker(url_key, property_name, function, function_arguments):
    error_msg = None
    try:
        data = function(*function_arguments)
    except Exception as e:
        data = []
        error_msg = ('Error: ' + traceback.format_exc().strip())
        error_msg += ('\n' + str(e.message))
    if error_msg:
        logger.error(error_msg)
        error_msg = None
    func_name = str(function.__name__)
    logger.info(('Attempting to save output from `%s`.' % func_name))
    return _save_to_database(url=url_key, property_name=property_name, data=data)

This function usually runs as process on the background.

It runs ``function(*function_arguments)`` and then stores them in REST API
storage.

Warning:
This function puts data into DB, isntead of returning them.

Args:
url_key (str): Key which will be used for database lookup.
property_name (str): Name of the property used to store data.
function (obj): Function used to load the data.
function_arguments (list): List of parameters for function which will
be called to retreive data.
error_log_path (str): If set, log errors into this file, otherwise
stderr.


def keywords_special_characters(keywords):

    invalid_chars = '!\"
    if any(char in invalid_chars for char in keywords):
        raise ValidationError(MESSAGE_KEYWORD_SPECIAL_CHARS)

Confirms that the keywords don't contain special characters

Args:
keywords (str)

Raises:
django.forms.ValidationError


def _TerminateProcessByPid(self, pid):
    self._RaiseIfNotRegistered(pid)
    process = self._processes_per_pid[pid]
    self._TerminateProcess(process)
    self._StopMonitoringProcess(process)

Terminate a process that's monitored by the engine.

Args:
pid (int): process identifier (PID).

Raises:
KeyError: if the process is not registered with and monitored by the
engine.


def group_pairs(blocks, layout_blocks_list):

    image_dict={}
    for block_id in layout_blocks_list:
        image_seq=blocks[block_id].ec_hdr.image_seq
        if image_seq not in image_dict:
            image_dict[image_seq]=[block_id]
        else:
            image_dict[image_seq].append(block_id)

    log(group_pairs, 'Layout blocks found at PEBs: %s' % list(image_dict.values()))

    return list(image_dict.values())

Sort a list of layout blocks into pairs

Arguments:
List:blocks        -- List of block objects
List:layout_blocks -- List of layout block indexes

Returns:
List -- Layout block pair indexes grouped in a list


def scheduler(self, sleep_time=0.2):
    while self.listening:
        if self.scheduled_calls:
            timestamp = time.time()
            self.scheduled_calls[:] = [item for item in self.scheduled_calls if (not self.time_reached(timestamp, item))]
        time.sleep(sleep_time)
    logger.info('Shutting down the call scheduler...')

Starts the scheduler to check for scheduled calls and execute them
at the correct time.

Args:
sleep_time (float): The amount of time to wait in seconds between
each loop iteration. This prevents the scheduler from consuming
100% of the host's CPU. Defaults to 0.2 seconds.

Returns:
None


def get_values(self, field_name: str) -> List[object]:
    result = list()
    if self.validate_field(field_name):
        for value_key in self._kg.get(field_name):
            result.append(value_key['value'])
    return result

Get a list of all the values of a field.

Args:
field_name:

Returns: the list of values (not the keys)


def split_field_path(path):

    if not path:
        return []

    elements = []
    want_dot = False

    for element in _tokenize_field_path(path):
        if want_dot:
            if element != ".":
                raise ValueError("Invalid path: {}".format(path))
            else:
                want_dot = False
        else:
            if element == ".":
                raise ValueError("Invalid path: {}".format(path))
            elements.append(element)
            want_dot = True

    if not want_dot or not elements:
        raise ValueError("Invalid path: {}".format(path))

    return elements

Split a field path into valid elements (without dots).

Args:
path (str): field path to be lexed.
Returns:
List(str): tokens
Raises:
ValueError: if the path does not match the elements-interspersed-
with-dots pattern.


def predict_task(self, X, t=0, break_ties='random', **kwargs):
    Y_tp = self.predict_task_proba(X, t=t, **kwargs)
    Y_tph = self._break_ties(Y_tp, break_ties)
    return Y_tph

Predicts int labels for an input X on task t

Args:
X: The input for the predict_task_proba method
t: The task index to predict
Returns:
An n-dim tensor of int predictions for the specified task


def export_artifacts(self, processed_artifacts, sketch_id):
    for (timeline_name, artifact_path) in processed_artifacts:
        print('Uploading {0:s} to timeline {1:s}'.format(artifact_path, timeline_name))
        new_timeline_id = self.upload_timeline(timeline_name, artifact_path)
        self.add_timeline_to_sketch(sketch_id, new_timeline_id)
    return sketch_id

Upload provided artifacts to specified, or new if non-existent, sketch.

Args:
processed_artifacts:  List of (timeline_name, artifact_path) tuples
sketch_id: ID of sketch to append the timeline to

Returns:
int: ID of sketch.


async def skip(self, query='1'):
    if (not (self.state == 'ready')):
        logger.debug("Trying to skip from wrong state '{}'".format(self.state))
        return
    if (query == ''):
        query = '1'
    elif (query == 'all'):
        query = str((len(self.queue) + 1))
    try:
        num = int(query)
    except TypeError:
        self.statuslog.error('Skip argument must be a number')
    except ValueError:
        self.statuslog.error('Skip argument must be a number')
    else:
        self.statuslog.info('Skipping')
        for i in range((num - 1)):
            if (len(self.queue) > 0):
                self.prev_queue.append(self.queue.pop(0))
        try:
            self.streamer.stop()
        except Exception as e:
            logger.exception(e)

The skip command

Args:
query (str): The number of items to skip


def __init__(self, win_registry):

    if not win_registry:
      raise ValueError('Missing Windows Registry value.')

    super(WinRegistrySearcher, self).__init__()
    self._win_registry = win_registry

Initializes a Windows Registry searcher.

Args:
win_registry (WinRegistry): Windows Registry.

Raises:
ValueError: when Windows Registry is not set.


def update_plot_limits(ax, white_space):

    if hasattr(ax, 'zz_dataLim'):
        bounds = ax.xy_dataLim.bounds
        ax.set_xlim(bounds[0] - white_space, bounds[0] + bounds[2] + white_space)
        ax.set_ylim(bounds[1] - white_space, bounds[1] + bounds[3] + white_space)

        bounds = ax.zz_dataLim.bounds
        ax.set_zlim(bounds[0] - white_space, bounds[0] + bounds[2] + white_space)
    else:
        bounds = ax.dataLim.bounds
        assert not any(map(np.isinf, bounds)), 'Cannot set bounds if dataLim has infinite elements'
        ax.set_xlim(bounds[0] - white_space, bounds[0] + bounds[2] + white_space)
        ax.set_ylim(bounds[1] - white_space, bounds[1] + bounds[3] + white_space)

Sets the limit options of a matplotlib plot.

Args:
ax: matplotlib axes
white_space(float): whitespace added to surround the tight limit of the data

Note: This relies on ax.dataLim (in 2d) and ax.[xy, zz]_dataLim being set in 3d


def order_nodes(nodes: Sequence[_OrderableNode]) -> list[_OrderableNode]:
    if not nodes:
        return []
    root = nodes[0]
    predecessor_map = compute_predecessors(nodes)
    dead = {node for node, predecessors in predecessor_map.items() if root not in predecessors}
    queue = {root: predecessor_map[root]}
    order = []
    seen = set()
    while queue:
        _, _, node = min(((len(predecessors), node.id, node) for node, predecessors in queue.items()))
        del queue[node]
        if node in seen:
            continue
        order.append(node)
        seen.add(node)
        for _, predecessors in queue.items():
            predecessors.discard(node)
        for n in node.outgoing:
            if n not in queue:
                queue[n] = predecessor_map[n] - seen
    assert len(set(order) | dead) == len(set(nodes))
    return order

Build an ancestors first traversal of CFG nodes.

This guarantees that at least one predecessor of a block is scheduled before
the block itself, and it also tries to schedule as many of them before the
block as possible (so e.g. if two branches merge in a node, it prefers to
process both the branches before that node).

Args:
nodes: A list of nodes or blocks. They have two attributes: "id" (an int to
enable deterministic sorting) and "outgoing" (a list of nodes).

Returns:
A list of nodes in the proper order.


def list_vms(access_token, subscription_id, resource_group):

    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourceGroups/', resource_group,
                        '/providers/Microsoft.Compute/virtualMachines',
                        '?api-version=', COMP_API])
    return do_get(endpoint, access_token)

List VMs in a resource group.

Args:
access_token (str): A valid Azure authentication token.
subscription_id (str): Azure subscription id.
resource_group (str): Azure resource group name.

Returns:
HTTP response. JSON body of a list of VM model views.


def play(env, transpose=True, fps=30, nop_=0):
    assert isinstance(env.observation_space, gym.spaces.box.Box)
    obs_s = env.observation_space
    is_bw = (len(obs_s.shape) == 2)
    is_rgb = ((len(obs_s.shape) == 3) and (obs_s.shape[2] in [1, 3]))
    assert (is_bw or is_rgb)
    if hasattr(env, 'get_keys_to_action'):
        keys_to_action = env.get_keys_to_action()
    elif hasattr(env.unwrapped, 'get_keys_to_action'):
        keys_to_action = env.unwrapped.get_keys_to_action()
    else:
        raise ValueError('env has no get_keys_to_action method')
    relevant_keys = set(sum(map(list, keys_to_action.keys()), []))
    video_size = (env.observation_space.shape[0], env.observation_space.shape[1])
    if transpose:
        video_size = tuple(reversed(video_size))
    pressed_keys = []
    running = True
    env_done = True
    flags = ((pygame.RESIZABLE | pygame.HWSURFACE) | pygame.DOUBLEBUF)
    screen = pygame.display.set_mode(video_size, flags)
    pygame.event.set_blocked(pygame.MOUSEMOTION)
    if (env.spec is not None):
        pygame.display.set_caption(env.spec.id)
    else:
        pygame.display.set_caption('nes-py')
    clock = pygame.time.Clock()
    while running:
        if env_done:
            env_done = False
            obs = env.reset()
        else:
            action = keys_to_action.get(tuple(sorted(pressed_keys)), nop_)
            (obs, rew, env_done, info) = env.step(action)
        if (obs is not None):
            if (len(obs.shape) == 2):
                obs = obs[(:, :, None)]
            if (obs.shape[2] == 1):
                obs = obs.repeat(3, axis=2)
            display_arr(screen, obs, video_size, transpose)
        for event in pygame.event.get():
            if (event.type == pygame.KEYDOWN):
                if (event.key in relevant_keys):
                    pressed_keys.append(event.key)
                elif (event.key == 27):
                    running = False
                elif (event.key == ord('e')):
                    env.unwrapped._backup()
                elif (event.key == ord('r')):
                    env.unwrapped._restore()
            elif (event.type == pygame.KEYUP):
                if (event.key in relevant_keys):
                    pressed_keys.remove(event.key)
            elif (event.type == pygame.QUIT):
                running = False
        pygame.display.flip()
        clock.tick(fps)
    pygame.quit()

Play the game using the keyboard as a human.

Args:
env (gym.Env): the environment to use for playing
transpose (bool): whether to transpose frame before viewing them
fps (int): number of steps of the environment to execute every second
nop_ (any): the object to use as a null op action for the environment

Returns:
None


class PerceiverAudioPreprocessor(AbstractPreprocessor):

    def __init__(self, config, prep_type: str='patches', samples_per_patch: int=96, position_encoding_type: str='fourier', concat_or_add_pos: str='concat', out_channels=64, project_pos_dim=-1, **position_encoding_kwargs):
        super().__init__()
        self.config = config
        if prep_type not in ('patches',):
            raise ValueError(f"Prep_type {prep_type} is invalid, can only be 'patches'.")
        if concat_or_add_pos not in ['concat', 'add']:
            raise ValueError(f"Concat_or_pos {concat_or_add_pos} is invalid, can only be 'concat' or 'add'.")
        self.samples_per_patch = samples_per_patch
        self.position_encoding_type = position_encoding_type
        self.concat_or_add_pos = concat_or_add_pos
        self.project_pos_dim = project_pos_dim
        self.position_embeddings, self.positions_projection = build_position_encoding(position_encoding_type=position_encoding_type, out_channels=out_channels, project_pos_dim=project_pos_dim, **position_encoding_kwargs)

    @property
    def num_channels(self) -> int:
        if self.project_pos_dim > 0:
            pos_dim = self.project_pos_dim
        else:
            pos_dim = self.position_embeddings.output_size()
        if self.concat_or_add_pos == 'add':
            return pos_dim
        return self.samples_per_patch + pos_dim

    def _build_network_inputs(self, inputs):

        batch_size = inputs.shape[0]
        index_dims = inputs.shape[1:-1]
        if self.position_encoding_type == 'trainable':
            pos_enc = self.position_embeddings(batch_size)
        elif self.position_encoding_type == 'fourier':
            pos_enc = self.position_embeddings(index_dims, batch_size, device=inputs.device, dtype=inputs.dtype)
        pos_enc = self.positions_projection(pos_enc)
        if self.concat_or_add_pos == 'concat':
            inputs_with_pos = torch.cat([inputs, pos_enc], dim=-1)
        elif self.concat_or_add_pos == 'add':
            inputs_with_pos = inputs + pos_enc
        return (inputs_with_pos, inputs)

    def forward(self, inputs: torch.Tensor, pos: Optional[torch.Tensor]=None, network_input_is_1d: bool=True, interpolate_pos_encoding: bool=False):
        inputs = torch.reshape(inputs, [inputs.shape[0], -1, self.samples_per_patch])
        inputs, inputs_without_pos = self._build_network_inputs(inputs)
        modality_sizes = None
        return (inputs, modality_sizes, inputs_without_pos)

Audio preprocessing for Perceiver Encoder.

Args:
config ([*PerceiverConfig*]):
Model configuration.
prep_type (`str`, *optional*, defaults to `"patches"`):
Preprocessor type to use. Only "patches" is supported.
samples_per_patch (`int`, *optional*, defaults to 96):
Number of samples per patch.
position_encoding_type (`str`, *optional*, defaults to `"fourier"`):
Type of position encoding to use. Can be "trainable" or "fourier".
concat_or_add_pos (`str`, *optional*, defaults to `"concat"`):
How to concatenate the position encoding to the input. Can be "concat" or "add".
out_channels (`int`, *optional*, defaults to 64):
Number of channels in the output.
project_pos_dim (`int`, *optional*, defaults to -1):
Dimension of the position encoding to project to. If -1, no projection is applied.
**position_encoding_kwargs (`Dict`, *optional*):
Keyword arguments for the position encoding.


def get_node_sum(self, age=None):
    if (age is None):
        age = self.age
    return (age if (self.comp == 1) else int(((pow(self.comp, (age + 1)) - 1) / (self.comp - 1))))

Get sum of all branches in the tree.

Returns:
int: The sum of all nodes grown until the age.


def expand(self, *args, **kwargs):
    if args:
        if (len(args) == 1):
            data_dict = args[0]
            trace = kwargs.get('trace')
            style = kwargs.get('style')
        else:
            raise TypeError(('expand() only takes 1 positional argument (got %s)' % args))
    else:
        data_dict = kwargs
        trace = None
        style = None
    tokens = []
    group = _MakeGroupFromRootSection(self._program, self.undefined_str)
    if style:
        style.execute(data_dict, tokens.append, group=group, trace=trace)
    else:
        self.execute(data_dict, tokens.append, group=group, trace=trace)
    return JoinTokens(tokens)

Expands the template with the given data dictionary, returning a string.

This is a small wrapper around execute(), and is the most convenient
interface.

Args:
data_dict: The JSON data dictionary.  Like the builtin dict() constructor,
it can take a single dictionary as a positional argument, or arbitrary
keyword arguments.
trace: Trace object for debugging
style: Template instance to be treated as a style for this template (the
"outside")

Returns:
The return value could be a str() or unicode() instance, depending on the
the type of the template string passed in, and what the types the strings
in the dictionary are.


def _close_rpc_interface(self, connection_id, callback):
    try:
        context = self.connections.get_context(connection_id)
    except ArgumentError:
        callback(connection_id, self.id, False, 'Could not find connection information')
        return
    self.connections.begin_operation(connection_id, 'close_interface', callback, self.get_config('default_timeout'))
    try:
        service = context['services'][TileBusService]
        header_characteristic = service[ReceiveHeaderChar]
        payload_characteristic = service[ReceivePayloadChar]
    except KeyError:
        self.connections.finish_operation(connection_id, False, "Can't find characteristics to open rpc interface")
        return
    self.bable.set_notification(enabled=False, connection_handle=context['connection_handle'], characteristic=header_characteristic, on_notification_set=[self._on_interface_closed, context, payload_characteristic], timeout=1.0)

Disable RPC interface for this IOTile device

Args:
connection_id (int): The unique identifier for the connection
callback (callback): Callback to be called when this command finishes
callback(conn_id, adapter_id, success, failure_reason)


def set_invite_only(self, invite_only):
    join_rule = ('invite' if invite_only else 'public')
    try:
        self.client.api.set_join_rule(self.room_id, join_rule)
        self.invite_only = invite_only
        return True
    except MatrixRequestError:
        return False

Set how the room can be joined.

Args:
invite_only(bool): If True, users will have to be invited to join
the room. If False, anyone who knows the room link can join.

Returns:
True if successful, False if not


def add_data(self, data):
    if (self.state == self.ErrorState):
        return
    self.raw_data += bytearray(data)
    still_processing = True
    while still_processing:
        still_processing = self.process_data()

Add data to our stream, emitting reports as each new one is seen

Args:
data (bytearray): A chunk of new data to add


def occurrence(self, indicator=None):
    self._request_entity = 'fileOccurrence'
    self._request_uri = '{}/fileOccurrences'.format(self._request_uri)
    if (indicator is not None):
        self._request_uri = '{}/{}/fileOccurrences'.format(self._api_uri, indicator)

Update the URI to retrieve file occurrences for the provided indicator.

Args:
indicator (string): The indicator to retrieve file occurrences.


def export(self, filepath, encoding="utf-8", gzipped=True):

        data = json.dumps(self.word_frequency.dictionary, sort_keys=True)
        write_file(filepath, encoding, gzipped, data)

Export the word frequency list for import in the future

Args:
filepath (str): The filepath to the exported dictionary
encoding (str): The encoding of the resulting output
gzipped (bool): Whether to gzip the dictionary or not


def set_query_parameter(url, param_name, param_value):
    (scheme, netloc, path, query_string, fragment) = urlsplit(url)
    query_params = parse_qs(query_string)
    query_params[param_name] = [param_value]
    new_query_string = urlencode(query_params, doseq=True)
    return urlunsplit((scheme, netloc, path, new_query_string, fragment))

Given a URL, set or replace a query parameter and return the modified URL.

Args:
url: a given  URL
param_name: the parameter name to add
param_value: the parameter value
Returns:
URL with the added parameter


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

        data = self.get_data('floating_ips/',
                             type=POST,
                             params={'droplet_id': self.droplet_id})

        if data:
            self.ip = data['floating_ip']['ip']
            self.region = data['floating_ip']['region']

        return self

Creates a FloatingIP and assigns it to a Droplet.

Note: Every argument and parameter given to this method will be
assigned to the object.

Args:
droplet_id: int - droplet id


def thumbnail(self, image: np.ndarray, size: Dict[str, int], resample: PILImageResampling=PILImageResampling.BICUBIC, data_format: Optional[Union[str, ChannelDimension]]=None, input_data_format: Optional[Union[str, ChannelDimension]]=None, **kwargs) -> np.ndarray:
    input_height, input_width = get_image_size(image, channel_dim=input_data_format)
    output_height, output_width = (size['height'], size['width'])
    height = min(input_height, output_height)
    width = min(input_width, output_width)
    if height == input_height and width == input_width:
        return image
    if input_height > input_width:
        width = int(input_width * height / input_height)
    elif input_width > input_height:
        height = int(input_height * width / input_width)
    return resize(image, size=(height, width), resample=resample, reducing_gap=2.0, data_format=data_format, input_data_format=input_data_format, **kwargs)

Resize the image to make a thumbnail. The image is resized so that no dimension is larger than any
corresponding dimension of the specified size.

Args:
image (`np.ndarray`):
The image to be resized.
size (`Dict[str, int]`):
The size `{"height": h, "width": w}` to resize the image to.
resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BICUBIC`):
The resampling filter to use.
data_format (`Optional[Union[str, ChannelDimension]]`, *optional*):
The data format of the output image. If unset, the same format as the input image is used.
input_data_format (`ChannelDimension` or `str`, *optional*):
The channel dimension format of the input image. If not provided, it will be inferred.


def _read_transitions(self):

        states = []
        i = 0
        regex = re.compile('[ \t\n\r:,]+')
        found = 0
        state = 0
        substate = 0
        mapping = []
        cur_line = None
        with open(self.outfile) as flex_file:
            for cur_line in flex_file:
                if cur_line[0:35] == "static yyconst flex_int16_t yy_nxt[" or cur_line[0:33] == "static const flex_int16_t yy_nxt[":
                    found = 1

                    continue
                if found == 1:
                    if state == 0 and cur_line[0:5] == "    {":
                        state = 1
                        continue
                    if state == 1 and cur_line[0:7] == "    } ;":
                        state = 0
                        break

                    if substate == 0 and cur_line[0:5] == "    {":
                        mapping = []
                        substate = 1
                        continue
                    if substate == 1:
                        if cur_line[0:6] != "    },":
                            cur_line = "".join(cur_line.split())
                            if cur_line == '':
                                continue
                            if cur_line[cur_line.__len__() - 1] == ',':
                                splitted_line = regex.split(
                                    cur_line[:cur_line.__len__() - 1])
                            else:
                                splitted_line = regex.split(cur_line)
                            mapping = mapping + splitted_line
                            continue
                        else:
                            cleared = []
                            for j in mapping:
                                cleared.append(int(j))
                            states.append(cleared)
                            mapping = []
                            substate = 0

        return states

Read DFA transitions from flex compiled file
Args:
None
Returns:
list: The list of states and the destination for a character


def cctop_save_xml(jobid, outpath):
    status = cctop_check_status(jobid=jobid)
    if (status == 'Finished'):
        result = 'http:
        result_text = requests.post(result)
        with open(outpath, 'w') as f:
            f.write(result_text.text)
        return outpath
    else:
        raise ConnectionRefusedError('CCTOP job incomplete, status is "{}"'.format(status))

Save the CCTOP results file in XML format.

Args:
jobid (str): Job ID obtained when job was submitted
outpath (str): Path to output filename

Returns:
str: Path to output filename


def enable_beacon(name, **kwargs):

    ret = {'comment': [],
           'result': True}

    if not name:
        ret['comment'] = 'Beacon name is required.'
        ret['result'] = False
        return ret

    if 'test' in kwargs and kwargs['test']:
        ret['comment'] = 'Beacon {0} would be enabled.'.format(name)
    else:
        _beacons = list_(return_yaml=False, **kwargs)
        if name not in _beacons:
            ret['comment'] = 'Beacon {0} is not currently configured.' \
                             ''.format(name)
            ret['result'] = False
            return ret

        try:
            eventer = salt.utils.event.get_event('minion', opts=__opts__)
            res = __salt__['event.fire']({'func': 'enable_beacon',
                                          'name': name},
                                         'manage_beacons')
            if res:
                event_ret = eventer.get_event(
                    tag='/salt/minion/minion_beacon_enabled_complete',
                    wait=kwargs.get('timeout', 30))
                if event_ret and event_ret['complete']:
                    beacons = event_ret['beacons']
                    beacon_config_dict = _get_beacon_config_dict(beacons[name])

                    if 'enabled' in beacon_config_dict and beacon_config_dict['enabled']:
                        ret['result'] = True
                        ret['comment'] = 'Enabled beacon {0} on minion.' \
                                         ''.format(name)
                    else:
                        ret['result'] = False
                        ret['comment'] = 'Failed to enable beacon {0} on ' \
                                         'minion.'.format(name)
                elif event_ret:
                    ret['result'] = False
                    ret['comment'] = event_ret['comment']
                else:
                    ret['result'] = False
                    ret['comment'] = 'Did not receive the manage event ' \
                                     'before the timeout of {0}s' \
                                     ''.format(kwargs.get('timeout', 30))
                return ret
        except KeyError:

            ret['result'] = False
            ret['comment'] = 'Event module not available. Beacon enable job ' \
                             'failed.'
    return ret

Enable a beacon on the minion.

Args:
name (str): Name of the beacon to enable.

Returns:
dict: Boolean and status message on success or failure of enable.

CLI Example:

.. code-block:: bash

salt '*' beacons.enable_beacon ps


def _set_input(el, value):
    if isinstance(value, dict):
        el.value = value['val']
    elif (type(value) in [list, tuple]):
        el.value = ', '.join((item['val'] for item in value))
    else:
        el.value = value

Set content of given `el` to `value`.

Args:
el (obj): El reference to input you wish to set.
value (obj/list): Value to which the `el` will be set.


def city(self, value=None):

        if value is not None:
            try:
                value = str(value)
            except ValueError:
                raise ValueError('value {} need to be of type str '
                                 'for field `city`'.format(value))
            if ',' in value:
                raise ValueError('value should not contain a comma '
                                 'for field `city`')

        self._city = value

Corresponds to IDD Field `city`

Args:
value (str): value for IDD Field `city`
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 add_grad(left, right):
    assert ((left is not None) and (right is not None))
    left_type = type(left)
    right_type = type(right)
    if (left_type is ZeroGradient):
        return right
    if (right_type is ZeroGradient):
        return left
    return grad_adders[(left_type, right_type)](left, right)

Recursively add the gradient of two objects.

Args:
left: The left value to add. Can be either an array, a number, list or
dictionary.
right: The right value. Must be of the same type (recursively) as the left.

Returns:
The sum of the two gradients, which will of the same type.


def singleprint_from_saved_model(export_dir: str) -> str:
    try:
        return singleprint_from_fingerprint_proto(export_dir)
    except ValueError:
        pass
    try:
        write_fingerprint(export_dir)
        return singleprint_from_fingerprint_proto(export_dir)
    except ValueError:
        pass
    try:
        return singleprint_from_saved_model_proto(export_dir)
    except ValueError as e:
        raise ValueError(e) from None

Returns the singleprint of the SavedModel in `export_dir`.

First tries to construct the singleprint from `fingerprint.pb`, then from
`saved_model.pb`. Attempts to write the `fingerprint.pb` if not found, but
doesn't return an error if it isn't writeable.

Args:
export_dir: The directory that contains the SavedModel.

Returns:
A string containing the singleprint of the SavedModel in `export_dir`.

Raises:
ValueError: If a valid singleprint cannot be constructed from the
SavedModel.


def try_checkpoint_metadata(self, trial):
    if (trial._checkpoint.storage == Checkpoint.MEMORY):
        logger.debug('Not saving data for trial w/ memory checkpoint.')
        return
    try:
        logger.debug('Saving trial metadata.')
        self._cached_trial_state[trial.trial_id] = trial.__getstate__()
    except Exception:
        logger.exception('Error checkpointing trial metadata.')

Checkpoints metadata.

Args:
trial (Trial): Trial to checkpoint.


def __init__(self,
               text_encoder_config=None,
               language_pair=(None, None),
               **kwargs):

    encoder_name = (
        text_encoder_config.name if text_encoder_config else "plain_text")
    name = "%s%s_%s" % (language_pair[0], language_pair[1], encoder_name)

    description = (
        "Translation dataset from %s to %s, uses encoder %s.") % (
            language_pair[0], language_pair[1], encoder_name)
    super(FloresConfig, self).__init__(
        name=name, description=description, **kwargs)
    self.text_encoder_config = (
        text_encoder_config or tfds.features.text.TextEncoderConfig())

    assert "en" in language_pair, (
        "Config language pair must contain `en`, got: %s",
        self.builder_config.language_pair)
    source, target = language_pair
    non_en = source if target == "en" else target
    assert non_en in ["ne", "si"], (
        "Invalid non-en language in pair: %s", non_en)

    self.language_pair = language_pair

BuilderConfig for FLoRes.

Args:
text_encoder_config: `tfds.features.text.TextEncoderConfig`, configuration
for the `tfds.features.text.TextEncoder` used for the features feature.
language_pair: pair of languages that will be used for translation. Should
contain 2-letter coded strings. First will be used at source and second
as target in supervised mode. For example: ("se", "en").
**kwargs: keyword arguments forwarded to super.


def python_value(self, value):
    value = super(PendulumDateTimeField, self).python_value(value)
    if isinstance(value, datetime.datetime):
        value = pendulum.instance(value)
    elif isinstance(value, datetime.date):
        value = pendulum.instance(datetime.datetime.combine(value, datetime.datetime.min.time()))
    elif isinstance(value, string_types):
        value = pendulum.parse(value)
    return value

Return the value in the database as an Pendulum object.

Returns:
pendulum.Pendulum:
An instance of Pendulum with the field filled in.


def inspect_volume(self, name):
    url = self._url('/volumes/{0}', name)
    return self._result(self._get(url), True)

Retrieve volume info by name.

Args:
name (str): volume name

Returns:
(dict): Volume information dictionary

Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.

Example:

>>> cli.inspect_volume('foobar')
{u'Driver': u'local',
u'Mountpoint': u'/var/lib/docker/volumes/foobar/_data',
u'Name': u'foobar'}


def get_chief_queue_runner(self):
    if self._gradients_applied is False:
        raise ValueError('Should be called after apply_gradients().')
    return self._chief_queue_runner

Returns the QueueRunner for the chief to execute.

This includes the operations to synchronize replicas: aggregate gradients,
apply to variables, increment global step, insert tokens to token queue.

Note that this can only be called after calling apply_gradients() which
actually generates this queuerunner.

Returns:
A `QueueRunner` for chief to execute.

Raises:
ValueError: If this is called before apply_gradients().


def recipe_url(config, auth, status, read, dataset, table):
    url(config, {'auth': auth, 'status': status, 'read': read, 'urls': {'bigquery': {'dataset': dataset, 'query': table, 'legacy': False}}, 'to': {'bigquery': {'dataset': dataset, 'table': table}}})

Pull URL list from a table, fetch them, and write the results to another table.

Args:
auth (authentication) - Credentials used for rading and writing data.
status (boolean) - Pull status of HTTP request.
read (boolean) - Pull data from HTTP request.
dataset (string) - Name of Google BigQuery dataset to write.
table (string) - Name of Google BigQuery table to write.


def _get_num_multimodal_tokens(self, image_sizes=None, video_sizes=None, **kwargs):
    vision_data = {}
    if image_sizes is not None:
        images_kwargs = LlavaOnevisionProcessorKwargs._defaults.get('images_kwargs', {})
        images_kwargs.update(kwargs)
        size = images_kwargs.get('size', None) or self.image_processor.size
        size = (size['shortest_edge'], size['shortest_edge']) if 'shortest_edge' in size else (min(size['height'], size['width']), min(size['height'], size['width']))
        processed_height, processed_width = size
        batch_num_image_tokens = []
        num_image_patches = [1] * len(image_sizes)
        for image_size in image_sizes:
            orig_height, orig_width = image_size
            num_image_tokens = self._get_number_of_features(orig_height, orig_width, processed_height, processed_width)
            if self.vision_feature_select_strategy == 'default':
                num_image_tokens -= 1
            batch_num_image_tokens.append(num_image_tokens)
        vision_data.update({'num_image_tokens': batch_num_image_tokens, 'num_image_patches': num_image_patches})
    return MultiModalData(**vision_data)

Computes the number of placeholder tokens needed for multimodal inputs with the given sizes.
Args:
image_sizes (List[List[str]], *optional*):
The input sizes formatted as (height, width) per each image.
video_sizes (List[List[str]], *optional*):
The input sizes formatted as (num_frames, height, width) per each video.
audio_lengths (List[int], *optional*):
The input length formatted as per each audio.
Returns:
Dict[str, List[int]]: A dictionary mapping each modality ("image", "video", "audio")
to a list containing the number of placeholder tokens required. If the model doesn't accept
a certain modality or no input sizes are provided, the dict value is set to an empty list.


def align_up(offset, align):

    remain = offset % align
    if remain == 0:
        return offset
    else:
        return offset + (align - remain)

Align ``offset`` up to ``align`` boundary.

Args:
offset (int): value to be aligned.
align (int): alignment boundary.

Returns:
int: aligned offset.

>>> align_up(3, 2)
4

>>> align_up(3, 1)
3


def get_pe(self):
    return PE(self.rest_client.make_request(self.pe), self.rest_client)

Get the Streams processing element this operator is executing in.

Returns:
PE: Processing element for this operator.

.. versionadded:: 1.9


def ParseOptions(cls, options, output_module):

    if not isinstance(output_module, sqlite_4n6time.SQLite4n6TimeOutputModule):
      raise errors.BadConfigObject(
          'Output module is not an instance of SQLite4n6TimeOutputModule')

    shared_4n6time_output.Shared4n6TimeOutputArgumentsHelper.ParseOptions(
        options, output_module)

    filename = getattr(options, 'write', None)
    if not filename:
      raise errors.BadConfigOption(
          'Output filename was not provided use "-w filename" to specify.')

    output_module.SetFilename(filename)

Parses and validates options.

Args:
options (argparse.Namespace): parser options.
output_module (OutputModule): output module to configure.

Raises:
BadConfigObject: when the output module object is of the wrong type.
BadConfigOption: when the output filename was not provided.


def recommend(self, limit=10):

        expected_list = [(arm_id, beta_dist.expected_value()) for arm_id, beta_dist in self.__beta_dist_dict.items()]
        expected_list = sorted(expected_list, key=lambda x: x[1], reverse=True)
        return expected_list[:limit]

Listup arms and expected value.

Args:
limit:      Length of the list.

Returns:
[Tuple(`Arms master id`, `expected value`)]


def get_parameter_dict(self, include_frozen=False):

        return OrderedDict(zip(
            self.get_parameter_names(include_frozen=include_frozen),
            self.get_parameter_vector(include_frozen=include_frozen),
        ))

Get an ordered dictionary of the parameters

Args:
include_frozen (Optional[bool]): Should the frozen parameters be
included in the returned value? (default: ``False``)


def get_contact(self, jid):
    try:
        return self.get_contacts()[jid.bare()]
    except KeyError:
        raise ContactNotFound
    except AttributeError:
        raise AttributeError('jid must be an aioxmpp.JID object')

Returns a contact

Args:
jid (aioxmpp.JID): jid of the contact

Returns:
dict: the roster of contacts


def pad_sparse_embedding_lookup_indices(sparse_indices, padded_size):
    batch_size = sparse_indices.dense_shape[0]
    sparse_indices = sparse_ops.sparse_slice(sparse_indices, [0, 0], [batch_size, padded_size])
    indices, values = (sparse_indices.indices, sparse_indices.values)
    padded_values = array_ops.scatter_nd(indices, math_ops.cast(values, dtypes.int32), shape=(batch_size, padded_size))
    weights = array_ops.ones_like(values, dtype=dtypes.float32)
    padded_mask = array_ops.scatter_nd(indices, weights, shape=(batch_size, padded_size))
    return (padded_values, padded_mask)

Creates statically-sized Tensors containing indices and weights.

From third_party/cloud_tpu/models/movielens/tpu_embedding.py

Also computes sparse_indices.values % embedding_table_size, for equivalent
functionality to sparse_column_with_integerized_feature. The returned
padded weight Tensor also doubles as a mask indicating which values in
the returned padded indices Tensor are indices versus padded zeros.

Args:
sparse_indices: SparseTensor of embedding lookup indices.
padded_size: Number of columns of the returned Tensors. Indices which fall
out of bounds will be truncated to the padded size.

Returns:
(sparse_indices.values padded to the specified size,
a mask the same size as the returned padded values in which 0s
indicate padded locations and 1s (or values from sparse_weights)
indicate actual values)


def dumps(ms, single=False, properties=False, pretty_print=True, show_status=False, predicate_modifiers=False, **kwargs):
    if ((not pretty_print) and kwargs.get('indent')):
        pretty_print = True
    if single:
        ms = [ms]
    return serialize(ms, properties=properties, pretty_print=pretty_print, show_status=show_status, predicate_modifiers=predicate_modifiers, **kwargs)

Serialize an Xmrs object to a Eds representation

Args:
ms: an iterator of :class:`~delphin.mrs.xmrs.Xmrs` objects to
serialize (unless the *single* option is `True`)
single (bool): if `True`, treat *ms* as a single
:class:`~delphin.mrs.xmrs.Xmrs` object instead of as an
iterator
properties (bool): if `False`, suppress variable properties
pretty_print (bool): if `True`, add newlines and indentation
show_status (bool): if `True`, annotate disconnected graphs and
nodes
Returns:
an :class:`Eds` string representation of a corpus of Xmrs


def _confirm_overwrite(filename):

        message = '{}Would you like to overwrite the contents of {} (y/[n])? '.format(
            c.Fore.MAGENTA, filename
        )

        response = raw_input(message)
        response = response.lower()

        if response in ['y', 'yes']:
            return True
        return False

Confirm overwrite of template files.

Make sure the user would like to continue downloading a file which will overwrite a file
in the current directory.

Args:
filename (str): The name of the file to overwrite.

Returns:
bool: True if the user specifies a "yes" response.


def parse_date_range(date, alt_end_date=None):
    NOT_ENDED = '9999'
    all_years = re.findall('\\d{4}', date)
    if alt_end_date:
        NOT_ENDED = alt_end_date
    if (not all_years):
        return ('****', NOT_ENDED)
    elif (len(all_years) == 1):
        return (all_years[0], NOT_ENDED)
    return (all_years[0], all_years[1])

Parse input `date` string in free-text format for four-digit long groups.

Args:
date (str): Input containing years.

Returns:
tuple: ``(from, to)`` as four-digit strings.


def int_to_str_digit(n):

    if n < 10:
        return str(n)

    elif n < 36:
        return chr(n + 55)

    else:
        return chr(n + 61)

Converts a positive integer, to a single string character.
Where: 9 -> "9", 10 -> "A", 11 -> "B", 12 -> "C", ...etc

Args:
n(int): A positve integer number.

Returns:
The character representation of the input digit of value n (str).


def validate_list(self, value):
    if (len(value) > self.max_items):
        raise ValidationError(u'list must not contain more than {max_items} items.'.format(max_items=self.max_items))
    if (all((isinstance(item, six.string_types) for item in value)) is False):
        raise ValidationError(u'list must only contain strings.')
    return value

Validate data before saving to database.

Arguemtns:
value(list): list to be validated

Returns:
list if validation is successful

Raises:
ValidationError


def __init__(self, resolver_context, encoding='utf-8'):

    super(TARFileSystem, self).__init__(resolver_context)
    self._file_object = None
    self._tar_file = None
    self.encoding = encoding

Initializes a file system.

Args:
resolver_context (Context): resolver context.
encoding (Optional[str]): file entry name encoding.


def replace_list(items, match, replacement):
    return [replace(item, match, replacement) for item in items]

Replaces occurrences of a match string in a given list of strings and returns
a list of new strings. The match string can be a regex expression.

Args:
items (list):       the list of strings to modify.
match (str):        the search expression.
replacement (str):  the string to replace with.


def get_metric_fns(metric_names, labels, outputs):
    metric_fns = {}
    for metric_name in metric_names:
        metric_fn_name = metric_name.split('/')[(- 1)]
        if hasattr(metrics, metric_fn_name):
            metric_fn = getattr(metrics, metric_fn_name)
            metric_fns[metric_name] = metric_fn(labels, outputs)
        else:
            raise ValueError('Metric {} is not implemented'.format(metric_fn_name))
    return metric_fns

Generate a dictionary of metric name to metric function.

Args:
metric_names: list of strings in the format "prefix/metric_function_name".
metric_function_name should refer to a function name in metrics.py. The
prefix will be included in the key in the returned dict.
labels: a tensor where batch is the first dimension.
outputs: a tensor of model predictions, same dimensionality as labels.

Returns:
metric_fns: dict of metric functions keyed by their name.


def get_plot_frame(map_obj, key_map, cached=False):
    if (map_obj.kdims and (len(map_obj.kdims) == 1) and (map_obj.kdims[0] == 'Frame')):
        return map_obj.last
    key = tuple((key_map[kd.name] for kd in map_obj.kdims if (kd.name in key_map)))
    if ((key in map_obj.data) and cached):
        return map_obj.data[key]
    else:
        try:
            return map_obj[key]
        except KeyError:
            return None
        except StopIteration as e:
            raise e
        except Exception:
            print(traceback.format_exc())
            return None

Returns the current frame in a mapping given a key mapping.

Args:
obj: Nested Dimensioned object
key_map: Dictionary mapping between dimensions and key value
cached: Whether to allow looking up key in cache

Returns:
The item in the mapping corresponding to the supplied key.


def assemble(ops, target=None):

    target = get_py_internals(target)

    opmap = target['opmap']
    hasjrel = target['hasjrel']
    hasjabs = target['hasjabs']
    hasjump = set(hasjrel) | set(hasjabs)
    have_argument = target['have_argument']
    extended_arg = target['extended_arg']
    wordcode = target['wordcode']

    if not wordcode:
        def encode_op(output, op_code, op_arg=None):
            n = 1
            if op_arg is None:
                output.append(op_code)
            else:
                n += 2
                ext_arg = op_arg >> 16
                if ext_arg:
                    n += 3
                    output.extend([extended_arg, ext_arg & 255, ext_arg >> 8])
                    op_arg &= 65535
                output.extend([op_code, op_arg & 255, op_arg >> 8])
            return n
    else:
        def encode_op(output, op_code, op_arg=None):
            n = 2
            if op_arg is None:
                output.extend([op_code, 0])
            else:
                ext_arg = op_arg >> 8
                if ext_arg:
                    n += encode_op(extended_arg, ext_arg)
                output.extend([op_code, op_arg & 255])
            return n

    label_address = {}
    while True:
        retry = False
        output = bytearray()
        address = 0

        for op in ops:
            if isinstance(op, Label):
                if label_address.get(op) != address:
                    retry = True
                    label_address[op] = address
                continue

            op_code = opmap[op.name]
            op_arg = op.arg

            if op_code >= have_argument and op_arg is None:

                raise ValueError('Opcode %s requires argument.' % op)
            elif op_code < have_argument and op_arg is not None:

                raise ValueError('Opcode %s should not have an argument.' % op)
            elif isinstance(op_arg, Label):
                if op_code not in hasjump:

                    raise ValueError('Did not expect label as argument for opcode %s.' % op)

                if op_arg not in ops:

                    raise ValueError('Label is not part of this op list.')

                op_arg = label_address.get(op_arg)
                if op_arg is None:

                    address += encode_op(output, op_code, 0)
                    continue

                if op_code in hasjrel:
                    op_arg -= address
            elif op_code in hasjump:

                raise ValueError('Expected label as argument for opcode %s.' % op)

            n = encode_op(output, op_code, op_arg)
            address += n

            if op_code in hasjrel:
                if not wordcode:
                    op_arg = output[-2] + (output[-1] << 8)
                    if op_arg < n:
                        ext_arg = output[-5] + (output[-4] << 8) - 1
                        output[-5], output[-4] = ext_arg & 255, ext_arg >> 8
                        op_arg += 65536
                    op_arg -= n
                    output[-2], output[-1] = op_arg & 255, op_arg >> 8
                else:
                    for i in itertools.count(1, 2):
                        if n <= output[-i]:
                            output[-i] -= n
                            break
                        output[-i] += 256 - n
                        n = 1

        if not retry:
            return bytes(output)

Assemble a set of :class:`Op` and :class:`Label` instance back into
bytecode.

Arguments:
ops(list): A list of opcodes and labels (as returned by
:func:`disassemble`).
target: The opcode specification of the targeted python
version. If this is ``None`` the specification of the currently
running python version will be used.

Returns:
bytes: The assembled bytecode.


def response_data_to_model_instance(self, response_data):

        response_data["datetime_created"] = dateutil.parser.parse(
            response_data["datetime_created"]
        )

        return super(
            BaseTaskTypeManager, self
        ).response_data_to_model_instance(response_data)

Convert response data to a task type model.

Args:
response_data (dict): The data from the request's response.

Returns:
:class:`saltant.models.base_task_type.BaseTaskType`:
A model instance representing the task type from the
reponse data.


def _CreateUserIdentifier(identifier_type=None, value=None):

  if identifier_type in _HASHED_IDENTIFIER_TYPES:

    value = hashlib.sha256(value.strip().lower()).hexdigest()

  user_identifier = {
      'userIdentifierType': identifier_type,
      'value': value
  }

  return user_identifier

Creates a user identifier from the specified type and value.

Args:
identifier_type: a str specifying the type of user identifier.
value: a str value of the identifier; to be hashed using SHA-256 if needed.

Returns:
A dict specifying a user identifier, with a value hashed using SHA-256 if
needed.


def _BiasAddGradGrad(op: ops.Operation, received_grad):
    try:
        data_format = op.get_attr('data_format')
    except ValueError:
        data_format = None
    shape = array_ops.shape(op.inputs[0])
    bias_shape = array_ops.shape(received_grad)
    if data_format == b'NCHW':
        expanded_shape = array_ops.concat([array_ops.ones_like(shape[:1]), bias_shape, array_ops.ones_like(shape[2:])], 0)
        tile_mults = array_ops.concat([shape[:1], [1], shape[2:]], 0)
    else:
        expanded_shape = array_ops.concat([array_ops.ones_like(shape[:-1]), bias_shape], 0)
        tile_mults = array_ops.concat([shape[:-1], [1]], 0)
    expanded_grad = array_ops.reshape(received_grad, expanded_shape)
    return array_ops.tile(expanded_grad, tile_mults)

Gradient for the BiasAddGrad op.

Args:
op: BiasAddGrad op for which we are calculating gradients.
received_grad: The gradients passed to the BiasAddGrad op.

Returns:
A single gradient Tensor for the input to BiasAddGrad (which
is the gradient of the bias term in BiasAdd)


def post_content(url, headers={}, post_data={}, decoded=True, **kwargs):
    if kwargs.get('post_data_raw'):
        logging.debug(('post_content: %s\npost_data_raw: %s' % (url, kwargs['post_data_raw'])))
    else:
        logging.debug(('post_content: %s\npost_data: %s' % (url, post_data)))
    req = request.Request(url, headers=headers)
    if cookies:
        cookies.add_cookie_header(req)
        req.headers.update(req.unredirected_hdrs)
    if kwargs.get('post_data_raw'):
        post_data_enc = bytes(kwargs['post_data_raw'], 'utf-8')
    else:
        post_data_enc = bytes(parse.urlencode(post_data), 'utf-8')
    response = urlopen_with_retry(req, data=post_data_enc)
    data = response.read()
    content_encoding = response.getheader('Content-Encoding')
    if (content_encoding == 'gzip'):
        data = ungzip(data)
    elif (content_encoding == 'deflate'):
        data = undeflate(data)
    if decoded:
        charset = match1(response.getheader('Content-Type'), 'charset=([\\w-]+)')
        if (charset is not None):
            data = data.decode(charset)
        else:
            data = data.decode('utf-8')
    return data

Post the content of a URL via sending a HTTP POST request.

Args:
url: A URL.
headers: Request headers used by the client.
decoded: Whether decode the response body using UTF-8 or the charset specified in Content-Type.

Returns:
The content as a string.


def mahalanobis_distances(df, axis=0):
    df = (df.transpose() if (axis == 1) else df)
    means = df.mean()
    try:
        inv_cov = np.linalg.inv(df.cov())
    except LinAlgError:
        return pd.Series(([np.NAN] * len(df.index)), df.index, name='Mahalanobis')
    dists = []
    for (i, sample) in df.iterrows():
        dists.append(mahalanobis(sample, means, inv_cov))
    return pd.Series(dists, df.index, name='Mahalanobis')

Returns a pandas Series with Mahalanobis distances for each sample on the
axis.

Note: does not work well when # of observations < # of dimensions
Will either return NaN in answer
or (in the extreme case) fail with a Singular Matrix LinAlgError

Args:
df: pandas DataFrame with columns to run diagnostics on
axis: 0 to find outlier rows, 1 to find outlier columns


def get_course_current_grades(self, course_id):

        resp = self.requester.get(
            urljoin(
                self.base_url,
                '/api/grades/v1/courses/{course_key}/'.format(course_key=course_id)
            )
        )
        resp.raise_for_status()
        resp_json = resp.json()
        if 'results' in resp_json:
            grade_entries = [CurrentGrade(entry) for entry in resp_json["results"]]
            while resp_json['next'] is not None:
                resp = self.requester.get(resp_json['next'])
                resp.raise_for_status()
                resp_json = resp.json()
                grade_entries.extend((CurrentGrade(entry) for entry in resp_json["results"]))
        else:
            grade_entries = [CurrentGrade(entry) for entry in resp_json]

        return CurrentGradesByCourse(grade_entries)

Returns a CurrentGradesByCourse object for all users in the specified course.

Args:
course_id (str): an edX course ids.

Returns:
CurrentGradesByCourse: object representing the student current grades

Authorization:
The authenticated user must have staff permissions to see grades for all users
in a course.


def _form_output(span_doc: span, output_format: str, relations: Dict, patterns: List) -> str:

        format_value = []
        output_inf = [a_pattern.in_output for a_pattern in patterns]
        for i in range(len(output_inf)):
            token_range = relations[i]
            if token_range and output_inf[i]:
                format_value.append(span_doc[token_range[0]:token_range[1]].text)

        if not output_format:
            return " ".join(format_value)

        result_str = re.sub("{}", " ".join(format_value), output_format)

        positions = re.findall("{[0-9]+}", result_str)

        if not positions:
            return result_str

        position_indices = [int(x[1:-1]) for x in positions]
        if max(position_indices) < len(format_value):
            result_str = result_str.format(*format_value)
        else:
            try:
                result_str = result_str.format("", *format_value)
            except:
                positions = [x for x in positions if int(x[1:-1]) > len(format_value)-1 or int(x[1:-1]) < 0]
                for pos in positions:
                    result_str = result_str.replace(pos, "")
                result_str = result_str.format(*format_value)

        return result_str

Form an output value according to user input of output_format
Args:
span_doc: span
format: str
relations: Dict
patterns: List

Returns: str


def deserialize(config, custom_objects=None):
    return serialization_lib.deserialize_keras_object(config, module_objects=ALL_OBJECTS_DICT, custom_objects=custom_objects)

Deserializes a serialized metric class/function instance.

Args:
config: Metric configuration.
custom_objects: Optional dictionary mapping names (strings)
to custom objects (classes and functions) to be
considered during deserialization.

Returns:
A Keras `Metric` instance or a metric function.


def extract_header_comment_key_value_tuples_from_file(file_descriptor):

    file_data = file_descriptor.read()
    findall_result = re.findall(HEADER_COMMENT_KEY_VALUE_TUPLES_REGEX, file_data, re.MULTILINE | re.DOTALL)

    returned_list = []
    for header_comment, _ignored, raw_comments, key, value in findall_result:
        comments = re.findall("/\* (.*?) \*/", raw_comments)
        if len(comments) == 0:
            comments = [u""]
        returned_list.append((header_comment, comments, key, value))

    return returned_list

Extracts tuples representing comments and localization entries from strings file.

Args:
file_descriptor (file): The file to read the tuples from

Returns:
list : List of tuples representing the headers and localization entries.


def _ParseRecord(
      self, parser_mediator, record_index, evtx_record, recovered=False):

    event_data = self._GetEventData(
        parser_mediator, record_index, evtx_record, recovered=recovered)

    try:
      written_time = evtx_record.get_written_time_as_integer()
    except OverflowError as exception:
      parser_mediator.ProduceExtractionWarning((
          'unable to read written time from event record: {0:d} '
          'with error: {1!s}').format(record_index, exception))

      written_time = None

    if not written_time:
      date_time = dfdatetime_semantic_time.SemanticTime('Not set')
    else:
      date_time = dfdatetime_filetime.Filetime(timestamp=written_time)

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

Extract data from a Windows XML EventLog (EVTX) record.

Args:
parser_mediator (ParserMediator): mediates interactions between parsers
and other components, such as storage and dfvfs.
record_index (int): event record index.
evtx_record (pyevtx.record): event record.
recovered (Optional[bool]): True if the record was recovered.


def set_filetype(self, filetype, bufnr=None):
    if bufnr:
        self._vim.command(((str(bufnr) + 'bufdo set filetype=') + filetype))
    else:
        self._vim.command(('set filetype=' + filetype))

Set filetype for a buffer.

Note: it's a quirk of Vim's Python API that using the buffer.options
dictionary to set filetype does not trigger ``FileType`` autocommands,
hence this implementation executes as a command instead.

Args:
filetype (str): The filetype to set.
bufnr (Optional[int]): A Vim buffer number, current if ``None``.


def _pre_action(self, action):

        assert len(action) == self.dof, "environment got invalid action dimension"
        low, high = self.action_spec
        action = np.clip(action, low, high)

        if self.has_gripper:
            arm_action = action[: self.mujoco_robot.dof]
            gripper_action_in = action[
                self.mujoco_robot.dof : self.mujoco_robot.dof + self.gripper.dof
            ]
            gripper_action_actual = self.gripper.format_action(gripper_action_in)
            action = np.concatenate([arm_action, gripper_action_actual])

        ctrl_range = self.sim.model.actuator_ctrlrange
        bias = 0.5 * (ctrl_range[:, 1] + ctrl_range[:, 0])
        weight = 0.5 * (ctrl_range[:, 1] - ctrl_range[:, 0])
        applied_action = bias + weight * action
        self.sim.data.ctrl[:] = applied_action

        self.sim.data.qfrc_applied[
            self._ref_joint_vel_indexes
        ] = self.sim.data.qfrc_bias[self._ref_joint_vel_indexes]

        if self.use_indicator_object:
            self.sim.data.qfrc_applied[
                self._ref_indicator_vel_low : self._ref_indicator_vel_high
            ] = self.sim.data.qfrc_bias[
                self._ref_indicator_vel_low : self._ref_indicator_vel_high
            ]

Overrides the superclass method to actuate the robot with the
passed joint velocities and gripper control.

Args:
action (numpy array): The control to apply to the robot. The first
@self.mujoco_robot.dof dimensions should be the desired
normalized joint velocities and if the robot has
a gripper, the next @self.gripper.dof dimensions should be
actuation controls for the gripper.


def delete_group(self, name):

        self.project_service.set_auth(self._token_project)
        return self.project_service.delete_group(name)

Delete given group.

Args:
name (string): Name of group.

Returns:
(bool): True on success.

Raises:
requests.HTTPError on failure.


def latex_sanitize_command_name(_cmdname):
    r
    import utool as ut
    command_name = _cmdname
    try:
        def subroman(match):
            import roman
            try:
                groupdict = match.groupdict()
                num = int(groupdict['num'])
                if num == 0:
                    return ''
                return roman.toRoman(num)
            except Exception as ex:
                ut.printex(ex, keys=['groupdict'])
                raise
        command_name = re.sub(ut.named_field('num', r'\d+'), subroman, command_name)
    except ImportError as ex:
        if ut.SUPER_STRICT:
            ut.printex(ex)
            raise

    command_name = re.sub(r'[\d' + re.escape('

    str_list = re.split('[_ ]', command_name)

    command_name = ut.to_camel_case('_'.join(str_list), mixed=True)
    return command_name

r"""
Args:
_cmdname (?):

Returns:
?: command_name

CommandLine:
python -m utool.util_latex --exec-latex_sanitize_command_name

Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_latex import *  # NOQA
>>> _cmdname = '#foo bar.'
>>> command_name = latex_sanitize_command_name(_cmdname)
>>> result = ('command_name = %s' % (str(command_name),))
>>> print(result)
FooBar


def get_ratio(self, max_denominator=5, index_none=None):

        structure = self.initial_structure
        lat_type = self.lat_type
        if lat_type == 't' or lat_type == 'h':

            a, c = (structure.lattice.a, structure.lattice.c)
            if c > a:
                frac = Fraction(c ** 2 / a ** 2).limit_denominator(max_denominator)
                ratio = [frac.numerator, frac.denominator]
            else:
                frac = Fraction(a ** 2 / c ** 2).limit_denominator(max_denominator)
                ratio = [frac.denominator, frac.numerator]
        elif lat_type == 'r':

            cos_alpha = cos(structure.lattice.alpha / 180 * np.pi)
            frac = Fraction((1 + 2 * cos_alpha) / cos_alpha).limit_denominator(max_denominator)
            ratio = [frac.numerator, frac.denominator]
        elif lat_type == 'o':

            ratio = [None] * 3
            lat = (structure.lattice.c, structure.lattice.b, structure.lattice.a)
            index = [0, 1, 2]
            if index_none is None:
                min_index = np.argmin(lat)
                index.pop(min_index)
                frac1 = Fraction(lat[index[0]] ** 2 / lat[min_index] ** 2).limit_denominator(max_denominator)
                frac2 = Fraction(lat[index[1]] ** 2 / lat[min_index] ** 2).limit_denominator(max_denominator)
                com_lcm = lcm(frac1.denominator, frac2.denominator)
                ratio[min_index] = com_lcm
                ratio[index[0]] = frac1.numerator * int(round((com_lcm / frac1.denominator)))
                ratio[index[1]] = frac2.numerator * int(round((com_lcm / frac2.denominator)))
            else:
                index.pop(index_none)
                if (lat[index[0]] > lat[index[1]]):
                    frac = Fraction(lat[index[0]] ** 2 / lat[index[1]] ** 2).limit_denominator(max_denominator)
                    ratio[index[0]] = frac.numerator
                    ratio[index[1]] = frac.denominator
                else:
                    frac = Fraction(lat[index[1]] ** 2 / lat[index[0]] ** 2).limit_denominator(max_denominator)
                    ratio[index[1]] = frac.numerator
                    ratio[index[0]] = frac.denominator
        elif lat_type == 'c':
            raise RuntimeError('Cubic system does not need axial ratio.')
        else:
            raise RuntimeError('Lattice type not implemented.')
        return ratio

find the axial ratio needed for GB generator input.
Args:
max_denominator (int): the maximum denominator for
the computed ratio, default to be 5.
index_none (int): specify the irrational axis.
0-a, 1-b, 2-c. Only may be needed for orthorombic system.
Returns:
axial ratio needed for GB generator (list of integers).