def stop_tuning_job(self, name):

        try:
            LOGGER.info('Stopping tuning job: {}'.format(name))
            self.sagemaker_client.stop_hyper_parameter_tuning_job(HyperParameterTuningJobName=name)
        except ClientError as e:
            error_code = e.response['Error']['Code']

            if error_code == 'ValidationException':
                LOGGER.info('Tuning job: {} is already stopped or not running.'.format(name))
            else:
                LOGGER.error('Error occurred while attempting to stop tuning job: {}. Please try again.'.format(name))
                raise

Stop the Amazon SageMaker hyperparameter tuning job with the specified name.

Args:
name (str): Name of the Amazon SageMaker hyperparameter tuning job.

Raises:
ClientError: If an error occurs while trying to stop the hyperparameter tuning job.


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

Convert UTF8 characters in a CSV file or dataframe into ASCII

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


def sanitize_filename(filename):
    dirname = os.path.dirname(filename)
    basename = os.path.basename(filename)
    basename = _sanitize_windows_filename(basename)
    basename = _truncate_filename(basename, LINUX_MAX_FILENAME_LENGTH)
    basename = basename.replace(' ', '_')
    return os.path.join(dirname, basename)

Sanitizes a filename for various operating systems.

Args:
filename: string, the filename to sanitize.

Returns:
A string that is safe to use as a filename on various operating systems.


def AddConnectedPeer(self, peer):

        self.RemoveFromQueue(peer.address)
        self.AddKnownAddress(peer.address)

        if len(self.Peers) > settings.CONNECTED_PEER_MAX:
            peer.Disconnect("Max connected peers reached", isDead=False)

        if peer not in self.Peers:
            self.Peers.append(peer)
        else:

            self.RemoveKnownAddress(peer.address)
            peer.Disconnect()

Add a new connect peer to the known peers list.

Args:
peer (NeoNode): instance.


def add_time(data):
    payload = data['data']
    updated = data['updated'].date()
    if (updated == date.today()):
        payload['last_updated'] = data['updated'].strftime('today at %H:%M:%S')
    elif (updated >= (date.today() - timedelta(days=1))):
        payload['last_updated'] = 'yesterday'
    elif (updated >= (date.today() - timedelta(days=7))):
        payload['last_updated'] = updated.strftime('on %A')
    else:
        payload['last_updated'] = updated.strftime('%Y-%m-%d')
    return payload

And a friendly update time to the supplied data.

Arguments:
data (:py:class:`dict`): The response data and its update time.

Returns:
:py:class:`dict`: The data with a friendly update time.


def to_pandas(self):
    dataframe = self.get().to_pandas()
    assert ((type(dataframe) is pandas.DataFrame) or (type(dataframe) is pandas.Series))
    return dataframe

Convert the object stored in this partition to a Pandas DataFrame.

Returns:
A Pandas DataFrame.


def remove_by_threshold(self, threshold=5):
    keys = [x for x in self._dictionary.keys()]
    for key in keys:
        if (self._dictionary[key] <= threshold):
            self._dictionary.pop(key)
    self._update_dictionary()

Remove all words at, or below, the provided threshold

Args:
threshold (int): The threshold at which a word is to be \
removed


def download(self, url, destination_path):
    self._pbar_url.update_total(1)
    future = self._executor.submit(self._sync_download, url, destination_path)
    return promise.Promise.resolve(future)

Download url to given path.

Returns Promise -> sha256 of downloaded file.

Args:
url: address of resource to download.
destination_path: `str`, path to directory where to download the resource.

Returns:
Promise obj -> (`str`, int): (downloaded object checksum, size in bytes).


def CreateSmartShoppingAd(client, ad_group_id):

  ad_group_ad_service = client.GetService('AdGroupAdService', version='v201809')

  adgroup_ad = {
      'adGroupId': ad_group_id,

      'ad': {
          'xsi_type': 'GoalOptimizedShoppingAd'
      }
  }

  ad_operation = {
      'operator': 'ADD',
      'operand': adgroup_ad
  }

  ad_result = ad_group_ad_service.mutate([ad_operation])

  for adgroup_ad in ad_result['value']:
    print 'Smart Shopping ad with ID "%s" was added.' % adgroup_ad['ad']['id']

Adds a new Smart Shopping ad.

Args:
client: an AdWordsClient instance.
ad_group_id: an integer ID for an ad group.


def Validate(self, problems, validate_children=True):

    self.ValidateRouteId(problems)
    self.ValidateServicePeriod(problems)
    self.ValidateDirectionId(problems)
    self.ValidateTripId(problems)
    self.ValidateShapeIdsExistInShapeList(problems)
    self.ValidateRouteIdExistsInRouteList(problems)
    self.ValidateServiceIdExistsInServiceList(problems)
    self.ValidateBikesAllowed(problems)
    self.ValidateWheelchairAccessible(problems)
    if self._schedule and validate_children:
      self.ValidateChildren(problems)

Validate attributes of this object.

Check that this object has all required values set to a valid value without
reference to the rest of the schedule. If the _schedule attribute is set
then check that references such as route_id and service_id are correct.

Args:
problems: A ProblemReporter object
validate_children: if True and the _schedule attribute is set than call
ValidateChildren


def poll(self, query_id=None, sequence_no=None, params=None, **kwargs):
    path = '/logging-service/v1/queries/{}/{}'.format(query_id, sequence_no)
    r = self._httpclient.request(method='GET', url=self.url, params=params, path=path, **kwargs)
    return r

Poll for asynchronous query results.

Continue to poll for results until this endpoint reports
JOB_FINISHED or JOB_FAILED. The results of queries can be
returned in multiple pages, each of which may contain many log
records. Use this endpoint to poll for query result batches, as
well as to track query result status.

Args:
params (dict): Payload/request dictionary.
query_id (str): Specifies the ID of the query job.
sequence_no (int): Specifies the sequenceNo.
**kwargs: Supported :meth:`~pancloud.httpclient.HTTPClient.request` parameters.

Returns:
requests.Response: Requests Response() object.

Examples:
Refer to ``logging_query.py`` example.


def custom_apply(self, path: utils.KeyPath, value_spec: pg_typing.ValueSpec, allow_partial: bool, child_transform: Optional[Callable[[utils.KeyPath, pg_typing.Field, Any], Any]]=None) -> Tuple[bool, 'List']:
    proceed_with_standard_apply = True
    if self._value_spec:
        if value_spec and (not value_spec.is_compatible(self._value_spec)):
            raise ValueError(utils.message_on_path(f'List (spec={self._value_spec!r}) cannot be assigned to an incompatible field (spec={value_spec!r}).', path))
        if self._allow_partial == allow_partial:
            proceed_with_standard_apply = False
        else:
            self._allow_partial = allow_partial
    elif isinstance(value_spec, pg_typing.List):
        self._value_spec = value_spec
    return (proceed_with_standard_apply, self)

Implement pg.typing.CustomTyping interface.

Args:
path: KeyPath of current object.
value_spec: Origin value spec of the field.
allow_partial: Whether allow partial object to be created.
child_transform: Function to transform child node values in dict_obj into
their final values. Transform function is called on leaf nodes first,
then on their containers, recursively.

Returns:
A tuple (proceed_with_standard_apply, transformed value)


def Lookup(self, name):
    if not self._name2item:
        self._InitCache()
    return self._name2item[name]

Convenience function: Look up a given name in the class namespace.

Tries to find a method or constant by this name in the class.

Args:
name: Name to look up.

Returns:
A Constant or Function instance.

Raises:
KeyError: if this identifier doesn't exist in this class.


def register_validator(flag_name, checker, message='Flag validation failed', flag_values=_flagvalues.FLAGS):
    v = SingleFlagValidator(flag_name, checker, message)
    _add_validator(flag_values, v)

Adds a constraint, which will be enforced during program execution.

The constraint is validated when flags are initially parsed, and after each
change of the corresponding flag's value.
Args:
flag_name: str, name of the flag to be checked.
checker: callable, a function to validate the flag.
input - A single positional argument: The value of the corresponding
flag (string, boolean, etc.  This value will be passed to checker
by the library).
output - bool, True if validator constraint is satisfied.
If constraint is not satisfied, it should either return False or
raise flags.ValidationError(desired_error_message).
message: str, error text to be shown to the user if checker returns False.
If checker raises flags.ValidationError, message from the raised
error will be shown.
flag_values: flags.FlagValues, optional FlagValues instance to validate
against.
Raises:
AttributeError: Raised when flag_name is not registered as a valid flag
name.


def copy_raw_block(self):
    ctable = []
    (r, c) = (0, 0)
    try:
        for row_index in range(self.start[0], self.end[0]):
            r = row_index
            row = []
            ctable.append(row)
            for column_index in range(self.start[1], self.end[1]):
                c = column_index
                row.append(self.table[row_index][column_index])
    except IndexError:
        raise InvalidBlockError(('Missing table element at [%d, %d]' % (r, c)))
    return ctable

Copies the block as it was originally specified by start and end into a new table.

Returns:
A copy of the block with no block transformations.


def decode_row(line, fields=None):
    cols = line.rstrip('\n').split(_field_delimiter)
    cols = list(map(unescape, cols))
    if (fields is not None):
        if (len(cols) != len(fields)):
            raise ItsdbError('Wrong number of fields: {} != {}'.format(len(cols), len(fields)))
        for i in range(len(cols)):
            col = cols[i]
            if col:
                field = fields[i]
                col = _cast_to_datatype(col, field)
            cols[i] = col
    return cols

Decode a raw line from a profile into a list of column values.

Decoding involves splitting the line by the field delimiter
(`"@"` by default) and unescaping special characters. If *fields*
is given, cast the values into the datatype given by their
respective Field object.

Args:
line: a raw line from a [incr tsdb()] profile.
fields: a list or Relation object of Fields for the row
Returns:
A list of column values.


def quantize_flow(flow, max_val=0.02, norm=True):

    h, w, _ = flow.shape
    dx = flow[..., 0]
    dy = flow[..., 1]
    if norm:
        dx = dx / w
        dy = dy / h

    flow_comps = [
        quantize(d, -max_val, max_val, 255, np.uint8) for d in [dx, dy]
    ]
    return tuple(flow_comps)

Quantize flow to [0, 255].

After this step, the size of flow will be much smaller, and can be
dumped as jpeg images.

Args:
flow (ndarray): (h, w, 2) array of optical flow.
max_val (float): Maximum value of flow, values beyond
[-max_val, max_val] will be truncated.
norm (bool): Whether to divide flow values by image width/height.

Returns:
tuple[ndarray]: Quantized dx and dy.


def fpn_map_rois_to_levels(boxes):
    sqrtarea = tf.sqrt(tf_area(boxes))
    level = tf.cast(tf.floor((4 + (tf.log(((sqrtarea * (1.0 / 224)) + 1e-06)) * (1.0 / np.log(2))))), tf.int32)
    level_ids = [tf.where((level <= 2)), tf.where(tf.equal(level, 3)), tf.where(tf.equal(level, 4)), tf.where((level >= 5))]
    level_ids = [tf.reshape(x, [(- 1)], name='roi_level{}_id'.format((i + 2))) for (i, x) in enumerate(level_ids)]
    num_in_levels = [tf.size(x, name='num_roi_level{}'.format((i + 2))) for (i, x) in enumerate(level_ids)]
    add_moving_summary(*num_in_levels)
    level_boxes = [tf.gather(boxes, ids) for ids in level_ids]
    return (level_ids, level_boxes)

Assign boxes to level 2~5.

Args:
boxes (nx4):

