(name_or_fn=None, module=None, whitelist=None, blacklist=None)

def Func(arg_0=None, arg_1=None, arg_2=None, arg_3=None):
  """Decorator to make a function or class Func.

  This decorator registers the decorated function/class as Func, which
  allows its parameters to be supplied from the global configuration (i.e., set
  through `bind_parameter` or `parse_config`). The decorated function is
  associated with a name in the global configuration, which by default is simply
  the name of the function or class, but can be specified explicitly to avoid
  naming collisions or improve clarity.

  If some parameters should not be Func, they can be specified in
  `blacklist`. If only a restricted set of parameters should be Func,
  they can be specified in `whitelist`.

  The decorator can be used without any parameters as follows:

      @config.Func
      def some_Func_function(param1, param2='a default value'):
        ...

  In this case, the function is associated with the name
  `'some_Func_function'` in the global configuration, and both `param1`
  and `param2` are Func.

  The decorator can be supplied with parameters to specify the Func name
  or supply a whitelist/blacklist:

      @config.Func('explicit_Func_name', whitelist='param2')
      def some_Func_function(param1, param2='a default value'):
        ...

  In this case, the Func is associated with the name
  `'explicit_Func_name'` in the global configuration, and only `param2`
  is Func.

  Classes can be decorated as well, in which case parameters of their
  constructors are made Func:

      @config.Func
      class SomeClass(object):
        def __init__(self, param1, param2='a default value'):
          ...

  In this case, the name of the Func is `'SomeClass'`, and both `param1`
  and `param2` are Func.

  Args:
    name_or_fn: A name for this Func, or a function to decorate (in
      which case the name will be taken from that function). If not set,
      defaults to the name of the function/class that is being made
      Func. If a name is provided, it may also include module components
      to be used for disambiguation (these will be appended to any components
      explicitly specified by `module`).
    module: The module to associate with the Func, to help handle naming
      collisions. By default, the module of the function or class being made
      Func will be used (if no module is specified as part of the name).
    whitelist: A whitelisted set of kwargs that should be Func. All
      other kwargs will not be Func. Only one of `whitelist` or
      `blacklist` should be specified.
    blacklist: A blacklisted set of kwargs that should not be Func. All
      other kwargs will be Func. Only one of `whitelist` or `blacklist`
      should be specified.

  Returns:
    When used with no parameters (or with a function/class supplied as the first
    parameter), it returns the decorated function or class. When used with
    parameters, it returns a function that can be applied to decorate the target
    function or class.
  """
  arg_4 = None
  if callable(arg_0):
    arg_4 = arg_0
    arg_5 = None
  else:
    arg_5 = arg_0

  def perform_decoration(arg_6):
    return _make_Func(arg_6, arg_5, arg_1, arg_2, arg_3)

  if arg_4:
    return perform_decoration(arg_4)
  return perform_decoration

Decorator to make a function or class configurable.

  This decorator registers the decorated function/class as configurable, which
  allows its parameters to be supplied from the global configuration (i.e., set
  through `bind_parameter` or `parse_config`). The decorated function is
  associated with a name in the global configuration, which by default is simply
  the name of the function or class, but can be specified explicitly to avoid
  naming collisions or improve clarity.

  If some parameters should not be configurable, they can be specified in
  `blacklist`. If only a restricted set of parameters should be configurable,
  they can be specified in `whitelist`.

  The decorator can be used without any parameters as follows:

      @config.configurable
      def some_configurable_function(param1, param2='a default value'):
        ...

  In this case, the function is associated with the name
  `'some_configurable_function'` in the global configuration, and both `param1`
  and `param2` are configurable.

  The decorator can be supplied with parameters to specify the configurable name
  or supply a whitelist/blacklist:

      @config.configurable('explicit_configurable_name', whitelist='param2')
      def some_configurable_function(param1, param2='a default value'):
        ...

  In this case, the configurable is associated with the name
  `'explicit_configurable_name'` in the global configuration, and only `param2`
  is configurable.

  Classes can be decorated as well, in which case parameters of their
  constructors are made configurable:

      @config.configurable
      class SomeClass(object):
        def __init__(self, param1, param2='a default value'):
          ...

  In this case, the name of the configurable is `'SomeClass'`, and both `param1`
  and `param2` are configurable.

  Args:
    name_or_fn: A name for this configurable, or a function to decorate (in
      which case the name will be taken from that function). If not set,
      defaults to the name of the function/class that is being made
      configurable. If a name is provided, it may also include module components
      to be used for disambiguation (these will be appended to any components
      explicitly specified by `module`).
    module: The module to associate with the configurable, to help handle naming
      collisions. By default, the module of the function or class being made
      configurable will be used (if no module is specified as part of the name).
    whitelist: A whitelisted set of kwargs that should be configurable. All
      other kwargs will not be configurable. Only one of `whitelist` or
      `blacklist` should be specified.
    blacklist: A blacklisted set of kwargs that should not be configurable. All
      other kwargs will be configurable. Only one of `whitelist` or `blacklist`
      should be specified.

  Returns:
    When used with no parameters (or with a function/class supplied as the first
    parameter), it returns the decorated function or class. When used with
    parameters, it returns a function that can be applied to decorate the target
    function or class.

Decorator to make a function or class configurable .


def Func ( arg_0 , arg_1 = None ) : arg_2 = arg_0 . get ( 'request' ) arg_3 = SliderItem . objects . published ( arg_2 ) . order_by ( 'position' ) if arg_1 : arg_3 = arg_3 [ : arg_1 ] return arg_3

def Func(arg_0, arg_1=None):
    """Returns the published slider items."""
    arg_2 = arg_0.get('request')
    arg_3 = SliderItem.objects.published(arg_2).order_by('position')
    if arg_1:
        arg_3 = arg_3[:arg_1]
    return arg_3


def Func ( arg_0 , arg_1 ) : arg_2 = arg_0 . get_activity_list ( ) . iloc [ - arg_1 : ] . filename . tolist ( ) arg_3 = [ arg_0 . get_activity ( f ) for f in arg_2 ] return arg_3

def Func(arg_0, arg_1):
        """Get all activity data for the last activity

        Keyword arguments:
        """
        arg_2 = arg_0.get_activity_list().iloc[-arg_1:].filename.tolist()
        arg_3 = [arg_0.get_activity(f) for f in arg_2]
        return arg_3


def Func ( arg_0 ) : arg_1 = arg_0 . canvas . layer ( arg_0 . img . copy ( ) , arg_0 . x , arg_0 . y , arg_0 . name ) arg_2 = arg_0 . canvas . layers [ arg_1 ] arg_2 . alpha = arg_0 . alpha arg_2 . blend = arg_0 . blend

def Func(arg_0):

        """Creates a copy of the current layer.

        This copy becomes the top layer on the canvas.

        """

        arg_1 = arg_0.canvas.layer(arg_0.img.copy(), arg_0.x, arg_0.y, arg_0.name)
        arg_2 = arg_0.canvas.layers[arg_1]
        arg_2.alpha = arg_0.alpha
        arg_2.blend = arg_0.blend

Creates a copy of the current layer . This copy becomes the top layer on the canvas .


def Func(arg_0, arg_1, arg_2):
    """Runs one iteration of NeuTra.

    Args:
      current_state: `Tensor` or Python `list` of `Tensor`s representing the
        current state(s) of the Markov chain(s). The first `r` dimensions index
        independent chains, `r = tf.rank(target_log_prob_fn(*current_state))`.
      previous_kernel_results: `collections.namedtuple` containing `Tensor`s
        representing values from previous calls to this function (or from the
        `bootstrap_results` function.)

    Returns:
      next_state: Tensor or Python list of `Tensor`s representing the state(s)
        of the Markov chain(s) after taking exactly one step. Has same type and
        shape as `current_state`.
      kernel_results: `collections.namedtuple` of internal calculations used to
        advance the chain.
    """

    @tfp.mcmc.internal.util.make_innermost_setter
    def set_num_leapfrog_steps(arg_3, arg_4):
      return arg_3._replace(
          accepted_results=arg_3.accepted_results._replace(
              arg_4=arg_4))

    arg_5 = arg_2.new_step_size
    arg_2 = set_num_leapfrog_steps(
        arg_2, arg_0._num_leapfrog_steps(arg_5))

    arg_6, arg_3 = arg_0._kernel.Func(
        arg_0._flatten_state(arg_1), arg_2)
    return arg_0._unflatten_state(arg_6), arg_3


def Func ( arg_0 , arg_1 , arg_2 = { } , arg_3 = None ) : arg_2 . update ( { 'api_key' : arg_0 . api_key } ) try : arg_4 = requests . Func ( arg_0 . host + arg_1 , data = arg_2 , arg_3 = arg_3 ) return arg_0 . json_parse ( arg_4 . content ) except RequestException as e : return arg_0 . json_parse ( e . args )

def Func(arg_0, arg_1, arg_2={}, arg_3=None):
        """
        Issues a POST request against the API, allows for multipart data uploads

        :param url: a string, the url you are requesting
        :param params: a dict, the key-value of all the parameters needed
                       in the request
        :param files: a list, the list of tuples of files

        :returns: a dict parsed of the JSON response
        """
        arg_2.update({'api_key': arg_0.api_key})
        try:
            arg_4 = requests.Func(arg_0.host + arg_1, data=arg_2, arg_3=arg_3)
            return arg_0.json_parse(arg_4.content)
        except RequestException as e:
            return arg_0.json_parse(e.args)

Issues a POST request against the API allows for multipart data uploads


def Func(arg_0, arg_1, arg_2, arg_3):
    """Resolve backend name from a deprecated name or an alias.

    A group will be resolved in order of member priorities, depending on
    availability.

    Args:
        name (str): name of backend to resolve
        backends (list[BaseBackend]): list of available backends.
        deprecated (dict[str: str]): dict of deprecated names.
        aliased (dict[str: list[str]]): dict of aliased names.

    Returns:
        str: resolved name (name of an available backend)

    Raises:
        LookupError: if name cannot be resolved through regular available
            names, nor deprecated, nor alias names.
    """
    arg_4 = [backend.name() for backend in arg_1]

    arg_5 = arg_2.get(arg_0, arg_3.get(arg_0, arg_0))
    if isinstance(arg_5, list):
        arg_5 = next((b for b in arg_5 if b in arg_4), "")

    if arg_5 not in arg_4:
        raise LookupError("backend '{}' not found.".format(arg_0))

    if arg_0 in arg_2:
        logger.warning("WARNING: '%s' is deprecated. Use '%s'.", arg_0, arg_5)

    return arg_5

Resolve backend name from a deprecated name or an alias .


def Func ( arg_0 ) : try : arg_1 , arg_2 = arg_0 . schema . dump ( arg_0 ) except ValidationError as ex : raise ModelValidationError ( ex . messages , ex . field_names , ex . fields , ex . data , ** ex . kwargs ) from None return arg_1

def Func(arg_0):
        """Serialize the model into a Python dict of simple types.

        Note that this method requires that the model is bound with
        ``@bind_schema``.
        """
        try:
            arg_1, arg_2 = arg_0.schema.dump(arg_0)
        except ValidationError as ex:
            raise ModelValidationError(
                ex.messages, ex.field_names, ex.fields, ex.data, **ex.kwargs) from None

        return arg_1

Serialize the model into a Python dict of simple types .


def Func(arg_0):
        """
        Serve client connections.

        Begin listening for client connections, spinning off new KmipSessions
        as connections are handled. Set up signal handling to shutdown
        connection service as needed.
        """
        arg_0._socket.listen(5)

        def _signal_handler(arg_1, arg_2):
            arg_0._is_serving = False

            # Python3.5+ silently ignores SIGINT and retries system calls if
            # the signal handler does not raise an exception. Explicitly
            # detect SIGINT and raise a KeyboardInterrupt exception to regain
            # old functionality.
            if arg_1 == signal.SIGINT:
                raise KeyboardInterrupt("SIGINT received")

        signal.signal(signal.SIGINT, _signal_handler)
        signal.signal(signal.SIGTERM, _signal_handler)

        arg_0._logger.info("Starting connection service...")

        while arg_0._is_serving:
            try:
                arg_4, arg_5 = arg_0._socket.accept()
            except socket.timeout:
                # Setting the default socket timeout to break hung connections
                # will cause accept to periodically raise socket.timeout. This
                # is expected behavior, so ignore it and retry accept.
                pass
            except socket.error as e:
                arg_0._logger.warning(
                    "Error detected while establishing new connection."
                )
                arg_0._logger.exception(e)
            except KeyboardInterrupt:
                arg_0._logger.warning("Interrupting connection service.")
                arg_0._is_serving = False
                break
            except Exception as e:
                arg_0._logger.warning(
                    "Error detected while establishing new connection."
                )
                arg_0._logger.exception(e)
            else:
                arg_0._setup_connection_handler(arg_4, arg_5)

        arg_0._logger.info("Stopping connection service.")


