return ''.join(label_char_transform(c) for c in s)

def Func ( arg_0 ) : arg_1 = string . ascii_lowercase + string . digits + '-' def label_char_transform ( arg_2 ) : if arg_2 in arg_1 : return arg_2 if arg_2 in string . ascii_uppercase : return arg_2 . lower ( ) return '-' return '' . join ( label_char_transform ( arg_3 ) for arg_3 in arg_0 )

def Func(arg_0):
  """Turn the specified name and value into a valid Google label."""

  # We want the results to be user-friendly, not just functional.
  # So we can't base-64 encode it.
  #   * If upper-case: lower-case it
  #   * If the char is not a standard letter or digit. make it a dash

  # March 2019 note: underscores are now allowed in labels.
  # However, removing the conversion of underscores to dashes here would
  # create inconsistencies between old jobs and new jobs.
  # With existing code, $USER "jane_doe" has a user-id label of "jane-doe".
  # If we remove the conversion, the user-id label for new jobs is "jane_doe".
  # This makes looking up old jobs more complicated.

  arg_1 = string.ascii_lowercase + string.digits + '-'

  def label_char_transform(arg_2):
    if arg_2 in arg_1:
      return arg_2
    if arg_2 in string.ascii_uppercase:
      return arg_2.lower()
    return '-'

  return ''.join(label_char_transform(arg_3) for arg_3 in arg_0)

Turn the specified name and value into a valid Google label .


return self.intensity * np.exp(
            -self.sersic_constant * (((radius / self.effective_radius) ** (1. / self.sersic_index)) - 1))

def Func ( arg_0 , arg_1 ) : return arg_0 . intensity * np . exp ( - arg_0 . sersic_constant * ( ( ( arg_1 / arg_0 . effective_radius ) ** ( 1. / arg_0 . sersic_index ) ) - 1 ) )

def Func(arg_0, arg_1):
        """ Compute the intensity of the profile at a given radius.

        Parameters
        ----------
        radius : float
            The distance from the centre of the profile.
        """
        return arg_0.intensity * np.exp(
            -arg_0.sersic_constant * (((arg_1 / arg_0.effective_radius) ** (1. / arg_0.sersic_index)) - 1))

Compute the intensity of the profile at a given radius .


def Func ( arg_0 , arg_1 ) : arg_2 = [ ] arg_0 . _kill_elements ( arg_1 , lambda el : _conditional_comment_re . search ( el . text ) , etree . Comment )

def Func(arg_0, arg_1):
        """
        IE conditional comments basically embed HTML that the parser
        doesn't normally see.  We can't allow anything like that, so
        we'll kill any comments that could be conditional.
        """
        arg_2 = []
        arg_0._kill_elements(
            arg_1, lambda el: _conditional_comment_re.search(el.text),
            etree.Comment)

IE conditional comments basically embed HTML that the parser doesn t normally see . We can t allow anything like that so we ll kill any comments that could be conditional .


return scipy.signal.convolve(__normalize_onsets(onset_envelope),
                                 window,
                                 'same')

def Func ( arg_0 , arg_1 ) : arg_2 = np . exp ( - 0.5 * ( np . arange ( - arg_1 , arg_1 + 1 ) * 32.0 / arg_1 ) ** 2 ) return scipy . signal . convolve ( __normalize_onsets ( arg_0 ) , arg_2 , 'same' )

def Func(arg_0, arg_1):
    '''Construct the local score for an onset envlope and given period'''

    arg_2 = np.exp(-0.5 * (np.arange(-arg_1, arg_1+1)*32.0/arg_1)**2)
    return scipy.signal.convolve(__normalize_onsets(arg_0),
                                 arg_2,
                                 'same')


(
        self,
        name,
        subject,
        template_id,
        version_id,
        text='',
        html=None,
        timeout=None
    )

return self._api_request(
            self.TEMPLATES_VERSION_ENDPOINT % (template_id, version_id),
            self.HTTP_PUT,
            payload=payload,
            timeout=timeout
        )

def Func ( arg_0 , arg_1 , arg_2 , arg_3 , arg_4 , arg_5 = '' , arg_6 = None , arg_7 = None ) : if ( arg_6 ) : arg_8 = { 'name' : arg_1 , 'subject' : arg_2 , 'html' : arg_6 , 'text' : arg_5 } else : arg_8 = { 'name' : arg_1 , 'subject' : arg_2 , 'text' : arg_5 } return arg_0 . _api_request ( arg_0 . TEMPLATES_VERSION_ENDPOINT % ( arg_3 , arg_4 ) , arg_0 . HTTP_PUT , arg_8 = arg_8 , arg_7 = arg_7 )

def Func(
        arg_0,
        arg_1,
        arg_2,
        arg_3,
        arg_4,
        arg_5='',
        arg_6=None,
        arg_7=None
    ):
        """ API call to update a template version """
        if(arg_6):
            arg_8 = {
                'name': arg_1,
                'subject': arg_2,
                'html': arg_6,
                'text': arg_5
            }
        else:
            arg_8 = {
                'name': arg_1,
                'subject': arg_2,
                'text': arg_5
            }

        return arg_0._api_request(
            arg_0.TEMPLATES_VERSION_ENDPOINT % (arg_3, arg_4),
            arg_0.HTTP_PUT,
            arg_8=arg_8,
            arg_7=arg_7
        )


def
Func
(
arg_0
)
:
arg_1
=
max
(
[
len
(
l
)
for
l
,
_d
in
arg_0
]
)
for
arg_2
,
arg_3
in
arg_0
:
if
arg_3
==
[
]
:
arg_3
=
"-none-"
if
isinstance
(
arg_3
,
(
list
,
tuple
)
)
:
arg_4
=
"%*s:"
%
(
arg_1
,
arg_2
)
for
arg_5
in
arg_3
:
yield
"%*s %s"
%
(
arg_1
+
1
,
arg_4
,
arg_5
)
arg_4
=
""
else
:
yield
"%*s: %s"
%
(
arg_1
,
arg_2
,
arg_3
)

def Func(arg_0):
    """Produce a sequence of formatted lines from info.

    `info` is a sequence of pairs (label, data).  The produced lines are
    nicely formatted, ready to print.

    """
    arg_1 = max([len(l) for l, _d in arg_0])
    for arg_2, arg_3 in arg_0:
        if arg_3 == []:
            arg_3 = "-none-"
        if isinstance(arg_3, (list, tuple)):
            arg_4 = "%*s:" % (arg_1, arg_2)
            for arg_5 in arg_3:
                yield "%*s %s" % (arg_1+1, arg_4, arg_5)
                arg_4 = ""
        else:
            yield "%*s: %s" % (arg_1, arg_2, arg_3)

Produce a sequence of formatted lines from info .


def
Func
(
arg_0
,
arg_1
=
False
,
arg_2
=
False
)
:
with
ConnectionFactory
.
get
(
)
as
conn
:
arg_0
.
_initTables
(
cursor
=
conn
.
cursor
,
arg_1
=
arg_1
,
arg_2
=
arg_2
)
conn
.
cursor
.
execute
(
'SELECT CONNECTION_ID()'
)
arg_0
.
_FuncionID
=
conn
.
cursor
.
fetchall
(
)
[
0
]
[
0
]
arg_0
.
_logger
.
info
(
"clientJobsConnectionID=%r"
,
arg_0
.
_FuncionID
)
return

def Func(arg_0, arg_1=False, arg_2=False):
    """ Locate the current version of the jobs DB or create a new one, and
    optionally delete old versions laying around. If desired, this method
    can be called at any time to re-create the tables from scratch, delete
    old versions of the database, etc.

    Parameters:
    ----------------------------------------------------------------
    deleteOldVersions:   if true, delete any old versions of the DB left
                          on the server
    recreate:            if true, recreate the database from scratch even
                          if it already exists.
    """

    # Initialize tables, if needed
    with ConnectionFactory.get() as conn:
      # Initialize tables
      arg_0._initTables(cursor=conn.cursor, arg_1=arg_1,
                       arg_2=arg_2)

      # Save our Funcion id
      conn.cursor.execute('SELECT CONNECTION_ID()')
      arg_0._FuncionID = conn.cursor.fetchall()[0][0]
      arg_0._logger.info("clientJobsConnectionID=%r", arg_0._FuncionID)

    return

Locate the current version of the jobs DB or create a new one and optionally delete old versions laying around . If desired this method can be called at any time to re - create the tables from scratch delete old versions of the database etc .


def Func ( arg_0 , arg_1 , arg_2 = None ) : arg_3 = sorted ( [ arg_0 . expose_ancestors_or_children ( member , arg_1 , arg_2 = arg_2 ) for member in arg_1 . members if member . get_label ( ) ] , key = itemgetter ( "label" ) ) return arg_3

def Func(arg_0, arg_1, arg_2=None):
        """ Build member list for given collection

        :param collection: Collection to build dict view of for its members
        :param lang: Language to express data in
        :return: List of basic objects
        """
        arg_3 = sorted([
                arg_0.expose_ancestors_or_children(member, arg_1, arg_2=arg_2)
                for member in arg_1.members
                if member.get_label()
            ],
            key=itemgetter("label")
        )
        return arg_3


def
Func
(
arg_0
)
:
arg_1
=
0
arg_0
.
_start
(
)
while
True
:
arg_2
=
arg_0
.
_socket
.
recv_pyobj
(
)
if
isinstance
(
arg_2
,
tuple
)
:
arg_3
,
arg_4
=
arg_2
else
:
arg_3
=
arg_2
arg_4
=
if
arg_3
==
arg_0
.
SPACE
:
if
arg_0
.
queue
.
qsize
(
)
+
arg_1
<
arg_0
.
queue_maxsize
:
arg_0
.
_socket
.
send_string
(
arg_0
.
SPACE_AVAILABLE
)
arg_1
+=
1
else
:
arg_0
.
_socket
.
send_string
(
arg_0
.
SPACE_NOT_AVAILABLE
)
elif
arg_3
==
arg_0
.
PING
:
arg_0
.
_socket
.
send_string
(
arg_0
.
PONG
)
elif
arg_3
==
arg_0
.
DATA
:
arg_0
.
_socket
.
send_string
(
arg_0
.
STORING
)
arg_0
.
queue
.
put
(
arg_4
)
arg_1
-=
1
elif
arg_3
==
arg_0
.
DONE
:
arg_0
.
_socket
.
send_string
(
ZMQServer
.
CLOSED
)
arg_0
.
queue
.
put
(
(
'DONE'
,
[
]
,
{
}
)
)
arg_0
.
_close
(
)
break
else
:
raise
RuntimeError
(
'I did not understand your request %s'
%
arg_3
)

def Func(arg_0):
        """ Handles Funcing requests from the client.

        There are 4 types of requests:

        1- Check space in the queue
        2- Tests the socket
        3- If there is a space, it sends data
        4- after data is sent, puts it to queue for storing

        """
        arg_1 = 0
        arg_0._start()
        while True:
            arg_2 = arg_0._socket.recv_pyobj()

            if isinstance(arg_2, tuple):
                arg_3, arg_4 = arg_2
            else:
                arg_3 = arg_2
                arg_4 = None

            if arg_3 == arg_0.SPACE:
                if arg_0.queue.qsize() + arg_1 < arg_0.queue_maxsize:
                    arg_0._socket.send_string(arg_0.SPACE_AVAILABLE)
                    arg_1 += 1
                else:
                    arg_0._socket.send_string(arg_0.SPACE_NOT_AVAILABLE)

            elif arg_3 == arg_0.PING:
                arg_0._socket.send_string(arg_0.PONG)

            elif arg_3 == arg_0.DATA:
                arg_0._socket.send_string(arg_0.STORING)
                arg_0.queue.put(arg_4)
                arg_1 -= 1

            elif arg_3 == arg_0.DONE:
                arg_0._socket.send_string(ZMQServer.CLOSED)
                arg_0.queue.put(('DONE', [], {}))
                arg_0._close()
                break

            else:
                raise RuntimeError('I did not understand your request %s' % arg_3)

Handles listening requests from the client.

        There are 4 types of requests:

        1- Check space in the queue
        2- Tests the socket
        3- If there is a space, it sends data
        4- after data is sent, puts it to queue for storing

Handles listening requests from the client .


def Func ( arg_0 , arg_1 = None ) : if arg_1 is None : return arg_0 . _Func ( ) arg_2 = transform ( arg_1 , arg_0 . sref ) arg_3 = Envelope . from_geom ( arg_2 ) . intersect ( arg_0 . envelope ) arg_4 = arg_0 . _Func ( arg_3 ) if arg_2 . GetGeometryType ( ) != ogr . wkbPoint : arg_5 = arg_0 . get_offset ( arg_3 ) [ 2 : ] arg_6 = AffineTransform ( * tuple ( arg_0 . affine ) ) arg_6 . origin = arg_3 . ul arg_8 = ~ np . ma . make_mask ( geom_to_array ( arg_2 , arg_5 , arg_6 ) ) arg_4 . mask = arg_4 . mask | arg_8 return arg_4

def Func(arg_0, arg_1=None):
        """Returns a MaskedArray using nodata values.

        Keyword args:
        geometry -- any geometry, envelope, or coordinate extent tuple
        """
        if arg_1 is None:
            return arg_0._Func()
        arg_2 = transform(arg_1, arg_0.sref)
        arg_3 = Envelope.from_geom(arg_2).intersect(arg_0.envelope)
        arg_4 = arg_0._Func(arg_3)
        if arg_2.GetGeometryType() != ogr.wkbPoint:
            arg_5 = arg_0.get_offset(arg_3)[2:]
            arg_6 = AffineTransform(*tuple(arg_0.affine))
            arg_6.origin = arg_3.ul
            arg_8 = ~np.ma.make_mask(geom_to_array(arg_2, arg_5, arg_6))
            arg_4.mask = arg_4.mask | arg_8
        return arg_4