Returns:
[tf.Tensor]: 4 tensors for level 2-5. Each tensor is a vector of indices of boxes in its level.
[tf.Tensor]: 4 tensors, the gathered boxes in each level.

Be careful that the returned tensor could be empty.


def nb_ll(data, P, R):

    genes, cells = data.shape
    clusters = P.shape[1]
    lls = np.zeros((cells, clusters))
    for c in range(clusters):
        P_c = P[:,c].reshape((genes, 1))
        R_c = R[:,c].reshape((genes, 1))

        ll = gammaln(R_c + data) - gammaln(R_c)
        ll += data*np.log(P_c) + xlog1py(R_c, -P_c)

        lls[:,c] = ll.sum(0)
    return lls

Returns the negative binomial log-likelihood of the data.

Args:
data (array): genes x cells
P (array): NB success probability param - genes x clusters
R (array): NB stopping param - genes x clusters

Returns:
cells x clusters array of log-likelihoods


def set_style(self, column, style):

        column_idx = None

        while len(self.headers) > len(self.__style_list):
            self.__style_list.append(None)

        if isinstance(column, six.integer_types):
            column_idx = column
        elif isinstance(column, six.string_types):
            try:
                column_idx = self.headers.index(column)
            except ValueError:
                pass

        if column_idx is not None:
            self.__style_list[column_idx] = style
            self.__clear_preprocess()
            self._dp_extractor.format_flags_list = [
                _ts_to_flag[self.__get_thousand_separator(col_idx)]
                for col_idx in range(len(self.__style_list))
            ]
            return

        raise ValueError("column must be an int or string: actual={}".format(column))

Set |Style| for a specific column.

Args:
column (|int| or |str|):
Column specifier. column index or header name correlated with the column.
style (|Style|):
Style value to be set to the column.

Raises:
ValueError: If the column specifier is invalid.


def run_without_tensor_float_32(description: str) -> Callable[[Callable[..., Any]], Callable[..., None]]:

    def decorator(f: Callable[..., Any]) -> Callable[..., None]:

        @functools.wraps(f)
        def decorated(*args, **kwargs):
            allowed = config.tensor_float_32_execution_enabled()
            try:
                config.enable_tensor_float_32_execution(False)
                f(*args, **kwargs)
            finally:
                config.enable_tensor_float_32_execution(allowed)
        return tf_decorator.make_decorator(f, decorated)
    return decorator

Execute test with TensorFloat-32 disabled.

While almost every real-world deep learning model runs fine with
TensorFloat-32, many tests use assertAllClose or similar methods.
TensorFloat-32 matmuls typically will cause such methods to fail with the
default tolerances.

Args:
description: A description used for documentation purposes, describing why
the test requires TensorFloat-32 to be disabled.

Returns:
Decorator which runs a test with TensorFloat-32 disabled.


def _find_longest_parent_path(path_set, path):
    while (path not in path_set):
        if (not path):
            return None
        path = os.path.dirname(path)
    return path

Finds the longest "parent-path" of 'path' in 'path_set'.

This function takes and returns "path-like" strings which are strings
made of strings separated by os.sep. No file access is performed here, so
these strings need not correspond to actual files in some file-system..
This function returns the longest ancestor path
For example, for path_set=["/foo/bar", "/foo", "/bar/foo"] and
path="/foo/bar/sub_dir", returns "/foo/bar".

Args:
path_set: set of path-like strings -- e.g. a list of strings separated by
os.sep. No actual disk-access is performed here, so these need not
correspond to actual files.
path: a path-like string.

Returns:
The element in path_set which is the longest parent directory of 'path'.


def profile(self, num):

        baseuri = self._BASE_URI + "company/{}".format(num)
        res = self.session.get(baseuri)
        self.handle_http_error(res)
        return res

Search for company profile by company number.

Args:
num (str): Company number to search on.


def from_json(cls, data):

        required_keys = ('name', 'day_type', 'location', 'dry_bulb_condition',
                         'humidity_condition', 'wind_condition', 'sky_condition')
        for key in required_keys:
            assert key in data, 'Required key "{}" is missing!'.format(key)

        return cls(data['name'], data['day_type'], Location.from_json(data['location']),
                   DryBulbCondition.from_json(data['dry_bulb_condition']),
                   HumidityCondition.from_json(data['humidity_condition']),
                   WindCondition.from_json(data['wind_condition']),
                   SkyCondition.from_json(data['sky_condition']))

Create a Design Day from a dictionary.

Args:
data = {
"name": string,
"day_type": string,
"location": ladybug Location schema,
"dry_bulb_condition": ladybug DryBulbCondition schema,
"humidity_condition": ladybug HumidityCondition schema,
"wind_condition": ladybug WindCondition schema,
"sky_condition": ladybug SkyCondition schema}


def request_stop(self, ex=None):
    with self._lock:
        ex = self._filter_exception(ex)
        if self._joined:
            if isinstance(ex, tuple):
                _, ex_instance, _ = ex
                raise ex_instance
            elif ex is not None:
                _, ex_instance, _ = sys.exc_info()
                raise ex_instance
        if not self._stop_event.is_set():
            if ex and self._exc_info_to_raise is None:
                if isinstance(ex, tuple):
                    logging.info('Error reported to Coordinator: %s', compat.as_str_any(ex[1]), exc_info=ex)
                    self._exc_info_to_raise = ex
                else:
                    logging.info('Error reported to Coordinator: %s, %s', type(ex), compat.as_str_any(ex))
                    self._exc_info_to_raise = sys.exc_info()
                if len(self._exc_info_to_raise) != 3 or not self._exc_info_to_raise[0] or (not self._exc_info_to_raise[1]):
                    try:
                        raise ValueError('ex must be a tuple or sys.exc_info must return the current exception: %s' % self._exc_info_to_raise)
                    except ValueError:
                        self._exc_info_to_raise = sys.exc_info()
            self._stop_event.set()

Request that the threads stop.

After this is called, calls to `should_stop()` will return `True`.

Note: If an exception is being passed in, in must be in the context of
handling the exception (i.e. `try: ... except Exception as ex: ...`) and not
a newly created one.

Args:
ex: Optional `Exception`, or Python `exc_info` tuple as returned by
`sys.exc_info()`.  If this is the first call to `request_stop()` the
corresponding exception is recorded and re-raised from `join()`.


def _on_channel_close(self, channel, reply_code_or_reason, reply_text=None):

        if isinstance(reply_code_or_reason, pika_errs.ChannelClosed):
            reply_code = reply_code_or_reason.reply_code
            reply_text = reply_code_or_reason.reply_text
        elif isinstance(reply_code_or_reason, int):
            reply_code = reply_code_or_reason
        else:
            reply_code = 0
            reply_text = str(reply_code_or_reason)

        _log.info("Channel %r closed (%d): %s", channel, reply_code, reply_text)
        self._channel = None

Callback invoked when the channel is closed.

Args:
channel (pika.channel.Channel): The channel that got closed.
reply_code_or_reason (int|Exception): The reason why the channel
was closed. In older versions of pika, this is the AMQP code.
reply_text (str): The human-readable reason for the channel's
closure (only in older versions of pika).


def Current():
    return Architecture._MACHINE_TO_ARCHITECTURE.get(platform.machine().lower())

Determines the current system architecture.

Returns:
ArchitectureTuple, One of the Architecture constants or None if it cannot
be determined.


def loadnetcdf(filename, copy=True):
    filename = str(Path(filename).expanduser())
    if copy:
        dataarray = xr.open_dataarray(filename).copy()
    else:
        dataarray = xr.open_dataarray(filename, chunks={})
    if (dataarray.name is None):
        dataarray.name = filename.rstrip('.nc')
    for (key, val) in dataarray.coords.items():
        if (val.dtype.kind == 'S'):
            dataarray[key] = val.astype('U')
        elif (val.dtype == np.int32):
            dataarray[key] = val.astype('i8')
    return dataarray

Load a dataarray from a NetCDF file.

Args:
filename (str): Filename (*.nc).
copy (bool): If True, dataarray is copied in memory. Default is True.

Returns:
dataarray (xarray.DataArray): Loaded dataarray.


def _find_docstring_line_for_no_body(self, start):
    tracked = sorted(list(self._tokenized_triple_quotes.keys()))
    for i in tracked:
        if (min(start, i) == start):
            return i
    return None

Find the docstring associated with a definition with no body
in the node.

In these cases, the provided start and end line number for that
element are the same, so we must get the docstring based on the
sequential position of known docstrings.

Args:
start: the row where the class / function starts.

Returns:
int: the row number where the docstring is found.


def get(self, key=None):

        if key:
            key = ub_to_str(key)
            if settings.ENABLE_CACHING:
                return self.get_from_cache(key) or self.set_to_cache(self._get_from_riak(key))

            else:
                return self._get_from_riak(key)

        else:
            self._exec_query()
            if not self._solr_cache['docs']:
                raise ObjectDoesNotExist("%s %s" % (self.index_name, self.compiled_query))

            if self.count() > 1:
                raise MultipleObjectsReturned(
                    "%s objects returned for %s" % (self.count(),
                                                    self._model_class.__name__))

            return self._get_from_riak(self._solr_cache['docs'][0]['_yz_rk'])

If key is not None, tries to get obj from cache first. If not
found, tries to get from riak and sets to cache.

If key is None, then execute solr query and checks result. Returns
obj data and key tuple or raises exception ObjectDoesNotExist or
MultipleObjectsReturned.

Args:
key(str): obj key
Return:
(tuple): obj data dict, obj key


def serialize_to_normalized_compact_json(py_obj):

    return json.dumps(
        py_obj, sort_keys=True, separators=(',', ':'), cls=ToJsonCompatibleTypes
    )

Serialize a native object to normalized, compact JSON.

The JSON string is normalized by sorting any dictionary keys. It will be on a single
line without whitespace between elements.

Args:
py_obj: object
Any object that can be represented in JSON. Some types, such as datetimes are
automatically converted to strings.

Returns:
str: normalized, compact JSON string.


def id_pools_vsn_ranges(self):
    if (not self.__id_pools_vsn_ranges):
        self.__id_pools_vsn_ranges = IdPoolsRanges('vsn', self.__connection)
    return self.__id_pools_vsn_ranges

Gets the IdPoolsRanges API Client for VSN Ranges.

Returns:
IdPoolsRanges:


def percent_point(self, U):

        self.check_fit()

        return scipy.optimize.brentq(self._brentq_cdf(U), -1000.0, 1000.0)

Given a cdf value, returns a value in original space.

Args:
U(numpy.array): cdf values in [0,1]

Returns:
numpy.array: value in original space


def attribute(self, attribute_id, action='GET', params=None):

        if params is None:
            params = {}
        if not self.can_update():
            self._tcex.handle_error(910, [self.type])

        if action == 'GET':
            return self.tc_requests.get_attribute(
                self.api_type,
                self.api_sub_type,
                self.unique_id,
                attribute_id,
                owner=self.owner,
                params=params,
            )

        if action == 'DELETE':
            return self.tc_requests.delete_attribute(
                self.api_type, self.api_sub_type, self.unique_id, attribute_id, owner=self.owner
            )

        self._tcex.handle_error(925, ['action', 'attribute', 'action', 'action', action])
        return None

Gets the attribute from a Group/Indicator or Victim

Args:
action:
params:
attribute_id:

Returns: attribute json


def makeDoubleLinked(dom, parent=None):
    dom.parent = parent
    for child in dom.childs:
        child.parent = dom
        makeDoubleLinked(child, dom)

Standard output from `dhtmlparser` is single-linked tree. This will make it
double-linked.