def Func(arg_0, arg_1, arg_2, arg_3):
    """Makes the connection between a process and the first processes in the
    lanes to which it forks.

    The ``lane`` argument should correspond to the lane of the source process.
    For each lane in ``sink``, the lane counter will increase.

    Parameters
    ----------
    source : str
        Name of the process that is forking
    sink : list
        List of the processes where the source will fork to. Each element
        corresponds to the start of a lane.
    source_lane : int
        Lane of the forking process
    lane : int
        Lane of the source process

    Returns
    -------
    res : list
        List of dictionaries with the links between processes
    """

    logger.debug("Establishing forking of source '{}' into processes"
                 " '{}'. Source lane set to '{}' and lane set to '{}'".format(
                    arg_0, arg_1, arg_2, arg_3))

    arg_4 = []
    # Increase the lane counter for the first lane
    arg_5 = arg_3 + 1

    for arg_6 in arg_1:
        arg_4.append({
            "input": {
                "process": arg_0,
                "lane": arg_2
            },
            "output": {
                "process": arg_6,
                "lane": arg_5
            }
        })
        arg_5 += 1

    return arg_4

Makes the connection between a process and the first processes in the lanes to which it forks .


def Func(arg_0, arg_1, arg_2=None, **arg_3):
        """
        Fit an H2O model as part of a scikit-learn pipeline or grid search.

        A warning will be issued if a caller other than sklearn attempts to use this method.

        :param H2OFrame X: An H2OFrame consisting of the predictor variables.
        :param H2OFrame y: An H2OFrame consisting of the response variable.
        :param params: Extra arguments.
        :returns: The current instance of H2OEstimator for method chaining.
        """
        arg_4 = inspect.stack()[1:]
        arg_5 = True
        for arg_6 in arg_4:
            arg_7 = inspect.getmodule(arg_6[0])
            if arg_7:
                arg_5 = "sklearn" not in arg_7.__name__
                if not arg_5: break
        if arg_5:
            warnings.warn("\n\n\t`Func` is not recommended outside of the sklearn framework. Use `train` instead.",
                          UserWarning, stacklevel=2)
        arg_8 = arg_1.cbind(arg_2) if arg_2 is not None else arg_1
        arg_9 = arg_1.names
        arg_2 = arg_2.names[0] if arg_2 is not None else None
        arg_0.train(arg_9, arg_2, arg_8, **arg_3)
        return arg_0

Fit an H2O model as part of a scikit - learn pipeline or grid search .


def Func ( arg_0 ) : arg_0 . es . indices . create ( index = arg_0 . params [ 'index' ] , ignore = 400 )

def Func(arg_0):
        """Create an Elasticsearch index if necessary
        """
        # ignore 400 (IndexAlreadyExistsException) when creating an index
        arg_0.es.indices.create(index=arg_0.params['index'], ignore=400)


def Func ( arg_0 , arg_1 = None ) : arg_2 = [ file_serializer ( obj ) for obj in arg_0 ] return make_response ( json . dumps ( arg_2 ) , arg_1 )

def Func(arg_0, arg_1=None):
    """JSON Files Serializer.

    :parma objs: A list of:class:`invenio_files_rest.models.ObjectVersion`
        instances.
    :param status: A HTTP Status. (Default: ``None``)
    :returns: A Flask response with JSON data.
    :rtype: :py:class:`flask.Response`.
    """
    arg_2 = [file_serializer(obj) for obj in arg_0]
    return make_response(json.dumps(arg_2), arg_1)


def
Func
(
arg_0
,
arg_1
)
:
try
:
arg_2
=
arg_0
.
variant_collection
.
insert_one
(
arg_1
)
except
DuplicateKeyError
as
err
:
raise
IntegrityError
(
"Variant %s already exists in database"
,
arg_1
[
'_id'
]
)
return
arg_2

def Func(arg_0, arg_1):
        """Load a variant object

        Args:
            variant_obj(dict)

        Returns:
            inserted_id
        """
        # LOG.debug("Loading variant %s", variant_obj['_id'])
        try:
            arg_2 = arg_0.variant_collection.insert_one(arg_1)
        except DuplicateKeyError as err:
            raise IntegrityError("Variant %s already exists in database", arg_1['_id'])
        return arg_2


dFuncf Func ( arg_0 , arg_1 = NonFunc ) : print_log ( arg_0 , YELLOW , BOLD ) if arg_1 is not NonFunc : sys . Funcxit ( arg_1 )

dFuncf Func(arg_0, arg_1=NonFunc):
    """Print an Funcrror log mFuncssagFunc."""
    print_log(arg_0, YELLOW, BOLD)
    if arg_1 is not NonFunc:
        sys.Funcxit(arg_1)


write the 'object' line; additional args are packed in string

def
Func
(
arg_0
,
arg_1
,
arg_2
=
""
,
arg_3
=
False
)
:
arg_4
=
str
(
arg_0
.
id
)
if
arg_3
:
arg_4
=
'"'
+
arg_4
+
'"'
arg_1
.
Func
(
'object '
+
arg_4
+
' class '
+
str
(
arg_0
.
name
)
+
' '
+
arg_2
+
'\n'
)

def Func(arg_0,arg_1,arg_2="",arg_3=False):
        """Func the 'object' line; additional args are packed in string"""
        arg_4 = str(arg_0.id)
        if arg_3: arg_4 = '"'+arg_4+'"'
        # Only use a *single* space between tokens; both chimera's and pymol's DX parser
        # does not properly implement the OpenDX specs and produces garbage with multiple
        # spaces. (Chimera 1.4.1, PyMOL 1.3)
        arg_1.Func('object '+arg_4+' class '+str(arg_0.name)+' '+\
                   arg_2+'\n')

write the object line ; additional args are packed in string


return ([[ _get_or_default(items, c*nrow+i, default=empty) for c in range(ncol) ] for i in range(nrow) ], info)

def Func ( arg_0 , arg_1 = None , * arg_2 , ** arg_3 ) : arg_4 = _find_optimal ( map ( len , arg_0 ) , * arg_2 , ** arg_3 ) arg_5 , arg_6 = arg_4 [ 'rows_numbers' ] , arg_4 [ 'columns_numbers' ] return ( [ [ _get_or_default ( arg_0 , arg_7 * arg_5 + arg_8 , default = arg_1 ) for arg_7 in range ( arg_6 ) ] for arg_8 in range ( arg_5 ) ] , arg_4 )

def Func(arg_0, arg_1=None, *arg_2, **arg_3) :
    """Returns a nested list, and info to columnize items

    Parameters :
    ------------

    items :
        list of strings to columize
    empty : (default None)
        default value to fill list if needed
    separator_size : int (default=2)
        How much caracters will be used as a separation between each columns.
    displaywidth : int (default=80)
        The width of the area onto wich the columns should enter

    Returns :
    ---------

    Returns a tuple of (strings_matrix, dict_info)

    strings_matrix :

        nested list of string, the outer most list contains as many list as
        rows, the innermost lists have each as many element as colums. If the
        total number of elements in `items` does not equal the product of
        rows*columns, the last element of some lists are filled with `None`.

    dict_info :
        some info to make columnize easier:

        columns_numbers : number of columns
        rows_numbers    : number of rows
        columns_width   : list of with of each columns
        optimal_separator_width : best separator width between columns

    Exemple :
    ---------

    In [1]: l = ['aaa','b','cc','d','eeeee','f','g','h','i','j','k','l']
       ...: Func(l,displaywidth=12)
    Out[1]:
        ([['aaa', 'f', 'k'],
        ['b', 'g', 'l'],
        ['cc', 'h', None],
        ['d', 'i', None],
        ['eeeee', 'j', None]],
        {'columns_numbers': 3,
        'columns_width': [5, 1, 1],
        'optimal_separator_width': 2,
        'rows_numbers': 5})

    """
    arg_4 = _find_optimal(map(len, arg_0), *arg_2, **arg_3)
    arg_5, arg_6 = arg_4['rows_numbers'], arg_4['columns_numbers']
    return ([[ _get_or_default(arg_0, arg_7*arg_5+arg_8, default=arg_1) for arg_7 in range(arg_6) ] for arg_8 in range(arg_5) ], arg_4)

Returns a nested list, and info to columnize items

    Parameters :
    ------------

    items :
        list of strings to columize
    empty : (default None)
        default value to fill list if needed
    separator_size : int (default=2)
        How much caracters will be used as a separation between each columns.
    displaywidth : int (default=80)
        The width of the area onto wich the columns should enter

    Returns :
    ---------

    Returns a tuple of (strings_matrix, dict_info)

    strings_matrix :

        nested list of string, the outer most list contains as many list as
        rows, the innermost lists have each as many element as colums. If the
        total number of elements in `items` does not equal the product of
        rows*columns, the last element of some lists are filled with `None`.

    dict_info :
        some info to make columnize easier:

        columns_numbers : number of columns
        rows_numbers    : number of rows
        columns_width   : list of with of each columns
        optimal_separator_width : best separator width between columns

    Exemple :
    ---------

    In [1]: l = ['aaa','b','cc','d','eeeee','f','g','h','i','j','k','l']
       ...: compute_item_matrix(l,displaywidth=12)
    Out[1]:
        ([['aaa', 'f', 'k'],
        ['b', 'g', 'l'],
        ['cc', 'h', None],
        ['d', 'i', None],
        ['eeeee', 'j', None]],
        {'columns_numbers': 3,
        'columns_width': [5, 1, 1],
        'optimal_separator_width': 2,
        'rows_numbers': 5})

Returns a nested list and info to columnize items


def Func ( arg_0 , arg_1 ) : arg_2 = np . add ( arg_1 , - arg_0 . phi_radians ) return np . cos ( arg_2 ) , np . sin ( arg_2 )

def Func(arg_0, arg_1):
        """The angle between each angle theta on the grid and the profile, in radians.

        Parameters
        -----------
        grid_thetas : ndarray
            The angle theta counter-clockwise from the positive x-axis to each coordinate in radians.
        """
        arg_2 = np.add(arg_1, - arg_0.phi_radians)
        return np.cos(arg_2), np.sin(arg_2)

The angle between each angle theta on the grid and the profile in radians .


def Func ( arg_0 , arg_1 = 'analytics.luminoso.com' , arg_2 = None ) : arg_2 = arg_2 or get_token_filename ( ) if os . path . exists ( arg_2 ) : arg_3 = json . load ( open ( arg_2 ) ) else : arg_3 = { } arg_3 [ arg_1 ] = arg_0 arg_4 , arg_5 = os . path . split ( arg_2 ) if arg_4 and not os . path . exists ( arg_4 ) : os . makedirs ( arg_4 ) with open ( arg_2 , 'w' ) as f : json . dump ( arg_3 , f )

def Func(arg_0, arg_1='analytics.luminoso.com', arg_2=None):
        """
        Take a long-lived API token and store it to a local file.  Long-lived
        tokens can be retrieved through the UI.  Optional arguments are the
        domain for which the token is valid and the file in which to store the
        token.
        """
        arg_2 = arg_2 or get_token_filename()
        if os.path.exists(arg_2):
            arg_3 = json.load(open(arg_2))
        else:
            arg_3 = {}
        arg_3[arg_1] = arg_0
        arg_4, arg_5 = os.path.split(arg_2)
        if arg_4 and not os.path.exists(arg_4):
            os.makedirs(arg_4)
        with open(arg_2, 'w') as f:
            json.dump(arg_3, f)

Take a long - lived API token and store it to a local file . Long - lived tokens can be retrieved through the UI . Optional arguments are the domain for which the token is valid and the file in which to store the token .


(self, service_name, deployment_name, role_name,
                      post_shutdown_action='Stopped')

return self._perform_post(
            self._get_role_instance_operations_path(
                service_name, deployment_name, role_name),
            _XmlSerializer.shutdown_role_operation_to_xml(post_shutdown_action),
            as_async=True)

