class ParameterListState(object):

    def __init__(self, opening_bracket, newline, opening_column):
        self.opening_bracket = opening_bracket
        self.has_split_before_first_param = newline
        self.opening_column = opening_column
        self.parameters = opening_bracket.parameters
        self.split_before_closing_bracket = False

    @property
    def closing_bracket(self):
        return self.opening_bracket.matching_bracket

    @property
    def has_typed_return(self):
        return self.closing_bracket.next_token.value == '->'

    @property
    @lru_cache()
    def has_default_values(self):
        return any((param.has_default_value for param in self.parameters))

    @property
    @lru_cache()
    def ends_in_comma(self):
        if not self.parameters:
            return False
        return self.parameters[-1].last_token.next_token.value == ','

    @property
    @lru_cache()
    def last_token(self):
        token = self.opening_bracket.matching_bracket
        while not token.is_comment and token.next_token:
            token = token.next_token
        return token

    @lru_cache()
    def LastParamFitsOnLine(self, indent):

        if not self.has_typed_return:
            return False
        if not self.parameters:
            return True
        total_length = self.last_token.total_length
        last_param = self.parameters[-1].first_token
        total_length -= last_param.total_length - len(last_param.value)
        return total_length + indent <= style.Get('COLUMN_LIMIT')

    @lru_cache()
    def SplitBeforeClosingBracket(self, indent):

        if style.Get('DEDENT_CLOSING_BRACKETS'):
            return True
        if self.ends_in_comma:
            return True
        if not self.parameters:
            return False
        total_length = self.last_token.total_length
        last_param = self.parameters[-1].first_token
        total_length -= last_param.total_length - len(last_param.value)
        return total_length + indent > style.Get('COLUMN_LIMIT')

    def Clone(self):
        clone = ParameterListState(self.opening_bracket, self.has_split_before_first_param, self.opening_column)
        clone.split_before_closing_bracket = self.split_before_closing_bracket
        clone.parameters = [param.Clone() for param in self.parameters]
        return clone

    def __repr__(self):
        return '[opening_bracket::%s, has_split_before_first_param::%s, opening_column::%d]' % (self.opening_bracket, self.has_split_before_first_param, self.opening_column)

    def __eq__(self, other):
        return hash(self) == hash(other)

    def __ne__(self, other):
        return not self == other

    def __hash__(self, *args, **kwargs):
        return hash((self.opening_bracket, self.has_split_before_first_param, self.opening_column, (hash(param) for param in self.parameters)))

Maintains the state of function parameter list formatting decisions.

Attributes:
opening_bracket: The opening bracket of the parameter list.
closing_bracket: The closing bracket of the parameter list.
has_typed_return: True if the function definition has a typed return.
ends_in_comma: True if the parameter list ends in a comma.
last_token: Returns the last token of the function declaration.
has_default_values: True if the parameters have default values.
has_split_before_first_param: Whether there is a newline before the first
parameter.
opening_column: The position of the opening parameter before a newline.
parameters: A list of parameter objects (Parameter).
split_before_closing_bracket: Split before the closing bracket. Sometimes
needed if the indentation would collide.


def Print(self, x, data, message, **kwargs):

    tf.logging.info("PlacementMeshImpl::Print")
    new_slices = x.tensor_list[:]
    with tf.device(self._devices[0]):
      new_slices[0] = tf.Print(
          new_slices[0], [t for d in data for t in d.tensor_list],
          message, **kwargs)
    return self.LaidOutTensor(new_slices)

call tf.Print.

Args:
x: a LaidOutTensor
data: a list of LaidOutTensor
message: a string
**kwargs: keyword arguments to tf.print
Returns:
a LaidOutTensor


def solve_fba(self, objective):

        self._prob.set_objective(self._v_wt[objective])
        return self._solve(lp.ObjectiveSense.Maximize)

Solve the wild type problem using FBA.

Args:
objective: The objective reaction to be maximized.

Returns:
The LP Result object for the solved FBA problem.


def check_type(o, acceptable_types, may_be_none=True):

    if not isinstance(acceptable_types, tuple):
        acceptable_types = (acceptable_types,)

    if may_be_none and o is None:

        pass
    elif isinstance(o, acceptable_types):

        pass
    else:

        error_message = (
            "We were expecting to receive an instance of one of the following "
            "types: {types}{none}; but instead we received {o} which is a "
            "{o_type}.".format(
                types=", ".join([repr(t.__name__) for t in acceptable_types]),
                none="or 'None'" if may_be_none else "",
                o=o,
                o_type=repr(type(o).__name__)
            )
        )
        raise TypeError(error_message)

Object is an instance of one of the acceptable types or None.

Args:
o: The object to be inspected.
acceptable_types: A type or tuple of acceptable types.
may_be_none(bool): Whether or not the object may be None.

Raises:
TypeError: If the object is None and may_be_none=False, or if the
object is not an instance of one of the acceptable types.


def _check_rules(browser, rules_js, config):
    if (config.rules_to_run is None):
        msg = 'No accessibility rules were specified to check.'
        log.warning(msg)
        return None
    rules = config.rules_to_run
    if rules:
        rules_config = u'auditConfig.auditRulesToRun = {rules};'.format(rules=rules)
    else:
        rules_config = ''
    ignored_rules = config.rules_to_ignore
    if ignored_rules:
        rules_config += u'\nauditConfig.auditRulesToIgnore = {rules};'.format(rules=ignored_rules)
    script = dedent(u'\n            {rules_js}\n            var auditConfig = new axs.AuditConfiguration();\n            {rules_config}\n            auditConfig.scope = {scope};\n            var run_results = axs.Audit.run(auditConfig);\n            var audit_results = axs.Audit.auditResults(run_results)\n            return audit_results;\n        '.format(rules_js=rules_js, rules_config=rules_config, scope=config.scope))
    result = browser.execute_script(script)
    audit_results = AuditResults(errors=result.get('errors_'), warnings=result.get('warnings_'))
    return audit_results

Check the page for violations of the configured rules. By default,
all rules in the ruleset will be checked.

Args:
browser: a browser instance.
rules_js: the ruleset JavaScript as a string.
config: an AxsAuditConfig instance.

Returns:
A namedtuple with 'errors' and 'warnings' fields whose values are
the errors and warnings returned from the audit.

None if config has rules_to_run set to None.

__Caution__: You probably don't really want to call this method
directly! It will be used by `A11yAudit.do_audit` if using this ruleset.


def name_changed(self, changed_item):

        name = str(changed_item.text())

        if name != '':
            if name != self.selected_element_name:
                self.elements_from_file[name] = self.elements_from_file[self.selected_element_name]
                del self.elements_from_file[self.selected_element_name]
                self.selected_element_name = name

checks if name has been changed and ignores the name change if the changed_item is an existing script
Args:
changed_item:


def discrete_bottleneck(self, x):

    x_reshaped = self.slice_hidden(x)
    x_means_hot = []
    x_means = 0
    loss = 0
    x_means_hot, x_means, q_loss, e_loss = self.embedding_lookup(
        x_reshaped, self.means)

    if self.hparams.ema:
      tf.logging.info("Using EMA with beta = {}".format(self.hparams.beta))
      updated_ema_count = \
          moving_averages.assign_moving_average(
              self.ema_count,
              tf.reduce_sum(
                  tf.reshape(
                      x_means_hot,
                      shape=[-1, self.hparams.num_blocks,
                             self.hparams.block_v_size]),
                  axis=0),
              self.hparams.decay,
              zero_debias=False)

      dw = tf.matmul(
          tf.transpose(x_means_hot, perm=[1, 2, 0]),
          tf.transpose(x_reshaped, perm=[1, 0, 2]))

      updated_ema_means = \
          moving_averages.assign_moving_average(
              self.ema_means, dw, self.hparams.decay,
              zero_debias=False)
      n = tf.reduce_sum(updated_ema_count, axis=-1, keep_dims=True)
      updated_ema_count = ((updated_ema_count + self.hparams.epsilon) / (
          n + 2**self.hparams.z_size * self.hparams.epsilon) * n)
      updated_ema_means = updated_ema_means / tf.expand_dims(
          updated_ema_count, axis=-1)

      with tf.control_dependencies([e_loss]):
        update_means = tf.assign(self.means, updated_ema_means)
        with tf.control_dependencies([update_means]):
          loss += self.hparams.beta * e_loss
    else:

      loss += q_loss + self.hparams.beta * e_loss

    x_means_idx = tf.argmax(x_means_hot, axis=-1)

    num_bits = int(self.hparams.z_size
    x_means_bits = self.int_to_bit(x_means_idx, num_bits=num_bits, base=2)
    x_discrete = self.bit_to_int(
        tf.to_int32(x_means_bits), num_bits=self.hparams.z_size, base=2)

    shape_x = common_layers.shape_list(x)
    shape_discrete = shape_x[:-1]
    x_discrete = tf.reshape(x_discrete, shape_discrete)
    x_means = tf.reshape(x_means, shape=shape_x)
    h1 = x + tf.stop_gradient(x_means - x)

    h2 = tf.layers.dense(tf.nn.relu(h1), self.hparams.filter_size, name="vch2")
    res = tf.layers.dense(
        tf.nn.relu(h2), self.hparams.hidden_size, name="vcfin")
    embed_fn = partial(self.embed)
    return {
        "dense": res,
        "discrete": x_discrete,
        "loss": loss,
        "embed": embed_fn
    }

Discretization bottleneck for latent variables.

Args:
x: Input to the discretization bottleneck.

Returns:
Embedding to pass to the decoder, discrete latent, loss, and the
embedding
function.

Raises:
ValueError: If projection_tensors is None for reshape_method
project, or
ema_count or ema_means is None if we are using ema, or unknown
args.


def on_run_end(self, request):
    self._is_run_start = False
    if request.performed_action == framework.OnRunStartAction.DEBUG_RUN:
        partition_graphs = None
        if request.run_metadata and request.run_metadata.partition_graphs:
            partition_graphs = request.run_metadata.partition_graphs
        elif request.client_graph_def:
            partition_graphs = [request.client_graph_def]
        if request.tf_error and (not os.path.isdir(self._dump_root)):
            raise request.tf_error
        debug_dump = debug_data.DebugDumpDir(self._dump_root, partition_graphs=partition_graphs)
        debug_dump.set_python_graph(self._sess.graph)
        passed_filter = None
        passed_filter_exclude_node_names = None
        if self._active_tensor_filter:
            if not debug_dump.find(self._tensor_filters[self._active_tensor_filter], first_n=1, exclude_node_names=self._active_filter_exclude_node_names):
                self._remove_dump_root()
                return framework.OnRunEndResponse()
            else:
                passed_filter = self._active_tensor_filter
                passed_filter_exclude_node_names = self._active_filter_exclude_node_names
                self._active_tensor_filter = None
                self._active_filter_exclude_node_names = None
        self._prep_debug_cli_for_run_end(debug_dump, request.tf_error, passed_filter, passed_filter_exclude_node_names)
        self._run_start_response = self._launch_cli()
        self._remove_dump_root()
    elif request.performed_action == framework.OnRunStartAction.PROFILE_RUN:
        self._prep_profile_cli_for_run_end(self._sess.graph, request.run_metadata)
        self._run_start_response = self._launch_cli()
    else:
        self._run_start_response = None
    return framework.OnRunEndResponse()

Overrides on-run-end callback.

Actions taken:
1) Load the debug dump.
2) Bring up the Analyzer CLI.

Args:
request: An instance of OnSessionInitRequest.

Returns:
An instance of OnSessionInitResponse.