Args:
dom (obj): :class:`.HTMLElement` instance.
parent (obj, default None): Don't use this, it is used in recursive
call.


def clone(self, to_namespace, to_name):

        r = fapi.clone_workspace(self.namespace, self.name,
                                 to_namespace, to_name, self.api_url)
        fapi._check_response_code(r, 201)
        return Workspace(to_namespace, to_name, self.api_url)

Clone this workspace.

Args:
to_namespace (str): Target workspace namespace
to_name (str): Target workspace name


def project_surface(surface, angle=DEFAULT_ANGLE):
    z_coef = np.sin(np.radians(angle))
    y_coef = np.cos(np.radians(angle))
    (surface_height, surface_width) = surface.shape
    slope = np.tile(np.linspace(0.0, 1.0, surface_height), [surface_width, 1]).T
    return ((slope * y_coef) + (surface * z_coef))

Returns the height of the surface when projected at the given angle.

Args:
surface (surface): the surface to project
angle (float): the angle at which to project the surface

Returns:
surface: A projected surface.


def extract_paths(self, paths, ignore_nopath):

        try:
            if self._has_tar_and_gzip():
                self._extract_paths_tar_gz(paths, ignore_nopath)
            else:
                self._extract_paths_scp(paths, ignore_nopath)
        except (ssh.LagoSSHTimeoutException, LagoVMNotRunningError):
            raise ExtractPathError(
                'Unable to extract paths from {0}: unreachable with SSH'.
                format(self.vm.name())
            )

Extract the given paths from the domain
Args:
paths(list of str): paths to extract
ignore_nopath(boolean): if True will ignore none existing paths.
Returns:
None
Raises:
:exc:`~lago.plugins.vm.ExtractPathNoPathError`: if a none existing
path was found on the VM, and ``ignore_nopath`` is True.
:exc:`~lago.plugins.vm.ExtractPathError`: on all other failures.


def check_or_generate_pyi(options) -> AnalysisResult:
    loader = load_pytd.create_loader(options)
    compiler_error = None
    other_error_info = ''
    src = ''
    try:
        src = read_source_file(options.input, options.open_function)
        if options.check:
            ctx = check_py(src=src, options=options, loader=loader).context
            ast, result = (None, None)
        else:
            ret, result = generate_pyi(src=src, options=options, loader=loader)
            ctx = ret.context
            ast = ret.ast
    except utils.UsageError:
        raise
    except pyc.CompileError as e:
        compiler_error = (options.input, e.line, e.error)
    except constant_folding.ConstantError as e:
        compiler_error = (options.input, e.lineno, e.message)
    except IndentationError as e:
        compiler_error = (options.input, e.lineno, e.msg)
    except libcst.ParserSyntaxError as e:
        compiler_error = (options.input, e.raw_line, e.message)
    except SyntaxError as e:
        compiler_error = (options.input, e.lineno, e.msg)
    except directors.SkipFileError:
        other_error_info = '
    except Exception as e:
        if options.nofail:
            log.warning('***Caught exception: %s', str(e), exc_info=True)
            if not options.check:
                other_error_info = '
        else:
            prefix = str(e.args[0]) if e.args else ''
            e.args = (f'{prefix}\nFile: {options.input}',) + e.args[1:]
            raise
    else:
        return AnalysisResult(ctx, ast, result)
    ctx = context.Context(options, loader, src=src)
    if compiler_error:
        ctx.errorlog.python_compiler_error(*compiler_error)
    ast = pytd_builtins.GetDefaultAst(parser.PyiOptions.from_toplevel_options(options))
    result = pytd_builtins.DEFAULT_SRC + other_error_info
    return AnalysisResult(ctx, ast, result)

Returns results from running pytype.

Args:
options: config.Options object.

Returns:
An AnalysisResult.


def reports_progress(reporter):

    def decorator(func):

        @wraps(func)
        def wrapper(*args, **kwargs):
            with progress_reporter(reporter):
                return func(*args, **kwargs)
        return wrapper
    return decorator

A decorator factory to mark functions which report progress.

Args:
reporter: A zero-argument callable to report progress.
The callable provided should have the means to both
retrieve and display current progress information.


def get_hash(self, handle):

        handle = os.path.expanduser(os.path.expandvars(handle))
        with open(self._prefixed('%s.hash' % handle)) as f:
            return f.read()

Returns the associated hash for the given handle, the hash file must
exist (``handle + '.hash'``).

Args:
handle (str): Path to the template to get the hash from

Returns:
str: Hash for the given handle


def decode(self, spec, encoded_value):
    raise NotImplementedError(f'{type(self).__name__}.decode')

Decodes `value` from a batchable tensor encoding.

Args:
spec: The TypeSpec for the result value.  If encoded values with spec `s`
were batched, then `spec` should be `s.batch(batch_size)`; or if encoded
values with spec `s` were unbatched, then `spec` should be
`s.unbatch()`.
encoded_value: A nest of values returned by `encode`; or a nest of values
that was formed by stacking, unstacking, or concatenating the
corresponding elements of values returned by `encode`.

Returns:
A value compatible with `type_spec`.


def download_patric_genomes(self, ids, force_rerun=False):
    ids = ssbio.utils.force_list(ids)
    counter = 0
    log.info('Downloading sequences from PATRIC...')
    for patric_id in tqdm(ids):
        f = ssbio.databases.patric.download_coding_sequences(patric_id=patric_id, seqtype='protein', outdir=self.sequences_by_organism_dir, force_rerun=force_rerun)
        if f:
            self.load_strain(patric_id, f)
            counter += 1
            log.debug('{}: downloaded sequence'.format(patric_id))
        else:
            log.warning('{}: unable to download sequence'.format(patric_id))
    log.info('Created {} new strain GEM-PROs, accessible at "strains" attribute'.format(counter))

Download genome files from PATRIC given a list of PATRIC genome IDs and load them as strains.

Args:
ids (str, list): PATRIC ID or list of PATRIC IDs
force_rerun (bool): If genome files should be downloaded again even if they exist


def to_string(cls, error_code):

        if error_code == cls.EMU_NO_CONNECTION:
            return 'No connection to emulator.'
        elif error_code == cls.EMU_COMM_ERROR:
            return 'Emulator connection error.'
        elif error_code == cls.DLL_NOT_OPEN:
            return 'DLL has not been opened.  Did you call \'.connect()\'?'
        elif error_code == cls.VCC_FAILURE:
            return 'Target system has no power.'
        elif error_code == cls.INVALID_HANDLE:
            return 'Given file / memory handle is invalid.'
        elif error_code == cls.NO_CPU_FOUND:
            return 'Could not find supported CPU.'
        elif error_code == cls.EMU_FEATURE_UNSUPPORTED:
            return 'Emulator does not support the selected feature.'
        elif error_code == cls.EMU_NO_MEMORY:
            return 'Emulator out of memory.'
        elif error_code == cls.TIF_STATUS_ERROR:
            return 'Target interface error.'
        elif error_code == cls.FLASH_PROG_COMPARE_FAILED:
            return 'Programmed data differs from source data.'
        elif error_code == cls.FLASH_PROG_PROGRAM_FAILED:
            return 'Programming error occured.'
        elif error_code == cls.FLASH_PROG_VERIFY_FAILED:
            return 'Error while verifying programmed data.'
        elif error_code == cls.OPEN_FILE_FAILED:
            return 'Specified file could not be opened.'
        elif error_code == cls.UNKNOWN_FILE_FORMAT:
            return 'File format of selected file is not supported.'
        elif error_code == cls.WRITE_TARGET_MEMORY_FAILED:
            return 'Could not write target memory.'
        elif error_code == cls.DEVICE_FEATURE_NOT_SUPPORTED:
            return 'Feature not supported by connected device.'
        elif error_code == cls.WRONG_USER_CONFIG:
            return 'User configured DLL parameters incorrectly.'
        elif error_code == cls.NO_TARGET_DEVICE_SELECTED:
            return 'User did not specify core to connect to.'
        elif error_code == cls.CPU_IN_LOW_POWER_MODE:
            return 'Target CPU is in low power mode.'
        elif error_code == cls.UNSPECIFIED_ERROR:
            return 'Unspecified error.'
        raise ValueError('Invalid error code: %d' % error_code)

Returns the string message for the given ``error_code``.

Args:
cls (JlinkGlobalErrors): the ``JLinkGlobalErrors`` class
error_code (int): error code to convert

Returns:
An error string corresponding to the error code.

Raises:
ValueError: if the error code is invalid.


def _get_upload_cmd(self, mirror=False):
    if mirror:
        dest_uri = self.s3_mirror_uri
    else:
        dest_uri = self.s3_version_uri
    cmd = 'aws s3 sync {} {} --delete --exact-timestamps --profile {}'.format(self.artifact_path, dest_uri, self.env)
    return cmd

Generate the S3 CLI upload command

Args:
mirror (bool): If true, uses a flat directory structure instead of nesting under a version.

Returns:
str: The full CLI command to run.


def info(self, server_id):

        result = self._storage[server_id].info()
        result['id'] = server_id
        return result

return dicionary object with info about server
Args:
server_id - server identity


def unreferenced_vert(script):

    if script.ml_version == '1.3.4BETA':
        filter_xml = '  <filter name="Remove Unreferenced Vertex"/>\n'
    else:
        filter_xml = '  <filter name="Remove Unreferenced Vertices"/>\n'
    util.write_filter(script, filter_xml)
    return None

Check for every vertex on the mesh: if it is NOT referenced by a face,
removes it.

Args:
script: the FilterScript object or script filename to write
the filter to.

Layer stack:
No impacts

MeshLab versions:
2016.12
1.3.4BETA


def avg_branch_length(self, terminal=True, internal=True):
    if (not isinstance(terminal, bool)):
        raise TypeError('terminal must be a bool')
    if (not isinstance(internal, bool)):
        raise TypeError('internal must be a bool')
    if ((not internal) and (not terminal)):
        raise RuntimeError('Must select either internal or terminal branches (or both)')
    tot = 0.0
    num = 0
    for node in self.traverse_preorder():
        if (((node.edge_length is not None) and (internal and (not node.is_leaf()))) or (terminal and node.is_leaf())):
            tot += node.edge_length
            num += 1
    return (tot / num)

Compute the average length of the selected branches of this ``Tree``. Edges with length ``None`` will be treated as 0-length

Args:
``terminal`` (``bool``): ``True`` to include terminal branches, otherwise ``False``

``internal`` (``bool``): ``True`` to include internal branches, otherwise ``False``

Returns:
The average length of the selected branches