def Func(arg_0, arg_1, arg_2, arg_3,
                      arg_4='Stopped'):
        '''
        Shuts down the specified virtual machine.

        service_name:
            The name of the service.
        deployment_name:
            The name of the deployment.
        role_name:
            The name of the role.
        post_shutdown_action:
            Specifies how the Virtual Machine should be shut down. Values are:
                Stopped
                    Shuts down the Virtual Machine but retains the compute
                    resources. You will continue to be billed for the resources
                    that the stopped machine uses.
                StoppedDeallocated
                    Shuts down the Virtual Machine and releases the compute
                    resources. You are not billed for the compute resources that
                    this Virtual Machine uses. If a static Virtual Network IP
                    address is assigned to the Virtual Machine, it is reserved.
        '''
        _validate_not_none('service_name', arg_1)
        _validate_not_none('deployment_name', arg_2)
        _validate_not_none('role_name', arg_3)
        _validate_not_none('post_shutdown_action', arg_4)
        return arg_0._perform_post(
            arg_0._get_role_instance_operations_path(
                arg_1, arg_2, arg_3),
            _XmlSerializer.Func_operation_to_xml(arg_4),
            as_async=True)

Shuts down the specified virtual machine .


def Func ( arg_0 , arg_1 ) : arg_2 = arg_1 . get ( 'sources' , [ ] ) for arg_3 in arg_2 : arg_4 = arg_0 . createSource ( arg_3 ) arg_0 . setupTriggers ( arg_3 , arg_4 ) arg_0 . sources . append ( arg_4 )

def Func(arg_0, arg_1):
        """Sets up source objects from the given config"""
        arg_2 = arg_1.get('sources', [])

        for arg_3 in arg_2:
            arg_4 = arg_0.createSource(arg_3)
            arg_0.setupTriggers(arg_3, arg_4)

            arg_0.sources.append(arg_4)


return self.get_data(masked=True, smoothed=True, safe_copy=True)

def Func ( arg_0 , arg_1 ) : arg_0 . set_mask ( arg_1 ) return arg_0 . get_data ( masked = True , smoothed = True , safe_copy = True )

def Func(arg_0, arg_1):
        """First set_mask and the get_masked_data.

        Parameters
        ----------
        mask_img:  nifti-like image, NeuroImage or str
            3D mask array: True where a voxel should be used.
            Can either be:
            - a file path to a Nifti image
            - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.
            If niimg is a string, consider it as a path to Nifti image and
            call nibabel.load on it. If it is an object, check if get_data()
            and get_affine() methods are present, raise TypeError otherwise.

        Returns
        -------
        The masked data deepcopied
        """
        arg_0.set_mask(arg_1)
        return arg_0.get_data(masked=True, smoothed=True, safe_copy=True)

First set_mask and the get_masked_data .


Override of the default decode method that also uses decode_date.

def Func ( arg_0 , arg_1 ) : arg_2 = arg_0 . Func_date ( arg_1 ) if arg_1 != arg_2 : return arg_2 return json . JSONDecoder . Func ( arg_0 , arg_1 )

def Func(arg_0, arg_1):
    """Override of the default Func method that also uses Func_date."""
    # First try the date Funcr.
    arg_2 = arg_0.Func_date(arg_1)
    if arg_1 != arg_2:
      return arg_2
    # Fall back to the default Funcr.
    return json.JSONDecoder.Func(arg_0, arg_1)

Override of the default decode method that also uses decode_date .


(self, start_date=None, end_date=None, update_bookmark=True)

def Func ( arg_0 , arg_1 = None , arg_2 = None , arg_3 = True ) : if not Index ( arg_0 . event_index , using = arg_0 . client ) . exists ( ) : return arg_4 = arg_1 or arg_0 . get_bookmark ( ) if arg_4 is None : return arg_5 = min ( arg_2 or datetime . datetime . max , datetime . datetime . utcnow ( ) . replace ( microsecond = 0 ) , datetime . datetime . combine ( arg_4 + datetime . timedelta ( arg_0 . batch_size ) , datetime . datetime . min . time ( ) ) ) while arg_5 <= datetime . datetime . utcnow ( ) : arg_0 . indices = set ( ) arg_0 . new_bookmark = arg_5 . strftime ( arg_0 . doc_id_suffix ) bulk ( arg_0 . client , arg_0 . agg_iter ( arg_4 , arg_5 ) , stats_only = True , chunk_size = 50 ) current_search_client . indices . flush ( index = ',' . join ( arg_0 . indices ) , wait_if_ongoing = True ) if arg_3 : arg_0 . set_bookmark ( ) arg_0 . indices = set ( ) arg_4 = arg_4 + datetime . timedelta ( arg_0 . batch_size ) arg_5 = min ( arg_2 or datetime . datetime . max , datetime . datetime . utcnow ( ) . replace ( microsecond = 0 ) , arg_4 + datetime . timedelta ( arg_0 . batch_size ) ) if arg_4 > arg_5 : break

def Func(arg_0, arg_1=None, arg_2=None, arg_3=True):
        """Calculate statistics aggregations."""
        # If no events have been indexed there is nothing to aggregate
        if not Index(arg_0.event_index, using=arg_0.client).exists():
            return
        arg_4 = arg_1 or arg_0.get_bookmark()
        # Stop here if no bookmark could be estimated.
        if arg_4 is None:
            return
        arg_5 = min(
            arg_2 or datetime.datetime.max,  # ignore if `None`
            datetime.datetime.utcnow().replace(microsecond=0),
            datetime.datetime.combine(
                arg_4 + datetime.timedelta(arg_0.batch_size),
                datetime.datetime.min.time())
        )
        while arg_5 <= datetime.datetime.utcnow():
            arg_0.indices = set()
            arg_0.new_bookmark = arg_5.strftime(arg_0.doc_id_suffix)
            bulk(arg_0.client,
                 arg_0.agg_iter(arg_4, arg_5),
                 stats_only=True,
                 chunk_size=50)
            # Flush all indices which have been modified
            current_search_client.indices.flush(
                index=','.join(arg_0.indices),
                wait_if_ongoing=True
            )
            if arg_3:
                arg_0.set_bookmark()
            arg_0.indices = set()
            arg_4 = arg_4 + datetime.timedelta(arg_0.batch_size)
            arg_5 = min(
                arg_2 or datetime.datetime.max,  # ignore if `None``
                datetime.datetime.utcnow().replace(microsecond=0),
                arg_4 + datetime.timedelta(arg_0.batch_size)
            )
            if arg_4 > arg_5:
                break


def Func ( ) : global g_summary_text_filename global g_output_filename_failed_tests global g_output_filename_passed_tests with open ( g_summary_text_filename , 'a' ) as tempfile : write_file_content ( tempfile , g_output_filename_failed_tests ) write_file_content ( tempfile , g_output_filename_passed_tests )

def Func():
    """
    Concatecate all log file into a summary text file to be sent to users
    at the end of a daily log scraping.

    :return: none
    """
    global g_summary_text_filename
    global g_output_filename_failed_tests
    global g_output_filename_passed_tests

    with open(g_summary_text_filename,'a') as tempfile:
        write_file_content(tempfile,g_output_filename_failed_tests)
        write_file_content(tempfile,g_output_filename_passed_tests)

Concatecate all log file into a summary text file to be sent to users at the end of a daily log scraping .


(self, method, url=None, post_data=None, parse_data=True, key=None, parameters=None, listener=None, full_return=False)

def Func(arg_0, arg_1, arg_2=None, arg_3=None, arg_4=True, arg_5=None, arg_6=None, arg_7=None, arg_8=False):
        """ Issue a request.

        Args:
            method (str): Request method (GET/POST/PUT/DELETE/etc.) If not specified, it will be POST if post_data is not None

        Kwargs:
            url (str): Destination URL
            post_data (str): A string of what to POST
            parse_data (bool): If true, parse response data
            key (string): If parse_data==True, look for this key when parsing data
            parameters (dict): Additional GET parameters to append to the URL
            listener (func): callback called when uploading a file
            full_return (bool): If set to True, get a full response (with success, data, info, body)

        Returns:
            dict. Response. If full_return==True, a dict with keys: success, data, info, body, otherwise the parsed data

        Raises:
            AuthenticationError, ConnectionError, urllib2.HTTPError, ValueError
        """

        arg_9 = arg_0.get_headers()
        arg_9["Content-Type"] = "application/json"

        arg_10 = []
        arg_11 = int(arg_0._settings["debug"])

        arg_10.append(urllib2.HTTPHandler(arg_11=arg_11))
        if hasattr(httplib, "HTTPS"):
            arg_10.append(urllib2.HTTPSHandler(arg_11=arg_11))

        arg_10.append(urllib2.HTTPCookieProcessor(cookielib.CookieJar()))

        arg_12 = arg_0._get_password_url()
        if arg_12 and "Authorization" not in arg_9:
            arg_13 = urllib2.HTTPPasswordMgrWithDefaultRealm()
            arg_13.add_password(None, arg_12, arg_0._settings["user"], arg_0._settings["password"])
            arg_10.append(HTTPBasicAuthHandler(arg_13))

        arg_14 = urllib2.build_opener(*arg_10)

        if arg_3 is not None:
            arg_3 = json.dumps(arg_3)

        arg_15 = arg_0._url(arg_2, arg_6)
        arg_16 = RESTRequest(arg_15, arg_1=arg_1, arg_9=arg_9)
        if arg_3 is not None:
            arg_16.add_data(arg_3)

        arg_17 = None

        try:
            arg_17 = arg_14.open(arg_16)
            arg_18 = arg_17.read()
            if arg_12 and arg_12 not in arg_0._settings["authorizations"] and arg_16.has_header("Authorization"):
                arg_0._settings["authorizations"][arg_12] = arg_16.get_header("Authorization")
        except urllib2.HTTPError as e:
            if e.code == 401:
                raise AuthenticationError("Access denied while trying to access %s" % arg_15)
            elif e.code == 404:
                raise ConnectionError("URL not found: %s" % arg_15)
            else:
                raise
        except urllib2.URLError as e:
            raise ConnectionError("Error while fetching from %s: %s" % (arg_15, e))
        finally:
            if arg_17:
                arg_17.close()

            arg_14.close()

        arg_20 = None
        if arg_4:
            if not arg_5:
                arg_5 = string.split(arg_2, "/")[0]

            arg_20 = arg_0.parse(arg_18, arg_5)

        if arg_8:
            arg_21 = arg_17.info() if arg_17 else None
            arg_22 = int(string.split(arg_21["status"])[0]) if (arg_21 and "status" in arg_21) else None

            return {
                "success": (arg_22 >= 200 and arg_22 < 300),
                "data": arg_20,
                "info": arg_21,
                "body": arg_18
            }

        return arg_20


def
Func
(
arg_0
,
arg_1
,
arg_2
=
)
:
arg_0
.
check_profile
(
arg_1
)
arg_3
=
arg_0
.
profiles
[
arg_1
]
if
arg_3
[
'status'
]
==
'running'
:
raise
web
.
HTTPError
(
409
,
u'cluster already running'
)
arg_4
,
arg_5
,
arg_6
=
arg_0
.
build_launchers
(
arg_3
[
'profile_dir'
]
)
arg_2
=
arg_2
if
arg_2
is
not
else
arg_6
def
clean_data
(
)
:
arg_3
.
pop
(
'controller_launcher'
,
)
arg_3
.
pop
(
'engine_set_launcher'
,
)
arg_3
.
pop
(
'n'
,
)
arg_3
[
'status'
]
=
'stopped'
def
engines_stopped
(
arg_7
)
:
arg_0
.
log
.
debug
(
'Engines stopped'
)
if
arg_4
.
running
:
arg_4
.
stop
(
)
clean_data
(
)
arg_5
.
on_stop
(
engines_stopped
)
def
controller_stopped
(
arg_7
)
:
arg_0
.
log
.
debug
(
'Controller stopped'
)
if
arg_5
.
running
:
arg_5
.
stop
(
)
clean_data
(
)
arg_4
.
on_stop
(
controller_stopped
)
arg_8
=
ioloop
.
DelayedCallback
(
lambda
:
arg_4
.
start
(
)
,
0
,
arg_0
.
loop
)
arg_8
.
start
(
)
arg_8
=
ioloop
.
DelayedCallback
(
lambda
:
arg_5
.
start
(
arg_2
)
,
1000
*
arg_0
.
delay
,
arg_0
.
loop
)
arg_8
.
start
(
)
arg_0
.
log
.
debug
(
'Cluster started'
)
arg_3
[
'controller_launcher'
]
=
arg_4
arg_3
[
'engine_set_launcher'
]
=
arg_5
arg_3
[
'n'
]
=
arg_2
arg_3
[
'status'
]
=
'running'
return
arg_0
.
profile_info
(
arg_1
)