def extractDates(self, inp):

    def merge(param):
        (day, time) = param
        if (not (day or time)):
            return None
        if (not day):
            return time
        if (not time):
            return day
        return datetime.datetime(day.year, day.month, day.day, time.hour, time.minute)
    days = self.extractDays(inp)
    times = self.extractTimes(inp)
    return map(merge, zip_longest(days, times, fillvalue=None))

Extract semantic date information from an input string.
In effect, runs both parseDay and parseTime on the input
string and merges the results to produce a comprehensive
datetime object.

Args:
inp (str): Input string to be parsed.

Returns:
A list of datetime objects containing the extracted dates from the
input snippet, or an empty list if not found.


def wp_decode(self, sequences):
    decode_strs = [seq.replace(' ', '') for seq in self.wp_tokenizer.batch_decode(sequences)]
    return decode_strs

Convert a list of lists of word piece token ids into a list of strings by calling word piece tokenizer.

Args:
sequences (`torch.Tensor`):
List of tokenized input ids.
Returns:
`List[str]`: The list of wp decoded sentences.


def _get_function(self, name):
    return self._functions.get(compat.as_str(name), None)

Returns the function definition for 'name'.

Args:
name: string function name.

Returns:
The function def proto.


def playback_trajectory(env, ep_dir):
    xml_path = os.path.join(ep_dir, 'model.xml')
    with open(xml_path, 'r') as f:
        env.reset_from_xml_string(f.read())
    state_paths = os.path.join(ep_dir, 'state_*.npz')
    t = 0
    for state_file in sorted(glob(state_paths)):
        print(state_file)
        dic = np.load(state_file)
        states = dic['states']
        for state in states:
            env.sim.set_state_from_flattened(state)
            env.sim.forward()
            env.render()
            t += 1
            if ((t % 100) == 0):
                print(t)

Playback data from an episode.

Args:
ep_dir: The path to the directory containing data for an episode.


def update_tag(self, tag_name, description=None,
                   custom_properties=None, **kwargs):

        data = {'description': description or '',
                'customProperties': custom_properties or {}}
        resp = self._put(self._u(self._TAG_ENDPOINT_SUFFIX, tag_name),
                         data=data, **kwargs)
        resp.raise_for_status()
        return resp.json()

update a tag by name

Args:
tag_name (string): name of tag to update
description (optional[string]): a description
custom_properties (optional[dict]): dictionary of custom properties


def _convert_id_to_token(self, artists_index, genres_index, lyric_index):
    artist = self.artists_decoder.get(artists_index)
    genres = [self.genres_decoder.get(genre) for genre in genres_index]
    lyrics = [self.lyrics_decoder.get(character) for character in lyric_index]
    return (artist, genres, lyrics)

Converts an index (integer) in a token (str) using the vocab.

Args:
artists_index (`int`):
Index of the artist in its corresponding dictionary.
genres_index (`Union[List[int], int]`):
Index of the genre in its corresponding dictionary.
lyric_index (`List[int]`):
List of character indices, which each correspond to a character.


def get_special_tokens_mask(self, token_ids_0: List[int], token_ids_1: Optional[List[int]]=None, already_has_special_tokens: bool=False) -> List[int]:
    if already_has_special_tokens:
        return super().get_special_tokens_mask(token_ids_0=token_ids_0, token_ids_1=token_ids_1, already_has_special_tokens=True)
    if token_ids_1 is not None:
        return [1] + [0] * len(token_ids_0) + [1] + [0] * len(token_ids_1) + [1]
    return [1] + [0] * len(token_ids_0) + [1]

Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding
special tokens using the tokenizer `prepare_for_model` method.

Args:
token_ids_0 (`List[int]`):
List of IDs.
token_ids_1 (`List[int]`, *optional*):
Optional second list of IDs for sequence pairs.
already_has_special_tokens (`bool`, *optional*, defaults to `False`):
Whether or not the token list is already formatted with special tokens for the model.

Returns:
`List[int]`: A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token.


def is_link(path):
    if (sys.getwindowsversion().major < 6):
        raise SaltInvocationError('Symlinks are only supported on Windows Vista or later.')
    try:
        return salt.utils.path.islink(path)
    except Exception as exc:
        raise CommandExecutionError(exc)

Check if the path is a symlink

This is only supported on Windows Vista or later.

Inline with Unix behavior, this function will raise an error if the path
is not a symlink, however, the error raised will be a SaltInvocationError,
not an OSError.

Args:
path (str): The path to a file or directory

Returns:
bool: True if path is a symlink, otherwise False

CLI Example:

.. code-block:: bash

salt '*' file.is_link /path/to/link


def to_dict(self, fields=None):

        data = {}

        def _add(field):
            return (fields is None or field in fields)

        if _add("resolved_packages"):
            resolved_packages = []
            for pkg in (self._resolved_packages or []):
                resolved_packages.append(pkg.handle.to_dict())
            data["resolved_packages"] = resolved_packages

        if _add("serialize_version"):
            data["serialize_version"] = \
                '.'.join(map(str, ResolvedContext.serialize_version))

        if _add("patch_locks"):
            data["patch_locks"] = dict((k, v.name) for k, v in self.patch_locks)

        if _add("package_orderers"):
            package_orderers = [package_order.to_pod(x)
                                for x in (self.package_orderers or [])]
            data["package_orderers"] = package_orderers or None

        if _add("package_filter"):
            data["package_filter"] = self.package_filter.to_pod()

        if _add("graph"):
            if self.graph_string and self.graph_string.startswith('{'):
                graph_str = self.graph_string
            else:
                g = self.graph()
                graph_str = write_compacted(g)

            data["graph"] = graph_str

        data.update(dict(
            timestamp=self.timestamp,
            requested_timestamp=self.requested_timestamp,
            building=self.building,
            caching=self.caching,
            implicit_packages=map(str, self.implicit_packages),
            package_requests=map(str, self._package_requests),
            package_paths=self.package_paths,

            default_patch_lock=self.default_patch_lock.name,

            rez_version=self.rez_version,
            rez_path=self.rez_path,
            user=self.user,
            host=self.host,
            platform=self.platform,
            arch=self.arch,
            os=self.os,
            created=self.created,

            parent_suite_path=self.parent_suite_path,
            suite_context_name=self.suite_context_name,

            status=self.status_.name,
            failure_description=self.failure_description,

            from_cache=self.from_cache,
            solve_time=self.solve_time,
            load_time=self.load_time,
            num_loaded_packages=self.num_loaded_packages
        ))

        if fields:
            data = dict((k, v) for k, v in data.iteritems() if k in fields)

        return data

Convert context to dict containing only builtin types.

Args:
fields (list of str): If present, only write these fields into the
dict. This can be used to avoid constructing expensive fields
(such as 'graph') for some cases.

Returns:
dict: Dictified context.


def labels(self, main_type, sub_type, unique_id, owner=None, filters=None, params=None):

        params = params or {}

        if owner:
            params['owner'] = owner
        if filters and filters.filters:
            params['filters'] = filters.filters_string
        if not sub_type:
            url = '/v2/{}/{}/securityLabels'.format(main_type, unique_id)
        else:
            url = '/v2/{}/{}/{}/securityLabels'.format(main_type, sub_type, unique_id)

        for l in self._iterate(url, params, 'securityLabel'):
            yield l

Args:
main_type:
sub_type:
unique_id:
owner:
filters:
params:

Return:


def graph_def(self):
    return self._graph.as_graph_def(add_shapes=self._add_shapes)

A serializable version of the underlying TensorFlow graph.

Returns:
A graph_pb2.GraphDef proto containing nodes for all of the Operations in
the underlying TensorFlow graph.


def transformer_prepare_encoder(inputs, target_space, hparams, features=None):

  ishape_static = inputs.shape.as_list()
  encoder_input = inputs
  if features and "inputs_segmentation" in features:

    inputs_segmentation = features["inputs_segmentation"]
    inputs_position = features["inputs_position"]
    targets_segmentation = features["targets_segmentation"]
    if (hasattr(hparams, "unidirectional_encoder") and
        hparams.unidirectional_encoder):
      tf.logging.info("Using unidirectional encoder")
      encoder_self_attention_bias = (
          common_attention.attention_bias_lower_triangle(
              common_layers.shape_list(inputs)[1]))
    else:
      encoder_self_attention_bias = (
          common_attention.attention_bias_same_segment(
              inputs_segmentation, inputs_segmentation))
    encoder_decoder_attention_bias = (
        common_attention.attention_bias_same_segment(targets_segmentation,
                                                     inputs_segmentation))
  else:
    encoder_padding = common_attention.embedding_to_padding(encoder_input)
    ignore_padding = common_attention.attention_bias_ignore_padding(
        encoder_padding)
    if (hasattr(hparams, "unidirectional_encoder") and
        hparams.unidirectional_encoder):
      tf.logging.info("Using unidirectional encoder")
      encoder_self_attention_bias = (
          common_attention.attention_bias_lower_triangle(
              common_layers.shape_list(inputs)[1]))
    else:

      encoder_self_attention_bias = ignore_padding
    encoder_decoder_attention_bias = ignore_padding
    inputs_position = None
  if hparams.proximity_bias:
    encoder_self_attention_bias += common_attention.attention_bias_proximal(
        common_layers.shape_list(inputs)[1])
  if target_space is not None and hparams.get("use_target_space_embedding",
                                              True):

    emb_target_space = common_layers.embedding(
        target_space,
        32,
        ishape_static[-1],
        name="target_space_embedding",
        dtype=hparams.get("activation_dtype", "float32"))
    emb_target_space = tf.reshape(emb_target_space, [1, 1, -1])
    encoder_input += emb_target_space
  if hparams.pos == "timing":
    if inputs_position is not None:
      encoder_input = common_attention.add_timing_signal_1d_given_position(
          encoder_input, inputs_position)
    else:
      encoder_input = common_attention.add_timing_signal_1d(encoder_input)
  elif hparams.pos == "emb":
    encoder_input = common_attention.add_positional_embedding(
        encoder_input, hparams.max_length, "inputs_positional_embedding",
        inputs_position)

  encoder_self_attention_bias = common_layers.cast_like(
      encoder_self_attention_bias, encoder_input)
  encoder_decoder_attention_bias = common_layers.cast_like(
      encoder_decoder_attention_bias, encoder_input)
  return (encoder_input, encoder_self_attention_bias,
          encoder_decoder_attention_bias)

Prepare one shard of the model for the encoder.

Args:
inputs: a Tensor.
target_space: a Tensor.
hparams: run hyperparameters
features: optionally pass the entire features dictionary as well.
This is needed now for "packed" datasets.

Returns:
encoder_input: a Tensor, bottom of encoder stack
encoder_self_attention_bias: a bias tensor for use in encoder self-attention
encoder_decoder_attention_bias: a bias tensor for use in encoder-decoder
attention


def _get_index_points(self, index_points=None):

    if self._index_points is None and index_points is None:
      raise ValueError(
          'This GaussianProcess instance was not instantiated with a value for '
          'index_points. One must therefore be provided when calling sample, '
          'log_prob, and other such methods. In particular, one can\'t compute '
          'KL divergences to/from an instance of `GaussianProccess` with '
          'unspecified `index_points` directly. Instead, use the '
          '`get_marginal_distribution` function, which takes `index_points` as '
          'an argument and returns a `Normal` or '
          '`MultivariateNormalLinearOperator` instance, whose KL can be '
          'computed.')
    return index_points if index_points is not None else self._index_points

Return `index_points` if not None, else `self._index_points`.

Args:
index_points: if given, this is what is returned; else,
`self._index_points`

Returns:
index_points: the given arg, if not None, else the class member
`self._index_points`.

Rases:
ValueError: if `index_points` and `self._index_points` are both `None`.