def _ReadElementSequenceDataTypeDefinition(self, definitions_registry, definition_values, data_type_definition_class, definition_name, supported_definition_values):
    unsupported_definition_values = set(definition_values.keys()).difference(supported_definition_values)
    if unsupported_definition_values:
        error_message = 'unsupported definition values: {0:s}'.format(', '.join(unsupported_definition_values))
        raise errors.DefinitionReaderError(definition_name, error_message)
    element_data_type = definition_values.get('element_data_type', None)
    if (not element_data_type):
        error_message = 'missing element data type'
        raise errors.DefinitionReaderError(definition_name, error_message)
    elements_data_size = definition_values.get('elements_data_size', None)
    elements_terminator = definition_values.get('elements_terminator', None)
    number_of_elements = definition_values.get('number_of_elements', None)
    size_values = (elements_data_size, elements_terminator, number_of_elements)
    size_values = [value for value in size_values if (value is not None)]
    if (not size_values):
        error_message = 'missing element data size, elements terminator and number of elements'
        raise errors.DefinitionReaderError(definition_name, error_message)
    if (len(size_values) > 1):
        error_message = 'element data size, elements terminator and number of elements not allowed to be set at the same time'
        raise errors.DefinitionReaderError(definition_name, error_message)
    element_data_type_definition = definitions_registry.GetDefinitionByName(element_data_type)
    if (not element_data_type_definition):
        error_message = 'undefined element data type: {0:s}.'.format(element_data_type)
        raise errors.DefinitionReaderError(definition_name, error_message)
    element_byte_size = element_data_type_definition.GetByteSize()
    element_type_indicator = element_data_type_definition.TYPE_INDICATOR
    if ((not element_byte_size) and (element_type_indicator != definitions.TYPE_INDICATOR_STRING)):
        error_message = 'unsupported variable size element data type: {0:s}'.format(element_data_type)
        raise errors.DefinitionReaderError(definition_name, error_message)
    aliases = definition_values.get('aliases', None)
    description = definition_values.get('description', None)
    urls = definition_values.get('urls', None)
    definition_object = data_type_definition_class(definition_name, element_data_type_definition, aliases=aliases, data_type=element_data_type, description=description, urls=urls)
    if (elements_data_size is not None):
        try:
            definition_object.elements_data_size = int(elements_data_size)
        except ValueError:
            definition_object.elements_data_size_expression = elements_data_size
    elif (elements_terminator is not None):
        if isinstance(elements_terminator, py2to3.UNICODE_TYPE):
            elements_terminator = elements_terminator.encode('ascii')
        definition_object.elements_terminator = elements_terminator
    elif (number_of_elements is not None):
        try:
            definition_object.number_of_elements = int(number_of_elements)
        except ValueError:
            definition_object.number_of_elements_expression = number_of_elements
    return definition_object

Reads an element sequence data type definition.

Args:
definitions_registry (DataTypeDefinitionsRegistry): data type definitions
registry.
definition_values (dict[str, object]): definition values.
data_type_definition_class (str): data type definition class.
definition_name (str): name of the definition.
supported_definition_values (set[str]): names of the supported definition
values.

Returns:
SequenceDefinition: sequence data type definition.

Raises:
DefinitionReaderError: if the definitions values are missing or if
the format is incorrect.


def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):
    super(ApplicationSpecificInformation, self).read(istream, kmip_version=kmip_version)
    tstream = BytearrayStream(istream.read(self.length))
    self.application_namespace.read(tstream, kmip_version=kmip_version)
    self.application_data.read(tstream, kmip_version=kmip_version)
    self.is_oversized(tstream)
    self.validate()

Read the data encoding the ApplicationSpecificInformation object and
decode it into its constituent parts.

Args:
istream (Stream): A data stream containing encoded object data,
supporting a read method; usually a BytearrayStream object.
kmip_version (KMIPVersion): An enumeration defining the KMIP
version with which the object will be decoded. Optional,
defaults to KMIP 1.0.


def effect_emd(d1, d2):
    return sum((abs((marginal_zero(d1, i) - marginal_zero(d2, i))) for i in range(d1.ndim)))

Compute the EMD between two effect repertoires.

Because the nodes are independent, the EMD between effect repertoires is
equal to the sum of the EMDs between the marginal distributions of each
node, and the EMD between marginal distribution for a node is the absolute
difference in the probabilities that the node is OFF.

Args:
d1 (np.ndarray): The first repertoire.
d2 (np.ndarray): The second repertoire.

Returns:
float: The EMD between ``d1`` and ``d2``.


def _datetime_from_json(value, field):

    if _not_null(value, field):
        if "." in value:

            return datetime.datetime.strptime(value, _RFC3339_MICROS_NO_ZULU)
        else:

            return datetime.datetime.strptime(value, _RFC3339_NO_FRACTION)
    else:
        return None

Coerce 'value' to a datetime, if set or not nullable.

Args:
value (str): The timestamp.
field (.SchemaField): The field corresponding to the value.

Returns:
Optional[datetime.datetime]: The parsed datetime object from
``value`` if the ``field`` is not null (otherwise it is
:data:`None`).


def _create_and_save_vocab_table_lookup_qat_model_tf1(self, output_path: str, tags: Collection[str], signature_def_key: str) -> Tuple[Mapping[str, core.Tensor], Mapping[str, core.Tensor]]:
    with session.Session(graph=ops.Graph()) as sess:
        input_vocabs_placeholder, lookup_tensor, output_tensor = self._create_vocab_table_lookup_qat_model_tf1(sess)
        inputs = {'input_vocabs': input_vocabs_placeholder}
        outputs = {'lookup': lookup_tensor, 'output': output_tensor}
        self._save_tf1_model(sess, output_path, signature_def_key, tags, inputs=inputs, outputs=outputs, init_op=lookup_ops.tables_initializer(), assets_collection=ops.get_collection(ops.GraphKeys.ASSET_FILEPATHS))
    return (inputs, outputs)

Creates and saves a simple QAT model that uses a vocab table.

Args:
output_path: Path to the directory to save the created model.
tags: Set of strings that identifies the saved meta graph.
signature_def_key: Name of the SignatureDef. Used to identify the
SignatureDef within the meta graph.

Returns:
inputs: A mapping of input_key -> input_tensor (placeholder). The input
key is "input_vocabs".
outputs: A mapping of output_key -> output_tensor. The output keys are
"lookup" and "output".


def StreamMedia(self, callback=None, finish_callback=None,
                    additional_headers=None):

        return self.__StreamMedia(
            callback=callback, finish_callback=finish_callback,
            additional_headers=additional_headers, use_chunks=False)

Send this resumable upload in a single request.

Args:
callback: Progress callback function with inputs
(http_wrapper.Response, transfer.Upload)
finish_callback: Final callback function with inputs
(http_wrapper.Response, transfer.Upload)
additional_headers: Dict of headers to include with the upload
http_wrapper.Request.

Returns:
http_wrapper.Response of final response.


class PerceiverClassificationPostprocessor(nn.Module):

    def __init__(self, config: PerceiverConfig, in_channels: int) -> None:
        super().__init__()
        self.classifier = nn.Linear(in_channels, config.num_labels)

    def forward(self, inputs, pos: Optional[torch.Tensor]=None, modality_sizes=None) -> torch.Tensor:
        logits = self.classifier(inputs)
        return logits[:, 0, :]

Classification postprocessing for Perceiver. Can be used to convert the decoder output to classification logits.

Args:
config ([*PerceiverConfig*]):
Model configuration.
in_channels (`int`):
Number of channels in the input.


def register_magics(store_name='_ampl_cells', ampl_object=None):
    from IPython.core.magic import Magics, magics_class, cell_magic, line_magic

    @magics_class
    class StoreAMPL(Magics):

        def __init__(self, shell=None, **kwargs):
            Magics.__init__(self, shell=shell, **kwargs)
            self._store = []
            shell.user_ns[store_name] = self._store

        @cell_magic
        def ampl(self, line, cell):
            'Store the cell in the store'
            self._store.append(cell)

        @cell_magic
        def ampl_eval(self, line, cell):
            'Evaluate the cell'
            ampl_object.eval(cell)

        @line_magic
        def get_ampl(self, line):
            'Retrieve the store'
            return self._store
    get_ipython().register_magics(StoreAMPL)

Register jupyter notebook magics ``%%ampl`` and ``%%ampl_eval``.

Args:
store_name: Name of the store where ``%%ampl cells`` will be stored.
ampl_object: Object used to evaluate ``%%ampl_eval`` cells.


def _get_loss_object(self, loss):
    if loss is None:
        return None
    loss = losses_mod.get(loss)
    if not isinstance(loss, losses_mod.Loss):
        loss_name = get_custom_object_name(loss)
        if loss_name is None:
            raise ValueError('Loss should be a callable, found: {}'.format(loss))
        loss = losses_mod.LossFunctionWrapper(loss, name=loss_name)
    loss._allow_sum_over_batch_size = True
    return loss

Returns a `Loss` object.

Converts the user-supplied loss to a `Loss` object. Also allows
`SUM_OVER_BATCH_SIZE` reduction to be used for this loss.

Args:
loss: A string, function, or `Loss` object.

Returns:
A `Loss` object.


def interact_GxG(pheno, snps1, snps2=None, K=None, covs=None):
    if (K is None):
        K = SP.eye(N)
    N = snps1.shape[0]
    if (snps2 is None):
        snps2 = snps1
    return interact_GxE(snps=snps1, pheno=pheno, env=snps2, covs=covs, K=K)

Epistasis test between two sets of SNPs

Args:
pheno:  [N x 1] SP.array of 1 phenotype for N individuals
snps1:  [N x S1] SP.array of S1 SNPs for N individuals
snps2:  [N x S2] SP.array of S2 SNPs for N individuals
K:      [N x N] SP.array of LMM-covariance/kinship koefficients (optional)
If not provided, then linear regression analysis is performed
covs:   [N x D] SP.array of D covariates for N individuals

Returns:
pv:     [S2 x S1] SP.array of P values for epistasis tests beten all SNPs in
snps1 and snps2


def dtime(sdat, tstart=None, tend=None):
    tseries = sdat.tseries_between(tstart, tend)
    time = tseries['t'].values
    return ((time[1:] - time[:(- 1)]), time[:(- 1)])

Time increment dt.

Compute dt as a function of time.

Args:
sdat (:class:`~stagpy.stagyydata.StagyyData`): a StagyyData instance.
tstart (float): time at which the computation should start. Use the
beginning of the time series data if set to None.
tend (float): time at which the computation should end. Use the
end of the time series data if set to None.
Returns:
tuple of :class:`numpy.array`: dt and time arrays.


def order_verification(self, institute, case, user, link, variant):
    LOG.info('Creating event for ordering validation for variant {0}'.format(variant['display_name']))
    updated_variant = self.variant_collection.find_one_and_update({'_id': variant['_id']}, {'$set': {'sanger_ordered': True}}, return_document=pymongo.ReturnDocument.AFTER)
    self.create_event(institute=institute, case=case, user=user, link=link, category='variant', verb='sanger', variant=variant, subject=variant['display_name'])
    LOG.info('Creating event for ordering sanger for case {0}'.format(case['display_name']))
    self.create_event(institute=institute, case=case, user=user, link=link, category='case', verb='sanger', variant=variant, subject=variant['display_name'])
    return updated_variant

Create an event for a variant verification for a variant
and an event for a variant verification for a case

Arguments:
institute (dict): A Institute object
case (dict): Case object
user (dict): A User object
link (str): The url to be used in the event
variant (dict): A variant object

Returns:
updated_variant(dict)


def merge(self, ref_name: str):
    if self.is_dirty():
        LOGGER.error('repository is dirty; cannot merge: %s', ref_name)
        sys.exit((- 1))
    LOGGER.info('merging ref: "%s" into branch: %s', ref_name, self.get_current_branch())
    self.repo.git.merge(ref_name)

Merges two refs

Args:
ref_name: ref to merge in the current one


def push_file(self, source, dest_dir):

        local_dest = dest_dir + '/' + os.path.basename(source)

        if os.path.dirname(source) != dest_dir:
            try:
                shutil.copyfile(source, local_dest)
                os.chmod(local_dest, 0o777)

            except OSError as e:
                raise FileCopyException(e, self.hostname)

        return local_dest

If the source files dirpath is the same as dest_dir, a copy
is not necessary, and nothing is done. Else a copy is made.

Args:
- source (string) : Path to the source file
- dest_dir (string) : Path to the directory to which the files is to be copied

Returns:
- destination_path (String) : Absolute path of the destination file