def Func(arg_0, arg_1, arg_2=None):
        """Start a cluster for a given profile."""
        arg_0.check_profile(arg_1)
        arg_3 = arg_0.profiles[arg_1]
        if arg_3['status'] == 'running':
            raise web.HTTPError(409, u'cluster already running')
        arg_4, arg_5, arg_6 = arg_0.build_launchers(arg_3['profile_dir'])
        arg_2 = arg_2 if arg_2 is not None else arg_6
        def clean_data():
            arg_3.pop('controller_launcher',None)
            arg_3.pop('engine_set_launcher',None)
            arg_3.pop('n',None)
            arg_3['status'] = 'stopped'
        def engines_stopped(arg_7):
            arg_0.log.debug('Engines stopped')
            if arg_4.running:
                arg_4.stop()
            clean_data()
        arg_5.on_stop(engines_stopped)
        def controller_stopped(arg_7):
            arg_0.log.debug('Controller stopped')
            if arg_5.running:
                arg_5.stop()
            clean_data()
        arg_4.on_stop(controller_stopped)

        arg_8 = ioloop.DelayedCallback(lambda: arg_4.start(), 0, arg_0.loop)
        arg_8.start()
        arg_8 = ioloop.DelayedCallback(lambda: arg_5.start(arg_2), 1000*arg_0.delay, arg_0.loop)
        arg_8.start()

        arg_0.log.debug('Cluster started')
        arg_3['controller_launcher'] = arg_4
        arg_3['engine_set_launcher'] = arg_5
        arg_3['n'] = arg_2
        arg_3['status'] = 'running'
        return arg_0.profile_info(arg_1)


def Func(arg_0):
        "setup a timeout for waiting for a proposal"
        if arg_0.timeout_time is not None or arg_0.proposal:
            return
        arg_1 = arg_0.cm.chainservice.now
        arg_2 = ConsensusManager.round_timeout
        arg_3 = ConsensusManager.round_timeout_factor
        arg_4 = arg_2 * arg_3 ** arg_0.round
        arg_0.timeout_time = arg_1 + arg_4
        return arg_4


def Func(arg_0):
        """Wait until there are no more inprogress transfers

        This will not stop when failures are encountered and not propogate any
        of these errors from failed transfers, but it can be interrupted with
        a KeyboardInterrupt.
        """
        try:
            arg_1 = None
            for arg_1 in arg_0.tracked_transfer_coordinators:
                arg_1.result()
        except KeyboardInterrupt:
            logger.debug('Received KeyboardInterrupt in Func()')
            # If Keyboard interrupt is raised while Funcing for
            # the result, then exit out of the Func and raise the
            # exception
            if arg_1:
                logger.debug(
                    'On KeyboardInterrupt was Funcing for %s',
                    arg_1)
            raise
        except Exception:
            # A general exception could have been thrown because
            # of result(). We just want to ignore this and continue
            # because we at least know that the transfer coordinator
            # has completed.
            pass


def Func ( arg_0 , arg_1 ) : arg_2 = defaultdict ( int ) for arg_3 in arg_0 . _scan ( ) : for arg_4 in arg_1 : if arg_4 ( did ( arg_3 [ '_id' ] ) ) : arg_2 [ arg_4 ] += arg_0 . fc_bytes ( arg_3 [ '_source' ] [ 'fc' ] ) return arg_2

def Func(arg_0, arg_1):
        '''Count bytes of all feature collections whose key satisfies one of
        the predicates in ``filter_preds``. The byte counts are binned
        by filter predicate.
        '''
        arg_2 = defaultdict(int)
        for arg_3 in arg_0._scan():
            for arg_4 in arg_1:
                if arg_4(did(arg_3['_id'])):
                    arg_2[arg_4] += arg_0.fc_bytes(
                        arg_3['_source']['fc'])
        return arg_2

Count bytes of all feature collections whose key satisfies one of the predicates in filter_preds . The byte counts are binned by filter predicate .


async
def
Func
(
arg_0
)
:
if
hasattr
(
arg_0
,
'seek'
)
:
await
execute
(
arg_0
.
seek
(
0
,
os
.
SEEK_END
)
)
arg_1
=
await
execute
(
arg_0
.
tell
(
)
)
await
execute
(
arg_0
.
seek
(
0
)
)
elif
hasattr
(
arg_0
,
'headers'
)
:
arg_1
=
int
(
arg_0
.
headers
[
'Content-Length'
]
)
elif
isinstance
(
arg_0
,
bytes
)
:
arg_1
=
len
(
arg_0
)
else
:
raise
TypeError
(
"Can't get size of media of type:"
,
type
(
arg_0
)
.
__name__
)
_logger
.
info
(
"media size: %dB"
%
arg_1
)
return
arg_1

async def Func(arg_0):
    """
        Get the size of a file

    Parameters
    ----------
    media : file object
        The file object of the media

    Returns
    -------
    int
        The size of the file
    """
    if hasattr(arg_0, 'seek'):
        await execute(arg_0.seek(0, os.SEEK_END))
        arg_1 = await execute(arg_0.tell())
        await execute(arg_0.seek(0))
    elif hasattr(arg_0, 'headers'):
        arg_1 = int(arg_0.headers['Content-Length'])
    elif isinstance(arg_0, bytes):
        arg_1 = len(arg_0)
    else:
        raise TypeError("Can't get size of media of type:",
                        type(arg_0).__name__)

    _logger.info("media size: %dB" % arg_1)
    return arg_1


(self, signum, seconds=0, callback_function=None)

def Func(arg_0, arg_1, arg_2=0, arg_3=None):
        """
        Pause execution, execution will resume in X seconds or when the
        appropriate resume signal is received. Execution will jump to the
        callback_function, the default callback function is the handler
        method which will run all tasks registered with the reg_on_resume
        methodi.
        Returns True if timer expired, otherwise returns False
        """
        if arg_3 is None:
            arg_3 = arg_0.default_handler
        if arg_2 > 0:
            arg_0.log.info("Signal handler pausing for {0} seconds or until it receives SIGALRM or SIGCONT".format(arg_2))
            signal.signal(signal.SIGALRM, arg_3)
            signal.alarm(arg_2)
        else:
            arg_0.log.info('Signal handler pausing until it receives SIGALRM or SIGCONT')
        signal.signal(signal.SIGCONT, arg_3)
        signal.Func()
        arg_0.log.info('Signal handler resuming from Func')
        if arg_1 == signal.SIGALRM:
            return True
        else:
            return False

Pause execution execution will resume in X seconds or when the appropriate resume signal is received . Execution will jump to the callback_function the default callback function is the handler method which will run all tasks registered with the reg_on_resume methodi . Returns True if timer expired otherwise returns False


(self, logger: typing.Union[logging.Logger, str, None])

def Func ( arg_0 , Func : arg_2 . Union [ arg_4 . Logger , arg_6 , None ] ) -> None : if Func is None or isinstance ( Func , arg_4 . Logger ) : arg_0 . __logger = Func else : arg_0 . __logger = arg_4 . getLogger ( Func )

def Func(arg_0, Func: arg_2.Union[arg_4.Logger, arg_6, None]) -> None:
        """Logger instance to use as override."""
        if Func is None or isinstance(Func, arg_4.Logger):
            arg_0.__logger = Func
        else:
            arg_0.__logger = arg_4.getLogger(Func)


(slidingWindow, total, newVal, windowSize)

return float(total) / len(slidingWindow), slidingWindow, total

def Func ( arg_0 , arg_1 , arg_2 , arg_3 ) : if len ( arg_0 ) == arg_3 : arg_1 -= arg_0 . pop ( 0 ) arg_0 . append ( arg_2 ) arg_1 += arg_2 return float ( arg_1 ) / len ( arg_0 ) , arg_0 , arg_1

def Func(arg_0, arg_1, arg_2, arg_3):
    """Routine for computing a moving average.

    @param slidingWindow a list of previous values to use in computation that
        will be modified and returned
    @param total the sum of the values in slidingWindow to be used in the
        calculation of the moving average
    @param newVal a new number Func the new windowed average
    @param windowSize how many values to use in the moving window

    @returns an updated windowed average, the modified input slidingWindow list,
        and the new total sum of the sliding window
    """
    if len(arg_0) == arg_3:
      arg_1 -= arg_0.pop(0)

    arg_0.append(arg_2)
    arg_1 += arg_2
    return float(arg_1) / len(arg_0), arg_0, arg_1

Routine for computing a moving average.

    @param slidingWindow a list of previous values to use in computation that
        will be modified and returned
    @param total the sum of the values in slidingWindow to be used in the
        calculation of the moving average
    @param newVal a new number compute the new windowed average
    @param windowSize how many values to use in the moving window

    @returns an updated windowed average, the modified input slidingWindow list,
        and the new total sum of the sliding window

Routine for computing a moving average .


def Func(arg_0, arg_1, **arg_2):
        """Helper method to return a full path from a full or partial path.

            If no domain, assumes user's account domain
            If the vault is "~", assumes personal vault.

        Valid vault paths include:

            domain:vault
            domain:vault:/path
            domain:vault/path
            vault:/path
            vault
            ~/

        Invalid vault paths include:

            /vault/
            /path
            /
            :/

        Does not allow overrides for any vault path components.
        """
        arg_3 = arg_2.pop('client', None) or arg_0._client or client

        arg_1 = arg_1.strip()
        if not arg_1:
            raise Exception(
                'Vault path "{0}" is invalid. Path must be in the format: '
                '"domain:vault:/path" or "vault:/path".'.format(arg_1)
            )

        arg_4 = arg_0.VAULT_PATH_RE.match(arg_1)
        if not arg_4:
            raise Exception(
                'Vault path "{0}" is invalid. Path must be in the format: '
                '"domain:vault:/path" or "vault:/path".'.format(arg_1)
            )
        arg_5 = arg_4.groupdict()

        # Handle the special case where "~" means personal vault
        if arg_5.get('vault') == '~':
            arg_5 = dict(domain=None, vault=None)

        # If any values are None, set defaults from the user.
        if None in arg_5.values():
            arg_6 = arg_3.get('/v1/user', {})
            arg_7 = {
                'domain': arg_6['account']['domain'],
                'vault': 'user-{0}'.format(arg_6['id'])
            }
            arg_5 = dict((k, v or arg_7.get(k))
                              for k, v in arg_5.items())

        # Rebuild the full path
        arg_1 = '{domain}:{vault}'.format(**arg_5)
        arg_5['vault_full_path'] = arg_1
        return arg_1, arg_5

Helper method to return a full path from a full or partial path .


def Func ( arg_0 ) : if arg_0 . startswith ( '+' ) : return hangups . hangouts_pb2 . EntityLookupSpec ( phone = arg_0 , create_offnetwork_gaia = True ) elif '@' in arg_0 : return hangups . hangouts_pb2 . EntityLookupSpec ( email = arg_0 , create_offnetwork_gaia = True ) else : return hangups . hangouts_pb2 . EntityLookupSpec ( gaia_id = arg_0 )

def Func(arg_0):
    """Return EntityLookupSpec from phone number, email address, or gaia ID."""
    if arg_0.startswith('+'):
        return hangups.hangouts_pb2.EntityLookupSpec(
            phone=arg_0, create_offnetwork_gaia=True
        )
    elif '@' in arg_0:
        return hangups.hangouts_pb2.EntityLookupSpec(
            email=arg_0, create_offnetwork_gaia=True
        )
    else:
        return hangups.hangouts_pb2.EntityLookupSpec(gaia_id=arg_0)

Return EntityLookupSpec from phone number email address or gaia ID .


return s[max(below)] if len(below) else -1

def Func ( arg_0 , arg_1 = .05 ) : arg_2 = np . sort ( arg_0 ) arg_3 = arg_0 . shape [ 0 ] arg_4 = np . array ( range ( 1 , arg_3 + 1 ) , dtype = 'float' ) * arg_1 / arg_3 arg_5 = np . where ( arg_2 <= arg_4 ) [ 0 ] return arg_2 [ max ( arg_5 ) ] if len ( arg_5 ) else - 1

def Func(arg_0, arg_1=.05):
    """ Determine FDR threshold given a p value array and desired false
    discovery rate q. """
    arg_2 = np.sort(arg_0)
    arg_3 = arg_0.shape[0]
    arg_4 = np.array(range(1, arg_3 + 1), dtype='float') * arg_1 / arg_3
    arg_5 = np.where(arg_2 <= arg_4)[0]
    return arg_2[max(arg_5)] if len(arg_5) else -1

Determine FDR threshold given a p value array and desired false discovery rate q .