def transformer_encoder_ffn_unit(x, hparams, nonpadding_mask=None, pad_remover=None):
    with tf.variable_scope('ffn'):
        if (hparams.transformer_ffn_type == 'fc'):
            y = transformer.transformer_ffn_layer(common_layers.layer_preprocess(x, hparams), hparams, pad_remover, conv_padding='SAME', nonpadding_mask=nonpadding_mask)
        if (hparams.transformer_ffn_type == 'sepconv'):
            assert (nonpadding_mask is not None), 'The nonpadding_mask should be provided, otherwise the model uses the leaked padding information to estimate the length!'
            y = common_layers.sepconv_relu_sepconv(common_layers.layer_preprocess(x, hparams), filter_size=hparams.filter_size, output_size=hparams.hidden_size, first_kernel_size=(3, 1), second_kernel_size=(5, 1), padding='SAME', nonpadding_mask=nonpadding_mask, dropout=hparams.relu_dropout)
        x = common_layers.layer_postprocess(x, y, hparams)
    return x

Applies a feed-forward function which is parametrised for encoding.

Args:
x: input
hparams: model hyper-parameters
nonpadding_mask: optional Tensor with shape [batch_size, encoder_length]
indicating what positions are not padding.  This is used
to mask out padding in convoltutional layers.  We generally only
need this mask for "packed" datasets, because for ordinary datasets,
no padding is ever followed by nonpadding.
pad_remover: to mask out padding in convolutional layers (efficiency).

Returns:
the output tensor


def _parse_price(html_chunk):
    price = get_first_content(html_chunk.find('div', {'class': 'prices'}))
    if (not price):
        return None
    price = dhtmlparser.removeTags(price)
    price = price.split('\n')[(- 1)]
    return price

Parse price of the book.

Args:
html_chunk (obj): HTMLElement containing slice of the page with details.

Returns:
str/None: Price as string with currency or None if not found.


def __init__(self, config, auth: str) -> None:
    self.config = config
    self.auth = auth
    self.columns = SA_FIELDS
    self.reportId = None

Construct a report factory, providing project and authentication data.

This class will track the reportID internally if the request call is used.

Args:
config, required - see: starthinker/util/configuration.py
auth, required - either "user" or "service" used to create and/or read the report.

Returns: None


def from_config(cls, config, custom_objects=None, columns_by_name=None):
    return cls._from_config(config, custom_objects, columns_by_name)

Creates a FeatureColumn from its config.

This method should be the reverse of `get_config`, capable of instantiating
the same FeatureColumn from the config dictionary. See `get_config` for an
example of common (de)serialization practices followed in this file.

TODO(b/118939620): This is a private method until consensus is reached on
supporting object deserialization deduping within Keras.

Args:
config: A Dict config acquired with `get_config`.
custom_objects: Optional dictionary mapping names (strings) to custom
classes or functions to be considered during deserialization.
columns_by_name: A Dict[String, FeatureColumn] of existing columns in
order to avoid duplication. Should be passed to any calls to
deserialize_feature_column().

Returns:
A FeatureColumn for the input config.


def sample_uniform(domain, rng):
    if isinstance(domain, hp.IntInterval):
        return rng.randint(domain.min_value, domain.max_value)
    elif isinstance(domain, hp.RealInterval):
        return rng.uniform(domain.min_value, domain.max_value)
    elif isinstance(domain, hp.Discrete):
        return rng.choice(domain.values)
    else:
        raise TypeError(('unknown domain type: %r' % (domain,)))

Sample a value uniformly from a domain.

Args:
domain: An `IntInterval`, `RealInterval`, or `Discrete` domain.
rng: A `random.Random` object; defaults to the `random` module.

Raises:
TypeError: If `domain` is not a known kind of domain.
IndexError: If the domain is empty.


def post_process_object_detection(self, outputs, threshold: float=0.5, target_sizes: Union[TensorType, List[Tuple]]=None, top_k: int=100):
    out_logits, out_bbox = (outputs.logits, outputs.pred_boxes)
    if target_sizes is not None:
        if len(out_logits) != len(target_sizes):
            raise ValueError('Make sure that you pass in as many target sizes as the batch dimension of the logits')
    prob = out_logits.sigmoid()
    prob = prob.view(out_logits.shape[0], -1)
    k_value = min(top_k, prob.size(1))
    topk_values, topk_indexes = torch.topk(prob, k_value, dim=1)
    scores = topk_values
    topk_boxes = torch.div(topk_indexes, out_logits.shape[2], rounding_mode='floor')
    labels = topk_indexes % out_logits.shape[2]
    boxes = center_to_corners_format(out_bbox)
    boxes = torch.gather(boxes, 1, topk_boxes.unsqueeze(-1).repeat(1, 1, 4))
    if target_sizes is not None:
        if isinstance(target_sizes, List):
            img_h = torch.Tensor([i[0] for i in target_sizes])
            img_w = torch.Tensor([i[1] for i in target_sizes])
        else:
            img_h, img_w = target_sizes.unbind(1)
        scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1).to(boxes.device)
        boxes = boxes * scale_fct[:, None, :]
    results = []
    for s, l, b in zip(scores, labels, boxes):
        score = s[s > threshold]
        label = l[s > threshold]
        box = b[s > threshold]
        results.append({'scores': score, 'labels': label, 'boxes': box})
    return results

Converts the raw output of [`DeformableDetrForObjectDetection`] into final bounding boxes in (top_left_x,
top_left_y, bottom_right_x, bottom_right_y) format. Only supports PyTorch.

Args:
outputs ([`DetrObjectDetectionOutput`]):
Raw outputs of the model.
threshold (`float`, *optional*):
Score threshold to keep object detection predictions.
target_sizes (`torch.Tensor` or `List[Tuple[int, int]]`, *optional*):
Tensor of shape `(batch_size, 2)` or list of tuples (`Tuple[int, int]`) containing the target size
(height, width) of each image in the batch. If left to None, predictions will not be resized.
top_k (`int`, *optional*, defaults to 100):
Keep only top k bounding boxes before filtering by thresholding.

Returns:
`List[Dict]`: A list of dictionaries, each dictionary containing the scores, labels and boxes for an image
in the batch as predicted by the model.


def notify_progress(self, conn_string, operation, finished, total, wait=True):
    if (operation not in self.PROGRESS_OPERATIONS):
        raise ArgumentError('Invalid operation for progress event: {}'.format(operation))
    event = dict(operation=operation, finished=finished, total=total)
    if wait:
        return self.notify_event(conn_string, 'progress', event)
    self.notify_event_nowait(conn_string, 'progress', event)
    return None

Send a progress event.

Progress events can be sent for ``debug`` and ``script`` operations and
notify the caller about the progress of these potentially long-running
operations.  They have two integer properties that specify what fraction
of the operation has been completed.

Args:
conn_string (str): The device that is sending the event.
operations (str): The operation that is in progress: debug or script
finished (int): The number of "steps" that have finished.
total (int): The total number of steps to perform.
wait (bool): Whether to return an awaitable that we can use to
block until the notification has made it to all callbacks.

Returns:
awaitable or None: An awaitable if wait=True.

If wait is False, the notification is run in the background with
no way to check its progress and None is returned.


def condition_indices(df):

    eigvals = eigenvalues(df)
    cond_idx = np.sqrt(eigvals.max() / eigvals)
    return pd.Series(cond_idx, df.columns, name='Condition index')

Returns a pandas Series with condition indices of the df columns.

Args:
df: pandas DataFrame with columns to run diagnostics on


def get_user(self, user_id=None, user_name=None):
    if user_id:
        endpoint = '/api/user_id/{0}'.format(user_id)
    elif user_name:
        endpoint = '/api/user_name/{0}'.format(user_name)
    else:
        endpoint = '/api/user'
    data = self._make_request(verb='GET', endpoint=endpoint)
    try:
        return User.NewFromJSON(data)
    except:
        return data

Get a user object from the API. If no ``user_id`` or ``user_name``
is specified, it will return the User object for the currently
authenticated user.

Args:
user_id (int): User ID of the user for whom you want to get
information. [Optional]
user_name(str): Username for the user for whom you want to get
information. [Optional]

Returns:
A User object.


def to_json(self, variables=None):

        variables_to_resolve = []
        if variables:
            for key, value in variables.items():
                variables_to_resolve.append(Variable(key, value))
        for k in self.get_parameter_definitions():
            if not variables or k not in variables:

                variables_to_resolve.append(Variable(k, 'unused_value'))
        self.resolve_variables(variables_to_resolve)

        return self.render_template()[1]

Render the blueprint and return the template in json form.

Args:
variables (dict):
Optional dictionary providing/overriding variable values.

Returns:
str: the rendered CFN JSON template


def post_process_image_text_to_text(self, generated_outputs, skip_special_tokens=True, **kwargs):
    beginning_of_answer = self.tokenizer.convert_tokens_to_ids(BEGINNING_OF_ANSWER_STRING)
    unpadded_output_sequences = [seq[(seq == beginning_of_answer).nonzero(as_tuple=True)[0] + 1:] for seq in generated_outputs]
    max_len = max((len(seq) for seq in unpadded_output_sequences))
    padded_output_sequences = torch.full((len(unpadded_output_sequences), max_len), self.pad_token_id)
    for i, seq in enumerate(unpadded_output_sequences):
        padded_output_sequences[i, :len(seq)] = torch.tensor(seq)
    return self.batch_decode(padded_output_sequences, skip_special_tokens=skip_special_tokens, **kwargs)

Post-processes the output of `FuyuForConditionalGeneration` to only return the text output.

Args:
generated_outputs (`torch.Tensor` or `np.ndarray`):
The output of the model. The output is expected to be a tensor of shape `(batch_size, sequence_length)`
containing the token ids of the generated sequences.
skip_special_tokens (`bool`, *optional*, defaults to `True`):
Whether or not to remove special tokens in the output. Argument passed to the tokenizer's `batch_decode` method.
**kwargs:
Additional arguments to be passed to the tokenizer's `batch_decode method`.

Returns:
`List[str]`: The decoded text output.


def strip_number(self):
    if (self.type != EventType.TABLET_PAD_STRIP):
        raise AttributeError(_wrong_prop.format(self.type))
    return self._libinput.libinput_event_tablet_pad_get_strip_number(self._handle)

The number of the strip that has changed state,
with 0 being the first strip.

On tablets with only one strip, this method always returns 0.

For events not of type
:attr:`~libinput.constant.EventType.TABLET_PAD_STRIP`, this property
raises :exc:`AttributeError`.

Returns:
int: The index of the strip that changed state.
Raises:
AttributeError


def get_dict(self, only_attributes=None, exclude_attributes=None, df_format=False):
    to_exclude = ['coach_bsites', 'coach_ec', 'coach_go_mf', 'coach_go_bp', 'coach_go_cc']
    if (not exclude_attributes):
        excluder = to_exclude
    else:
        excluder = ssbio.utils.force_list(exclude_attributes)
        excluder.extend(to_exclude)
    summary_dict = StructProp.get_dict(self, only_attributes=only_attributes, exclude_attributes=excluder, df_format=df_format)
    if self.coach_bsites:
        tmp = {('top_bsite_' + k): v for (k, v) in self.coach_bsites[0].items()}
        summary_dict.update(tmp)
    if self.coach_ec:
        tmp = {('top_ec_' + k): v for (k, v) in self.coach_ec[0].items()}
        summary_dict.update(tmp)
    if self.coach_go_mf:
        tmp = {('top_go_mf_' + k): v for (k, v) in self.coach_go_mf[0].items()}
        summary_dict.update(tmp)
    if self.coach_go_bp:
        tmp = {('top_go_bp_' + k): v for (k, v) in self.coach_go_bp[0].items()}
        summary_dict.update(tmp)
    if self.coach_go_cc:
        tmp = {('top_go_cc_' + k): v for (k, v) in self.coach_go_cc[0].items()}
        summary_dict.update(tmp)
    return summary_dict

