def GetFileEntryByPathSpec(self, path_spec):

    fsapfs_file_entry = None
    location = getattr(path_spec, 'location', None)
    identifier = getattr(path_spec, 'identifier', None)

    if (location == self.LOCATION_ROOT or
        identifier == self.ROOT_DIRECTORY_IDENTIFIER):
      fsapfs_file_entry = self._fsapfs_volume.get_root_directory()
      return apfs_file_entry.APFSFileEntry(
          self._resolver_context, self, path_spec,
          fsapfs_file_entry=fsapfs_file_entry, is_root=True)

    try:
      if identifier is not None:
        fsapfs_file_entry = self._fsapfs_volume.get_file_entry_by_identifier(
            identifier)
      elif location is not None:
        fsapfs_file_entry = self._fsapfs_volume.get_file_entry_by_path(location)

    except IOError as exception:
      raise errors.BackEndError(exception)

    if fsapfs_file_entry is None:
      return None

    return apfs_file_entry.APFSFileEntry(
        self._resolver_context, self, path_spec,
        fsapfs_file_entry=fsapfs_file_entry)

Retrieves a file entry for a path specification.

Args:
path_spec (PathSpec): path specification.

Returns:
APFSFileEntry: file entry or None if not available.

Raises:
BackEndError: if the file entry cannot be opened.


def GetParsersInformation(cls):
    parsers_information = []
    for (_, parser_class) in cls.GetParsers():
        description = getattr(parser_class, 'DESCRIPTION', '')
        parsers_information.append((parser_class.NAME, description))
    return parsers_information

Retrieves the parsers information.

Returns:
list[tuple[str, str]]: parser names and descriptions.


def __init__(
            self, keys: Dict[Tuple[YangIdentifier, Optional[YangIdentifier]], str]):

        self.keys = keys

Initialize the class instance.

Args:
keys: Dictionary with keys of an entry.


def signature_cert_chain_url(url):
    r = urlparse(url)
    if (not (r.scheme.lower() == 'https')):
        warnings.warn('Certificate URL scheme is invalid.')
        return False
    if (not (r.hostname.lower() == 's3.amazonaws.com')):
        warnings.warn('Certificate URL hostname is invalid.')
        return False
    if (not os.path.normpath(r.path).startswith('/echo.api/')):
        warnings.warn('Certificate URL path is invalid.')
        return False
    if (r.port and (not (r.port == 443))):
        warnings.warn('Certificate URL port is invalid.')
        return False
    return True

Validate URL specified by SignatureCertChainUrl.

See `validate.request` for additional info.

Args:
url: str. SignatureCertChainUrl header value sent by request.

Returns:
bool: True if valid, False otherwise.


def list_file_extensions(path: str, reportevery: int=1) -> List[str]:
    extensions = set()
    count = 0
    for (root, dirs, files) in os.walk(path):
        count += 1
        if ((count % reportevery) == 0):
            log.debug('Walking directory {}: {!r}', count, root)
        for file in files:
            (filename, ext) = os.path.splitext(file)
            extensions.add(ext)
    return sorted(list(extensions))

Returns a sorted list of every file extension found in a directory
and its subdirectories.

Args:
path: path to scan
reportevery: report directory progress after every *n* steps

Returns:
sorted list of every file extension found


def GetForwardedIps(self, interface, interface_ip=None):

    try:
      ips = netifaces.ifaddresses(interface)
      ips = ips[netifaces.AF_INET]
    except (ValueError, IndexError):
      return []
    forwarded_ips = []
    for ip in ips:
      if ip['addr'] != interface_ip:
        full_addr = '%s/%d' % (ip['addr'], netaddr.IPAddress(ip['netmask']).netmask_bits())
        forwarded_ips.append(full_addr)
    return self.ParseForwardedIps(forwarded_ips)

Retrieve the list of configured forwarded IP addresses.

Args:
interface: string, the output device to query.
interface_ip: string, current interface ip address.

Returns:
list, the IP address strings.


def all(self, **kwargs):
    path = ('%s/all' % self.path)
    obj = self.gitlab.http_list(path, **kwargs)
    return [self._obj_cls(self, item) for item in obj]

List all the members, included inherited ones.

Args:
all (bool): If True, return all the items, without pagination
per_page (int): Number of items to retrieve per request
page (int): ID of the page to return (starts with page 1)
as_list (bool): If set to False and no pagination option is
defined, return a generator instead of a list
**kwargs: Extra options to send to the server (e.g. sudo)

Raises:
GitlabAuthenticationError: If authentication is not correct
GitlabListError: If the list could not be retrieved

Returns:
RESTObjectList: The list of members


def add_numeric_table_values(table, min_consolidation_fraction=0.7, debug_info=None):
    table = table.copy()
    filter_invalid_unicode_from_table(table)
    for row_index, row in table.iterrows():
        for col_index, cell in enumerate(row):
            table.iloc[row_index, col_index] = Cell(text=cell)
    for col_index, column in enumerate(table.columns):
        column_values = _consolidate_numeric_values(_get_column_values(table, col_index), min_consolidation_fraction=min_consolidation_fraction, debug_info=(debug_info, column))
        for row_index, numeric_value in column_values.items():
            table.iloc[row_index, col_index].numeric_value = numeric_value
    return table

Parses text in table column-wise and adds the consolidated values. Consolidation refers to finding values with a
common types (date or number)

Args:
table:
Table to annotate.
min_consolidation_fraction:
Fraction of cells in a column that need to have consolidated value.
debug_info:
Additional information used for logging.


def block(self, cutoffs=None, values=None, n_bins=0, right=False, function=None):
    params = self.__dict__.copy()
    if ((values is not None) and (cutoffs is None)):
        cutoffs = values[1:]
    if ((cutoffs is None) and (n_bins == 0)):
        cutoffs = np.mean(self)
    if ((n_bins != 0) and (cutoffs is None)):
        (mi, ma) = (np.amin(self), np.amax(self))
        cutoffs = np.linspace(mi, ma, (n_bins + 1))
        cutoffs = cutoffs[:(- 1)]
    try:
        data = np.digitize(self, cutoffs, right)
    except ValueError:
        data = np.digitize(self, [cutoffs], right)
    if ((function is None) and (values is None)):
        return Curve(data, params=params)
    data = data.astype(float)
    f = (function or utils.null)
    (tops, vals) = utils.find_edges(data)
    if (values is None):
        for (top, base) in zip(tops[:(- 1)], tops[1:]):
            data[top:base] = f(np.copy(self[top:base]))
        data[base:] = f(np.copy(self[base:]))
    else:
        for (top, base, val) in zip(tops[:(- 1)], tops[1:], vals[:(- 1)]):
            data[top:base] = values[int(val)]
        data[base:] = values[int(vals[(- 1)])]
    return Curve(data, params=params)

Block a log based on number of bins, or on cutoffs.

Args:
cutoffs (array)
values (array): the values to map to. Defaults to [0, 1, 2,...]
n_bins (int)
right (bool)
function (function): transform the log if you want.

Returns:
Curve.


def get_table_columns(metadata):
    cols = OrderedDict()
    for col in metadata.c:
        name = str(col).rpartition('.')[2]
        cols[name] = col.type.python_type.__name__
    return cols

Extract columns names and python typos from metadata

Args:
metadata: Table metadata

Returns:
dict with columns names and python types


def set_hparam(self, name, value):
    (param_type, is_list) = self._hparam_types[name]
    if isinstance(value, list):
        if (not is_list):
            raise ValueError(('Must not pass a list for single-valued parameter: %s' % name))
        setattr(self, name, [_cast_to_type_if_compatible(name, param_type, v) for v in value])
    else:
        if is_list:
            raise ValueError(('Must pass a list for multi-valued parameter: %s.' % name))
        setattr(self, name, _cast_to_type_if_compatible(name, param_type, value))

Set the value of an existing hyperparameter.

This function verifies that the type of the value matches the type of the
existing hyperparameter.

Args:
name: Name of the hyperparameter.
value: New value of the hyperparameter.

Raises:
KeyError: If the hyperparameter doesn't exist.
ValueError: If there is a type mismatch.


def GetLaunchedFlows(self, flow_type="outstanding"):

    result = None
    all_clients = set(self.ListAllClients())
    finished_clients = set(self.ListFinishedClients())
    outstanding_clients = all_clients - finished_clients

    if flow_type == "all":
      result = all_clients
    elif flow_type == "finished":
      result = finished_clients
    elif flow_type == "outstanding":
      result = outstanding_clients

    flows = aff4.FACTORY.MultiListChildren(
        [self.urn.Add(x.Basename()) for x in result])

    return [x[0] for _, x in flows]

Returns the session IDs of all the flows we launched.

Args:
flow_type: The type of flows to fetch. Can be "all", "outstanding" or
"finished".

Returns:
A list of flow URNs.


def force_string(val=None):
    if (val is None):
        return ''
    if isinstance(val, list):
        newval = [str(x) for x in val]
        return ';'.join(newval)
    if isinstance(val, str):
        return val
    else:
        return str(val)

Force a string representation of an object

Args:
val: object to parse into a string

Returns:
str: String representation


def plot_state_qsphere(rho, figsize=None):

    if not HAS_MATPLOTLIB:
        raise ImportError('Must have Matplotlib installed.')
    rho = _validate_input_state(rho)
    if figsize is None:
        figsize = (7, 7)
    num = int(np.log2(len(rho)))

    we, stateall = linalg.eigh(rho)
    for _ in range(2**num):

        probmix = we.max()
        prob_location = we.argmax()
        if probmix > 0.001:

            state = stateall[:, prob_location]
            loc = np.absolute(state).argmax()

            for j in range(2**num):
                test = np.absolute(np.absolute(state[j]) -
                                   np.absolute(state[loc]))
                if test < 0.001:
                    loc = j
                    break

            angles = (np.angle(state[loc]) + 2 * np.pi) % (2 * np.pi)
            angleset = np.exp(-1j*angles)

            state = angleset*state

            state.flatten()

            fig = plt.figure(figsize=figsize)
            ax = fig.add_subplot(111, projection='3d')
            ax.axes.set_xlim3d(-1.0, 1.0)
            ax.axes.set_ylim3d(-1.0, 1.0)
            ax.axes.set_zlim3d(-1.0, 1.0)
            ax.set_aspect("equal")
            ax.axes.grid(False)

            u = np.linspace(0, 2 * np.pi, 25)
            v = np.linspace(0, np.pi, 25)
            x = np.outer(np.cos(u), np.sin(v))
            y = np.outer(np.sin(u), np.sin(v))
            z = np.outer(np.ones(np.size(u)), np.cos(v))
            ax.plot_surface(x, y, z, rstride=1, cstride=1, color='k',
                            alpha=0.05, linewidth=0)

            ax.w_xaxis.set_pane_color((1.0, 1.0, 1.0, 0.0))
            ax.w_yaxis.set_pane_color((1.0, 1.0, 1.0, 0.0))
            ax.w_zaxis.set_pane_color((1.0, 1.0, 1.0, 0.0))

            ax.w_xaxis.line.set_color((1.0, 1.0, 1.0, 0.0))
            ax.w_yaxis.line.set_color((1.0, 1.0, 1.0, 0.0))
            ax.w_zaxis.line.set_color((1.0, 1.0, 1.0, 0.0))

            ax.set_xticks([])
            ax.set_yticks([])
            ax.set_zticks([])

            d = num
            for i in range(2**num):

                element = bin(i)[2:].zfill(num)
                weight = element.count("1")
                zvalue = -2 * weight / d + 1
                number_of_divisions = n_choose_k(d, weight)
                weight_order = bit_string_index(element)

                angle = weight_order * 2 * np.pi / number_of_divisions
                xvalue = np.sqrt(1 - zvalue**2) * np.cos(angle)
                yvalue = np.sqrt(1 - zvalue**2) * np.sin(angle)
                ax.plot([xvalue], [yvalue], [zvalue],
                        markerfacecolor=(.5, .5, .5),
                        markeredgecolor=(.5, .5, .5),
                        marker='o', markersize=10, alpha=1)

                prob = np.real(np.dot(state[i], state[i].conj()))
                colorstate = phase_to_color_wheel(state[i])
                a = Arrow3D([0, xvalue], [0, yvalue], [0, zvalue],
                            mutation_scale=20, alpha=prob, arrowstyle="-",
                            color=colorstate, lw=10)
                ax.add_artist(a)

            for weight in range(d + 1):
                theta = np.linspace(-2 * np.pi, 2 * np.pi, 100)
                z = -2 * weight / d + 1
                r = np.sqrt(1 - z**2)
                x = r * np.cos(theta)
                y = r * np.sin(theta)
                ax.plot(x, y, z, color=(.5, .5, .5))

            ax.plot([0], [0], [0], markerfacecolor=(.5, .5, .5),
                    markeredgecolor=(.5, .5, .5), marker='o', markersize=10,
                    alpha=1)
            we[prob_location] = 0
        else:
            break
    plt.tight_layout()
    plt.close(fig)
    return fig