def Func ( arg_0 , arg_1 , arg_2 , arg_3 ) : arg_3 = dict ( arg_3 ) arg_4 = arg_3 . get ( 'fill' , arg_0 . _canvas . fillcolor ) if not isinstance ( arg_4 , Color ) : arg_4 = Color ( arg_4 , mode = 'rgb' , color_range = 1 ) arg_3 [ 'fill' ] = arg_4 arg_5 = arg_3 . get ( 'stroke' , arg_0 . _canvas . strokecolor ) if not isinstance ( arg_5 , Color ) : arg_5 = Color ( arg_5 , mode = 'rgb' , color_range = 1 ) arg_3 [ 'stroke' ] = arg_5 arg_3 [ 'strokewidth' ] = arg_3 . get ( 'strokewidth' , arg_0 . _canvas . strokewidth ) arg_6 = arg_1 ( arg_0 , * arg_2 , ** arg_3 ) return arg_6

def Func(arg_0, arg_1, arg_2, arg_3):
        """
        Create an object, if fill, stroke or strokewidth
        is not specified, get them from the _canvas

        :param clazz:
        :param args:
        :param kwargs:
        :return:
        """
        arg_3 = dict(arg_3)

        arg_4 = arg_3.get('fill', arg_0._canvas.fillcolor)
        if not isinstance(arg_4, Color):
            arg_4 = Color(arg_4, mode='rgb', color_range=1)
        arg_3['fill'] = arg_4

        arg_5 = arg_3.get('stroke', arg_0._canvas.strokecolor)
        if not isinstance(arg_5, Color):
            arg_5 = Color(arg_5, mode='rgb', color_range=1)
        arg_3['stroke'] = arg_5

        arg_3['strokewidth'] = arg_3.get('strokewidth', arg_0._canvas.strokewidth)
        arg_6 = arg_1(arg_0, *arg_2, **arg_3)
        return arg_6

Create an object if fill stroke or strokewidth is not specified get them from the _canvas


def Func(arg_0):
    r""" Compute allele frequency from its expectation.

    Parameters
    ----------
    expec : array_like
        Allele expectations encoded as a samples-by-alleles matrix.

    Returns
    -------
    :class:`numpy.ndarray`
        Allele frequencies encoded as a variants-by-alleles matrix.

    Examples
    --------
    .. doctest::

        >>> from bgen_reader import read_bgen, example_files
        >>> from bgen_reader import allele_expectation, Func
        >>>
        >>> # Download an example
        >>> example = example_files("example.32bits.bgen")
        >>> filepath = example.filepath
        >>>
        >>> bgen = read_bgen(filepath, verbose=False)
        >>>
        >>> variants = bgen["variants"]
        >>> samples = bgen["samples"]
        >>> genotype = bgen["genotype"]
        >>>
        >>> variant = variants[variants["rsid"] == "RSID_6"].compute()
        >>> variant_idx = variant.index.item()
        >>>
        >>> p = genotype[variant_idx].compute()["probs"]
        >>> # For unphased genotypes only.
        >>> e = allele_expectation(bgen, variant_idx)
        >>> f = Func(e)
        >>>
        >>> alleles = variant["allele_ids"].item().split(",")
        >>> print(alleles[0] + ": {}".format(f[0]))
        A: 229.23103218810434
        >>> print(alleles[1] + ": {}".format(f[1]))
        G: 270.7689678118956
        >>> print(variant)
                id    rsid chrom   pos  nalleles allele_ids  vaddr
        4  SNPID_6  RSID_6    01  6000         2        A,G  19377
        >>>
        >>> # Clean-up the example
        >>> example.close()
    """
    arg_0 = asarray(arg_0, float)
    if arg_0.ndim != 2:
        raise ValueError("Expectation matrix must be bi-dimensional.")
    arg_1 = arg_0.shape[-1]
    return arg_0.sum(-2) / arg_1