Summarize the I-TASSER run in a dictionary containing modeling results and top predictions from COACH

Args:
only_attributes (str, list): Attributes that should be returned. If not provided, all are returned.
exclude_attributes (str, list): Attributes that should be excluded.
df_format (bool): If dictionary values should be formatted for a dataframe
(everything possible is transformed into strings, int, or float -
if something can't be transformed it is excluded)

Returns:
dict: Dictionary of attributes


Called at the end of evaluation or validation.

Subclasses should override for any actions to run.

Args:
logs: Dict. Currently the output of the last call to
`on_test_batch_end()` is passed to this argument for this method
but that may change in the future.


def _matmul_3d_with_map_fn(a, b, **kwargs):
    if isinstance(b, ragged_tensor.RaggedTensor) and (b.ragged_rank == 2 or kwargs.get('transpose_b') or kwargs.get('adjoint_b')):
        output_ragged_rank = 2
    else:
        output_ragged_rank = 1

    def single_batch_matmul(x):
        out = _matmul_2d(x[0], x[1], **kwargs)
        if output_ragged_rank == 2:
            out = ragged_tensor.RaggedTensor.from_tensor(out)
        return out
    fn_out_shape = None
    row_splits_dtype = a.row_splits.dtype if isinstance(a, ragged_tensor.RaggedTensor) else b.row_splits.dtype
    output_type = kwargs['output_type']
    if output_type is None:
        output_type = a.dtype
    spec = ragged_tensor.RaggedTensorSpec(shape=fn_out_shape, dtype=output_type, ragged_rank=output_ragged_rank - 1, row_splits_dtype=row_splits_dtype)
    result = map_fn.map_fn(single_batch_matmul, elems=(a, b), fn_output_signature=spec)
    if kwargs.get('transpose_a') or kwargs.get('adjoint_a'):
        result._set_shape(a.shape[:-2] + a.shape[-1:] + [None])
    else:
        result._set_shape(a.shape[:-2] + a.shape[-2:-1] + [None])
    if kwargs.get('transpose_b') or kwargs.get('adjoint_b'):
        result._set_shape(b.shape[:-2] + [None] + b.shape[-2:-1])
    else:
        result._set_shape(b.shape[:-2] + [None] + b.shape[-1:])
    return result

Multiplies batches of 2D matrices using map_fn.

`output[n, i, k]` = sum_j (a[n, i, j] * b[n, j, k])` (for all `n`, `i`, `k`).

Requires that `a[n, i].nrows()` == `b[n].nrows()` (for all `n` and `i`).

Args:
a: A 3D Tensor or RaggedTensor with `shape=[B, I, J]`, where dimensions `I`
and `J` may be ragged.
b: A 3D Tensor or RaggedTensor with `shape=[B, J, K]`, where dimensions `J`
and `K` may be ragged.
**kwargs: Additional arguments for `tf.matmul` (e.g. transpose_a).

Returns:
A 3D RaggedTensor with `shape=[B, (I), (K)]`.


def _sim_timestamps(self, max_rate, bg_rate, emission, i_start, rs, ip_start=0, scale=10, sort=True):
    counts_chunk = sim_timetrace_bg(emission, max_rate, bg_rate, self.t_step, rs=rs)
    nrows = emission.shape[0]
    if (bg_rate is not None):
        nrows += 1
    assert (counts_chunk.shape == (nrows, emission.shape[1]))
    max_counts = counts_chunk.max()
    if (max_counts == 0):
        return (np.array([], dtype=np.int64), np.array([], dtype=np.int64))
    time_start = (i_start * scale)
    time_stop = (time_start + (counts_chunk.shape[1] * scale))
    ts_range = np.arange(time_start, time_stop, scale, dtype='int64')
    times_chunk_p = []
    par_index_chunk_p = []
    for (ip, counts_chunk_ip) in enumerate(counts_chunk):
        times_c_ip = []
        for v in range(1, (max_counts + 1)):
            times_c_ip.append(ts_range[(counts_chunk_ip >= v)])
        t = np.hstack(times_c_ip)
        times_chunk_p.append(t)
        par_index_chunk_p.append(np.full(t.size, (ip + ip_start), dtype='u1'))
    times_chunk = np.hstack(times_chunk_p)
    par_index_chunk = np.hstack(par_index_chunk_p)
    if sort:
        index_sort = times_chunk.argsort(kind='mergesort')
        times_chunk = times_chunk[index_sort]
        par_index_chunk = par_index_chunk[index_sort]
    return (times_chunk, par_index_chunk)

Simulate timestamps from emission trajectories.

Uses attributes: `.t_step`.

Returns:
A tuple of two arrays: timestamps and particles.


async def get_person(self, id_):

        data = await self._get_person_json(
            id_,
            OrderedDict(append_to_response='movie_credits')
        )
        return Person.from_json(data, self.config['data'].get('images'))

Retrieve person data by ID.

Arguments:
id_ (:py:class:`int`): The person's TMDb ID.

Returns:
:py:class:`~.Person`: The requested person.


def _add_deprecation_notice_to_docstring(docstring, message):
    if docstring:
        return f'{docstring}\n\n.. deprecated:: {message}'
    else:
        return f'.. deprecated:: {message}'

Adds a deprecation notice to a docstring.

Args:
docstring: The original docstring (can be None or empty).
message: The deprecation message to add.

Returns:
The modified docstring.


def convert_code(in_file, out_file, in_alg='taudem', out_alg='arcgis', datatype=None):

        FileClass.check_file_exists(in_file)
        in_alg = in_alg.lower()
        out_alg = out_alg.lower()
        if in_alg not in FlowModelConst.d8_dirs or out_alg not in FlowModelConst.d8_dirs:
            raise RuntimeError('The input algorithm name should one of %s' %
                               ', '.join(list(FlowModelConst.d8_dirs.keys())))
        convert_dict = dict()
        in_code = FlowModelConst.d8_dirs.get(in_alg)
        out_code = FlowModelConst.d8_dirs.get(out_alg)
        assert len(in_code) == len(out_code)
        for i, tmp_in_code in enumerate(in_code):
            convert_dict[tmp_in_code] = out_code[i]
        if datatype is not None and datatype in GDALDataType:
            RasterUtilClass.raster_reclassify(in_file, convert_dict, out_file, datatype)
        else:
            RasterUtilClass.raster_reclassify(in_file, convert_dict, out_file)

convert D8 flow direction code from one algorithm to another.
Args:
in_file: input raster file path
out_file: output raster file path
in_alg: available algorithms are in FlowModelConst.d8_dirs. "taudem" is the default
out_alg: same as in_alg. "arcgis" is the default
datatype: default is None and use the datatype of the in_file


def parameterized_send(self, request, parameter_list):
    response_queues = OrderedDict()
    for parameter in parameter_list:
        response_queues[parameter] = self.send((request % parameter))
    return response_queues

Send batched requests for a list of parameters

Args:
request (str): Request to send, like "%s.*?\n"
parameter_list (list): parameters to format with, like
["TTLIN", "TTLOUT"]

Returns:
dict: {parameter: response_queue}


def ParseFromHumanReadable(self, string):
    if (not string):
        return None
    match = self.REGEX.match(string.strip().lower())
    if (not match):
        raise DecodeError(('Unknown specification for ByteSize %s' % string))
    multiplier = self.DIVIDERS.get(match.group(2))
    if (not multiplier):
        raise DecodeError(('Invalid multiplier %s' % match.group(2)))
    value = match.group(1)
    if ('.' in value):
        value = float(value)
    else:
        value = int(value)
    self._value = int((value * multiplier))

Parse a human readable string of a byte string.

Args:
string: The string to parse.

Raises:
DecodeError: If the string can not be parsed.


def load_from_file(self, yamlfile, _override=True, _allow_undeclared=False):

    self._logger.info('Loading configuration from file: %s', yamlfile)

    try:
      parsed_yaml = self._modules['yaml'].safe_load(yamlfile.read())
    except self._modules['yaml'].YAMLError:
      self._logger.exception('Problem parsing YAML')
      raise self.ConfigurationInvalidError(
          'Failed to load from %s as YAML' % yamlfile)

    if not isinstance(parsed_yaml, dict):

      raise self.ConfigurationInvalidError(
          'YAML parsed, but wrong type, should be dict', parsed_yaml)

    self._logger.debug('Configuration loaded from file: %s', parsed_yaml)
    self.load_from_dict(
        parsed_yaml, _override=_override, _allow_undeclared=_allow_undeclared)

Loads the configuration from a file.

Parsed contents must be a single dict mapping config key to value.

Args:
yamlfile: The opened file object to load configuration from.
See load_from_dict() for other args' descriptions.

Raises:
ConfigurationInvalidError: If configuration file can't be read, or can't
be parsed as either YAML (or JSON, which is a subset of YAML).


def merge_translations(localization_bundle_path):
    logging.info('Merging translations')
    for lang_dir in os.listdir(localization_bundle_path):
        if (lang_dir == DEFAULT_LANGUAGE_DIRECTORY_NAME):
            continue
        for translated_path in glob.glob(os.path.join(localization_bundle_path, lang_dir, ('*' + TRANSLATED_SUFFIX))):
            strings_path = translated_path[:((- 1) * len(TRANSLATED_SUFFIX))]
            localizable_path = os.path.join(localization_bundle_path, DEFAULT_LANGUAGE_DIRECTORY_NAME, os.path.basename(strings_path))
            localization_merge_back(localizable_path, strings_path, translated_path, strings_path)

Merges the new translation with the old one.

The translated files are saved as '.translated' file, and are merged with old translated file.

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


def get_build_tool_version(self):
    with open(('%s/%s/build.gradle' % (self.path, self.src_folder))) as f:
        for line in f.readlines():
            if ('buildToolsVersion' in line):
                matches = re.findall('buildToolsVersion \\"(.+?)\\"', line)
                if (len(matches) == 1):
                    return matches[0]
    return config.build_tool_version

Gets the build tool version to be used by zipalign from build.gradle file.

Returns:
A string containing the build tool version, default is 23.0.2.


def oem(self):

        buf = (ctypes.c_char * self.MAX_BUF_SIZE)()
        res = self._dll.JLINKARM_GetOEMString(ctypes.byref(buf))
        if res != 0:
            raise errors.JLinkException('Failed to grab OEM string.')

        oem = ctypes.string_at(buf).decode()
        if len(oem) == 0:

            return None

        return oem

Retrieves and returns the OEM string of the connected J-Link.

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

Returns:
The string of the OEM.  If this is an original SEGGER product, then
``None`` is returned instead.

Raises:
JLinkException: on hardware error.


def grid_destroy_from_name(job_name):

    jobs = grid_reload_from_name(job_name)
    for job in jobs:
        job.delete()
        logger.info("Killing the job (%s, %s)" % (job.site, job.uid))

Destroy all the jobs with a given name.

Args:
job_name (str): the job name


def _get_endpoint(self, sub_domain):

        storage_parameters = self._storage_parameters or dict()
        account_name = storage_parameters.get('account_name')

        if not account_name:
            raise ValueError('"account_name" is required for Azure storage')

        suffix = storage_parameters.get(
            'endpoint_suffix', 'core.windows.net')

        self._endpoint = 'http%s:
            '' if self._unsecure else 's', account_name, sub_domain, suffix)

        return account_name, suffix.replace('.', r'\.')

Get endpoint information from storage parameters.

Update system with endpoint information and return information required
to define roots.

Args:
self (pycosio._core.io_system.SystemBase subclass): System.
sub_domain (str): Azure storage sub-domain.

Returns:
tuple of str: account_name, endpoint_suffix


def query_api_version(self):
    version_resp = self._session.get('/api/version', logon_required=False)
    self._api_version = version_resp
    return self._api_version

The Query API Version operation returns information about
the level of Web Services API supported by the HMC.

This operation does not require authentication.

Returns:

:term:`json object`:
A JSON object with members ``api-major-version``,
``api-minor-version``, ``hmc-version`` and ``hmc-name``.
For details about these properties, see section
'Response body contents' in section 'Query API Version' in the
:term:`HMC API` book.

Raises:

:exc:`~zhmcclient.HTTPError`
:exc:`~zhmcclient.ParseError`
:exc:`~zhmcclient.ConnectionError`


def GetFileSystemTypeIndicators(cls, path_spec, resolver_context=None):
    if ((cls._file_system_remainder_list is None) or (cls._file_system_store is None)):
        (specification_store, remainder_list) = cls._GetSpecificationStore(definitions.FORMAT_CATEGORY_FILE_SYSTEM)
        cls._file_system_remainder_list = remainder_list
        cls._file_system_store = specification_store
    if (cls._file_system_scanner is None):
        cls._file_system_scanner = cls._GetSignatureScanner(cls._file_system_store)
    return cls._GetTypeIndicators(cls._file_system_scanner, cls._file_system_store, cls._file_system_remainder_list, path_spec, resolver_context=resolver_context)

Determines if a file contains a supported file system types.

Args:
path_spec (PathSpec): path specification.
resolver_context (Optional[Context]): resolver context, where None
represents the built-in context which is not multi process safe.

Returns:
list[str]: supported format type indicators.


def Dump(obj,
         sort_keys = False,
         encoder = None):

  text = json.dumps(
      obj,
      indent=2,
      sort_keys=sort_keys,
      ensure_ascii=False,
      cls=encoder,
      separators=_SEPARATORS)

  if compatibility.PY2 and isinstance(text, bytes):
    text = text.decode("utf-8")

  return text

Stringifies a Python object into its JSON representation.

Args:
obj: A Python object to convert to JSON.
sort_keys: If True, output dictionaries keys in sorted (ascending) order.
encoder: An (optional) encoder class to use.

Returns:
A JSON representation of the given object.


def _segment_reduce(values, index, segment_reduce_fn, name):
    flat_index = flatten(index)
    vector_shape = values.size()[len(index.indices.size()):]
    flattened_shape = torch.cat([torch.as_tensor([-1], dtype=torch.long), torch.as_tensor(vector_shape, dtype=torch.long)], dim=0)
    flat_values = values.reshape(flattened_shape.tolist())
    out = torch.zeros(int(flat_index.num_segments), dtype=torch.float, device=flat_values.device)
    segment_means = out.scatter_reduce(dim=0, index=flat_index.indices.long(), src=flat_values.float(), reduce=segment_reduce_fn, include_self=False)
    device = index.num_segments.device
    new_shape = torch.cat([torch.as_tensor(index.batch_shape(), dtype=torch.long, device=device), torch.as_tensor([index.num_segments], dtype=torch.long, device=device), torch.as_tensor(vector_shape, dtype=torch.long, device=device)], dim=0)
    output_values = segment_means.clone().view(new_shape.tolist()).to(values.dtype)
    output_index = range_index_map(index.batch_shape(), index.num_segments)
    return (output_values, output_index)

Applies a segment reduction segment-wise.

Args:
values (`torch.Tensor`):
Tensor with segment values.
index (`IndexMap`):
IndexMap.
segment_reduce_fn (`str`):
Name for the reduce operation. One of "sum", "mean", "max" or "min".
name (`str`):
Name for the operation. Currently not used

Returns:
(`IndexMap`): IndexMap of shape batch_shape with elements equal to range(num_segments).


def __init__(self, index, port = 8081):

        self.index = index
        self.server = None
        self.port = port if port else find_free_port()
        self.settings = index.columns
        self.docs = index.docs
        self._create_settings()
        self.html_path = get_cur_path()+'/data/table/'

        self.cleanup_flag = False

Table Constructor

todo::make sure this is memory efficient

Args:
Index (Index):  An Index object with a valid .query method
and a .columns attribute.

Returns:
A table object

Usage example

>>> Table(ind)


def get_by_provider_display_name(self, provider_display_name):

        san_managers = self._client.get_all()
        result = [x for x in san_managers if x['providerDisplayName'] == provider_display_name]
        return result[0] if result else None

Gets a SAN Manager by provider display name.

Args:
provider_display_name: Name of the Provider Display Name

Returns:
dict: SAN Manager.


def __init__(self, config: JetMoeConfig, layer_idx: Optional[int]=None):
    super().__init__()
    self.config = config
    self.layer_idx = layer_idx
    self.is_causal = True
    if layer_idx is None:
        logger.warning_once(f'Instantiating {self.__class__.__name__} without passing a `layer_idx` is not recommended and will lead to errors during the forward call if caching is used. Please make sure to provide a `layer_idx` when creating this class.')
    self.top_k = config.num_experts_per_tok
    self.attention_dropout = config.attention_dropout
    self.kv_projection_size = config.kv_channels * config.num_key_value_heads
    self.num_key_value_heads = config.num_key_value_heads
    self.num_heads = config.num_attention_heads
    self.head_dim = config.kv_channels
    self.experts = JetMoeMoA(config)
    self.kv_proj = torch.nn.Linear(config.hidden_size, self.kv_projection_size * 2, bias=False)
    self.rotary_emb = JetMoeRotaryEmbedding(config)

Initialize the JetMoeAttention module.

Args:
config:
Configuration object with model hyperparameters.
layer_idx:
Index of the layer in the model.


def scale_geom_opt_threshold(self, gradient=0.1, displacement=0.1, energy=0.1):
    if ((gradient < (1.0 / (300 - 1))) or (displacement < (1.0 / (1200 - 1))) or (energy < (1.0 / (100 - 1)))):
        raise ValueError('The geometry optimization convergence criteria is too tight')
    self.params['rem']['geom_opt_tol_gradient'] = int((gradient * 300))
    self.params['rem']['geom_opt_tol_displacement'] = int((displacement * 1200))
    self.params['rem']['geom_opt_tol_energy'] = int((energy * 100))

Adjust the convergence criteria of geometry optimization.

Args:
gradient: the scale factor for gradient criteria. If less than
1.0, you are tightening the threshold. The base value is
300 × 10E−6
displacement: the scale factor for atomic displacement. If less
then 1.0, you are tightening the threshold. The base value is
1200 × 10E−6
energy: the scale factor for energy change between successive
iterations. If less than 1.0, you are tightening the
threshold. The base value is 100 × 10E−8.


def _verify_time_range(payload_dict):
    now = int(time.time())
    issued_at = payload_dict.get('iat')
    if (issued_at is None):
        raise AppIdentityError('No iat field in token: {0}'.format(payload_dict))
    expiration = payload_dict.get('exp')
    if (expiration is None):
        raise AppIdentityError('No exp field in token: {0}'.format(payload_dict))
    if (expiration >= (now + MAX_TOKEN_LIFETIME_SECS)):
        raise AppIdentityError('exp field too far in future: {0}'.format(payload_dict))
    earliest = (issued_at - CLOCK_SKEW_SECS)
    if (now < earliest):
        raise AppIdentityError('Token used too early, {0} < {1}: {2}'.format(now, earliest, payload_dict))
    latest = (expiration + CLOCK_SKEW_SECS)
    if (now > latest):
        raise AppIdentityError('Token used too late, {0} > {1}: {2}'.format(now, latest, payload_dict))

Verifies the issued at and expiration from a JWT payload.

Makes sure the current time (in UTC) falls between the issued at and
expiration for the JWT (with some skew allowed for via
``CLOCK_SKEW_SECS``).

Args:
payload_dict: dict, A dictionary containing a JWT payload.

Raises:
AppIdentityError: If there is no ``'iat'`` field in the payload
dictionary.
AppIdentityError: If there is no ``'exp'`` field in the payload
dictionary.
AppIdentityError: If the JWT expiration is too far in the future (i.e.
if the expiration would imply a token lifetime
longer than what is allowed.)
AppIdentityError: If the token appears to have been issued in the
future (up to clock skew).
AppIdentityError: If the token appears to have expired in the past
(up to clock skew).


def _AddFileDescriptor(self, file_desc):

    if not isinstance(file_desc, descriptor.FileDescriptor):
      raise TypeError('Expected instance of descriptor.FileDescriptor.')
    self._file_descriptors[file_desc.name] = file_desc

Adds a FileDescriptor to the pool, non-recursively.

If the FileDescriptor contains messages or enums, the caller must explicitly
register them.

Args:
file_desc: A FileDescriptor.


def display(port=None, height=None):
    _display(port=port, height=height, print_message=True, display_handle=None)

Display a TensorBoard instance already running on this machine.

Args:
port: The port on which the TensorBoard server is listening, as an
`int`, or `None` to automatically select the most recently
launched TensorBoard.
height: The height of the frame into which to render the TensorBoard
UI, as an `int` number of pixels, or `None` to use a default value
(currently 800).


def get_vulnerability_chains(current_node, sink, def_use, chain=[]):
    for use in def_use[current_node]:
        if (use == sink):
            (yield chain)
        else:
            vuln_chain = list(chain)
            vuln_chain.append(use)
            (yield from get_vulnerability_chains(use, sink, def_use, vuln_chain))

Traverses the def-use graph to find all paths from source to sink that cause a vulnerability.

Args:
current_node()
sink()
def_use(dict):
chain(list(Node)): A path of nodes between source and sink.


def ParseRecord(self, parser_mediator, key, structure):

    if key not in ('header', 'header_signature', 'logline'):
      raise errors.ParseError(
          'Unable to parse record, unknown structure: {0:s}'.format(key))

    if key == 'logline':
      self._ParseLogLine(parser_mediator, structure)

    elif key == 'header':
      self._ParseHeader(parser_mediator, structure)

    elif key == 'header_signature':

      logger.warning('Unknown locale header.')
      self._xchat_year = 0

Parses a log record structure and produces events.

Args:
parser_mediator (ParserMediator): mediates interactions between parsers
and other components, such as storage and dfvfs.
key (str): identifier of the structure of tokens.
structure (pyparsing.ParseResults): structure of tokens derived from
a line of a text file.

Raises:
ParseError: when the structure type is unknown.


def resize_bytes(fobj, old_size, new_size, offset):

    if new_size < old_size:
        delete_size = old_size - new_size
        delete_at = offset + new_size
        delete_bytes(fobj, delete_size, delete_at)
    elif new_size > old_size:
        insert_size = new_size - old_size
        insert_at = offset + old_size
        insert_bytes(fobj, insert_size, insert_at)

Resize an area in a file adding and deleting at the end of it.
Does nothing if no resizing is needed.

Args:
fobj (fileobj)
old_size (int): The area starting at offset
new_size (int): The new size of the area
offset (int): The start of the area
Raises:
IOError


def derive_value(self, value):

        return IonEvent(
            self.event_type,
            self.ion_type,
            value,
            self.field_name,
            self.annotations,
            self.depth
        )

Derives a new event from this one setting the ``value`` attribute.

Args:
value: (any):
The value associated with the derived event.

Returns:
IonEvent: The newly generated non-thunk event.


def for_default_graph(*args, **kwargs):
    graph = tf.get_default_graph()
    collection = graph.get_collection(_BOOKKEEPER)
    if collection:
        if (args or kwargs):
            raise ValueError(('Requesting construction of a BookKeeper that already exists: %s %s' % (args, kwargs)))
        return collection[0]
    else:
        books = BOOKKEEPER_FACTORY(*args, g=graph, **kwargs)
        graph.add_to_collection(_BOOKKEEPER, books)
        return books

Creates a bookkeeper for the default graph.

Args:
*args: Arguments to pass into Bookkeeper's constructor.
**kwargs: Arguments to pass into Bookkeeper's constructor.
Returns:
A new Bookkeeper.
Raises:
ValueError: If args or kwargs are provided and the Bookkeeper already
exists.


def restart(self, container, timeout=10):

        params = {'t': timeout}
        url = self._url("/containers/{0}/restart", container)
        conn_timeout = self.timeout
        if conn_timeout is not None:
            conn_timeout += timeout
        res = self._post(url, params=params, timeout=conn_timeout)
        self._raise_for_status(res)

Restart a container. Similar to the ``docker restart`` command.

Args:
container (str or dict): The container to restart. If a dict, the
``Id`` key is used.
timeout (int): Number of seconds to try to stop for before killing
the container. Once killed it will then be restarted. Default
is 10 seconds.

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


def get_enabled_features(self, user_id, attributes=None):

    enabled_features = []
    if not self.is_valid:
      self.logger.error(enums.Errors.INVALID_DATAFILE.format('get_enabled_features'))
      return enabled_features

    if not isinstance(user_id, string_types):
      self.logger.error(enums.Errors.INVALID_INPUT_ERROR.format('user_id'))
      return enabled_features

    if not self._validate_user_inputs(attributes):
      return enabled_features

    for feature in self.config.feature_key_map.values():
      if self.is_feature_enabled(feature.key, user_id, attributes):
        enabled_features.append(feature.key)

    return enabled_features

Returns the list of features that are enabled for the user.

Args:
user_id: ID for user.
attributes: Dict representing user attributes.

Returns:
A list of the keys of the features that are enabled for the user.


def nack(self, items):
    self.modify_ack_deadline([requests.ModAckRequest(ack_id=item.ack_id, seconds=0) for item in items])
    self.drop([requests.DropRequest(*item) for item in items])

Explicitly deny receipt of messages.

Args:
items(Sequence[NackRequest]): The items to deny.


def _validate_observation_data(kernel, observation_index_points, observations):
    ndims = kernel.feature_ndims
    if (tensorshape_util.is_fully_defined(observation_index_points.shape[:(- ndims)]) and tensorshape_util.is_fully_defined(observations.shape)):
        index_point_count = observation_index_points.shape[:(- ndims)]
        observation_count = observations.shape
        try:
            tf.broadcast_static_shape(index_point_count, observation_count)
        except ValueError:
            raise ValueError('Observation index point and observation counts are not broadcastable: {} and {}, respectively.'.format(index_point_count, observation_count))

Ensure that observation data and locations have consistent shapes.

This basically means that the batch shapes are broadcastable. We can only
ensure this when those shapes are fully statically defined.

Args:
kernel: The GP kernel.
observation_index_points: the observation data locations in the index set.
observations: the observation data.

Raises:
ValueError: if the observations' batch shapes are not broadcastable.


def _ParseCommentRecord(self, structure):

    comment = structure[1]
    if comment.startswith('Version'):
      _, _, self._version = comment.partition(':')
    elif comment.startswith('Software'):
      _, _, self._software = comment.partition(':')
    elif comment.startswith('Time'):
      _, _, time_format = comment.partition(':')
      if 'local' in time_format.lower():
        self._use_local_timezone = True

Parse a comment and store appropriate attributes.

Args:
structure (pyparsing.ParseResults): parsed log line.


def pre_release_work(patch: bool=False):
    default_version = get_version()
    if patch and default_version.is_devrelease:
        raise ValueError("Can't create a patch version from the dev branch, checkout a released version!")
    if default_version.is_devrelease:
        default_version = default_version.base_version
    elif patch:
        default_version = f'{default_version.major}.{default_version.minor}.{default_version.micro + 1}'
    else:
        default_version = f'{default_version.major}.{default_version.minor + 1}.0'
    version = input(f'Which version are you releasing? [{default_version}]')
    if len(version) == 0:
        version = default_version
    print(f'Updating version to {version}.')
    global_version_update(version, patch=patch)
    print('Deleting conversion scripts.')
    remove_conversion_scripts()

Do all the necessary pre-release steps:
- figure out the next minor release version and ask confirmation
- update the version everywhere
- clean-up the model list in the main README

Args:
patch (`bool`, *optional*, defaults to `False`): Whether or not this is a patch release.


def _process_new(self, feed_item):
    return {'assetIdentifier': {'name': feed_item.get(FieldMap.CREATIVE_ASSET_FILE_NAME, None), 'type': feed_item.get(FieldMap.CREATIVE_TYPE, None)}}

Creates a new creative asset DCM object from a feed item representing a creative asset from the Bulkdozer feed.

This function simply creates the object to be inserted later by the BaseDAO
object.

Args:
feed_item: Feed item representing the creative asset from the Bulkdozer
feed.

Returns:
A creative asset object ready to be inserted in DCM through the API.


def matvec(self, x, adjoint=False, name='matvec'):
    with self._name_scope(name):
        block_dimensions = self._block_range_dimensions() if adjoint else self._block_domain_dimensions()
        if linear_operator_util.arg_is_blockwise(block_dimensions, x, -1):
            for i, block in enumerate(x):
                if not isinstance(block, linear_operator.LinearOperator):
                    block = tensor_conversion.convert_to_tensor_v2_with_dispatch(block)
                    self._check_input_dtype(block)
                    block_dimensions[i].assert_is_compatible_with(block.shape[-1])
                    x[i] = block
            x_mat = [block[..., array_ops.newaxis] for block in x]
            y_mat = self.matmul(x_mat, adjoint=adjoint)
            return [array_ops.squeeze(y, axis=-1) for y in y_mat]
        x = tensor_conversion.convert_to_tensor_v2_with_dispatch(x, name='x')
        self._check_input_dtype(x)
        op_dimension = self.range_dimension if adjoint else self.domain_dimension
        op_dimension.assert_is_compatible_with(x.shape[-1])
        x_mat = x[..., array_ops.newaxis]
        y_mat = self.matmul(x_mat, adjoint=adjoint)
        return array_ops.squeeze(y_mat, axis=-1)

Transform [batch] vector `x` with left multiplication:  `x --> Ax`.

```python
# Make an operator acting like batch matrix A.  Assume A.shape = [..., M, N]
operator = LinearOperator(...)

X = ... # shape [..., N], batch vector

Y = operator.matvec(X)
Y.shape
==> [..., M]

Y[..., :] = sum_j A[..., :, j] X[..., j]
```

Args:
x: `Tensor` with compatible shape and same `dtype` as `self`, or an
iterable of `Tensor`s. `Tensor`s are treated a [batch] vectors, meaning
for every set of leading dimensions, the last dimension defines a
vector.
See class docstring for definition of compatibility.
adjoint: Python `bool`.  If `True`, left multiply by the adjoint: `A^H x`.
name:  A name for this `Op`.

Returns:
A `Tensor` with shape `[..., M]` and same `dtype` as `self`.


def inference(self, observed_arr):

        self.__pred_arr = self.__lstm_model.inference(observed_arr)
        return self.__pred_arr

Draws samples from the `true` distribution.

Args:
observed_arr:     `np.ndarray` of observed data points.

Returns:
`np.ndarray` of inferenced.


def sort_ordered_objects(items, getter=(lambda x: x)):
    return sorted(items, key=(lambda x: getattr(getter(x), OrderedBase.CREATION_COUNTER_FIELD, (- 1))))

Sort an iterable of OrderedBase instances.

Args:
items (iterable): the objects to sort
getter (callable or None): a function to extract the OrderedBase instance from an object.

Examples:
>>> sort_ordered_objects([x, y, z])
>>> sort_ordered_objects(v.items(), getter=lambda e: e[1])


def get_min_max_value(statistics: calib_stats_pb2.CalibrationStatistics, calib_opts: stablehlo_quant_config_pb2.CalibrationOptions) -> tuple[float, float]:
    calib_method = calib_opts.calibration_method
    if calib_method not in _REGISTRY:
        raise ValueError(f'Unsupported calibration method: {calib_method}')
    calibration_algorithm = _REGISTRY[calib_method](statistics, calib_opts)
    return calibration_algorithm.get_min_max_value()

Calculates min and max from statistics using calibration options.

Args:
statistics: Collected calibration statistics.
calib_opts: Calibration options used for calculating min and max.

Returns:
(min_value, max_value): Min and max calculated using calib_opts.

Raises:
ValueError: Unsupported calibration method is given.


def get_service_state_object_id(subsystem: str, name: str,
                                    version: str) -> str:

        return '{}:{}:{}'.format(subsystem, name, version)

Return service state data object key.

Args:
subsystem (str): Subsystem the service belongs to
name (str): Name of the Service
version (str): Version of the Service

Returns:
str, Key used to store the service state data object


def _batch_accumulator(cls, primals, tangents):
    acc = super(ForwardAccumulator, cls).__new__(cls, primals, tangents)
    acc._recording = False
    acc._accumulator = pywrap_tfe.TFE_Py_ForwardAccumulatorNew(True)
    primal_ids = set()
    for primal, tangent in zip(nest.flatten(primals), nest.flatten(tangents)):
        tangent.shape.assert_is_compatible_with(tensor_shape.TensorShape([None]) + primal.shape)
        if id(primal) in primal_ids:
            raise ValueError('Tensor {} was specified as a primal multiple times. This may indicate an error. If it was intended, please sum the corresponding tangents.')
        primal_ids.add(id(primal))
    acc._watch(primals, tangents)
    return acc

Factory constructor to test accumulator on batches of tangents.

Args:
primals: A tensor or nested structure of tensors to watch.
tangents: A tensor or nested structure of tensors, with the same nesting
structure as `primals`, with each element being a vector with compatible
shape `[None] + primal.shape` of the corresponding primal element.

Returns:
A batch accumulator object.


def get_configuration_file(configuration_files: list[str]) -> str:
    configuration_files_map = {}
    for file_name in configuration_files:
        if file_name.startswith('config.') and file_name.endswith('.json') and (file_name != 'config.json'):
            v = file_name.removeprefix('config.').removesuffix('.json')
            configuration_files_map[v] = file_name
    available_versions = sorted(configuration_files_map.keys())
    configuration_file = CONFIG_NAME
    transformers_version = version.parse(__version__)
    for v in available_versions:
        if version.parse(v) <= transformers_version:
            configuration_file = configuration_files_map[v]
        else:
            break
    return configuration_file

Get the configuration file to use for this version of transformers.

Args:
configuration_files (`List[str]`): The list of available configuration files.

Returns:
`str`: The configuration file to use.


class ZoeDepthReassembleStage(nn.Module):

    def __init__(self, config):
        super().__init__()
        self.readout_type = config.readout_type
        self.layers = nn.ModuleList()
        for neck_hidden_size, factor in zip(config.neck_hidden_sizes, config.reassemble_factors):
            self.layers.append(ZoeDepthReassembleLayer(config, channels=neck_hidden_size, factor=factor))
        if config.readout_type == 'project':
            self.readout_projects = nn.ModuleList()
            hidden_size = config.backbone_hidden_size
            for _ in config.neck_hidden_sizes:
                self.readout_projects.append(nn.Sequential(nn.Linear(2 * hidden_size, hidden_size), ACT2FN[config.hidden_act]))

    def forward(self, hidden_states: List[torch.Tensor], patch_height, patch_width) -> List[torch.Tensor]:

        batch_size = hidden_states[0].shape[0]
        hidden_states = torch.cat(hidden_states, dim=0)
        cls_token, hidden_states = (hidden_states[:, 0], hidden_states[:, 1:])
        total_batch_size, sequence_length, num_channels = hidden_states.shape
        hidden_states = hidden_states.reshape(total_batch_size, patch_height, patch_width, num_channels)
        hidden_states = hidden_states.permute(0, 3, 1, 2).contiguous()
        if self.readout_type == 'project':
            hidden_states = hidden_states.flatten(2).permute((0, 2, 1))
            readout = cls_token.unsqueeze(dim=1).expand_as(hidden_states)
            hidden_states = torch.cat((hidden_states, readout), -1)
        elif self.readout_type == 'add':
            hidden_states = hidden_states + cls_token.unsqueeze(-1)
        out = []
        for stage_idx, hidden_state in enumerate(hidden_states.split(batch_size, dim=0)):
            if self.readout_type == 'project':
                hidden_state = self.readout_projects[stage_idx](hidden_state)
            hidden_state = hidden_state.permute(0, 2, 1).reshape(batch_size, -1, patch_height, patch_width)
            hidden_state = self.layers[stage_idx](hidden_state)
            out.append(hidden_state)
        return out

This class reassembles the hidden states of the backbone into image-like feature representations at various
resolutions.

This happens in 3 stages:
1. Map the N + 1 tokens to a set of N tokens, by taking into account the readout ([CLS]) token according to
`config.readout_type`.
2. Project the channel dimension of the hidden states according to `config.neck_hidden_sizes`.
3. Resizing the spatial dimensions (height, width).

Args:
config (`[ZoeDepthConfig]`):
Model configuration class defining the model architecture.


def get(self, uid: int) -> Optional[CachedMessage]:
    return self._cache.get(uid)

Return the given cached message.

Args:
uid: The message UID.


def GetCampaignFeeds(client, feed, placeholder_type):

  campaign_feed_service = client.GetService('CampaignFeedService', 'v201809')

  campaign_feeds = []
  more_pages = True

  selector = {
      'fields': ['CampaignId', 'MatchingFunction', 'PlaceholderTypes'],
      'predicates': [
          {
              'field': 'Status',
              'operator': 'EQUALS',
              'values': ['ENABLED']
          },
          {
              'field': 'FeedId',
              'operator': 'EQUALS',
              'values': [feed['id']]
          },
          {
              'field': 'PlaceholderTypes',
              'operator': 'CONTAINS_ANY',
              'values': [placeholder_type]
          }
      ],
      'paging': {
          'startIndex': 0,
          'numberResults': PAGE_SIZE
      }
  }

  while more_pages:
    page = campaign_feed_service.get(selector)

    if 'entries' in page:
      campaign_feeds.extend(page['entries'])

    selector['paging']['startIndex'] += PAGE_SIZE
    more_pages = selector['paging']['startIndex'] < int(page['totalNumEntries'])

  return campaign_feeds

Get a list of Feed Item Ids used by a campaign via a given Campaign Feed.

Args:
client: an AdWordsClient instance.
feed: a Campaign Feed.
placeholder_type: the Placeholder Type.

Returns:
A list of Feed Item Ids.


def NHWCToNCHW(input_tensor):
    if isinstance(input_tensor, tensor.Tensor):
        return array_ops.transpose(input_tensor, [0, 3, 1, 2])
    else:
        return [input_tensor[0], input_tensor[3], input_tensor[1], input_tensor[2]]

Convert the input from NHWC format to NCHW.

Args:
input_tensor:  a 4-D tensor, or a 4-element array representing the same.

Returns:
the converted tensor or a shape array


def direct_transformers_import(path: str, file='__init__.py') -> ModuleType:
    name = 'transformers'
    location = os.path.join(path, file)
    spec = importlib.util.spec_from_file_location(name, location, submodule_search_locations=[path])
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    module = sys.modules[name]
    return module

Imports transformers directly

Args:
path (`str`): The path to the source file
file (`str`, *optional*): The file to join with the path. Defaults to "__init__.py".

Returns:
`ModuleType`: The resulting imported module


def AddRow(self, values):

    if self._number_of_columns and len(values) != self._number_of_columns:
      raise ValueError('Number of values is out of bounds.')

    self._rows.append(values)

    if not self._number_of_columns:
      self._number_of_columns = len(values)

Adds a row of values.

Args:
values (list[object]): values.

Raises:
ValueError: if the number of values is out of bounds.


def shift(x, offset, dim, wrap, name=None):

  return ShiftOperation(x, offset, dim, wrap, name=name).outputs[0]

Shift operation.

Shift x right by +offset in dimension dim.

Args:
x: a Tensor
offset: an integer. If negative, shift left instead of right.
dim: a Dimension of x
wrap: a boolean - whether to wrap (True) or pad with zeros (False).
name: an optional string

Returns:
a Tensor with the same shape and dtype as x


def go_from(self, vertex):
    if self.vertex_out:
        self.vertex_out.edges_out.remove(self)
    self.vertex_out = vertex
    vertex.edges_out.add(self)

Tell the edge to go out from this vertex.

Args:
vertex (Vertex): vertex to go from.


def get_member_information(self, query_params=None):
    return self.fetch_json(uri_path=self.base_uri, query_params=(query_params or {}))

Get Information for a member. Returns a dictionary of values.

Returns:
dict


def create(self, vrf_name, rd=None):
    commands = [('vrf definition %s' % vrf_name)]
    if rd:
        commands.append(('rd %s' % rd))
    return self.configure(commands)

Creates a new VRF resource

Note: A valid RD has the following format admin_ID:local_assignment.
The admin_ID can be an AS number or globally assigned IPv4 address.
The local_assignment can be an integer between 0-65,535 if the
admin_ID is an IPv4 address and can be between 0-4,294,967,295 if
the admin_ID is an AS number. If the admin_ID is an AS number the
local_assignment could also be in the form of an IPv4 address.

Args:
vrf_name (str): The VRF name to create
rd (str): The value to configure the vrf rd

Returns:
True if create was successful otherwise False


def _compute_causal_mask(self, query, value=None):
    q_seq_length = ops.shape(query)[1]
    v_seq_length = q_seq_length if value is None else ops.shape(value)[1]
    ones_mask = ops.ones((1, q_seq_length, v_seq_length), dtype='int32')
    row_index = ops.cumsum(ones_mask, axis=-2)
    col_index = ops.cumsum(ones_mask, axis=-1)
    return ops.greater_equal(row_index, col_index)

Computes a causal mask (e.g., for masked self-attention layers).

For example, if query and value both contain sequences of length 4,
this function returns a boolean tensor equal to:

```
[[[True,  False, False, False],
[True,  True,  False, False],
[True,  True,  True,  False],
[True,  True,  True,  True]]]
```

Args:
query: query tensor of shape `(B, T, ...)`.
value: value tensor of shape `(B, S, ...)` (optional, defaults to
query).

Returns:
mask: a boolean tensor of shape `(1, T, S)` containing a lower
triangular matrix of shape `(T, S)`.


def compose(*funcs):

    if not funcs:
        return lambda *args: args[0] if args else None

    if len(funcs) == 1:
        return funcs[0]

    last = funcs[-1]
    rest = funcs[0:-1]
    return lambda *args: reduce(lambda ax, func: func(ax),
                                reversed(rest), last(*args))

chained function composition wrapper

creates function f, where f(x) = arg0(arg1(arg2(...argN(x))))

if *funcs is empty, an identity function is returned.

Args:
*funcs: list of functions to chain

Returns:
a new function composed of chained calls to *args


def GetAttributeContainerByIndex(self, index):

    if index < 0:
      raise IndexError(
          'Unsupported negative index value: {0:d}.'.format(index))

    if index < len(self._list):
      return self._list[index]

    return None

Retrieves a specific serialized attribute container from the list.

Args:
index (int): attribute container index.

Returns:
bytes: serialized attribute container data or None if not available.

Raises:
IndexError: if the index is less than zero.


def Parse(self, raw_data):
    self.results = raw_data
    for f in self.filters:
        self.results = f.Parse(self.results)
    return self.results

Take the results and yield results that passed through the filters.

The output of each filter is used as the input for successive filters.

Args:
raw_data: An iterable series of rdf values.

Returns:
A list of rdf values that matched all filters.


def launch_external_file(filename: str, raise_if_fails: bool = False) -> None:

    log.info("Launching external file: {!r}", filename)
    try:
        if sys.platform.startswith('linux'):
            cmdargs = ["xdg-open", filename]

            subprocess.call(cmdargs)
        else:

            os.startfile(filename)
    except Exception as e:
        log.critical("Error launching {!r}: error was {}.\n\n{}",
                     filename, str(e), traceback.format_exc())
        if raise_if_fails:
            raise

Launches a file using the operating system's standard launcher.

Args:
filename: file to launch
raise_if_fails: raise any exceptions from
``subprocess.call(["xdg-open", filename])`` (Linux)
or ``os.startfile(filename)`` (otherwise)? If not, exceptions
are suppressed.


def update_unexpected_keys(self, model, unexpected_keys: List[str], prefix: str) -> List[str]:
    return unexpected_keys

Override this method if you want to adjust the `unexpected_keys`.

Args:
unexpected_keys (`List[str]`, *optional*):
The list of unexpected keys in the checkpoint compared to the state dict of the model


def list_media_endpoint_keys(access_token, subscription_id, rgname, msname):
    endpoint = ''.join([get_rm_endpoint(), '/subscriptions/', subscription_id, '/resourceGroups/', rgname, '/providers/microsoft.media/', '/mediaservices/', msname, '/listKeys?api-version=', MEDIA_API])
    return do_get(endpoint, access_token)

list the media endpoint keys in a media service

Args:
access_token (str): A valid Azure authentication token.
subscription_id (str): Azure subscription id.
rgname (str): Azure resource group name.
msname (str): Media service name.

Returns:
HTTP response. JSON body.


def get_load_balancer(self, id):

        return LoadBalancer.get_object(api_token=self.token, id=id)

Returns a Load Balancer object by its ID.

Args:
id (str): Load Balancer ID


def AdManagerDateTimePacker(cls, value, version):

    if isinstance(value, datetime.datetime):
      if value.tzinfo is None:
        raise googleads.errors.GoogleAdsValueError(
            'Datetime %s is not timezone aware.' % value
        )
      return {
          'date': cls.AdManagerDateTimePacker(value.date(), version),
          'hour': value.hour,
          'minute': value.minute,
          'second': value.second,

          'timeZoneId' if version >= 'v201811' else 'timeZoneID':
              value.tzinfo.zone,
      }
    elif isinstance(value, datetime.date):
      return {'year': value.year, 'month': value.month, 'day': value.day}

Returns dicts formatted for Ad Manager SOAP based on date/datetime.

Args:
value: A date or datetime object to be converted.
version: the version of the current API, e.g. 'v201811'

Returns:
The value object correctly represented for Ad Manager SOAP.


def optimal_partitions(sizes, counts, num_part):
    if (num_part < 2):
        return [(sizes[0], sizes[(- 1)])]
    if (num_part >= len(sizes)):
        partitions = [(x, x) for x in sizes]
        return partitions
    nfps = _compute_nfps_real(counts, sizes)
    (partitions, _, _) = _compute_best_partitions(num_part, sizes, nfps)
    return partitions

Compute the optimal partitions given a distribution of set sizes.

Args:
sizes (numpy.array): The complete domain of set sizes in ascending
order.
counts (numpy.array): The frequencies of all set sizes in the same
order as `sizes`.
num_part (int): The number of partitions to create.

Returns:
list: A list of partitions in the form of `(lower, upper)` tuples,
where `lower` and `upper` are lower and upper bound (inclusive)
set sizes of each partition.


def get(self, block=True, timeout=None):
    if (not block):
        (success, item) = ray.get(self.actor.get.remote())
        if (not success):
            raise Empty
    elif (timeout is None):
        (success, item) = ray.get(self.actor.get.remote())
        while (not success):
            (success, item) = ray.get(self.actor.get.remote())
    elif (timeout < 0):
        raise ValueError("'timeout' must be a non-negative number")
    else:
        endtime = (time.time() + timeout)
        success = False
        while ((not success) and (time.time() < endtime)):
            (success, item) = ray.get(self.actor.get.remote())
        if (not success):
            raise Empty
    return item

Gets an item from the queue.

Uses polling if block=True, so there is no guarantee of order if
multiple consumers get from the same empty queue.

Returns:
The next item in the queue.

Raises:
Empty if the queue is empty and blocking is False.


def _restructure_if_volume_follows_journal(left, right):

    def _get_volume_keyword_op_and_remaining_subtree(right_subtree):
        if (isinstance(right_subtree, NotOp) and isinstance(right_subtree.op, KeywordOp) and (right_subtree.op.left == Keyword('volume'))):
            return (None, None)
        elif (isinstance(right_subtree, AndOp) and isinstance(right_subtree.left, NotOp) and isinstance(right_subtree.left.op, KeywordOp) and (right_subtree.left.op.left == Keyword('volume'))):
            return (None, right_subtree.right)
        elif (isinstance(right_subtree, KeywordOp) and (right_subtree.left == Keyword('volume'))):
            return (right_subtree, None)
        elif (isinstance(right_subtree, AndOp) and (right_subtree.left.left == Keyword('volume'))):
            return (right_subtree.left, right_subtree.right)
    journal_value = left.right.value
    volume_and_remaining_subtree = _get_volume_keyword_op_and_remaining_subtree(right)
    if (not volume_and_remaining_subtree):
        return
    (volume_node, remaining_subtree) = volume_and_remaining_subtree
    if volume_node:
        left.right.value = ','.join([journal_value, volume_node.right.value])
    return (AndOp(left, remaining_subtree) if remaining_subtree else left)

Remove volume node if it follows a journal logically in the tree hierarchy.

Args:
left (ast.ASTElement): The journal KeywordOp node.
right (ast.ASTElement): The rest of the tree to be restructured.

Return:
(ast.ASTElement): The restructured tree, with the volume node removed.

Notes:
This happens to support queries like "journal Phys.Rev. and vol d85". Appends the value of KeywordOp with
Keyword 'volume' and discards 'volume' KeywordOp node from the tree.


def _UpdateStatus(
      self, status, display_name, number_of_consumed_sources, storage_writer,
      force=False):

    current_timestamp = time.time()
    if not force and current_timestamp < (
        self._last_status_update_timestamp + self._STATUS_UPDATE_INTERVAL):
      return

    if status == definitions.STATUS_INDICATOR_IDLE:
      status = definitions.STATUS_INDICATOR_RUNNING

    used_memory = self._process_information.GetUsedMemory() or 0

    self._processing_status.UpdateForemanStatus(
        self._name, status, self._pid, used_memory, display_name,
        number_of_consumed_sources, storage_writer.number_of_event_sources, 0,
        storage_writer.number_of_events, 0, 0, 0, 0, 0,
        storage_writer.number_of_warnings)

    if self._status_update_callback:
      self._status_update_callback(self._processing_status)

    self._last_status_update_timestamp = current_timestamp

Updates the processing status.

Args:
status (str): human readable status of the processing e.g. 'Idle'.
display_name (str): human readable of the file entry currently being
processed.
number_of_consumed_sources (int): number of consumed sources.
storage_writer (StorageWriter): storage writer for a session storage.
force (Optional[bool]): True if the update should be forced ignoring
the last status update time.


def diet_expert(x, hidden_size, params):

    @fn_with_diet_vars(params)
    def diet_expert_internal(x):
        dim = x.get_shape().as_list()[(- 1)]
        h = tf.layers.dense(x, hidden_size, activation=tf.nn.relu, use_bias=False)
        y = tf.layers.dense(h, dim, use_bias=False)
        y *= tf.rsqrt(tf.to_float((dim * hidden_size)))
        return y
    return diet_expert_internal(x)

A two-layer feed-forward network with relu activation on hidden layer.

Uses diet variables.
Recomputes hidden layer on backprop to save activation memory.

Args:
x: a Tensor with shape [batch, io_size]
hidden_size: an integer
params: a diet variable HParams object.

Returns:
a Tensor with shape [batch, io_size]


def unload(self):

        unloaded = False

        if self._lib is not None:
            if self._winlib is not None:

                ctypes.windll.kernel32.FreeLibrary.argtypes = (
                    ctypes.c_void_p,
                )

                ctypes.windll.kernel32.FreeLibrary(self._lib._handle)
                ctypes.windll.kernel32.FreeLibrary(self._winlib._handle)

                self._lib = None
                self._winlib = None

                unloaded = True
            else:

                del self._lib
                self._lib = None
                unloaded = True

        if self._temp is not None:
            os.remove(self._temp.name)
            self._temp = None

        return unloaded

Unloads the library's DLL if it has been loaded.

This additionally cleans up the temporary DLL file that was created
when the library was loaded.

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

Returns:
``True`` if the DLL was unloaded, otherwise ``False``.


def render(self, fname=''):
    import qnet.visualization.circuit_pyx as circuit_visualization
    from tempfile import gettempdir
    from time import time, sleep
    if (not fname):
        tmp_dir = gettempdir()
        fname = os.path.join(tmp_dir, 'tmp_{}.png'.format(hash(time)))
    if circuit_visualization.draw_circuit(self, fname):
        done = False
        for k in range(20):
            if os.path.exists(fname):
                done = True
                break
            else:
                sleep(0.5)
        if done:
            return fname
    raise CannotVisualize()

Render the circuit expression and store the result in a file

Args:
fname (str): Path to an image file to store the result in.

Returns:
str: The path to the image file


def ReleaseObject(self, identifier):

    if identifier not in self._values:
      raise KeyError('Missing cached object for identifier: {0:s}'.format(
          identifier))

    cache_value = self._values[identifier]
    if not cache_value:
      raise RuntimeError('Missing cache value for identifier: {0:s}'.format(
          identifier))

    cache_value.DecrementReferenceCount()

Releases a cached object based on the identifier.

This method decrements the cache value reference count.

Args:
identifier (str): VFS object identifier.

Raises:
KeyError: if the VFS object is not found in the cache.
RuntimeError: if the cache value is missing.


def __init__(self, application, a_service):

        if not isinstance(a_service, sm_messages.Service):
            raise ValueError(u"service is None or not an instance of Service")

        self._application = application
        self._service = a_service

        method_registry, reporting_rules = self._configure()
        self._method_registry = method_registry
        self._reporting_rules = reporting_rules

Initializes a new Middleware instance.

Args:
application: the wrapped wsgi application
a_service (:class:`endpoints_management.gen.servicemanagement_v1_messages.Service`):
a service instance


def follow(id, edges, directed=False, _visited=None):

    if _visited is None:
        _visited = set()
    _visited.add(id)

    for row in edges[edges.ix[:, 0] == id].values:
        if(row[1] not in _visited):
            follow(row[1], edges, directed, _visited)

    if not directed:
        for row in edges[edges.ix[:, 1] == id].values:
            if(row[0] not in _visited):
                follow(row[0], edges, directed, _visited)

    return _visited

Follow the a graph to find the nodes connected to a given node.
Args:
id: the id of the starting node
edges: a pandas DataFrame of edges. Each row is an edge with two columns containing
the ids of the vertices.
directed: If True, edges are directed from first column to second column.
Otherwise edges are undirected.
_visited: used internally for recursion
Returns: the set of all nodes connected to the starting node.


def apply_masks(tensor: torch.Tensor, masks: List[torch.Tensor]) -> torch.Tensor:
    all_masked_tensors = []
    for mask in masks:
        mask = mask.to(tensor.device)
        mask_keep = mask.unsqueeze(-1).repeat(1, 1, tensor.size(-1))
        all_masked_tensors += [torch.gather(tensor, dim=1, index=mask_keep)]
    return torch.cat(all_masked_tensors, dim=0)

Args:
tensor (`torch.Tensor`):
Tensor of shape [batch_size, num_patches, feature_dim]
masks (`List[torch.Tensor]`):
List of tensors of shape [batch_size, num_patches] containing indices of patches to keep


def retrieve_review(self, reviewer, product):
    if (not isinstance(reviewer, self._reviewer_cls)):
        raise TypeError("Type of given reviewer isn't acceptable:", reviewer, ', expected:', self._reviewer_cls)
    elif (not isinstance(product, self._product_cls)):
        raise TypeError("Type of given product isn't acceptable:", product, ', expected:', self._product_cls)
    try:
        return self.graph[reviewer][product]['review']
    except TypeError:
        raise KeyError('{0} does not review {1}.'.format(reviewer, product))

Retrieve review that the given reviewer put the given product.

Args:
reviewer: An instance of Reviewer.
product: An instance of Product.

Returns:
A review object.

Raises:
TypeError: when given reviewer and product aren't instance of
specified reviewer and product class when this graph is constructed.
KeyError: When the reviewer does not review the product.


def in_to_out(self, in_path, out_path=None):
    is_in_place_edit = False
    if is_same_file(in_path, out_path):
        logger.debug('in path and out path are the same file. writing to temp file and then replacing in path with the temp file.')
        out_path = None
        is_in_place_edit = True
    logger.debug(f'opening source file: {in_path}')
    with open(in_path) as infile:
        if out_path:
            logger.debug(f'opening destination file for writing: {out_path}')
            ensure_dir(out_path)
            with open(out_path, 'w') as outfile:
                outfile.writelines(self.formatter(infile))
            return
        else:
            logger.debug('opening temp file for writing...')
            with NamedTemporaryFile(mode='w+t', dir=os.path.dirname(in_path), delete=False) as outfile:
                outfile.writelines(self.formatter(infile))
            is_in_place_edit = True
    if is_in_place_edit:
        logger.debug(f'moving temp file to: {in_path}')
        move_temp_file(outfile.name, infile.name)

Write a single file in to out, running self.formatter on each line.

If in_path and out_path point to the same thing it will in-place edit
and overwrite the in path. Even easier, if you do want to edit a file
in place, don't specify out_path, or set it to None.

Args:
in_path: str or path-like. Must refer to a single existing file.
out_path: str or path-like. Must refer to a single destination file
location. will create directory structure if it doesn't
exist.
If out_path is not specified or None, will in-place edit
and overwrite the in-files.

Returns:
None.


def __init__(self, out_stream=None, hide_cursor=True):

        BaseWindow.__init__(self, out_stream=out_stream,
                            hide_cursor=hide_cursor)
        self.fullscreen_ctx = self.t.fullscreen()

Constructs a FullscreenWindow

Args:
out_stream (file): Defaults to sys.__stdout__
hide_cursor (bool): Hides cursor while in context


def _build_graph(self, tags):
    graph = SimpleGraph()
    for tag_index in xrange(len(tags)):
        for entity_index in xrange(len(tags[tag_index].get('entities'))):
            a_entity_name = graph_key_from_tag(tags[tag_index], entity_index)
            tokens = self.tokenizer.tokenize(tags[tag_index].get('entities', [])[entity_index].get('match'))
            for tag in tags[(tag_index + 1):]:
                start_token = tag.get('start_token')
                if (start_token >= (tags[tag_index].get('start_token') + len(tokens))):
                    for b_entity_index in xrange(len(tag.get('entities'))):
                        b_entity_name = graph_key_from_tag(tag, b_entity_index)
                        graph.add_edge(a_entity_name, b_entity_name)
    return graph

Builds a graph from the entities included in the tags.
Note this is used internally.

Args:
tags (list): A list of the tags to include in graph

Returns:
graph : this is the resulting graph of the tagged entities.