Raises:
- FileCopyException : If file copy failed.


def get_concept(self, conceptId, lang='en'):
    url = urljoin((self.concept_service + '/'), conceptId)
    (res, status_code) = self.get(url, params={'lang': lang})
    if (status_code != 200):
        logger.debug('Fetch concept failed.')
    return (self.decode(res), status_code)

Fetch the concept from the Knowledge base

Args:
id (str): The concept id to be fetched, it can be Wikipedia
page id or Wikiedata id.

Returns:
dict, int: A dict containing the concept information; an integer
representing the response code.


def get(self, key):
    self._create_file_if_none_exists()
    with open(self.filename, 'rb') as file_object:
        cache_pickle = pickle.load(file_object)
        val = cache_pickle.get(key, None)
        return val

Gets a value by a key.

Args:
key (str): Key to retrieve the value.

Returns: Retrieved value.


def draw_points(self, *points):

        point_array = ffi.new('SDL_Point[]', len(points))
        for i, p in enumerate(points):
            point_array[i] = p._ptr[0]
        check_int_err(lib.SDL_RenderDrawPoints(self._ptr, point_array, len(points)))

Draw multiple points on the current rendering target.

Args:
*points (Point): The points to draw.

Raises:
SDLError: If an error is encountered.


def _hash_sequence(self, sighash_type, anyone_can_pay):

        if anyone_can_pay or sighash_type == shared.SIGHASH_SINGLE:

            return b'\x00' * 32
        else:

            sequences = ByteData()
            for tx_in in self.tx_ins:
                sequences += tx_in.sequence
            return utils.hash256(sequences.to_bytes())

BIP143 hashSequence implementation

Args:
sighash_type    (int): SIGHASH_SINGLE or SIGHASH_ALL
anyone_can_pay (bool): true if ANYONECANPAY should be set
Returns:
(bytes): the hashSequence, a 32 byte hash


def _load_tmp_fact(filepath):
    from hamster_lib import Fact
    try:
        with open(filepath, 'rb') as fobj:
            fact = pickle.load(fobj)
    except IOError:
        fact = False
    else:
        if (not isinstance(fact, Fact)):
            raise TypeError(_("Something went wrong. It seems our pickled file does not contain valid Fact instance. [Content: '{content}'; Type: {type}".format(content=fact, type=type(fact))))
    return fact

Load an 'ongoing fact' from a given location.

Args:
filepath: Full path to the tmpfile location.

Returns:
hamster_lib.Fact: ``Fact`` representing the 'ongoing fact'. Returns ``False``
if no file was found.

Raises:
TypeError: If for some reason our stored instance is no instance of
``hamster_lib.Fact``.


def validate(request: Union[Dict, List], schema: dict) -> Union[Dict, List]:

    jsonschema_validate(request, schema)
    return request

Wraps jsonschema.validate, returning the same object passed in.

Args:
request: The deserialized-from-json request.
schema: The jsonschema schema to validate against.

Raises:
jsonschema.ValidationError


def as_dataframe(self, max_rows=None):
    max_rows = (len(self._timeseries_list) if (max_rows is None) else max_rows)
    headers = [{'resource': ts.resource._asdict(), 'metric': ts.metric._asdict()} for ts in self._timeseries_list[:max_rows]]
    if (not headers):
        return pandas.DataFrame()
    dataframe = pandas.io.json.json_normalize(headers)
    dataframe.columns = pandas.MultiIndex.from_tuples([((col, '') if (col == 'resource.type') else col.rsplit('.', 1)) for col in dataframe.columns])
    resource_keys = google.cloud.monitoring._dataframe._sorted_resource_labels(dataframe['resource.labels'].columns)
    sorted_columns = [('resource.type', '')]
    sorted_columns += [('resource.labels', key) for key in resource_keys]
    sorted_columns += sorted((col for col in dataframe.columns if (col[0] == 'metric.labels')))
    dataframe = dataframe[sorted_columns]
    dataframe = dataframe.sort_values(sorted_columns)
    dataframe = dataframe.reset_index(drop=True).fillna('')
    return dataframe

Creates a pandas dataframe from the query metadata.

Args:
max_rows: The maximum number of timeseries metadata to return. If None,
return all.

Returns:
A pandas dataframe containing the resource type, resource labels and
metric labels. Each row in this dataframe corresponds to the metadata
from one time series.


def load_user_config(vcs):

    config_path = os.path.join(vcs.path, 'eci.yaml')
    if not os.path.exists(config_path):
        raise ConfigNotFoundError
    with open(config_path, 'r') as f:
        try:
            config = yaml.safe_load(f)
        except yaml.YAMLError:
            raise ConfigFormatError
    if not isinstance(config, dict):
        raise ConfigFormatError
    for k, v in _default_config.iteritems():
        config.setdefault(k, v)
    for k, v in _config_types.iteritems():
        if not isinstance(config[k], v):
            raise ConfigFormatError
    return config

Load the user config

Args:
vcs (easyci.vcs.base.Vcs) - the vcs object for the current project

Returns:
dict - the config

Raises:
ConfigFormatError
ConfigNotFoundError


def test_encode_with_non_root_fhir_path_constraint_succeeds(self, fhir_path_expression: str, expected_sql_expression: str, expected_fhir_path_sql_expression: str, expected_fields_referenced: List[str]):
    self.maxDiff = None
    constraint = self.build_constraint(fhir_path_expression=fhir_path_expression)
    self.assert_constraint_is_equal_to_expression(base_id='Hospital', element_definition_id='Hospital.patients', constraint=constraint, expected_sql_expression=expected_sql_expression, expected_fhir_path_sql_expression=expected_fhir_path_sql_expression, expected_fields_referenced=expected_fields_referenced)

Tests that a "transitive constraint" is properly encoded.

A "transitive constraint" is a constraint defined relative to a resource
elsewhere in the FHIR resource graph than what we're querying against.

Args:
fhir_path_expression: The FHIRPath expression to encode.
expected_sql_expression: The expected generated Standard SQL.
expected_fhir_path_sql_expression: The expected generated Standard SQL
without any contextual subqueries.
expected_fields_referenced: The expected fields_referenced_by_expression
attribute on the resulting constraint.


def variable_summaries(vars_, groups=None, scope='weights'):
    groups = (groups or {'all': '.*'})
    grouped = collections.defaultdict(list)
    for var in vars_:
        for (name, pattern) in groups.items():
            if re.match(pattern, var.name):
                name = re.sub(pattern, name, var.name)
                grouped[name].append(var)
    for name in groups:
        if (name not in grouped):
            tf.logging.warn("No variables matching '{}' group.".format(name))
    summaries = []
    for (name, vars_) in grouped.items():
        vars_ = [tf.reshape(var, [(- 1)]) for var in vars_]
        vars_ = tf.concat(vars_, 0)
        summaries.append(tf.summary.histogram(((scope + '/') + name), vars_))
    return tf.summary.merge(summaries)

Create histogram summaries for the provided variables.

Summaries can be grouped via regexes matching variables names.

Args:
vars_: List of variables to summarize.
groups: Mapping of name to regex for grouping summaries.
scope: Name scope for this operation.

Returns:
Summary tensor.


def from_filenames(filenames, transformations=None, primitive=True,
                       extend_collection=False):

        allcifs = []
        for fname in filenames:
            with open(fname, "r") as f:
                allcifs.append(f.read())
        return CifTransmuter("\n".join(allcifs), transformations,
                             primitive=primitive,
                             extend_collection=extend_collection)

Generates a TransformedStructureCollection from a cif, possibly
containing multiple structures.

Args:
filenames: List of strings of the cif files
transformations: New transformations to be applied to all
structures
primitive: Same meaning as in __init__.
extend_collection: Same meaning as in __init__.


def extract(self, destination, format='csv', csv_delimiter=None, csv_header=True, compress=False):
    job = self.extract_async(destination, format=format, csv_delimiter=csv_delimiter, csv_header=csv_header, compress=compress)
    if (job is not None):
        job.wait()
    return job

Exports the table to GCS; blocks until complete.

Args:
destination: the destination URI(s). Can be a single URI or a list.
format: the format to use for the exported data; one of 'csv', 'json', or 'avro'
(default 'csv').
csv_delimiter: for CSV exports, the field delimiter to use. Defaults to ','
csv_header: for CSV exports, whether to include an initial header line. Default true.
compress: whether to compress the data on export. Compression is not supported for
AVRO format. Defaults to False.
Returns:
A Job object for the completed export Job if it was started successfully; else None.


def add_chain_ids(self, chains):
    chains = ssbio.utils.force_list(chains)
    for c in chains:
        if self.chains.has_id(c):
            log.debug('{}: chain already present'.format(c))
        else:
            chain_prop = ChainProp(ident=c, pdb_parent=self.id)
            self.chains.append(chain_prop)
            log.debug('{}: added to chains list'.format(c))

Add chains by ID into the chains attribute

Args:
chains (str, list): Chain ID or list of IDs


async def _handle_set_typing_notification(self, set_typing_notification):

        conv_id = set_typing_notification.conversation_id.id
        res = parsers.parse_typing_status_message(set_typing_notification)
        await self.on_typing.fire(res)
        try:
            conv = await self._get_or_fetch_conversation(conv_id)
        except exceptions.NetworkError:
            logger.warning(
                'Failed to fetch conversation for typing notification: %s',
                conv_id
            )
        else:
            await conv.on_typing.fire(res)

Receive SetTypingNotification and update the conversation.

Args:
set_typing_notification: hangouts_pb2.SetTypingNotification
instance


def _parse_example_raw(serialized, names, params, name):
    if params.num_features == 0:
        raise ValueError('Must provide at least one feature key.')
    with ops.name_scope(name, 'ParseExample', [serialized, names]):
        names = [] if names is None else names
        serialized = ops.convert_to_tensor(serialized, name='serialized')
        if params.ragged_keys and serialized.shape.ndims is None:
            raise ValueError('serialized must have statically-known rank to parse ragged features.')
        outputs = gen_parsing_ops.parse_example_v2(serialized=serialized, names=names, sparse_keys=params.sparse_keys, dense_keys=params.dense_keys, ragged_keys=params.ragged_keys, dense_defaults=params.dense_defaults_vec, num_sparse=len(params.sparse_keys), sparse_types=params.sparse_types, ragged_value_types=params.ragged_value_types, ragged_split_types=params.ragged_split_types, dense_shapes=params.dense_shapes_as_proto, name=name)
        sparse_indices, sparse_values, sparse_shapes, dense_values, ragged_values, ragged_row_splits = outputs
        ragged_tensors = parsing_config._build_ragged_tensors(serialized.shape, ragged_values, ragged_row_splits)
        sparse_tensors = [sparse_tensor.SparseTensor(ix, val, shape) for ix, val, shape in zip(sparse_indices, sparse_values, sparse_shapes)]
        return dict(zip(params.sparse_keys + params.dense_keys + params.ragged_keys, sparse_tensors + dense_values + ragged_tensors))

Parses `Example` protos.

Args:
serialized: A vector (1-D Tensor) of strings, a batch of binary
serialized `Example` protos.
names: A vector (1-D Tensor) of strings (optional), the names of
the serialized protos.
params: A `ParseOpParams` containing the parameters for the parse op.
name: A name for this operation (optional).

Returns:
A `dict` mapping keys to `Tensor`s and `SparseTensor`s and `RaggedTensor`s.


def add_comment(self, comment):

        if not comment:
            return

        self.__comments[comment.name] = comment
        self.comment_added_signal(self, comment)

Add a comment to the database.