r""" Compute allele frequency from its expectation.

    Parameters
    ----------
    expec : array_like
        Allele expectations encoded as a samples-by-alleles matrix.

    Returns
    -------
    :class:`numpy.ndarray`
        Allele frequencies encoded as a variants-by-alleles matrix.

    Examples
    --------
    .. doctest::

        >>> from bgen_reader import read_bgen, example_files
        >>> from bgen_reader import allele_expectation, allele_frequency
        >>>
        >>> # Download an example
        >>> example = example_files("example.32bits.bgen")
        >>> filepath = example.filepath
        >>>
        >>> bgen = read_bgen(filepath, verbose=False)
        >>>
        >>> variants = bgen["variants"]
        >>> samples = bgen["samples"]
        >>> genotype = bgen["genotype"]
        >>>
        >>> variant = variants[variants["rsid"] == "RSID_6"].compute()
        >>> variant_idx = variant.index.item()
        >>>
        >>> p = genotype[variant_idx].compute()["probs"]
        >>> # For unphased genotypes only.
        >>> e = allele_expectation(bgen, variant_idx)
        >>> f = allele_frequency(e)
        >>>
        >>> alleles = variant["allele_ids"].item().split(",")
        >>> print(alleles[0] + ": {}".format(f[0]))
        A: 229.23103218810434
        >>> print(alleles[1] + ": {}".format(f[1]))
        G: 270.7689678118956
        >>> print(variant)
                id    rsid chrom   pos  nalleles allele_ids  vaddr
        4  SNPID_6  RSID_6    01  6000         2        A,G  19377
        >>>
        >>> # Clean-up the example
        >>> example.close()

r Compute allele frequency from its expectation .


def Func ( arg_0 , arg_1 , arg_2 ) : arg_0 . _SUB ( arg_1 , arg_2 , carry = True )

def Func(arg_0, arg_1, arg_2):
        """
        Integer subtraction with borrow.

        Adds the source operand (second operand) and the carry (CF) flag, and
        subtracts the result from the destination operand (first operand). The
        result of the subtraction is stored in the destination operand. The
        destination operand can be a register or a memory location; the source
        operand can be an immediate, a register, or a memory location.
        (However, two memory operands cannot be used in one instruction.) The
        state of the CF flag represents a borrow from a previous subtraction.
        When an immediate value is used as an operand, it is sign-extended to
        the length of the destination operand format.
        The Func instruction does not distinguish between signed or unsigned
        operands. Instead, the processor evaluates the result for both data
        types and sets the OF and CF flags to indicate a borrow in the signed
        or unsigned result, respectively. The SF flag indicates the sign of the
        signed result.  The Func instruction is usually executed as part of a
        multibyte or multiword subtraction in which a SUB instruction is
        followed by a Func instruction::

                DEST  =  DEST - (SRC + CF);

        :param cpu: current CPU.
        :param dest: destination operand.
        :param src: source operand.
        """
        arg_0._SUB(arg_1, arg_2, carry=True)

Integer subtraction with borrow.

        Adds the source operand (second operand) and the carry (CF) flag, and
        subtracts the result from the destination operand (first operand). The
        result of the subtraction is stored in the destination operand. The
        destination operand can be a register or a memory location; the source
        operand can be an immediate, a register, or a memory location.
        (However, two memory operands cannot be used in one instruction.) The
        state of the CF flag represents a borrow from a previous subtraction.
        When an immediate value is used as an operand, it is sign-extended to
        the length of the destination operand format.
        The SBB instruction does not distinguish between signed or unsigned
        operands. Instead, the processor evaluates the result for both data
        types and sets the OF and CF flags to indicate a borrow in the signed
        or unsigned result, respectively. The SF flag indicates the sign of the
        signed result.  The SBB instruction is usually executed as part of a
        multibyte or multiword subtraction in which a SUB instruction is
        followed by a SBB instruction::

                DEST  =  DEST - (SRC + CF);

        :param cpu: current CPU.
        :param dest: destination operand.
        :param src: source operand.


def Func ( arg_0 = True ) : arg_1 = list ( ) arg_1 . extend ( [ ( 'n' , 'uint32' ) , ( 'edge' , 'uint32' ) , ] ) if arg_0 : arg_1 . extend ( [ ( 'has_spanning_cluster' , 'bool' ) , ] ) arg_1 . extend ( [ ( 'max_cluster_size' , 'uint32' ) , ( 'moments' , '(5,)uint64' ) , ] ) return _ndarray_dtype ( arg_1 )

def Func(arg_0=True):
    """
    Return the numpy structured array data type for sample states

    Helper function

    Parameters
    ----------
    spanning_cluster : bool, optional
        Whether to detect a spanning cluster or not.
        Defaults to ``True``.

    Returns
    -------
    ret : list of pairs of str
        A list of tuples of field names and data types to be used as ``dtype``
        argument in numpy ndarray constructors

    See Also
    --------
    http://docs.scipy.org/doc/numpy/user/basics.rec.html
    canonical_statistics_dtype
    """
    arg_1 = list()
    arg_1.extend([
        ('n', 'uint32'),
        ('edge', 'uint32'),
    ])
    if arg_0:
        arg_1.extend([
            ('has_spanning_cluster', 'bool'),
        ])
    arg_1.extend([
        ('max_cluster_size', 'uint32'),
        ('moments', '(5,)uint64'),
    ])
    return _ndarray_dtype(arg_1)


def Func(arg_0):
        """
        Log of the marginal likelihood for optimal scale.

        Implementation for unrestricted LML::

        Returns
        -------
        lml : float
            Log of the marginal likelihood.
        """
        assert arg_0._optimal["scale"]

        arg_1 = len(arg_0._y)
        arg_2 = -arg_0._df * log2pi - arg_0._df - arg_1 * log(arg_0.scale)
        arg_2 -= sum(npsum(log(arg_3)) for arg_3 in arg_0._D)
        return arg_2 / 2

Log of the marginal likelihood for optimal scale .


def Func(arg_0):
        """
        Trigger a query of the configured ``nsq_lookupd_http_addresses``.
        """
        arg_1 = arg_0.lookupd_http_addresses[arg_0.lookupd_query_index]
        arg_0.lookupd_query_index = (arg_0.lookupd_query_index + 1) % len(arg_0.lookupd_http_addresses)

        # urlsplit() is faulty if scheme not present
        if '://' not in arg_1:
            arg_1 = 'http://' + arg_1

        arg_3, arg_4, arg_5, arg_6, arg_7 = urlparse.urlsplit(arg_1)

        if not arg_5 or arg_5 == "/":
            arg_5 = "/lookup"

        arg_8 = parse_qs(arg_6)
        arg_8['topic'] = arg_0.topic
        arg_6 = urlencode(_utf8_params(arg_8), doseq=1)
        arg_9 = urlparse.urlunsplit((arg_3, arg_4, arg_5, arg_6, arg_7))

        arg_10 = tornado.httpclient.HTTPRequest(
            arg_9, method='GET',
            headers={'Accept': 'application/vnd.nsq; version=1.0'},
            connect_timeout=arg_0.lookupd_connect_timeout,
            request_timeout=arg_0.lookupd_request_timeout)
        arg_11 = functools.partial(arg_0._finish_Func, arg_9=arg_9)
        arg_0.http_client.fetch(arg_10, arg_11=arg_11)

Trigger a query of the configured nsq_lookupd_http_addresses .


def Func(arg_0, arg_1='', arg_2='test_data'):

        '''
        Make prediction
        input test data
        output the prediction
        '''

        Func = {}

        if (arg_0.status != 'train'):
            print("Please load train data and init W then train the W first.")
            return Func

        if (arg_1 == ''):
            print("Please input test data for prediction.")
            return Func

        if arg_2 == 'future_data':
            arg_4 = arg_1.split()
            arg_5 = [float(v) for v in arg_4]
            arg_5 = utility.DatasetLoader.feature_transform(
                np.array(arg_5).reshape(1, -1),
                arg_0.feature_transform_mode,
                arg_0.feature_transform_degree
            )
            arg_5 = np.ravel(arg_5)
            Func = arg_0.score_function(arg_5, arg_0.W)
            return {"input_data_x": arg_5, "input_data_y": None, "prediction": Func}
        else:
            arg_4 = arg_1.split()
            arg_5 = [float(v) for v in arg_4[:-1]]
            arg_5 = utility.DatasetLoader.feature_transform(
                np.array(arg_5).reshape(1, -1),
                arg_0.feature_transform_mode,
                arg_0.feature_transform_degree
            )
            arg_5 = np.ravel(arg_5)
            arg_6 = float(arg_4[-1])
            Func = arg_0.score_function(arg_5, arg_0.W)
            return {"input_data_x": arg_5, "input_data_y": arg_6, "prediction": Func}


return {os.path.basename(absfilename): open(absfilename, "rb")}

def
Func
(
arg_0
)
:
if
not
arg_0
:
return
arg_1
=
os
.
path
.
abspath
(
arg_0
)
if
not
os
.
path
.
exists
(
arg_1
)
:
raise
H2OValueError
(
"File %s does not exist"
%
arg_0
,
skip_frames
=
1
)
return
{
os
.
path
.
basename
(
arg_1
)
:
open
(
arg_1
,
"rb"
)
}

def Func(arg_0):
        """
        Prepare `filename` to be sent to the server.

        The "preparation" consists of creating a data structure suitable
        for passing to requests.request().
        """
        if not arg_0: return None
        arg_1 = os.path.abspath(arg_0)
        if not os.path.exists(arg_1):
            raise H2OValueError("File %s does not exist" % arg_0, skip_frames=1)
        return {os.path.basename(arg_1): open(arg_1, "rb")}

Prepare filename to be sent to the server .


def Func ( arg_0 ) : global DEBUG , WordNode arg_1 = nx . DiGraph ( ) for arg_2 in arg_0 : if DEBUG : print ( arg_2 [ "graf" ] ) for arg_3 in get_tiles ( map ( WordNode . _make , arg_2 [ "graf" ] ) ) : if DEBUG : print ( arg_3 ) for arg_4 in arg_3 : if not arg_1 . has_node ( arg_4 ) : arg_1 . add_node ( arg_4 ) try : arg_1 . edge [ arg_3 [ 0 ] ] [ arg_3 [ 1 ] ] [ "weight" ] += 1.0 except KeyError : arg_1 . add_edge ( arg_3 [ 0 ] , arg_3 [ 1 ] , weight = 1.0 ) return arg_1

def Func (arg_0):
    """
    construct the TextRank graph from parsed paragraphs
    """
    global DEBUG, WordNode
    arg_1 = nx.DiGraph()

    for arg_2 in arg_0:
        if DEBUG:
            print(arg_2["graf"])

        for arg_3 in get_tiles(map(WordNode._make, arg_2["graf"])):
            if DEBUG:
                print(arg_3)

            for arg_4 in arg_3:
                if not arg_1.has_node(arg_4):
                    arg_1.add_node(arg_4)

            try:
                arg_1.edge[arg_3[0]][arg_3[1]]["weight"] += 1.0
            except KeyError:
                arg_1.add_edge(arg_3[0], arg_3[1], weight=1.0)

    return arg_1


def Func ( arg_0 , arg_1 , arg_2 , arg_3 = False ) : util . valid_audio ( arg_1 , mono = False ) if arg_3 and np . issubdtype ( arg_1 . dtype , np . floating ) : arg_4 = util . normalize ( arg_1 , arg_3 = np . inf , axis = None ) else : arg_4 = arg_1 if arg_4 . ndim > 1 and arg_4 . shape [ 0 ] == 2 : arg_4 = arg_4 . T scipy . io . wavfile . write ( arg_0 , arg_2 , arg_4 )

def Func(arg_0, arg_1, arg_2, arg_3=False):
    """Output a time series as a .wav file

    Note: only mono or stereo, floating-point data is supported.
        For more advanced and flexible output options, refer to
        `soundfile`.

    Parameters
    ----------
    path : str
        path to save the output wav file

    y : np.ndarray [shape=(n,) or (2,n), dtype=np.float]
        audio time series (mono or stereo).

        Note that only floating-point values are supported.

    sr : int > 0 [scalar]
        sampling rate of `y`

    norm : boolean [scalar]
        enable amplitude normalization.
        For floating point `y`, scale the data to the range [-1, +1].

    Examples
    --------
    Trim a signal to 5 seconds and save it back

    >>> y, sr = librosa.load(librosa.util.example_audio_file(),
    ...                      duration=5.0)
    >>> librosa.output.Func('file_trim_5s.wav', y, sr)

    See Also
    --------
    soundfile.write
    """

    # Validate the buffer.  Stereo is okay here.
    util.valid_audio(arg_1, mono=False)

    # normalize
    if arg_3 and np.issubdtype(arg_1.dtype, np.floating):
        arg_4 = util.normalize(arg_1, arg_3=np.inf, axis=None)
    else:
        arg_4 = arg_1

    # Check for stereo
    if arg_4.ndim > 1 and arg_4.shape[0] == 2:
        arg_4 = arg_4.T

    # Save
    scipy.io.wavfile.write(arg_0, arg_2, arg_4)

Output a time series as a .wav file

    Note: only mono or stereo, floating-point data is supported.
        For more advanced and flexible output options, refer to
        `soundfile`.

    Parameters
    ----------
    path : str
        path to save the output wav file

    y : np.ndarray [shape=(n,) or (2,n), dtype=np.float]
        audio time series (mono or stereo).

        Note that only floating-point values are supported.

    sr : int > 0 [scalar]
        sampling rate of `y`

    norm : boolean [scalar]
        enable amplitude normalization.
        For floating point `y`, scale the data to the range [-1, +1].

    Examples
    --------
    Trim a signal to 5 seconds and save it back

    >>> y, sr = librosa.load(librosa.util.example_audio_file(),
    ...                      duration=5.0)
    >>> librosa.output.write_wav('file_trim_5s.wav', y, sr)

    See Also
    --------
    soundfile.write


return reparsed.toprettyxml(indent="    ")

def
Func
(
arg_0
)
:
arg_1
=
xml
.
dom
.
minidom
.
parseString
(
arg_0
)
return
arg_1
.
toprettyxml
(
indent
=
"    "
)

def Func(arg_0):
    '''
    Indent an xml string with four spaces, and add an additional line break after each node.
    '''
    arg_1 = xml.dom.minidom.parseString(arg_0)
    return arg_1.toprettyxml(indent="    ")

Indent an xml string with four spaces and add an additional line break after each node .


def Func ( arg_0 ) : def simple_decorator ( arg_1 ) : arg_1 . dispatch = method_decorator ( arg_0 ) ( arg_1 . dispatch ) return arg_1 return simple_decorator

def Func(arg_0):
	"""Convert a function based decorator into a class based decorator usable
	on class based Views.

	Can't subclass the `View` as it breaks inheritance (super in particular),
	so we monkey-patch instead.

	Based on http://stackoverflow.com/a/8429311
	"""

	def simple_decorator(arg_1):
		arg_1.dispatch = method_decorator(arg_0)(arg_1.dispatch)
		return arg_1

	return simple_decorator

Convert a function based decorator into a class based decorator usable on class based Views .


return remove_falsy_values({
        'Translocations': len(get_translocated(graph)),
        'Degradations': len(get_degradations(graph)),
        'Molecular Activities': len(get_activities(graph)),
    })

def
Func
(
arg_0
:
arg_1
)
->
Mapping
[
str
,
int
]
:
return
remove_falsy_values
(
{
'Translocations'
:
len
(
get_translocated
(
arg_0
)
)
,
'Degradations'
:
len
(
get_degradations
(
arg_0
)
)
,
'Molecular Activities'
:
len
(
get_activities
(
arg_0
)
)
,
}
)

def Func(arg_0: arg_1) -> Mapping[str, int]:
    """Get a modifications count dictionary."""
    return remove_falsy_values({
        'Translocations': len(get_translocated(arg_0)),
        'Degradations': len(get_degradations(arg_0)),
        'Molecular Activities': len(get_activities(arg_0)),
    })


def Func(arg_0, arg_1):
        """
        Enables analog reporting. By turning reporting on for a single pin.

        :param pin: Analog pin number. For example for A0, the number is 0.

        :return: No return value
        """
        arg_2 = [arg_0._command_handler.REPORT_ANALOG + arg_1, arg_0.REPORTING_ENABLE]
        arg_0._command_handler.send_command(arg_2)

Enables analog reporting . By turning reporting on for a single pin .


def Func ( arg_0 ) : arg_1 = latex ( arg_0 , mode = 'plain' ) arg_1 = arg_1 . strip ( '$' ) arg_2 = latex_to_png ( '$$%s$$' % arg_1 , backend = 'dvipng' ) return arg_2

def Func(arg_0):
    """
    A function to display sympy expression using display style LaTeX in PNG.
    """
    arg_1 = latex(arg_0, mode='plain')
    arg_1 = arg_1.strip('$')
    # As matplotlib does not support display style, dvipng backend is
    # used here.
    arg_2 = latex_to_png('$$%s$$' % arg_1, backend='dvipng')
    return arg_2

A function to display sympy expression using display style LaTeX in PNG .


(uri, timeout, scanner, requests_session)

def Func(arg_0, arg_1, arg_2, arg_3):
    """
    Get a stream URI from a playlist URI, ``uri``.
    Unwraps nested playlists until something that's not a playlist is found or
    the ``timeout`` is reached.
    """

    arg_4 = arg_0
    arg_5 = set()
    arg_6 = time.time() + arg_1

    while time.time() < arg_6:
        if arg_0 in arg_5:
            logger.info(
                'Unwrapping stream from URI (%s) failed: '
                'playlist referenced itself', arg_0)
            return None
        else:
            arg_5.add(arg_0)

        logger.debug('Unwrapping stream from URI: %s', arg_0)

        try:
            arg_7 = arg_6 - time.time()
            if arg_7 < 0:
                logger.info(
                    'Unwrapping stream from URI (%s) failed: '
                    'timed out in %sms', arg_0, arg_1)
                return None
            arg_8 = arg_2.scan(arg_0, arg_1=arg_7)
        except exceptions.ScannerError as exc:
            logger.debug('GStreamer failed scanning URI (%s): %s', arg_0, exc)
            arg_8 = None

        if arg_8 is not None and not (
                arg_8.mime.startswith('text/') or
                arg_8.mime.startswith('application/')):
            logger.debug(
                'Unwrapped potential %s stream: %s', arg_8.mime, arg_0)
            return arg_0

        arg_9 = arg_6 - time.time()
        if arg_9 < 0:
            logger.info(
                'Unwrapping stream from URI (%s) failed: timed out in %sms',
                arg_0, arg_1)
            return None
        arg_10 = http.download(
            arg_3, arg_0, arg_1=arg_9)

        if arg_10 is None:
            logger.info(
                'Unwrapping stream from URI (%s) failed: '
                'error downloading URI %s', arg_4, arg_0)
            return None

        arg_11 = playlists.parse(arg_10)
        if not arg_11:
            logger.debug(
                'Failed parsing URI (%s) as playlist; found potential stream.',
                arg_0)
            return arg_0

        # TODO Test streams and return first that seems to be playable
        logger.debug(
            'Parsed playlist (%s) and found new URI: %s', arg_0, arg_11[0])
        arg_0 = arg_11[0]

Get a stream URI from a playlist URI uri . Unwraps nested playlists until something that s not a playlist is found or the timeout is reached .


(self, pattern, replacement, ignore_case=False)

return H2OFrame._expr(expr=ExprNode("replacefirst", self, pattern, replacement, ignore_case))

def Func ( arg_0 , arg_1 , arg_2 , arg_3 = False ) : return H2OFrame . _expr ( expr = ExprNode ( "replacefirst" , arg_0 , arg_1 , arg_2 , arg_3 ) )

def Func(arg_0, arg_1, arg_2, arg_3=False):
        """
        Substitute the first occurrence of pattern in a string with replacement.

        :param str pattern: A regular expression.
        :param str replacement: A replacement string.
        :param bool ignore_case: If True then pattern will match case-insensitively.
        :returns: an H2OFrame with all values matching ``pattern`` replaced with ``replacement``.
        """
        return H2OFrame._expr(expr=ExprNode("replacefirst", arg_0, arg_1, arg_2, arg_3))

Substitute the first occurrence of pattern in a string with replacement .


def Func(arg_0, arg_1, arg_2, arg_3=None):
        """Report on GitHub that the specified branch is failing to build at
        the specified commit. The method will open an issue indicating that
        the branch is failing. If there is an issue already open, it will add a
        comment avoiding to Func twice about the same failure.

        Args:
            branch (str): branch name to Func about.
            commit (str): commit hash at which the build fails.
            infourl (str): URL with extra info about the failure such as the
                build logs.
        """
        arg_4 = arg_0._get_Func_issue_number()
        if arg_4:
            arg_0._Func_as_comment(arg_4, arg_1, arg_2, arg_3)
        else:
            arg_0._Func_as_issue(arg_1, arg_2, arg_3)

Report on GitHub that the specified branch is failing to build at
        the specified commit. The method will open an issue indicating that
        the branch is failing. If there is an issue already open, it will add a
        comment avoiding to report twice about the same failure.

        Args:
            branch (str): branch name to report about.
            commit (str): commit hash at which the build fails.
            infourl (str): URL with extra info about the failure such as the
                build logs.

Report on GitHub that the specified branch is failing to build at the specified commit . The method will open an issue indicating that the branch is failing . If there is an issue already open it will add a comment avoiding to report twice about the same failure .


def Func ( arg_0 , arg_1 ) : arg_2 = { } arg_3 = split ( '\W+' , arg_1 ) if len ( arg_3 ) < 7 : arg_2 [ 'available' ] = None arg_2 [ 'used' ] = None arg_2 [ 'config' ] = None else : arg_2 [ 'available' ] = arg_3 [ - 4 ] arg_2 [ 'used' ] = arg_3 [ - 3 ] arg_2 [ 'config' ] = arg_3 [ - 2 ] return arg_2

def Func(arg_0, arg_1):
        """Return a dict of md status define in the line."""
        arg_2 = {}

        arg_3 = split('\W+', arg_1)
        if len(arg_3) < 7:
            arg_2['available'] = None
            arg_2['used'] = None
            arg_2['config'] = None
        else:
            # The final 2 entries on this line: [n/m] [UUUU_]
            # [n/m] means that ideally the array would have n devices however, currently, m devices are in use.
            # Obviously when m >= n then things are good.
            arg_2['available'] = arg_3[-4]
            arg_2['used'] = arg_3[-3]
            # [UUUU_] represents the status of each device, either U for up or _ for down.
            arg_2['config'] = arg_3[-2]

        return arg_2

Return a dict of md status define in the line .


def Func(arg_0, arg_1):
        """Retrieve the Func whit `Func_id` identifier.

        :param Func_id: identifier of the Func to retrieve
        """
        arg_2 = {
            arg_0.PKEY: arg_0.api_key
        }

        # http://example.com/Funcs/10.json
        arg_3 = arg_0._call(arg_0.POSTS, arg_1,
                              arg_2=arg_2)

        return arg_3

Retrieve the post whit `post_id` identifier.

        :param post_id: identifier of the post to retrieve

Retrieve the post whit post_id identifier .


def
Func
(
arg_0
)
:
arg_1
=
arg_0
.
_Func_list_to_test_filtering
(
)
if
PyFunceble
.
CONFIGURATION
[
"idna_conversion"
]
:
arg_1
=
domain2idna
(
arg_1
)
if
PyFunceble
.
CONFIGURATION
[
"hierarchical_sorting"
]
:
arg_1
=
List
(
arg_1
)
.
custom_format
(
Sort
.
hierarchical
)
else
:
arg_1
=
List
(
arg_1
)
.
custom_format
(
Sort
.
standard
)
arg_2
=
arg_1
try
:
arg_1
=
List
(
list
(
set
(
arg_1
[
PyFunceble
.
INTERN
[
"counter"
]
[
"number"
]
[
"tested"
]
:
]
)
set
(
PyFunceble
.
INTERN
[
"flatten_inactive_db"
]
)
)
)
.
format
(
)
arg_3
=
arg_1
[
1
]
except
IndexError
:
arg_1
=
arg_2
[
PyFunceble
.
INTERN
[
"counter"
]
[
"number"
]
[
"tested"
]
:
]
del
arg_2
if
PyFunceble
.
CONFIGURATION
[
"hierarchical_sorting"
]
:
arg_1
=
List
(
list
(
arg_1
)
)
.
custom_format
(
Sort
.
hierarchical
)
try
:
return
[
arg_0
.
domain
(
arg_4
,
arg_1
[
1
]
)
for
arg_4
in
arg_1
if
arg_4
]
except
IndexError
:
print
(
PyFunceble
.
Fore
.
CYAN
+
PyFunceble
.
Style
.
BRIGHT
+
"Nothing to test."
)

def Func(arg_0):
        """
        Manage the case that need to test each domain of a given Func path.

        .. note::
            1 domain per line.
        """

        # We get, format, filter, clean the list to test.
        arg_1 = arg_0._Func_list_to_test_filtering()

        if PyFunceble.CONFIGURATION["idna_conversion"]:
            # We have to convert domains to idna.

            # We convert if we need to convert.
            arg_1 = domain2idna(arg_1)

            if PyFunceble.CONFIGURATION["hierarchical_sorting"]:
                # The hierarchical sorting is desired by the user.

                # We format the list.
                arg_1 = List(arg_1).custom_format(Sort.hierarchical)
            else:
                # The hierarchical sorting is not desired by the user.

                # We format the list.
                arg_1 = List(arg_1).custom_format(Sort.standard)

        # We initiate a local variable which will save the current state of the list.
        arg_2 = arg_1

        try:
            # We remove the element which are in the database from the
            # current list to test.
            arg_1 = List(
                list(
                    set(
                        arg_1[PyFunceble.INTERN["counter"]["number"]["tested"] :]
                    )
                    - set(PyFunceble.INTERN["flatten_inactive_db"])
                )
            ).format()
            arg_3 = arg_1[-1]
        except IndexError:
            # Our list to test is the one with the element from the database.
            arg_1 = arg_2[
                PyFunceble.INTERN["counter"]["number"]["tested"] :
            ]

            # We delete the undesired variable.
            del arg_2

        if PyFunceble.CONFIGURATION["hierarchical_sorting"]:
            # The hierarchical sorting is desired by the user.

            # We format the list.
            arg_1 = List(list(arg_1)).custom_format(Sort.hierarchical)

        try:
            # We test each element of the list to test.
            return [arg_0.domain(arg_4, arg_1[-1]) for arg_4 in arg_1 if arg_4]
        except IndexError:
            # We print a message on screen.
            print(PyFunceble.Fore.CYAN + PyFunceble.Style.BRIGHT + "Nothing to test.")

Manage the case that need to test each domain of a given file path.

        .. note::
            1 domain per line.

Manage the case that need to test each domain of a given file path .


(
    perc_graph_result, seeds, ps, convolution_factors_tasks_iterator
)

return reduce(
        percolate.hpc.bond_reduce,
        map(
            bond_run,
            itertools.repeat(perc_graph_result),
            seeds,
            itertools.repeat(ps),
            itertools.repeat(convolution_factors_tasks),
        )
    )

def Func ( arg_0 , arg_1 , arg_2 , arg_3 ) : arg_4 = list ( arg_3 ) return reduce ( percolate . hpc . bond_reduce , map ( bond_run , itertools . repeat ( arg_0 ) , arg_1 , itertools . repeat ( arg_2 ) , itertools . repeat ( arg_4 ) , ) )

def Func(
    arg_0, arg_1, arg_2, arg_3
):
    """
    Perform a number of runs

    The number of runs is the number of seeds

    convolution_factors_tasks_iterator needs to be an iterator

    We shield the convolution factors tasks from jug value/result mechanism
    by supplying an iterator to the list of tasks for lazy evaluation
    http://github.com/luispedro/jug/blob/43f0d80a78f418fd3aa2b8705eaf7c4a5175fff7/jug/task.py#L100
    http://github.com/luispedro/jug/blob/43f0d80a78f418fd3aa2b8705eaf7c4a5175fff7/jug/task.py#L455
    """

    # restore the list of convolution factors tasks
    arg_4 = list(arg_3)

    return reduce(
        percolate.hpc.bond_reduce,
        map(
            bond_run,
            itertools.repeat(arg_0),
            arg_1,
            itertools.repeat(arg_2),
            itertools.repeat(arg_4),
        )
    )


(self, first=0, last=0, limit=-1, only_ops=[], exclude_ops=[])

def
Func
(
arg_0
,
arg_1
=
0
,
arg_2
=
0
,
arg_3
=
1
,
arg_4
=
[
]
,
arg_5
=
[
]
)
:
arg_6
=
100
arg_7
=
0
if
arg_1
<
0
:
arg_1
=
0
while
True
:
arg_8
=
arg_0
.
blockchain
.
rpc
.
get_account_Func
(
arg_0
[
"id"
]
,
"1.11.{}"
.
format
(
arg_2
)
,
arg_6
,
"1.11.{}"
.
format
(
arg_1
1
)
,
api
=
"Func"
,
)
for
arg_9
in
arg_8
:
if
(
arg_5
and
arg_0
.
operations
.
getOperationNameForId
(
arg_9
[
"op"
]
[
0
]
)
in
arg_5
)
:
continue
if
(
not
arg_4
or
arg_0
.
operations
.
getOperationNameForId
(
arg_9
[
"op"
]
[
0
]
)
in
arg_4
)
:
arg_7
+=
1
yield
arg_9
if
arg_3
>=
0
and
arg_7
>=
arg_3
:
return
if
not
arg_8
:
log
.
info
(
"No more Func returned from API node"
)
break
if
len
(
arg_8
)
<
arg_6
:
log
.
info
(
"Less than {} have been returned."
.
format
(
arg_6
)
)
break
arg_1
=
int
(
arg_8
[
1
]
[
"id"
]
.
split
(
"."
)
[
2
]
)

def Func(arg_0, arg_1=0, arg_2=0, arg_3=-1, arg_4=[], arg_5=[]):
        """ Returns a generator for individual account transactions. The
            latest operation will be first. This call can be used in a
            ``for`` loop.

            :param int first: sequence number of the first
                transaction to return (*optional*)
            :param int last: sequence number of the last
                transaction to return (*optional*)
            :param int limit: limit number of transactions to
                return (*optional*)
            :param array only_ops: Limit generator by these
                operations (*optional*)
            :param array exclude_ops: Exclude these operations from
                generator (*optional*).

            ... note::
                only_ops and exclude_ops takes an array of strings:
                The full list of operation ID's can be found in
                operationids.py.
                Example: ['transfer', 'fill_order']
        """
        arg_6 = 100
        arg_7 = 0

        if arg_1 < 0:
            arg_1 = 0

        while True:
            # RPC call
            arg_8 = arg_0.blockchain.rpc.get_account_Func(
                arg_0["id"],
                "1.11.{}".format(arg_2),
                arg_6,
                "1.11.{}".format(arg_1 - 1),
                api="Func",
            )
            for arg_9 in arg_8:
                if (
                    arg_5
                    and arg_0.operations.getOperationNameForId(arg_9["op"][0]) in arg_5
                ):
                    continue
                if (
                    not arg_4
                    or arg_0.operations.getOperationNameForId(arg_9["op"][0]) in arg_4
                ):
                    arg_7 += 1
                    yield arg_9
                    if arg_3 >= 0 and arg_7 >= arg_3:  # pragma: no cover
                        return

            if not arg_8:
                log.info("No more Func returned from API node")
                break
            if len(arg_8) < arg_6:
                log.info("Less than {} have been returned.".format(arg_6))
                break
            arg_1 = int(arg_8[-1]["id"].split(".")[2])

Returns a generator for individual account transactions . The latest operation will be first . This call can be used in a for loop .


(self, target, extensions=None, filter_func=None,
                          zip='deflated', log_function=None,
                          ignore_errors=True, py_compile=False)

def Func(arg_0, arg_1, arg_2=None, arg_3=None,
                          arg_4='deflated', arg_5=None,
                          arg_6=True, arg_7=False):
        """Finds all the templates the loader can find, compiles them
        and stores them in `target`.  If `zip` is `None`, instead of in a
        zipfile, the templates will be will be stored in a directory.
        By default a deflate zip algorithm is used, to switch to
        the stored algorithm, `zip` can be set to ``'stored'``.

        `extensions` and `filter_func` are passed to :meth:`list_templates`.
        Each template returned will be compiled to the target folder or
        zipfile.

        By default template compilation errors are ignored.  In case a
        log function is provided, errors are logged.  If you want template
        syntax errors to abort the compilation you can set `ignore_errors`
        to `False` and you will get an exception on syntax errors.

        If `py_compile` is set to `True` .pyc files will be written to the
        target instead of standard .py files.  This flag does not do anything
        on pypy and Python 3 where pyc files are not picked up by itself and
        don't give much benefit.

        .. versionadded:: 2.4
        """
        from jinja2.loaders import ModuleLoader

        if arg_5 is None:
            arg_5 = lambda x: None

        if arg_7:
            if not PY2 or PYPY:
                from warnings import warn
                warn(Warning('py_compile has no effect on pypy or Python 3'))
                arg_7 = False
            else:
                import imp, marshal
                arg_8 = imp.get_magic() + \
                    u'\xff\xff\xff\xff'.encode('iso-8859-15')

                # Python 3.3 added a source filesize to the header
                if sys.version_info >= (3, 3):
                    arg_8 += u'\x00\x00\x00\x00'.encode('iso-8859-15')

        def write_file(arg_9, arg_10, arg_11):
            if arg_4:
                arg_12 = ZipInfo(arg_9)
                arg_12.external_attr = 0o755 << 16
                arg_15.writestr(arg_12, arg_10)
            else:
                arg_14 = open(os.path.join(arg_1, arg_9), arg_11)
                try:
                    arg_14.write(arg_10)
                finally:
                    arg_14.close()

        if arg_4 is not None:
            from zipfile import ZipFile, ZipInfo, ZIP_DEFLATED, ZIP_STORED
            arg_15 = ZipFile(arg_1, 'w', dict(deflated=ZIP_DEFLATED,
                                                 stored=ZIP_STORED)[arg_4])
            arg_5('Compiling into Zip archive "%s"' % arg_1)
        else:
            if not os.path.isdir(arg_1):
                os.makedirs(arg_1)
            arg_5('Compiling into folder "%s"' % arg_1)

        try:
            for arg_16 in arg_0.list_templates(arg_2, arg_3):
                arg_17, arg_9, arg_18 = arg_0.loader.get_source(arg_0, arg_16)
                try:
                    arg_19 = arg_0.compile(arg_17, arg_16, arg_9, True, True)
                except TemplateSyntaxError as e:
                    if not arg_6:
                        raise
                    arg_5('Could not compile "%s": %s' % (arg_16, e))
                    continue

                arg_9 = ModuleLoader.get_module_filename(arg_16)

                if arg_7:
                    arg_20 = arg_0._compile(arg_19, encode_filename(arg_9))
                    write_file(arg_9 + 'c', arg_8 +
                               marshal.dumps(arg_20), 'wb')
                    arg_5('Byte-compiled "%s" as %s' %
                                 (arg_16, arg_9 + 'c'))
                else:
                    write_file(arg_9, arg_19, 'w')
                    arg_5('Compiled "%s" as %s' % (arg_16, arg_9))
        finally:
            if arg_4:
                arg_15.close()

        arg_5('Finished compiling templates')

Finds all the templates the loader can find compiles them and stores them in target . If zip is None instead of in a zipfile the templates will be will be stored in a directory . By default a deflate zip algorithm is used to switch to the stored algorithm zip can be set to stored .


def Func(arg_0):
        '''
        This function converts the estimated "time_before_present" properties of all nodes
        to numerical dates stored in the "numdate" attribute. This date is further converted
        into a human readable date string in format %Y-%m-%d assuming the usual calendar.

        Returns
        -------
         None
            All manipulations are done in place on the tree

        '''
        from datetime import datetime, timedelta
        arg_1 = numeric_date()
        for arg_2 in arg_0.tree.find_clades():
            arg_3 = arg_0.date2dist.to_years(arg_2.time_before_present)
            if arg_3 < 0 and arg_0.real_dates:
                if not hasattr(arg_2, "bad_branch") or arg_2.bad_branch is False:
                    arg_0.logger("ClockTree.Func -- WARNING: The node is later than today, but it is not "
                        "marked as \"BAD\", which indicates the error in the "
                        "likelihood optimization.",4 , warn=True)
                else:
                    arg_0.logger("ClockTree.Func -- WARNING: node which is marked as \"BAD\" optimized "
                        "later than present day",4 , warn=True)

            arg_2.numdate = arg_1 - arg_3

            # set the human-readable date
            arg_5 = np.floor(arg_2.numdate)
            arg_6 = max(0,365.25 * (arg_2.numdate - arg_5)-1)
            try:  # datetime will only operate on dates after 1900
                arg_7 = datetime(arg_5, 1, 1) + timedelta(arg_6=arg_6)
                arg_2.date = datetime.strftime(arg_7, "%Y-%m-%d")
            except:
                # this is the approximation not accounting for gap years etc
                arg_7 = datetime(1900, 1, 1) + timedelta(arg_6=arg_6)
                arg_2.date = "%04d-%02d-%02d"%(arg_5, arg_7.month, arg_7.day)

This function converts the estimated time_before_present properties of all nodes to numerical dates stored in the numdate attribute . This date is further converted into a human readable date string in format %Y - %m - %d assuming the usual calendar .


def Func ( arg_0 , arg_1 ) : try : arg_2 , arg_3 , arg_4 = arg_0 . split ( ':' , 2 ) except ( ValueError , TypeError ) : return False try : arg_5 = hashlib . new ( arg_2 ) except ValueError : return False if len ( arg_4 ) == 0 : return False arg_5 . update ( cast_bytes ( arg_1 , 'utf-8' ) + str_to_bytes ( arg_3 , 'ascii' ) ) return arg_5 . hexdigest ( ) == arg_4

def Func(arg_0, arg_1):
    """Verify that a given passphrase matches its hashed version.

    Parameters
    ----------
    hashed_passphrase : str
        Hashed password, in the format returned by `passwd`.
    passphrase : str
        Passphrase to validate.

    Returns
    -------
    valid : bool
        True if the passphrase matches the hash.

    Examples
    --------
    In [1]: from IPython.lib.security import Func

    In [2]: Func('sha1:0e112c3ddfce:a68df677475c2b47b6e86d0467eec97ac5f4b85a',
       ...:              'mypassword')
    Out[2]: True

    In [3]: Func('sha1:0e112c3ddfce:a68df677475c2b47b6e86d0467eec97ac5f4b85a',
       ...:              'anotherpassword')
    Out[3]: False

    """
    try:
        arg_2, arg_3, arg_4 = arg_0.split(':', 2)
    except (ValueError, TypeError):
        return False

    try:
        arg_5 = hashlib.new(arg_2)
    except ValueError:
        return False

    if len(arg_4) == 0:
        return False

    arg_5.update(cast_bytes(arg_1, 'utf-8') + str_to_bytes(arg_3, 'ascii'))

    return arg_5.hexdigest() == arg_4

Verify that a given passphrase matches its hashed version.

    Parameters
    ----------
    hashed_passphrase : str
        Hashed password, in the format returned by `passwd`.
    passphrase : str
        Passphrase to validate.

    Returns
    -------
    valid : bool
        True if the passphrase matches the hash.

    Examples
    --------
    In [1]: from IPython.lib.security import passwd_check

    In [2]: passwd_check('sha1:0e112c3ddfce:a68df677475c2b47b6e86d0467eec97ac5f4b85a',
       ...:              'mypassword')
    Out[2]: True

    In [3]: passwd_check('sha1:0e112c3ddfce:a68df677475c2b47b6e86d0467eec97ac5f4b85a',
       ...:              'anotherpassword')
    Out[3]: False

Verify that a given passphrase matches its hashed version .


(wave, npoints=None, indep_min=None, indep_max=None)

return imag(ifft(wave, npoints, indep_min, indep_max))

def Func ( arg_0 , arg_1 = None , arg_2 = None , arg_3 = None ) : return imag ( ifft ( arg_0 , arg_1 , arg_2 , arg_3 ) )

def Func(arg_0, arg_1=None, arg_2=None, arg_3=None):
    r"""
    Return the imaginary part of the inverse Fast Fourier Transform of a waveform.

    :param wave: Waveform
    :type  wave: :py:class:`peng.eng.Waveform`

    :param npoints: Number of points to use in the transform. If **npoints**
                    is less than the size of the independent variable vector
                    the waveform is truncated; if **npoints** is greater than
                    the size of the independent variable vector, the waveform
                    is zero-padded
    :type  npoints: positive integer

    :param indep_min: Independent vector start point of computation
    :type  indep_min: integer or float

    :param indep_max: Independent vector stop point of computation
    :type  indep_max: integer or float

    :rtype: :py:class:`peng.eng.Waveform`

    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc(raised=True)) ]]]
    .. Auto-generated exceptions documentation for
    .. peng.wave_functions.Func

    :raises:
     * RuntimeError (Argument \`indep_max\` is not valid)

     * RuntimeError (Argument \`indep_min\` is not valid)

     * RuntimeError (Argument \`npoints\` is not valid)

     * RuntimeError (Argument \`wave\` is not valid)

     * RuntimeError (Incongruent \`indep_min\` and \`indep_max\`
       arguments)

     * RuntimeError (Non-uniform frequency spacing)

    .. [[[end]]]
    """
    return imag(ifft(arg_0, arg_1, arg_2, arg_3))

r"""
    Return the imaginary part of the inverse Fast Fourier Transform of a waveform.

    :param wave: Waveform
    :type  wave: :py:class:`peng.eng.Waveform`

    :param npoints: Number of points to use in the transform. If **npoints**
                    is less than the size of the independent variable vector
                    the waveform is truncated; if **npoints** is greater than
                    the size of the independent variable vector, the waveform
                    is zero-padded
    :type  npoints: positive integer

    :param indep_min: Independent vector start point of computation
    :type  indep_min: integer or float

    :param indep_max: Independent vector stop point of computation
    :type  indep_max: integer or float

    :rtype: :py:class:`peng.eng.Waveform`

    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc(raised=True)) ]]]
    .. Auto-generated exceptions documentation for
    .. peng.wave_functions.iffti

    :raises:
     * RuntimeError (Argument \`indep_max\` is not valid)

     * RuntimeError (Argument \`indep_min\` is not valid)

     * RuntimeError (Argument \`npoints\` is not valid)

     * RuntimeError (Argument \`wave\` is not valid)

     * RuntimeError (Incongruent \`indep_min\` and \`indep_max\`
       arguments)

     * RuntimeError (Non-uniform frequency spacing)

    .. [[[end]]]

r Return the imaginary part of the inverse Fast Fourier Transform of a waveform .


async
def
Func
(
arg_0
)
:
if
arg_0
.
_subscription_id
is
:
_LOGGER
.
error
(
"Not subscribed."
)
return
await
arg_0
.
_tibber_control
.
sub_manager
.
unsubscribe
(
arg_0
.
_subscription_id
)

async def Func(arg_0):
        """Unsubscribe to Tibber rt subscription."""
        if arg_0._subscription_id is None:
            _LOGGER.error("Not subscribed.")
            return
        await arg_0._tibber_control.sub_manager.unsubscribe(arg_0._subscription_id)


(num_results, sequence_indices, dtype, name=None)

def Func ( arg_0 , arg_1 , arg_2 , arg_3 = None ) : with tf . compat . v1 . name_scope ( arg_3 , 'Func' , [ arg_0 , arg_1 ] ) : if arg_1 is None : arg_0 = tf . cast ( arg_0 , arg_2 = arg_2 ) arg_1 = tf . range ( arg_0 , arg_2 = arg_2 ) else : arg_1 = tf . cast ( arg_1 , arg_2 ) arg_4 = arg_1 + 1 return tf . reshape ( arg_4 , [ - 1 , 1 , 1 ] )

def Func(arg_0, arg_1, arg_2, arg_3=None):
  """Generates starting points for the Halton sequence procedure.

  The k'th element of the sequence is generated starting from a positive integer
  which must be distinct for each `k`. It is conventional to choose the starting
  point as `k` itself (or `k+1` if k is zero based). This function generates
  the starting integers for the required elements and reshapes the result for
  later use.

  Args:
    num_results: Positive scalar `Tensor` of dtype int32. The number of samples
      to generate. If this parameter is supplied, then `sequence_indices`
      should be None.
    sequence_indices: `Tensor` of dtype int32 and rank 1. The entries
      index into the Halton sequence starting with 0 and hence, must be whole
      numbers. For example, sequence_indices=[0, 5, 6] will produce the first,
      sixth and seventh elements of the sequence. If this parameter is not None
      then `n` must be None.
    dtype: The dtype of the sample. One of `float32` or `float64`.
      Default is `float32`.
    name: Python `str` name which describes ops created by this function.

  Returns:
    indices: `Tensor` of dtype `dtype` and shape = `[n, 1, 1]`.
  """
  with tf.compat.v1.name_scope(arg_3, 'Func',
                               [arg_0, arg_1]):
    if arg_1 is None:
      arg_0 = tf.cast(arg_0, arg_2=arg_2)
      arg_1 = tf.range(arg_0, arg_2=arg_2)
    else:
      arg_1 = tf.cast(arg_1, arg_2)

    # Shift the indices so they are 1 based.
    arg_4 = arg_1 + 1

    # Reshape to make space for the event dimension and the place value
    # coefficients.
    return tf.reshape(arg_4, [-1, 1, 1])

Generates starting points for the Halton sequence procedure .


(n, fmin=None, bins_per_octave=12, **_kwargs)

return core.cqt_frequencies(n+1,
                                fmin=fmin / 2.0**(0.5/bins_per_octave),
                                bins_per_octave=bins_per_octave)

def Func(arg_0, arg_1=None, arg_2=12, **arg_3):
    '''Get CQT bin frequencies'''
    if arg_1 is None:
        arg_1 = core.note_to_hz('C1')

    # we drop by half a bin so that CQT bins are centered vertically
    return core.cqt_frequencies(arg_0+1,
                                arg_1=arg_1 / 2.0**(0.5/arg_2),
                                arg_2=arg_2)