def Func(arg_0, **arg_1):
    """Generates a URL to the given endpoint with the method provided.

    Variable arguments that are unknown to the target endpoint are appended
    to the generated URL as query arguments.  If the value of a query argument
    is `None`, the whole pair is skipped.  In case blueprints are active
    you can shortcut references to the same blueprint by prefixing the
    local endpoint with a dot (``.``).

    This will reference the index function local to the current blueprint::

        Func('.index')

    For more information, head over to the :ref:`Quickstart <url-building>`.

    To integrate applications, :class:`Flask` has a hook to intercept URL build
    errors through :attr:`Flask.build_error_handler`.  The `Func` function
    results in a :exc:`~werkzeug.routing.BuildError` when the current app does
    not have a URL for the given endpoint and values.  When it does, the
    :data:`~flask.current_app` calls its :attr:`~Flask.build_error_handler` if
    it is not `None`, which can return a string to use as the result of
    `Func` (instead of `Func`'s default to raise the
    :exc:`~werkzeug.routing.BuildError` exception) or re-raise the exception.
    An example::

        def external_url_handler(error, endpoint, **values):
            "Looks up an external URL when `Func` cannot build a URL."
            # This is an example of hooking the build_error_handler.
            # Here, lookup_url is some utility function you've built
            # which looks up the endpoint in some external URL registry.
            url = lookup_url(endpoint, **values)
            if url is None:
                # External lookup did not have a URL.
                # Re-raise the BuildError, in context of original traceback.
                exc_type, exc_value, tb = sys.exc_info()
                if exc_value is error:
                    raise exc_type, exc_value, tb
                else:
                    raise error
            # Func will use this result, instead of raising BuildError.
            return url

        app.build_error_handler = external_url_handler

    Here, `error` is the instance of :exc:`~werkzeug.routing.BuildError`, and
    `endpoint` and `**values` are the arguments passed into `Func`.  Note
    that this is for building URLs outside the current application, and not for
    handling 404 NotFound errors.

    .. versionadded:: 0.10
       The `_scheme` parameter was added.

    .. versionadded:: 0.9
       The `_anchor` and `_method` parameters were added.

    .. versionadded:: 0.9
       Calls :meth:`Flask.handle_build_error` on
       :exc:`~werkzeug.routing.BuildError`.

    :param endpoint: the endpoint of the URL (name of the function)
    :param values: the variable arguments of the URL rule
    :param _external: if set to `True`, an absolute URL is generated. Server
      address can be changed via `SERVER_NAME` configuration variable which
      defaults to `localhost`.
    :param _scheme: a string specifying the desired URL scheme. The `_external`
      parameter must be set to `True` or a `ValueError` is raised.
    :param _anchor: if provided this is added as anchor to the URL.
    :param _method: if provided this explicitly specifies an HTTP method.
    """
    arg_2 = _app_ctx_stack.top
    arg_3 = _request_ctx_stack.top
    if arg_2 is None:
        raise RuntimeError('Attempted to generate a URL without the '
                           'application context being pushed. This has to be '
                           'executed when application context is available.')

    # If request specific information is available we have some extra
    # features that support "relative" urls.
    if arg_3 is not None:
        arg_4 = arg_3.url_adapter
        arg_5 = request.blueprint
        if not arg_3.request._is_old_module:
            if arg_0[:1] == '.':
                if arg_5 is not None:
                    arg_0 = arg_5 + arg_0
                else:
                    arg_0 = arg_0[1:]
        else:
            # TODO: get rid of this deprecated functionality in 1.0
            if '.' not in arg_0:
                if arg_5 is not None:
                    arg_0 = arg_5 + '.' + arg_0
            elif arg_0.startswith('.'):
                arg_0 = arg_0[1:]
        arg_6 = arg_1.pop('_external', False)

    # Otherwise go with the url adapter from the appctx and make
    # the urls external by default.
    else:
        arg_4 = arg_2.url_adapter
        if arg_4 is None:
            raise RuntimeError('Application was not able to create a URL '
                               'adapter for request independent URL generation. '
                               'You might be able to fix this by setting '
                               'the SERVER_NAME config variable.')
        arg_6 = arg_1.pop('_external', True)

    arg_7 = arg_1.pop('_anchor', None)
    arg_8 = arg_1.pop('_method', None)
    arg_9 = arg_1.pop('_scheme', None)
    arg_2.app.inject_url_defaults(arg_0, arg_1)

    if arg_9 is not None:
        if not arg_6:
            raise ValueError('When specifying _scheme, _external must be True')
        arg_4.url_scheme = arg_9

    try:
        arg_11 = arg_4.build(arg_0, arg_1, arg_8=arg_8,
                               force_external=arg_6)
    except BuildError as error:
        # We need to inject the values again so that the app callback can
        # deal with that sort of stuff.
        arg_1['_external'] = arg_6
        arg_1['_anchor'] = arg_7
        arg_1['_method'] = arg_8
        return arg_2.app.handle_url_build_error(error, arg_0, arg_1)

    if arg_7 is not None:
        arg_11 += '#' + url_quote(arg_7)
    return arg_11

Generates a URL to the given endpoint with the method provided.

    Variable arguments that are unknown to the target endpoint are appended
    to the generated URL as query arguments.  If the value of a query argument
    is `None`, the whole pair is skipped.  In case blueprints are active
    you can shortcut references to the same blueprint by prefixing the
    local endpoint with a dot (``.``).

    This will reference the index function local to the current blueprint::

        url_for('.index')

    For more information, head over to the :ref:`Quickstart <url-building>`.

    To integrate applications, :class:`Flask` has a hook to intercept URL build
    errors through :attr:`Flask.build_error_handler`.  The `url_for` function
    results in a :exc:`~werkzeug.routing.BuildError` when the current app does
    not have a URL for the given endpoint and values.  When it does, the
    :data:`~flask.current_app` calls its :attr:`~Flask.build_error_handler` if
    it is not `None`, which can return a string to use as the result of
    `url_for` (instead of `url_for`'s default to raise the
    :exc:`~werkzeug.routing.BuildError` exception) or re-raise the exception.
    An example::

        def external_url_handler(error, endpoint, **values):
            "Looks up an external URL when `url_for` cannot build a URL."
            # This is an example of hooking the build_error_handler.
            # Here, lookup_url is some utility function you've built
            # which looks up the endpoint in some external URL registry.
            url = lookup_url(endpoint, **values)
            if url is None:
                # External lookup did not have a URL.
                # Re-raise the BuildError, in context of original traceback.
                exc_type, exc_value, tb = sys.exc_info()
                if exc_value is error:
                    raise exc_type, exc_value, tb
                else:
                    raise error
            # url_for will use this result, instead of raising BuildError.
            return url

        app.build_error_handler = external_url_handler

    Here, `error` is the instance of :exc:`~werkzeug.routing.BuildError`, and
    `endpoint` and `**values` are the arguments passed into `url_for`.  Note
    that this is for building URLs outside the current application, and not for
    handling 404 NotFound errors.

    .. versionadded:: 0.10
       The `_scheme` parameter was added.

    .. versionadded:: 0.9
       The `_anchor` and `_method` parameters were added.

    .. versionadded:: 0.9
       Calls :meth:`Flask.handle_build_error` on
       :exc:`~werkzeug.routing.BuildError`.

    :param endpoint: the endpoint of the URL (name of the function)
    :param values: the variable arguments of the URL rule
    :param _external: if set to `True`, an absolute URL is generated. Server
      address can be changed via `SERVER_NAME` configuration variable which
      defaults to `localhost`.
    :param _scheme: a string specifying the desired URL scheme. The `_external`
      parameter must be set to `True` or a `ValueError` is raised.
    :param _anchor: if provided this is added as anchor to the URL.
    :param _method: if provided this explicitly specifies an HTTP method.

Generates a URL to the given endpoint with the method provided .


def
Func
(
arg_0
)
:
logging
.
info
(
"Writing configure file: %s"
%
arg_0
.
config_file
)
if
arg_0
.
config_file
is
:
return
arg_1
=
cparser
.
ConfigParser
(
)
arg_1
.
add_section
(
"lrcloud"
)
for
arg_2
in
[
x
for
x
in
dir
(
arg_0
)
if
not
x
.
startswith
(
"_"
)
]
:
if
arg_2
in
IGNORE_ARGS
:
continue
arg_3
=
getattr
(
arg_0
,
arg_2
)
if
arg_3
is
not
:
arg_1
.
set
(
'lrcloud'
,
arg_2
,
str
(
arg_3
)
)
with
open
(
arg_0
.
config_file
,
'w'
)
as
f
:
arg_1
.
Func
(
f
)

def Func(arg_0):
    """Writing the configure file with the attributes in 'args'"""

    logging.info("Writing configure file: %s"%arg_0.config_file)
    if arg_0.config_file is None:
        return

    #Let's add each attribute of 'args' to the configure file
    arg_1 = cparser.ConfigParser()
    arg_1.add_section("lrcloud")
    for arg_2 in [x for x in dir(arg_0) if not x.startswith("_")]:
        if arg_2 in IGNORE_ARGS:
            continue#We ignore some attributes
        arg_3 = getattr(arg_0, arg_2)
        if arg_3 is not None:
            arg_1.set('lrcloud', arg_2, str(arg_3))

    with open(arg_0.config_file, 'w') as f:
        arg_1.Func(f)

Writing the configure file with the attributes in args


def Func(arg_0):
    """
    Checks element definitions.
    """
    # ELEMENT TYPE CHECKING
    arg_1 = set(arg_0.elements.type.argiope.values.flatten())
    arg_2 = set(ELEMENTS.keys())
    if (arg_1 <= arg_2) == False:
      raise ValueError("Element types {0} not in know elements {1}".format(
                       arg_1 - arg_2, arg_2))
    print("<Elements: OK>")


(units: tf.Tensor,
                   n_hidden_list: List,
                   cell_type='gru',
                   seq_lengths=None,
                   use_peepholes=False,
                   name='RNN_layer')

def
Func
(
arg_0
:
arg_1
.
Tensor
,
arg_3
:
arg_4
,
arg_5
=
'gru'
,
arg_6
=
,
arg_7
=
False
,
arg_8
=
'RNN_layer'
)
:
for
arg_9
,
arg_10
in
enumerate
(
arg_3
)
:
with
arg_1
.
variable_scope
(
arg_8
+
'_'
+
str
(
arg_9
)
)
:
if
arg_5
==
'gru'
:
arg_11
=
arg_1
.
nn
.
rnn_cell
.
GRUCell
(
arg_10
)
arg_12
=
arg_1
.
nn
.
rnn_cell
.
GRUCell
(
arg_10
)
elif
arg_5
==
'lstm'
:
arg_11
=
arg_1
.
nn
.
rnn_cell
.
LSTMCell
(
arg_10
,
arg_7
=
arg_7
)
arg_12
=
arg_1
.
nn
.
rnn_cell
.
LSTMCell
(
arg_10
,
arg_7
=
arg_7
)
else
:
raise
RuntimeError
(
'cell_type must be either gru or lstm'
)
(
arg_13
,
arg_14
)
,
(
arg_15
,
arg_16
)
=
arg_1
.
nn
.
bidirectional_dynamic_rnn
(
arg_11
,
arg_12
,
arg_0
,
dtype
=
arg_1
.
float32
,
sequence_length
=
arg_6
)
arg_0
=
arg_1
.
concat
(
[
arg_13
,
arg_14
]
,
axis
=
2
)
if
arg_5
==
'gru'
:
arg_17
=
arg_1
.
concat
(
[
arg_15
,
arg_16
]
,
axis
=
1
)
else
:
(
arg_18
,
arg_19
)
,
(
arg_20
,
arg_21
)
=
arg_15
,
arg_16
arg_22
=
arg_1
.
concat
(
[
arg_18
,
arg_20
]
,
axis
=
1
)
arg_23
=
arg_1
.
concat
(
[
arg_19
,
arg_21
]
,
axis
=
1
)
arg_17
=
(
arg_23
,
arg_22
)
return
arg_0
,
arg_17

def Func(arg_0: arg_1.Tensor,
                   arg_3: arg_4,
                   arg_5='gru',
                   arg_6=None,
                   arg_7=False,
                   arg_8='RNN_layer'):
    """ Stackted recurrent neural networks GRU or LSTM

        Args:
            units: a tensorflow tensor with dimensionality [None, n_tokens, n_features]
            n_hidden_list: list with number of hidden units at the ouput of each layer
            seq_lengths: length of sequences for different length sequences in batch
                can be None for maximum length as a length for every sample in the batch
            cell_type: 'lstm' or 'gru'
            use_peepholes: whether to use peephole connections (only 'lstm' case affected)
            name: what variable_scope to use for the network parameters
        Returns:
            units: tensor at the output of the last recurrent layer
                with dimensionality [None, n_tokens, n_hidden_list[-1]]
            last_units: tensor of last hidden states for GRU and tuple
                of last hidden stated and last cell states for LSTM
                dimensionality of cell states and hidden states are
                similar and equal to [B x 2 * H], where B - batch
                size and H is number of hidden units
    """
    for arg_9, arg_10 in enumerate(arg_3):
        with arg_1.variable_scope(arg_8 + '_' + str(arg_9)):
            if arg_5 == 'gru':
                arg_11 = arg_1.nn.rnn_cell.GRUCell(arg_10)
                arg_12 = arg_1.nn.rnn_cell.GRUCell(arg_10)
            elif arg_5 == 'lstm':
                arg_11 = arg_1.nn.rnn_cell.LSTMCell(arg_10, arg_7=arg_7)
                arg_12 = arg_1.nn.rnn_cell.LSTMCell(arg_10, arg_7=arg_7)
            else:
                raise RuntimeError('cell_type must be either gru or lstm')

            (arg_13, arg_14), (arg_15, arg_16) = \
                arg_1.nn.bidirectional_dynamic_rnn(arg_11,
                                                arg_12,
                                                arg_0,
                                                dtype=arg_1.float32,
                                                sequence_length=arg_6)
            arg_0 = arg_1.concat([arg_13, arg_14], axis=2)
            if arg_5 == 'gru':
                arg_17 = arg_1.concat([arg_15, arg_16], axis=1)
            else:
                (arg_18, arg_19), (arg_20, arg_21) = arg_15, arg_16
                arg_22 = arg_1.concat([arg_18, arg_20], axis=1)
                arg_23 = arg_1.concat([arg_19, arg_21], axis=1)
                arg_17 = (arg_23, arg_22)
    return arg_0, arg_17