Args:
comment (hotdoc.core.Comment): comment to add


def _pack_images(images, rows, cols):

  shape = onp.shape(images)
  width, height, depth = shape[-3:]
  images = onp.reshape(images, (-1, width, height, depth))
  batch = onp.shape(images)[0]
  rows = onp.minimum(rows, batch)
  cols = onp.minimum(batch
  images = images[:rows * cols]
  images = onp.reshape(images, (rows, cols, width, height, depth))
  images = onp.transpose(images, [0, 2, 1, 3, 4])
  images = onp.reshape(images, [rows * width, cols * height, depth])
  return images

Helper utility to make a tiled field of images from numpy arrays.

Args:
images: Image tensor in shape [N, W, H, C].
rows: Number of images per row in tiled image.
cols: Number of images per column in tiled image.

Returns:
A tiled image of shape [W * rows, H * cols, C].
Truncates incomplete rows.


def export_to_dir(network, export_dir):

    package_path = ding0.__path__[0]

    network.export_to_csv_folder(os.path.join(package_path,
                                              'output',
                                              'debug',
                                              'grid',
                                              export_dir))

Exports PyPSA network as CSV files to directory

Args:
network: pypsa.Network
export_dir: str
Sub-directory in output/debug/grid/ where csv Files of PyPSA network are exported to.


def hashed(field_name, percent, fields=None, count=0):

    if field_name is None:
      raise Exception('Hash field must be specified')

    def _hashed_sampling(sql):
      projection = Sampling._create_projection(fields)
      sql = 'SELECT %s FROM (%s) WHERE MOD(ABS(FARM_FINGERPRINT(CAST(%s AS STRING))), 100) < %d' % \
            (projection, sql, field_name, percent)
      if count != 0:
        sql = '%s LIMIT %d' % (sql, count)
      return sql
    return _hashed_sampling

Provides a sampling strategy based on hashing and selecting a percentage of data.

Args:
field_name: the name of the field to hash.
percent: the percentage of the resulting hashes to select.
fields: an optional list of field names to retrieve.
count: optional maximum count of rows to pick.
Returns:
A sampling function that can be applied to get a hash-based sampling.


def create_detector(self, detector):

        resp = self._post(self._u(self._DETECTOR_ENDPOINT_SUFFIX),
                          data=detector)
        resp.raise_for_status()
        return resp.json()

Creates a new detector.

Args:
detector (object): the detector model object. Will be serialized as
JSON.
Returns:
dictionary of the response (created detector model).


def dummy_inputs(self):
    input_ids = tf.constant(DUMMY_INPUTS, dtype=tf.int32)
    batch_size, seq_len = input_ids.shape
    VISION_DUMMY_INPUTS = tf.random.uniform(shape=(batch_size, self.config.vision_config.num_channels, self.config.vision_config.image_size, self.config.vision_config.image_size), dtype=tf.float32)
    pixel_values = tf.constant(VISION_DUMMY_INPUTS)
    dummy = {'pixel_values': pixel_values, 'input_ids': input_ids}
    return dummy

Dummy inputs to build the network.

Returns:
`Dict[str, tf.Tensor]`: The dummy inputs.


def __init__(self, shape, layout_rules):

    self._shape = convert_to_shape(shape)
    self._layout_rules = convert_to_layout_rules(layout_rules)

Creates a mesh implementation.

Args:
shape: Shape.
layout_rules: LayoutRules.


def MapByteStream(self, byte_stream, byte_offset=0, **kwargs):

    byte_stream = super(StringMap, self).MapByteStream(
        byte_stream, byte_offset=byte_offset, **kwargs)

    if self._HasElementsTerminator():

      elements_terminator = self._data_type_definition.elements_terminator
      elements_terminator_size = len(elements_terminator)

      byte_offset = 0
      byte_stream_size = len(byte_stream)

      while byte_offset < byte_stream_size:
        end_offset = byte_offset + elements_terminator_size
        if byte_stream[byte_offset:end_offset] == elements_terminator:
          break

        byte_offset += elements_terminator_size

      byte_stream = byte_stream[:byte_offset]

    try:
      return byte_stream.decode(self._data_type_definition.encoding)

    except Exception as exception:
      error_string = (
          'Unable to read: {0:s} from byte stream at offset: {1:d} '
          'with error: {2!s}').format(
              self._data_type_definition.name, byte_offset, exception)
      raise errors.MappingError(error_string)

Maps the data type on a byte stream.

Args:
byte_stream (bytes): byte stream.
byte_offset (Optional[int]): offset into the byte stream where to start.

Returns:
str: mapped values.

Raises:
MappingError: if the data type definition cannot be mapped on
the byte stream.


def _get_profile_data_generator(self):
    node_to_traceback = defaultdict(list)
    node_to_op_type = defaultdict(str)
    for op in self._graph.get_operations():
        node_to_traceback[op.name] = op.traceback
        node_to_op_type[op.name] = op.type

    def profile_data_generator(device_step_stats):
        for node_stats in device_step_stats.node_stats:
            if node_stats.node_name == '_SOURCE' or node_stats.node_name == '_SINK':
                continue
            yield ProfileDatum(node_stats, node_to_op_type[node_stats.node_name], node_to_traceback[node_stats.node_name])
    return profile_data_generator

Get function that generates `ProfileDatum` objects.

Returns:
A function that generates `ProfileDatum` objects.


def ones(shape, dtype=None):
    return backend.numpy.ones(shape, dtype=dtype)

Return a new tensor of given shape and type, filled with ones.

Args:
shape: Shape of the new tensor.
dtype: Desired data type of the tensor.

Returns:
Tensor of ones with the given shape and dtype.


def add_get_parameters(url, parameters, percent_encode=True):

    url_parts = list(parse.urlparse(url))
    query = dict(parse.parse_qs(url_parts[4]))
    query.update(parameters)

    if percent_encode:
        url_parts[4] = parse.urlencode(query)
    else:
        url_parts[4] = "&".join([key + "=" + value for key, value in query.items()])

    return parse.urlunparse(url_parts)

Utility function to add GET parameters to an existing URL.

Args:
parameters
A dictionary of the parameters that should be added.
percent_encode
Whether the query parameters should be percent encoded.

Returns:
The updated URL.


def _FindKeys(self, key, names, matches):
    for (name, subkey) in iter(key.items()):
        if (name in names):
            matches.append((name, subkey))
        if isinstance(subkey, dict):
            self._FindKeys(subkey, names, matches)

Searches the plist key hierarchy for keys with matching names.

If a match is found a tuple of the key name and value is added to
the matches list.

Args:
key (dict[str, object]): plist key.
names (list[str]): names of the keys to match.
matches (list[str]): keys with matching names.


def __init__(self, pattern, flags=0):

    self.regex = re.compile(pattern, flags=flags)

Initialize.

Args:
# pattern is the regular expression to search for
pattern: str
# flags passed to re.compile function as the second argument
flags: int


def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):
    local_buffer = utils.BytearrayStream()
    if self._unique_identifier:
        self._unique_identifier.write(local_buffer, kmip_version=kmip_version)
    else:
        raise exceptions.InvalidField('The GetAttributeList response payload is missing the unique identifier field.')
    if self._attribute_names:
        if (kmip_version < enums.KMIPVersion.KMIP_2_0):
            for attribute_name in self._attribute_names:
                attribute_name.write(local_buffer, kmip_version=kmip_version)
        else:
            for attribute_name in self._attribute_names:
                t = enums.convert_attribute_name_to_tag(attribute_name.value)
                e = primitives.Enumeration(enums.Tags, value=t, tag=enums.Tags.ATTRIBUTE_REFERENCE)
                e.write(local_buffer, kmip_version=kmip_version)
    else:
        raise exceptions.InvalidField('The GetAttributeList response payload is missing the attribute names field.')
    self.length = local_buffer.length()
    super(GetAttributeListResponsePayload, self).write(output_buffer, kmip_version=kmip_version)
    output_buffer.write(local_buffer.buffer)

Write the data encoding the GetAttributeList response payload to a
stream.

Args:
output_buffer (stream): A data stream in which to encode object
data, supporting a write method; usually a BytearrayStream
object.
kmip_version (KMIPVersion): An enumeration defining the KMIP
version with which the object will be encoded. Optional,
defaults to KMIP 1.0.

Raises:
InvalidField: Raised if the unique identifier or attribute name
are not defined.


def _construct_graph(self, vertex_dict, edge_dict, default_vertex_attrs, default_edge_attrs):
    with self._lock:
        self._graph = pydot.Dot()
        if default_vertex_attrs:
            self._graph.set_node_defaults(**default_vertex_attrs)
        if default_edge_attrs:
            self._graph.set_edge_defaults(**default_edge_attrs)
        self._vertex_refs = {}
        self._edge_refs = {}
        for vertex, vertex_attrs in vertex_dict.items():
            vertex_ref = pydot.Node(vertex, **vertex_attrs)
            self._vertex_refs[vertex] = vertex_ref
            self._graph.add_node(vertex_ref)
        for edge, edge_attrs in edge_dict.items():
            vertex_src = self._vertex_refs[edge[0]]
            vertex_dst = self._vertex_refs[edge[1]]
            edge_ref = pydot.Edge(vertex_src, vertex_dst, **edge_attrs)
            self._edge_refs[edge] = edge_ref
            self._graph.add_edge(edge_ref)

Constructs the pydot.Dot object for the pipeline graph.

Args:
vertex_dict: (Dict[str, Dict[str, str]]) maps vertex names to attributes
edge_dict: (Dict[(str, str), Dict[str, str]]) maps vertex name pairs to
attributes
default_vertex_attrs: (Dict[str, str]) a dict of attributes
default_edge_attrs: (Dict[str, str]) a dict of attributes


def vectorize(self, token_list):

        sentence_list = [token_list]
        test_observed_arr = self.__setup_dataset(sentence_list, self.__token_master_list)
        pred_arr = self.__controller.inference(test_observed_arr)
        return self.__controller.get_feature_points()

Tokenize token list.

Args:
token_list:   The list of tokens..

Returns:
[vector of token, vector of token, vector of token, ...]


def tournament_selection(population, fitnesses, num_competitors=2, diversity_weight=0.0):
    if (diversity_weight <= 0.0):
        fitness_pop = zip(fitnesses, population)
        return [max(random.sample(fitness_pop, num_competitors))[1] for _ in range(len(population))]
    else:
        indices = range(len(population))
        selected_solutions = []
        for _ in range(len(population)):
            competitor_indices = random.sample(indices, num_competitors)
            if (random.uniform(0.0, 1.0) < (1.0 / (1.0 + diversity_weight))):
                selected_solutions.append(max(zip([fitnesses[i] for i in competitor_indices], [population[i] for i in competitor_indices]))[(- 1)])
            else:
                selected_solutions.append(max(zip([_diversity_metric(population[i], selected_solutions) for i in competitor_indices], [fitnesses[i] for i in competitor_indices], [population[i] for i in competitor_indices]))[(- 1)])
        return selected_solutions

Create a list of parents with tournament selection.

Args:
population: A list of solutions.
fitnesses: A list of fitness values corresponding to solutions in population.
num_competitors: Number of solutions to compare every round.
Best solution among competitors is selected.
diversity_weight: Weight of diversity metric.
Determines how frequently diversity is used to select tournament winners.
Note that fitness is given a weight of 1.0.
diversity_weight == 1.0 gives equal weight to diversity and fitness.