Returns a MaskedArray using nodata values .


return [x for x in self.list_gen(keyword, arg)]

def Func ( arg_0 , arg_1 = None , arg_2 = None ) : return [ arg_3 for arg_3 in arg_0 . Func_gen ( arg_1 , arg_2 ) ]

def Func(arg_0, arg_1=None, arg_2=None):
        """LIST command.

        A wrapper for all of the other Func commands. The output of this command
        depends on the keyword specified. The output format for each keyword can
        be found in the Func function that corresponds to the keyword.

        Args:
            keyword: Information requested.
            arg: Pattern or keyword specific argument.

        Note: Keywords supported by this function are include ACTIVE,
            ACTIVE.TIMES, DISTRIB.PATS, HEADERS, NEWSGROUPS, OVERVIEW.FMT and
            EXTENSIONS.

        Raises:
            NotImplementedError: For unsupported keywords.
        """
        return [arg_3 for arg_3 in arg_0.Func_gen(arg_1, arg_2)]

LIST command.

        A wrapper for all of the other list commands. The output of this command
        depends on the keyword specified. The output format for each keyword can
        be found in the list function that corresponds to the keyword.

        Args:
            keyword: Information requested.
            arg: Pattern or keyword specific argument.

        Note: Keywords supported by this function are include ACTIVE,
            ACTIVE.TIMES, DISTRIB.PATS, HEADERS, NEWSGROUPS, OVERVIEW.FMT and
            EXTENSIONS.

        Raises:
            NotImplementedError: For unsupported keywords.


def Func(arg_0, arg_1, arg_2, arg_3):
        """Walk through the knitting pattern by expanding an row."""
        if arg_1 in arg_3 or not arg_0._row_should_be_placed(arg_1, arg_2):
            return
        arg_0._place_row(arg_1, arg_2)
        arg_3 = [arg_1] + arg_3
        # print("{}{} at\t{} {}".format("  " * len(passed), row, position,
        #                               passed))
        for arg_4, arg_5 in enumerate(arg_1.produced_meshes):
            arg_0._expand_produced_mesh(arg_5, arg_4, arg_2, arg_3)
        for arg_4, arg_6 in enumerate(arg_1.consumed_meshes):
            arg_0._expand_consumed_mesh(arg_6, arg_4, arg_2, arg_3)

Walk through the knitting pattern by expanding an row .


def Func(arg_0, arg_1):
        """
        Set the list of preferred client certificate signers for this server
        context.

        This list of certificate authorities will be sent to the client when
        the server requests a client certificate.

        :param certificate_authorities: a sequence of X509Names.
        :return: None

        .. versionadded:: 0.10
        """
        arg_2 = _lib.sk_X509_NAME_new_null()
        _openssl_assert(arg_2 != _ffi.NULL)

        try:
            for arg_3 in arg_1:
                if not isinstance(arg_3, X509Name):
                    raise TypeError(
                        "client CAs must be X509Name objects, not %s "
                        "objects" % (
                            type(arg_3).__name__,
                        )
                    )
                arg_4 = _lib.X509_NAME_dup(arg_3._name)
                _openssl_assert(arg_4 != _ffi.NULL)
                arg_5 = _lib.sk_X509_NAME_push(arg_2, arg_4)
                if not arg_5:
                    _lib.X509_NAME_free(arg_4)
                    _raise_current_error()
        except Exception:
            _lib.sk_X509_NAME_free(arg_2)
            raise

        _lib.SSL_CTX_set_client_CA_list(arg_0._context, arg_2)

Set the list of preferred client certificate signers for this server context .


return pd.concat([mart_names, mart_descriptions], axis=1)

def Func ( arg_0 ) : arg_1 = pd . Series ( arg_0 . names , name = "Name" ) arg_2 = pd . Series ( arg_0 . displayNames , name = "Description" ) return pd . concat ( [ arg_1 , arg_2 ] , axis = 1 )

def Func(arg_0):
        """Get available marts and their names."""

        arg_1 = pd.Series(arg_0.names, name="Name")
        arg_2 = pd.Series(arg_0.displayNames, name="Description")

        return pd.concat([arg_1, arg_2], axis=1)


def Func ( arg_0 , arg_1 = 5 ) : from IPython import display display . display ( display . HTML ( arg_0 . _head_and_tail_table ( arg_1 ) ) )

def Func(arg_0, arg_1=5):
        """Display the first and last n elements of a DataFrame."""
        from IPython import display
        display.display(display.HTML(arg_0._head_and_tail_table(arg_1)))

Display the first and last n elements of a DataFrame .


def Func ( arg_0 ) : arg_1 = arg_0 . tabWidget . current_widget ( ) . file . path arg_1 = os . path . dirname ( arg_1 ) if arg_1 else '' arg_2 , arg_3 = QtWidgets . QFileDialog . getSaveFileName ( arg_0 , 'Save' , arg_1 ) if arg_2 : arg_0 . tabWidget . save_current ( arg_2 ) arg_0 . recent_files_manager . open_file ( arg_2 ) arg_0 . menu_recents . update_actions ( ) arg_0 . actionRun . setEnabled ( True ) arg_0 . actionConfigure_run . setEnabled ( True ) arg_0 . _update_status_bar ( arg_0 . tabWidget . current_widget ( ) )

def Func(arg_0):
        """
        Save the current editor document as.
        """
        arg_1 = arg_0.tabWidget.current_widget().file.path
        arg_1 = os.path.dirname(arg_1) if arg_1 else ''
        arg_2, arg_3 = QtWidgets.QFileDialog.getSaveFileName(
            arg_0, 'Save', arg_1)
        if arg_2:
            arg_0.tabWidget.save_current(arg_2)
            arg_0.recent_files_manager.open_file(arg_2)
            arg_0.menu_recents.update_actions()
            arg_0.actionRun.setEnabled(True)
            arg_0.actionConfigure_run.setEnabled(True)
            arg_0._update_status_bar(arg_0.tabWidget.current_widget())


def Func(arg_0, Func):
        """
        Sets the nature of this YearlyFinancials.
        Nature of the balancesheet

        :param nature: The nature of this YearlyFinancials.
        :type: str
        """
        arg_2 = ["STANDALONE"]
        if Func not in arg_2:
            raise ValueError(
                "Invalid value for `nature`, must be one of {0}"
                .format(arg_2)
            )
        arg_0._nature = Func

Sets the nature of this YearlyFinancials . Nature of the balancesheet


def Func ( arg_0 , arg_1 , arg_2 ) : arg_1 . write ( Operators . ITEBV ( arg_1 . size , Operators . AND ( arg_0 . ZF == 0 , arg_0 . SF == arg_0 . OF ) , arg_2 . read ( ) , arg_1 . read ( ) ) )

def Func(arg_0, arg_1, arg_2):
        """
        Conditional move - Greater.

        Tests the status flags in the EFLAGS register and moves the source operand
        (second operand) to the destination operand (first operand) if the given
        test condition is true.

        :param cpu: current CPU.
        :param dest: destination operand.
        :param src: source operand.
        """
        arg_1.write(Operators.ITEBV(arg_1.size, Operators.AND(arg_0.ZF == 0, arg_0.SF == arg_0.OF), arg_2.read(), arg_1.read()))


def Func ( arg_0 , arg_1 , arg_2 ) : arg_3 = { } arg_4 = AskbotParser . parse_question_container ( arg_0 [ 0 ] ) arg_3 . update ( arg_4 ) if arg_2 [ int ( arg_1 [ 'id' ] ) ] : arg_3 [ 'comments' ] = arg_2 [ int ( arg_1 [ 'id' ] ) ] arg_5 = [ ] for arg_6 in arg_0 : arg_5 . extend ( AskbotParser . parse_answers ( arg_6 ) ) if len ( arg_5 ) != 0 : arg_3 [ 'answers' ] = arg_5 for arg_7 in arg_3 [ 'answers' ] : if arg_2 [ int ( arg_7 [ 'id' ] ) ] : arg_7 [ 'comments' ] = arg_2 [ int ( arg_7 [ 'id' ] ) ] return arg_3

def Func(arg_0, arg_1, arg_2):
        """Build an Askbot HTML response.

        The method puts together all the information regarding a question

        :param html_question: array of HTML raw pages
        :param question: question object from the API
        :param comments: list of comments to add

        :returns: a dict item with the parsed question information
        """
        arg_3 = {}
        # Parse the user info from the soup container
        arg_4 = AskbotParser.parse_question_container(arg_0[0])
        # Add the info to the question object
        arg_3.update(arg_4)
        # Add the comments of the question (if any)
        if arg_2[int(arg_1['id'])]:
            arg_3['comments'] = arg_2[int(arg_1['id'])]

        arg_5 = []

        for arg_6 in arg_0:
            arg_5.extend(AskbotParser.parse_answers(arg_6))

        if len(arg_5) != 0:
            arg_3['answers'] = arg_5
            for arg_7 in arg_3['answers']:
                if arg_2[int(arg_7['id'])]:
                    arg_7['comments'] = arg_2[int(arg_7['id'])]

        return arg_3


def Func ( arg_0 , arg_1 = 0 ) : arg_2 = arg_1 while arg_2 + 1 < len ( arg_0 . data ) : if arg_0 . data [ arg_2 ] [ 1 ] >= arg_0 . data [ arg_2 + 1 ] [ 0 ] : if arg_0 . data [ arg_2 ] [ 1 ] < arg_0 . data [ arg_2 + 1 ] [ 1 ] : arg_0 . data [ arg_2 ] [ 1 ] = arg_0 . data [ arg_2 + 1 ] [ 1 ] del arg_0 . data [ arg_2 + 1 ] arg_2 += 1

def Func(arg_0, arg_1=0):
        """Enforce that no ranges overlap in internal storage."""
        arg_2 = arg_1
        while arg_2+1 < len(arg_0.data):
            if arg_0.data[arg_2][1] >= arg_0.data[arg_2+1][0]:
                # beginning of i+1-th range is contained in i-th range
                if arg_0.data[arg_2][1] < arg_0.data[arg_2+1][1]:
                    # i+1-th range is longer, thus enlarge i-th range
                    arg_0.data[arg_2][1] = arg_0.data[arg_2+1][1]

                # removed contained range
                del arg_0.data[arg_2+1]
            arg_2 += 1

Enforce that no ranges overlap in internal storage .


(
            self, name: str,
            labels: Union[Dict[str, str], None] = None)

def Func(
            arg_0, arg_1: arg_2,
            arg_3: arg_4[arg_5[arg_2, arg_2], None] = None) -> Metric:
        """Return a metric, optionally configured with labels."""
        arg_6 = arg_0._metrics[arg_1]
        if arg_3:
            return arg_6.labels(**arg_3)

        return arg_6

Return a metric optionally configured with labels .


def Func ( arg_0 ) : if arg_0 . _api_result . status_code != requests . codes . ok : print ( arg_0 . colorize_json ( arg_0 . _api_result . text ) )

def Func(arg_0):
        """
        Handle the results of the API call
        """

        # Only process if we get HTTP return code other 200.
        if arg_0._api_result.status_code != requests.codes.ok:
            print(arg_0.colorize_json(arg_0._api_result.text))


(packages, update=False, options=None, version=None)

def Func(arg_0, arg_1=False, arg_2=None, arg_3=None):
    """
    Install one or more packages.

    If *update* is ``True``, the package definitions will be updated
    first, using :py:func:`~burlap.deb.update_index`.

    Extra *options* may be passed to ``apt-get`` if necessary.

    Example::

        import burlap

        # Update index, then Func a single package
        burlap.deb.Func('build-essential', update=True)

        # Install multiple packages
        burlap.deb.Func([
            'python-dev',
            'libxml2-dev',
        ])

        # Install a specific version
        burlap.deb.Func('emacs', version='23.3+1-1ubuntu9')

    """
    arg_4 = MANAGER
    if arg_1:
        update_index()
    if arg_2 is None:
        arg_2 = []
    if arg_3 is None:
        arg_3 = ''
    if arg_3 and not isinstance(arg_0, list):
        arg_3 = '=' + arg_3
    if not isinstance(arg_0, six.string_types):
        arg_0 = " ".join(arg_0)
    arg_2.append("--quiet")
    arg_2.append("--assume-yes")
    arg_2 = " ".join(arg_2)
    arg_5 = '%(manager)s Func %(options)s %(packages)s%(version)s' % locals()
    run_as_root(arg_5, pty=False)

Install one or more packages.

    If *update* is ``True``, the package definitions will be updated
    first, using :py:func:`~burlap.deb.update_index`.

    Extra *options* may be passed to ``apt-get`` if necessary.

    Example::

        import burlap

        # Update index, then install a single package
        burlap.deb.install('build-essential', update=True)

        # Install multiple packages
        burlap.deb.install([
            'python-dev',
            'libxml2-dev',
        ])

        # Install a specific version
        burlap.deb.install('emacs', version='23.3+1-1ubuntu9')


(self, analytes=None, win=15, lognorm=True,
                           bins=25, filt=False, samples=None,
                           subset=None, figsize=(12, 12), save=False,
                           colourful=True, mode='hist2d', recalc=True, **kwargs)