(command, formatter=None, write_stdin=None, ignore_empty=False)

def Func(arg_0, arg_1=None, arg_2=None, arg_3=False):
    """
    Starts `command` in a subprocess. Prints every line the command prints,
    prefaced with `description`.

    :param command: The bash command to run. Must use fully-qualified paths.
    :type command: ``str``
    :param formatter: An optional formatting function to apply to each line.
    :type formatter: ``function`` or ``NoneType``
    :param write_stdin: An optional string to write to the process' stdin.
    :type write_stdin: ``str`` or ``NoneType``
    :param ignore_empty: If true, empty or whitespace-only lines will be skipped.
    :type ignore_empty: ``bool``
    """
    arg_4 = shlex.split(arg_0)
    try:
        arg_5 = subprocess.Popen(arg_4, stdout=subprocess.PIPE,
                                stderr=subprocess.STDOUT, stdin=subprocess.PIPE)
    except Exception as e:
        raise IOError('Encountered error: {0} when running command {1}'
                      .format(e.message, ' '.join(arg_4)))
    if arg_2 is not None:
        arg_5.stdin.write(arg_2)
        arg_5.stdin.flush()

    while arg_5.poll() is None:
        try:
            arg_6 = arg_5.stdout.readline()
        except KeyboardInterrupt:
            sys.exit('Keyboard interrupt while running {}'.format(arg_0))
        if len(arg_6.strip()) == 0 and arg_3 is True:
            continue
        elif 'killed by signal 1' in decode(arg_6).lower():
            continue
        elif 'to the list of known hosts' in decode(arg_6).lower():
            continue
        if arg_1 is not None:
            arg_6 = arg_1(arg_6)
        sys.stdout.write(arg_6)
    arg_7 = arg_5.poll()
    return arg_7

Starts command in a subprocess . Prints every line the command prints prefaced with description .


def Func(arg_0, arg_1, arg_2=arg_3.KMIPVersion.KMIP_1_0):
        """
        Write the data encoding the MACSignatureKeyInformation struct to a
        stream.

        Args:
            output_stream (stream): A data stream in which to encode object
                data, supporting a Func 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.
        """
        arg_6 = BytearrayStream()

        if arg_0._unique_identifier:
            arg_0._unique_identifier.Func(
                arg_6,
                arg_2=arg_2
            )
        else:
            raise ValueError(
                "Invalid struct missing the unique identifier attribute."
            )

        if arg_0._cryptographic_parameters:
            arg_0._cryptographic_parameters.Func(
                arg_6,
                arg_2=arg_2
            )

        arg_0.length = arg_6.length()
        super(MACSignatureKeyInformation, arg_0).Func(
            arg_1,
            arg_2=arg_2
        )
        arg_1.Func(arg_6.buffer)

Write the data encoding the MACSignatureKeyInformation struct 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.

Write the data encoding the MACSignatureKeyInformation struct to a stream .


def Func(arg_0, arg_1, arg_2):
    """Register an extension code."""
    arg_2 = int(arg_2)
    if not 1 <= arg_2 <= 0x7fffffff:
        raise ValueError, "code out of range"
    arg_3 = (arg_0, arg_1)
    if (arg_4.get(arg_3) == arg_2 and
        arg_5.get(arg_2) == arg_3):
        return # Redundant registrations are benign
    if arg_3 in arg_4:
        raise ValueError("key %s is already registered with code %s" %
                         (arg_3, arg_4[arg_3]))
    if arg_2 in arg_5:
        raise ValueError("code %s is already in use for key %s" %
                         (arg_2, arg_5[arg_2]))
    arg_4[arg_3] = arg_2
    arg_5[arg_2] = arg_3


(self, sample_rate_Hz=None, sample_width=None, channels=None, console_output=False)

def
Func
(
arg_0
,
arg_1
=
,
arg_2
=
,
arg_3
=
,
arg_4
=
False
)
:
if
arg_1
is
:
arg_1
=
arg_0
.
frame_rate
if
arg_2
is
:
arg_2
=
arg_0
.
sample_width
if
arg_3
is
:
arg_3
=
arg_0
.
channels
arg_5
=
"sox {inputfile} -b "
+
str
(
arg_2
*
8
)
+
" -r "
+
str
(
arg_1
)
+
" -t wav {outputfile} channels "
+
str
(
arg_3
)
return
arg_0
.
_execute_sox_cmd
(
arg_5
,
arg_4
=
arg_4
)

def Func(arg_0, arg_1=None, arg_2=None, arg_3=None, arg_4=False):
        """
        Returns a new AudioSegment whose data is the same as this one, but which has been Funcd to the
        specified characteristics. Any parameter left None will be unchanged.

        .. note:: This method requires that you have the program 'sox' installed.

        .. warning:: This method uses the program 'sox' to perform the task. While this is very fast for a single
                     function call, the IO may add up for large numbers of AudioSegment objects.

        :param sample_rate_Hz: The new sample rate in Hz.
        :param sample_width: The new sample width in bytes, so sample_width=2 would correspond to 16 bit (2 byte) width.
        :param channels: The new number of channels.
        :param console_output: Will print the output of sox to the console if True.
        :returns: The newly sampled AudioSegment.
        """
        if arg_1 is None:
            arg_1 = arg_0.frame_rate
        if arg_2 is None:
            arg_2 = arg_0.sample_width
        if arg_3 is None:
            arg_3 = arg_0.channels

        # TODO: Replace this with librosa's implementation to remove SOX dependency here
        arg_5 = "sox {inputfile} -b " + str(arg_2 * 8) + " -r " + str(arg_1) \
            + " -t wav {outputfile} channels " + str(arg_3)

        return arg_0._execute_sox_cmd(arg_5, arg_4=arg_4)

Returns a new AudioSegment whose data is the same as this one, but which has been resampled to the
        specified characteristics. Any parameter left None will be unchanged.

        .. note:: This method requires that you have the program 'sox' installed.

        .. warning:: This method uses the program 'sox' to perform the task. While this is very fast for a single
                     function call, the IO may add up for large numbers of AudioSegment objects.

        :param sample_rate_Hz: The new sample rate in Hz.
        :param sample_width: The new sample width in bytes, so sample_width=2 would correspond to 16 bit (2 byte) width.
        :param channels: The new number of channels.
        :param console_output: Will print the output of sox to the console if True.
        :returns: The newly sampled AudioSegment.

Returns a new AudioSegment whose data is the same as this one but which has been resampled to the specified characteristics . Any parameter left None will be unchanged .


def Func(arg_0):
    """Loads a class from a string naming the module and class name.

    For example:
    >>> Func(full_class_string = 'pypet.brian.parameter.BrianParameter')
    <BrianParameter>

    """

    arg_1 = arg_0.split(".")
    arg_2 = ".".join(arg_1[:-1])
    arg_3 = arg_1[-1]
    arg_4 = importlib.import_module(arg_2)

    # We retrieve the Class from the module
    return getattr(arg_4, arg_3)

Loads a class from a string naming the module and class name.

    For example:
    >>> load_class(full_class_string = 'pypet.brian.parameter.BrianParameter')
    <BrianParameter>

Loads a class from a string naming the module and class name .


(objective_function,
                         simplex,
                         best_index,
                         shrinkage,
                         batch_evaluate_objective)

return (False,
          shrunk_simplex,
          objective_at_shrunk_simplex,
          evals)

def Func(arg_0,
                         arg_1,
                         arg_2,
                         arg_3,
                         arg_4):
  """Shrinks the simplex around the best vertex."""

  # If the contraction step fails to improve the average objective enough,
  # the simplex is shrunk towards the best vertex.
  arg_5 = arg_1[arg_2]
  arg_6 = arg_5 + arg_3 * (arg_1 - arg_5)
  arg_7, arg_8 = _evaluate_objective_multiple(
      arg_0,
      arg_6,
      arg_4)
  return (False,
          arg_6,
          arg_7,
          arg_8)

Shrinks the simplex around the best vertex .


(load_balancer, flags=FLAGS.ALL ^ FLAGS.POLICY_TYPES, **conn)

return registry.build_out(flags, start_with=load_balancer, pass_datastructure=True, **conn)

def Func ( arg_0 , arg_1 = arg_2 . ALL ^ arg_2 . POLICY_TYPES , ** arg_5 ) : try : arg_6 except NameError as _ : arg_6 = str if isinstance ( arg_0 , arg_6 ) : arg_0 = dict ( LoadBalancerName = arg_0 ) return registry . build_out ( arg_1 , start_with = arg_0 , pass_datastructure = True , ** arg_5 )

def Func(arg_0, arg_1=arg_2.ALL ^ arg_2.POLICY_TYPES, **arg_5):
    """
    Fully describes an ELB.

    :param loadbalancer: Could be an ELB Name or a dictionary. Likely the return value from a previous call to describe_load_balancers. At a minimum, must contain a key titled 'LoadBalancerName'.
    :param flags: Flags describing which sections should be included in the return value. Default is FLAGS.ALL minus FLAGS.POLICY_TYPES.
    :return: Returns a dictionary describing the ELB with the fields described in the flags parameter.
    """
    # Python 2 and 3 support:
    try:
        arg_6
    except NameError as _:
        arg_6 = str

    if isinstance(arg_0, arg_6):
        arg_0 = dict(LoadBalancerName=arg_0)

    return registry.build_out(arg_1, start_with=arg_0, pass_datastructure=True, **arg_5)


(show=1, name=None, group=None, release=None, except_release=None)

def Func(arg_0=1, arg_1=None, arg_2=None, arg_3=None, arg_4=None):
    """
    Retrieves all virtual machines instances in the current environment.
    """
    from burlap.common import shelf, OrderedDict, get_verbose

    arg_5 = get_verbose()
    require('vm_type', 'vm_group')
    assert arg_6.vm_type, 'No VM type specified.'
    arg_6.vm_type = (arg_6.vm_type or '').lower()
    arg_8 = arg_1
    arg_9 = arg_2
    arg_10 = arg_3
    if arg_5:
        print('name=%s, group=%s, release=%s' % (arg_8, arg_9, arg_10))

    arg_6.vm_elastic_ip_mappings = shelf.get('vm_elastic_ip_mappings')

    arg_12 = type(arg_6)()
    if arg_6.vm_type == EC2:
        if arg_5:
            print('Checking EC2...')
        for arg_13 in get_all_running_ec2_instances():
            arg_1 = arg_13.tags.get(arg_6.vm_name_tag)
            arg_2 = arg_13.tags.get(arg_6.vm_group_tag)
            arg_3 = arg_13.tags.get(arg_6.vm_release_tag)
            if arg_6.vm_group and arg_6.vm_group != arg_2:
                if arg_5:
                    print(('Skipping instance %s because its group "%s" '
                        'does not match env.vm_group "%s".') \
                            % (arg_13.public_dns_name, arg_2, arg_6.vm_group))
                continue
            if arg_9 and arg_2 != arg_9:
                if arg_5:
                    print(('Skipping instance %s because its group "%s" '
                        'does not match local group "%s".') \
                            % (arg_13.public_dns_name, arg_2, arg_9))
                continue
            if arg_8 and arg_1 != arg_8:
                if arg_5:
                    print(('Skipping instance %s because its name "%s" '
                        'does not match name "%s".') \
                            % (arg_13.public_dns_name, arg_1, arg_8))
                continue
            if arg_10 and arg_3 != arg_10:
                if arg_5:
                    print(('Skipping instance %s because its release "%s" '
                        'does not match release "%s".') \
                            % (arg_13.public_dns_name, arg_3, arg_10))
                continue
            if arg_4 and arg_3 == arg_4:
                continue
            if arg_5:
                print('Adding instance %s (%s).' \
                    % (arg_1, arg_13.public_dns_name))
            arg_12.setdefault(arg_1, type(arg_6)())
            arg_12[arg_1]['id'] = arg_13.id
            arg_12[arg_1]['public_dns_name'] = arg_13.public_dns_name
            if arg_5:
                print('Public DNS: %s' % arg_13.public_dns_name)

            if arg_6.vm_elastic_ip_mappings and arg_1 in arg_6.vm_elastic_ip_mappings:
                arg_12[arg_1]['ip'] = arg_6.vm_elastic_ip_mappings[arg_1]
            else:
                arg_12[arg_1]['ip'] = socket.gethostbyname(arg_13.public_dns_name)

        if int(arg_0):
            pprint(arg_12, indent=4)
        return arg_12
    elif arg_6.vm_type == KVM:
        #virsh list
        pass
    else:
        raise NotImplementedError