def __init__(self, sess, watch_fn=None, thread_name_filter=None, pass_through_operrors=False):
    BaseDebugWrapperSession.__init__(self, sess, thread_name_filter=thread_name_filter, pass_through_operrors=pass_through_operrors)
    self._watch_fn = None
    if watch_fn is not None:
        if not callable(watch_fn):
            raise TypeError('watch_fn is not callable')
        self._watch_fn = watch_fn

Constructor of NonInteractiveDebugWrapperSession.

Args:
sess: The TensorFlow `Session` object being wrapped.
watch_fn: (`Callable`) A Callable that maps the fetches and feeds of a
debugged `Session.run()` call to `WatchOptions.`
* Args:
* `fetches`: the fetches to the `Session.run()` call.
* `feeds`: the feeds to the `Session.run()` call.

* Returns:
(`tf_debug.WatchOptions`) An object containing debug options including
the debug ops to use, the node names, op types and/or tensor data
types to watch, etc. See the documentation of `tf_debug.WatchOptions`
for more details.
thread_name_filter: Regular-expression white list for threads on which the
wrapper session will be active. See doc of `BaseDebugWrapperSession` for
more details.
pass_through_operrors: If true, all captured OpErrors will be
propagated.  By default this captures all OpErrors.
Raises:
TypeError: If a non-None `watch_fn` is specified and it is not callable.


def write_to_file(self, file_path):
    with gfile.Open(file_path, 'w') as f:
        for line in self._lines:
            f.write(line + '\n')

Write the object itself to file, in a plain format.

The font_attr_segs and annotations are ignored.

Args:
file_path: (str) path of the file to write to.


def call(command, collect_missing=False, silent=True):
  r
  return (_execCommand if silent else execCommand)(shlex.split(command), collect_missing)