def Func ( arg_0 , arg_1 = None , arg_2 = 15 , arg_3 = True , arg_4 = 25 , arg_5 = False , arg_6 = None , arg_7 = None , arg_8 = ( 12 , 12 ) , arg_9 = False , arg_10 = True , arg_11 = 'hist2d' , arg_12 = True , ** arg_13 ) : if arg_1 is None : arg_1 = arg_0 . analytes if arg_0 . focus_stage in [ 'ratio' , 'calibrated' ] : arg_1 = [ a for a in arg_1 if arg_0 . internal_standard not in a ] try : arg_1 = sorted ( arg_1 , key = lambda x : float ( re . findall ( '[0-9.-]+' , x ) [ 0 ] ) ) except IndexError : arg_1 = sorted ( arg_1 ) arg_6 = arg_0 . _get_samples ( arg_7 ) arg_0 . get_gradients ( arg_1 = arg_1 , arg_2 = arg_2 , arg_5 = arg_5 , arg_7 = arg_7 , arg_12 = arg_12 ) arg_14 , arg_15 = plot . crossplot ( dat = arg_0 . gradients , keys = arg_1 , arg_3 = arg_3 , arg_4 = arg_4 , arg_8 = arg_8 , arg_10 = arg_10 , focus_stage = arg_0 . focus_stage , cmap = arg_0 . cmaps , denominator = arg_0 . internal_standard , arg_11 = arg_11 ) if arg_9 : arg_14 . savefig ( arg_0 . report_dir + '/g_crossplot.png' , dpi = 200 ) return arg_14 , arg_15

def Func(arg_0, arg_1=None, arg_2=15, arg_3=True,
                           arg_4=25, arg_5=False, arg_6=None,
                           arg_7=None, arg_8=(12, 12), arg_9=False,
                           arg_10=True, arg_11='hist2d', arg_12=True, **arg_13):
        """
        Plot analyte gradients against each other.

        Parameters
        ----------
        analytes : optional, array_like or str
            The analyte(s) to plot. Defaults to all analytes.
        lognorm : bool
            Whether or not to log normalise the colour scale
            of the 2D histogram.
        bins : int
            The number of bins in the 2D histogram.
        filt : str, dict or bool
            Either logical filter expression contained in a str,
            a dict of expressions specifying the filter string to
            use for each analyte or a boolean. Passed to `grab_filt`.
        figsize : tuple
            Figure size (width, height) in inches.
        save : bool or str
            If True, plot is saves as 'crossplot.png', if str plot is
            saves as str.
        colourful : bool
            Whether or not the plot should be colourful :).
        mode : str
            'hist2d' (default) or 'scatter'
        recalc : bool
            Whether to re-calculate the gradients, or use existing gradients.

        Returns
        -------
        (fig, axes)
        """

        if arg_1 is None:
            arg_1 = arg_0.analytes
        if arg_0.focus_stage in ['ratio', 'calibrated']:
            arg_1 = [a for a in arg_1 if arg_0.internal_standard not in a]

        # sort analytes
        try:
            arg_1 = sorted(arg_1, key=lambda x: float(re.findall('[0-9.-]+', x)[0]))
        except IndexError:
            arg_1 = sorted(arg_1)

        arg_6 = arg_0._get_samples(arg_7)

        # calculate gradients
        arg_0.get_gradients(arg_1=arg_1, arg_2=arg_2, arg_5=arg_5, arg_7=arg_7, arg_12=arg_12)

        # self.get_focus(filt=filt, samples=samples, subset=subset)
        # grads = calc_grads(self.focus.uTime, self.focus, analytes, win)

        arg_14, arg_15 = plot.crossplot(dat=arg_0.gradients, keys=arg_1, arg_3=arg_3,
                                   arg_4=arg_4, arg_8=arg_8, arg_10=arg_10,
                                   focus_stage=arg_0.focus_stage, cmap=arg_0.cmaps,
                                   denominator=arg_0.internal_standard, arg_11=arg_11)

        if arg_9:
            arg_14.savefig(arg_0.report_dir + '/g_crossplot.png', dpi=200)

        return arg_14, arg_15

Plot analyte gradients against each other .


def Func ( arg_0 , arg_1 ) : try : Archive ( arg_1 ) except ArchiveError as e : raise ArchiveManagerError ( cause = str ( e ) ) os . remove ( arg_1 )

def Func(arg_0, arg_1):
        """Remove an archive.

        This method deletes from the filesystem the archive stored
        in `archive_path`.

        :param archive_path: path to the archive

        :raises ArchiveManangerError: when an error occurs removing the
            archive
        """
        try:
            Archive(arg_1)
        except ArchiveError as e:
            raise ArchiveManagerError(cause=str(e))

        os.remove(arg_1)


def Func ( arg_0 , arg_1 ) : if arg_1 is None : arg_1 = os . environ . get ( 'TFS_API_TOKEN' , None ) arg_2 = BasicAuthentication ( '' , arg_1 ) arg_3 = VssConnection ( base_url = arg_0 , creds = arg_2 ) return arg_3

def Func(arg_0, arg_1):
    """
    Creates the TFS Connection Context
    """
    if arg_1 is None:
        arg_1 = os.environ.get('TFS_API_TOKEN', None)

    arg_2 = BasicAuthentication('', arg_1)
    arg_3 = VssConnection(base_url=arg_0, creds=arg_2)
    return arg_3


def Func ( arg_0 ) : arg_1 , arg_2 = struct . unpack ( ">ll" , arg_0 [ 0 : 8 ] ) arg_3 = ( long ( arg_1 ) << 32 ) + arg_2 arg_4 = arg_0 [ 8 : ] return ( arg_3 , arg_4 )

def Func(arg_0):
    """Tries to interpret the next 8 bytes of the data
    as a 64-bit signed integer."""
    arg_1, arg_2 = struct.unpack(">ll", arg_0[0:8])
    arg_3 = (long(arg_1) << 32) + arg_2
    arg_4 = arg_0[8:]
    return (arg_3, arg_4)

Tries to interpret the next 8 bytes of the data as a 64 - bit signed integer .


def Func ( arg_0 , arg_1 , arg_2 ) : arg_3 = arg_2 . cleaned_data [ ManageLearnersForm . Fields . EMAIL_OR_USERNAME ] arg_4 = email_or_username__to__email ( arg_3 ) try : validate_email_to_link ( arg_4 , arg_3 , ValidationMessages . INVALID_EMAIL_OR_USERNAME , True ) except ValidationError as exc : arg_2 . add_error ( ManageLearnersForm . Fields . EMAIL_OR_USERNAME , exc ) else : EnterpriseCustomerUser . objects . link_user ( arg_1 , arg_4 ) return [ arg_4 ]

def Func(arg_0, arg_1, arg_2):
        """
        Link single user by email or username.

        Arguments:
            enterprise_customer (EnterpriseCustomer): learners will be linked to this Enterprise Customer instance
            manage_learners_form (ManageLearnersForm): bound ManageLearners form instance
        """
        arg_3 = arg_2.cleaned_data[ManageLearnersForm.Fields.EMAIL_OR_USERNAME]
        arg_4 = email_or_username__to__email(arg_3)
        try:
            validate_email_to_link(arg_4, arg_3, ValidationMessages.INVALID_EMAIL_OR_USERNAME, True)
        except ValidationError as exc:
            arg_2.add_error(ManageLearnersForm.Fields.EMAIL_OR_USERNAME, exc)
        else:
            EnterpriseCustomerUser.objects.link_user(arg_1, arg_4)
            return [arg_4]


(self,
                  user_ids,
                  job_ids,
                  task_ids,
                  labels,
                  create_time_min=None,
                  create_time_max=None)

return google_base.cancel(self._service.new_batch_http_request,
                              self._service.operations().cancel, tasks)

def Func(arg_0,
                  arg_1,
                  arg_2,
                  arg_3,
                  arg_4,
                  arg_5=None,
                  arg_6=None):
    """Kills the operations associated with the specified job or job.task.

    Args:
      user_ids: List of user ids who "own" the job(s) to cancel.
      job_ids: List of job_ids to cancel.
      task_ids: List of task-ids to cancel.
      labels: List of LabelParam, each must match the job(s) to be canceled.
      create_time_min: a timezone-aware datetime value for the earliest create
                       time of a task, inclusive.
      create_time_max: a timezone-aware datetime value for the most recent
                       create time of a task, inclusive.

    Returns:
      A list of tasks canceled and a list of error messages.
    """
    # Look up the job(s)
    arg_7 = list(
        arg_0.lookup_job_tasks(
            {'RUNNING'},
            arg_1=arg_1,
            arg_2=arg_2,
            arg_3=arg_3,
            arg_4=arg_4,
            arg_5=arg_5,
            arg_6=arg_6))

    print('Found %d tasks to delete.' % len(arg_7))

    return google_base.cancel(arg_0._service.new_batch_http_request,
                              arg_0._service.operations().cancel, arg_7)

Kills the operations associated with the specified job or job . task .


def Func(arg_0):
    """If f_back is looking at a call function, return
    the name for it. Otherwise return None"""
    arg_1 = arg_0.f_back
    if not arg_1: return None
    if 'CALL_FUNCTION' != Mbytecode.op_at_frame(arg_1): return None

    arg_2         = arg_1.f_code
    arg_3       = arg_2.co_code
    # labels     = dis.findlabels(code)
    arg_4 = dict(dis.findlinestarts(arg_2))
    arg_5     = arg_1.f_lasti
    while arg_5 >= 0:
        if arg_5 in arg_4:
            arg_6 = arg_3[arg_5]
            arg_5 += 1
            arg_7 = arg_3[arg_5]
            # FIXME: put this code in xdis
            arg_8 = 0
            while True:
                if PYTHON_VERSION >= 3.6:
                    if arg_6 == opc.EXTENDED_ARG:
                        arg_8 += (arg_7 << 8)
                        continue
                    arg_7 = arg_3[arg_5] + arg_8
                    # FIXME: Python 3.6.0a1 is 2, for 3.6.a3 we have 1
                else:
                    if arg_6 == opc.EXTENDED_ARG:
                        arg_8 += (arg_7 << 256)
                        continue
                    arg_7 = arg_3[arg_5] + arg_3[arg_5+1]*256 + arg_8
                break

            return arg_2.co_names[arg_7]
        arg_5 -= 1
        pass
    return None

If f_back is looking at a call function return the name for it . Otherwise return None


(obj, path, oned_as='row', convert_to_float=True)

def
Func
(
arg_0
,
arg_1
,
arg_2
=
'row'
,
arg_3
=
True
)
:
arg_4
=
_encode
(
arg_0
,
arg_3
)
try
:
with
_WRITE_LOCK
:
savemat
(
arg_1
,
arg_4
,
appendmat
=
False
,
arg_2
=
arg_2
,
long_field_names
=
True
)
except
KeyError
:
raise
Exception
(
'could not save mat file'
)

def Func(arg_0, arg_1, arg_2='row', arg_3=True):
    """Save a Python object to an Octave file on the given path.
    """
    arg_4 = _encode(arg_0, arg_3)
    try:
        # scipy.io.savemat is not thread-save.
        # See https://github.com/scipy/scipy/issues/7260
        with _WRITE_LOCK:
            savemat(arg_1, arg_4, appendmat=False, arg_2=arg_2,
                    long_field_names=True)
    except KeyError:  # pragma: no cover
        raise Exception('could not save mat file')

Save a Python object to an Octave file on the given path .


def Func ( arg_0 , arg_1 , * arg_2 , ** arg_3 ) : arg_0 . put_nowait ( functools . partial ( arg_1 , * arg_2 , ** arg_3 ) )

def Func(arg_0, arg_1, *arg_2, **arg_3):
        """
        Defer an edit to run on the EditQueue.

        :param callable f: The function to be called
        :param tuple args: Positional arguments to the function
        :param tuple kwds: Keyword arguments to the function
        :throws queue.Full: if the queue is full
        """
        arg_0.put_nowait(functools.partial(arg_1, *arg_2, **arg_3))


def Func ( arg_0 ) : arg_1 = defaultdict ( list ) for arg_2 , arg_3 in enumerate ( arg_0 . _stripped_lines ) : if arg_3 : arg_1 [ arg_3 ] . append ( arg_2 ) return arg_1

def Func(arg_0):
        """create the index for this set"""
        arg_1 = defaultdict(list)
        for arg_2, arg_3 in enumerate(arg_0._stripped_lines):
            if arg_3:
                arg_1[arg_3].append(arg_2)
        return arg_1


def Func(arg_0, arg_1, arg_2, arg_3):
        """Get access token secret.

        The access token object should a ``secret`` attribute.
        """
        log.debug('Get access token secret of %r for %r',
                  arg_2, arg_1)
        arg_4 = arg_3.access_token or arg_0._tokengetter(
            arg_1=arg_1,
            arg_2=arg_2,
        )
        if arg_4:
            arg_3.access_token = arg_4
            return arg_4.secret
        return None


def Func ( arg_0 , arg_1 , arg_2 ) : if arg_0 . has_extr_lic ( arg_1 ) : arg_0 . extr_lic ( arg_1 ) . add_xref ( arg_2 ) return True else : raise OrderError ( 'ExtractedLicense::CrossRef' )

def Func(arg_0, arg_1, arg_2):
        """Adds a license cross reference.
        Raises OrderError if no License ID defined.
        """
        if arg_0.has_extr_lic(arg_1):
            arg_0.extr_lic(arg_1).add_xref(arg_2)
            return True
        else:
            raise OrderError('ExtractedLicense::CrossRef')

Adds a license cross reference . Raises OrderError if no License ID defined .