Retrieves all virtual machines instances in the current environment .


def
Func
(
arg_0
,
arg_1
,
arg_2
=
,
**
arg_3
)
:
arg_4
=
arg_0
.
get_pages
(
arg_1
,
arg_2
=
arg_2
,
**
arg_3
)
for
arg_5
in
arg_4
:
assert
isinstance
(
arg_5
,
dict
)
arg_6
=
arg_5
.
get
(
'items'
)
if
arg_6
is
:
arg_7
=
"'items' key not found in JSON data: "
"{!r}"
.
format
(
arg_5
)
raise
MalformedResponse
(
arg_7
)
else
:
for
arg_8
in
arg_6
:
yield
arg_8

def Func(arg_0, arg_1, arg_2=None, **arg_3):
        """Return a generator that GETs and yields individual JSON `items`.

        Yields individual `items` from Webex Teams's top-level {'items': [...]}
        JSON objects. Provides native support for RFC5988 Web Linking.  The
        generator will request additional pages as needed until all items have
        been returned.

        Args:
            url(basestring): The URL of the API endpoint.
            params(dict): The parameters for the HTTP GET request.
            **kwargs:
                erc(int): The expected (success) response code for the request.
                others: Passed on to the requests package.

        Raises:
            ApiError: If anything other than the expected response code is
                returned by the Webex Teams API endpoint.
            MalformedResponse: If the returned response does not contain a
                top-level dictionary with an 'items' key.

        """
        # Get generator for pages of JSON data
        arg_4 = arg_0.get_pages(arg_1, arg_2=arg_2, **arg_3)

        for arg_5 in arg_4:
            assert isinstance(arg_5, dict)

            arg_6 = arg_5.get('items')

            if arg_6 is None:
                arg_7 = "'items' key not found in JSON data: " \
                                "{!r}".format(arg_5)
                raise MalformedResponse(arg_7)

            else:
                for arg_8 in arg_6:
                    yield arg_8

Return a generator that GETs and yields individual JSON items .


def Func ( arg_0 , arg_1 : 'TimeslotCollection' ) -> bool : for arg_2 in arg_1 . timeslots : for arg_3 in arg_0 . _table [ arg_2 . channel ] : if arg_2 . interval . has_overlap ( arg_3 ) : return False return True

def Func(arg_0, arg_1: 'TimeslotCollection') -> bool:
        """Return if self is mergeable with `timeslots`.

        Args:
            timeslots: TimeslotCollection to be checked
        """
        for arg_2 in arg_1.timeslots:
            for arg_3 in arg_0._table[arg_2.channel]:
                if arg_2.interval.has_overlap(arg_3):
                    return False
        return True

Return if self is mergeable with timeslots .


def Func ( arg_0 , arg_1 ) : if arg_0 . triggersStep ( arg_1 ) : arg_0 . __wrapOtherPub ( arg_1 ) arg_0 . __newRootKey ( "receiving" ) arg_0 . __newRatchetKey ( ) arg_0 . __newRootKey ( "sending" )

def Func(arg_0, arg_1):
        """
        Perform a rachted Func, calculating a new shared secret from the public key and
        deriving new chain keys from this secret.

        New Diffie-Hellman calculations are only performed if the public key is different
        from the previous one.

        :param other_pub: A bytes-like object encoding the public key of the other
            Diffie-Hellman ratchet to synchronize with.
        """

        if arg_0.triggersStep(arg_1):
            arg_0.__wrapOtherPub(arg_1)
            arg_0.__newRootKey("receiving")

            arg_0.__newRatchetKey()

            arg_0.__newRootKey("sending")

Perform a rachted step, calculating a new shared secret from the public key and
        deriving new chain keys from this secret.

        New Diffie-Hellman calculations are only performed if the public key is different
        from the previous one.

        :param other_pub: A bytes-like object encoding the public key of the other
            Diffie-Hellman ratchet to synchronize with.

Perform a rachted step calculating a new shared secret from the public key and deriving new chain keys from this secret .


return reduce(lambda x, y: x * y[0] / y[1],
                  zip(range(n - k + 1, n + 1),
                      range(1, k + 1)), 1)

def Func ( arg_0 , arg_1 ) : if arg_0 == 0 : return 0 return reduce ( lambda x , y : x * y [ 0 ] / y [ 1 ] , zip ( range ( arg_0 - arg_1 + 1 , arg_0 + 1 ) , range ( 1 , arg_1 + 1 ) ) , 1 )

def Func(arg_0, arg_1):
    """Return the number of combinations for n choose k.

    Args:
        n (int): the total number of options .
        k (int): The number of elements.

    Returns:
        int: returns the binomial coefficient
    """
    if arg_0 == 0:
        return 0
    return reduce(lambda x, y: x * y[0] / y[1],
                  zip(range(arg_0 - arg_1 + 1, arg_0 + 1),
                      range(1, arg_1 + 1)), 1)

Return the number of combinations for n choose k .


def Func ( arg_0 , arg_1 , arg_2 = None ) : if arg_1 in arg_0 . config : return arg_0 . config . get ( arg_1 ) else : return arg_2

def Func(arg_0, arg_1, arg_2=None):
        """Returns the configuration for KEY"""
        if arg_1 in arg_0.config:
            return arg_0.config.get(arg_1)
        else:
            return arg_2


def
Func
(
arg_0
)
:
for
arg_1
in
range
(
len
(
arg_0
)
)
:
sys
.
stdout
.
write
(
"%2x "
%
(
ord
(
arg_0
[
arg_1
]
)
)
)
if
(
arg_1
+
1
)
%
8
==
0
:
print
repr
(
arg_0
[
arg_1
7
:
arg_1
+
1
]
)
if
(
len
(
arg_0
)
%
8
!=
0
)
:
print
string
.
rjust
(
""
,
11
)
,
repr
(
arg_0
[
arg_1
len
(
arg_0
)
%
8
:
arg_1
+
1
]
)

def Func(arg_0):
    """Useful utility; prints the string in hexadecimal"""
    for arg_1 in range(len(arg_0)):
        sys.stdout.write("%2x " % (ord(arg_0[arg_1])))
        if (arg_1+1) % 8 == 0:
            print repr(arg_0[arg_1-7:arg_1+1])

    if(len(arg_0) % 8 != 0):
        print string.rjust("", 11), repr(arg_0[arg_1-len(arg_0)%8:arg_1+1])

Useful utility ; prints the string in hexadecimal


def Func():
    """Verify BOARD variables and construct exported variables"""

    if cij.ssh.Func():
        cij.err("board.Func: invalid SSH Funcironment")
        return 1

    arg_0 = cij.Func_to_dict(PREFIX, REQUIRED)   # Verify REQUIRED variables
    if arg_0 is None:
        cij.err("board.Func: invalid BOARD Funcironment")
        return 1

    arg_0["CLASS"] = "_".join([arg_0[r] for r in REQUIRED[:-1]])
    arg_0["IDENT"] = "-".join([arg_0["CLASS"], arg_0["ALIAS"]])

    cij.Func_export(PREFIX, EXPORTED, arg_0)     # Export EXPORTED variables

    return 0


def Func ( arg_0 = '.txt' , arg_1 = None ) : if arg_1 is None : arg_1 = get_temp_dir ( ) return tempfile . NamedTemporaryFile ( arg_0 = arg_0 , dir = arg_1 )

def Func(arg_0='.txt', arg_1=None):
    """ Return a temporary file with the given suffix within dirpath.
    If dirpath is None, will look for a temporary folder in your system.

    Parameters
    ----------
    suffix: str
        Temporary file name suffix

    dirpath: str
        Folder path where create the temporary file

    Returns
    -------
    temp_filepath: str
        The path to the temporary path
    """
    if arg_1 is None:
        arg_1 = get_temp_dir()

    return tempfile.NamedTemporaryFile(arg_0=arg_0, dir=arg_1)

Return a temporary file with the given suffix within dirpath . If dirpath is None will look for a temporary folder in your system .


def Func ( arg_0 , arg_1 = None , arg_2 = None ) : try : arg_3 = arg_0 . to_operator ( ) return arg_3 . Func ( arg_1 = arg_1 , arg_2 = arg_2 ) except QiskitError : return False

def Func(arg_0, arg_1=None, arg_2=None):
        """Return True if QuantumChannel is a unitary channel."""
        try:
            arg_3 = arg_0.to_operator()
            return arg_3.Func(arg_1=arg_1, arg_2=arg_2)
        except QiskitError:
            return False

Return True if QuantumChannel is a unitary channel .


return content, 'text/%s' % extension[1:]

def Func ( arg_0 ) : arg_1 = os . path . join ( os . path . dirname ( __file__ ) , _STATIC_DIR , arg_0 . path [ 1 : ] ) with io . open ( arg_1 , 'rb' ) as res_file : arg_2 = res_file . read ( ) arg_3 , arg_4 = os . path . splitext ( arg_0 . path ) return arg_2 , 'text/%s' % arg_4 [ 1 : ]

def Func(arg_0):
        """Handles static files requests."""
        arg_1 = os.path.join(
            os.path.dirname(__file__), _STATIC_DIR, arg_0.path[1:])
        with io.open(arg_1, 'rb') as res_file:
            arg_2 = res_file.read()
        arg_3, arg_4 = os.path.splitext(arg_0.path)
        return arg_2, 'text/%s' % arg_4[1:]


return username, course_id, program_uuid, enterprise_customer_uuid

def
Func
(
arg_0
,
arg_1
)
:
arg_2
=
get_request_value
(
arg_1
,
arg_0
.
REQUIRED_PARAM_USERNAME
,
''
)
arg_3
=
get_request_value
(
arg_1
,
arg_0
.
REQUIRED_PARAM_COURSE_ID
,
''
)
arg_4
=
get_request_value
(
arg_1
,
arg_0
.
REQUIRED_PARAM_PROGRAM_UUID
,
''
)
arg_5
=
get_request_value
(
arg_1
,
arg_0
.
REQUIRED_PARAM_ENTERPRISE_CUSTOMER
)
if
not
(
arg_2
and
(
arg_3
or
arg_4
)
and
arg_5
)
:
raise
ConsentAPIRequestError
(
arg_0
.
get_missing_params_message
(
[
(
"'username'"
,
bool
(
arg_2
)
)
,
(
"'enterprise_customer_uuid'"
,
bool
(
arg_5
)
)
,
(
"one of 'course_id' or 'program_uuid'"
,
bool
(
arg_3
or
arg_4
)
)
,
]
)
)
return
arg_2
,
arg_3
,
arg_4
,
arg_5

def Func(arg_0, arg_1):
        """
        Gets ``username``, ``course_id``, and ``enterprise_customer_uuid``,
        which are the relevant query parameters for this API endpoint.

        :param request: The request to this endpoint.
        :return: The ``username``, ``course_id``, and ``enterprise_customer_uuid`` from the request.
        """
        arg_2 = get_request_value(arg_1, arg_0.REQUIRED_PARAM_USERNAME, '')
        arg_3 = get_request_value(arg_1, arg_0.REQUIRED_PARAM_COURSE_ID, '')
        arg_4 = get_request_value(arg_1, arg_0.REQUIRED_PARAM_PROGRAM_UUID, '')
        arg_5 = get_request_value(arg_1, arg_0.REQUIRED_PARAM_ENTERPRISE_CUSTOMER)
        if not (arg_2 and (arg_3 or arg_4) and arg_5):
            raise ConsentAPIRequestError(
                arg_0.get_missing_params_message([
                    ("'username'", bool(arg_2)),
                    ("'enterprise_customer_uuid'", bool(arg_5)),
                    ("one of 'course_id' or 'program_uuid'", bool(arg_3 or arg_4)),
                ])
            )
        return arg_2, arg_3, arg_4, arg_5

Gets username course_id and enterprise_customer_uuid which are the relevant query parameters for this API endpoint .


return server.post(
            'task_admin',
            self.as_payload(),
            replacements={
                'slug': self.__challenge__.slug,
                'identifier': self.identifier})

def
Func
(
arg_0
,
arg_1
)
:
if
len
(
arg_0
.
geometries
)
==
0
:
raise
Exception
(
'no geometries'
)
return
arg_1
.
post
(
'task_admin'
,
arg_0
.
as_payload
(
)
,
replacements
=
{
'slug'
:
arg_0
.
__challenge__
.
slug
,
'identifier'
:
arg_0
.
identifier
}
)

def Func(arg_0, arg_1):
        """Create the task on the server"""
        if len(arg_0.geometries) == 0:
            raise Exception('no geometries')
        return arg_1.post(
            'task_admin',
            arg_0.as_payload(),
            replacements={
                'slug': arg_0.__challenge__.slug,
                'identifier': arg_0.identifier})


def Func ( arg_0 ) : arg_1 = Client ( arg_0 . host , arg_0 . port , arg_0 . prefix ) arg_0 . _configure_client ( arg_1 ) return arg_1

def Func(arg_0):
        # type: () -> Client
        """Return a client with same settings of the batch client"""

        arg_1 = Client(arg_0.host, arg_0.port, arg_0.prefix)
        arg_0._configure_client(arg_1)
        return arg_1