r"""Calls a task, as if it were called from the command line.

Args:
command (str): A route followed by params (as if it were entered in the shell).
collect_missing (bool): Collects any missing argument for the command through the shell. Defaults to False.

Returns:
The return value of the called command.


def ParsePageVisitedRow(
      self, parser_mediator, query, row, cache=None, database=None,
      **unused_kwargs):

    query_hash = hash(query)

    from_visit = self._GetRowValue(query_hash, row, 'from_visit')
    hidden = self._GetRowValue(query_hash, row, 'hidden')
    rev_host = self._GetRowValue(query_hash, row, 'rev_host')
    typed = self._GetRowValue(query_hash, row, 'typed')

    extras = []
    if from_visit:
      extras.append('visited from: {0:s}'.format(
          self._GetUrl(from_visit, cache, database)))

    if hidden == '1':
      extras.append('(url hidden)')

    if typed == '1':
      extras.append('(directly typed)')
    else:
      extras.append('(URL not typed directly)')

    event_data = FirefoxPlacesPageVisitedEventData()
    event_data.host = self._ReverseHostname(rev_host)
    event_data.offset = self._GetRowValue(query_hash, row, 'id')
    event_data.query = query
    event_data.title = self._GetRowValue(query_hash, row, 'title')
    event_data.url = self._GetRowValue(query_hash, row, 'url')
    event_data.visit_count = self._GetRowValue(query_hash, row, 'visit_count')
    event_data.visit_type = self._GetRowValue(query_hash, row, 'visit_type')

    if extras:
      event_data.extra = extras

    timestamp = self._GetRowValue(query_hash, row, 'visit_date')
    if timestamp:
      date_time = dfdatetime_posix_time.PosixTimeInMicroseconds(
          timestamp=timestamp)
      event = time_events.DateTimeValuesEvent(
          date_time, definitions.TIME_DESCRIPTION_LAST_VISITED)
      parser_mediator.ProduceEventWithEventData(event, event_data)

Parses a page visited row.

Args:
parser_mediator (ParserMediator): mediates interactions between parsers
and other components, such as storage and dfvfs.
query (str): query that created the row.
row (sqlite3.Row): row.
cache (Optional[SQLiteCache]): cache.
database (Optional[SQLiteDatabase]): database.


def load_parameters(self, path):

        nn.load_parameters(path)
        for v in self.get_modules():
            if not isinstance(v, tuple):
                continue
            prefix, module = v
            for k, v in module.__dict__.items():
                if not isinstance(v, nn.Variable):
                    continue
                pname = k
                name = "{}/{}".format(prefix, pname)

                param0 = v
                param1 = nn.parameter.pop_parameter(name)
                if param0 is None:
                    raise ValueError(
                        "Model does not have {} parameter.".format(name))
                param0.d = param1.d.copy()
                nn.logger.info("`{}` loaded.)".format(name))

Load parameters from a file with the specified format.

Args:
path : path or file object


def _get_hash(self, file_obj):
    size = 0
    hash_buider = self.hash_builder()
    for piece in self._get_file_iterator(file_obj):
        hash_buider.update(piece)
        size += len(piece)
    file_obj.seek(0)
    return ('%s_%x' % (hash_buider.hexdigest(), size))

Compute hash for the `file_obj`.

Attr:
file_obj (obj): File-like object with ``.write()`` and ``.seek()``.

Returns:
str: Hexdigest of the hash.


class PerceiverClassificationDecoder(PerceiverAbstractDecoder):

    def __init__(self, config, **decoder_kwargs):
        super().__init__()
        self.num_labels = config.num_labels
        self.decoder = PerceiverBasicDecoder(config, output_num_channels=self.num_labels, output_index_dims=1, **decoder_kwargs)

    @property
    def num_query_channels(self) -> int:
        return self.decoder.num_query_channels

    def decoder_query(self, inputs, modality_sizes=None, inputs_without_pos=None, subsampled_points=None):
        return self.decoder.decoder_query(inputs, modality_sizes, inputs_without_pos, subsampled_points=subsampled_points)

    def forward(self, query: torch.Tensor, z: torch.FloatTensor, query_mask: Optional[torch.FloatTensor]=None, output_attentions: Optional[bool]=False) -> PerceiverDecoderOutput:
        decoder_outputs = self.decoder(query, z, output_attentions=output_attentions)
        logits = decoder_outputs.logits[:, 0, :]
        return PerceiverDecoderOutput(logits=logits, cross_attentions=decoder_outputs.cross_attentions)

Cross-attention based classification decoder. Light-weight wrapper of [`PerceiverBasicDecoder`] for logit output.
Will turn the output of the Perceiver encoder which is of shape (batch_size, num_latents, d_latents) to a tensor of
shape (batch_size, num_labels). The queries are of shape (batch_size, 1, num_labels).

Args:
config ([`PerceiverConfig`]):
Model configuration.


def mark_done(task_id):
    task = Task.get_by_id(task_id)
    if (task is None):
        raise ValueError(('Task with id %d does not exist' % task_id))
    task.done = True
    task.put()

Marks a task as done.

Args:
task_id: The integer id of the task to update.

Raises:
ValueError: if the requested task doesn't exist.


def scan_directory(self, dirname, exclude_exts=(), exclude_fnames=()):
    for (i, ext) in enumerate(exclude_exts):
        if (not ext.strip().startswith('.')):
            exclude_exts[i] = ('.' + ext.strip())
    paths = []
    for fname in os.listdir(dirname):
        (root, ext) = os.path.splitext(fname)
        path = os.path.join(dirname, fname)
        if ((ext in exclude_exts) or (fname in exclude_fnames) or fname.startswith('.') or (not os.path.isfile(path))):
            continue
        paths.append(path)
    pseudos = []
    for path in paths:
        try:
            pseudo = self.parse(path)
        except:
            pseudo = None
        if (pseudo is not None):
            pseudos.append(pseudo)
            self._parsed_paths.extend(path)
        else:
            self._wrong_paths.extend(path)
    return pseudos

Analyze the files contained in directory dirname.

Args:
dirname: directory path
exclude_exts: list of file extensions that should be skipped.
exclude_fnames: list of file names that should be skipped.

Returns:
List of pseudopotential objects.


def indicators(self, indicator_type=None, filters=None, params=None):

        indicator = self._tcex.ti.indicator(indicator_type)
        for i in self.tc_requests.indicators_from_tag(
            indicator, self.name, filters=filters, params=params
        ):
            yield i

Gets all indicators from a tag.

Args:
params:
filters:
indicator_type:


def use_test_undeclared_outputs_dir(self):
    return self.is_flag_on(FLAG_NAME_USE_TEST_UNDECLARED_OUTPUTS_DIR)

Decides the output directory of the report and trace files.

Args:
None.

Returns:
True if the output files should be written to the
test-undeclared-outputs-directory defined via an
env variable.


def VFSMultiOpen(pathspecs, progress_callback=None):
    precondition.AssertIterableType(pathspecs, rdf_paths.PathSpec)
    vfs_open = functools.partial(VFSOpen, progress_callback=progress_callback)
    return context.MultiContext(map(vfs_open, pathspecs))

Opens multiple files specified by given path-specs.

See documentation for `VFSOpen` for more information.

Args:
pathspecs: A list of pathspec instances of files to open.
progress_callback: A callback function to call to notify about progress

Returns:
A context manager yielding file-like objects.


def jax_gather(params, indices, batch_dims=2):

    def _jax_gather(params, indices):
        return params[indices]
    for _ in range(batch_dims):
        _jax_gather = jax.vmap(_jax_gather, in_axes=(0, 0))
    return _jax_gather(params, indices)

Gather the indices from params correctly (equivalent to tf.gather but with modifications)

Args:
params: (bsz, n_heads, num_blocks, block_size, head_dim)
indices: (<num_blocks, 1)


def save(self, path):
    self.clip.write_videofile(path, audio_fps=self.clip.audio.fps)

Save source video to file.

Args:
path (str): Filename to save to.

Notes: Saves entire source video to file, not just currently selected
frames.


def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):
    super(BigInteger, self).read(istream, kmip_version=kmip_version)
    if (self.length % 8):
        raise exceptions.InvalidPrimitiveLength('invalid big integer length read; expected: multiple of 8, observed: {0}'.format(self.length))
    sign = 1
    binary = ''
    for _ in range(self.length):
        byte = struct.unpack('!B', istream.read(1))[0]
        bits = '{0:b}'.format(byte)
        pad = (len(bits) % 8)
        if pad:
            bits = (('0' * (8 - pad)) + bits)
        binary += bits
    if (binary[0] == '1'):
        sign = (- 1)
        binary = binary.replace('1', 'i')
        binary = binary.replace('0', '1')
        binary = binary.replace('i', '0')
        pivot = binary.rfind('0')
        binary = ((binary[0:pivot] + '1') + ('0' * len(binary[(pivot + 1):])))
    self.value = (int(binary, 2) * sign)

Read the encoding of the BigInteger from the input stream.

Args:
istream (stream): A buffer containing the encoded bytes of the
value of a BigInteger. Usually a BytearrayStream object.
Required.
kmip_version (KMIPVersion): An enumeration defining the KMIP
version with which the object will be decoded. Optional,
defaults to KMIP 1.0.

Raises:
InvalidPrimitiveLength: if the big integer encoding read in has
an invalid encoded length.


def parse_args(test: ArgList=None) -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('encoded_train_data', help='File path for the encoded training data.')
    parser.add_argument('-o', '--output', help=f'Output file path for the learned weights. (default: {DEFAULT_OUTPUT_NAME})', type=str, default=DEFAULT_OUTPUT_NAME)
    parser.add_argument('--log', help=f'Output file path for the training log. (default: {DEFAULT_LOG_NAME})', type=str, default=DEFAULT_LOG_NAME)
    parser.add_argument('--feature-thres', help=f'Threshold value of the minimum feature frequency. (default: {DEFAULT_FEATURE_THRES})', type=int, default=DEFAULT_FEATURE_THRES)
    parser.add_argument('--iter', help=f'Number of iterations for training. (default: {DEFAULT_ITERATION})', type=int, default=DEFAULT_ITERATION)
    parser.add_argument('--out-span', help=f'Iteration span to output metrics and weights. (default: {DEFAULT_OUT_SPAN})', type=int, default=DEFAULT_OUT_SPAN)
    parser.add_argument('--val-data', help='File path for the encoded validation data.', type=str)
    if test is None:
        return parser.parse_args()
    else:
        return parser.parse_args(test)

Parses commandline arguments.

Args:
test (typing.Optional[typing.List[str]], optional): Commandline args for
testing. Defaults to None.

Returns:
argparse.Namespace: Parsed data of args.


def _VerifyValues(self, input_sizes=None, filter_sizes=None, strides=None, dilations=None, padding=None, data_format_src='NHWC', data_format_dst='NHWC', expected=None, op_name='Conv2D'):
    total_size_1 = np.prod(input_sizes)
    total_size_2 = np.prod(filter_sizes)
    x1 = np.arange(1, total_size_1 + 1, dtype=np.float32).reshape(input_sizes)
    x2 = np.arange(1, total_size_2 + 1, dtype=np.float32).reshape(filter_sizes)
    strides = [1] + strides + [1]
    if dilations is None:
        dilations = [1, 1]
    dilations = [1] + dilations + [1]
    expected = test_utils.ConvertBetweenDataFormats(expected, data_format_src, data_format_dst)
    x1 = test_utils.ConvertBetweenDataFormats(x1, data_format_src, data_format_dst)
    input_sizes = test_utils.PermuteDimsBetweenDataFormats(input_sizes, data_format_src, data_format_dst)
    strides = test_utils.PermuteDimsBetweenDataFormats(strides, data_format_src, data_format_dst)
    dilations = test_utils.PermuteDimsBetweenDataFormats(dilations, data_format_src, data_format_dst)
    with self.session() as sess:
        t1 = array_ops.placeholder(dtypes.float32, shape=input_sizes)
        t2 = array_ops.placeholder(dtypes.float32, shape=filter_sizes)
        with self.test_scope():
            if op_name == 'Conv':
                conv_format = 'CHANNELS_LAST' if data_format_dst == 'NHWC' else 'CHANNELS_FIRST'
                out = gen_nn_ops.conv(t1, t2, strides=strides, padding=padding, data_format=conv_format, dilations=dilations)
            elif op_name == 'Conv2D':
                out = nn_ops.conv2d(t1, t2, strides=strides, padding=padding, data_format=data_format_dst, dilations=dilations)
            else:
                raise ValueError('Invalid op name: %s' % op_name)
        value = sess.run(out, {t1: x1, t2: x2})
        self.assertAllClose(expected, value, 0.001)

Tests that tf.nn.conv2d produces the expected value.

Args:
input_sizes: Input tensor dimensions in [batch, input_rows, input_cols,
input_depth].
filter_sizes: Filter tensor dimensions in [kernel_rows, kernel_cols,
input_depth, output_depth].
strides: Strides.
dilations: RHS dilations.
padding: Padding type.
data_format_src: Data format input is in.
data_format_dst: Data format verification will run and input is converted
to.
expected: Expected output.
op_name: Name of operation to test (Conv/Conv2D)


def related_domains(self, domains):

        api_name = 'opendns-related_domains'
        fmt_url_path = u'links/name/{0}.json'
        return self._multi_get(api_name, fmt_url_path, domains)

Get list of domain names that have been seen requested around the
same time (up to 60 seconds before or after) to the given domain name.

Args:
domains: an enumerable of strings domain names
Returns:
An enumerable of [domain name, scores]


def _parse_line(self, instrumentation_block, line):
    if instrumentation_block.state == _InstrumentationBlockStates.METHOD:
        return self._parse_method_block_line(instrumentation_block, line)
    elif instrumentation_block.state == _InstrumentationBlockStates.RESULT:
        return self._parse_result_block_line(instrumentation_block, line)
    else:
        return self._parse_unknown_block_line(instrumentation_block, line)

Parses an arbitrary line from the instrumentation output based upon
the current parser state.

Args:
instrumentation_block: _InstrumentationBlock, an instrumentation
block with any of the possible parser states.
line: string, the raw instrumentation output line to parse
appropriately.

Returns:
The next instrumenation block to continue parsing with.


def add_get(self, path, controller, template, raw=False):

        if raw:
            fn = controller
        else:
            fn = self._prepare_controller(controller, template)
        self.app.router.add_get(path, fn)

Setup a route of type GET

Args:
path (str): URL to listen to
controller (coroutine): the coroutine to handle the request
template (str): the template to render the response or None if it is a JSON response
raw (bool): indicates if post-processing (jinja, json, etc) is needed or not


def empty_like(x, init=None):
    x = ops.convert_to_tensor(x)
    return gen_array_ops.empty(array_ops.shape(x), x.dtype, init=init)

Returns a non-initialized tensor with the same shape and dtype as x.

Args:
x: A Tensor.
init: Initialize the returned tensor with the default value of
x.dtype(), if True. Otherwise, do not initialize. Defaults to
None.

Returns:
A tensor y, whose dtype and shape are the same as those of x.
y is guaranteed not to be an alias of x. Upon return, y may contain
arbitrary data.


def valid(self, value, level=[]):

		self.validation_failures = []

		if value is None and self._optional:
			return True

		if not isinstance(value, dict):
			self.validation_failures.append(('.'.join(level), str(value)))
			return False

		bRet = True

		for k in self._nodes:

			lLevel = level[:]
			lLevel.append(k)

			if k not in value:

				if not self._nodes[k]._optional:
					self.validation_failures.append(('.'.join(lLevel), 'missing'))
					bRet = False

				continue

			if not self._nodes[k].valid(value[k], lLevel):
				self.validation_failures.extend(self._nodes[k].validation_failures)
				bRet = False
				continue

			if k in self._requires:

				for f in self._requires[k]:

					if f not in value or value[f] in ('0000-00-00','',None):
						self.validation_failures.append(('.'.join(lLevel), 'requires \'%s\' to also be set' % str(f)))
						bRet = False

		return bRet

Valid

Checks if a value is valid based on the instance's values

Arguments:
value {mixed} -- The value to validate

Returns:
bool


def chmod_r(root: str, permission: int) -> None:
    os.chmod(root, permission)
    for (dirpath, dirnames, filenames) in os.walk(root):
        for d in dirnames:
            os.chmod(os.path.join(dirpath, d), permission)
        for f in filenames:
            os.chmod(os.path.join(dirpath, f), permission)

Recursive ``chmod``.

Args:
root: directory to walk down
permission: e.g. ``e.g. stat.S_IWUSR``


def pre_run_cell(self, cellno, code):

        self.cellid = cellno

        import ast
        if findloop(ast.parse(code)):

            from acorn.logging.decoration import set_streamlining
            set_streamlining(True)

            from time import time
            self.pre = {
                "m": "loop",
                "a": None,
                "s": time(),
                "r": None,
                "c": code,
            }

Executes before the user-entered code in `ipython` is run. This
intercepts loops and other problematic code that would produce lots of
database entries and streamlines it to produce only a single entry.

Args:
cellno (int): the cell number that is about to be executed.
code (str): python source code that is about to be executed.


def get_ini(self, incl_unset=False):

        configp = configparser.ConfigParser(allow_no_value=True)
        configp.read_dict(self._config)
        with StringIO() as config_ini:
            if self._parser:
                self._parser.set_defaults(
                    **self.get_section(self.root_section)
                )
                argparse_ini = argparse_to_ini(
                    parser=self._parser, incl_unset=incl_unset
                )
                return argparse_ini
            else:
                configp.write(config_ini)
                return config_ini.getvalue()

Return the config dictionary in INI format
Args:
incl_unset (bool): include variables with no defaults.

Returns:
str: string of the config file in INI format


def _display(port=None, height=None, print_message=False, display_handle=None):
    if (height is None):
        height = 800
    if (port is None):
        infos = manager.get_all()
        if (not infos):
            raise ValueError("Can't display TensorBoard: no known instances running.")
        else:
            info = max(manager.get_all(), key=(lambda x: x.start_time))
            port = info.port
    else:
        infos = [i for i in manager.get_all() if (i.port == port)]
        info = (max(infos, key=(lambda x: x.start_time)) if infos else None)
    if print_message:
        if (info is not None):
            message = 'Selecting TensorBoard with {data_source} (started {delta} ago; port {port}, pid {pid}).'.format(data_source=manager.data_source_from_info(info), delta=_time_delta_from_info(info), port=info.port, pid=info.pid)
            print(message)
        else:
            pass
    fn = {_CONTEXT_COLAB: _display_colab, _CONTEXT_IPYTHON: _display_ipython, _CONTEXT_NONE: _display_cli}[_get_context()]
    return fn(port=port, height=height, display_handle=display_handle)

Internal version of `display`.

Args:
port: As with `display`.
height: As with `display`.
print_message: True to print which TensorBoard instance was selected
for display (if applicable), or False otherwise.
display_handle: If not None, an IPython display handle into which to
render TensorBoard.


def set_flowcontrol(self, name, direction, value=None, default=False, disable=False):
    if (value is not None):
        if (value not in ['on', 'off']):
            raise ValueError('invalid flowcontrol value')
    if (direction not in ['send', 'receive']):
        raise ValueError('invalid direction specified')
    commands = [('interface %s' % name)]
    commands.append(self.command_builder(('flowcontrol %s' % direction), value=value, default=default, disable=disable))
    return self.configure(commands)

Configures the interface flowcontrol value

Args:
name (string): The interface identifier.  It must be a full
interface name (ie Ethernet, not Et)

direction (string): one of either 'send' or 'receive'

value (boolean): True if the interface should enable flow control
packet handling, otherwise False

default (boolean): Specifies to default the interface flow control
send or receive value

disable (boolean): Specifies to disable the interface flow control
send or receive value

Returns:
True if the operation succeeds otherwise False is returned


def process(self, batch, device=None):

        padded = self.pad(batch)
        tensor = self.numericalize(padded, device=device)
        return tensor

Process a list of examples to create a torch.Tensor.

Pad, numericalize, and postprocess a batch and create a tensor.

Args:
batch (list(object)): A list of object from a batch of examples.
Returns:
torch.autograd.Variable: Processed object given the input
and custom postprocessing Pipeline.


def coupling_efficiency(mode_solver, fibre_mfd, fibre_offset_x=0, fibre_offset_y=0, n_eff_fibre=1.441):
    etas = []
    gaus = _make_gaussian(mode_solver._structure.xc, mode_solver._structure.yc, fibre_mfd, fibre_offset_x, fibre_offset_y)
    for (mode, n_eff) in zip(mode_solver.modes, mode_solver.n_effs):
        o = abs(_overlap(mode, gaus))
        t = abs(transmission(n_eff, n_eff_fibre))
        eta = (o * t)
        etas.append(eta)
    return etas

Finds the coupling efficiency between a solved
fundamental mode and a fibre of given MFD.

Args:
mode_solver (_ModeSolver): Mode solver that
has found a fundamental mode.
fibre_mfd (float): The mode-field diameter
(MFD) of the fibre.
fibre_offset_x (float): Offset the fibre
from the centre position of the window
in x. Default is 0 (no offset).
fibre_offset_y (float): Offset the fibre
from the centre position of the window
in y. Default is 0 (no offset).
n_eff_fibre (float): The effective index
of the fibre mode.  Default is 1.441.

Returns:
float: The power coupling efficiency.