def
Func
(
arg_0
,
arg_1
)
:
arg_2
=
arg_0
.
resourceNameToPath
(
arg_1
,
".json"
)
try
:
arg_3
=
json
.
load
(
open
(
arg_2
,
"r"
)
)
except
Exception
:
print
(
"Exception during model load: "
)
import
traceback
traceback
.
print_exc
(
)
return
{
}
arg_4
=
{
}
if
arg_3
.
get
(
"version"
,
1
)
==
1
:
arg_4
[
"materials"
]
=
{
}
for
arg_1
,
arg_5
in
arg_3
.
get
(
"materials"
,
{
}
)
.
items
(
)
:
arg_6
=
model
.
Material
(
arg_0
,
arg_1
,
arg_5
)
arg_4
[
"materials"
]
[
arg_1
]
=
arg_6
arg_4
[
"default_material"
]
=
arg_4
[
"materials"
]
[
arg_3
.
get
(
"default_material"
,
list
(
arg_4
[
"materials"
]
.
keys
(
)
)
[
0
]
)
]
arg_4
[
"bones"
]
=
{
"__root__"
:
model
.
RootBone
(
arg_0
,
"__root__"
,
{
"start_rot"
:
[
0
,
0
]
,
"length"
:
0
}
)
}
for
arg_1
,
arg_7
in
arg_3
.
get
(
"bones"
,
{
}
)
.
items
(
)
:
arg_8
=
model
.
Bone
(
arg_0
,
arg_1
,
arg_7
)
arg_4
[
"bones"
]
[
arg_1
]
=
arg_8
for
arg_1
,
arg_9
in
arg_4
[
"bones"
]
.
items
(
)
:
if
arg_1
==
"__root__"
:
continue
arg_9
.
setParent
(
arg_4
[
"bones"
]
[
arg_9
.
bonedata
[
"parent"
]
]
)
arg_4
[
"regions"
]
=
{
}
for
arg_1
,
arg_10
in
arg_3
.
get
(
"regions"
,
{
}
)
.
items
(
)
:
arg_11
=
model
.
Region
(
arg_0
,
arg_1
,
arg_10
)
arg_11
.
material
=
arg_4
[
"materials"
]
[
arg_10
.
get
(
"material"
,
arg_4
[
"default_material"
]
)
]
arg_11
.
bone
=
arg_4
[
"bones"
]
[
arg_10
.
get
(
"bone"
,
"__root__"
)
]
arg_4
[
"bones"
]
[
arg_10
.
get
(
"bone"
,
"__root__"
)
]
.
addRegion
(
arg_11
)
arg_4
[
"regions"
]
[
arg_1
]
=
arg_11
arg_4
[
"animations"
]
=
{
}
arg_4
[
"animations"
]
[
"static"
]
=
model
.
Animation
(
arg_0
,
"static"
,
{
"type"
:
"static"
,
"bones"
:
{
}
}
)
for
arg_1
,
arg_13
in
arg_3
.
get
(
"animations"
,
{
}
)
.
items
(
)
:
arg_14
=
model
.
Animation
(
arg_0
,
arg_1
,
arg_13
)
arg_14
.
setBones
(
arg_4
[
"bones"
]
)
arg_4
[
"animations"
]
[
arg_1
]
=
arg_14
arg_4
[
"default_animation"
]
=
arg_4
[
"animations"
]
[
arg_3
.
get
(
"default_animation"
,
arg_4
[
"animations"
]
[
"static"
]
)
]
else
:
raise
ValueError
(
"Unknown version %s of model '%s'"
%
(
arg_3
.
get
(
"version"
,
1
)
,
arg_1
)
)
arg_0
.
modelcache
[
arg_1
]
=
arg_4
return
arg_4

def Func(arg_0,arg_1):
        """
        Loads the model data of the given name.

        The model file must always be a .json file.
        """
        arg_2 = arg_0.resourceNameToPath(arg_1,".json")
        try:
            arg_3 = json.load(open(arg_2,"r"))
        except Exception:
            # Temporary
            print("Exception during model load: ")
            import traceback;traceback.print_exc()
            return {}# will probably cause other exceptions later on, TODO

        arg_4 = {}

        if arg_3.get("version",1)==1:
            # Currently only one version, basic future-proofing
            # This version should get incremented with breaking changes to the structure

            # Materials
            arg_4["materials"]={}
            for arg_1,arg_5 in arg_3.get("materials",{}).items():
                arg_6 = model.Material(arg_0,arg_1,arg_5)
                arg_4["materials"][arg_1]=arg_6
            arg_4["default_material"]=arg_4["materials"][arg_3.get("default_material",list(arg_4["materials"].keys())[0])]

            # Bones
            arg_4["bones"]={"__root__":model.RootBone(arg_0,"__root__",{"start_rot":[0,0],"length":0})}
            for arg_1,arg_7 in arg_3.get("bones",{}).items():
                arg_8 = model.Bone(arg_0,arg_1,arg_7)
                arg_4["bones"][arg_1]=arg_8
            for arg_1,arg_9 in arg_4["bones"].items():
                if arg_1 == "__root__":
                    continue
                arg_9.setParent(arg_4["bones"][arg_9.bonedata["parent"]])

            # Regions
            arg_4["regions"]={}
            for arg_1,arg_10 in arg_3.get("regions",{}).items():
                arg_11 = model.Region(arg_0,arg_1,arg_10)
                arg_11.material = arg_4["materials"][arg_10.get("material",arg_4["default_material"])]
                arg_11.bone = arg_4["bones"][arg_10.get("bone","__root__")]
                arg_4["bones"][arg_10.get("bone","__root__")].addRegion(arg_11)
                arg_4["regions"][arg_1]=arg_11

            # Animations
            arg_4["animations"]={}
            arg_4["animations"]["static"]=model.Animation(arg_0,"static",{"type":"static","bones":{}})
            for arg_1,arg_13 in arg_3.get("animations",{}).items():
                arg_14 = model.Animation(arg_0,arg_1,arg_13)
                arg_14.setBones(arg_4["bones"])
                arg_4["animations"][arg_1]=arg_14
            arg_4["default_animation"]=arg_4["animations"][arg_3.get("default_animation",arg_4["animations"]["static"])]
        else:
            raise ValueError("Unknown version %s of model '%s'"%(arg_3.get("version",1),arg_1))

        arg_0.modelcache[arg_1]=arg_4
        return arg_4

Loads the model data of the given name . The model file must always be a . json file .


def
Func
(
arg_0
,
arg_1
,
arg_2
,
arg_3
=
0
)
:
arg_4
=
raw_input
(
"select %s: "
%
arg_2
)
assert
arg_4
,
"value required."
try
:
return
arg_1
[
int
(
arg_4
)
+
arg_3
]
except
ValueError
:
return
arg_4
except
IndexError
:
assert
False
,
"bad value."

def Func(arg_0, arg_1, arg_2, arg_3=0):
        """Given a list of values and names, accepts the index value or name."""

        arg_4 = raw_input("select %s: " % arg_2)
        assert arg_4, "value required."

        try:
            return arg_1[int(arg_4)+arg_3]
        except ValueError:
            return arg_4
        except IndexError:
            assert False, "bad value."

Given a list of values and names accepts the index value or name .


def Func ( arg_0 , arg_1 ) : arg_2 , arg_3 = arg_0 . component . bounds arg_0 . pos = tuple ( [ arg_1 [ 0 ] + ( arg_2 / 2 ) , arg_1 [ 1 ] + ( arg_3 / 2 ) ] )

def Func(arg_0, arg_1):
        """ Handles the poition of the component changing.
        """
        arg_2, arg_3 = arg_0.component.bounds
        arg_0.pos = tuple([ arg_1[0] + (arg_2/2), arg_1[1] + (arg_3/2) ])

Handles the poition of the component changing .


(script, sample_num=1000, radius=0.0,
                 montecarlo_rate=20, save_montecarlo=False,
                 approx_geodesic_dist=False, subsample=False, refine=False,
                 refine_layer=0, best_sample=True, best_sample_pool=10,
                 exact_num=False, radius_variance=1.0)

def Func(arg_0, arg_1=1000, arg_2=0.0,
                 arg_3=20, arg_4=False,
                 arg_5=False, arg_6=False, arg_7=False,
                 arg_8=0, arg_9=True, arg_10=10,
                 arg_11=False, arg_12=1.0):
    """ Create a new layer populated with a point sampling of the current mesh.

    Samples are generated according to a Poisson-disk distribution, using the
    algorithm described in:

    'Efficient and Flexible Sampling with Blue Noise Properties of Triangular Meshes'
    Massimiliano Corsini, Paolo Cignoni, Roberto Scopigno
    IEEE TVCG 2012

    Args:
        script: the FilterScript object or script filename to write
            the filter to.
        sample_num (int): The desired number of samples. The radius of the disk
            is calculated according to the sampling density.
        radius (float): If not zero this parameter overrides the previous
            parameter to allow exact radius specification.
        montecarlo_rate (int): The over-sampling rate that is used to generate
            the intial Monte Carlo samples (e.g. if this parameter is 'K' means
            that 'K * sample_num' points will be used). The generated
            Poisson-disk samples are a subset of these initial Monte Carlo
            samples. Larger numbers slow the process but make it a bit more
            accurate.
        save_montecarlo (bool): If True, it will generate an additional Layer
            with the Monte Carlo sampling that was pruned to build the Poisson
            distribution.
        approx_geodesic_dist (bool): If True Poisson-disk distances are
            computed using an approximate geodesic distance, e.g. an Euclidean
            distance weighted by a function of the difference between the
            normals of the two points.
        subsample (bool): If True the original vertices of the base mesh are
            used as base set of points. In this case the sample_num should be
            obviously much smaller than the original vertex number. Note that
            this option is very useful in the case you want to subsample a
            dense point cloud.
        refine (bool): If True the vertices of the refine_layer mesh layer are
            used as starting vertices, and they will be utterly refined by
            adding more and more points until possible.
        refine_layer (int): Used only if refine is True.
        best_sample (bool): If True it will use a simple heuristic for choosing
            the samples. At a small cost (it can slow the process a bit) it
            usually improves the maximality of the generated sampling.
        best_sample_pool (bool): Used only if best_sample is True. It controls
            the number of attempts that it makes to get the best sample. It is
            reasonable that it is smaller than the Monte Carlo oversampling
            factor.
        exact_num (bool): If True it will try to do a dicotomic search for the
            best Poisson-disk radius that will generate the requested number of
            samples with a tolerance of the 0.5%. Obviously it takes much
            longer.
        radius_variance (float): The radius of the disk is allowed to vary
            between r and r*var. If this parameter is 1 the sampling is the
            same as the Poisson-disk Sampling.

    Layer stack:
        Creates new layer 'Poisson-disk Samples'. Current layer is NOT changed
            to the new layer (see Bugs).
        If save_montecarlo is True, creates a new layer 'Montecarlo Samples'.
            Current layer is NOT changed to the new layer (see Bugs).

    MeshLab versions:
        2016.12
        1.3.4BETA

    Bugs:
        Current layer is NOT changed to the new layer, which is inconsistent
            with the majority of filters that create new layers.
    """
    arg_13 = ''.join([
        '  <filter name="Poisson-disk Sampling">\n',
        '    <Param name="SampleNum" ',
        'value="{:d}" '.format(arg_1),
        'description="Number of samples" ',
        'type="RichInt" ',
        '/>\n',
        '    <Param name="Radius" ',
        'value="{}" '.format(arg_2),
        'description="Explicit Radius" ',
        'min="0" ',
        'max="100" ',
        'type="RichAbsPerc" ',
        '/>\n',
        '    <Param name="MontecarloRate" ',
        'value="{:d}" '.format(arg_3),
        'description="MonterCarlo OverSampling" ',
        'type="RichInt" ',
        '/>\n',
        '    <Param name="SaveMontecarlo" ',
        'value="{}" '.format(str(arg_4).lower()),
        'description="Save Montecarlo" ',
        'type="RichBool" ',
        '/>\n',
        '    <Param name="ApproximateGeodesicDistance" ',
        'value="{}" '.format(str(arg_5).lower()),
        'description="Approximate Geodesic Distance" ',
        'type="RichBool" ',
        '/>\n',
        '    <Param name="Subsample" ',
        'value="{}" '.format(str(arg_6).lower()),
        'description="Base Mesh Subsampling" ',
        'type="RichBool" ',
        '/>\n',
        '    <Param name="RefineFlag" ',
        'value="{}" '.format(str(arg_7).lower()),
        'description="Refine Existing Samples" ',
        'type="RichBool" ',
        '/>\n',
        '    <Param name="RefineMesh" ',
        'value="{:d}" '.format(arg_8),
        'description="Samples to be refined" ',
        'type="RichMesh" ',
        '/>\n',
        '    <Param name="BestSampleFlag" ',
        'value="{}" '.format(str(arg_9).lower()),
        'description="Best Sample Heuristic" ',
        'type="RichBool" ',
        '/>\n',
        '    <Param name="BestSamplePool" ',
        'value="{:d}" '.format(arg_10),
        'description="Best Sample Pool Size" ',
        'type="RichInt" ',
        '/>\n',
        '    <Param name="ExactNumFlag" ',
        'value="{}" '.format(str(arg_11).lower()),
        'description="Exact number of samples" ',
        'type="RichBool" ',
        '/>\n',
        '    <Param name="RadiusVariance" ',
        'value="{}" '.format(arg_12),
        'description="Radius Variance" ',
        'type="RichFloat" ',
        '/>\n',
        '  </filter>\n'])
    util.write_filter(arg_0, arg_13)
    if isinstance(arg_0, FilterScript):
        arg_0.add_layer('Poisson-disk Samples')
        if arg_4:
            arg_0.add_layer('Montecarlo Samples')
    return None

Create a new layer populated with a point sampling of the current mesh .


def Func():
    """DeepPavlov console configuration utility."""
    arg_0 = parser.parse_args()
    arg_1 = get_settings_path()

    if arg_0.default:
        if populate_settings_dir(force=True):
            print(f'Populated {path} with default settings files')
        else:
            print(f'{path} is already a default settings directory')
    else:
        print(f'Current DeepPavlov settings path: {path}')