(func=None, *,
         field = _UNSET,
         get: bool = True, set: bool = True, del_: bool = False,
         default = _UNSET,
         types: tuple = _UNSET)

def Func(arg_0=None, *,
         arg_1 = arg_2,
         arg_3: arg_4 = True, arg_5: arg_4 = True, arg_6: arg_4 = False,
         arg_7 = arg_2,
         arg_8: arg_9 = arg_2):
    '''
    `Func` is a sugar for `Funcerty`.

    ``` py
    @Func
    def value(self):
        pass

    # equals:

    @Funcerty
    def value(self):
        return self._value

    @value.setter
    def value(self, val):
        self._value = val
    ```
    '''

    def wrap(arg_0):
        if not callable(arg_0):
            raise TypeError

        arg_10 = arg_0.__name__
        arg_11 = arg_1
        if arg_11 is arg_2:
            arg_11 = '_' + arg_10

        arg_12, arg_13, arg_14 = None, None, None

        if arg_3:
            def arg_12(arg_15):
                try:
                    return arg_15.__dict__[arg_11]
                except KeyError:
                    if arg_7 is not arg_2:
                        return arg_7
                    raise AttributeError(f"'{type(self).__name__}' object has no attribute '{key}'")

        if arg_5:
            def arg_13(arg_15, arg_16):
                if arg_8 is not arg_2 and not isinstance(arg_16, arg_8):
                    if isinstance(arg_8, arg_9):
                        arg_17 = arg_9(x.__name__ for x in arg_8)
                    else:
                        arg_17 = arg_8.__name__
                    raise TypeError(f'type of {type(self).__name__}.{Func_name} must be {types_name}; '
                                    f'got {type(val).__name__} instead')
                arg_15.__dict__[arg_11] = arg_16

        if arg_6:
            def arg_14(arg_15):
                del arg_15.__dict__[arg_11]

        return Funcerty(arg_12, arg_13, arg_14, arg_0.__doc__)

    return wrap(arg_0) if arg_0 else wrap

`prop` is a sugar for `property`.

    ``` py
    @prop
    def value(self):
        pass

    # equals:

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, val):
        self._value = val
    ```


def Func ( arg_0 , arg_1 ) : for arg_2 in _tzfile . attrs : setattr ( arg_0 , '_' + arg_2 , getattr ( arg_1 , arg_2 ) )

def Func(arg_0, arg_1):
        """ Set the time zone data of this object from a _tzfile object """
        # Copy the relevant attributes over as private attributes
        for arg_2 in _tzfile.attrs:
            setattr(arg_0, '_' + arg_2, getattr(arg_1, arg_2))


def Func ( arg_0 ) : arg_1 = ET . Element ( 'html' ) arg_2 = ET . SubElement ( arg_1 , 'head' ) arg_3 = ET . SubElement ( arg_2 , 'title' ) arg_3 . text = arg_0 . description arg_5 = ET . SubElement ( arg_1 , 'body' ) arg_6 = ET . SubElement ( arg_5 , 'h1' ) arg_6 . text = arg_0 . description arg_7 = ET . SubElement ( arg_5 , 'span' ) arg_7 . text = '___CONTENT___' arg_8 = ET . tostring ( arg_1 ) arg_9 = '' arg_10 = set ( ) for arg_11 in arg_0 . get_specs_depth_first ( ) : if arg_11 . svg and arg_11 . svg not in arg_10 : arg_9 += '<p>' + arg_11 . svg + "</p>" arg_10 . add ( arg_11 . svg ) return arg_8 . replace ( '___CONTENT___' , arg_9 )

def Func(arg_0):
        """
        Returns an etree HTML node with a document describing the process. This
        is only supported if the editor provided an SVG representation.
        """
        arg_1 = ET.Element('html')
        arg_2 = ET.SubElement(arg_1, 'head')
        arg_3 = ET.SubElement(arg_2, 'title')
        arg_3.text = arg_0.description
        arg_5 = ET.SubElement(arg_1, 'body')
        arg_6 = ET.SubElement(arg_5, 'h1')
        arg_6.text = arg_0.description
        arg_7 = ET.SubElement(arg_5, 'span')
        arg_7.text = '___CONTENT___'

        arg_8 = ET.tostring(arg_1)

        arg_9 = ''
        arg_10 = set()
        for arg_11 in arg_0.get_specs_depth_first():
            if arg_11.svg and arg_11.svg not in arg_10:
                arg_9 += '<p>' + arg_11.svg + "</p>"
                arg_10.add(arg_11.svg)
        return arg_8.replace('___CONTENT___', arg_9)

Returns an etree HTML node with a document describing the process . This is only supported if the editor provided an SVG representation .


def Func(arg_0):
    """receives a UUID via the request and returns either a fresh or an existing dropbox
    for it"""
    try:
        arg_1 = int(arg_0.registry.settings.get('post_token_max_age_seconds'))
    except Exception:
        arg_1 = 300

    try:
        arg_2 = parse_post_token(
            token=arg_0.matchdict['token'],
            secret=arg_0.registry.settings['post_secret'],
            arg_1=arg_1)
    except SignatureExpired:
        raise HTTPGone('dropbox expired')
    except Exception:  # don't be too specific on the reason for the error
        raise HTTPNotFound('no such dropbox')
    arg_3 = arg_0.registry.settings['dropbox_container'].get_dropbox(arg_2)
    if arg_3.status_int >= 20:
        raise HTTPGone('dropbox already in processing, no longer accepts data')
    return arg_3


def Func ( arg_0 ) : arg_1 = [ ] for arg_2 , arg_3 in list ( arg_0 . items ( ) ) : for arg_4 , arg_5 in list ( arg_3 . items ( ) ) : arg_1 . append ( ( arg_2 , arg_4 , arg_5 ) ) return arg_1

def Func(arg_0):
    """
    Parses option_settings as they are defined in the configuration file
    """
    arg_1 = []
    for arg_2, arg_3 in list(arg_0.items()):
        for arg_4, arg_5 in list(arg_3.items()):
            arg_1.append((arg_2, arg_4, arg_5))
    return arg_1


(cls, center, radius, n_vertices=50, **kwargs)

return cls.regular_polygon(center, radius, n_vertices, **kwargs)

def Func(arg_0, arg_1, arg_2, arg_3=50, **arg_4):
        """Construct a Func.

        Parameters
        ----------
        center : array-like
        radius : float
        n_vertices : int, optional
            Number of points to draw.
            Decrease for performance, increase for appearance.
        kwargs
            Other keyword arguments are passed to the |Shape| constructor.

        """
        return arg_0.regular_polygon(arg_1, arg_2, arg_3, **arg_4)

Construct a circle.

        Parameters
        ----------
        center : array-like
        radius : float
        n_vertices : int, optional
            Number of points to draw.
            Decrease for performance, increase for appearance.
        kwargs
            Other keyword arguments are passed to the |Shape| constructor.


def Func(arg_0, arg_1, arg_2=False):
        """
        Looks for files in the extra locations
        as defined in ``MEDIA_FIXTURES_FILES_DIRS``.
        """
        arg_3 = []
        for arg_4, arg_5 in arg_0.locations:
            if arg_5 not in searched_locations:
                searched_locations.append(arg_5)
            arg_6 = arg_0.Func_location(arg_5, arg_1, arg_4)
            if arg_6:
                if not arg_2:
                    return arg_6
                arg_3.append(arg_6)
        return arg_3

Looks for files in the extra locations as defined in MEDIA_FIXTURES_FILES_DIRS .


return self._nn_interface._add_generic(self, type_name=RESULT_GROUP,
                                               group_type_name=RESULT_GROUP,
                                               args=args, kwargs=kwargs)

def Func(arg_0, *arg_1, **arg_2):
        """Adds an empty result group under the current node.

        Adds the full name of the current node as prefix to the name of the group.
        If current node is a single run (root) adds the prefix `'results.runs.run_08%d%'` to the
        full name where `'08%d'` is replaced by the index of the current run.

        The `name` can also contain subgroups separated via colons, for example:
        `name=subgroup1.subgroup2.subgroup3`. These other parent groups will be automatically
        be created.

        """

        return arg_0._nn_interface._add_generic(arg_0, type_name=RESULT_GROUP,
                                               group_type_name=RESULT_GROUP,
                                               arg_1=arg_1, arg_2=arg_2)

Adds an empty result group under the current node .


def Func ( arg_0 ) : arg_1 = [ ] for arg_2 , arg_3 in arg_0 . items ( ) : arg_1 . append ( zipkin_pb2 . Annotation ( timestamp = int ( arg_3 * 1000 * 1000 ) , arg_2 = arg_2 , ) ) return arg_1

def Func(arg_0):
    """Converts py_zipkin's annotations dict to protobuf.

    :param annotations: annotations dict.
    :type annotations: dict
    :return: corresponding protobuf's list of annotations.
    :rtype: list
    """
    arg_1 = []
    for arg_2, arg_3 in arg_0.items():
        arg_1.append(zipkin_pb2.Annotation(
            timestamp=int(arg_3 * 1000 * 1000),
            arg_2=arg_2,
        ))
    return arg_1

Converts py_zipkin s annotations dict to protobuf .


(self, client_id, code, request,
                                      *args, **kwargs)

def Func(arg_0, arg_1, arg_2, arg_3,
                                      *arg_4, **arg_5):
        """Invalidate an authorization code after use.

        We keep the temporary code in a grant, which has a `delete`
        function to destroy itself.
        """
        log.debug('Destroy grant token for client %r, %r', arg_1, arg_2)
        arg_6 = arg_0._grantgetter(arg_1=arg_1, arg_2=arg_2)
        if arg_6:
            arg_6.delete()

Invalidate an authorization code after use .


return TypingStatusMessage(
        conv_id=p.conversation_id.id,
        user_id=from_participantid(p.sender_id),
        timestamp=from_timestamp(p.timestamp),
        status=p.type,
    )

def Func ( arg_0 ) : return TypingStatusMessage ( conv_id = arg_0 . conversation_id . id , user_id = from_participantid ( arg_0 . sender_id ) , timestamp = from_timestamp ( arg_0 . timestamp ) , status = arg_0 . type , )

def Func(arg_0):
    """Return TypingStatusMessage from hangouts_pb2.SetTypingNotification.

    The same status may be sent multiple times consecutively, and when a
    message is sent the typing status will not change to stopped.
    """
    return TypingStatusMessage(
        conv_id=arg_0.conversation_id.id,
        user_id=from_participantid(arg_0.sender_id),
        timestamp=from_timestamp(arg_0.timestamp),
        status=arg_0.type,
    )

Return TypingStatusMessage from hangouts_pb2 . SetTypingNotification .


def
Func
(
arg_0
,
arg_1
,
arg_2
)
:
if
not
arg_1
[
"by_msg"
]
:
raise
exceptions
.
EmptyReportError
(
)
arg_3
=
sorted
(
[
(
arg_5
,
arg_6
)
for
arg_6
,
arg_5
in
arg_1
[
"by_msg"
]
.
items
(
)
if
not
arg_6
.
startswith
(
"I"
)
]
)
arg_3
.
reverse
(
)
arg_4
=
(
"message id"
,
"occurrences"
)
for
arg_5
,
arg_6
in
arg_3
:
arg_4
+=
(
arg_6
,
str
(
arg_5
)
)
arg_0
.
append
(
report_nodes
.
Table
(
children
=
arg_4
,
cols
=
2
,
rheaders
=
1
)
)

def Func(arg_0, arg_1, arg_2):
    """make messages type report"""
    if not arg_1["by_msg"]:
        # don't print this report when we didn't detected any errors
        raise exceptions.EmptyReportError()
    arg_3 = sorted(
        [
            (arg_5, arg_6)
            for arg_6, arg_5 in arg_1["by_msg"].items()
            if not arg_6.startswith("I")
        ]
    )
    arg_3.reverse()
    arg_4 = ("message id", "occurrences")
    for arg_5, arg_6 in arg_3:
        arg_4 += (arg_6, str(arg_5))
    arg_0.append(report_nodes.Table(children=arg_4, cols=2, rheaders=1))


def Func ( arg_0 , arg_1 ) : arg_2 = tkinter . Tk ( ) arg_2 . attributes ( "-topmost" , True ) arg_2 . withdraw ( ) arg_3 = tkinter . messagebox . askyesno ( arg_0 , arg_1 ) arg_2 . destroy ( ) return arg_3

def Func(arg_0,arg_1):
    """use the GUI to ask YES or NO."""
    arg_2 = tkinter.Tk()
    arg_2.attributes("-topmost", True) #always on top
    arg_2.withdraw() #hide tk window
    arg_3=tkinter.messagebox.askyesno(arg_0,arg_1)
    arg_2.destroy()
    return arg_3


def Func(arg_0: arg_1, arg_2: arg_3, arg_4: arg_3):
    """Export the graph to a SPIA Excel sheet."""
    if not arg_2 and not arg_4:
        click.secho('Specify at least one option --xlsx or --tsvs', fg='red')
        sys.exit(1)

    arg_5 = bel_to_spia_matrices(arg_0)

    if arg_2:
        spia_matrices_to_excel(arg_5, arg_2)

    if arg_4:
        spia_matrices_to_tsvs(arg_5, arg_4)