Plot the qsphere representation of a quantum state.

Args:
rho (ndarray): State vector or density matrix representation.
of quantum state.
figsize (tuple): Figure size in inches.

Returns:
Figure: A matplotlib figure instance.

Raises:
ImportError: Requires matplotlib.


def write_json(self, fh, pretty=True):
    sjson = json.JSONEncoder().encode(self.json())
    if pretty:
        json.dump(json.loads(sjson), fh, sort_keys=True, indent=4)
    else:
        json.dump(json.loads(sjson), fh)
    return

Write composite object to file handle in JSON format.

Args:
fh (file): File handle to write to.
pretty (bool): Sort keys and indent in output.


def summary_writer_function(name, tensor, function, family=None):
    name_scope = ops.get_name_scope()
    if name_scope:
        name_scope += '/'

    def record():
        with ops.name_scope(name_scope), summary_op_util.summary_scope(name, family, values=[tensor]) as (tag, scope):
            with ops.control_dependencies([function(tag, scope)]):
                return constant_op.constant(True)
    if _summary_state.writer is None:
        return control_flow_ops.no_op()
    with ops.device('cpu:0'):
        op = smart_cond.smart_cond(_legacy_contrib_should_record_summaries(), record, _nothing, name='')
        if not context.executing_eagerly():
            ops.add_to_collection(ops.GraphKeys._SUMMARY_COLLECTION, op)
    return op

Helper function to write summaries.

Args:
name: name of the summary
tensor: main tensor to form the summary
function: function taking a tag and a scope which writes the summary
family: optional, the summary's family

Returns:
The result of writing the summary.


def transform_rest_response(self, response_body):
    body_json = json.loads(response_body)
    return json.dumps(body_json, indent=1, sort_keys=True)

Translates an apiserving REST response so it's ready to return.

Currently, the only thing that needs to be fixed here is indentation,
so it's consistent with what the live app will return.

Args:
response_body: A string containing the backend response.

Returns:
A reformatted version of the response JSON.


def check_constraint(type_constraint, object_instance):
    if type_constraint is None and object_instance is None:
        return
    elif isinstance(type_constraint, TypeConstraint):
        type_constraint.type_check(object_instance)
    elif type_constraint is None:
        pass
    elif not isinstance(type_constraint, type):
        raise RuntimeError('bad type: %s' % (type_constraint,))
    elif not isinstance(object_instance, type_constraint):
        raise SimpleTypeHintError

Determine if the passed type instance satisfies the TypeConstraint.

When examining a candidate type for constraint satisfaction in
'type_check', all CompositeTypeHint's eventually call this function. This
function may end up being called recursively if the hinted type of a
CompositeTypeHint is another CompositeTypeHint.

Args:
type_constraint: An instance of a TypeConstraint or a built-in Python type.
object_instance: An object instance.

Raises:
SimpleTypeHintError: If 'type_constraint' is a one of the allowed primitive
Python types and 'object_instance' isn't an instance of this type.
CompositeTypeHintError: If 'type_constraint' is a TypeConstraint object and
'object_instance' does not satisfy its constraint.


def _deconstruct_single_qubit_matrix_into_gate_turns(
        mat: np.ndarray) -> Tuple[float, float, float]:

    pre_phase, rotation, post_phase = (
        linalg.deconstruct_single_qubit_matrix_into_angles(mat))

    tau = 2 * np.pi
    xy_turn = rotation / tau
    xy_phase_turn = 0.25 - pre_phase / tau
    total_z_turn = (post_phase + pre_phase) / tau

    return (_signed_mod_1(xy_turn), _signed_mod_1(xy_phase_turn),
            _signed_mod_1(total_z_turn))

Breaks down a 2x2 unitary into gate parameters.

Args:
mat: The 2x2 unitary matrix to break down.

Returns:
A tuple containing the amount to rotate around an XY axis, the phase of
that axis, and the amount to phase around Z. All results will be in
fractions of a whole turn, with values canonicalized into the range
[-0.5, 0.5).


def parse_filepath(self, filepath=None):
    filepath = (filepath or self._default_filename)
    (path, filename) = os.path.split(filepath)
    if (not path):
        path = self.basedir
    elif (not os.path.isabs(path)):
        path = os.path.join(self.basedir, path)
    return (os.path.normpath(path), filename)

Parse given filepath to split possible path directory from filename.

* If path directory is empty, will use ``basedir`` attribute as base
filepath;
* If path directory is absolute, ignore ``basedir`` attribute;
* If path directory is relative, join it to ``basedir`` attribute;

Keyword Arguments:
filepath (str): Filepath to use to search for settings file. Will
use value from ``_default_filename`` class attribute if empty.

If filepath contain a directory path, it will be splitted from
filename and used as base directory (and update object
``basedir`` attribute).

Returns:
tuple: Separated path directory and filename.


def get_conflicting_tools(self, request_only=False):

        from collections import defaultdict

        tool_sets = defaultdict(set)
        tools_dict = self.get_tools(request_only=request_only)
        for variant, tools in tools_dict.itervalues():
            for tool in tools:
                tool_sets[tool].add(variant)

        conflicts = dict((k, v) for k, v in tool_sets.iteritems() if len(v) > 1)
        return conflicts

Returns tools of the same name provided by more than one package.

Args:
request_only: If True, only return the key from resolved packages
that were also present in the request.

Returns:
Dict of {tool-name: set([Variant])}.


def _list_samples(self, predicate=None):
    cursor = self.database[self.sample_collection].find(predicate, {'_id': 0, 'md5': 1})
    return [item['md5'] for item in cursor]

List all samples that meet the predicate or all if predicate is not specified.

Args:
predicate: Match samples against this predicate (or all if not specified)

Returns:
List of the md5s for the matching samples


def InitFromAff4Object(self, file_obj, stat_entry=None, hash_entry=None, with_details=False):
    self.name = file_obj.urn.Basename()
    self.path = '/'.join(file_obj.urn.Path().split('/')[2:])
    self.is_directory = ('Container' in file_obj.behaviours)
    self.stat = (stat_entry or file_obj.Get(file_obj.Schema.STAT))
    self.hash = (hash_entry or file_obj.Get(file_obj.Schema.HASH, None))
    if (not self.is_directory):
        try:
            self.last_collected = file_obj.GetContentAge()
        except AttributeError:
            logging.debug("File-like object %s doesn't have GetContentAge defined.", file_obj.__class__.__name__)
        if self.last_collected:
            self.last_collected_size = file_obj.Get(file_obj.Schema.SIZE)
    type_obj = file_obj.Get(file_obj.Schema.TYPE)
    if (type_obj is not None):
        self.age = type_obj.age
    if with_details:
        self.details = ApiAff4ObjectRepresentation().InitFromAff4Object(file_obj)
    return self

Initializes the current instance from an Aff4Stream.

Args:
file_obj: An Aff4Stream representing a file.
stat_entry: An optional stat entry object to be used. If none is provided,
the one stored in the AFF4 data store is used.
hash_entry: An optional hash entry object to be used. If none is provided,
the one stored in the AFF4 data store is used.
with_details: True if all details of the Aff4Object should be included,
false otherwise.

Returns:
A reference to the current instance.


def __init__( self, label, r ):

        self.label = label
        self.r = r

Initialise an Atom instance

Args:
label (Str): a label for this atom
r (numpy.array): the atom coordinates

Returns:
None


def __init__(self, optimizer, scope=None, summary_labels=(), **kwargs):

        self.tf_optimizer_type = optimizer
        self.tf_optimizer = TFOptimizer.tf_optimizers[optimizer](**kwargs)

        super(TFOptimizer, self).__init__(scope=(scope or optimizer), summary_labels=summary_labels)

Creates a new optimizer instance of a TensorFlow optimizer.

Args:
optimizer: The name of the optimizer. Must be one of the keys of the tf_optimizers dict.
**kwargs: Arguments passed on to the TensorFlow optimizer constructor as **kwargs.


def choose(self, locator=None, allow_label_click=None, **kwargs):

        self._check_with_label(
            "radio_button", True, locator=locator, allow_label_click=allow_label_click, **kwargs)

Find a radio button and mark it as checked. The radio button can be found via name, id, or
label text. ::

page.choose("Male")