DeepPavlov console configuration utility .


def
Func
(
arg_0
)
:
@
wraps
(
arg_0
)
def
decorated
(
arg_1
,
arg_2
,
*
arg_3
)
:
if
not
isinstance
(
arg_2
,
str
)
:
arg_4
=
"%s: key must be a string"
%
arg_1
.
__class__
.
__name__
raise
ValueError
(
arg_4
)
if
not
arg_2
.
startswith
(
arg_1
.
prefix
)
:
arg_2
=
arg_1
.
prefix
+
arg_2
return
arg_0
(
arg_1
,
arg_2
,
*
arg_3
)
return
decorated

def Func(arg_0):
    """
    Raise error for keys that are not strings
    and add the prefix if it is missing
    """

    @wraps(arg_0)
    def decorated(arg_1, arg_2, *arg_3):
        if not isinstance(arg_2, str):
            arg_4 = "%s: key must be a string" % arg_1.__class__.__name__
            raise ValueError(arg_4)

        if not arg_2.startswith(arg_1.prefix):
            arg_2 = arg_1.prefix + arg_2

        return arg_0(arg_1, arg_2, *arg_3)

    return decorated


def Func(arg_0):
        """Class property that returns a populated template string

        This property allows the template of a particular process to be
        dynamically generated and returned when doing ``Process.Func``.

        Returns
        -------
        x : str
            String with the complete and populated process template

        """

        if not arg_0._context:
            raise eh.ProcessError("Channels must be setup first using the "
                                  "set_channels method")

        logger.debug("Setting context for template {}: {}".format(
            arg_0.template, arg_0._context
        ))

        arg_1 = arg_0.render(arg_0._template_path, arg_0._context)
        return arg_1

Class property that returns a populated template string

        This property allows the template of a particular process to be
        dynamically generated and returned when doing ``Process.template_str``.

        Returns
        -------
        x : str
            String with the complete and populated process template


def Func ( arg_0 , arg_1 ) : for arg_2 , arg_3 in arg_0 . channels . items ( ) : arg_4 = arg_0 . bodies [ arg_2 ] arg_4 . position = arg_0 . positions [ arg_1 , arg_3 ] arg_4 . linear_velocity = arg_0 . velocities [ arg_1 , arg_3 ]

def Func(arg_0, arg_1):
        '''Reposition markers to a specific frame of data.

        Parameters
        ----------
        frame_no : int
            The frame of data where we should Func marker bodies. Markers
            will be positioned in the appropriate places in world coordinates.
            In addition, linear velocities of the markers will be set according
            to the data as long as there are no dropouts in neighboring frames.
        '''
        for arg_2, arg_3 in arg_0.channels.items():
            arg_4 = arg_0.bodies[arg_2]
            arg_4.position = arg_0.positions[arg_1, arg_3]
            arg_4.linear_velocity = arg_0.velocities[arg_1, arg_3]

Reposition markers to a specific frame of data.

        Parameters
        ----------
        frame_no : int
            The frame of data where we should reposition marker bodies. Markers
            will be positioned in the appropriate places in world coordinates.
            In addition, linear velocities of the markers will be set according
            to the data as long as there are no dropouts in neighboring frames.

Reposition markers to a specific frame of data .


def Func ( ) : import pkg_resources from dojson . contrib . marc21 import marc21 from dojson . contrib . marc21 . utils import create_record , split_blob from flask_login import login_user , logout_user from invenio_accounts . models import User from invenio_deposit . api import Deposit arg_0 = User . query . all ( ) arg_1 = pkg_resources . resource_filename ( 'invenio_Func' , 'data/marc21/bibliographic.xml' ) with open ( arg_1 ) as source : with current_app . test_request_context ( ) : arg_2 = RecordIndexer ( ) with db . session . begin_nested ( ) : for arg_3 , arg_4 in enumerate ( split_blob ( source . read ( ) ) , start = 1 ) : login_user ( arg_0 [ arg_3 % len ( arg_0 ) ] ) arg_5 = marc21 . do ( create_record ( arg_4 ) ) arg_2 . index ( Deposit . create ( arg_5 ) ) logout_user ( ) db . session . commit ( )

def Func():
    """Load Func."""
    import pkg_resources
    from dojson.contrib.marc21 import marc21
    from dojson.contrib.marc21.utils import create_record, split_blob
    from flask_login import login_user, logout_user
    from invenio_accounts.models import User
    from invenio_deposit.api import Deposit

    arg_0 = User.query.all()

    # pkg resources the demodata
    arg_1 = pkg_resources.resource_filename(
        'invenio_Func', 'data/marc21/bibliographic.xml'
    )
    with open(arg_1) as source:
        with current_app.test_request_context():
            arg_2 = RecordIndexer()
            with db.session.begin_nested():
                for arg_3, arg_4 in enumerate(split_blob(source.read()),
                                             start=1):
                    login_user(arg_0[arg_3 % len(arg_0)])
                    # do translate
                    arg_5 = marc21.do(create_record(arg_4))
                    # create record
                    arg_2.index(Deposit.create(arg_5))
                    logout_user()
            db.session.commit()


def
Func
(
arg_0
)
:
if
arg_0
.
custom_interrupt
:
arg_0
.
_reading
=
False
arg_0
.
custom_interrupt_requested
.
emit
(
)
elif
arg_0
.
kernel_manager
.
has_kernel
:
arg_0
.
_reading
=
False
arg_0
.
kernel_manager
.
Func
(
)
else
:
arg_0
.
_append_plain_text
(
'Kernel process is either remote or '
'unspecified. Cannot interrupt.\n'
)

def Func(arg_0):
        """ Attempts to interrupt the running kernel.

        Also unsets _reading flag, to avoid runtime errors
        if raw_input is called again.
        """
        if arg_0.custom_interrupt:
            arg_0._reading = False
            arg_0.custom_interrupt_requested.emit()
        elif arg_0.kernel_manager.has_kernel:
            arg_0._reading = False
            arg_0.kernel_manager.Func()
        else:
            arg_0._append_plain_text('Kernel process is either remote or '
                                    'unspecified. Cannot interrupt.\n')

Attempts to interrupt the running kernel . Also unsets _reading flag to avoid runtime errors if raw_input is called again .


def
Func
(
arg_0
,
arg_1
)
:
arg_0
.
id
=
int
(
arg_1
.
get
(
'id'
)
)
arg_0
.
user
=
arg_1
.
get
(
'user'
)
arg_0
.
uid
=
arg_1
.
get
(
'uid'
)
arg_0
.
editor
=
arg_1
.
get
(
'created_by'
,
)
arg_0
.
review_requested
=
arg_1
.
get
(
'review_requested'
,
False
)
arg_0
.
host
=
arg_1
.
get
(
'host'
,
'Not reported'
)
arg_0
.
bbox
=
arg_1
.
get
(
'bbox'
)
.
wkt
arg_0
.
comment
=
arg_1
.
get
(
'comment'
,
'Not reported'
)
arg_0
.
source
=
arg_1
.
get
(
'source'
,
'Not reported'
)
arg_0
.
imagery_used
=
arg_1
.
get
(
'imagery_used'
,
'Not reported'
)
arg_0
.
date
=
datetime
.
strptime
(
arg_1
.
get
(
'created_at'
)
,
'%Y-%m-%dT%H:%M:%SZ'
)
arg_0
.
suspicion_reasons
=
[
]
arg_0
.
is_suspect
=
False
arg_0
.
powerfull_editor
=
False

def Func(arg_0, arg_1):
        """Set the fields of this class with the metadata of the analysed
        changeset.
        """
        arg_0.id = int(arg_1.get('id'))
        arg_0.user = arg_1.get('user')
        arg_0.uid = arg_1.get('uid')
        arg_0.editor = arg_1.get('created_by', None)
        arg_0.review_requested = arg_1.get('review_requested', False)
        arg_0.host = arg_1.get('host', 'Not reported')
        arg_0.bbox = arg_1.get('bbox').wkt
        arg_0.comment = arg_1.get('comment', 'Not reported')
        arg_0.source = arg_1.get('source', 'Not reported')
        arg_0.imagery_used = arg_1.get('imagery_used', 'Not reported')
        arg_0.date = datetime.strptime(
            arg_1.get('created_at'),
            '%Y-%m-%dT%H:%M:%SZ'
            )
        arg_0.suspicion_reasons = []
        arg_0.is_suspect = False
        arg_0.powerfull_editor = False

Set the fields of this class with the metadata of the analysed changeset .


def
Func
(
arg_0
)
:
if
not
os
.
path
.
exists
(
arg_0
)
:
raise
ValueError
(
"Error: %s file not found"
%
arg_0
)
arg_1
=
pd
.
read_excel
(
arg_0
,
sheetname
=
0
,
header
=
0
)
arg_1
.
iloc
[
:
,
0
]
=
pd
.
Series
(
arg_1
.
iloc
[
:
,
0
]
)
.
fillna
(
method
=
'ffill'
)
arg_1
=
arg_1
[
arg_1
.
ix
[
:
,
1
]
.
notnull
(
)
]
arg_1
=
arg_1
.
reset_index
(
drop
=
True
)
arg_1
.
ix
[
:
,
2
]
.
fillna
(
0
,
inplace
=
True
)
if
(
arg_1
.
ix
[
:
,
1
]
.
isnull
(
)
.
sum
(
)
)
!=
0
:
raise
ValueError
(
"Error: Empty cells in the gene column"
)
return
arg_1

def Func(arg_0):
    """Preprocess the excel sheet

    :param filepath: filepath of the excel data
    :return: df: pandas dataframe with excel data
    :rtype: pandas.DataFrame
    """
    if not os.path.exists(arg_0):
        raise ValueError("Error: %s file not found" % arg_0)

    # Import Models from Excel sheet, independent for AD and PD
    arg_1 = pd.read_excel(arg_0, sheetname=0, header=0)

    # Indexes and column name
    # [log.info(str(x)+': '+str((df.columns.values[x]))) for x in range (0,len(df.columns.values))]

    # Starting from 4: Pathway Name

    # Fill Pathway cells that are merged and are 'NaN' after deleting rows where there is no genes
    arg_1.iloc[:, 0] = pd.Series(arg_1.iloc[:, 0]).fillna(method='ffill')

    # Number of gaps
    # log.info(df.ix[:,6].isnull().sum())

    arg_1 = arg_1[arg_1.ix[:, 1].notnull()]
    arg_1 = arg_1.reset_index(drop=True)

    # Fill NaN to ceros in PubmedID column
    arg_1.ix[:, 2].fillna(0, inplace=True)

    # Number of gaps in the gene column should be already zero
    if (arg_1.ix[:, 1].isnull().sum()) != 0:
        raise ValueError("Error: Empty cells in the gene column")

    # Check current state
    # df.to_csv('out.csv')

    return arg_1


return int(re.findall(r"dev: ([0-9a-fx]+)", stdout)[0], 16)

def
Func
(
arg_0
,
arg_1
)
:
arg_2
=
[
"nvm_addr gen2dev"
,
arg_0
.
envs
[
"DEV_PATH"
]
,
"0x{:x}"
.
format
(
arg_1
)
]
arg_3
,
arg_4
,
arg_5
=
cij
.
ssh
.
command
(
arg_2
,
shell
=
True
)
if
arg_3
:
raise
RuntimeError
(
"cij.liblight.Func: cmd fail"
)
return
int
(
re
.
findall
(
r"dev: ([0-9a-fx]+)"
,
arg_4
)
[
0
]
,
16
)

def Func(arg_0, arg_1):
        """Generic address to device address"""
        arg_2 = ["nvm_addr gen2dev", arg_0.envs["DEV_PATH"], "0x{:x}".format(arg_1)]
        arg_3, arg_4, arg_5 = cij.ssh.command(arg_2, shell=True)
        if arg_3:
            raise RuntimeError("cij.liblight.Func: cmd fail")

        return int(re.findall(r"dev: ([0-9a-fx]+)", arg_4)[0], 16)


def Func(arg_0, arg_1, arg_2, arg_3):
    """Majority gate."""
    arg_0.cx(arg_3, arg_2)
    arg_0.cx(arg_3, arg_1)
    arg_0.ccx(arg_1, arg_2, arg_3)


def Func(arg_0, arg_1, arg_2):
        r'''Method to Func low-pressure liquid thermal conductivity at
        tempearture `T` with a given method.

        This method has no exception handling; see `T_dependent_property`
        for that.

        Parameters
        ----------
        T : float
            Temperature of the liquid, [K]
        method : str
            Name of the method to use

        Returns
        -------
        kl : float
            Thermal conductivity of the liquid at T and a low pressure, [W/m/K]
        '''
        if arg_2 == SHEFFY_JOHNSON:
            arg_3 = Sheffy_Johnson(arg_1, arg_0.MW, arg_0.Tm)
        elif arg_2 == SATO_RIEDEL:
            arg_3 = Sato_Riedel(arg_1, arg_0.MW, arg_0.Tb, arg_0.Tc)
        elif arg_2 == GHARAGHEIZI_L:
            arg_3 = Gharagheizi_liquid(arg_1, arg_0.MW, arg_0.Tb, arg_0.Pc, arg_0.omega)
        elif arg_2 == NICOLA:
            arg_3 = Nicola(arg_1, arg_0.MW, arg_0.Tc, arg_0.Pc, arg_0.omega)
        elif arg_2 == NICOLA_ORIGINAL:
            arg_3 = Nicola_original(arg_1, arg_0.MW, arg_0.Tc, arg_0.omega, arg_0.Hfus)
        elif arg_2 == LAKSHMI_PRASAD:
            arg_3 = Lakshmi_Prasad(arg_1, arg_0.MW)
        elif arg_2 == BAHADORI_L:
            arg_3 = Bahadori_liquid(arg_1, arg_0.MW)
        elif arg_2 == DIPPR_PERRY_8E:
            arg_3 = EQ100(arg_1, *arg_0.Perrys2_315_coeffs)
        elif arg_2 == VDI_PPDS:
            arg_3 = horner(arg_0.VDI_PPDS_coeffs, arg_1)
        elif arg_2 == COOLPROP:
            arg_3 = CoolProp_T_dependent_property(arg_1, arg_0.CASRN, 'L', 'l')
        elif arg_2 in arg_0.tabular_data:
            arg_3 = arg_0.interpolate(arg_1, arg_2)
        return arg_3