Export the graph to a SPIA Excel sheet .


def Func ( arg_0 , arg_1 , arg_2 = None ) : arg_3 = False if hasattr ( arg_2 , '__iter__' ) : for arg_4 in arg_2 : if arg_1 [ : len ( arg_4 ) ] == arg_4 : return len ( arg_4 ) for arg_5 in range ( len ( arg_1 ) ) : if not arg_3 and arg_1 [ arg_5 ] in arg_0 . _vowels : arg_3 = True elif arg_3 and arg_1 [ arg_5 ] not in arg_0 . _vowels : return arg_5 + 1 return len ( arg_1 )

def Func(arg_0, arg_1, arg_2=None):
        """Return the R1 region, as defined in the Porter2 specification.

        Parameters
        ----------
        term : str
            The term to examine
        r1_prefixes : set
            Prefixes to consider

        Returns
        -------
        int
            Length of the R1 region

        """
        arg_3 = False
        if hasattr(arg_2, '__iter__'):
            for arg_4 in arg_2:
                if arg_1[: len(arg_4)] == arg_4:
                    return len(arg_4)

        for arg_5 in range(len(arg_1)):
            if not arg_3 and arg_1[arg_5] in arg_0._vowels:
                arg_3 = True
            elif arg_3 and arg_1[arg_5] not in arg_0._vowels:
                return arg_5 + 1
        return len(arg_1)

Return the R1 region as defined in the Porter2 specification .


(port, address, data_name, data_type, return_ctypes=False)

def Func(arg_0, arg_1, arg_2, arg_3, arg_4=False):
    # type: (int, AmsAddr, str, Type, bool) -> Any
    """Read data synchronous from an ADS-device from data name.

    :param int port: local AMS port as returned by adsPortOpenEx()
    :param pyads.structs.AmsAddr address: local or remote AmsAddr
    :param string data_name: data name
    :param Type data_type: type of the data given to the PLC, according to
        PLCTYPE constants
    :param bool return_ctypes: return ctypes instead of python types if True
        (default: False)
    :rtype: data_type
    :return: value: **value**

    """
    # Get the handle of the PLC-variable
    arg_5 = adsSyncReadWriteReqEx2(
        arg_0,
        arg_1,
        ADSIGRP_SYM_HNDBYNAME,
        0x0,
        PLCTYPE_UDINT,
        arg_2,
        PLCTYPE_STRING,
    )

    # Read the value of a PLC-variable, via handle
    arg_6 = adsSyncReadReqEx2(
        arg_0, arg_1, ADSIGRP_SYM_VALBYHND, arg_5, arg_3, arg_4
    )

    # Release the handle of the PLC-variable
    adsSyncWriteReqEx(arg_0, arg_1, ADSIGRP_SYM_RELEASEHND, 0, arg_5, PLCTYPE_UDINT)

    return arg_6

Read data synchronous from an ADS - device from data name .


def Func(arg_0, arg_1):
        """Return stripped HTML, keeping only MathML."""
        arg_2 = arg_0()
        arg_2.feed(arg_1)
        arg_3 = arg_2.unescape(arg_2.get_data())
        return escape_for_xml(arg_3, tags_to_keep=arg_2.mathml_elements)

Return stripped HTML keeping only MathML .


def
Func
(
arg_0
)
:
while
True
:
arg_1
=
arg_0
.
_read_varint
(
)
if
arg_1
==
0
:
break
for
arg_2
in
range
(
arg_1
)
:
arg_3
=
arg_0
.
_read_varint
(
)
if
arg_3
==
0
:
raise
EOFError
(
'unexpected EOF.'
)
yield
arg_0
.
_fd
.
read
(
arg_3
)
if
arg_0
.
_group_delim
:
yield
arg_0
.
_delimiter
(
)
if
arg_0
.
_delimiter
is
not
else

def Func(arg_0):
        """A generator yielding all protobuf object data in the file. It is the
        main parser of the stream encoding.
        """
        while True:
            arg_1 = arg_0._read_varint()
            if arg_1 == 0:
                break
            # Read a group containing `count` number of objects.
            for arg_2 in range(arg_1):
                arg_3 = arg_0._read_varint()
                if arg_3 == 0:
                    raise EOFError('unexpected EOF.')
                # Read an object from the object group.
                yield arg_0._fd.read(arg_3)

            if arg_0._group_delim:
                yield arg_0._delimiter() if arg_0._delimiter is not None \
                                        else None

A generator yielding all protobuf object data in the file . It is the main parser of the stream encoding .


def Func(arg_0, arg_1=None, **arg_2):
        """
        Internal utility function for Unified Job Templates. Returns data about the last job run off of that UJT
        """
        arg_3 = arg_0.get(arg_1, include_debug_header=True, **arg_2)

        # Determine the appropriate inventory source update.
        if 'current_update' in arg_3['related']:
            debug.log('A current job; retrieving it.', header='details')
            return client.get(arg_3['related']['current_update'][7:]).json()
        elif arg_3['related'].get('last_update', None):
            debug.log('No current job or update exists; retrieving the most recent.', header='details')
            return client.get(arg_3['related']['last_update'][7:]).json()
        else:
            raise exc.NotFound('No related jobs or updates exist.')

Internal utility function for Unified Job Templates . Returns data about the last job run off of that UJT


def
Func
(
arg_0
,
arg_1
,
arg_2
,
arg_3
=
True
)
:
arg_1
=
pass_white
(
arg_0
,
arg_1
)
if
arg_1
<
len
(
arg_0
)
and
arg_0
[
arg_1
]
==
arg_2
:
return
arg_1
+
1
if
arg_3
:
raise
SyntaxError
(
'Missing token. Expected %s'
%
arg_2
)
return

def Func(arg_0, arg_1, arg_2, arg_3=True):
    """Token can be only a single char. Returns position after token if found. Otherwise raises syntax error if throw
    otherwise returns None"""
    arg_1 = pass_white(arg_0, arg_1)
    if arg_1 < len(arg_0) and arg_0[arg_1] == arg_2:
        return arg_1 + 1
    if arg_3:
        raise SyntaxError('Missing token. Expected %s' % arg_2)
    return None

Token can be only a single char . Returns position after token if found . Otherwise raises syntax error if throw otherwise returns None


def Func(arg_0, arg_1):
    """
    Load a public key from a buffer.

    :param type: The file type (one of :data:`FILETYPE_PEM`,
        :data:`FILETYPE_ASN1`).
    :param buffer: The buffer the key is stored in.
    :type buffer: A Python string object, either unicode or bytestring.
    :return: The PKey object.
    :rtype: :class:`PKey`
    """
    if isinstance(arg_1, _text_type):
        arg_1 = arg_1.encode("ascii")

    arg_2 = _new_mem_buf(arg_1)

    if arg_0 == FILETYPE_PEM:
        arg_3 = _lib.PEM_read_bio_PUBKEY(
            arg_2, _ffi.NULL, _ffi.NULL, _ffi.NULL)
    elif arg_0 == FILETYPE_ASN1:
        arg_3 = _lib.d2i_PUBKEY_bio(arg_2, _ffi.NULL)
    else:
        raise ValueError("type argument must be FILETYPE_PEM or FILETYPE_ASN1")

    if arg_3 == _ffi.NULL:
        _raise_current_error()

    arg_4 = PKey.__new__(PKey)
    arg_4._pkey = _ffi.gc(arg_3, _lib.EVP_PKEY_free)
    arg_4._only_public = True
    return arg_4


async def Func ( arg_0 , arg_1 ) : arg_2 = hangouts_pb2 . SyncAllNewEventsResponse ( ) await arg_0 . _pb_request ( 'conversations/syncallnewevents' , arg_1 , arg_2 ) return arg_2

async def Func(arg_0, arg_1):
        """List all events occurring at or after a timestamp."""
        arg_2 = hangouts_pb2.SyncAllNewEventsResponse()
        await arg_0._pb_request('conversations/syncallnewevents',
                               arg_1, arg_2)
        return arg_2

List all events occurring at or after a timestamp .


def Func ( arg_0 = None , arg_1 = None , arg_2 = None ) : if arg_0 is None : try : raise ZeroDivisionError except ZeroDivisionError : arg_0 = sys . exc_info ( ) [ 2 ] . tb_frame . f_back print_list ( extract_stack ( arg_0 , arg_1 ) , arg_2 )

def Func(arg_0=None, arg_1=None, arg_2=None):
    """Print a stack trace from its invocation point.

    The optional 'f' argument can be used to specify an alternate
    stack frame at which to start. The optional 'limit' and 'file'
    arguments have the same meaning as for print_exception().
    """
    if arg_0 is None:
        try:
            raise ZeroDivisionError
        except ZeroDivisionError:
            arg_0 = sys.exc_info()[2].tb_frame.f_back
    print_list(extract_stack(arg_0, arg_1), arg_2)

Print a stack trace from its invocation point .


def Func ( arg_0 , arg_1 ) : try : arg_2 = utils . safe_infer ( utils . get_argument_from_call ( arg_1 , position = 0 ) ) except utils . NoSuchArgumentError : pass else : if arg_2 is astroid . Uninferable : return if arg_2 is None : if isinstance ( arg_1 . args [ 0 ] , astroid . Call ) : try : arg_3 = next ( arg_1 . args [ 0 ] . func . infer ( ) ) except astroid . InferenceError : return if getattr ( arg_3 , "name" , None ) == "iter" and utils . is_builtin_object ( arg_3 ) : arg_0 . add_message ( "bad-reversed-sequence" , arg_1 = arg_1 ) return if isinstance ( arg_2 , ( astroid . List , astroid . Tuple ) ) : return if isinstance ( arg_2 , astroid . Instance ) : if arg_2 . _proxied . name == "dict" and utils . is_builtin_object ( arg_2 . _proxied ) : arg_0 . add_message ( "bad-reversed-sequence" , arg_1 = arg_1 ) return if any ( arg_4 . name == "dict" and utils . is_builtin_object ( arg_4 ) for arg_4 in arg_2 . _proxied . ancestors ( ) ) : try : arg_2 . locals [ REVERSED_PROTOCOL_METHOD ] except KeyError : arg_0 . add_message ( "bad-reversed-sequence" , arg_1 = arg_1 ) return if hasattr ( arg_2 , "getattr" ) : for arg_5 in REVERSED_METHODS : for meth in arg_5 : try : arg_2 . getattr ( meth ) except astroid . NotFoundError : break else : break else : arg_0 . add_message ( "bad-reversed-sequence" , arg_1 = arg_1 ) else : arg_0 . add_message ( "bad-reversed-sequence" , arg_1 = arg_1 )

def Func(arg_0, arg_1):
        """ check that the argument to `reversed` is a sequence """
        try:
            arg_2 = utils.safe_infer(utils.get_argument_from_call(arg_1, position=0))
        except utils.NoSuchArgumentError:
            pass
        else:
            if arg_2 is astroid.Uninferable:
                return
            if arg_2 is None:
                # Nothing was infered.
                # Try to see if we have iter().
                if isinstance(arg_1.args[0], astroid.Call):
                    try:
                        arg_3 = next(arg_1.args[0].func.infer())
                    except astroid.InferenceError:
                        return
                    if getattr(
                        arg_3, "name", None
                    ) == "iter" and utils.is_builtin_object(arg_3):
                        arg_0.add_message("bad-reversed-sequence", arg_1=arg_1)
                return

            if isinstance(arg_2, (astroid.List, astroid.Tuple)):
                return

            if isinstance(arg_2, astroid.Instance):
                if arg_2._proxied.name == "dict" and utils.is_builtin_object(
                    arg_2._proxied
                ):
                    arg_0.add_message("bad-reversed-sequence", arg_1=arg_1)
                    return
                if any(
                    arg_4.name == "dict" and utils.is_builtin_object(arg_4)
                    for arg_4 in arg_2._proxied.ancestors()
                ):
                    # Mappings aren't accepted by reversed(), unless
                    # they provide explicitly a __reversed__ method.
                    try:
                        arg_2.locals[REVERSED_PROTOCOL_METHOD]
                    except KeyError:
                        arg_0.add_message("bad-reversed-sequence", arg_1=arg_1)
                    return

            if hasattr(arg_2, "getattr"):
                # everything else is not a proper sequence for reversed()
                for arg_5 in REVERSED_METHODS:
                    for meth in arg_5:
                        try:
                            arg_2.getattr(meth)
                        except astroid.NotFoundError:
                            break
                    else:
                        break
                else:
                    arg_0.add_message("bad-reversed-sequence", arg_1=arg_1)
            else:
                arg_0.add_message("bad-reversed-sequence", arg_1=arg_1)

check that the argument to reversed is a sequence


def Func ( arg_0 , arg_1 = None , arg_2 = None ) : arg_3 = arg_1 or arg_0 . _settings [ "url" ] if arg_1 and arg_0 . _settings [ "baseFunc" ] : arg_3 = "%s/%s" % ( arg_0 . _settings [ "baseFunc" ] , arg_1 ) arg_3 += ".json" if arg_2 : arg_3 += "?%s" % urllib . urlencode ( arg_2 ) return arg_3