Args:
locator (str, optional): Which radio button to choose.
allow_label_click (bool, optional): Attempt to click the label to toggle state if
element is non-visible. Defaults to :data:`capybara.automatic_label_click`.
**kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.


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 None:
        return [1] + [0] * len(token_ids_0)
    return [1] + [0] * len(token_ids_0) + [1, 1] + [0] * len(token_ids_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 forward(self, hidden_features):
    hidden_features = self.flatten(hidden_features)
    hidden_features = self.dropout_layer(hidden_features)
    forecast = self.base_forecast_block(hidden_features)
    if isinstance(forecast, tuple):
        forecast = tuple((z.transpose(-1, -2) for z in forecast))
    else:
        forecast = forecast.transpose(-1, -2)
    if self.prediction_channel_indices is not None:
        if isinstance(forecast, tuple):
            forecast = tuple((z[..., self.prediction_channel_indices] for z in forecast))
        else:
            forecast = forecast[..., self.prediction_channel_indices]
    return forecast

Args:
hidden_features (`torch.Tensor` of shape `(batch_size, num_patch, d_model)` in `flatten` mode
or `(batch_size, n_vars, num_patch, d_model)` in `common_channel`/`mix_channel` mode.): Input hidden
features.

Returns:
`torch.Tensor` of shape `(batch_size, prediction_length, nvars)`.


def parse(ifp, pb_cls, **kwargs):
    mode = 'rb'
    if isinstance(ifp, str):
        istream = open(ifp, mode=mode, **kwargs)
    else:
        istream = open(fileobj=ifp, mode=mode, **kwargs)
    with istream:
        for data in istream:
            pb_obj = pb_cls()
            pb_obj.ParseFromString(data)
            (yield pb_obj)

Parse a stream.

Args:
ifp (string or file-like object): input stream.
pb_cls (protobuf.message.Message.__class__): The class object of
the protobuf message type encoded in the stream.


def _resolve_and_add(nodes1, s_val, final_s, nodes2, t_val, final_t):
    (s_val, t_val) = _intersection_helpers.newton_refine(s_val, nodes1, t_val, nodes2)
    (s_val, success_s) = _helpers.wiggle_interval(s_val)
    (t_val, success_t) = _helpers.wiggle_interval(t_val)
    if (not (success_s and success_t)):
        return
    final_s.append(s_val)
    final_t.append(t_val)

Resolve a computed intersection and add to lists.

We perform one Newton step to deal with any residual issues of
high-degree polynomial solves (one of which depends on the already
approximate ``x_val, y_val``).

Args:
nodes1 (numpy.ndarray): The nodes in the first curve.
s_val (float): The approximate intersection parameter
along ``nodes1``.
final_s (List[float]): The list of accepted intersection
parameters ``s``.
nodes2 (numpy.ndarray): The nodes in the second curve.
t_val (float): The approximate intersection parameter
along ``nodes2``.
final_t (List[float]): The list of accepted intersection
parameters ``t``.


def _create_3d_attention_mask_from_input_mask(self, from_tensor, to_mask):
    batch_size, from_seq_length = (from_tensor.shape[0], from_tensor.shape[1])
    to_seq_length = to_mask.shape[1]
    to_mask = torch.reshape(to_mask, (batch_size, 1, to_seq_length)).float()
    broadcast_ones = torch.ones(size=(batch_size, from_seq_length, 1), dtype=torch.float32, device=to_mask.device)
    mask = broadcast_ones * to_mask
    return mask

Create 3D attention mask from a 2D tensor mask.

Args:
from_tensor: 2D or 3D Tensor of shape [batch_size, from_seq_length, ...].
to_mask: int32 Tensor of shape [batch_size, to_seq_length].

Returns:
float Tensor of shape [batch_size, from_seq_length, to_seq_length].


def register_from_fields(self, *args):
    names = []
    for field in args:
        widget = self.resolve_widget(field)
        self.register(widget.config_name)
        if (widget.config_name not in names):
            names.append(widget.config_name)
    return names

Register config name from field widgets

Arguments:
*args: Fields that contains widget
:class:`djangocodemirror.widget.CodeMirrorWidget`.

Returns:
list: List of registered config names from fields.


def AppendPathEntries(cls, path, path_separator, number_of_wildcards, skip_first):
    if (path[(- 1)] == path_separator):
        path = path[:(- 1)]
    if skip_first:
        path = ''.join([path, path_separator, '*'])
        number_of_wildcards -= 1
    paths = []
    for _ in range(0, number_of_wildcards):
        path = ''.join([path, path_separator, '*'])
        paths.append(path)
    return paths

Appends glob wildcards to a path.

This function will append glob wildcards "*" to a path, returning paths
with an additional glob wildcard up to the specified number. E.g. given
the path "/tmp" and a number of 2 wildcards, this function will return
"tmp/*", "tmp/*/*". When skip_first is true the path with the first
wildcard is not returned as a result.

Args:
path (str): path to append glob wildcards to.
path_separator (str): path segment separator.
number_of_wildcards (int): number of glob wildcards to append.
skip_first (bool): True if the the first path with glob wildcard should
be skipped as a result.

Returns:
list[str]: paths with glob wildcards.


def write(self, output_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):
    local_stream = utils.BytearrayStream()
    if self._unique_identifier:
        self._unique_identifier.write(local_stream, kmip_version=kmip_version)
    if self._lease_time:
        self._lease_time.write(local_stream, kmip_version=kmip_version)
    if self._last_change_date:
        self._last_change_date.write(local_stream, kmip_version=kmip_version)
    self.length = local_stream.length()
    super(ObtainLeaseResponsePayload, self).write(output_stream, kmip_version=kmip_version)
    output_stream.write(local_stream.buffer)

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

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

Raises:
ValueError: Raised if the data attribute is not defined.


def _fill_meta_graph_def(meta_graph_def: meta_graph_pb2.MetaGraphDef, saveable_view: _SaveableView, signature_functions: Dict[str, Callable[..., Any]], namespace_whitelist: List[str], save_custom_gradients: bool, create_saver: bool, enable_debug_stripper: bool, defaults=None) -> Tuple[_AssetInfo, ops.Graph]:
    resource_initializers = saveable_view.get_concrete_resource_initializers()
    exported_graph = ops.Graph()
    resource_initializer_ops = []
    with exported_graph.as_default():
        object_map, tensor_map, asset_info = saveable_view.map_resources()
        signatures = _generate_signatures(signature_functions, object_map, defaults)
    if save_custom_gradients:
        _trace_gradient_functions(exported_graph, saveable_view)
    with exported_graph.as_default():
        for resource_initializer_function in resource_initializers:
            asset_dependencies = []
            for capture in resource_initializer_function.graph.external_captures:
                asset_initializer = asset_info.asset_initializers_by_resource.get(capture, None)
                if asset_initializer is not None:
                    asset_dependencies.append(asset_initializer)
            with ops.control_dependencies(asset_dependencies):
                mapped_initializer = object_map[resource_initializer_function]
                resource_initializer_ops.append(mapped_initializer())
        resource_initializer_ops.extend(asset_info.asset_initializers_by_resource.values())
        with ops.control_dependencies(resource_initializer_ops):
            init_op = control_flow_ops.no_op()
        meta_graph_def.collection_def[constants.MAIN_OP_KEY].node_list.value.append(init_op.name)
        meta_graph_def.signature_def[constants.INIT_OP_SIGNATURE_KEY].CopyFrom(signature_def_utils.op_signature_def(init_op, constants.INIT_OP_SIGNATURE_KEY))

    def call_with_mapped_captures(function, args):
        if function in object_map:
            return object_map[function](*args)
        return saved_model_exported_concrete.ExportedConcreteFunction(function, tensor_map)(*args)
    for obj in object_map.values():
        obj._maybe_initialize_trackable()
    named_saveable_objects, registered_savers = save_util_v1.frozen_saveables_and_savers(graph_view=saveable_view.augmented_graph_view, object_map=object_map, to_graph=exported_graph, call_with_mapped_captures=call_with_mapped_captures)
    if create_saver:
        saver = functional_saver.MultiDeviceSaver.from_saveables(named_saveable_objects, registered_savers, call_with_mapped_captures)
        with exported_graph.as_default():
            saver_def = saver.to_proto()
            meta_graph_def.saver_def.CopyFrom(saver_def)
    _dependency_sorted_node_ids(saveable_view)
    graph_def, _ = exported_graph._as_graph_def(add_shapes=True, use_pybind11_proto=False)
    graph_def.library.registered_gradients.extend(saveable_view.gradient_defs)
    _verify_ops(graph_def, namespace_whitelist)
    meta_graph_def.graph_def.CopyFrom(graph_def)
    meta_graph_def.meta_info_def.tags.append(tag_constants.SERVING)
    if saveable_view.options.extra_tags:
        for tag in saveable_view.options.extra_tags:
            meta_graph_def.meta_info_def.tags.append(tag)
    meta_graph_def.meta_info_def.tensorflow_version = versions.__version__
    meta_graph_def.meta_info_def.tensorflow_git_version = versions.__git_version__
    meta_graph_def.meta_info_def.stripped_default_attrs = True
    meta_graph_def.asset_file_def.extend(asset_info.asset_defs)
    for signature_key, signature in signatures.items():
        meta_graph_def.signature_def[signature_key].CopyFrom(signature)
    meta_graph.strip_graph_default_valued_attrs(meta_graph_def)
    if sys.byteorder == 'big':
        utils_impl.swap_function_tensor_content(meta_graph_def, 'big', 'little')
    if enable_debug_stripper:
        _strip_debug_nodes(meta_graph_def)
    meta_graph_def.meta_info_def.stripped_op_list.MergeFrom(meta_graph.stripped_op_list_for_graph(meta_graph_def.graph_def))
    return (asset_info, exported_graph)

Generates a MetaGraph which calls `signature_functions`.

Args:
meta_graph_def: The MetaGraphDef proto to fill.
saveable_view: The _SaveableView being exported.
signature_functions: A dictionary mapping signature keys to concrete
functions containing signatures to add to the MetaGraph.
namespace_whitelist: List of strings containing whitelisted op namespaces.
save_custom_gradients: Whether to save custom gradients.
create_saver: Whether to add SavedModel's native save and restore ops.
enable_debug_stripper: Whether to strip the debug nodes from the graph.
defaults: A dictionary mapping signature_key to dictionary of
user_specified_name to Tensor representing default values.

Returns:
A tuple of (_AssetInfo, Graph) containing the captured assets and
exported Graph generated from tracing the saveable_view.


def get_run_short_description(run_call_count, fetches, feed_dict, is_callable_runner=False):
    if is_callable_runner:
        return 'runner from make_callable()'
    description = 'run
    if isinstance(fetches, (tensor_lib.Tensor, ops.Operation, variables.Variable)):
        description += '1 fetch (%s); ' % common.get_graph_element_name(fetches)
    else:
        num_fetches = len(common.get_flattened_names(fetches))
        if num_fetches > 1:
            description += '%d fetches; ' % num_fetches
        else:
            description += '%d fetch; ' % num_fetches
    if not feed_dict:
        description += '0 feeds'
    elif len(feed_dict) == 1:
        for key in feed_dict:
            description += '1 feed (%s)' % (key if isinstance(key, str) or not hasattr(key, 'name') else key.name)
    else:
        description += '%d feeds' % len(feed_dict)
    return description

Get a short description of the run() call.

Args:
run_call_count: (int) Run call counter.
fetches: Fetches of the `Session.run()` call. See doc of `Session.run()`
for more details.
feed_dict: Feeds to the `Session.run()` call. See doc of `Session.run()`
for more details.
is_callable_runner: (bool) whether a runner returned by
Session.make_callable is being run.

Returns:
(str) A short description of the run() call, including information about
the fetche(s) and feed(s).


def assert_equal_graph_def_v2(expected: graph_pb2.GraphDef, actual: graph_pb2.GraphDef) -> None:
    assert_equal_graph_def(actual, expected, checkpoint_v2=True, hash_table_shared_name=True)

Asserts that two `GraphDef`s are (mostly) the same.

Compares two `GraphDef` protos for equality, ignoring versions and ordering of
nodes, attrs, and control inputs.  Node names are used to match up nodes
between the graphs, so the naming of nodes must be consistent. This function
ignores randomized attribute values that may appear in V2 checkpoints.

Args:
expected: The `GraphDef` we expected.
actual: The `GraphDef` we have.

Raises:
AssertionError: If the `GraphDef`s do not match.
TypeError: If either argument is not a `GraphDef`.


def from_directory(input_dir, optional_files=None):

        sub_d = {}
        for fname, ftype in [("INCAR", Incar), ("KPOINTS", Kpoints),
                             ("POSCAR", Poscar), ("POTCAR", Potcar)]:
            fullzpath = zpath(os.path.join(input_dir, fname))
            sub_d[fname.lower()] = ftype.from_file(fullzpath)
        sub_d["optional_files"] = {}
        if optional_files is not None:
            for fname, ftype in optional_files.items():
                sub_d["optional_files"][fname] = \
                    ftype.from_file(os.path.join(input_dir, fname))
        return VaspInput(**sub_d)

Read in a set of VASP input from a directory. Note that only the
standard INCAR, POSCAR, POTCAR and KPOINTS files are read unless
optional_filenames is specified.

Args:
input_dir (str): Directory to read VASP input from.
optional_files (dict): Optional files to read in as well as a
dict of {filename: Object type}. Object type must have a
static method from_file.


def is_user_enrolled(cls, user, course_id, course_mode):

        enrollment_client = EnrollmentApiClient()
        try:
            enrollments = enrollment_client.get_course_enrollment(user.username, course_id)
            if enrollments and course_mode == enrollments.get('mode'):
                return True
        except HttpClientError as exc:
            logging.error(
                'Error while checking enrollment status of user %(user)s: %(message)s',
                dict(user=user.username, message=str(exc))
            )
        except KeyError as exc:
            logging.warning(
                'Error while parsing enrollment data of user %(user)s: %(message)s',
                dict(user=user.username, message=str(exc))
            )
        return False

Query the enrollment API and determine if a learner is enrolled in a given course run track.

Args:
user: The user whose enrollment needs to be checked
course_mode: The mode with which the enrollment should be checked
course_id: course id of the course where enrollment should be checked.

Returns:
Boolean: Whether or not enrollment exists


def _error_messages(self, driver_id):
    assert isinstance(driver_id, ray.DriverID)
    message = self.redis_client.execute_command('RAY.TABLE_LOOKUP', ray.gcs_utils.TablePrefix.ERROR_INFO, '', driver_id.binary())
    if (message is None):
        return []
    gcs_entries = ray.gcs_utils.GcsTableEntry.GetRootAsGcsTableEntry(message, 0)
    error_messages = []
    for i in range(gcs_entries.EntriesLength()):
        error_data = ray.gcs_utils.ErrorTableData.GetRootAsErrorTableData(gcs_entries.Entries(i), 0)
        assert (driver_id.binary() == error_data.DriverId())
        error_message = {'type': decode(error_data.Type()), 'message': decode(error_data.ErrorMessage()), 'timestamp': error_data.Timestamp()}
        error_messages.append(error_message)
    return error_messages

Get the error messages for a specific driver.

Args:
driver_id: The ID of the driver to get the errors for.

Returns:
A list of the error messages for this driver.


def _ReadN(self, n):
    ret = ''
    while True:
        chunk = self._read_file.read((n - len(ret)))
        ret += chunk
        if ((len(ret) == n) or (not chunk)):
            return ret

Reads n characters from the input stream, or until EOF.

This is equivalent to the current CPython implementation of read(n), but
not guaranteed by the docs.

Args:
n: int

Returns:
string


def recompose(src: Path, target_file: Path):

        mission_folder, assets_folder = NewMiz._get_subfolders(src)

        base_info = ujson.loads(Path(mission_folder, 'base_info.json').read_text(encoding=ENCODING))
        version = base_info['__version__']
        with Miz(target_file) as miz:
            LOGGER.info('re-composing mission table from folder: "%s"', mission_folder)
            miz.mission.d = NewMiz._recreate_dict_from_folder(mission_folder, version)
            for item in assets_folder.iterdir():
                target = Path(miz.temp_dir, item.name).absolute()
                if item.is_dir():
                    if target.exists():
                        shutil.rmtree(target)
                    shutil.copytree(item.absolute(), target)
                elif item.is_file():
                    shutil.copy(item.absolute(), target)
            miz.zip(target_file, encode=False)

Recompose a Miz from json object

Args:
src: folder containing the json structure
target_file: target Miz file


def get_value_spec(self, name: str) -> Optional[class_schema.ValueSpec]:
    for arg in self.named_args:
        if arg.name == name:
            return arg.value_spec
    if self.varkw is not None:
        return self.varkw.value_spec.schema.dynamic_field.value
    return None

Returns Value spec for an argument name.

Args:
name: Argument name.

Returns:
ValueSpec for the requested argument. If name is not found, value spec of
wildcard keyword argument will be used. None will be returned if name
does not exist in signature and wildcard keyword is not accepted.


def subtract_business_days(self, date_tensor, num_days, roll_convention=constants.BusinessDayConvention.NONE):
    return self.add_business_days(date_tensor, -num_days, roll_convention)

Adds given number of business days to given dates.

Note that this is different from calling `subtract_period_and_roll` with
PeriodType.DAY. For example, subtracting 5 business days from Friday gives
the previous Friday (unless there are holidays on this week or previous
Friday). Subtracting 5 days and rolling means landing on Sunday and then
rolling either to Monday or to Friday, depending on the roll convention.

If any of the dates in `date_tensor` are not business days, they will be
rolled to business days before doing the subtraction. If `roll_convention`
is `NONE`, and any dates are not business days, an exception is raised.

Args:
date_tensor: DateTensor of dates to advance from.
num_days: Tensor of int32 type broadcastable to `date_tensor`.
roll_convention: BusinessDayConvention. Determines how to roll a date that
falls on a holiday.

Returns:
The resulting DateTensor.


def add_citations(voevent, event_ivorns):
    if (not voevent.xpath('Citations')):
        etree.SubElement(voevent, 'Citations')
    voevent.Citations.extend(_listify(event_ivorns))

Add citations to other voevents.

The schema mandates that the 'Citations' section must either be entirely
absent, or non-empty - hence we require this wrapper function for its
creation prior to listing the first citation.

Args:
voevent(:class:`Voevent`): Root node of a VOEvent etree.
event_ivorns (:class:`voeventparse.misc.EventIvorn`): List of EventIvorn
elements to add to citation list.


def _CopyDateFromString(self, date_string):

    date_string_length = len(date_string)

    if date_string_length < 10:
      raise ValueError('Date string too short.')

    if date_string[4] != '-' or date_string[7] != '-':
      raise ValueError('Invalid date string.')

    try:
      year = int(date_string[0:4], 10)
    except ValueError:
      raise ValueError('Unable to parse year.')

    try:
      month = int(date_string[5:7], 10)
    except ValueError:
      raise ValueError('Unable to parse month.')

    try:
      day_of_month = int(date_string[8:10], 10)
    except ValueError:
      raise ValueError('Unable to parse day of month.')

    days_per_month = self._GetDaysPerMonth(year, month)
    if day_of_month < 1 or day_of_month > days_per_month:
      raise ValueError('Day of month value out of bounds.')

    return year, month, day_of_month

Copies a date from a string.

Args:
date_string (str): date value formatted as: YYYY-MM-DD

Returns:
tuple[int, int, int]: year, month, day of month.

Raises:
ValueError: if the date string is invalid or not supported.


def equal_distribution_folds(y, folds=2):
    (n, classes) = y.shape
    dist = y.sum(axis=0).astype('float')
    dist /= dist.sum()
    index_list = []
    fold_dist = np.zeros((folds, classes), dtype='float')
    for _ in range(folds):
        index_list.append([])
    for i in range(n):
        if (i < folds):
            target_fold = i
        else:
            normed_folds = (fold_dist.T / fold_dist.sum(axis=1))
            how_off = (normed_folds.T - dist)
            target_fold = np.argmin(np.dot((y[i] - 0.5).reshape(1, (- 1)), how_off.T))
        fold_dist[target_fold] += y[i]
        index_list[target_fold].append(i)
    logger.debug('Fold distributions:')
    logger.debug(fold_dist)
    return index_list

Creates `folds` number of indices that has roughly balanced multi-label distribution.

Args:
y: The multi-label outputs.
folds: The number of folds to create.

Returns:
`folds` number of indices that have roughly equal multi-label distributions.


def to_json(self, **kwargs):
    config = self.get_config()
    timeseries_generator_config = {'class_name': self.__class__.__name__, 'config': config}
    return json.dumps(timeseries_generator_config, **kwargs)

Returns a JSON string containing the generator's configuration.

Args:
**kwargs: Additional keyword arguments to be passed
to `json.dumps()`.

Returns:
A JSON string containing the tokenizer configuration.


def _process_sum_prod(self, func, **kwargs):
    axis = kwargs.get('axis', 0)
    min_count = kwargs.get('min_count', 0)

    def sum_prod_builder(df, **kwargs):
        return func(df, **kwargs)
    if (min_count <= 1):
        return self._full_reduce(axis, sum_prod_builder)
    else:
        return self._full_axis_reduce(axis, sum_prod_builder)

Calculates the sum or product of the DataFrame.

Args:
func: Pandas func to apply to DataFrame.
ignore_axis: Whether to ignore axis when raising TypeError
Return:
A new QueryCompiler object with sum or prod of the object.


def start(logdir):
    if logdir.startswith('gs:
        datalab.storage._api.Api.verify_permitted_to_read(logdir)
    port = datalab.utils.pick_unused_port()
    args = ['tensorboard', ('--logdir=' + logdir), ('--port=' + str(port))]
    p = subprocess.Popen(args)
    retry = 10
    while (retry > 0):
        if datalab.utils.is_http_running_on(port):
            basepath = os.environ.get('DATALAB_ENDPOINT_URL', '')
            url = ('%s/_proxy/%d/' % (basepath.rstrip('/'), port))
            html = ('
TensorBoard was started successfully with pid %d. ' % p.pid)
            html += ('Click here to access it.
' % url)
            IPython.display.display_html(html, raw=True)
            return p.pid
        time.sleep(1)
        retry -= 1
    raise Exception('Cannot start TensorBoard.')

Start a TensorBoard instance.

Args:
logdir: the logdir to run TensorBoard on.
Raises:
Exception if the instance cannot be started.


def _compile_function_expression(self, expr: Expression, scope: Dict[(str, TensorFluent)], batch_size: Optional[int]=None, noise: Optional[List[tf.Tensor]]=None) -> TensorFluent:
    etype = expr.etype
    args = expr.args
    if (len(args) == 1):
        etype2func = {'abs': TensorFluent.abs, 'exp': TensorFluent.exp, 'log': TensorFluent.log, 'sqrt': TensorFluent.sqrt, 'cos': TensorFluent.cos, 'sin': TensorFluent.sin, 'tan': TensorFluent.tan, 'acos': TensorFluent.acos, 'arccos': TensorFluent.acos, 'asin': TensorFluent.asin, 'arcsin': TensorFluent.asin, 'atan': TensorFluent.atan, 'arctan': TensorFluent.atan, 'round': TensorFluent.round, 'ceil': TensorFluent.ceil, 'floor': TensorFluent.floor}
        if (etype[1] not in etype2func):
            raise ValueError('Invalid unary function expression:\n{}'.format(expr))
        op = etype2func[etype[1]]
        x = self._compile_expression(args[0], scope, batch_size, noise)
        fluent = op(x)
    else:
        etype2func = {'pow': TensorFluent.pow, 'max': TensorFluent.max, 'min': TensorFluent.min}
        if (etype[1] not in etype2func):
            raise ValueError('Invalid binary function expression:\n{}'.format(expr))
        op = etype2func[etype[1]]
        x = self._compile_expression(args[0], scope, batch_size, noise)
        y = self._compile_expression(args[1], scope, batch_size, noise)
        fluent = op(x, y)
    return fluent

Compile a function expression `expr` into a TensorFluent
in the given `scope` with optional batch size.

Args:
expr (:obj:`rddl2tf.expr.Expression`): A RDDL function expression.
scope (Dict[str, :obj:`rddl2tf.fluent.TensorFluent`]): A fluent scope.
batch_size (Optional[size]): The batch size.

Returns:
:obj:`rddl2tf.fluent.TensorFluent`: The compiled expression as a TensorFluent.


def fixminimized(self, alphabet):

        endstate = len(list(self.states))
        for state in self.states:
            for char in alphabet:
                found = 0
                for arc in state.arcs:
                    if self.isyms.find(arc.ilabel) == char:
                        found = 1
                        break
                if found == 0:
                    self.add_arc(state.stateid, endstate, char)

        self[endstate].final = TropicalWeight(float('inf'))

        for char in alphabet:
            self.add_arc(endstate, endstate, char)

After pyfst minimization,
all unused arcs are removed,
and all sink states are removed.
However this may break compatibility.
Args:
alphabet (list): The input alphabet
Returns:
None


def users_lookupByEmail(self, *, email: str, **kwargs) -> SlackResponse:

        kwargs.update({"email": email})
        return self.api_call("users.lookupByEmail", http_verb="GET", params=kwargs)

Find a user with an email address.

Args:
email (str): An email address belonging to a user in the workspace.
e.g. 'spengler@ghostbusters.example.com'


def sg_mean(tensor, opt):
    r
    return tf.reduce_mean(tensor, axis=opt.axis, keep_dims=opt.keep_dims, name=opt.name)

r"""Computes the mean of elements across axis of a tensor.

See `tf.reduce_mean()` in tensorflow.

Args:
tensor: A `Tensor` (automatically given by chain).
opt:
axis : A tuple/list of integers or an integer. The axis to reduce.
keep_dims: If true, retains reduced dimensions with length 1.
name: If provided, replace current tensor's name.

Returns:
A `Tensor`.


def safe_sum(x, alt_value=(- np.inf), name=None):
    with tf.compat.v1.name_scope(name, 'safe_sum', [x, alt_value]):
        if (not is_list_like(x)):
            raise TypeError('Expected list input.')
        if (not x):
            raise ValueError('Input should not be empty.')
        in_shape = x[0].shape
        x = tf.stack(x, axis=(- 1))
        x = tf.reduce_sum(input_tensor=x, axis=(- 1))
        alt_value = np.array(alt_value, x.dtype.as_numpy_dtype)
        alt_fill = tf.fill(tf.shape(input=x), value=alt_value)
        x = tf.where(tf.math.is_finite(x), x, alt_fill)
        x.set_shape(x.shape.merge_with(in_shape))
        return x

Elementwise adds list members, replacing non-finite results with alt_value.

Typically the `alt_value` is chosen so the `MetropolisHastings`
`TransitionKernel` always rejects the proposal.

Args:
x: Python `list` of `Tensors` to elementwise add.
alt_value: Python scalar used to replace any elementwise sums which would
otherwise be non-finite.
name: Python `str` name prefixed to Ops created by this function.
Default value: `None` (i.e., "safe_sum").

Returns:
safe_sum: `Tensor` representing the elementwise sum of list of `Tensor`s
`x` or `alt_value` where sums are non-finite.

Raises:
TypeError: if `x` is not list-like.
ValueError: if `x` is empty.


def _GetTaskStorageFilePath(self, task):

    filename = '{0:s}.plaso'.format(task.identifier)
    return os.path.join(self._task_storage_path, filename)

Retrieves the path of a task storage file in the temporary directory.

Args:
task (Task): task.

Returns:
str: path of a task storage file in the temporary directory.


def get_column_names(self, X):
    if isinstance(X, pd.DataFrame):
        return X.columns
    return range(X.shape[1])

Return iterable containing columns for the given array X.

Args:
X: `numpy.ndarray` or `pandas.DataFrame`.

Returns:
iterable: columns for the given matrix.


def garbage_collect_exports(export_dir_base, exports_to_keep):
    if (exports_to_keep is None):
        return
    version_paths = []
    for filename in tf_v1.gfile.ListDirectory(export_dir_base):
        path = os.path.join(tf.compat.as_bytes(export_dir_base), tf.compat.as_bytes(filename))
        if ((len(filename) == 10) and filename.isdigit()):
            version_paths.append((int(filename), path))
    oldest_version_path = sorted(version_paths)[:(- exports_to_keep)]
    for (_, path) in oldest_version_path:
        try:
            tf_v1.gfile.DeleteRecursively(path)
        except tf.errors.NotFoundError as e:
            logging.warn('Can not delete %s recursively: %s', path, e)

Deletes older exports, retaining only a given number of the most recent.

Export subdirectories are assumed to be named with monotonically increasing
integers; the most recent are taken to be those with the largest values.

Args:
export_dir_base: the base directory under which each export is in a
versioned subdirectory.
exports_to_keep: Number of exports to keep. Older exports will be garbage
collected. Set to None to disable.


def exists(path):
    filesystem = FileSystems.get_filesystem(path)
    return filesystem.exists(path)

Check if the provided path exists on the FileSystem.

Args:
path: string path that needs to be checked.

Returns: boolean flag indicating if path exists


def limit(self, accountID, **kwargs):
    return self.create(accountID, order=LimitOrderRequest(**kwargs))

Shortcut to create a Limit Order in an Account

Args:
accountID : The ID of the Account
kwargs : The arguments to create a LimitOrderRequest

Returns:
v20.response.Response containing the results from submitting
the request


def Parse(text):

  precondition.AssertType(text, Text)

  if compatibility.PY2:
    text = text.encode("utf-8")

  return yaml.safe_load(text)

Parses a YAML source into a Python object.

Args:
text: A YAML source to parse.

Returns:
A Python data structure corresponding to the YAML source.


def verify(self, obj):

        if self.encoding == 'none' and not isinstance(obj, (bytes, bytearray)):
            raise ValidationError('Byte object was not either bytes or a bytearray', type=obj.__class__.__name__)
        elif self.encoding == 'base64':
            try:
                data = base64.b64decode(obj)
                return data
            except TypeError:
                raise ValidationError("Could not decode base64 encoded bytes", obj=obj)
        elif self.encoding == 'hex':
            try:
                data = binascii.unhexlify(obj)
                return data
            except TypeError:
                raise ValidationError("Could not decode hex encoded bytes", obj=obj)

        return obj

Verify that the object conforms to this verifier's schema

Args:
obj (object): A python object to verify

Returns:
bytes or byterray: The decoded byte buffer

Raises:
ValidationError: If there is a problem verifying the object, a
ValidationError is thrown with at least the reason key set indicating
the reason for the lack of validation.


def extract_class(jar, name):

    with jar.open(name) as entry:
        return LinkableClass(javatools.unpack_class(entry))

Extracts a LinkableClass from a jar.

Args:
jar: An open ZipFile instance.
name: A string containing the binary name of a class.

Raises:
KeyError: The class does not exist in the jar.


def save(self, path=None, complevel=1, complib='zlib'):
    if (path is None):
        path = (self.hexuid + '.hdf5')
    elif os.path.isdir(path):
        path += ((os.sep + self.hexuid) + '.hdf5')
    elif (not (path.endswith('.hdf5') or path.endswith('.hdf'))):
        raise ValueError('File path must have a ".hdf5" or ".hdf" extension.')
    with pd.HDFStore(path, 'w', complevel=complevel, complib=complib) as store:
        store['kwargs'] = pd.Series()
        store.get_storer('kwargs').attrs.metadata = self._rel()
        fc = 0
        for (name, data) in self._data().items():
            if hasattr(data, '_revert_categories'):
                data._revert_categories()
            name = (name[1:] if name.startswith('_') else name)
            if isinstance(data, Field):
                fname = (('FIELD{}_'.format(fc) + name) + '/')
                store[(fname + 'data')] = pd.DataFrame(data)
                for (i, field) in enumerate(data.field_values):
                    ffname = ((fname + 'values') + str(i))
                    if isinstance(field, pd.Series):
                        store[ffname] = pd.Series(field)
                    else:
                        store[ffname] = pd.DataFrame(field)
                fc += 1
            elif isinstance(data, Series):
                s = pd.Series(data)
                if isinstance(data.dtype, pd.types.dtypes.CategoricalDtype):
                    s = s.astype('O')
                store[name] = s
            elif isinstance(data, DataFrame):
                store[name] = pd.DataFrame(data)
            elif isinstance(data, SparseSeries):
                s = pd.SparseSeries(data)
                if isinstance(data.dtype, pd.types.dtypes.CategoricalDtype):
                    s = s.astype('O')
                store[name] = s
            elif isinstance(data, SparseDataFrame):
                store[name] = pd.SparseDataFrame(data)
            else:
                if (hasattr(data, 'dtype') and isinstance(data.dtype, pd.types.dtypes.CategoricalDtype)):
                    data = data.astype('O')
                else:
                    for col in data:
                        if isinstance(data[col].dtype, pd.types.dtypes.CategoricalDtype):
                            data[col] = data[col].astype('O')
                store[name] = data
            if hasattr(data, '_set_categories'):
                data._set_categories()

Save the container as an HDF5 archive.

Args:
path (str): Path where to save the container


def write_jsonl_file(fname, data):
    if (not isinstance(data, list)):
        print('warning: malformed json data for file', fname)
        return
    with open(fname, 'w') as of:
        for row in data:
            if row.strip():
                of.write(('%s\n' % row.strip()))

Writes a jsonl file.

Args:
data: list of json encoded data


def get_pointgroup(self, tolerance=0.3):
    PA = self._get_point_group_analyzer(tolerance=tolerance)
    return PointGroupOperations(PA.sch_symbol, PA.symmops)

Returns a PointGroup object for the molecule.

Args:
tolerance (float): Tolerance to generate the full set of symmetry
operations.

Returns:
:class:`~PointGroupOperations`


def __init__(self, idx):

    self.idx = idx
    self.in_edges = []
    self.out_edges = []

Initialize the Vertex.

Args:
idx: The index of the vertex.


def bounding_box_from(points, i, i1, thr):

    pi = points[i]
    pi1 = points[i1]

    min_lat = min(pi.lat, pi1.lat)
    min_lon = min(pi.lon, pi1.lon)
    max_lat = max(pi.lat, pi1.lat)
    max_lon = max(pi.lon, pi1.lon)

    return min_lat-thr, min_lon-thr, max_lat+thr, max_lon+thr

Creates bounding box for a line segment

Args:
points (:obj:`list` of :obj:`Point`)
i (int): Line segment start, index in points array
i1 (int): Line segment end, index in points array
Returns:
(float, float, float, float): with bounding box min x, min y, max x and max y


def start_worker(node_ip_address, object_store_name, raylet_name, redis_address, worker_path, temp_dir, stdout_file=None, stderr_file=None):
    command = [sys.executable, '-u', worker_path, ('--node-ip-address=' + node_ip_address), ('--object-store-name=' + object_store_name), ('--raylet-name=' + raylet_name), ('--redis-address=' + str(redis_address)), ('--temp-dir=' + temp_dir)]
    process_info = start_ray_process(command, ray_constants.PROCESS_TYPE_WORKER, stdout_file=stdout_file, stderr_file=stderr_file)
    return process_info

This method starts a worker process.

Args:
node_ip_address (str): The IP address of the node that this worker is
running on.
object_store_name (str): The socket name of the object store.
raylet_name (str): The socket name of the raylet server.
redis_address (str): The address that the Redis server is listening on.
worker_path (str): The path of the source code which the worker process
will run.
temp_dir (str): The path of the temp dir.
stdout_file: A file handle opened for writing to redirect stdout to. If
no redirection should happen, then this should be None.
stderr_file: A file handle opened for writing to redirect stderr to. If
no redirection should happen, then this should be None.

Returns:
ProcessInfo for the process that was started.


def run(command, num_retries=1, timeout=(- 1), **kwargs):
    last_error = None
    for _ in range(num_retries):
        try:
            process = Subprocess(command, **kwargs)
            return process.run(timeout)
        except Exception as err:
            last_error = err
    raise last_error

Run a command with optional timeout and retries.

Provides a convenience method for executing a subprocess with
additional error handling.

Arguments:
command (list of str): The command to execute.
num_retries (int, optional): If the subprocess fails, the number of
attempts to execute it before failing.
timeout (float, optional): If positive, the number of seconds to wait
for subprocess completion before failing.
**kwargs: Additional args to pass to Subprocess.__init__()

Returns:
Tuple of (int, str, str): Where the variables represent
(exit status, stdout, stderr).

Raises:
SubprocessError: If the command fails after the given number of
retries.


def monitoring(line, cell=None):
    parser = datalab.utils.commands.CommandParser(prog='monitoring', description='Execute various Monitoring-related operations. Use "%monitoring <command> -h" for help on a specific command.')
    list_parser = parser.subcommand('list', 'List the metrics or resource types in a monitored project.')
    list_metric_parser = list_parser.subcommand('metrics', 'List the metrics that are available through the Monitoring API.')
    list_metric_parser.add_argument('-t', '--type', help='The type of metric(s) to list; can include wildchars.')
    list_metric_parser.add_argument('-p', '--project', help='The project on which to execute the request.')
    list_metric_parser.set_defaults(func=_list_metric_descriptors)
    list_resource_parser = list_parser.subcommand('resource_types', 'List the monitored resource types that are available through the Monitoring API.')
    list_resource_parser.add_argument('-p', '--project', help='The project on which to execute the request.')
    list_resource_parser.add_argument('-t', '--type', help='The resource type(s) to list; can include wildchars.')
    list_resource_parser.set_defaults(func=_list_resource_descriptors)
    list_group_parser = list_parser.subcommand('groups', 'List the Stackdriver groups in this project.')
    list_group_parser.add_argument('-p', '--project', help='The project on which to execute the request.')
    list_group_parser.add_argument('-n', '--name', help='The name of the group(s) to list; can include wildchars.')
    list_group_parser.set_defaults(func=_list_groups)
    return datalab.utils.commands.handle_magic_line(line, cell, parser)

Implements the monitoring cell magic for ipython notebooks.

Args:
line: the contents of the storage line.
Returns:
The results of executing the cell.


def int64_gauge(urn, metric, ptransform=None) -> metrics_pb2.MonitoringInfo:
    labels = create_labels(ptransform=ptransform)
    if isinstance(metric, int):
        value = metric
        time_ms = int(time.time()) * 1000
    else:
        raise TypeError('Expected int metric type but received %s with value %s' % (type(metric), metric))
    coder = coders.VarIntCoder()
    payload = coder.encode(time_ms) + coder.encode(value)
    return create_monitoring_info(urn, LATEST_INT64_TYPE, payload, labels)

Return the gauge monitoring info for the URN, metric and labels.

Args:
urn: The URN of the monitoring info/metric.
metric: An int representing the value. The current time will be used for
the timestamp.
ptransform: The ptransform id used as a label.


def _call_concrete_function(function, inputs):
    expected_structure = function.graph.structured_input_signature
    flatten_inputs = nest.flatten_up_to(expected_structure, inputs, expand_composites=True)
    flatten_expected = nest.flatten(expected_structure, expand_composites=True)
    tensor_inputs = []
    for arg, expected in zip(flatten_inputs, flatten_expected):
        if isinstance(expected, tensor.TensorSpec):
            tensor_inputs.append(ops.convert_to_tensor(arg, dtype_hint=expected.dtype))
        elif isinstance(expected, resource_variable_ops.VariableSpec):
            tensor_inputs.append(arg.handle)
    result = function._call_flat(tensor_inputs, function.captured_inputs)
    if isinstance(result, ops.Operation):
        return None
    return result

Calls a restored Function with structured inputs.

This differs from `function.__call__` in that inputs and outputs are
structured and that it casts inputs to tensors if needed.

Note: this does not checks that non-tensor inputs match. That should be
done before via `_concrete_function_callable_with`.

Args:
function: ConcreteFunction to call.
inputs: Structured inputs compatible with
`function.graph.structured_input_signature`.

Returns:
The structured function output.


def method_not_allowed(cls, errors=None):

        if cls.expose_status:
            cls.response.content_type = 'application/json'
            cls.response._status_line = '405 Method Not Allowed'

        return cls(405, None, errors).to_json

Shortcut API for HTTP 405 `Method not allowed` response.

Args:
errors (list): Response key/value data.

Returns:
WSResponse Instance.


def most_frequent(self, k):

    word_count = {w:self.word_count[w] for w in self.words[:k]}
    return CountedVocabulary(word_count=word_count)

Returns a vocabulary with the most frequent `k` words.

Args:
k (integer): specifies the top k most frequent words to be returned.


def get_cached_filename(self, filename, extention, settings_list=None):

        cached_name = "_".join([filename, self.get_hash()])
        return ".".join([cached_name, extention])

Creates a filename with md5 cache string based on settings list

Args:
filename (str): the filename without extention
extention (str): the file extention without dot. (i.e. 'pkl')
settings_list (dict|list): the settings list as list (optional)
NB! The dictionaries have to be sorted or hash id will change
arbitrarely.


def _log_band_gap_information(bs):
    bg_data = bs.get_band_gap()
    if (not bg_data['direct']):
        logging.info('Indirect band gap: {:.3f} eV'.format(bg_data['energy']))
    direct_data = bs.get_direct_band_gap_dict()
    if bs.is_spin_polarized:
        direct_bg = min((spin_data['value'] for spin_data in direct_data.values()))
        logging.info('Direct band gap: {:.3f} eV'.format(direct_bg))
        for (spin, spin_data) in direct_data.items():
            direct_kindex = spin_data['kpoint_index']
            direct_kpoint = bs.kpoints[direct_kindex].frac_coords
            direct_kpoint = kpt_str.format(k=direct_kpoint)
            eq_kpoints = bs.get_equivalent_kpoints(direct_kindex)
            k_indices = ', '.join(map(str, eq_kpoints))
            b_indices = ', '.join([str((i + 1)) for i in spin_data['band_indices']])
            logging.info('  {}:'.format(spin.name.capitalize()))
            logging.info('    k-point: {}'.format(direct_kpoint))
            logging.info('    k-point indices: {}'.format(k_indices))
            logging.info('    Band indices: {}'.format(b_indices))
    else:
        direct_bg = direct_data[Spin.up]['value']
        logging.info('Direct band gap: {:.3f} eV'.format(direct_bg))
        direct_kindex = direct_data[Spin.up]['kpoint_index']
        direct_kpoint = kpt_str.format(k=bs.kpoints[direct_kindex].frac_coords)
        k_indices = ', '.join(map(str, bs.get_equivalent_kpoints(direct_kindex)))
        b_indices = ', '.join([str((i + 1)) for i in direct_data[Spin.up]['band_indices']])
        logging.info('  k-point: {}'.format(direct_kpoint))
        logging.info('  k-point indices: {}'.format(k_indices))
        logging.info('  Band indices: {}'.format(b_indices))

Log data about the direct and indirect band gaps.

Args:
bs (:obj:`~pymatgen.electronic_structure.bandstructure.BandStructureSymmLine`):


def install(self, connection, partition, table_name=None, columns=None, materialize=False, logger=None):
    partition.localize()
    self._add_partition(connection, partition)
    fdw_table = partition.vid
    view_table = '{}_v'.format(fdw_table)
    if materialize:
        with connection.cursor() as cursor:
            view_exists = self._relation_exists(connection, view_table)
            if view_exists:
                logger.debug('Materialized view of the partition already exists.\n    partition: {}, view: {}'.format(partition.name, view_table))
            else:
                query = 'CREATE MATERIALIZED VIEW {} AS SELECT * FROM {};'.format(view_table, fdw_table)
                logger.debug('Creating new materialized view of the partition.\n    partition: {}, view: {}, query: {}'.format(partition.name, view_table, query))
                cursor.execute(query)
                cursor.execute('COMMIT;')
    final_table = (view_table if materialize else fdw_table)
    with connection.cursor() as cursor:
        view_q = 'CREATE VIEW IF NOT EXISTS {} AS SELECT * FROM {} '.format(partition.vid, final_table)
        cursor.execute(view_q)
        cursor.execute('COMMIT;')
    return partition.vid

Creates FDW or materialize view for given partition.

Args:
connection: connection to postgresql
partition (orm.Partition):
materialize (boolean): if True, create read-only table. If False create virtual table.

Returns:
str: name of the created table.


def linear_interpolate(tensor1, tensor2, coeffs):

  interp_tensors = []
  for coeff in coeffs:
    interp_tensor = tensor1 + coeff * (tensor2 - tensor1)
    interp_tensors.append(interp_tensor)
  return tf.concat(interp_tensors, axis=0)

Linearly interpolate between two tensors at coeff.

Args:
tensor1: 4-D Tensor, shape=(NHWC)
tensor2: 4-D Tensor, shape=(NHWC)
coeffs: list of floats.
Returns:
interp_latents: 5-D Tensor, with interp_latents[i] representing
interpolations at coeffs[i].
shape=(len(coeffs), NHWC)


def CheckAltTokens(filename, clean_lines, linenum, error):
    line = clean_lines.elided[linenum]
    if Match('^\\s*
        return
    if ((line.find('') >= 0)):
        return
    for match in _ALT_TOKEN_REPLACEMENT_PATTERN.finditer(line):
        error(filename, linenum, 'readability/alt_tokens', 2, ('Use operator %s instead of %s' % (_ALT_TOKEN_REPLACEMENT[match.group(1)], match.group(1))))

Check alternative keywords being used in boolean expressions.

Args:
filename: The name of the current file.
clean_lines: A CleansedLines instance containing the file.
linenum: The number of the line to check.
error: The function to call with any errors found.


def remove(path):

    if os.path.isdir(path):
        return __rmtree(path)
    else:
        return __rmfile(path)

Delete a file or directory.

Args:
path (str): Path to the file or directory that needs to be deleted.

Returns:
bool: True if the operation is successful, False otherwise.


def parse(self, **global_args):
    if (self.build_file not in ParseContext._parsed):
        butcher_context = {}
        for str_to_exec in self._strs_to_exec:
            ast = compile(str_to_exec, '<string>', 'exec')
            exec_function(ast, butcher_context)
        with ParseContext.activate(self):
            startdir = os.path.abspath(os.curdir)
            try:
                os.chdir(self.build_file.path_on_disk)
                if (self.build_file not in ParseContext._parsed):
                    ParseContext._parsed.add(self.build_file)
                    eval_globals = copy.copy(butcher_context)
                    eval_globals.update({'ROOT_DIR': self.build_file.path_on_disk, '__file__': 'bogus please fix this'})
                    eval_globals.update(global_args)
                    exec_function(self.build_file.code, eval_globals)
            finally:
                os.chdir(startdir)

Entry point to parsing a BUILD file.

Args:
**global_args: Variables to include in the parsing environment.


def variable_type(self, variable):
    var_type = 'String'
    if (variable is not None):
        variable = variable.strip()
        if re.match(self._variable_match, variable):
            var_type = re.search(self._variable_parse, variable).group(4)
    return var_type

Get the Type from the variable string or default to String type.

The default type is "String" for those cases when the input variable is
contains not "DB variable" and is just a String.

**Example Variable**::

#App:1234:output!StringArray returns **StringArray**

**Example String**::

"My Data" returns **String**

Args:
variable (string): The variable to be parsed

Returns:
(string): The variable type.


def FillDepressions(dem, epsilon=False, in_place=False, topology='D8'):
    if (type(dem) is not rdarray):
        raise Exception('A richdem.rdarray or numpy.ndarray is required!')
    if (topology not in ['D8', 'D4']):
        raise Exception('Unknown topology!')
    if (not in_place):
        dem = dem.copy()
    _AddAnalysis(dem, 'FillDepressions(dem, epsilon={0})'.format(epsilon))
    demw = dem.wrap()
    if epsilon:
        if (topology == 'D8'):
            _richdem.rdPFepsilonD8(demw)
        elif (topology == 'D4'):
            _richdem.rdPFepsilonD4(demw)
    elif (topology == 'D8'):
        _richdem.rdFillDepressionsD8(demw)
    elif (topology == 'D4'):
        _richdem.rdFillDepressionsD4(demw)
    dem.copyFromWrapped(demw)
    if (not in_place):
        return dem

Fills all depressions in a DEM.

Args:
dem     (rdarray): An elevation model
epsilon (float):   If True, an epsilon gradient is imposed to all flat regions.
This ensures that there is always a local gradient.
in_place (bool):   If True, the DEM is modified in place and there is
no return; otherwise, a new, altered DEM is returned.
topology (string): A topology indicator

Returns:
DEM without depressions.


def getHeaders(self):
    headers = self._impl.getHeaders()
    return tuple((headers.getIndex(i) for i in range(self._impl.getNumCols())))

Get the headers of this DataFrame.

Returns:
The headers of this DataFrame.


def PyParseRangeCheck(lower_bound, upper_bound):

  def CheckRange(string, location, tokens):

    try:
      check_number = tokens[0]
    except IndexError:
      check_number = -1

    if check_number < lower_bound:
      raise pyparsing.ParseException(
          'Value: {0:d} precedes lower bound: {1:d}'.format(
              check_number, lower_bound))

    if check_number > upper_bound:
      raise pyparsing.ParseException(
          'Value: {0:d} exceeds upper bound: {1:d}'.format(
              check_number, upper_bound))

  return CheckRange

Verify that a number is within a defined range.

This is a callback method for pyparsing setParseAction
that verifies that a read number is within a certain range.

To use this method it needs to be defined as a callback method
in setParseAction with the upper and lower bound set as parameters.

Args:
lower_bound (int): lower bound of the range.
upper_bound (int): upper bound of the range.

Returns:
Function: callback method that can be used by pyparsing setParseAction.


def _rolling_window(self, window_length, func1d, step=1, return_rolled=False):

        if window_length % 2 == 0:
            window_length += 1

        shape = self.shape[:-1] + (self.shape[-1], window_length)
        strides = self.strides + (step*self.strides[-1],)
        data = np.nan_to_num(self)
        data = np.pad(data, int(step*window_length
        rolled = np.lib.stride_tricks.as_strided(data,
                                                 shape=shape,
                                                 strides=strides)
        result = np.apply_along_axis(func1d, -1, rolled)
        result[np.isnan(self)] = np.nan

        if return_rolled:
            return result, rolled
        else:
            return result

Private function. Smoother for other smoothing/conditioning functions.

Args:
window_length (int): the window length.
func1d (function): a function that takes a 1D array and returns a
scalar.
step (int): if you want to skip samples in the shifted versions.
Don't use this for smoothing, you will get strange results.

Returns:
ndarray: the resulting array.


def project_group_token(self, group_tokens: tf.Tensor) -> tf.Tensor:
    projected_group_tokens = self.mlp_inter(group_tokens)
    projected_group_tokens = self.norm_post_tokens(projected_group_tokens)
    return projected_group_tokens

Args:
group_tokens (tf.Tensor): group tokens, [batch_size, num_group_tokens, channels]

Returns:
projected_group_tokens (tf.Tensor): [batch_size, num_output_groups, channels]


def parseSemver(text):
    txt = text.strip().lstrip('vV')
    ret = {}
    m = semver_re.match(txt)
    if (not m):
        return None
    d = m.groupdict()
    ret['major'] = int(d.get('maj'))
    ret['minor'] = int(d.get('min'))
    ret['patch'] = int(d.get('pat'))
    pre = d.get('pre')
    bld = d.get('bld')
    if pre:
        parts = pre.split('.')
        for part in parts:
            if (not part):
                return None
            try:
                int(part)
            except ValueError:
                continue
            else:
                if ((part[0] == '0') and (len(part) > 1)):
                    return None
        ret['pre'] = pre
    if bld:
        parts = bld.split('.')
        for part in parts:
            if (not part):
                return None
        ret['build'] = bld
    return ret

Parse a Semantic Version string into is component parts.

Args:
text (str): A text string to parse into semver components. This string has whitespace and leading 'v'
characters stripped off of it.

Examples:
Parse a string into it semvar parts::

parts = parseSemver('v1.2.3')

Returns:
dict: The dictionary will contain the keys 'major', 'minor' and 'patch' pointing to integer values.
The dictionary may also contain keys for 'build' and 'pre' information if that data is parsed out
of a semver string. None is returned if the string is not a valid Semver string.


def get_execution_role(sagemaker_session=None):

    if not sagemaker_session:
        sagemaker_session = Session()
    arn = sagemaker_session.get_caller_identity_arn()

    if ':role/' in arn:
        return arn
    message = 'The current AWS identity is not a role: {}, therefore it cannot be used as a SageMaker execution role'
    raise ValueError(message.format(arn))

Return the role ARN whose credentials are used to call the API.
Throws an exception if
Args:
sagemaker_session(Session): Current sagemaker session
Returns:
(str): The role ARN


def createEditor(self, parent, option, index):

        editor = QtGui.QLineEdit(parent)
        return editor

Returns the widget used to edit the item specified by index for editing. The parent widget and style option are used to control how the editor widget appears.

Args:
parent (QWidget): parent widget.
option (QStyleOptionViewItem): controls how editor widget appears.
index (QModelIndex): model data index.


def validator(sample: rd.RepresentativeSample) -> rd.RepresentativeSample:
    if not isinstance(sample, Mapping):
        raise ValueError(f'Invalid representative sample type. Provide a mapping (usually a dict) of {{input_key: input_value}}. Got type: {type(sample)} instead.')
    if set(sample.keys()) != expected_input_keys:
        raise KeyError(f'Invalid input keys for representative sample. The function expects input keys of: {set(expected_input_keys)}. Got: {set(sample.keys())}. Please provide correct input keys for representative samples.')
    return sample

Validates a single instance of representative sample.

This provides a simple check for `sample` that this is a mapping of
{input_key: input_value}.

Args:
sample: A `RepresentativeSample` to validate.

Returns:
`sample` iff it is valid.

Raises:
ValueError: iff the sample isn't an instance of `Mapping`.
KeyError: iff the sample does not have the set of input keys that match
the input keys of the function.


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 None:
        return [1] + [0] * len(token_ids_0) + [1]
    return [1] + [0] * len(token_ids_0) + [1, 1] + [0] * len(token_ids_1) + [1]

Args:
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.
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 threshold(x, threshold, default_value):
    return ops.threshold(x, threshold, default_value)

Threshold activation function.

It is defined as:

`threshold(x) = x` if `x > threshold`,
`threshold(x) = default_value` otherwise.

Args:
x: Input tensor.
threshold: The value that decides when to retain or replace x.
default_value: Value to assign when `x <= threshold`.


def get_repo(task, source_env_prefix):

    repo = _extract_from_env_in_payload(task, source_env_prefix + '_HEAD_REPOSITORY')
    if repo is not None:
        repo = repo.rstrip('/')
    return repo

Get the repo for a task.

Args:
task (ChainOfTrust or LinkOfTrust): the trust object to inspect
source_env_prefix (str): The environment variable prefix that is used
to get repository information.

Returns:
str: the source url.
None: if not defined for this task.


def preprocessing_fn(inputs):
    outputs = {}
    for key in taxi.DENSE_FLOAT_FEATURE_KEYS:
        outputs[taxi.transformed_name(key)] = transform.scale_to_z_score(_fill_in_missing(inputs[key]))
    for key in taxi.VOCAB_FEATURE_KEYS:
        outputs[taxi.transformed_name(key)] = transform.compute_and_apply_vocabulary(_fill_in_missing(inputs[key]), top_k=taxi.VOCAB_SIZE, num_oov_buckets=taxi.OOV_SIZE)
    for key in taxi.BUCKET_FEATURE_KEYS:
        outputs[taxi.transformed_name(key)] = transform.bucketize(_fill_in_missing(inputs[key]), taxi.FEATURE_BUCKET_COUNT)
    for key in taxi.CATEGORICAL_FEATURE_KEYS:
        outputs[taxi.transformed_name(key)] = _fill_in_missing(inputs[key])
    taxi_fare = _fill_in_missing(inputs[taxi.FARE_KEY])
    tips = _fill_in_missing(inputs[taxi.LABEL_KEY])
    outputs[taxi.transformed_name(taxi.LABEL_KEY)] = tf.where(tf.is_nan(taxi_fare), tf.cast(tf.zeros_like(taxi_fare), tf.int64), tf.cast(tf.greater(tips, tf.multiply(taxi_fare, tf.constant(0.2))), tf.int64))
    return outputs

tf.transform's callback function for preprocessing inputs.

Args:
inputs: map from feature keys to raw not-yet-transformed features.

Returns:
Map from string feature key to transformed feature operations.


def __init__(self, resolver_context, file_object=None):

    super(DataRange, self).__init__(resolver_context)
    self._current_offset = 0
    self._file_object = file_object

    if file_object:
      self._file_object_set_in_init = True
      self._range_offset = 0
      self._range_size = file_object.get_size()
    else:
      self._file_object_set_in_init = False
      self._range_offset = -1
      self._range_size = -1

Initializes a file-like object.

If the file-like object is chained do not separately use the parent
file-like object.

Args:
resolver_context (Context): resolver context.
file_object (Optional[file]): parent file-like object.


def fetch(self, addon_id, data={}, **kwargs):

        return super(Addon, self).fetch(addon_id, data, **kwargs)

Fetch addon for given Id

Args:
addon_id : Id for which addon object has to be retrieved

Returns:
addon dict for given subscription Id


def get_context(self, max_frames=None, missing_entities=[]):
    if ((not max_frames) or (max_frames > len(self.frame_stack))):
        max_frames = len(self.frame_stack)
    missing_entities = list(missing_entities)
    context = []
    for i in xrange(max_frames):
        frame_entities = [entity.copy() for entity in self.frame_stack[i].entities]
        for entity in frame_entities:
            entity['confidence'] = (entity.get('confidence', 1.0) / (2.0 + i))
        context += frame_entities
    result = []
    if (len(missing_entities) > 0):
        for entity in context:
            if (entity.get('data') in missing_entities):
                result.append(entity)
                missing_entities.remove(entity.get('data'))
    else:
        result = context
    return result

Constructs a list of entities from the context.

Args:
max_frames(int): maximum number of frames to look back
missing_entities(list of str): a list or set of tag names, as strings

Returns:
list: a list of entities


def mean_pooling(self, model_output, attention_mask):
    token_embeddings = model_output[0]
    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
    return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-09)

The function calculates the mean of token embeddings

Args:
model_output: The output of the model.
attention_mask: This is a tensor that contains 1s for all input tokens and
0s for all padding tokens.

Returns:
The mean of the token embeddings.


def by_location(self, location, cc=None):

        header, content = self._http_request(self.BASE_URL, location=location, cc=cc)
        return json.loads(content)

Perform a Yelp Neighborhood API Search based on a location specifier.

Args:
location - textual location specifier of form: "address, city, state or zip, optional country"
cc       - ISO 3166-1 alpha-2 country code. (Optional)


def show_backref(target, max_depth=3):
    if objgraph is None:
        raise NotImplementedError('objgraph is not installed.')
    string_io = io.StringIO()
    objgraph.show_backrefs(target, max_depth=max_depth, output=string_io)
    graph = string_io.getvalue()
    string_io.close()
    return graph

Returns a dot graph of all the objects that are referencing the target.

A object referencing graph is useful to debug memory leak like circular
reference. objgraph provides a good visualization of the memory graph than
most python built-in utilities like gc.get_referrers(), which are not
human-readable sometimes.

The dot graph will be written to a string IO object, and can be rendered with
graphviz in operating system.
E.g. dot -Tpng {$dot_graph} -o output.png
Args:
target: The target object for the memory graph.
max_depth: The maximum depth of the graph. By default 3 layers of references
are used. Increases this a lot may result in the graph growing too big.

Returns:
A string that contains the object reference graph.
Raises:
NotImplementedError: if objgraph is not installed.


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

    mru_values_dict = {}
    for subkey in registry_key.GetSubkeys():
      username_value = subkey.GetValueByName('UsernameHint')

      if (username_value and username_value.data and
          username_value.DataIsString()):
        username = username_value.GetDataAsObject()
      else:
        username = 'N/A'

      mru_values_dict[subkey.name] = username

      event_data = windows_events.WindowsRegistryEventData()
      event_data.key_path = subkey.path
      event_data.offset = subkey.offset
      event_data.regvalue = {'Username hint': username}
      event_data.source_append = self._SOURCE_APPEND

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

    event_data = windows_events.WindowsRegistryEventData()
    event_data.key_path = registry_key.path
    event_data.offset = registry_key.offset
    event_data.regvalue = mru_values_dict
    event_data.source_append = self._SOURCE_APPEND

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

Extracts events from a Terminal Server Client Windows Registry key.

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


def get_victim_web_asset(self, main_type, sub_type, unique_id, asset_id, params=None):

        params = params or {}

        return self.victim_web_asset(main_type, sub_type, unique_id, asset_id, params=params)

Args:
main_type:
sub_type:
unique_id:
asset_id:
params:

Return:


def forward(self, g_values: torch.Tensor) -> torch.Tensor:
    p_one_unique_token, p_two_unique_tokens = self._compute_latents(g_values)
    return 0.5 * ((g_values + 0.5) * p_two_unique_tokens + p_one_unique_token)

Computes the likelihoods P(g_values|watermarked).

Args:
g_values (`torch.Tensor` of shape `(batch_size, seq_len, watermarking_depth)`):
g-values (values 0 or 1)

Returns:
p(g_values|watermarked) of shape [batch_size, seq_len, watermarking_depth].


def _bitResponseToValue(bytestring):
    _checkString(bytestring, description='bytestring', minlength=1, maxlength=1)
    RESPONSE_ON = '\x01'
    RESPONSE_OFF = '\x00'
    if (bytestring == RESPONSE_ON):
        return 1
    elif (bytestring == RESPONSE_OFF):
        return 0
    else:
        raise ValueError('Could not convert bit response to a value. Input: {0!r}'.format(bytestring))

Convert a response string to a numerical value.

Args:
bytestring (str): A string of length 1. Can be for example ``\\x01``.

Returns:
The converted value (int).

Raises:
TypeError, ValueError


def tseries_between(self, tstart=None, tend=None):

        if self.tseries is None:
            return None

        ndat = self.tseries.shape[0]

        if tstart is None:
            istart = 0
        else:
            igm = 0
            igp = ndat - 1
            while igp - igm > 1:
                istart = igm + (igp - igm)
                if self.tseries.iloc[istart]['t'] >= tstart:
                    igp = istart
                else:
                    igm = istart
            istart = igp

        if tend is None:
            iend = None
        else:
            igm = 0
            igp = ndat - 1
            while igp - igm > 1:
                iend = igm + (igp - igm)
                if self.tseries.iloc[iend]['t'] > tend:
                    igp = iend
                else:
                    igm = iend
            iend = igm + 1

        return self.tseries.iloc[istart:iend]

Return time series data between requested times.

Args:
tstart (float): starting time. Set to None to start at the
beginning of available data.
tend (float): ending time. Set to None to stop at the end of
available data.
Returns:
:class:`pandas.DataFrame`: slice of :attr:`tseries`.


def count(cls, cur, table:str, where_keys: list=None):

        if where_keys:
            where_clause, values = cls._get_where_clause_with_values(where_keys)
            query = cls._count_query_where.format(table, where_clause)
            q, t = query, values
        else:
            query = cls._count_query.format(table)
            q, t = query, ()
        yield from cur.execute(q, t)
        result = yield from cur.fetchone()
        return int(result[0])

gives the number of records in the table

Args:
table: a string indicating the name of the table

Returns:
an integer indicating the number of records in the table


def _postprocess_flat_outputs(outputs: Any, need_spmd_partitioning: bool) -> Tuple[List[Optional[core_types.Tensor]], List[ops.Operation], List[Any]]:
    if outputs is None:
        outputs = tuple()
    pack_template = nest.flatten(outputs, expand_composites=False)
    outputs = nest.flatten(outputs, expand_composites=True)
    outputs += (control_flow_ops.no_op(),)
    maybe_convert = lambda x: None if x is None else ops.convert_to_tensor(x)
    try:
        if need_spmd_partitioning:
            outputs = [o if isinstance(o, ops.Operation) else maybe_convert(o) for o in outputs]
        else:
            with ops.device(core(0)):
                outputs = [o if isinstance(o, ops.Operation) else maybe_convert(o) for o in outputs]
    except Exception as e:
        raise ValueError(f'TPU function return values must all either be Operations or convertible to Tensors. Got error: {e}')
    output_operations = [o for o in outputs if isinstance(o, ops.Operation)]
    output_tensors = [o for o in outputs if not isinstance(o, ops.Operation)]
    if outputs != output_tensors + output_operations:
        raise ValueError('TPU functions must return zero-or more Tensor values followed by zero or more Operations.')
    if len(output_operations) > 1:
        pack_template = pack_template[:1 - len(output_operations)]
    new_output_tensors = []
    for t in output_tensors:
        if t is None:
            new_output_tensors.append(None)
        elif need_spmd_partitioning:
            o = array_ops.identity(t)
            o.op._set_attr('_tpu_output_identity', attr_value_pb2.AttrValue(b=True))
            new_output_tensors.append(o)
        else:
            with ops.device(t.device if t.device else core(0)):
                o = array_ops.identity(t)
                o.op._set_attr('_tpu_output_identity', attr_value_pb2.AttrValue(b=True))
                new_output_tensors.append(o)
    return (new_output_tensors, output_operations, pack_template)

Validates non-flat outputs, add backs device assignments and other attrs.

Args:
outputs: Output from `computation` inside `tpu.rewrite`.
need_spmd_partitioning: Whether XLA SPMD partitioning is needed.

Returns:
- Tensors extracted from outputs.
- Operations extracted from outputs.
- A pack template for use with nest.pack_sequence_as to pack the tensors.


def HandleMessageBundles(self, request_comms, response_comms):
    (messages, source, timestamp) = self._communicator.DecodeMessages(request_comms)
    now = time.time()
    if messages:
        self.ReceiveMessages(source, messages)
    required_count = max(0, (self.max_queue_size - request_comms.queue_size))
    tasks = []
    message_list = rdf_flows.MessageList()
    if ((time.time() - now) < 10):
        tasks = self.DrainTaskSchedulerQueueForClient(source, required_count)
        message_list.job = tasks
    self._communicator.EncodeMessages(message_list, response_comms, destination=source, timestamp=timestamp, api_version=request_comms.api_version)
    return (source, len(messages))

Processes a queue of messages as passed from the client.

We basically dispatch all the GrrMessages in the queue to the task scheduler
for backend processing. We then retrieve from the TS the messages destined
for this client.

Args:
request_comms: A ClientCommunication rdfvalue with messages sent by the
client. source should be set to the client CN.
response_comms: A ClientCommunication rdfvalue of jobs destined to this
client.

Returns:
tuple of (source, message_count) where message_count is the number of
messages received from the client with common name source.


def scatterplot_matrix(df, features, downsample_frac=None, figsize=(15, 15)):

    if downsample_frac:
        df = df.sample(frac=downsample_frac)

    plt.figure(figsize=figsize)
    sns.pairplot(df[features], hue='target')
    plt.show()

Plot a scatterplot matrix for a list of features, colored by target value.

Example: `scatterplot_matrix(X, X.columns.tolist(), downsample_frac=0.01)`

Args:
df: Pandas dataframe containing the target column (named 'target').
features: The list of features to include in the correlation plot.
downsample_frac: Dataframe downsampling rate (0.1 to include 10% of the dataset).
figsize: The size of the plot.


def get_module(module_abs_import):

    logger.debug("starting")
    logger.debug(f"loading module {module_abs_import}")
    try:
        imported_module = importlib.import_module(module_abs_import)
        logger.debug("done")
        return imported_module
    except ModuleNotFoundError as err:
        msg = ("The module doesn't exist. Looking for a file like this: "
               f"{module_abs_import}")

        extended_msg = (f"{module_abs_import}.py should be in your working "
                        "dir or it should be installed to the python path."
                        "\nIf you have 'package.sub.mod' your current working "
                        "dir should contain ./package/sub/mod.py\n"
                        "If you specified 'mymodulename', your current "
                        "working dir should contain ./mymodulename.py\n"
                        "If the module is not in your current working dir, it "
                        "must exist in your current python path - so you "
                        "should have run pip install or setup.py")
        logger.error(msg)
        raise PyModuleNotFoundError(extended_msg) from err

Use importlib to get the module dynamically.

Get instance of the module specified by the module_abs_import.
This means that module_abs_import must be resolvable from this package.

Args:
module_abs_import: string. Absolute name of module to import.

Raises:
PyModuleNotFoundError: if module not found.


def get_qos_aggregated_configuration(self):
    uri = '{}{}'.format(self.data['uri'], self.QOS_AGGREGATED_CONFIGURATION)
    return self._helper.do_get(uri)

Gets the QoS aggregated configuration for the logical interconnect.

Returns:
dict: QoS Configuration.


def _length(self):
    self._build_chunk_headers()
    length = 0
    if self._data:
        for field in self._data:
            length += len(self._chunk_headers[field])
            length += len(self._data[field])
            length += 2
    if self._files:
        for field in self._files:
            length += len(self._chunk_headers[field])
            length += self._file_size(field)
            length += 2
    length += len(self.boundary)
    length += 6
    return length

Returns total length for this request.

Returns:
int. Length


class _TrainingTarget(object):

    def __init__(self, target, feedable=False, skip_target_weights=True):
        self._target = target
        self._feedable = feedable
        self._skip_target_weights = skip_target_weights

    @property
    def target(self):
        return self._target

    @property
    def feedable(self):
        return self._feedable

    @property
    def skip_target_weights(self):
        return self._skip_target_weights

Container for a target tensor (y_true) and its metadata (shape, loss...).

Args:
target: A target tensor for the model. It may be `None` if the
output is excluded from loss computation. It is still kept as None
since each output of the model should have a corresponding target. If
the target is None, the rest of the attributes will be None as well.
feedable: Boolean, whether the target is feedable (requires data to be
passed in `fit` or `train_on_batch`), or not (model compiled with
`target_tensors` argument).
skip_target_weights: Boolean, whether the target should be skipped during
weights calculation.