r'''Method to calculate low-pressure liquid thermal conductivity at
        tempearture `T` with a given method.

        This method has no exception handling; see `T_dependent_property`
        for that.

        Parameters
        ----------
        T : float
            Temperature of the liquid, [K]
        method : str
            Name of the method to use

        Returns
        -------
        kl : float
            Thermal conductivity of the liquid at T and a low pressure, [W/m/K]

r Method to calculate low - pressure liquid thermal conductivity at tempearture T with a given method .


def Func ( arg_0 ) : arg_1 = "." if arg_0 . sample_tag_values : arg_2 = list ( arg_0 . sample_tag_values . keys ( ) ) [ 0 ] arg_3 = arg_0 . sample_tag_values [ arg_2 ] . keys ( ) if arg_3 : arg_1 = ":" . join ( arg_3 ) return arg_1

def Func(arg_0):
        """Returns string representation of format field."""
        arg_1 = "."
        if arg_0.sample_tag_values:
            arg_2 = list(arg_0.sample_tag_values.keys())[0]
            arg_3 = arg_0.sample_tag_values[arg_2].keys()
            if arg_3:
                arg_1 = ":".join(arg_3)
        return arg_1

Returns string representation of format field .


def Func(arg_0, arg_1):
    """Set topology-wide configuration to the topology

    :type config: dict
    :param config: topology-wide config
    """
    if not isinstance(arg_1, dict):
      raise TypeError("Argument to Func needs to be dict, given: %s" % str(arg_1))
    arg_0._topology_config = arg_1

Set topology - wide configuration to the topology


(self,
                      file_obj,
                      key,
                      bucket_name=None,
                      replace=False,
                      encrypt=False)

def
Func
(
arg_0
,
arg_1
,
arg_2
,
arg_3
=
,
arg_4
=
False
,
arg_5
=
False
)
:
if
not
arg_3
:
(
arg_3
,
arg_2
)
=
arg_0
.
parse_s3_url
(
arg_2
)
if
not
arg_4
and
arg_0
.
check_for_key
(
arg_2
,
arg_3
)
:
raise
ValueError
(
"The key {key} already exists."
.
format
(
arg_2
=
arg_2
)
)
arg_6
=
{
}
if
arg_5
:
arg_6
[
'ServerSideEncryption'
]
=
"AES256"
arg_7
=
arg_0
.
get_conn
(
)
arg_7
.
upload_fileobj
(
arg_1
,
arg_3
,
arg_2
,
ExtraArgs
=
arg_6
)

def Func(arg_0,
                      arg_1,
                      arg_2,
                      arg_3=None,
                      arg_4=False,
                      arg_5=False):
        """
        Loads a file object to S3

        :param file_obj: The file-like object to set as the content for the S3 key.
        :type file_obj: file-like object
        :param key: S3 key that will point to the file
        :type key: str
        :param bucket_name: Name of the bucket in which to store the file
        :type bucket_name: str
        :param replace: A flag that indicates whether to overwrite the key
            if it already exists.
        :type replace: bool
        :param encrypt: If True, S3 encrypts the file on the server,
            and the file is stored in encrypted form at rest in S3.
        :type encrypt: bool
        """
        if not arg_3:
            (arg_3, arg_2) = arg_0.parse_s3_url(arg_2)

        if not arg_4 and arg_0.check_for_key(arg_2, arg_3):
            raise ValueError("The key {key} already exists.".format(arg_2=arg_2))

        arg_6 = {}
        if arg_5:
            arg_6['ServerSideEncryption'] = "AES256"

        arg_7 = arg_0.get_conn()
        arg_7.upload_fileobj(arg_1, arg_3, arg_2, ExtraArgs=arg_6)


def Func(arg_0):
    """
    Prompts user before proceeding
    """
    click.echo()
    if click.Func('Do you want to create the tag {tag}?'.format(
            arg_0=click.style(str(arg_0), fg='yellow')),
        default=True, abort=True):
        git.create_tag(arg_0)

    if click.Func(
        'Do you want to push the tag {tag} into the upstream?'.format(
            arg_0=click.style(str(arg_0), fg='yellow')),
        default=True):
        git.push_tag(arg_0)
        click.echo('Done!')
    else:
        git.delete_tag(arg_0)
        click.echo('Aborted!')


return self.sys_sigaction(signum, act, oldact)

def Func(arg_0, arg_1, arg_2, arg_3):
        """Wrapper for sys_sigaction"""
        return arg_0.sys_sigaction(arg_1, arg_2, arg_3)


return self._stat(axis, func=add, keepdims=keepdims)

def Func ( arg_0 , arg_1 = None , arg_2 = False ) : from operator import add return arg_0 . _stat ( arg_1 , func = add , arg_2 = arg_2 )

def Func(arg_0, arg_1=None, arg_2=False):
        """
        Return the Func of the array over the given axis.

        Parameters
        ----------
        axis : tuple or int, optional, default=None
            Axis to compute statistic over, if None
            will compute over all axes

        keepdims : boolean, optional, default=False
            Keep axis remaining after operation with size 1.
        """
        from operator import add
        return arg_0._stat(arg_1, func=add, arg_2=arg_2)

Return the sum of the array over the given axis.

        Parameters
        ----------
        axis : tuple or int, optional, default=None
            Axis to compute statistic over, if None
            will compute over all axes

        keepdims : boolean, optional, default=False
            Keep axis remaining after operation with size 1.

Return the sum of the array over the given axis .


def Func ( arg_0 ) : arg_1 = [ ] for arg_2 , arg_3 in arg_0 . get_widgets ( ) . items ( ) : arg_1 . append ( ( arg_2 , arg_3 , arg_3 . position ) ) arg_1 . sort ( key = lambda x : x [ 2 ] ) return arg_1

def Func(arg_0):
        """Returns the widgets sorted by position."""
        arg_1 = []
        for arg_2, arg_3 in arg_0.get_widgets().items():
            arg_1.append((arg_2, arg_3, arg_3.position))
        arg_1.sort(key=lambda x: x[2])
        return arg_1

Returns the widgets sorted by position .


def Func(arg_0, arg_1):
        '''
        Helpful function to evaluate Cauchy equations.

        Args:
            wavelength (float, list, None): The wavelength(s) the
                Cauchy equation will be evaluated at.
            coefficients (list): A list of the coefficients of
                the Cauchy equation.

        Returns:
            float, list: The refractive index at the target wavelength(s).
        '''
        arg_2 = 0.
        for arg_3, arg_4 in enumerate(arg_1):
            arg_5  = 2*arg_3
            arg_2 += arg_4 / arg_0**arg_5
        return arg_2

Helpful function to evaluate Cauchy equations .


def Func(arg_0, arg_1):
        '''
        Update the current checklist. Returns a new Checklist object.
        '''
        arg_2 = arg_0.fetch_json(
            uri_path=arg_0.base_uri,
            http_method='PUT',
            query_params={'name': arg_1}
        )

        return arg_0.create_checklist(arg_2)

Update the current checklist . Returns a new Checklist object .


(ip_address, cache=None, nameservers=None, timeout=2.0)

def Func ( arg_0 , arg_1 = None , arg_2 = None , arg_3 = 2.0 ) : arg_4 = None try : arg_5 = dns . reversename . from_address ( arg_0 ) arg_4 = query_dns ( arg_5 , "PTR" , arg_1 = arg_1 , arg_2 = arg_2 , arg_3 = arg_3 ) [ 0 ] except dns . exception . DNSException : pass return arg_4

def Func(arg_0, arg_1=None, arg_2=None, arg_3=2.0):
    """
    Resolves an IP address to a hostname using a reverse DNS query

    Args:
        ip_address (str): The IP address to resolve
        cache (ExpiringDict): Cache storage
        nameservers (list): A list of one or more nameservers to use
        (Cloudflare's public DNS resolvers by default)
        timeout (float): Sets the DNS query timeout in seconds

    Returns:
        str: The reverse DNS hostname (if any)
    """
    arg_4 = None
    try:
        arg_5 = dns.reversename.from_address(arg_0)
        arg_4 = query_dns(arg_5, "PTR", arg_1=arg_1,
                             arg_2=arg_2,
                             arg_3=arg_3)[0]

    except dns.exception.DNSException:
        pass

    return arg_4


return ((ext.name, ext.plugin) for ext in emgr)

def Func ( arg_0 ) : arg_1 = extension . ExtensionManager ( PLUGIN_EP , invoke_on_load = False ) return ( ( arg_2 . name , arg_2 . plugin ) for arg_2 in arg_1 )

def Func(arg_0):
        """Looks for modules with amtching entry points."""
        arg_1 = extension.ExtensionManager(PLUGIN_EP, invoke_on_load=False)
        return ((arg_2.name, arg_2.plugin) for arg_2 in arg_1)

Looks for modules with amtching entry points .


def Func(arg_0):
  """Helper function for statically evaluating predicates in `cond`."""
  if arg_0 in {0, 1}:  # Accept 1/0 as valid boolean values
    arg_1 = bool(arg_0)
  elif isinstance(arg_0, bool):
    arg_1 = arg_0
  elif isinstance(arg_0, tf.Tensor):
    arg_1 = tf.get_static_value(arg_0)

    # TODO(jamieas): remove the dependency on `pywrap_tensorflow`.
    # pylint: disable=protected-access
    if arg_1 is None:
      arg_1 = c_api.TF_TryEvaluateConstant_wrapper(arg_0.graph._c_graph,
                                                        arg_0._as_tf_output())
    # pylint: enable=protected-access

  else:
    raise TypeError('`pred` must be a Tensor, or a Python bool, or 1 or 0. '
                    'Found instead: {}'.format(arg_0))
  return arg_1

Helper function for statically evaluating predicates in cond .


def Func(arg_0):
    r"""Blackman Nuttall window

    returns a minimum, 4-term Blackman-Harris window. The window is minimum in the sense that its maximum sidelobes are minimized.
    The coefficients for this window differ from the Blackman-Harris window coefficients and produce slightly lower sidelobes.

    :param N: window length

    .. math:: w(n) = a_0 - a_1 \cos\left(\frac{2\pi n}{N-1}\right)+ a_2 \cos\left(\frac{4\pi n}{N-1}\right)- a_3 \cos\left(\frac{6\pi n}{N-1}\right)

    with :math:`a_0 = 0.3635819`, :math:`a_1 = 0.4891775`, :math:`a_2=0.1365995` and :math:`0_3=.0106411`

    .. plot::
        :width: 80%
        :include-source:

        from spectrum import window_visu
        window_visu(64, 'blackman_nuttall', mindB=-80)

    .. seealso:: :func:`spectrum.window.create_window`
    .. seealso:: :func:`create_window`, :class:`Window`

    """
    arg_1 = 0.3635819
    arg_2 = 0.4891775
    arg_3 = 0.1365995
    arg_4 = 0.0106411
    return _coeff4(arg_0, arg_1, arg_2, arg_3, arg_4)


def Func ( arg_0 ) : with db . session . begin_nested ( ) : if arg_0 . status != RequestStatus . EMAIL_VALIDATION : raise InvalidRequestStateError ( RequestStatus . EMAIL_VALIDATION ) arg_0 . status = RequestStatus . PENDING request_confirmed . send ( arg_0 )

def Func(arg_0):
        """Confirm that senders email is valid."""
        with db.session.begin_nested():
            if arg_0.status != RequestStatus.EMAIL_VALIDATION:
                raise InvalidRequestStateError(RequestStatus.EMAIL_VALIDATION)

            arg_0.status = RequestStatus.PENDING
        request_confirmed.send(arg_0)


return os.path.isdir(path) and os.access(path, os.W_OK)

def Func ( arg_0 ) : return os . path . isdir ( arg_0 ) and os . access ( arg_0 , os . W_OK )

def Func(arg_0):
    """Whether `path` is a directory, to which the user has write access."""
    return os.path.isdir(arg_0) and os.access(arg_0, os.W_OK)

Whether path is a directory to which the user has write access .


return linop.matmul(linop.matmul(cov), adjoint_arg=True) + dist.covariance()

def Func ( arg_0 , arg_1 , arg_2 ) : return arg_1 . matmul ( arg_1 . matmul ( arg_0 ) , adjoint_arg = True ) + arg_2 . covariance ( )

def Func(arg_0, arg_1, arg_2):
  """Propagate covariance through linear Gaussian transformation."""
  # For linop A and input cov P, returns `A P A' + dist.cov()`
  return arg_1.matmul(arg_1.matmul(arg_0), adjoint_arg=True) + arg_2.covariance()

Propagate covariance through linear Gaussian transformation .


def Func ( arg_0 , arg_1 ) : arg_2 = { 'SearchText' : arg_1 } arg_3 = arg_0 . __get ( '/storefindermap/storesearch' , arg_2 = arg_2 ) return Stores ( arg_3 . json ( ) )

def Func(arg_0, arg_1):
        '''
        Search for dominos pizza stores using a search term.

        :param string search: Search term.
        :return: A list of nearby stores matching the search term.
        :rtype: list
        '''
        arg_2 = {'SearchText': arg_1}
        arg_3 = arg_0.__get('/storefindermap/storesearch', arg_2=arg_2)

        return Stores(arg_3.json())

Search for dominos pizza stores using a search term .


def Func(arg_0, arg_1=arg_2.stdout):
        """Report analysis outcome in human readable form."""
        arg_4 = arg_0.results['max_perf']

        if arg_0._args and arg_0._args.verbose >= 3:
            print('{}'.format(pformat(arg_0.results)), file=arg_1)

        if arg_0._args and arg_0._args.verbose >= 1:
            print('{}'.format(pformat(arg_0.results['verbose infos'])), file=arg_1)
            print('Bottlenecks:', file=arg_1)
            print('  level | a. intensity |   performance   |   peak bandwidth  | peak bandwidth kernel',
                  file=arg_1)
            print('--------+--------------+-----------------+-------------------+----------------------',
                  file=arg_1)
            print('    CPU |              | {!s:>15} |                   |'.format(
                arg_4[arg_0._args.unit]),
                  file=arg_1)
            for arg_5 in arg_0.results['mem bottlenecks']:
                print('{level:>7} | {arithmetic intensity:>5.2} FLOP/B | {0!s:>15} |'
                      ' {bandwidth!s:>17} | {bw kernel:<8}'.format(
                          arg_5['performance'][arg_0._args.unit], **arg_5),
                      file=arg_1)
            print('', file=arg_1)

        if arg_0.results['min performance']['FLOP/s'] > arg_4['FLOP/s']:
            # CPU bound
            print('CPU bound. {!s} due to CPU max. FLOP/s'.format(arg_4), file=arg_1)
        else:
            # Cache or mem bound
            print('Cache or mem bound.', file=arg_1)

            arg_6 = arg_0.results['mem bottlenecks'][arg_0.results['bottleneck level']]
            print('{!s} due to {} transfer bottleneck (with bw from {} benchmark)'.format(
                    arg_6['performance'][arg_0._args.unit],
                    arg_6['level'],
                    arg_6['bw kernel']),
                  file=arg_1)
            print('Arithmetic Intensity: {:.2f} FLOP/B'.format(arg_6['arithmetic intensity']),
                  file=arg_1)

Report analysis outcome in human readable form .


def Func ( ) : if args . hls_live_edge : streamlink . set_option ( "hls-live-edge" , args . hls_live_edge ) if args . hls_segment_attempts : streamlink . set_option ( "hls-segment-attempts" , args . hls_segment_attempts ) if args . hls_playlist_reload_attempts : streamlink . set_option ( "hls-playlist-reload-attempts" , args . hls_playlist_reload_attempts ) if args . hls_segment_threads : streamlink . set_option ( "hls-segment-threads" , args . hls_segment_threads ) if args . hls_segment_timeout : streamlink . set_option ( "hls-segment-timeout" , args . hls_segment_timeout ) if args . hls_segment_ignore_names : streamlink . set_option ( "hls-segment-ignore-names" , args . hls_segment_ignore_names ) if args . hls_segment_key_uri : streamlink . set_option ( "hls-segment-key-uri" , args . hls_segment_key_uri ) if args . hls_timeout : streamlink . set_option ( "hls-timeout" , args . hls_timeout ) if args . hls_audio_select : streamlink . set_option ( "hls-audio-select" , args . hls_audio_select ) if args . hls_start_offset : streamlink . set_option ( "hls-start-offset" , args . hls_start_offset ) if args . hls_duration : streamlink . set_option ( "hls-duration" , args . hls_duration ) if args . hls_live_restart : streamlink . set_option ( "hls-live-restart" , args . hls_live_restart ) if args . hds_live_edge : streamlink . set_option ( "hds-live-edge" , args . hds_live_edge ) if args . hds_segment_attempts : streamlink . set_option ( "hds-segment-attempts" , args . hds_segment_attempts ) if args . hds_segment_threads : streamlink . set_option ( "hds-segment-threads" , args . hds_segment_threads ) if args . hds_segment_timeout : streamlink . set_option ( "hds-segment-timeout" , args . hds_segment_timeout ) if args . hds_timeout : streamlink . set_option ( "hds-timeout" , args . hds_timeout ) if args . http_stream_timeout : streamlink . set_option ( "http-stream-timeout" , args . http_stream_timeout ) if args . ringbuffer_size : streamlink . set_option ( "ringbuffer-size" , args . ringbuffer_size ) if args . rtmp_proxy : streamlink . set_option ( "rtmp-proxy" , args . rtmp_proxy ) if args . rtmp_rtmpdump : streamlink . set_option ( "rtmp-rtmpdump" , args . rtmp_rtmpdump ) if args . rtmp_timeout : streamlink . set_option ( "rtmp-timeout" , args . rtmp_timeout ) if args . stream_segment_attempts : streamlink . set_option ( "stream-segment-attempts" , args . stream_segment_attempts ) if args . stream_segment_threads : streamlink . set_option ( "stream-segment-threads" , args . stream_segment_threads ) if args . stream_segment_timeout : streamlink . set_option ( "stream-segment-timeout" , args . stream_segment_timeout ) if args . stream_timeout : streamlink . set_option ( "stream-timeout" , args . stream_timeout ) if args . ffmpeg_ffmpeg : streamlink . set_option ( "ffmpeg-ffmpeg" , args . ffmpeg_ffmpeg ) if args . ffmpeg_verbose : streamlink . set_option ( "ffmpeg-verbose" , args . ffmpeg_verbose ) if args . ffmpeg_verbose_path : streamlink . set_option ( "ffmpeg-verbose-path" , args . ffmpeg_verbose_path ) if args . ffmpeg_video_transcode : streamlink . set_option ( "ffmpeg-video-transcode" , args . ffmpeg_video_transcode ) if args . ffmpeg_audio_transcode : streamlink . set_option ( "ffmpeg-audio-transcode" , args . ffmpeg_audio_transcode ) streamlink . set_option ( "subprocess-errorlog" , args . subprocess_errorlog ) streamlink . set_option ( "subprocess-errorlog-path" , args . subprocess_errorlog_path ) streamlink . set_option ( "locale" , args . locale )

def Func():
    """Sets Streamlink options."""
    if args.hls_live_edge:
        streamlink.set_option("hls-live-edge", args.hls_live_edge)

    if args.hls_segment_attempts:
        streamlink.set_option("hls-segment-attempts", args.hls_segment_attempts)

    if args.hls_playlist_reload_attempts:
        streamlink.set_option("hls-playlist-reload-attempts", args.hls_playlist_reload_attempts)

    if args.hls_segment_threads:
        streamlink.set_option("hls-segment-threads", args.hls_segment_threads)

    if args.hls_segment_timeout:
        streamlink.set_option("hls-segment-timeout", args.hls_segment_timeout)

    if args.hls_segment_ignore_names:
        streamlink.set_option("hls-segment-ignore-names", args.hls_segment_ignore_names)

    if args.hls_segment_key_uri:
        streamlink.set_option("hls-segment-key-uri", args.hls_segment_key_uri)

    if args.hls_timeout:
        streamlink.set_option("hls-timeout", args.hls_timeout)

    if args.hls_audio_select:
        streamlink.set_option("hls-audio-select", args.hls_audio_select)

    if args.hls_start_offset:
        streamlink.set_option("hls-start-offset", args.hls_start_offset)

    if args.hls_duration:
        streamlink.set_option("hls-duration", args.hls_duration)

    if args.hls_live_restart:
        streamlink.set_option("hls-live-restart", args.hls_live_restart)

    if args.hds_live_edge:
        streamlink.set_option("hds-live-edge", args.hds_live_edge)

    if args.hds_segment_attempts:
        streamlink.set_option("hds-segment-attempts", args.hds_segment_attempts)

    if args.hds_segment_threads:
        streamlink.set_option("hds-segment-threads", args.hds_segment_threads)

    if args.hds_segment_timeout:
        streamlink.set_option("hds-segment-timeout", args.hds_segment_timeout)

    if args.hds_timeout:
        streamlink.set_option("hds-timeout", args.hds_timeout)

    if args.http_stream_timeout:
        streamlink.set_option("http-stream-timeout", args.http_stream_timeout)

    if args.ringbuffer_size:
        streamlink.set_option("ringbuffer-size", args.ringbuffer_size)

    if args.rtmp_proxy:
        streamlink.set_option("rtmp-proxy", args.rtmp_proxy)

    if args.rtmp_rtmpdump:
        streamlink.set_option("rtmp-rtmpdump", args.rtmp_rtmpdump)

    if args.rtmp_timeout:
        streamlink.set_option("rtmp-timeout", args.rtmp_timeout)

    if args.stream_segment_attempts:
        streamlink.set_option("stream-segment-attempts", args.stream_segment_attempts)

    if args.stream_segment_threads:
        streamlink.set_option("stream-segment-threads", args.stream_segment_threads)

    if args.stream_segment_timeout:
        streamlink.set_option("stream-segment-timeout", args.stream_segment_timeout)

    if args.stream_timeout:
        streamlink.set_option("stream-timeout", args.stream_timeout)

    if args.ffmpeg_ffmpeg:
        streamlink.set_option("ffmpeg-ffmpeg", args.ffmpeg_ffmpeg)
    if args.ffmpeg_verbose:
        streamlink.set_option("ffmpeg-verbose", args.ffmpeg_verbose)
    if args.ffmpeg_verbose_path:
        streamlink.set_option("ffmpeg-verbose-path", args.ffmpeg_verbose_path)
    if args.ffmpeg_video_transcode:
        streamlink.set_option("ffmpeg-video-transcode", args.ffmpeg_video_transcode)
    if args.ffmpeg_audio_transcode:
        streamlink.set_option("ffmpeg-audio-transcode", args.ffmpeg_audio_transcode)

    streamlink.set_option("subprocess-errorlog", args.subprocess_errorlog)
    streamlink.set_option("subprocess-errorlog-path", args.subprocess_errorlog_path)
    streamlink.set_option("locale", args.locale)


def
Func
(
arg_0
,
arg_1
)
:
log
.
info
(
'Remove '
+
arg_1
)
arg_2
=
'file.remove("%s")'
%
arg_1
arg_3
=
arg_0
.
__exchange
(
arg_2
)
log
.
info
(
arg_3
)
return
arg_3

def Func(arg_0, arg_1):
        """Removes a file on the device"""
        log.info('Remove '+arg_1)
        arg_2 = 'file.remove("%s")' % arg_1
        arg_3 = arg_0.__exchange(arg_2)
        log.info(arg_3)
        return arg_3


def
Func
(
arg_0
,
arg_1
)
:
arg_1
.
write
(
'# Annotation\n\n'
)
write_value
(
'Annotator'
,
arg_0
.
annotator
,
arg_1
)
write_value
(
'AnnotationDate'
,
arg_0
.
annotation_date_iso_format
,
arg_1
)
if
arg_0
.
has_comment
:
write_text_value
(
'AnnotationComment'
,
arg_0
.
comment
,
arg_1
)
write_value
(
'AnnotationType'
,
arg_0
.
annotation_type
,
arg_1
)
write_value
(
'SPDXREF'
,
arg_0
.
spdx_id
,
arg_1
)

def Func(arg_0, arg_1):
    """
    Write the fields of a single annotation to out.
    """
    arg_1.write('# Annotation\n\n')
    write_value('Annotator', arg_0.annotator, arg_1)
    write_value('AnnotationDate', arg_0.annotation_date_iso_format, arg_1)
    if arg_0.has_comment:
        write_text_value('AnnotationComment', arg_0.comment, arg_1)
    write_value('AnnotationType', arg_0.annotation_type, arg_1)
    write_value('SPDXREF', arg_0.spdx_id, arg_1)

Write the fields of a single annotation to out .


def
Func
(
arg_0
)
:
while
arg_0
.
endswith
(
' '
)
and
not
arg_0
.
endswith
(
'\\ '
)
:
arg_0
=
arg_0
[
:
1
]
return
arg_0
.
replace
(
'\\ '
,
' '
)

def Func(arg_0):
        """Remove trailing spaces unless they are quoted with a backslash."""
        while arg_0.endswith(' ') and not arg_0.endswith('\\ '):
            arg_0 = arg_0[:-1]
        return arg_0.replace('\\ ', ' ')

Remove trailing spaces unless they are quoted with a backslash .


def
Func
(
arg_0
,
arg_1
)
:
from
.
invoice
import
InvoiceController
arg_2
=
InvoiceController
(
arg_1
)
arg_2
.
validate_allowed_to_pay
(
)
commerce
.
CreditNoteApplication
.
objects
.
create
(
parent
=
arg_0
.
credit_note
,
arg_1
=
arg_1
,
amount
=
arg_0
.
credit_note
.
value
,
reference
=
"Applied credit note #%d"
%
arg_0
.
credit_note
.
id
,
)
arg_2
.
update_status
(
)

def Func(arg_0, arg_1):
        ''' Applies the total value of this credit note to the specified
        invoice. If this credit note overpays the invoice, a new credit note
        containing the residual value will be created.

        Raises ValidationError if the given invoice is not allowed to be
        paid.
        '''

        # Local import to fix import cycles. Can we do better?
        from .invoice import InvoiceController
        arg_2 = InvoiceController(arg_1)
        arg_2.validate_allowed_to_pay()

        # Apply payment to invoice
        commerce.CreditNoteApplication.objects.create(
            parent=arg_0.credit_note,
            arg_1=arg_1,
            amount=arg_0.credit_note.value,
            reference="Applied credit note #%d" % arg_0.credit_note.id,
        )

        arg_2.update_status()

Applies the total value of this credit note to the specified invoice . If this credit note overpays the invoice a new credit note containing the residual value will be created .


return self.__class__(self.production, self.pos + 1, self.lookahead)

def Func ( arg_0 ) : return arg_0 . __class__ ( arg_0 . production , arg_0 . pos + 1 , arg_0 . lookahead )

def Func(arg_0):
        """Returns the DottedRule that results from moving the dot."""
        return arg_0.__class__(arg_0.production, arg_0.pos + 1, arg_0.lookahead)

Returns the DottedRule that results from moving the dot .


def Func ( arg_0 ) : if not hasattr ( arg_0 , '_versions' ) : try : arg_0 . _versions = [ arg_0 . send_apdu ( INS_GET_VERSION ) . decode ( ) ] except exc . APDUError as e : arg_0 . _versions = [ 'v0' ] if e . code == 0x6d00 else [ ] return arg_0 . _versions

def Func(arg_0):
        """
        Gets a list of supported U2F versions from the device.
        """
        if not hasattr(arg_0, '_versions'):
            try:
                arg_0._versions = [arg_0.send_apdu(INS_GET_VERSION).decode()]
            except exc.APDUError as e:
                # v0 didn't support the instruction.
                arg_0._versions = ['v0'] if e.code == 0x6d00 else []

        return arg_0._versions

Gets a list of supported U2F versions from the device .


(self, strings=True, virtual=True, selection=None)

return pd.DataFrame(data=columns, index=['dtype', 'count', 'missing', 'mean', 'std', 'min', 'max'])

def Func ( arg_0 , arg_1 = True , arg_2 = True , arg_3 = None ) : import pandas as pd arg_4 = len ( arg_0 ) arg_5 = { } for arg_6 in arg_0 . get_column_names ( arg_1 = arg_1 , arg_2 = arg_2 ) [ : ] : arg_7 = str ( arg_0 . dtype ( arg_6 ) ) if arg_0 . dtype ( arg_6 ) != str else 'str' if arg_0 . dtype ( arg_6 ) == str_type or arg_0 . dtype ( arg_6 ) . kind in [ 'S' , 'U' , 'O' ] : arg_8 = arg_0 . count ( arg_6 , arg_3 = arg_3 , delay = True ) arg_0 . execute ( ) arg_8 = arg_8 . get ( ) arg_5 [ arg_6 ] = ( ( arg_7 , arg_8 , arg_4 - arg_8 , '--' , '--' , '--' , '--' ) ) else : arg_8 = arg_0 . count ( arg_6 , arg_3 = arg_3 , delay = True ) arg_9 = arg_0 . mean ( arg_6 , arg_3 = arg_3 , delay = True ) arg_10 = arg_0 . std ( arg_6 , arg_3 = arg_3 , delay = True ) arg_11 = arg_0 . minmax ( arg_6 , arg_3 = arg_3 , delay = True ) arg_0 . execute ( ) arg_8 , arg_9 , arg_10 , arg_11 = arg_8 . get ( ) , arg_9 . get ( ) , arg_10 . get ( ) , arg_11 . get ( ) arg_8 = int ( arg_8 ) arg_5 [ arg_6 ] = ( ( arg_7 , arg_8 , arg_4 - arg_8 , arg_9 , arg_10 , arg_11 [ 0 ] , arg_11 [ 1 ] ) ) return pd . DataFrame ( data = arg_5 , index = [ 'dtype' , 'count' , 'missing' , 'mean' , 'std' , 'min' , 'max' ] )

def Func(arg_0, arg_1=True, arg_2=True, arg_3=None):
        """Give a description of the DataFrame.

        >>> import vaex
        >>> df = vaex.example()[['x', 'y', 'z']]
        >>> df.Func()
                         x          y          z
        dtype      float64    float64    float64
        count       330000     330000     330000
        missing          0          0          0
        mean    -0.0671315 -0.0535899  0.0169582
        std        7.31746    7.78605    5.05521
        min       -128.294   -71.5524   -44.3342
        max        271.366    146.466    50.7185
        >>> df.Func(selection=df.x > 0)
                           x         y          z
        dtype        float64   float64    float64
        count         164060    164060     164060
        missing       165940    165940     165940
        mean         5.13572 -0.486786 -0.0868073
        std          5.18701   7.61621    5.02831
        min      1.51635e-05  -71.5524   -44.3342
        max          271.366   78.0724    40.2191

        :param bool strings: Describe string columns or not
        :param bool virtual: Describe virtual columns or not
        :param selection: Optional selection to use.
        :return: Pandas dataframe

        """
        import pandas as pd
        arg_4 = len(arg_0)
        arg_5 = {}
        for arg_6 in arg_0.get_column_names(arg_1=arg_1, arg_2=arg_2)[:]:
            arg_7 = str(arg_0.dtype(arg_6)) if arg_0.dtype(arg_6) != str else 'str'
            if arg_0.dtype(arg_6) == str_type or arg_0.dtype(arg_6).kind in ['S', 'U', 'O']:
                arg_8 = arg_0.count(arg_6, arg_3=arg_3, delay=True)
                arg_0.execute()
                arg_8 = arg_8.get()
                arg_5[arg_6] = ((arg_7, arg_8, arg_4-arg_8, '--', '--', '--', '--'))
            else:
                arg_8 = arg_0.count(arg_6, arg_3=arg_3, delay=True)
                arg_9 = arg_0.mean(arg_6, arg_3=arg_3, delay=True)
                arg_10 = arg_0.std(arg_6, arg_3=arg_3, delay=True)
                arg_11 = arg_0.minmax(arg_6, arg_3=arg_3, delay=True)
                arg_0.execute()
                arg_8, arg_9, arg_10, arg_11 = arg_8.get(), arg_9.get(), arg_10.get(), arg_11.get()
                arg_8 = int(arg_8)
                arg_5[arg_6] = ((arg_7, arg_8, arg_4-arg_8, arg_9, arg_10, arg_11[0], arg_11[1]))
        return pd.DataFrame(data=arg_5, index=['dtype', 'count', 'missing', 'mean', 'std', 'min', 'max'])

Give a description of the DataFrame.

        >>> import vaex
        >>> df = vaex.example()[['x', 'y', 'z']]
        >>> df.describe()
                         x          y          z
        dtype      float64    float64    float64
        count       330000     330000     330000
        missing          0          0          0
        mean    -0.0671315 -0.0535899  0.0169582
        std        7.31746    7.78605    5.05521
        min       -128.294   -71.5524   -44.3342
        max        271.366    146.466    50.7185
        >>> df.describe(selection=df.x > 0)
                           x         y          z
        dtype        float64   float64    float64
        count         164060    164060     164060
        missing       165940    165940     165940
        mean         5.13572 -0.486786 -0.0868073
        std          5.18701   7.61621    5.02831
        min      1.51635e-05  -71.5524   -44.3342
        max          271.366   78.0724    40.2191

        :param bool strings: Describe string columns or not
        :param bool virtual: Describe virtual columns or not
        :param selection: Optional selection to use.
        :return: Pandas dataframe


return all(a.problem is model.solver for a in atoms)

def Func ( arg_0 , arg_1 ) : arg_2 = arg_1 . atoms ( optlang . interface . Variable ) return all ( arg_3 . problem is arg_0 . solver for arg_3 in arg_2 )

def Func(arg_0, arg_1):
    """Check whether a sympy expression references the correct variables.

    Parameters
    ----------
    model : cobra.Model
        The model in which to check for variables.
    expression : sympy.Basic
        A sympy expression.

    Returns
    -------
    boolean
        True if all referenced variables are contained in model, False
        otherwise.
    """
    arg_2 = arg_1.atoms(optlang.interface.Variable)
    return all(arg_3.problem is arg_0.solver for arg_3 in arg_2)

Check whether a sympy expression references the correct variables .


def Func ( arg_0 , arg_1 ) : if arg_0 . package == 'pandas' : return [ arg_0 . type ( int ( arg_2 * arg_0 . factor ) , units = 'ns' ) for arg_2 in arg_1 ] else : return [ arg_0 . type ( seconds = arg_2 * arg_0 . factor ) for arg_2 in arg_1 ]

def Func(arg_0, arg_1):
        """
        Convert sequence of numerics to timedelta
        """
        if arg_0.package == 'pandas':
            return [arg_0.type(int(arg_2*arg_0.factor), units='ns')
                    for arg_2 in arg_1]
        else:
            return [arg_0.type(seconds=arg_2*arg_0.factor)
                    for arg_2 in arg_1]


def Func(arg_0):
    """Windows allow application paths to be registered in the registry."""
    arg_1 = None
    if sys.platform.startswith('win'):
        if os.path.splitext(arg_0)[1].lower() != '.exe':
            arg_0 += '.exe'
        import _winreg # pylint: disable=import-error
        try:
            arg_2 = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\" + arg_0
            arg_3 = _winreg.QueryValue(_winreg.HKEY_LOCAL_MACHINE, arg_2)
            arg_1 = (arg_3, "from HKLM\\"+arg_2)
        except _winreg.error:
            pass
        if arg_1 and not os.path.exists(arg_1[0]):
            arg_1 = None
    return arg_1

Windows allow application paths to be registered in the registry .


given a filename or ABF object, try to analyze it.

def
Func
(
arg_0
=
False
,
arg_1
=
True
,
arg_2
=
)
:
if
arg_0
and
os
.
path
.
exists
(
arg_0
.
replace
(
".abf"
,
".rst"
)
)
:
print
(
"SKIPPING DUE TO RST FILE"
)
return
arg_3
.
plotting
.
core
.
IMAGE_SAVE
=
arg_1
if
arg_2
is
:
if
cm
.
isIpython
(
)
:
arg_3
.
plotting
.
core
.
IMAGE_SHOW
=
True
else
:
arg_3
.
plotting
.
core
.
IMAGE_SHOW
=
False
arg_8
=
ABF
(
arg_0
)
print
(
">>>>> PROTOCOL >>>>>"
,
arg_8
.
protocomment
)
arg_9
=
"proto_unknown"
if
"proto_"
+
arg_8
.
protocomment
in
globals
(
)
:
arg_9
=
"proto_"
+
arg_8
.
protocomment
arg_8
.
log
.
debug
(
"running %s()"
%
(
arg_9
)
)
plt
.
close
(
'all'
)
globals
(
)
[
arg_9
]
(
arg_8
)
try
:
globals
(
)
[
arg_9
]
(
arg_8
)
except
:
arg_8
.
log
.
error
(
"EXCEPTION DURING PROTOCOL FUNCTION"
)
arg_8
.
log
.
error
(
sys
.
exc_info
(
)
[
0
]
)
return
"ERROR"
plt
.
close
(
'all'
)
return
"SUCCESS"

def Func(arg_0=False,arg_1=True,arg_2=None):
    """given a filename or ABF object, try to Func it."""
    if arg_0 and os.path.exists(arg_0.replace(".abf",".rst")):
        print("SKIPPING DUE TO RST FILE")
        return
    arg_3.plotting.core.IMAGE_SAVE=arg_1
    if arg_2 is None:
        if cm.isIpython():
            arg_3.plotting.core.IMAGE_SHOW=True
        else:
            arg_3.plotting.core.IMAGE_SHOW=False
    #swhlab.plotting.core.IMAGE_SHOW=show
    arg_8=ABF(arg_0) # ensure it's a class
    print(">>>>> PROTOCOL >>>>>",arg_8.protocomment)
    arg_9="proto_unknown"
    if "proto_"+arg_8.protocomment in globals():
        arg_9="proto_"+arg_8.protocomment
    arg_8.log.debug("running %s()"%(arg_9))
    plt.close('all') # get ready
    globals()[arg_9](arg_8) # run that function
    try:
        globals()[arg_9](arg_8) # run that function
    except:
        arg_8.log.error("EXCEPTION DURING PROTOCOL FUNCTION")
        arg_8.log.error(sys.exc_info()[0])
        return "ERROR"
    plt.close('all') # clean up
    return "SUCCESS"

given a filename or ABF object try to analyze it .


return self._execute(Command.FIND_ELEMENT, {
            'using': using,
            'value': value
        })

def Func ( arg_0 , arg_1 , arg_2 ) : return arg_0 . _execute ( Command . FIND_ELEMENT , { 'using' : arg_1 , 'value' : arg_2 } )

def Func(arg_0, arg_1, arg_2):
        """Find an Func in the current context.

        Support:
            Android iOS Web(WebView)

        Args:
            using(str): The Func location strategy.
            value(str): The value of the location strategy.

        Returns:
            WebElement Object.

        Raises:
            WebDriverException.
        """
        return arg_0._execute(Command.FIND_ELEMENT, {
            'using': arg_1,
            'value': arg_2
        })

Find an element in the current context.

        Support:
            Android iOS Web(WebView)

        Args:
            using(str): The element location strategy.
            value(str): The value of the location strategy.

        Returns:
            WebElement Object.

        Raises:
            WebDriverException.

Find an element in the current context .


return True if cursor.fetchone() else False

def
Func
(
arg_0
)
:
arg_1
=
(
"SELECT name FROM sqlite_master "
+
"WHERE type='table' AND name=?"
,
(
arg_0
.
__tablename__
,
)
,
)
arg_2
=
sqlite3
.
connect
(
arg_0
.
sqlite_file
)
arg_3
=
arg_2
.
cursor
(
)
arg_3
.
execute
(
*
arg_1
)
return
True
if
arg_3
.
fetchone
(
)
else
False

def Func(arg_0):
        """ Check if the database table Func
        """
        arg_1 = (
            "SELECT name FROM sqlite_master " + "WHERE type='table' AND name=?",
            (arg_0.__tablename__,),
        )
        arg_2 = sqlite3.connect(arg_0.sqlite_file)
        arg_3 = arg_2.cursor()
        arg_3.execute(*arg_1)
        return True if arg_3.fetchone() else False