def Func(arg_0, arg_1=None, arg_2=None):
        """ Build destination URL.

        Kwargs:
            url (str): Destination URL
            parameters (dict): Additional GET parameters to append to the URL

        Returns:
            str. URL
        """

        arg_3 = arg_1 or arg_0._settings["url"]
        if arg_1 and arg_0._settings["baseFunc"]:
            arg_3 = "%s/%s" % (arg_0._settings["baseFunc"], arg_1)
        arg_3 += ".json"
        if arg_2:
            arg_3 += "?%s" % urllib.urlencode(arg_2)
        return arg_3


def
Func
(
arg_0
)
:
arg_1
=
0
while
True
:
arg_2
=
arg_0
.
_buffer
.
find
(
INST_TERM
.
encode
(
)
,
arg_1
)
if
arg_2
!=
1
:
arg_3
=
arg_0
.
_buffer
[
:
arg_2
+
1
]
.
decode
(
)
arg_0
.
_buffer
=
arg_0
.
_buffer
[
arg_2
+
1
:
]
arg_0
.
logger
.
debug
(
'Received instruction: %s'
%
arg_3
)
return
arg_3
else
:
arg_1
=
len
(
arg_0
.
_buffer
)
arg_5
=
arg_0
.
client
.
recv
(
BUF_LEN
)
if
not
arg_5
:
arg_0
.
close
(
)
arg_0
.
logger
.
debug
(
'Failed to Func instruction. Closing.'
)
return
arg_0
.
_buffer
.
extend
(
arg_5
)

def Func(arg_0):
        """
        Receive instructions from Guacamole guacd server.
        """
        arg_1 = 0

        while True:
            arg_2 = arg_0._buffer.find(INST_TERM.encode(), arg_1)
            if arg_2 != -1:
                # instruction was fully Funcd!
                arg_3 = arg_0._buffer[:arg_2 + 1].decode()
                arg_0._buffer = arg_0._buffer[arg_2 + 1:]
                arg_0.logger.debug('Received instruction: %s' % arg_3)
                return arg_3
            else:
                arg_1 = len(arg_0._buffer)
                # we are still waiting for instruction termination
                arg_5 = arg_0.client.recv(BUF_LEN)
                if not arg_5:
                    # No data recieved, connection lost?!
                    arg_0.close()
                    arg_0.logger.debug(
                        'Failed to Func instruction. Closing.')
                    return None
                arg_0._buffer.extend(arg_5)

Receive instructions from Guacamole guacd server .


(script, min_quality=0.0, max_quality=0.05, inclusive=True)

def Func(arg_0, arg_1=0.0, arg_2=0.05, arg_3=True):
    """ Select all the faces and vertexes within the specified vertex quality
        range.

    Args:
        script: the FilterScript object or script filename to write
            the filter] to.
        min_quality (float): Minimum acceptable quality value.
        max_quality (float): Maximum acceptable quality value.
        inclusive (bool): If True only the faces with ALL the vertices within
            the specified range are selected. Otherwise any face with at least
            one vertex within the range is selected.

    Layer stack:
        No impacts

    MeshLab versions:
        2016.12
        1.3.4BETA
    """
    arg_4 = ''.join([
        '  <filter name="Select by Vertex Quality">\n',
        '    <Param name="minQ" ',
        'value="{}" '.format(arg_1),
        'description="Min Quality" ',
        'min="0" ',
        'max="{}" '.format(2 * arg_2),
        'type="RichDynamicFloat" ',
        '/>\n',
        '    <Param name="maxQ" ',
        'value="{}" '.format(arg_2),
        'description="Max Quality" ',
        'min="0" ',
        'max="{}" '.format(2 * arg_2),
        'type="RichDynamicFloat" ',
        '/>\n',
        '    <Param name="Inclusive" ',
        'value="{}" '.format(str(arg_3).lower()),
        'description="Inclusive Sel." ',
        'type="RichBool" ',
        '/>\n',
        '  </filter>\n'])
    util.write_filter(arg_0, arg_4)
    return None

Select all the faces and vertexes within the specified vertex quality range .


return {
        'initializers': [
            tf.compat.v2.initializers.serialize(
                tf.keras.initializers.get(init))
            for init in self.initializers
        ],
        'sizes': self.sizes,
        'validate_args': self.validate_args,
    }

def Func ( arg_0 ) : return { 'initializers' : [ tf . compat . v2 . initializers . serialize ( tf . keras . initializers . get ( arg_1 ) ) for arg_1 in arg_0 . initializers ] , 'sizes' : arg_0 . sizes , 'validate_args' : arg_0 . validate_args , }

def Func(arg_0):
    """Returns initializer configuration as a JSON-serializable dict."""
    return {
        'initializers': [
            tf.compat.v2.initializers.serialize(
                tf.keras.initializers.get(arg_1))
            for arg_1 in arg_0.initializers
        ],
        'sizes': arg_0.sizes,
        'validate_args': arg_0.validate_args,
    }

Returns initializer configuration as a JSON - serializable dict .


def Func ( arg_0 , arg_1 , arg_2 ) : arg_3 = ( 'store_true' , 'store_false' ) for arg_4 , arg_5 in arg_1 . items ( ) : arg_6 = arg_0 . _conf [ arg_5 ] . def_ [ arg_4 ] arg_7 = copy . deepcopy ( arg_6 . cmd_kwargs ) arg_8 = arg_7 . get ( 'action' ) if arg_8 is internal . Switch : arg_7 . update ( nargs = 0 ) elif arg_6 . default is not None and arg_8 not in arg_3 : arg_7 . setdefault ( 'type' , type ( arg_6 . default ) ) arg_7 . update ( help = arg_6 . help ) arg_7 . setdefault ( 'default' , arg_0 . _conf [ arg_5 ] [ arg_4 ] ) arg_2 . add_argument ( * _names ( arg_0 . _conf [ arg_5 ] , arg_4 ) , ** arg_7 )

def Func(arg_0, arg_1, arg_2):
        """Add options to a parser."""
        arg_3 = ('store_true', 'store_false')
        for arg_4, arg_5 in arg_1.items():
            arg_6 = arg_0._conf[arg_5].def_[arg_4]
            arg_7 = copy.deepcopy(arg_6.cmd_kwargs)
            arg_8 = arg_7.get('action')
            if arg_8 is internal.Switch:
                arg_7.update(nargs=0)
            elif arg_6.default is not None and arg_8 not in arg_3:
                arg_7.setdefault('type', type(arg_6.default))
            arg_7.update(help=arg_6.help)
            arg_7.setdefault('default', arg_0._conf[arg_5][arg_4])
            arg_2.add_argument(*_names(arg_0._conf[arg_5], arg_4), **arg_7)


def Func ( arg_0 ) : arg_1 = arg_0 . name if arg_0 . params : arg_1 = "%s(%s)" % ( arg_1 , "," . join ( [ str ( i ) for i in arg_0 . params ] ) ) return arg_0 . _Funcif ( arg_1 )

def Func(arg_0):
        """Return a default OpenQASM string for the instruction.

        Derived instructions may override this to print in a
        different format (e.g. measure q[0] -> c[0];).
        """
        arg_1 = arg_0.name
        if arg_0.params:
            arg_1 = "%s(%s)" % (arg_1, ",".join(
                [str(i) for i in arg_0.params]))

        return arg_0._Funcif(arg_1)

Return a default OpenQASM string for the instruction .


def Func ( arg_0 , arg_1 ) : if len ( arg_0 . coords ) <= 1 or arg_1 < 1 : return arg_0 . deepcopy ( ) arg_2 = interpolate_points ( arg_0 . coords , nb_steps = arg_1 , closed = False ) return arg_0 . deepcopy ( arg_2 = arg_2 )

def Func(arg_0, arg_1):
        """
        Adds ``N`` interpolated points with uniform spacing to each edge.

        For each edge between points ``A`` and ``B`` this adds points
        at ``A + (i/(1+N)) * (B - A)``, where ``i`` is the index of the added
        point and ``N`` is the number of points to add per edge.

        Calling this method two times will split each edge at its center
        and then again split each newly created edge at their center.
        It is equivalent to calling `Func(3)`.

        Parameters
        ----------
        points_per_edge : int
            Number of points to interpolate on each edge.

        Returns
        -------
        LineString
            Line string with Funcd edges.

        """
        if len(arg_0.coords) <= 1 or arg_1 < 1:
            return arg_0.deepcopy()
        arg_2 = interpolate_points(arg_0.coords, nb_steps=arg_1,
                                    closed=False)
        return arg_0.deepcopy(arg_2=arg_2)

Adds ``N`` interpolated points with uniform spacing to each edge.

        For each edge between points ``A`` and ``B`` this adds points
        at ``A + (i/(1+N)) * (B - A)``, where ``i`` is the index of the added
        point and ``N`` is the number of points to add per edge.

        Calling this method two times will split each edge at its center
        and then again split each newly created edge at their center.
        It is equivalent to calling `subdivide(3)`.

        Parameters
        ----------
        points_per_edge : int
            Number of points to interpolate on each edge.

        Returns
        -------
        LineString
            Line string with subdivided edges.

Adds N interpolated points with uniform spacing to each edge .


def Func ( arg_0 , arg_1 ) : arg_2 = PointFormat ( arg_0 ) . dtype arg_3 = PointFormat ( arg_1 ) . dtype arg_4 = arg_3 . fields arg_5 = [ ] for arg_6 in arg_2 . names : if arg_6 not in arg_4 : arg_5 . append ( arg_6 ) return arg_5

def Func(arg_0, arg_1):
    """  Returns a list of the names of the dimensions that will be lost
    when converting from point_fmt_in to point_fmt_out
    """

    arg_2 = PointFormat(arg_0).dtype
    arg_3 = PointFormat(arg_1).dtype

    arg_4 = arg_3.fields
    arg_5 = []
    for arg_6 in arg_2.names:
        if arg_6 not in arg_4:
            arg_5.append(arg_6)
    return arg_5


(
            self,
            decryption_algorithm,
            decryption_key,
            cipher_text,
            padding_method,
            hashing_algorithm=None)

def Func(
            arg_0,
            arg_1,
            arg_2,
            arg_3,
            arg_4,
            arg_5=None):
        """
        Encrypt data using asymmetric decryption.

        Args:
            decryption_algorithm (CryptographicAlgorithm): An enumeration
                specifying the asymmetric decryption algorithm to use for
                decryption. Required.
            decryption_key (bytes): The bytes of the private key to use for
                decryption. Required.
            cipher_text (bytes): The bytes to be decrypted. Required.
            padding_method (PaddingMethod): An enumeration specifying the
                padding method to use with the asymmetric decryption
                algorithm. Required.
            hashing_algorithm (HashingAlgorithm): An enumeration specifying
                the hashing algorithm to use with the decryption padding
                method. Required, if the padding method is OAEP. Optional
                otherwise, defaults to None.

        Returns:
            dict: A dictionary containing the decrypted data, with at least
                the following key/value field:
                * plain_text - the bytes of the decrypted data

        Raises:
            InvalidField: Raised when the algorithm is unsupported or the
                length is incompatible with the algorithm.
            CryptographicFailure: Raised when the key generation process
                fails.
        """
        if arg_1 == enums.CryptographicAlgorithm.RSA:
            if arg_4 == enums.PaddingMethod.OAEP:
                arg_6 = arg_0._encryption_hash_algorithms.get(
                    arg_5
                )
                if arg_6 is None:
                    raise exceptions.InvalidField(
                        "The hashing algorithm '{0}' is not supported for "
                        "asymmetric decryption.".format(arg_5)
                    )

                arg_4 = asymmetric_padding.OAEP(
                    mgf=asymmetric_padding.MGF1(
                        algorithm=arg_6()
                    ),
                    algorithm=arg_6(),
                    label=None
                )
            elif arg_4 == enums.PaddingMethod.PKCS1v15:
                arg_4 = asymmetric_padding.PKCS1v15()
            else:
                raise exceptions.InvalidField(
                    "The padding method '{0}' is not supported for asymmetric "
                    "decryption.".format(arg_4)
                )

            arg_7 = default_backend()

            try:
                arg_8 = arg_7.load_der_private_key(
                    arg_2,
                    None
                )
            except Exception:
                try:
                    arg_8 = arg_7.load_pem_private_key(
                        arg_2,
                        None
                    )
                except Exception:
                    raise exceptions.CryptographicFailure(
                        "The private key bytes could not be loaded."
                    )
            arg_9 = arg_8.decrypt(
                arg_3,
                arg_4
            )
            return arg_9
        else:
            raise exceptions.InvalidField(
                "The cryptographic algorithm '{0}' is not supported for "
                "asymmetric decryption.".format(arg_1)
            )

Encrypt data using asymmetric decryption .


def Func ( arg_0 = 10 , arg_1 = 500 , arg_2 = 50 ) : arg_3 = SM32 ( int ( arg_0 ) , int ( arg_1 ) ) arg_4 = numpy . array ( [ 1.0 ] * arg_2 , dtype = numpy . float32 ) for arg_5 in xrange ( arg_0 ) : arg_6 = numpy . array ( random . sample ( xrange ( arg_1 ) , arg_2 ) , dtype = numpy . uint32 ) arg_6 . sort ( ) arg_3 . setRowFromSparse ( arg_5 , arg_6 , arg_4 ) arg_7 = SM32 ( int ( arg_0 ) , int ( arg_1 ) ) arg_7 . initializeWithFixedNNZR ( arg_2 ) return arg_3

def Func(arg_0=10, arg_1=500, arg_2=50):
  """
  Generate a coincidence matrix. This is used to generate random inputs to the
  temporal learner and to compare the predicted output against.

  It generates a matrix of nCoinc rows, each row has length 'length' and has
  a total of 'activity' bits on.

  Parameters:
  -----------------------------------------------
  nCoinc:        the number of rows to generate
  length:        the length of each row
  activity:      the number of ones to put into each row.

  """

  arg_3 = SM32(int(arg_0), int(arg_1))
  arg_4 = numpy.array([1.0] * arg_2, dtype=numpy.float32)
  for arg_5 in xrange(arg_0):
    arg_6 = numpy.array(random.sample(xrange(arg_1),
                arg_2), dtype=numpy.uint32)
    arg_6.sort()
    arg_3.setRowFromSparse(arg_5, arg_6, arg_4)

  # This is the right code to use, it's faster, but it derails the unit
  # testing of the pooling for now.
  arg_7 = SM32(int(arg_0), int(arg_1))
  arg_7.initializeWithFixedNNZR(arg_2)

  return arg_3

Generate a coincidence matrix . This is used to generate random inputs to the temporal learner and to compare the predicted output against .


(cls, data,
             protocol=None,
             fallback_protocol=TBinaryProtocol,
             finagle_thrift=False,
             max_fields=MAX_FIELDS,
             max_list_size=MAX_LIST_SIZE,
             max_map_size=MAX_MAP_SIZE,
             max_set_size=MAX_SET_SIZE,
             read_values=False)

return cls(method, mtype, seqid, args, header, msglen), msglen

def
Func
(
arg_0
,
arg_1
,
arg_2
=
,
arg_3
=
arg_4
,
arg_5
=
False
,
arg_6
=
arg_7
,
arg_8
=
arg_9
,
arg_10
=
arg_11
,
arg_12
=
arg_13
,
arg_14
=
False
)
:
if
len
(
arg_1
)
<
arg_0
.
MIN_MESSAGE_SIZE
:
raise
ValueError
(
'not enough data'
)
if
arg_2
is
:
arg_2
=
arg_0
.
detect_protocol
(
arg_1
,
arg_3
)
arg_15
=
TTransport
.
TMemoryBuffer
(
arg_1
)
arg_16
=
arg_2
(
arg_15
)
arg_17
=
if
arg_5
:
try
:
arg_17
=
ThriftStruct
.
Func
(
arg_16
,
arg_6
,
arg_8
,
arg_10
,
arg_12
,
arg_14
)
except
:
arg_15
=
TTransport
.
TMemoryBuffer
(
arg_1
)
arg_16
=
arg_2
(
arg_15
)
arg_18
,
arg_19
,
arg_20
=
arg_16
.
FuncMessageBegin
(
)
arg_19
=
arg_0
.
message_type_to_str
(
arg_19
)
if
len
(
arg_18
)
==
0
or
arg_18
.
isspace
(
)
or
arg_18
.
startswith
(
' '
)
:
raise
ValueError
(
'no method name'
)
if
len
(
arg_18
)
>
arg_0
.
MAX_METHOD_LENGTH
:
raise
ValueError
(
'method name too long'
)
arg_21
=
range
(
33
,
127
)
if
any
(
ord
(
arg_22
)
not
in
arg_21
for
arg_22
in
arg_18
)
:
raise
ValueError
(
'invalid method name'
%
arg_18
)
arg_23
=
ThriftStruct
.
Func
(
arg_16
,
arg_6
,
arg_8
,
arg_10
,
arg_12
,
arg_14
)
arg_16
.
FuncMessageEnd
(
)
arg_24
=
arg_15
.
_buffer
.
tell
(
)
return
arg_0
(
arg_18
,
arg_19
,
arg_20
,
arg_23
,
arg_17
,
arg_24
)
,
arg_24

def Func(arg_0, arg_1,
             arg_2=None,
             arg_3=arg_4,
             arg_5=False,
             arg_6=arg_7,
             arg_8=arg_9,
             arg_10=arg_11,
             arg_12=arg_13,
             arg_14=False):
        """ tries to deserialize a message, might fail if data is missing """

        # do we have enough data?
        if len(arg_1) < arg_0.MIN_MESSAGE_SIZE:
            raise ValueError('not enough data')

        if arg_2 is None:
            arg_2 = arg_0.detect_protocol(arg_1, arg_3)
        arg_15 = TTransport.TMemoryBuffer(arg_1)
        arg_16 = arg_2(arg_15)

        # finagle-thrift prepends a RequestHeader
        #
        # See: http://git.io/vsziG
        arg_17 = None
        if arg_5:
            try:
                arg_17 = ThriftStruct.Func(
                    arg_16,
                    arg_6,
                    arg_8,
                    arg_10,
                    arg_12,
                    arg_14)
            except:
                # reset stream, maybe it's not finagle-thrift
                arg_15 = TTransport.TMemoryBuffer(arg_1)
                arg_16 = arg_2(arg_15)

        # unpack the message
        arg_18, arg_19, arg_20 = arg_16.FuncMessageBegin()
        arg_19 = arg_0.message_type_to_str(arg_19)

        if len(arg_18) == 0 or arg_18.isspace() or arg_18.startswith(' '):
            raise ValueError('no method name')

        if len(arg_18) > arg_0.MAX_METHOD_LENGTH:
            raise ValueError('method name too long')

        # we might have made it until this point by mere chance, so filter out
        # suspicious method names
        arg_21 = range(33, 127)
        if any(ord(arg_22) not in arg_21 for arg_22 in arg_18):
            raise ValueError('invalid method name' % arg_18)

        arg_23 = ThriftStruct.Func(
            arg_16,
            arg_6,
            arg_8,
            arg_10,
            arg_12,
            arg_14)

        arg_16.FuncMessageEnd()

        # Note: this is a bit fragile, the right thing would be to count bytes
        # as we Func them (i.e.: when calling FuncI32, etc).
        arg_24 = arg_15._buffer.tell()

        return arg_0(arg_18, arg_19, arg_20, arg_23, arg_17, arg_24), arg_24

tries to deserialize a message might fail if data is missing


def Func(arg_0, arg_1):
        """Parses the API response and raises appropriate errors if
        raise_errors was set to True
        """
        if not arg_0._raise_errors:
            return arg_1

        arg_2 = str(arg_1.status_code)[0] == '4'
        arg_3 = str(arg_1.status_code)[0] == '5'
        arg_4 = arg_1.content

        if arg_1.status_code == 403:
            raise AuthenticationError(arg_4)
        elif arg_2:
            raise APIError(arg_4)
        elif arg_3:
            raise ServerError(arg_4)

        return arg_1


def Func ( arg_0 , arg_1 ) : arg_2 = arg_0 . _containers . get ( arg_1 , None ) if not arg_2 is None : return arg_2 . get ( 'id' , None ) return None

def Func(arg_0, arg_1):
        '''Try to find the container ID with the specified name'''
        arg_2 = arg_0._containers.get(arg_1, None)
        if not arg_2 is None:
            return arg_2.get('id', None)
        return None


return numpy.array(non_delta_peak_split_points), \
               numpy.array(non_delta_peak_densities), delta_peak_loc_to_probability_mass

def Func(arg_0):
        """
        Temporal distance probability density function.

        Returns
        -------
        non_delta_peak_split_points: numpy.array
        non_delta_peak_densities: numpy.array
            len(density) == len(temporal_distance_split_points_ordered) -1
        delta_peak_loc_to_probability_mass : dict
        """
        arg_1, arg_2 = arg_0._temporal_distance_cdf()
        arg_3 = {}

        arg_4 = [arg_1[0]]
        arg_5 = []
        for arg_6 in range(0, len(arg_1) - 1):
            arg_7 = arg_1[arg_6]
            arg_8 = arg_1[arg_6 + 1]
            arg_9 = arg_8 - arg_7
            arg_10 = arg_2[arg_6 + 1] - arg_2[arg_6]
            if arg_9 == 0.0:
                arg_3[arg_7] = arg_10
            else:
                arg_4.append(arg_8)
                arg_5.append(arg_10 / float(arg_9))
        assert (len(arg_5) == len(arg_4) - 1)
        return numpy.array(arg_4), \
               numpy.array(arg_5), arg_3

Temporal distance probability density function .


def Func ( arg_0 , arg_1 ) : if is_type ( arg_1 , str ) : arg_1 = arg_0 . names . index ( arg_1 ) arg_2 = H2OFrame . _expr ( expr = ExprNode ( "cols" , arg_0 , arg_1 ) ) arg_3 = arg_0 . _ex . _cache arg_0 . _ex = ExprNode ( "cols" , arg_0 , - ( arg_1 + 1 ) ) arg_0 . _ex . _cache . ncols -= 1 arg_0 . _ex . _cache . names = arg_3 . names [ : arg_1 ] + arg_3 . names [ arg_1 + 1 : ] arg_0 . _ex . _cache . types = { name : arg_3 . types [ name ] for name in arg_0 . _ex . _cache . names } arg_0 . _ex . _cache . _data = None arg_2 . _ex . _cache . ncols = 1 arg_2 . _ex . _cache . names = [ arg_3 . names [ arg_1 ] ] return arg_2

def Func(arg_0, arg_1):
        """
        Pop a column from the H2OFrame at index i.

        :param i: The index (int) or name (str) of the column to Func.
        :returns: an H2OFrame containing the column dropped from the current frame; the current frame is modified
            in-place and loses the column.
        """
        if is_type(arg_1, str): arg_1 = arg_0.names.index(arg_1)
        arg_2 = H2OFrame._expr(expr=ExprNode("cols", arg_0, arg_1))
        arg_3 = arg_0._ex._cache
        arg_0._ex = ExprNode("cols", arg_0, -(arg_1 + 1))
        arg_0._ex._cache.ncols -= 1
        arg_0._ex._cache.names = arg_3.names[:arg_1] + arg_3.names[arg_1 + 1:]
        arg_0._ex._cache.types = {name: arg_3.types[name] for name in arg_0._ex._cache.names}
        arg_0._ex._cache._data = None
        arg_2._ex._cache.ncols = 1
        arg_2._ex._cache.names = [arg_3.names[arg_1]]
        return arg_2

Pop a column from the H2OFrame at index i.

        :param i: The index (int) or name (str) of the column to pop.
        :returns: an H2OFrame containing the column dropped from the current frame; the current frame is modified
            in-place and loses the column.

Pop a column from the H2OFrame at index i .


def Func ( arg_0 ) : arg_1 = hashlib . sha256 ( ) with open ( arg_0 , "rb" ) as f : for arg_2 in iter ( lambda : f . read ( 4096 ) , b"" ) : arg_1 . update ( arg_2 ) return arg_1 . hexdigest ( )

def Func(arg_0):
    '''find the SHA256 hash string of a file
    '''
    arg_1 = hashlib.sha256()
    with open(arg_0, "rb") as f:
        for arg_2 in iter(lambda: f.read(4096), b""):
            arg_1.update(arg_2)
    return arg_1.hexdigest()


def Func ( arg_0 ) : arg_1 = int ( math . sqrt ( arg_0 ) ) assert arg_1 * arg_1 == arg_0 return arg_1

def Func(arg_0):
    "If n2 is a perfect square, return its square root, else raise error."
    arg_1 = int(math.sqrt(arg_0))
    assert arg_1 * arg_1 == arg_0
    return arg_1

If n2 is a perfect square return its square root else raise error .


def
Func
(
arg_0
,
arg_1
=
'optimization failed'
)
:
arg_2
=
arg_0
.
solver
.
status
if
arg_2
!=
OPTIMAL
:
arg_3
=
OPTLANG_TO_EXCEPTIONS_DICT
.
get
(
arg_2
,
OptimizationError
)
raise
arg_3
(
"{} ({})"
.
format
(
arg_1
,
arg_2
)
)

def Func(arg_0, arg_1='optimization failed'):
    """Assert model solver status is optimal.

    Do nothing if model solver status is optimal, otherwise throw
    appropriate exception depending on the status.

    Parameters
    ----------
    model : cobra.Model
        The model to check the solver status for.
    message : str (optional)
        Message to for the exception if solver status was not optimal.
    """
    arg_2 = arg_0.solver.status
    if arg_2 != OPTIMAL:
        arg_3 = OPTLANG_TO_EXCEPTIONS_DICT.get(
            arg_2, OptimizationError)
        raise arg_3("{} ({})".format(arg_1, arg_2))


(self, log=None, ml_log=None, mlp_out=None, overwrite=False,
                   file_out=None, output_mask=None, script_file=None, print_meshlabserver_output=True)

def
Func
(
arg_0
,
arg_1
=
,
arg_2
=
,
arg_3
=
,
arg_4
=
False
,
arg_5
=
,
arg_6
=
,
arg_7
=
,
arg_8
=
True
)
:
arg_9
=
False
arg_10
=
False
if
arg_0
.
__no_file_in
:
arg_11
=
tempfile
.
NamedTemporaryFile
(
delete
=
False
,
suffix
=
'.xyz'
,
dir
=
os
.
getcwd
(
)
)
arg_11
.
write
(
b'0 0 0'
)
arg_11
.
close
(
)
arg_0
.
file_in
=
[
arg_11
.
name
]
if
not
arg_0
.
filters
:
arg_7
=
elif
arg_7
is
:
arg_9
=
True
arg_13
=
tempfile
.
NamedTemporaryFile
(
delete
=
False
,
suffix
=
'.mlx'
)
arg_13
.
close
(
)
arg_0
.
save_to_file
(
arg_13
.
name
)
arg_7
=
arg_13
.
name
if
(
arg_0
.
parse_geometry
or
arg_0
.
parse_topology
or
arg_0
.
parse_hausdorff
)
and
(
arg_2
is
)
:
arg_10
=
True
arg_14
=
tempfile
.
NamedTemporaryFile
(
delete
=
False
,
suffix
=
'.txt'
)
arg_14
.
close
(
)
arg_2
=
arg_14
.
name
if
arg_5
is
:
arg_5
=
arg_0
.
file_out
run
(
script
=
arg_7
,
arg_1
=
arg_1
,
arg_2
=
arg_2
,
mlp_in
=
arg_0
.
mlp_in
,
arg_3
=
arg_3
,
arg_4
=
arg_4
,
arg_12
=
arg_0
.
file_in
,
arg_5
=
arg_5
,
arg_6
=
arg_6
,
ml_version
=
arg_0
.
ml_version
,
arg_8
=
arg_8
)
if
arg_0
.
parse_geometry
:
arg_0
.
geometry
=
compute
.
parse_geometry
(
arg_2
,
arg_1
,
print_output
=
arg_8
)
if
arg_0
.
parse_topology
:
arg_0
.
topology
=
compute
.
parse_topology
(
arg_2
,
arg_1
,
print_output
=
arg_8
)
if
arg_0
.
parse_hausdorff
:
arg_0
.
hausdorff_distance
=
compute
.
parse_hausdorff
(
arg_2
,
arg_1
,
print_output
=
arg_8
)
if
arg_0
.
__no_file_in
:
os
.
remove
(
arg_11
.
name
)
if
arg_9
:
os
.
remove
(
arg_13
.
name
)
if
arg_10
:
os
.
remove
(
arg_14
.
name
)

def Func(arg_0, arg_1=None, arg_2=None, arg_3=None, arg_4=False,
                   arg_5=None, arg_6=None, arg_7=None, arg_8=True):
        """ Run the script
        """

        arg_9 = False
        arg_10 = False

        if arg_0.__no_file_in:
            # If no input files are provided, create a dummy file
            # with a single vertex and delete it first in the script.
            # This works around the fact that meshlabserver will
            # not run without an input file.
            arg_11 = tempfile.NamedTemporaryFile(delete=False, suffix='.xyz', dir=os.getcwd())
            arg_11.write(b'0 0 0')
            arg_11.close()
            arg_0.file_in = [arg_11.name]

        if not arg_0.filters:
            arg_7 = None
        elif arg_7 is None:
            # Create temporary script file
            arg_9 = True
            arg_13 = tempfile.NamedTemporaryFile(delete=False, suffix='.mlx')
            arg_13.close()
            arg_0.save_to_file(arg_13.name)
            arg_7 = arg_13.name

        if (arg_0.parse_geometry or arg_0.parse_topology or arg_0.parse_hausdorff) and (arg_2 is None):
            # create temp ml_log
            arg_10 = True
            arg_14 = tempfile.NamedTemporaryFile(delete=False, suffix='.txt')
            arg_14.close()
            arg_2 = arg_14.name
        if arg_5 is None:
            arg_5 = arg_0.file_out

        run(script=arg_7, arg_1=arg_1, arg_2=arg_2,
            mlp_in=arg_0.mlp_in, arg_3=arg_3, arg_4=arg_4,
            arg_12=arg_0.file_in, arg_5=arg_5, arg_6=arg_6, ml_version=arg_0.ml_version,
            arg_8=arg_8)

        # Parse output
        # TODO: record which layer this is associated with?
        if arg_0.parse_geometry:
            arg_0.geometry = compute.parse_geometry(arg_2, arg_1, print_output=arg_8)
        if arg_0.parse_topology:
            arg_0.topology = compute.parse_topology(arg_2, arg_1, print_output=arg_8)
        if arg_0.parse_hausdorff:
            arg_0.hausdorff_distance = compute.parse_hausdorff(arg_2, arg_1, print_output=arg_8)

        # Delete temp files
        if arg_0.__no_file_in:
            os.remove(arg_11.name)
        if arg_9:
            os.remove(arg_13.name)
        if arg_10:
            os.remove(arg_14.name)


return [
        create_binary_annotation(key, str(value), ann_type, host)
        for key, value in binary_annotations.items()
    ]

def Func ( arg_0 , arg_1 ) : arg_2 = zipkin_core . AnnotationType . STRING return [ create_binary_annotation ( arg_3 , str ( arg_4 ) , arg_2 , arg_1 ) for arg_3 , arg_4 in arg_0 . items ( ) ]

def Func(arg_0, arg_1):
    """
    Reformat binary annotations dict to return list of zipkin_core objects. The
    value of the binary annotations MUST be in string format.

    :param binary_annotations: dict with key, value being the name and value
                               of the binary annotation being logged.
    :type host: :class:`zipkin_core.Endpoint`
    :returns: a list of binary annotation zipkin_core objects
    :rtype: list
    """
    # TODO: Remove the type hard-coding of STRING to take it as a param option.
    arg_2 = zipkin_core.AnnotationType.STRING
    return [
        create_binary_annotation(arg_3, str(arg_4), arg_2, arg_1)
        for arg_3, arg_4 in arg_0.items()
    ]

Reformat binary annotations dict to return list of zipkin_core objects . The value of the binary annotations MUST be in string format .


return self.fetch_json(
            uri_path=self.base_uri + '/checkItems',
            http_method='POST',
            query_params=query_params or {}
        )

def Func ( arg_0 , arg_1 = None ) : return arg_0 . fetch_json ( uri_path = arg_0 . base_uri + '/checkItems' , http_method = 'POST' , arg_1 = arg_1 or { } )

def Func(arg_0, arg_1=None):
        '''
        Add an item to this checklist. Returns a dictionary of values of new
        item.
        '''
        return arg_0.fetch_json(
            uri_path=arg_0.base_uri + '/checkItems',
            http_method='POST',
            arg_1=arg_1 or {}
        )

Add an item to this checklist . Returns a dictionary of values of new item .


def
Func
(
arg_0
,
arg_1
,
arg_2
,
arg_3
=
False
)
:
arg_4
,
arg_5
,
arg_6
=
read_element_tag
(
arg_0
,
arg_1
)
if
arg_2
and
arg_4
not
in
[
etypes
[
arg_7
]
[
'n'
]
for
arg_7
in
arg_2
]
:
raise
ParseError
(
'Got type {}, expected {}'
.
format
(
arg_4
,
' / '
.
join
(
'{} ({})'
.
format
(
etypes
[
arg_7
]
[
'n'
]
,
arg_7
)
for
arg_7
in
arg_2
)
)
)
if
not
arg_6
:
arg_6
=
arg_0
.
read
(
arg_5
)
arg_8
=
arg_5
%
8
if
arg_8
:
arg_0
.
seek
(
8
arg_8
,
1
)
if
arg_3
:
arg_9
=
's'
arg_10
=
[
unpack
(
arg_1
,
arg_9
,
s
)
for
s
in
arg_6
.
split
(
b'\0'
)
if
s
]
if
len
(
arg_10
)
==
0
:
arg_10
=
''
elif
len
(
arg_10
)
==
1
:
arg_10
=
asstr
(
arg_10
[
0
]
)
else
:
arg_10
=
[
asstr
(
s
)
for
s
in
arg_10
]
else
:
arg_9
=
etypes
[
inv_etypes
[
arg_4
]
]
[
'fmt'
]
arg_10
=
unpack
(
arg_1
,
arg_9
,
arg_6
)
return
arg_10

def Func(arg_0, arg_1, arg_2, arg_3=False):
    """Read elements from the file.

    If list of possible matrix data types mtps is provided, the data type
    of the elements are verified.
    """
    arg_4, arg_5, arg_6 = read_element_tag(arg_0, arg_1)
    if arg_2 and arg_4 not in [etypes[arg_7]['n'] for arg_7 in arg_2]:
        raise ParseError('Got type {}, expected {}'.format(
            arg_4, ' / '.join('{} ({})'.format(
                etypes[arg_7]['n'], arg_7) for arg_7 in arg_2)))
    if not arg_6:
        # full format, read data
        arg_6 = arg_0.read(arg_5)
        # Seek to next 64-bit boundary
        arg_8 = arg_5 % 8
        if arg_8:
            arg_0.seek(8 - arg_8, 1)

    # parse data and return values
    if arg_3:
        # names are stored as miINT8 bytes
        arg_9 = 's'
        arg_10 = [unpack(arg_1, arg_9, s)
               for s in arg_6.split(b'\0') if s]
        if len(arg_10) == 0:
            arg_10 = ''
        elif len(arg_10) == 1:
            arg_10 = asstr(arg_10[0])
        else:
            arg_10 = [asstr(s) for s in arg_10]
    else:
        arg_9 = etypes[inv_etypes[arg_4]]['fmt']
        arg_10 = unpack(arg_1, arg_9, arg_6)
    return arg_10


def Func ( arg_0 , arg_1 ) : for arg_2 in arg_0 : arg_3 = [ ] for arg_4 in arg_1 : if hasattr ( arg_2 , arg_4 ) : arg_3 . append ( getattr ( arg_2 , arg_4 ) ) yield arg_3

def Func(arg_0, arg_1):
    """Func pipe can extract attribute values of object.

    If attr_names is a list and its item is not a valid attribute of
    prev's object. It will be excluded from yielded dict.

    :param prev: The previous iterator of pipe.
    :type prev: Pipe
    :param attr_names: The list of attribute names
    :type attr_names: str of list
    :returns: generator
    """
    for arg_2 in arg_0:
        arg_3 = []
        for arg_4 in arg_1:
            if hasattr(arg_2, arg_4):
                arg_3.append(getattr(arg_2, arg_4))
        yield arg_3

attrs pipe can extract attribute values of object.

    If attr_names is a list and its item is not a valid attribute of
    prev's object. It will be excluded from yielded dict.

    :param prev: The previous iterator of pipe.
    :type prev: Pipe
    :param attr_names: The list of attribute names
    :type attr_names: str of list
    :returns: generator

attrs pipe can extract attribute values of object .


async def Func(arg_0, arg_1):
        """ Shows some stats about the currently playing song. """
        arg_2 = arg_0.bot.lavalink.players.get(arg_1.guild.id)
        arg_3 = 'Nothing'

        if arg_2.current:
            arg_4 = lavalink.Utils.format_time(arg_2.position)
            if arg_2.current.stream:
                arg_5 = '🔴 LIVE'
            else:
                arg_5 = lavalink.Utils.format_time(arg_2.current.duration)
            arg_3 = f'**[{player.current.title}]({player.current.uri})**\n({position}/{duration})'

        arg_6 = discord.Embed(color=discord.Color.blurple(), title='Now Playing', description=arg_3)
        await arg_1.send(arg_6=arg_6)

Shows some stats about the currently playing song .


def Func ( arg_0 , arg_1 = 2 ** 10 , arg_2 = 1 ) : arg_3 , arg_4 = pylab . mlab . psd ( arg_0 , arg_1 , arg_2 ) return arg_3 . flatten ( ) , arg_4

def Func(arg_0,arg_1=2**10,arg_2=1):
    """
    A local version of NumPy's PSD function that returns the plot arrays.

    A mlab.psd wrapper function that returns two ndarrays;
    makes no attempt to auto plot anything.

    Parameters
    ----------
    x : ndarray input signal
    NFFT : a power of two, e.g., 2**10 = 1024
    Fs : the sampling rate in Hz

    Returns
    -------
    Px : ndarray of the power spectrum estimate
    f : ndarray of frequency values

    Notes
    -----
    This function makes it easier to overlay spectrum plots because
    you have better control over the axis scaling than when using psd()
    in the autoscale mode.

    Examples
    --------
    >>> import matplotlib.pyplot as plt
    >>> from sk_dsp_comm import digitalcom as dc
    >>> from numpy import log10
    >>> x,b, data = dc.NRZ_bits(10000,10)
    >>> Px,f = dc.Func(x,2**10,10)
    >>> plt.plot(f, 10*log10(Px))
    >>> plt.show()
    """
    arg_3,arg_4 = pylab.mlab.psd(arg_0,arg_1,arg_2)
    return arg_3.flatten(), arg_4

A local version of NumPy's PSD function that returns the plot arrays.

    A mlab.psd wrapper function that returns two ndarrays;
    makes no attempt to auto plot anything.

    Parameters
    ----------
    x : ndarray input signal
    NFFT : a power of two, e.g., 2**10 = 1024
    Fs : the sampling rate in Hz

    Returns
    -------
    Px : ndarray of the power spectrum estimate
    f : ndarray of frequency values

    Notes
    -----
    This function makes it easier to overlay spectrum plots because
    you have better control over the axis scaling than when using psd()
    in the autoscale mode.

    Examples
    --------
    >>> import matplotlib.pyplot as plt
    >>> from sk_dsp_comm import digitalcom as dc
    >>> from numpy import log10
    >>> x,b, data = dc.NRZ_bits(10000,10)
    >>> Px,f = dc.my_psd(x,2**10,10)
    >>> plt.plot(f, 10*log10(Px))
    >>> plt.show()

A local version of NumPy s PSD function that returns the plot arrays .