def
Func
(
arg_0
,
arg_1
,
arg_2
)
:
if
arg_0
.
control_stream
:
arg_0
.
control_stream
.
flush
(
)
arg_3
,
arg_2
=
arg_0
.
session
.
feed_identities
(
arg_2
,
copy
=
False
)
try
:
arg_2
=
arg_0
.
session
.
unserialize
(
arg_2
,
content
=
True
,
copy
=
False
)
except
:
arg_0
.
log
.
error
(
"Invalid Message"
,
exc_info
=
True
)
return
arg_4
=
arg_2
[
'header'
]
arg_5
=
arg_4
[
'msg_id'
]
arg_6
=
arg_2
[
'header'
]
[
'msg_type'
]
arg_0
.
log
.
debug
(
'\n*** MESSAGE TYPE:%s***'
,
arg_6
)
arg_0
.
log
.
debug
(
'   Content: %s\n   --->\n   '
,
arg_2
[
'content'
]
)
if
arg_5
in
arg_0
.
aborted
:
arg_0
.
aborted
.
remove
(
arg_5
)
arg_7
=
arg_6
.
split
(
'_'
)
[
0
]
+
'_reply'
arg_8
=
{
'status'
:
'aborted'
}
arg_9
=
{
'engine'
:
arg_0
.
ident
}
arg_9
.
update
(
arg_8
)
arg_10
=
arg_0
.
session
.
send
(
arg_1
,
arg_7
,
subheader
=
arg_9
,
content
=
arg_8
,
parent
=
arg_2
,
ident
=
arg_3
)
return
arg_11
=
arg_0
.
shell_handlers
.
get
(
arg_6
,
)
if
arg_11
is
:
arg_0
.
log
.
error
(
"UNKNOWN MESSAGE TYPE: %r"
,
arg_6
)
else
:
arg_12
=
signal
(
SIGINT
,
default_int_handler
)
try
:
arg_11
(
arg_1
,
arg_3
,
arg_2
)
except
Exception
:
arg_0
.
log
.
error
(
"Exception in message handler:"
,
exc_info
=
True
)
finally
:
signal
(
SIGINT
,
arg_12
)

def Func(arg_0, arg_1, arg_2):
        """dispatch shell requests"""
        # flush control requests first
        if arg_0.control_stream:
            arg_0.control_stream.flush()

        arg_3,arg_2 = arg_0.session.feed_identities(arg_2, copy=False)
        try:
            arg_2 = arg_0.session.unserialize(arg_2, content=True, copy=False)
        except:
            arg_0.log.error("Invalid Message", exc_info=True)
            return

        arg_4 = arg_2['header']
        arg_5 = arg_4['msg_id']
        arg_6 = arg_2['header']['msg_type']

        # Print some info about this message and leave a '--->' marker, so it's
        # easier to trace visually the message chain when debugging.  Each
        # handler prints its message at the end.
        arg_0.log.debug('\n*** MESSAGE TYPE:%s***', arg_6)
        arg_0.log.debug('   Content: %s\n   --->\n   ', arg_2['content'])

        if arg_5 in arg_0.aborted:
            arg_0.aborted.remove(arg_5)
            # is it safe to assume a msg_id will not be resubmitted?
            arg_7 = arg_6.split('_')[0] + '_reply'
            arg_8 = {'status' : 'aborted'}
            arg_9 = {'engine' : arg_0.ident}
            arg_9.update(arg_8)
            arg_10 = arg_0.session.send(arg_1, arg_7, subheader=arg_9,
                        content=arg_8, parent=arg_2, ident=arg_3)
            return

        arg_11 = arg_0.shell_handlers.get(arg_6, None)
        if arg_11 is None:
            arg_0.log.error("UNKNOWN MESSAGE TYPE: %r", arg_6)
        else:
            # ensure default_int_handler during handler call
            arg_12 = signal(SIGINT, default_int_handler)
            try:
                arg_11(arg_1, arg_3, arg_2)
            except Exception:
                arg_0.log.error("Exception in message handler:", exc_info=True)
            finally:
                signal(SIGINT, arg_12)


def Func(arg_0, arg_1):
    """
    returns number of days for the given year and month

    :param int year: calendar year
    :param int month: calendar month
    :return int:
    """

    arg_2 = _days_per_month[arg_1 - 1]
    if is_leap_year(arg_0) and arg_1 == 2:
        arg_2 += 1

    return arg_2


def Func(arg_0, arg_1, arg_2=False):
        """
        Add a model.

        The model will be asssigned to a class attribute with the YANG name of the model.

        Args:
            model (PybindBase): Model to add.
            force (bool): If not set, verify the model is in SUPPORTED_MODELS

        Examples:

            >>> import napalm_yang
            >>> config = napalm_yang.base.Root()
            >>> config.Func(napalm_yang.models.openconfig_interfaces)
            >>> config.interfaces
            <pyangbind.lib.yangtypes.YANGBaseClass object at 0x10bef6680>
        """
        if isinstance(arg_1, str):
            arg_0._load_model(arg_1)
            return

        try:
            arg_1 = arg_1()
        except Exception:
            pass

        if arg_1._yang_name not in [arg_3[0] for arg_3 in SUPPORTED_MODELS] and not arg_2:
            raise ValueError(
                "Only models in SUPPORTED_MODELS can be added without `force=True`"
            )

        for arg_4, arg_5 in arg_1:
            arg_0._elements[arg_4] = arg_5
            setattr(arg_0, arg_4, arg_5)

Add a model.

        The model will be asssigned to a class attribute with the YANG name of the model.

        Args:
            model (PybindBase): Model to add.
            force (bool): If not set, verify the model is in SUPPORTED_MODELS

        Examples:

            >>> import napalm_yang
            >>> config = napalm_yang.base.Root()
            >>> config.add_model(napalm_yang.models.openconfig_interfaces)
            >>> config.interfaces
            <pyangbind.lib.yangtypes.YANGBaseClass object at 0x10bef6680>


def Func(arg_0, arg_1, **arg_2):
        """Fetch the articles

        :param category: the category of items to fetch
        :param kwargs: backend arguments

        :returns: a generator of items
        """
        arg_3 = arg_2['offset']

        logger.info("Fetching articles of '%s' group on '%s' offset %s",
                    arg_0.group, arg_0.host, str(arg_3))

        arg_4, arg_5, arg_6 = (0, 0, 0)

        arg_7, arg_7, arg_8, arg_9, arg_7 = arg_0.client.group(arg_0.group)

        if arg_3 <= arg_9:
            arg_8 = max(arg_8, arg_3)
            arg_7, arg_10 = arg_0.client.over((arg_8, arg_9))
        else:
            arg_10 = []

        arg_6 = len(arg_10)

        logger.debug("Total number of articles to fetch: %s", arg_6)

        for arg_11, arg_7 in arg_10:
            try:
                arg_12 = arg_0.client.article(arg_11)
                arg_13 = arg_0.__parse_article(arg_12)
            except ParseError:
                logger.warning("Error parsing %s article; skipping",
                               arg_11)
                arg_5 += 1
                continue
            except nntplib.NNTPTemporaryError as e:
                logger.warning("Error '%s' fetching article %s; skipping",
                               e.response, arg_11)
                arg_5 += 1
                continue

            yield arg_13
            arg_4 += 1


return self.VIEWS[path].as_view()(request, *args, **kwargs)

def Func ( arg_0 , arg_1 , * arg_2 , ** arg_3 ) : arg_4 , arg_5 , arg_6 , arg_7 = RouterView . get_path_variables ( ** arg_3 ) arg_8 = arg_6 or arg_5 or arg_7 arg_9 = re . sub ( '{}|{}' . format ( arg_4 , re . escape ( arg_8 ) ) , '{}' , arg_1 . path ) arg_3 . pop ( 'course_key' , None ) return arg_0 . VIEWS [ arg_9 ] . as_view ( ) ( arg_1 , * arg_2 , ** arg_3 )

def Func(arg_0, arg_1, *arg_2, **arg_3):
        """
        Redirects to the appropriate view depending on where the user came from.
        """
        arg_4, arg_5, arg_6, arg_7 = RouterView.get_path_variables(**arg_3)
        arg_8 = arg_6 or arg_5 or arg_7
        # Replace enterprise UUID and resource ID with '{}', to easily match with a path in RouterView.VIEWS. Example:
        # /enterprise/fake-uuid/course/course-v1:cool+course+2017/enroll/ -> /enterprise/{}/course/{}/enroll/
        arg_9 = re.sub('{}|{}'.format(arg_4, re.escape(arg_8)), '{}', arg_1.path)

        # Remove course_key from kwargs if it exists because delegate views are not expecting it.
        arg_3.pop('course_key', None)

        return arg_0.VIEWS[arg_9].as_view()(arg_1, *arg_2, **arg_3)

Redirects to the appropriate view depending on where the user came from .


def Func(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5=1):
        r'''Method to calculate a derivative of a mixture property with respect
        to pressure at constant temperature and composition,
        of a given order. Methods found valid by `select_valid_methods` are
        attempted until a method succeeds. If no methods are valid and succeed,
        None is returned.

        Calls `calculate_derivative_P` internally to perform the actual
        calculation.

        .. math::
            \text{derivative} = \frac{d (\text{property})}{d P}|_{T, z}

        Parameters
        ----------
        T : float
            Temperature at which to calculate the derivative, [K]
        P : float
            Pressure at which to calculate the derivative, [Pa]
        zs : list[float]
            Mole fractions of all species in the mixture, [-]
        ws : list[float]
            Weight fractions of all species in the mixture, [-]
        order : int
            Order of the derivative, >= 1

        Returns
        -------
        d_prop_d_P_at_T : float
            Calculated derivative property, [`units/Pa^order`]
        '''
        arg_6 = arg_0.select_valid_methods(arg_1, arg_2, arg_3, arg_4)
        for arg_7 in arg_6:
            try:
                return arg_0.calculate_derivative_P(arg_2, arg_1, arg_3, arg_4, arg_7, arg_5)
            except:
                pass
        return None

r Method to calculate a derivative of a mixture property with respect to pressure at constant temperature and composition of a given order . Methods found valid by select_valid_methods are attempted until a method succeeds . If no methods are valid and succeed None is returned .


def Func(arg_0):
        """
        Returns `resource` wrapped in the appropriate html tag for it's mimetype.
        """
        if arg_0.mimetype == "text/css":
            if arg_0.kind == "text":
                return u"<style type='text/css'>\n%s\n</style>" % arg_0.data
            elif arg_0.kind == "url":
                return u"<link rel='stylesheet' href='%s' type='text/css'>" % arg_0.data
            else:
                raise Exception("Unrecognized resource kind %r" % arg_0.kind)

        elif arg_0.mimetype == "application/javascript":
            if arg_0.kind == "text":
                return u"<script>\n%s\n</script>" % arg_0.data
            elif arg_0.kind == "url":
                return u"<script src='%s' type='application/javascript'></script>" % arg_0.data
            else:
                raise Exception("Unrecognized resource kind %r" % arg_0.kind)

        elif arg_0.mimetype == "text/html":
            assert arg_0.kind == "text"
            return arg_0.data

        else:
            raise Exception("Unrecognized mimetype %r" % arg_0.mimetype)

Returns resource wrapped in the appropriate html tag for it s mimetype .


def Func(arg_0):
    """Convers a CamelCase string into a snake_case one

    Parameters
    ----------
    name : str
        An arbitrary string that may be CamelCase

    Returns
    -------
    str
        The input string converted into snake_case

    """
    arg_1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', arg_0)
    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', arg_1).lower()


(self, start_time, end_time, strict=False)

def Func ( arg_0 , arg_1 , arg_2 , arg_3 = False ) : arg_4 = AnnotationArray ( ) for arg_5 in arg_0 : arg_4 . append ( arg_5 . Func ( arg_1 , arg_2 , arg_3 = arg_3 ) ) return arg_4

def Func(arg_0, arg_1, arg_2, arg_3=False):
        '''
        Trim every annotation contained in the annotation array using
        `Annotation.Func` and return as a new `AnnotationArray`.

        See `Annotation.Func` for details about Funcming. This function does
        not modify the annotations in the original annotation array.

        Parameters
        ----------
        start_time : float
            The desired start time for the Funcmed annotations in seconds.
        end_time
            The desired end time for Funcmed annotations in seconds. Must be
            greater than ``start_time``.
        strict : bool
            When ``False`` (default) observations that lie at the boundaries of
            the Funcming range (see `Annotation.Func` for details) will have
            their time and/or duration adjusted such that only the part of the
            observation that lies within the Func range is kept. When ``True``
            such observations are discarded and not included in the Funcmed
            annotation.

        Returns
        -------
        Funcmed_array : AnnotationArray
            An annotation array where every annotation has been Funcmed.
        '''
        arg_4 = AnnotationArray()
        for arg_5 in arg_0:
            arg_4.append(arg_5.Func(arg_1, arg_2, arg_3=arg_3))

        return arg_4

Trim every annotation contained in the annotation array using
        `Annotation.trim` and return as a new `AnnotationArray`.

        See `Annotation.trim` for details about trimming. This function does
        not modify the annotations in the original annotation array.

        Parameters
        ----------
        start_time : float
            The desired start time for the trimmed annotations in seconds.
        end_time
            The desired end time for trimmed annotations in seconds. Must be
            greater than ``start_time``.
        strict : bool
            When ``False`` (default) observations that lie at the boundaries of
            the trimming range (see `Annotation.trim` for details) will have
            their time and/or duration adjusted such that only the part of the
            observation that lies within the trim range is kept. When ``True``
            such observations are discarded and not included in the trimmed
            annotation.

        Returns
        -------
        trimmed_array : AnnotationArray
            An annotation array where every annotation has been trimmed.

Trim every annotation contained in the annotation array using Annotation . trim and return as a new AnnotationArray .


async def Func(arg_0, arg_1: arg_2) -> None:
        """
        Send ASGI websocket messages, ensuring valid state transitions.
        """
        if arg_0.application_state == WebSocketState.CONNECTING:
            arg_3 = arg_1["type"]
            assert arg_3 in {"websocket.accept", "websocket.close"}
            if arg_3 == "websocket.close":
                arg_0.application_state = WebSocketState.DISCONNECTED
            else:
                arg_0.application_state = WebSocketState.CONNECTED
            await arg_0._Func(arg_1)
        elif arg_0.application_state == WebSocketState.CONNECTED:
            arg_3 = arg_1["type"]
            assert arg_3 in {"websocket.Func", "websocket.close"}
            if arg_3 == "websocket.close":
                arg_0.application_state = WebSocketState.DISCONNECTED
            await arg_0._Func(arg_1)
        else:
            raise RuntimeError('Cannot call "Func" once a close message has been sent.')

Send ASGI websocket messages ensuring valid state transitions .


(self, out_buffer, in_buffer, *,
                            out_start=0, out_end=None, in_start=0, in_end=None, stop=True)

def Func(arg_0, arg_1, arg_2, *,
                            arg_3=0, arg_4=None, arg_5=0, arg_6=None, arg_7=True):
        """
        Write the bytes from ``out_buffer`` to the device, then immediately
        reads into ``in_buffer`` from the device. The number of bytes read
        will be the length of ``in_buffer``.
        Transmits a stop bit after the write, if ``stop`` is set.

        If ``out_start`` or ``out_end`` is provided, then the output buffer
        will be sliced as if ``out_buffer[out_start:out_end]``. This will
        not cause an allocation like ``buffer[out_start:out_end]`` will so
        it saves memory.

        If ``in_start`` or ``in_end`` is provided, then the input buffer
        will be sliced as if ``in_buffer[in_start:in_end]``. This will not
        cause an allocation like ``in_buffer[in_start:in_end]`` will so
        it saves memory.

        :param bytearray out_buffer: buffer containing the bytes to write
        :param bytearray in_buffer: buffer containing the bytes to read into
        :param int out_start: Index to start writing from
        :param int out_end: Index to read up to but not include
        :param int in_start: Index to start writing at
        :param int in_end: Index to write up to but not include
        :param bool stop: If true, output an I2C stop condition after the buffer is written
        """
        if arg_4 is None:
            arg_4 = len(arg_1)
        if arg_6 is None:
            arg_6 = len(arg_2)
        if hasattr(arg_0.i2c, 'writeto_then_readfrom'):
            if arg_0._debug:
                print("i2c_device.writeto_then_readfrom.out_buffer:",
                      [hex(arg_8) for arg_8 in arg_1[arg_3:arg_4]])
            # In linux, at least, this is a special kernel function call
            arg_0.i2c.writeto_then_readfrom(arg_0.device_address, arg_1, arg_2,
                                           arg_3=arg_3, arg_4=arg_4,
                                           arg_5=arg_5, arg_6=arg_6, arg_7=arg_7)
            if arg_0._debug:
                print("i2c_device.writeto_then_readfrom.in_buffer:",
                      [hex(arg_8) for arg_8 in arg_2[arg_5:arg_6]])
        else:
            # If we don't have a special implementation, we can fake it with two calls
            arg_0.write(arg_1, start=arg_3, end=arg_4, arg_7=arg_7)
            if arg_0._debug:
                print("i2c_device.Func.write.out_buffer:",
                      [hex(arg_8) for arg_8 in arg_1[arg_3:arg_4]])
            arg_0.readinto(arg_2, start=arg_5, end=arg_6)
            if arg_0._debug:
                print("i2c_device.Func.readinto.in_buffer:",
                      [hex(arg_8) for arg_8 in arg_2[arg_5:arg_6]])

Write the bytes from out_buffer to the device then immediately reads into in_buffer from the device . The number of bytes read will be the length of in_buffer . Transmits a stop bit after the write if stop is set .


def
Func
(
arg_0
)
:
try
:
arg_1
=
blosc
.
unpack_array
(
arg_0
)
except
Exception
as
e
:
raise
ValueError
(
"Could not load numpy data. {}"
.
format
(
e
)
)
return
arg_1

def Func(arg_0):
    """
    Import a blosc array into a numpy array.

    Arguments:
        data: A blosc packed numpy array

    Returns:
        A numpy array with data from a blosc compressed array
    """
    try:
        arg_1 = blosc.unpack_array(arg_0)
    except Exception as e:
        raise ValueError("Could not load numpy data. {}".format(e))

    return arg_1

Import a blosc array into a numpy array .


def Func(arg_0, arg_1, arg_2, arg_3):
        """
        Filter issues that belong to specified tag range.

        :param list(dict) issues: Issues to filter.
        :param dict older_tag: All issues before this tag's date will be
                               excluded. May be special value, if **newer_tag**
                               is the first tag. (Means **older_tag** is when
                               the repo was created.)
        :param dict newer_tag: All issues after this tag's date  will be
                               excluded. May be title of unreleased section.
        :rtype: list(dict)
        :return: Filtered issues.
        """

        if not arg_2 and not arg_3:
            # in case if no tags are specified - return unchanged array
            return copy.deepcopy(arg_1)

        arg_4 = arg_0.get_time_of_tag(arg_3)
        arg_5 = arg_0.get_time_of_tag(arg_2)
        arg_6 = []
        for arg_7 in arg_1:
            if arg_7.get('actual_date'):
                arg_8 = arg_5 < arg_7['actual_date'] <= arg_4
                if arg_8:
                    arg_6.append(copy.deepcopy(arg_7))
        return arg_6

Filter issues that belong to specified tag range .


def Func ( arg_0 , arg_1 ) : def _is_used_in_except_block ( arg_1 ) : arg_2 = arg_1 . scope ( ) arg_3 = arg_1 while ( arg_3 and arg_3 != arg_2 and not isinstance ( arg_3 , astroid . ExceptHandler ) ) : arg_3 = arg_3 . parent return isinstance ( arg_3 , astroid . ExceptHandler ) and arg_3 . type != arg_1 if isinstance ( arg_1 . name , ( astroid . Tuple , astroid . List ) ) : arg_0 . add_message ( "unpacking-in-except" , arg_1 = arg_1 ) return if not arg_1 . name : return arg_2 = arg_1 . parent . scope ( ) arg_4 = arg_2 . nodes_of_class ( astroid . Name , skip_klass = astroid . FunctionDef ) arg_4 = list ( arg_4 ) arg_5 = [ scope_name for scope_name in arg_4 if scope_name . name == arg_1 . name . name and scope_name . lineno > arg_1 . lineno and not _is_used_in_except_block ( scope_name ) ] arg_6 = { assign_name . lineno for assign_name in arg_2 . nodes_of_class ( astroid . AssignName , skip_klass = astroid . FunctionDef ) if assign_name . name == arg_1 . name . name } for arg_7 in arg_5 : if any ( arg_1 . lineno < arg_8 < arg_7 . lineno for arg_8 in arg_6 ) : continue arg_0 . add_message ( "exception-escape" , arg_1 = arg_7 )

def Func(arg_0, arg_1):
        """Visit an except handler block and check for exception unpacking."""

        def _is_used_in_except_block(arg_1):
            arg_2 = arg_1.scope()
            arg_3 = arg_1
            while (
                arg_3
                and arg_3 != arg_2
                and not isinstance(arg_3, astroid.ExceptHandler)
            ):
                arg_3 = arg_3.parent
            return isinstance(arg_3, astroid.ExceptHandler) and arg_3.type != arg_1

        if isinstance(arg_1.name, (astroid.Tuple, astroid.List)):
            arg_0.add_message("unpacking-in-except", arg_1=arg_1)
            return

        if not arg_1.name:
            return

        # Find any names
        arg_2 = arg_1.parent.scope()
        arg_4 = arg_2.nodes_of_class(astroid.Name, skip_klass=astroid.FunctionDef)
        arg_4 = list(arg_4)
        arg_5 = [
            scope_name
            for scope_name in arg_4
            if scope_name.name == arg_1.name.name
            and scope_name.lineno > arg_1.lineno
            and not _is_used_in_except_block(scope_name)
        ]
        arg_6 = {
            assign_name.lineno
            for assign_name in arg_2.nodes_of_class(
                astroid.AssignName, skip_klass=astroid.FunctionDef
            )
            if assign_name.name == arg_1.name.name
        }
        for arg_7 in arg_5:
            if any(
                arg_1.lineno < arg_8 < arg_7.lineno
                for arg_8 in arg_6
            ):
                continue
            arg_0.add_message("exception-escape", arg_1=arg_7)

Visit an except handler block and check for exception unpacking .


def Func ( arg_0 , arg_1 , arg_2 = None ) : if isinstance ( arg_1 , Component ) : if arg_1 : if arg_2 : arg_1 = Component ( { k : getattr ( arg_1 , k , None ) for k in arg_2 } ) for arg_3 in arg_0 . __list : try : if arg_1 == arg_3 . component : return arg_3 except AttributeError : continue else : for arg_3 in arg_0 . __list : try : if getattr ( arg_1 , 'mnemonic' ) . lower ( ) == arg_3 . curve . mnemonic : return arg_3 except AttributeError : continue return Decor ( { 'colour' : '#eeeeee' , 'component' : Component ( ) } )

def Func(arg_0, arg_1, arg_2=None):
        """
        Get the decor for a component.

        Args:
           c (component): The component to look up.
           match_only (list of str): The component attributes to include in the
               comparison. Default: All of them.

        Returns:
           Decor. The matching Decor from the Legend, or None if not found.
        """
        if isinstance(arg_1, Component):
            if arg_1:
                if arg_2:
                    # Filter the component only those attributes
                    arg_1 = Component({k: getattr(arg_1, k, None) for k in arg_2})
                for arg_3 in arg_0.__list:
                    try:
                        if arg_1 == arg_3.component:
                            return arg_3
                    except AttributeError:
                        continue
        else:
            for arg_3 in arg_0.__list:
                try:
                    if getattr(arg_1, 'mnemonic').lower() == arg_3.curve.mnemonic:
                        return arg_3
                except AttributeError:
                    continue
        return Decor({'colour': '#eeeeee', 'component': Component()})


def Func ( arg_0 ) : if arg_0 . _callback != None : arg_1 = time . clock ( ) * 1000 - arg_0 . _start arg_0 . _callback . Func ( arg_0 . _counter , arg_1 )

def Func(arg_0):
        """
        Completes measuring time interval and updates counter.
        """

        if arg_0._callback != None:
            arg_1 = time.clock() * 1000 - arg_0._start
            arg_0._callback.Func(arg_0._counter, arg_1)

Completes measuring time interval and updates counter .


def Func ( arg_0 ) : if '.' in arg_0 : arg_1 , arg_2 = os . path . splitext ( arg_0 ) return arg_1 + arg_2 . lower ( ) return arg_0

def Func(arg_0):
    """
    This is a helper used by UploadSet.save to provide lowercase extensions for
    all processed files, to compare with configured extensions in the same
    case.

    .. versionchanged:: 0.1.4
       Filenames without extensions are no longer lowercased, only the
       extension is returned in lowercase, if an extension exists.

    :param filename: The filename to ensure has a lowercase extension.
    """
    if '.' in arg_0:
        arg_1, arg_2 = os.path.splitext(arg_0)
        return arg_1 + arg_2.lower()
    # For consistency with os.path.splitext,
    # do not treat a filename without an extension as an extension.
    # That is, do not return filename.lower().
    return arg_0

This is a helper used by UploadSet . save to provide lowercase extensions for all processed files to compare with configured extensions in the same case .


(self, category=CATEGORY_MESSAGE, offset=DEFAULT_OFFSET, chats=None)

def Func ( arg_0 , arg_1 = arg_2 , arg_3 = arg_4 , arg_5 = None ) : if not arg_3 : arg_3 = arg_4 arg_6 = { "offset" : arg_3 , "chats" : arg_5 } arg_7 = super ( ) . Func ( arg_1 , ** arg_6 ) return arg_7

def Func(arg_0, arg_1=arg_2, arg_3=arg_4, arg_5=None):
        """Fetch the messages the bot can read from the server.

        The method retrieves, from the Telegram server, the messages
        sent with an offset equal or greater than the given.

        A list of chats, groups and channels identifiers can be set
        using the parameter `chats`. When it is set, only those
        messages sent to any of these will be returned. An empty list
        will return no messages.

        :param category: the category of items to Func
        :param offset: obtain messages from this offset
        :param chats: list of chat names used to filter messages

        :returns: a generator of messages

        :raises ValueError: when `chats` is an empty list
        """
        if not arg_3:
            arg_3 = arg_4

        arg_6 = {"offset": arg_3, "chats": arg_5}
        arg_7 = super().Func(arg_1, **arg_6)

        return arg_7

Fetch the messages the bot can read from the server.

        The method retrieves, from the Telegram server, the messages
        sent with an offset equal or greater than the given.

        A list of chats, groups and channels identifiers can be set
        using the parameter `chats`. When it is set, only those
        messages sent to any of these will be returned. An empty list
        will return no messages.

        :param category: the category of items to fetch
        :param offset: obtain messages from this offset
        :param chats: list of chat names used to filter messages

        :returns: a generator of messages

        :raises ValueError: when `chats` is an empty list

Fetch the messages the bot can read from the server .


def Func ( arg_0 ) : arg_1 = dict ( ** arg_0 . kwargs ) arg_1 . update ( form = arg_0 . __class__ . __name__ . lower ( ) , name = arg_0 . name , activation = arg_0 . kwargs . get ( 'activation' , 'relu' ) , ) return arg_1

def Func(arg_0):
        '''Create a specification dictionary for this layer.

        Returns
        -------
        spec : dict
            A dictionary specifying the configuration of this layer.
        '''
        arg_1 = dict(**arg_0.kwargs)
        arg_1.update(
            form=arg_0.__class__.__name__.lower(),
            name=arg_0.name,
            activation=arg_0.kwargs.get('activation', 'relu'),
        )
        return arg_1

Create a specification dictionary for this layer .


def Func ( arg_0 , arg_1 = None , arg_2 = None ) : arg_2 = arg_2 or capybara . default_max_wait_time with arg_0 . driver . accept_modal ( "alert" , arg_1 = arg_1 , arg_2 = arg_2 ) : yield

def Func(arg_0, arg_1=None, arg_2=None):
        """
        Execute the wrapped code, accepting an alert.

        Args:
            text (str | RegexObject, optional): Text to match against the text in the modal.
            wait (int | float, optional): Maximum time to wait for the modal to appear after
                executing the wrapped code.

        Raises:
            ModalNotFound: If a modal dialog hasn't been found.
        """

        arg_2 = arg_2 or capybara.default_max_wait_time
        with arg_0.driver.accept_modal("alert", arg_1=arg_1, arg_2=arg_2):
            yield

Execute the wrapped code accepting an alert .


def Func ( ) : def get_mem ( arg_0 ) : if os . name == 'posix' : arg_1 = arg_0 . memory_info_ex ( ) arg_2 = arg_1 . rss if 'shared' in arg_1 . _fields : arg_2 -= arg_1 . shared return arg_2 else : return arg_0 . get_memory_info ( ) . rss if SERVER_PROC is not None : arg_1 = get_mem ( SERVER_PROC ) for arg_3 in SERVER_PROC . children ( ) : arg_1 += get_mem ( arg_3 ) server_memory . append ( bytes2human ( arg_1 ) )

def Func():
    """Register an approximation of memory used by FTP server process
    and all of its children.
    """
    # XXX How to get a reliable representation of memory being used is
    # not clear. (rss - shared) seems kind of ok but we might also use
    # the private working set via get_memory_maps().private*.
    def get_mem(arg_0):
        if os.name == 'posix':
            arg_1 = arg_0.memory_info_ex()
            arg_2 = arg_1.rss
            if 'shared' in arg_1._fields:
                arg_2 -= arg_1.shared
            return arg_2
        else:
            # TODO figure out what to do on Windows
            return arg_0.get_memory_info().rss

    if SERVER_PROC is not None:
        arg_1 = get_mem(SERVER_PROC)
        for arg_3 in SERVER_PROC.children():
            arg_1 += get_mem(arg_3)
        server_memory.append(bytes2human(arg_1))

Register an approximation of memory used by FTP server process and all of its children .


def Func(arg_0, arg_1, arg_2, *arg_3):
        """Write bash complete script.

        Args:
            path (path-like): desired path of the complete script.
            cmd (str): command name that should be completed.
            cmds (str): extra command names that should be completed.
        """
        arg_1 = pathlib.Path(arg_1)
        arg_4 = list(arg_0.subcmds.keys())
        with arg_1.open('w') as bcf:
            # main function
            print('_{}() {{'.format(arg_2), file=bcf)
            print('COMPREPLY=()', file=bcf)
            print(r'local cur=${COMP_WORDS[COMP_CWORD]}', end='\n\n', file=bcf)
            arg_5 = ' '.join(arg_0._bash_comp_command(None))
            print(r'local options="{}"'.format(arg_5), end='\n\n', file=bcf)
            if arg_4:
                print('local commands="{}"'.format(' '.join(arg_4)),
                      file=bcf)
                print('declare -A suboptions', file=bcf)
            for arg_6 in arg_4:
                arg_5 = ' '.join(arg_0._bash_comp_command(arg_6))
                print('suboptions[{}]="{}"'.format(arg_6, arg_5), file=bcf)
            arg_7 = 'if'
            for arg_6 in arg_4:
                print(arg_7, r'[[ "${COMP_LINE}" == *"', arg_6, '"* ]] ; then',
                      file=bcf)
                print(r'COMPREPLY=( `compgen -W "${suboptions[', arg_6,
                      r']}" -- ${cur}` )', sep='', file=bcf)
                arg_7 = 'elif'
            print(arg_7, r'[[ ${cur} == -* ]] ; then', file=bcf)
            print(r'COMPREPLY=( `compgen -W "${options}" -- ${cur}`)',
                  file=bcf)
            if arg_4:
                print(r'else', file=bcf)
                print(r'COMPREPLY=( `compgen -W "${commands}" -- ${cur}`)',
                      file=bcf)
            print('fi', file=bcf)
            print('}', end='\n\n', file=bcf)
            print('complete -F _{0} {0}'.format(arg_2), *arg_3, file=bcf)


def Func(arg_0, arg_1, arg_2, arg_3=None):
        """Verify a user defined gate call."""
        if arg_1.name not in arg_0.global_symtab:
            raise QasmError("Cannot find gate definition for '" + arg_1.name
                            + "', line", str(arg_1.line), 'file', arg_1.file)
        arg_4 = arg_0.global_symtab[arg_1.name]
        if not (arg_4.type == 'gate' or arg_4.type == 'opaque'):
            raise QasmError("'" + arg_1.name + "' is used as a gate "
                            + "or opaque call but the symbol is neither;"
                            + " it is a '" + arg_4.type + "' line",
                            str(arg_1.line), 'file', arg_1.file)

        if arg_4.n_bits() != arg_2.size():
            raise QasmError("Gate or opaque call to '" + arg_1.name
                            + "' uses", str(arg_2.size()),
                            "qubits but is declared for",
                            str(arg_4.n_bits()), "qubits", "line",
                            str(arg_1.line), 'file', arg_1.file)

        if arg_3:
            if arg_4.n_args() != arg_3.size():
                raise QasmError("Gate or opaque call to '" + arg_1.name
                                + "' uses", str(arg_3.size()),
                                "qubits but is declared for",
                                str(arg_4.n_args()), "qubits", "line",
                                str(arg_1.line), 'file', arg_1.file)
        else:
            if arg_4.n_args() > 0:
                raise QasmError("Gate or opaque call to '" + arg_1.name
                                + "' has no arguments but is declared for",
                                str(arg_4.n_args()), "qubits", "line",
                                str(arg_1.line), 'file', arg_1.file)


def Func(arg_0, arg_1=None, **arg_2):
        """Finds and runs a pending task.

        Parameters
        -----------
        task_name : str
            The task name.
        kwargs : other parameters
            Users customized parameters such as description, version number.

        Examples
        ---------
        Wait until all tasks finish in user's local console

        >>> while not db.Func():
        >>>     time.sleep(1)
        >>> print("all tasks finished")
        >>> sess = tf.InteractiveSession()
        >>> net = db.find_top_model(sess=sess, sort=[("test_accuracy", -1)])
        >>> print("the best accuracy {} is from model {}".format(net._test_accuracy, net._name))

        Returns
        --------
        boolean : True for success, False for fail.

        """

        if not isinstance(arg_1, str):  # is None:
            raise Exception("task_name should be string")
        arg_0._fill_project_info(arg_2)

        arg_2.update({'$or': [{'status': 'pending'}, {'status': 'running'}]})

        # ## find task
        # task = self.db.Task.find_one(kwargs)
        arg_3 = arg_0.db.Task.find(arg_2)

        arg_4 = arg_3.distinct('_id')
        arg_5 = len(arg_4)

        if arg_5 == 0:
            logging.info("[Database] No unfinished task - task_name: {}".format(arg_1))
            return False
        else:

            logging.info("[Database] Find {} unfinished task - task_name: {}".format(arg_5, arg_1))
            return True

Finds and runs a pending task.

        Parameters
        -----------
        task_name : str
            The task name.
        kwargs : other parameters
            Users customized parameters such as description, version number.

        Examples
        ---------
        Wait until all tasks finish in user's local console

        >>> while not db.check_unfinished_task():
        >>>     time.sleep(1)
        >>> print("all tasks finished")
        >>> sess = tf.InteractiveSession()
        >>> net = db.find_top_model(sess=sess, sort=[("test_accuracy", -1)])
        >>> print("the best accuracy {} is from model {}".format(net._test_accuracy, net._name))

        Returns
        --------
        boolean : True for success, False for fail.


def Func(arg_0):  # pragma: no cover
        """ Create the new table in the SQLite database
        """
        arg_1 = (
            """
            CREATE TABLE {} (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                {} STRING(256),
                {} STRING(256)
            )"""
        ).format(arg_0.__tablename__, arg_0.__key__, arg_0.__value__)
        arg_2 = sqlite3.connect(arg_0.sqlite_file)
        arg_3 = arg_2.cursor()
        arg_3.execute(arg_1)
        arg_2.commit()


def Func(arg_0, arg_1):
    """
    Return sig and val reduced by & operator or None
    if it is not possible to statically reduce expression
    """
    arg_2 = arg_0._dtype.all_mask()
    if arg_1._isFullVld():
        arg_3 = arg_1.val
        if arg_3 == arg_2:
            return arg_0
        elif arg_3 == 0:
            return arg_1


def Func ( arg_0 , ** arg_1 ) : arg_0 [ '_version' ] = 1 arg_2 = get_server_certificate_api ( arg_0 [ 'ServerCertificateName' ] , ** arg_1 ) if arg_2 : arg_0 . update ( arg_2 [ 'ServerCertificateMetadata' ] ) arg_0 [ 'CertificateBody' ] = arg_2 [ 'CertificateBody' ] arg_0 [ 'CertificateChain' ] = arg_2 . get ( 'CertificateChain' , None ) arg_0 [ 'UploadDate' ] = get_iso_string ( arg_0 [ 'UploadDate' ] ) arg_0 [ 'Expiration' ] = get_iso_string ( arg_0 [ 'Expiration' ] ) return arg_0

def Func(arg_0, **arg_1):
    """Fetch the base IAM Server Certificate."""
    arg_0['_version'] = 1

    # Get the initial cert details:
    arg_2 = get_server_certificate_api(arg_0['ServerCertificateName'], **arg_1)

    if arg_2:
        arg_0.update(arg_2['ServerCertificateMetadata'])
        arg_0['CertificateBody'] = arg_2['CertificateBody']
        arg_0['CertificateChain'] = arg_2.get('CertificateChain', None)

        # Cast dates from a datetime to something JSON serializable.
        arg_0['UploadDate'] = get_iso_string(arg_0['UploadDate'])
        arg_0['Expiration'] = get_iso_string(arg_0['Expiration'])

    return arg_0


def Func ( arg_0 ) : arg_1 = arg_0 . widget if arg_1 is not None : arg_2 = arg_1 . getparent ( ) if arg_2 is not None : arg_2 . remove ( arg_1 ) del arg_0 . widget arg_3 = arg_0 . declaration try : del CACHE [ arg_3 . ref ] except KeyError : pass super ( WebComponent , arg_0 ) . Func ( )

def Func(arg_0):
        """ A reimplemented destructor.

        This destructor will clear the reference to the toolkit widget
        and set its parent to None.

        """
        arg_1 = arg_0.widget
        if arg_1 is not None:
            arg_2 = arg_1.getparent()
            if arg_2 is not None:
                arg_2.remove(arg_1)
            del arg_0.widget

            arg_3 = arg_0.declaration
            try:
                del CACHE[arg_3.ref]
            except KeyError:
                pass
        super(WebComponent, arg_0).Func()


def Func ( arg_0 ) : if isinstance ( arg_0 , datetime . datetime ) : arg_0 = _format_datetime ( arg_0 ) return arg_0

def Func(arg_0):
    """If maybe_dttm is a datetime instance, convert to a STIX-compliant
    string representation.  Otherwise return the value unchanged."""
    if isinstance(arg_0, datetime.datetime):
        arg_0 = _format_datetime(arg_0)
    return arg_0

If maybe_dttm is a datetime instance convert to a STIX - compliant string representation . Otherwise return the value unchanged .


def Func ( arg_0 , arg_1 , arg_2 ) : if arg_2 is None : return True arg_3 = arg_1 [ 'message' ] [ 'chat' ] [ 'id' ] return arg_3 in arg_2

def Func(arg_0, arg_1, arg_2):
        """Check if a message can be filtered based in a list of chats.

        This method returns `True` when the message was sent to a chat
        of the given list. It also returns `True` when chats is `None`.

        :param message: Telegram message
        :param chats: list of chat, groups and channels identifiers

        :returns: `True` when the message can be filtered; otherwise,
            it returns `False`
        """
        if arg_2 is None:
            return True

        arg_3 = arg_1['message']['chat']['id']

        return arg_3 in arg_2

Check if a message can be filtered based in a list of chats .


def Func ( arg_0 ) : def method ( arg_1 , ** arg_2 ) : arg_3 = arg_2 . get ( method . _res_name ) arg_4 = arg_2 . get ( method . _other_name ) arg_5 = getattr ( arg_1 , method . _internal_name ) return arg_5 ( method . _relationship , arg_3 , arg_4 ) return method

def Func(arg_0):
        '''
        Returns a callable which becomes the associate or disassociate
        method for the related field.
        Method can be overridden to add additional functionality, but
        `_produce_method` may also need to be subclassed to decorate
        it appropriately.
        '''

        def method(arg_1, **arg_2):
            arg_3 = arg_2.get(method._res_name)
            arg_4 = arg_2.get(method._other_name)
            arg_5 = getattr(arg_1, method._internal_name)
            return arg_5(method._relationship, arg_3, arg_4)

        return method

Returns a callable which becomes the associate or disassociate method for the related field . Method can be overridden to add additional functionality but _produce_method may also need to be subclassed to decorate it appropriately .


def Func ( arg_0 , arg_1 ) : arg_2 = XdotAttrParser ( ) . parse_xdot_data ( arg_1 ) arg_3 = min ( [ c . x for c in arg_2 ] ) arg_4 = min ( [ c . y for c in arg_2 ] ) move_to_origin ( arg_2 ) arg_5 = Container ( auto_size = True , position = [ arg_3 - arg_0 . pos [ 0 ] , arg_4 - arg_0 . pos [ 1 ] ] , bgcolor = "red" ) arg_5 . add ( * arg_2 ) arg_0 . label_drawing = arg_5

def Func(arg_0, arg_1):
        """ Parses the label drawing directive, updating the label
            components.
        """
        arg_2 = XdotAttrParser().parse_xdot_data(arg_1)

        arg_3 = min( [c.x for c in arg_2] )
        arg_4 = min( [c.y for c in arg_2] )

        move_to_origin(arg_2)

        arg_5 = Container(auto_size=True,
            position=[arg_3-arg_0.pos[0], arg_4-arg_0.pos[1]],
            bgcolor="red")

        arg_5.add( *arg_2 )

        arg_0.label_drawing = arg_5

Parses the label drawing directive updating the label components .


def Func(arg_0):
        """
        Creates the virtualenv for the project

        """
        if check_command('virtualenv'):
            arg_1 = os.path.join(arg_0._ve_dir, arg_0._project_name)
            if os.path.exists(arg_1):
                if arg_0._force:
                    logging.warn('Removing existing virtualenv')
                    shutil.rmtree(arg_1)
                else:
                    logging.warn('Found existing virtualenv; not creating (use --force to overwrite)')
                    return
            logging.info('Creating virtualenv')
            arg_2 = subprocess.Popen('virtualenv --no-site-packages {0} > /dev/null'.format(arg_1), shell=True)
            os.waitpid(arg_2.pid, 0)
            # install modules
            for arg_3 in arg_0._modules:
                arg_0.log.info('Installing module {0}'.format(arg_3))
                arg_2 = subprocess.Popen('{0} install {1} > /dev/null'.format(os.path.join(arg_0._ve_dir, \
                arg_0._project_name) + os.sep + 'bin' + os.sep + 'pip', arg_3), shell=True)
                os.waitpid(arg_2.pid, 0)


def Func(arg_0, arg_1=0.0):
    """ Split non-manifold vertices until it becomes two-manifold.

    Args:
        script: the FilterScript object or script filename to write
            the filter to.
        vert_displacement_ratio (float): When a vertex is split it is moved
            along the average vector going from its position to the centroid
            of the FF connected faces sharing it.

    Layer stack:
        No impacts

    MeshLab versions:
        2016.12
        1.3.4BETA
    """
    arg_2 = ''.join([
        '  <filter name="Split Vertexes Incident on Non Manifold Faces">\n',
        '    <Param name="VertDispRatio" ',
        'value="{}" '.format(arg_1),
        'description="Vertex Displacement Ratio" ',
        'type="RichFloat" ',
        '/>\n',
        '  </filter>\n'])
    util.write_filter(arg_0, arg_2)
    return None

Split non - manifold vertices until it becomes two - manifold .


def Func ( arg_0 , arg_1 = 32 , arg_2 = 0 ) : if arg_1 <= 0 or arg_1 > 32 : raise ValueError from . account import EVMAccount if not isinstance ( arg_0 , ( int , BitVec , EVMAccount ) ) : raise ValueError if issymbolic ( arg_0 ) : arg_3 = ArrayVariable ( index_bits = 256 , index_max = 32 , value_bits = 8 , name = 'temp{}' . format ( uuid . uuid1 ( ) ) ) if arg_0 . size <= arg_1 * 8 : arg_0 = Operators . ZEXTEND ( arg_0 , arg_1 * 8 ) else : arg_0 = Operators . EXTRACT ( arg_0 , 0 , arg_1 * 8 ) arg_3 = ArrayProxy ( arg_3 . write_BE ( arg_2 , arg_0 , arg_1 ) ) else : arg_0 = int ( arg_0 ) arg_3 = bytearray ( ) for arg_4 in range ( arg_2 ) : arg_3 . append ( 0 ) for arg_5 in reversed ( range ( arg_1 ) ) : arg_3 . append ( Operators . EXTRACT ( arg_0 , arg_5 * 8 , 8 ) ) assert len ( arg_3 ) == arg_1 + arg_2 return arg_3

def Func(arg_0, arg_1=32, arg_2=0):
        """
        Translates a python integral or a BitVec into a 32 byte string, MSB first
        """
        if arg_1 <= 0 or arg_1 > 32:
            raise ValueError

        from .account import EVMAccount  # because of circular import
        if not isinstance(arg_0, (int, BitVec, EVMAccount)):
            raise ValueError
        if issymbolic(arg_0):
            # FIXME This temporary array variable should be obtained from a specific constraint store
            arg_3 = ArrayVariable(index_bits=256, index_max=32, value_bits=8, name='temp{}'.format(uuid.uuid1()))
            if arg_0.size <= arg_1 * 8:
                arg_0 = Operators.ZEXTEND(arg_0, arg_1 * 8)
            else:
                # automatically truncate, e.g. if they passed a BitVec(256) for an `address` argument (160 bits)
                arg_0 = Operators.EXTRACT(arg_0, 0, arg_1 * 8)
            arg_3 = ArrayProxy(arg_3.write_BE(arg_2, arg_0, arg_1))
        else:
            arg_0 = int(arg_0)
            arg_3 = bytearray()
            for arg_4 in range(arg_2):
                arg_3.append(0)
            for arg_5 in reversed(range(arg_1)):
                arg_3.append(Operators.EXTRACT(arg_0, arg_5 * 8, 8))
        assert len(arg_3) == arg_1 + arg_2
        return arg_3

Translates a python integral or a BitVec into a 32 byte string MSB first


def Func ( arg_0 , arg_1 , arg_2 ) : arg_3 , arg_4 = os . path . splitext ( arg_2 ) if arg_4 == '' : arg_4 = '.lalog' with open ( arg_3 + arg_4 , 'w' ) as f : f . write ( '\n' . join ( arg_1 ) ) f . write ( '\n' . join ( arg_0 ) ) return arg_3 + arg_4

def Func(arg_0, arg_1, arg_2):
    """
    Write and analysis log to a file.

    Parameters
    ----------
    log : list
        latools.analyse analysis log
    header : list
        File header lines.
    file_name : str
        Destination file. If no file extension
        specified, uses '.lalog'

    Returns
    -------
    None
    """
    arg_3, arg_4 = os.path.splitext(arg_2)
    if arg_4 == '':
        arg_4 = '.lalog'

    with open(arg_3 + arg_4, 'w') as f:
        f.write('\n'.join(arg_1))
        f.write('\n'.join(arg_0))

    return arg_3 + arg_4


def Func(arg_0, arg_1, arg_2, arg_3):
    """Perform generic operation on a waveform object."""
    arg_4 = copy.copy(arg_0)
    arg_4.dep_units = arg_2
    arg_4.dep_name = "{0}({1})".format(arg_1, arg_4.dep_name)
    arg_4._dep_vector = arg_3(arg_4._dep_vector)
    return arg_4

Perform generic operation on a waveform object .


def Func ( arg_0 , arg_1 ) : arg_2 , arg_3 , arg_4 = arg_1 . strip ( ) . partition ( '=' ) assert arg_2 == 'runtimepath' assert arg_3 == '=' return arg_4 . split ( ',' )

def Func(arg_0, arg_1):
        """
        Parse runtime path representation to list.

        :param string string: runtime path string
        :return: list of runtime paths
        :rtype: list of string
        """
        arg_2, arg_3, arg_4 = arg_1.strip().partition('=')
        assert arg_2 == 'runtimepath'
        assert arg_3 == '='
        return arg_4.split(',')

Parse runtime path representation to list .


def Func ( arg_0 , arg_1 , arg_2 = None ) : if arg_0 is not NoSet : return arg_0 elif arg_1 is not NoSet : return arg_1 else : return arg_2

def Func(arg_0, arg_1, arg_2=None):
    """Exclude NoSet objec

    .. code-block::

        >>> Func(NoSet, 'value')
        'value'

    """
    if arg_0 is not NoSet:
        return arg_0
    elif arg_1 is not NoSet:
        return arg_1
    else:
        return arg_2

Exclude NoSet objec

    .. code-block::

        >>> coerce(NoSet, 'value')
        'value'


def Func(arg_0, arg_1):
    """
    Delete's the output cache associated with the given modelID. This actually
    clears up the resources associated with the cache, rather than deleting al
    the records in the cache

    Parameters:
    -----------------------------------------------------------------------
    modelID:      The id of the model whose output cache is being deleted

    """

    # If this is our output, we should close the connection
    if arg_1 == arg_0._modelID and arg_0._predictionLogger is not None:
      arg_0._predictionLogger.close()
      del arg_0.__predictionCache
      arg_0._predictionLogger = None
      arg_0.__predictionCache = None

Delete s the output cache associated with the given modelID . This actually clears up the resources associated with the cache rather than deleting al the records in the cache


def Func(arg_0):
        """
        Collect learner data for the ``EnterpriseCustomer`` where data sharing consent is granted.

        Yields a learner data object for each enrollment, containing:

        * ``enterprise_enrollment``: ``EnterpriseCourseEnrollment`` object.
        * ``completed_date``: datetime instance containing the course/enrollment completion date; None if not complete.
          "Course completion" occurs for instructor-paced courses when course certificates are issued, and
          for self-paced courses, when the course end date is passed, or when the learner achieves a passing grade.
        * ``grade``: string grade recorded for the learner in the course.
        """
        # Fetch the consenting enrollment data, including the enterprise_customer_user.
        # Order by the course_id, to avoid fetching course API data more than we have to.
        arg_1 = EnterpriseCourseEnrollment.objects.select_related(
            'enterprise_customer_user'
        ).filter(
            enterprise_customer_user__enterprise_customer=arg_0.enterprise_customer,
            enterprise_customer_user__active=True,
        ).order_by('course_id')

        # Fetch course details from the Course API, and cache between calls.
        arg_2 = None
        for arg_3 in arg_1:

            arg_4 = arg_3.course_id

            # Fetch course details from Courses API
            # pylint: disable=unsubscriptable-object
            if arg_2 is None or arg_2['course_id'] != arg_4:
                if arg_0.course_api is None:
                    arg_0.course_api = CourseApiClient()
                arg_2 = arg_0.course_api.get_course_details(arg_4)

            if arg_2 is None:
                # Course not found, so we have nothing to report.
                LOGGER.error("No course run details found for enrollment [%d]: [%s]",
                             arg_3.pk, arg_4)
                continue

            arg_6 = DataSharingConsent.objects.proxied_get(
                username=arg_3.enterprise_customer_user.username,
                arg_4=arg_3.course_id,
                enterprise_customer=arg_3.enterprise_customer_user.enterprise_customer
            )

            if not arg_6.granted or arg_3.audit_reporting_disabled:
                continue

            # For instructor-paced courses, let the certificate determine course completion
            if arg_2.get('pacing') == 'instructor':
                arg_7, arg_8, arg_9 = arg_0._collect_certificate_data(arg_3)

            # For self-paced courses, check the Grades API
            else:
                arg_7, arg_8, arg_9 = arg_0._collect_grades_data(arg_3, arg_2)

            arg_10 = arg_0.get_learner_data_records(
                arg_3=arg_3,
                arg_7=arg_7,
                arg_8=arg_8,
                arg_9=arg_9,
            )
            if arg_10:
                # There are some cases where we won't receive a record from the above
                # method; right now, that should only happen if we have an Enterprise-linked
                # user for the integrated channel, and transmission of that user's
                # data requires an upstream user identifier that we don't have (due to a
                # failure of SSO or similar). In such a case, `get_learner_data_record`
                # would return None, and we'd simply skip yielding it here.
                for arg_11 in arg_10:
                    yield arg_11

Collect learner data for the EnterpriseCustomer where data sharing consent is granted .


return HeronTuple(id=str(tuple_key), component=component_name, stream=stream_id,
                      task=gen_task, values=values, creation_time=time.time(), roots=roots)

def Func ( arg_0 , arg_1 , arg_2 , arg_3 = None ) : arg_4 = arg_0 . component_name arg_5 = arg_0 . id arg_6 = arg_3 [ 0 ] . taskid if arg_3 is not None and len ( arg_3 ) > 0 else None return HeronTuple ( id = str ( arg_1 ) , component = arg_4 , arg_0 = arg_5 , task = arg_6 , arg_2 = arg_2 , creation_time = time . time ( ) , arg_3 = arg_3 )

def Func(arg_0, arg_1, arg_2, arg_3=None):
    """Creates a HeronTuple

    :param stream: protobuf message ``StreamId``
    :param tuple_key: tuple id
    :param values: a list of values
    :param roots: a list of protobuf message ``RootId``
    """
    arg_4 = arg_0.component_name
    arg_5 = arg_0.id
    arg_6 = arg_3[0].taskid if arg_3 is not None and len(arg_3) > 0 else None
    return HeronTuple(id=str(arg_1), component=arg_4, arg_0=arg_5,
                      task=arg_6, arg_2=arg_2, creation_time=time.time(), arg_3=arg_3)


def Func ( arg_0 , arg_1 = '' ) : arg_0 = arg_0 or '' if not isinstance ( arg_0 , str ) : if type ( arg_0 ) == type : arg_0 = '%s.%s' % ( arg_0 . __module__ , arg_0 . __name__ ) else : arg_0 = '%s.%s' % ( arg_0 . __class__ . __module__ , arg_0 . __class__ . __name__ ) if arg_1 : arg_0 = '%s.%s' % ( arg_0 , arg_1 ) return MetricsInterface ( arg_0 )

def Func(arg_0, arg_1=''):
    """Return MetricsInterface instance with specified name.

    The name is used as the prefix for all keys generated with this
    :py:class:`markus.main.MetricsInterface`.

    The :py:class:`markus.main.MetricsInterface` is not tied to metrics
    backends. The list of active backends are globally configured. This allows
    us to create :py:class:`markus.main.MetricsInterface` classes without
    having to worry about bootstrapping order of the app.

    :arg class/instance/str thing: The name to use as a key prefix.

        If this is a class, it uses the dotted Python path. If this is an
        instance, it uses the dotted Python path plus ``str(instance)``.

    :arg str extra: Any extra bits to add to the end of the name.

    :returns: a ``MetricsInterface`` instance

    Examples:

    >>> from markus import Func

    Create a MetricsInterface with the name "myapp" and generate a count with
    stat "myapp.thing1" and value 1:

    >>> metrics = Func('myapp')
    >>> metrics.incr('thing1', value=1)

    Create a MetricsInterface with the prefix of the Python module it's being
    called in:

    >>> metrics = Func(__name__)

    Create a MetricsInterface with the prefix as the qualname of the class:

    >>> class Foo:
    ...     def __init__(self):
    ...         self.metrics = Func(self)

    Create a prefix of the class path plus some identifying information:

    >>> class Foo:
    ...     def __init__(self, myname):
    ...         self.metrics = Func(self, extra=myname)
    ...
    >>> foo = Foo('jim')

    Assume that ``Foo`` is defined in the ``myapp`` module. Then this will
    generate the name ``myapp.Foo.jim``.

    """
    arg_0 = arg_0 or ''

    if not isinstance(arg_0, str):
        # If it's not a str, it's either a class or an instance. Handle
        # accordingly.
        if type(arg_0) == type:
            arg_0 = '%s.%s' % (arg_0.__module__, arg_0.__name__)
        else:
            arg_0 = '%s.%s' % (
                arg_0.__class__.__module__, arg_0.__class__.__name__
            )

    if arg_1:
        arg_0 = '%s.%s' % (arg_0, arg_1)

    return MetricsInterface(arg_0)

Return MetricsInterface instance with specified name.

    The name is used as the prefix for all keys generated with this
    :py:class:`markus.main.MetricsInterface`.

    The :py:class:`markus.main.MetricsInterface` is not tied to metrics
    backends. The list of active backends are globally configured. This allows
    us to create :py:class:`markus.main.MetricsInterface` classes without
    having to worry about bootstrapping order of the app.

    :arg class/instance/str thing: The name to use as a key prefix.

        If this is a class, it uses the dotted Python path. If this is an
        instance, it uses the dotted Python path plus ``str(instance)``.

    :arg str extra: Any extra bits to add to the end of the name.

    :returns: a ``MetricsInterface`` instance

    Examples:

    >>> from markus import get_metrics

    Create a MetricsInterface with the name "myapp" and generate a count with
    stat "myapp.thing1" and value 1:

    >>> metrics = get_metrics('myapp')
    >>> metrics.incr('thing1', value=1)

    Create a MetricsInterface with the prefix of the Python module it's being
    called in:

    >>> metrics = get_metrics(__name__)

    Create a MetricsInterface with the prefix as the qualname of the class:

    >>> class Foo:
    ...     def __init__(self):
    ...         self.metrics = get_metrics(self)

    Create a prefix of the class path plus some identifying information:

    >>> class Foo:
    ...     def __init__(self, myname):
    ...         self.metrics = get_metrics(self, extra=myname)
    ...
    >>> foo = Foo('jim')

    Assume that ``Foo`` is defined in the ``myapp`` module. Then this will
    generate the name ``myapp.Foo.jim``.

Return MetricsInterface instance with specified name .


def
Func
(
arg_0
)
:
arg_1
=
Innuendo
(
)
if
not
arg_0
.
tasks
:
arg_2
=
" "
.
join
(
arg_1
.
process_descriptions
.
keys
(
)
)
else
:
arg_2
=
arg_0
.
tasks
arg_3
=
arg_1
.
validate_pipeline
(
arg_2
)
if
not
arg_3
:
sys
.
exit
(
1
)
arg_4
=
arg_1
.
run_auto_pipeline
(
arg_2
)
return
arg_4

def Func(arg_0):
    """Brews a given list of processes according to the recipe

    Parameters
    ----------
    args : argparse.Namespace
        The arguments passed through argparser that will be used to check the
        the recipe, tasks and brew the process

    Returns
    -------
    str
        The final pipeline string, ready for the engine.
    list
        List of process strings.
    """

    # Create recipe class instance
    arg_1 = Innuendo()

    if not arg_0.tasks:
        arg_2 = " ".join(
            arg_1.process_descriptions.keys())
    else:
        arg_2 = arg_0.tasks

    # Validate the provided pipeline processes
    arg_3 = arg_1.validate_pipeline(arg_2)
    if not arg_3:
        sys.exit(1)
    # Get the final pipeline string
    arg_4 = arg_1.run_auto_pipeline(arg_2)

    return arg_4


return _MinidomXmlToObject.convert_response_to_feeds(
            response,
            partial(
                _ServiceBusManagementXmlSerializer.xml_to_metrics,
                object_type=MetricRollups
            )
        )

def Func(arg_0, arg_1, arg_2, arg_3):
        '''
        This operation gets rollup data for Service Bus metrics queue.
        Rollup data includes the time granularity for the telemetry aggregation as well as
        the retention settings for each time granularity.

        name:
            Name of the service bus namespace.
        queue_name:
            Name of the service bus queue in this namespace.
        metric:
            name of a supported metric
        '''
        arg_4 = arg_0._perform_get(
            arg_0._get_get_metrics_rollup_queue_path(arg_1, arg_2, arg_3),
            None)

        return _MinidomXmlToObject.convert_response_to_feeds(
            arg_4,
            partial(
                _ServiceBusManagementXmlSerializer.xml_to_metrics,
                object_type=MetricRollups
            )
        )

This operation gets rollup data for Service Bus metrics queue . Rollup data includes the time granularity for the telemetry aggregation as well as the retention settings for each time granularity .


def
Func
(
arg_0
,
arg_1
,
arg_2
)
:
arg_3
,
arg_4
=
os
.
path
.
split
(
arg_0
)
arg_5
=
get_filtered_filename
(
arg_4
,
arg_1
)
arg_6
=
os
.
path
.
join
(
*
[
arg_3
,
VERSATILEIMAGEFIELD_FILTERED_DIRNAME
,
arg_5
]
)
arg_6
=
arg_6
.
replace
(
' '
,
''
)
return
arg_6

def Func(arg_0, arg_1, arg_2):
    """
    Return the 'filtered path'
    """
    arg_3, arg_4 = os.path.split(arg_0)

    arg_5 = get_filtered_filename(arg_4, arg_1)
    arg_6 = os.path.join(*[
        arg_3,
        VERSATILEIMAGEFIELD_FILTERED_DIRNAME,
        arg_5
    ])
    # Removing spaces so this path is memcached key friendly
    arg_6 = arg_6.replace(' ', '')
    return arg_6


(self, argv=None, aliases=None, flags=None)

def Func(arg_0, arg_1=None, arg_2=None, arg_3=None):
        """Parse command line arguments and return as a Config object.

        Parameters
        ----------

        args : optional, list
          If given, a list with the structure of sys.argv[1:] to parse
          arguments from. If not given, the instance's self.argv attribute
          (given at construction time) is used."""
        arg_0.clear()
        if arg_1 is None:
            arg_1 = arg_0.argv
        if arg_2 is None:
            arg_2 = arg_0.aliases
        if arg_3 is None:
            arg_3 = arg_0.flags
        arg_0._create_parser(arg_2, arg_3)
        arg_0._parse_args(arg_1)
        arg_0._convert_to_config()
        return arg_0.config

Parse command line arguments and return as a Config object .


def
Func
(
arg_0
)
:
if
arg_0
.
startswith
(
':'
)
:
return
,
if
':'
not
in
arg_0
:
return
arg_0
,
''
arg_1
,
arg_2
=
arg_0
.
split
(
':'
,
1
)
arg_2
=
arg_2
[
1
:
]
if
arg_2
.
startswith
(
' '
)
else
arg_2
return
arg_1
,
arg_2

def Func(arg_0):
    """ Parse the field and value from a line. """
    if arg_0.startswith(':'):
        # Ignore the line
        return None, None

    if ':' not in arg_0:
        # Treat the entire line as the field, use empty string as value
        return arg_0, ''

    # Else field is before the ':' and value is after
    arg_1, arg_2 = arg_0.split(':', 1)

    # If value starts with a space, remove it.
    arg_2 = arg_2[1:] if arg_2.startswith(' ') else arg_2

    return arg_1, arg_2


def Func(arg_0: arg_1):
    """Adds all of the reactants and products of reactions to the graph."""
    arg_2 = list(get_nodes_by_function(arg_0, REACTION))
    for arg_3 in arg_2:
        for arg_4 in arg_3.reactants:
            arg_0.add_has_reactant(arg_3, arg_4)

        for arg_4 in arg_3.products:
            arg_0.add_has_product(arg_3, arg_4)

Adds all of the reactants and products of reactions to the graph .


def Func ( arg_0 ) : if isinstance ( arg_0 , list ) : arg_0 = ',' . join ( arg_0 ) arg_1 = { "hq" : 1 , "songIds" : arg_0 } arg_2 = requests . post ( MUSIC_INFO_URL , arg_1 = arg_1 ) arg_3 = arg_2 . json ( ) arg_4 = arg_3 [ "data" ] arg_5 = [ ] for arg_6 in arg_4 [ "songList" ] : arg_7 , arg_8 = _song_link ( arg_6 , arg_4 [ "xcode" ] ) arg_5 . append ( { "name" : arg_6 [ "songName" ] , "singer" : arg_6 [ "artistName" ] , "lrc_link" : arg_6 [ "lrcLink" ] , "song_link" : arg_7 , "size" : arg_8 } ) return arg_5

def Func(arg_0):
    """
    Get music info from baidu music api
    """
    if isinstance(arg_0, list):
        arg_0 = ','.join(arg_0)
    arg_1 = {
        "hq": 1,
        "songIds": arg_0
    }
    arg_2 = requests.post(MUSIC_INFO_URL, arg_1=arg_1)
    arg_3 = arg_2.json()
    arg_4 = arg_3["data"]

    arg_5 = []
    for arg_6 in arg_4["songList"]:
        arg_7, arg_8 = _song_link(arg_6, arg_4["xcode"])
        arg_5.append({
            "name": arg_6["songName"],
            "singer": arg_6["artistName"],
            "lrc_link": arg_6["lrcLink"],
            "song_link": arg_7,
            "size": arg_8
        })
    return arg_5


def Func ( arg_0 ) : arg_0 = str ( arg_0 ) if arg_0 . upper ( ) in [ 'TRUE' , 'FALSE' ] : return 'BOOLEAN' elif re . match ( r'(-)?(\d+)(\.\d+)' , arg_0 ) : return 'REAL' elif re . match ( r'(-)?(\d+)' , arg_0 ) : return 'INTEGER' elif re . match ( r'\'((\'\')|[^\'])*\'' , arg_0 ) : return 'STRING' elif re . match ( r'\"([^\\\n]|(\\.))*?\"' , arg_0 ) : return 'UNIQUE_ID'

def Func(arg_0):
    '''
    Guess the type name of a serialized value.
    '''
    arg_0 = str(arg_0)

    if arg_0.upper() in ['TRUE', 'FALSE']:
        return 'BOOLEAN'

    elif re.match(r'(-)?(\d+)(\.\d+)', arg_0):
        return 'REAL'

    elif re.match(r'(-)?(\d+)', arg_0):
        return 'INTEGER'

    elif re.match(r'\'((\'\')|[^\'])*\'', arg_0):
        return 'STRING'

    elif re.match(r'\"([^\\\n]|(\\.))*?\"', arg_0):
        return 'UNIQUE_ID'

Guess the type name of a serialized value .


def Func ( arg_0 , arg_1 , arg_2 ) : while True : arg_3 = arg_2 ( ) arg_1 . write ( arg_3 ) time . sleep ( 1 )

def Func(arg_0, arg_1, arg_2):
        """Write items to the queue

        :param writer: the writer object
        :param items_generator: items to be written in the queue
        """
        while True:
            arg_3 = arg_2()
            arg_1.write(arg_3)
            time.sleep(1)


Attempts to ping the server using current credentials, and responds with the path of the currently
        authenticated device

return self.handleresult(self.r.get(self.url,
                                            params={"q": "this"})).text

def Func ( arg_0 ) : return arg_0 . handleresult ( arg_0 . r . get ( arg_0 . url , params = { "q" : "this" } ) ) . text

def Func(arg_0):
        """Attempts to Func the server using current credentials, and responds with the path of the currently
        authenticated device"""
        return arg_0.handleresult(arg_0.r.get(arg_0.url,
                                            params={"q": "this"})).text

Attempts to ping the server using current credentials and responds with the path of the currently authenticated device


return (rv_lambda.log_prob(lambda_1) + rv_lambda.log_prob(lambda_2) +
          rv_tau.log_prob(tau) +
          tf.reduce_sum(input_tensor=rv_observation.log_prob(count_data)))

def Func ( arg_0 , arg_1 , arg_2 , arg_3 ) : arg_4 = ( 1. / tf . reduce_mean ( input_tensor = arg_0 ) ) arg_5 = tfd . Exponential ( rate = arg_4 ) arg_6 = tfd . Uniform ( ) arg_7 = tf . gather ( [ arg_1 , arg_2 ] , indices = tf . cast ( arg_3 * tf . cast ( tf . size ( input = arg_0 ) , dtype = tf . float32 ) <= tf . cast ( tf . range ( tf . size ( input = arg_0 ) ) , dtype = tf . float32 ) , dtype = tf . int32 ) ) arg_8 = tfd . Poisson ( rate = arg_7 ) return ( arg_5 . log_prob ( arg_1 ) + arg_5 . log_prob ( arg_2 ) + arg_6 . log_prob ( arg_3 ) + tf . reduce_sum ( input_tensor = arg_8 . log_prob ( arg_0 ) ) )

def Func(arg_0, arg_1, arg_2, arg_3):
  """Joint log probability function."""
  arg_4 = (1. / tf.reduce_mean(input_tensor=arg_0))
  arg_5 = tfd.Exponential(rate=arg_4)

  arg_6 = tfd.Uniform()

  arg_7 = tf.gather(
      [arg_1, arg_2],
      indices=tf.cast(
          arg_3 * tf.cast(tf.size(input=arg_0), dtype=tf.float32) <= tf.cast(
              tf.range(tf.size(input=arg_0)), dtype=tf.float32),
          dtype=tf.int32))
  arg_8 = tfd.Poisson(rate=arg_7)

  return (arg_5.log_prob(arg_1) + arg_5.log_prob(arg_2) +
          arg_6.log_prob(arg_3) +
          tf.reduce_sum(input_tensor=arg_8.log_prob(arg_0)))


(
    value_and_gradients_function,
    search_interval,
    active,
    f_lim)

return prefer_static.cond(
      tf.reduce_any(input_tensor=still_active),
      _apply_update,
      lambda: next_inteval)

def Func ( arg_0 , arg_1 , arg_2 , arg_3 ) : arg_4 = ( arg_1 . left . x + arg_1 . right . x ) / 2 arg_5 = arg_0 ( arg_4 ) arg_6 = hzl . is_finite ( arg_5 ) arg_7 = arg_2 & arg_6 arg_8 = arg_2 & ~ arg_6 arg_9 = arg_1 . _replace ( failed = arg_1 . failed | arg_8 , func_evals = arg_1 . func_evals + 1 ) def _apply_update ( ) : arg_10 = hzl . update ( arg_0 , arg_9 . left , arg_9 . right , arg_5 , arg_3 , arg_2 = arg_7 ) return HagerZhangLineSearchResult ( converged = arg_9 . converged , failed = arg_9 . failed | arg_10 . failed , iterations = arg_9 . iterations + arg_10 . iteration , func_evals = arg_9 . func_evals + arg_10 . num_evals , left = arg_10 . left , right = arg_10 . right ) return prefer_static . cond ( tf . reduce_any ( input_tensor = arg_7 ) , _apply_update , lambda : arg_9 )

def Func(
    arg_0,
    arg_1,
    arg_2,
    arg_3):
  """Performs bisection and updates the interval."""
  arg_4 = (arg_1.left.x + arg_1.right.x) / 2
  arg_5 = arg_0(arg_4)
  arg_6 = hzl.is_finite(arg_5)

  arg_7 = arg_2 & arg_6
  arg_8 = arg_2 & ~arg_6
  arg_9 = arg_1._replace(
      failed=arg_1.failed | arg_8,
      func_evals=arg_1.func_evals + 1)

  def _apply_update():
    arg_10 = hzl.update(
        arg_0, arg_9.left, arg_9.right,
        arg_5, arg_3, arg_2=arg_7)
    return HagerZhangLineSearchResult(
        converged=arg_9.converged,
        failed=arg_9.failed | arg_10.failed,
        iterations=arg_9.iterations + arg_10.iteration,
        func_evals=arg_9.func_evals + arg_10.num_evals,
        left=arg_10.left,
        right=arg_10.right)

  return prefer_static.cond(
      tf.reduce_any(input_tensor=arg_7),
      _apply_update,
      lambda: arg_9)

Performs bisection and updates the interval .


def Func ( arg_0 , arg_1 ) : for arg_2 in arg_0 . nodes ( data = True ) : if arg_2 [ 0 ] == arg_1 : return arg_2 [ 1 ]

def Func(arg_0, arg_1):
    """
    Helper function that returns the node data
    of the node with the name supplied
    """
    for arg_2 in arg_0.nodes(data=True):
        if arg_2[0] == arg_1:
            return arg_2[1]


return [_dequote(x.strip()).replace('\000', ',')
            for x in value.split(',')]

def Func ( arg_0 ) : arg_1 = _QUOTED_SEGMENT_RE . findall ( arg_0 ) for arg_2 in arg_1 : arg_3 , arg_4 , arg_5 = arg_0 . partition ( arg_2 ) arg_0 = '' . join ( [ arg_3 , arg_4 . replace ( ',' , '\000' ) , arg_5 ] ) return [ _dequote ( arg_6 . strip ( ) ) . replace ( '\000' , ',' ) for arg_6 in arg_0 . split ( ',' ) ]

def Func(arg_0):
    """
    Parse a comma-separated list header.

    :param str value: header value to split into elements
    :return: list of header elements as strings

    """
    arg_1 = _QUOTED_SEGMENT_RE.findall(arg_0)
    for arg_2 in arg_1:
        arg_3, arg_4, arg_5 = arg_0.partition(arg_2)
        arg_0 = ''.join([arg_3, arg_4.replace(',', '\000'), arg_5])
    return [_dequote(arg_6.strip()).replace('\000', ',')
            for arg_6 in arg_0.split(',')]


def Func(arg_0, arg_1, arg_2):

        """Positions the layer at the given coordinates.

        The x and y parameters define where to position
        the top left corner of the layer,
        measured from the top left of the canvas.

        """

        arg_0.x = arg_1
        arg_0.y = arg_2

Positions the layer at the given coordinates . The x and y parameters define where to position the top left corner of the layer measured from the top left of the canvas .


def Func ( arg_0 , arg_1 : arg_2 = None ) -> bool : if arg_1 is None : arg_3 = datetime ( 1970 , 1 , 1 , 0 , 0 , 0 ) arg_4 = datetime . utcnow ( ) arg_1 = arg_2 ( ( arg_4 - arg_3 ) . total_seconds ( ) ) if isinstance ( arg_0 . Func_from , arg_2 ) and arg_1 < arg_0 . Func_from : return False if isinstance ( arg_0 . Func_to , arg_2 ) and arg_1 > arg_0 . Func_to : return False return True

def Func(arg_0, arg_1: arg_2 = None) -> bool:
        """
        Is the token Func? This method only checks the timestamps within the
        token and compares them against the current time if none is provided.

        :param time: The timestamp to Funcate against
        :type time: Union[int, None]
        :return: The Funcity of the token.
        :rtype: bool
        """
        if arg_1 is None:
            arg_3 = datetime(1970, 1, 1, 0, 0, 0)
            arg_4 = datetime.utcnow()
            arg_1 = arg_2((arg_4 - arg_3).total_seconds())
        if isinstance(arg_0.Func_from, arg_2) and arg_1 < arg_0.Func_from:
            return False
        if isinstance(arg_0.Func_to, arg_2) and arg_1 > arg_0.Func_to:
            return False
        return True

Is the token valid? This method only checks the timestamps within the
        token and compares them against the current time if none is provided.

        :param time: The timestamp to validate against
        :type time: Union[int, None]
        :return: The validity of the token.
        :rtype: bool

Is the token valid? This method only checks the timestamps within the token and compares them against the current time if none is provided .


def Func(arg_0, arg_1: arg_2):
        """
        Attempts to assign a loader class to a resource description

        :param meta: The resource description instance
        """
        arg_1.loader_cls = arg_0.get_loader(arg_1, raise_on_error=True)


def Func ( arg_0 , arg_1 ) : arg_0 . opt_obj . Func ( arg_1 ) return arg_0 . opt_obj . get_error ( )

def Func(arg_0, arg_1):
        """Updates the opt_obj, returns new error."""
        arg_0.opt_obj.Func(arg_1)
        return arg_0.opt_obj.get_error()


def Func ( arg_0 , arg_1 , arg_2 ) : for arg_3 , ( arg_4 , arg_5 ) in reversed ( enumerate ( arg_0 . controlled_vocabularies [ arg_1 ] [ 1 ] ) ) : if arg_4 == arg_2 : del ( arg_0 . controlled_vocabularies [ arg_1 ] [ 1 ] [ arg_3 ] )

def Func(arg_0, arg_1, arg_2):
        """Remove a controlled vocabulary description.

        :param str cv_id: Name of the controlled vocabulary.
        :paarm str cve_id: Name of the entry.
        :throws KeyError: If there is no controlled vocabulary with that name.
        """
        for arg_3, (arg_4, arg_5) in reversed(enumerate(
                arg_0.controlled_vocabularies[arg_1][1])):
            if arg_4 == arg_2:
                del(arg_0.controlled_vocabularies[arg_1][1][arg_3])

Remove a controlled vocabulary description .


Move object to a certain position, updating all affected objects to move accordingly up or down.

def Func ( arg_0 , arg_1 ) : if arg_1 is None or arg_0 . order == arg_1 : return arg_2 = arg_0 . get_ordering_queryset ( ) if arg_0 . order > arg_1 : arg_2 . filter ( order__lt = arg_0 . order , order__gte = arg_1 ) . update ( arg_1 = F ( 'order' ) + 1 ) else : arg_2 . filter ( order__gt = arg_0 . order , order__lte = arg_1 ) . update ( arg_1 = F ( 'order' ) - 1 ) arg_0 . order = arg_1 arg_0 . save ( )

def Func(arg_0, arg_1):
        """
        Move object Func a certain position, updating all affected objects Func move accordingly up or down.
        """
        if arg_1 is None or arg_0.order == arg_1:
            # object is already at desired position
            return
        arg_2 = arg_0.get_ordering_queryset()
        if arg_0.order > arg_1:
            arg_2.filter(order__lt=arg_0.order, order__gte=arg_1).update(arg_1=F('order') + 1)
        else:
            arg_2.filter(order__gt=arg_0.order, order__lte=arg_1).update(arg_1=F('order') - 1)
        arg_0.order = arg_1
        arg_0.save()

Move object to a certain position updating all affected objects to move accordingly up or down .


def
Func
(
arg_0
)
:
if
arg_0
.
_page_control
is
not
and
arg_0
.
_page_control
.
hasFocus
(
)
:
arg_0
.
_page_control
.
Func
(
)
elif
arg_0
.
_control
.
hasFocus
(
)
:
arg_1
=
arg_0
.
_control
.
textCursor
(
)
.
selection
(
)
.
toPlainText
(
)
if
arg_1
:
arg_2
=
map
(
arg_0
.
_transform_prompt
,
arg_1
.
splitlines
(
)
)
arg_1
=
'\n'
.
join
(
arg_2
)
QtGui
.
QApplication
.
clipboard
(
)
.
setText
(
arg_1
)
else
:
arg_0
.
log
.
debug
(
"frontend widget : unknown Func target"
)

def Func(arg_0):
        """ Copy the currently selected text to the clipboard, removing prompts.
        """
        if arg_0._page_control is not None and arg_0._page_control.hasFocus():
            arg_0._page_control.Func()
        elif arg_0._control.hasFocus():
            arg_1 = arg_0._control.textCursor().selection().toPlainText()
            if arg_1:
                arg_2 = map(arg_0._transform_prompt, arg_1.splitlines())
                arg_1 = '\n'.join(arg_2)
                QtGui.QApplication.clipboard().setText(arg_1)
        else:
            arg_0.log.debug("frontend widget : unknown Func target")

Copy the currently selected text to the clipboard removing prompts .


def
Func
(
arg_0
,
arg_1
)
:
arg_2
=
200
if
arg_1
==
'all'
:
arg_3
=
{
'workers'
:
[
{
'id'
:
job
,
'report'
:
arg_0
.
_inspect_worker
(
job
)
}
for
job
in
arg_0
.
jobs
]
}
elif
arg_1
in
arg_0
.
jobs
:
arg_3
=
{
'id'
:
arg_1
,
'report'
:
arg_0
.
_inspect_worker
(
arg_1
)
}
else
:
arg_3
=
{
'error'
:
'job {} unknown'
.
format
(
arg_1
)
}
arg_2
=
404
return
flask
.
jsonify
(
arg_3
)
,
arg_2

def Func(arg_0, arg_1):
        ''' Return status report '''
        arg_2 = 200

        if arg_1 == 'all':
            arg_3 = {'workers': [{
                'id': job,
                'report': arg_0._inspect_worker(job)}
                for job in arg_0.jobs]
            }

        elif arg_1 in arg_0.jobs:
            arg_3 = {
                'id': arg_1,
                'report': arg_0._inspect_worker(arg_1)
            }

        else:
            arg_3 = {'error': 'job {} unknown'.format(arg_1)}
            arg_2 = 404

        return flask.jsonify(arg_3), arg_2


(self, body='', headers=None, status_code=200)

def Func ( arg_0 , arg_1 = '' , arg_2 = None , arg_3 = 200 ) : arg_4 = Response ( ) arg_4 . status_code = arg_3 if arg_2 is not None : arg_4 . headers . update ( arg_2 ) arg_4 . raw = StringIO ( arg_1 ) return arg_4

def Func(arg_0, arg_1='', arg_2=None, arg_3=200):
        """Return a response object from the given parameters.

        :param body: Buffer/string containing the response body.
        :type body: str
        :param headers: Dict of headers to include in the requests.
        :type headers: dict
        :param status_code: HTTP status code.
        :type status_code: int
        :rtype: requests.Response
        """
        arg_4 = Response()
        arg_4.status_code = arg_3
        if arg_2 is not None:
            arg_4.headers.update(arg_2)
        arg_4.raw = StringIO(arg_1)
        return arg_4

Return a response object from the given parameters .


def
Func
(
arg_0
)
:
try
:
arg_0
.
conn
.
Func
(
)
arg_0
.
logger
.
debug
(
"Close connect succeed."
)
except
pymssql
.
Error
as
e
:
arg_0
.
unknown
(
"Close connect error: %s"
%
e
)

def Func(arg_0):
        """Close the connection."""
        try:
            arg_0.conn.Func()
            arg_0.logger.debug("Close connect succeed.")
        except pymssql.Error as e:
            arg_0.unknown("Close connect error: %s" % e)


(
            self, resource_group_name, name, slot, target_slot, preserve_vnet, custom_headers=None, raw=False, polling=True, **operation_config)

return LROPoller(self._client, raw_result, get_long_running_output, polling_method)

def Func(
            arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6=None, arg_7=False, arg_8=True, **arg_9):
        """Swaps two deployment slots of an app.

        Swaps two deployment slots of an app.

        :param resource_group_name: Name of the resource group to which the
         resource belongs.
        :type resource_group_name: str
        :param name: Name of the app.
        :type name: str
        :param slot: Name of the source slot. If a slot is not specified, the
         production slot is used as the source slot.
        :type slot: str
        :param target_slot: Destination deployment slot during swap operation.
        :type target_slot: str
        :param preserve_vnet: true to preserve Virtual Network to
         the slot during swap; otherwise, false.
        :type preserve_vnet: bool
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: The poller return type is ClientRawResponse, the
         direct response alongside the deserialized response
        :param polling: True for ARMPolling, False for no polling, or a
         polling object for personal polling strategy
        :return: An instance of LROPoller that returns None or
         ClientRawResponse<None> if raw==True
        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or
         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        arg_10 = arg_0._Func_initial(
            arg_1=arg_1,
            arg_2=arg_2,
            arg_3=arg_3,
            arg_4=arg_4,
            arg_5=arg_5,
            arg_6=arg_6,
            arg_7=True,
            **arg_9
        )

        def get_long_running_output(arg_11):
            if arg_7:
                arg_12 = ClientRawResponse(None, arg_11)
                return arg_12

        arg_13 = arg_9.get(
            'long_running_operation_timeout',
            arg_0.config.long_running_operation_timeout)
        if arg_8 is True: arg_14 = ARMPolling(arg_13, **arg_9)
        elif arg_8 is False: arg_14 = NoPolling()
        else: arg_14 = arg_8
        return LROPoller(arg_0._client, arg_10, get_long_running_output, arg_14)


def Func ( arg_0 ) : arg_1 = DottedRule ( arg_0 . start , 0 , END_OF_INPUT ) return arg_0 . closure ( [ arg_1 ] )

def Func(arg_0):
        """Computes the initial closure using the START_foo production."""
        arg_1 = DottedRule(arg_0.start, 0, END_OF_INPUT)
        return arg_0.closure([arg_1])

Computes the initial closure using the START_foo production .


def Func ( arg_0 , arg_1 ) : arg_0 . _valid_group_id ( arg_1 ) arg_2 = "{}/group/{}/member" . format ( arg_0 . API , arg_1 ) arg_3 = arg_0 . _get_resource ( arg_2 ) arg_4 = [ ] for arg_5 in arg_3 . get ( "data" ) : arg_4 . append ( arg_0 . _group_member_from_json ( arg_5 ) ) return arg_4

def Func(arg_0, arg_1):
        """
        Returns a list of restclients.GroupMember objects for the group
        identified by the passed group ID.
        """
        arg_0._valid_group_id(arg_1)

        arg_2 = "{}/group/{}/member".format(arg_0.API, arg_1)

        arg_3 = arg_0._get_resource(arg_2)

        arg_4 = []
        for arg_5 in arg_3.get("data"):
            arg_4.append(arg_0._group_member_from_json(arg_5))
        return arg_4

Returns a list of restclients . GroupMember objects for the group identified by the passed group ID .


def Func ( arg_0 , arg_1 ) : arg_2 = [ ] arg_3 = [ ] for arg_4 , ( arg_5 , ( arg_6 , arg_7 ) ) in RANGES . items ( ) : if arg_0 >= arg_6 and arg_1 <= arg_7 : arg_2 . append ( arg_4 ) arg_3 . append ( arg_5 ) return arg_2 , arg_3

def Func(arg_0, arg_1):
    """ Returns the valid encodings for a given encoding range.

    The encoding ranges are stored in the :py:data:`RANGES` dictionary, with
    the encoding name as a string and a list as a value containing the
    phred score and a tuple with the encoding range. For a given encoding
    range provided via the two first arguments, this function will return
    all possible encodings and phred scores.

    Parameters
    ----------
    rmin : int
        Minimum Unicode code in range.
    rmax : int
        Maximum Unicode code in range.

    Returns
    -------
    valid_encodings : list
        List of all possible encodings for the provided range.
    valid_phred : list
        List of all possible phred scores.

    """

    arg_2 = []
    arg_3 = []

    for arg_4, (arg_5, (arg_6, arg_7)) in RANGES.items():
        if arg_0 >= arg_6 and arg_1 <= arg_7:
            arg_2.append(arg_4)
            arg_3.append(arg_5)

    return arg_2, arg_3

Returns the valid encodings for a given encoding range .


return PrettyPrinter(indent=indent, width=width, depth=depth).pformat(o)

def Func(arg_0, arg_1=1, arg_2=80, arg_3=None):
    """Format a Python o into a pretty-printed representation."""
    return PrettyPrinter(arg_1=arg_1, arg_2=arg_2, arg_3=arg_3).Func(arg_0)

Format a Python o into a pretty - printed representation .


def
Func
(
arg_0
)
->
parsing
.
Node
:
arg_1
=
try
:
arg_1
=
arg_0
.
eval_rule
(
'bnf_dsl'
)
if
not
arg_1
:
arg_0
.
diagnostic
.
notify
(
error
.
Severity
.
ERROR
,
"Parse error in '%s' in EBNF bnf"
%
arg_0
.
_lastRule
,
error
.
LocationInfo
.
from_maxstream
(
arg_0
.
_stream
)
)
raise
arg_0
.
diagnostic
except
error
.
Diagnostic
as
d
:
d
.
notify
(
error
.
Severity
.
ERROR
,
"Parse error in '%s' in EBNF bnf"
%
arg_0
.
_lastRule
)
raise
d
return
arg_1

def Func(arg_0) -> parsing.Node:
        """
        Parse the DSL and provide a dictionnaries of all resulting rules.
        Call by the MetaGrammar class.

        TODO: could be done in the rules property of parsing.BasicParser???
        """
        arg_1 = None
        try:
            arg_1 = arg_0.eval_rule('bnf_dsl')
            if not arg_1:
                # we fail to parse, but error is not set
                arg_0.diagnostic.notify(
                    error.Severity.ERROR,
                    "Parse error in '%s' in EBNF bnf" % arg_0._lastRule,
                    error.LocationInfo.from_maxstream(arg_0._stream)
                )
                raise arg_0.diagnostic
        except error.Diagnostic as d:
            d.notify(
                error.Severity.ERROR,
                "Parse error in '%s' in EBNF bnf" % arg_0._lastRule
            )
            raise d
        return arg_1

Parse the DSL and provide a dictionnaries of all resulting rules . Call by the MetaGrammar class .


def Func(arg_0, arg_1, arg_2=None):
        """Add a new, empty knitting pattern to the set.

        :param id_: the id of the pattern
        :param name: the name of the pattern to add or if :obj:`None`, the
          :paramref:`id_` is used
        :return: a new, empty knitting pattern
        :rtype: knittingpattern.KnittingPattern.KnittingPattern
        """
        if arg_2 is None:
            arg_2 = arg_1
        arg_3 = arg_0._parser.new_pattern(arg_1, arg_2)
        arg_0._patterns.append(arg_3)
        return arg_3

Add a new empty knitting pattern to the set .


def
Func
(
arg_0
,
arg_1
)
:
arg_2
=
sum
(
[
arg_6
.
size
for
arg_6
in
arg_1
.
qregs
.
values
(
)
]
)
if
arg_2
>
arg_0
.
coupling_map
.
size
(
)
:
raise
TranspilerError
(
'Number of qubits greater than device.'
)
arg_3
=
arg_0
.
_best_subset
(
arg_2
)
arg_4
=
Layout
(
)
arg_5
=
0
for
arg_6
in
arg_1
.
qregs
.
values
(
)
:
for
arg_7
in
range
(
arg_6
.
size
)
:
arg_4
[
(
arg_6
,
arg_7
)
]
=
int
(
arg_3
[
arg_5
]
)
arg_5
+=
1
arg_0
.
property_set
[
'layout'
]
=
arg_4

def Func(arg_0, arg_1):
        """
        Pick a convenient layout depending on the best matching
        qubit connectivity, and set the property `layout`.

        Args:
            dag (DAGCircuit): DAG to find layout for.

        Raises:
            TranspilerError: if dag wider than self.coupling_map
        """
        arg_2 = sum([arg_6.size for arg_6 in arg_1.qregs.values()])
        if arg_2 > arg_0.coupling_map.size():
            raise TranspilerError('Number of qubits greater than device.')
        arg_3 = arg_0._best_subset(arg_2)
        arg_4 = Layout()
        arg_5 = 0
        for arg_6 in arg_1.qregs.values():
            for arg_7 in range(arg_6.size):
                arg_4[(arg_6, arg_7)] = int(arg_3[arg_5])
                arg_5 += 1
        arg_0.property_set['layout'] = arg_4

Pick a convenient layout depending on the best matching qubit connectivity and set the property layout .


def Func ( arg_0 ) : Func = [ ] arg_2 = getattr ( arg_0 . element , 'Children' ) for arg_3 in getattr ( arg_2 , 'BrowseNode' , [ ] ) : Func . append ( AmazonBrowseNode ( arg_3 ) ) return Func

def Func(arg_0):
        """This browse node's children in the browse node tree.

    :return:
    A list of this browse node's children in the browse node tree.
    """
        Func = []
        arg_2 = getattr(arg_0.element, 'Children')
        for arg_3 in getattr(arg_2, 'BrowseNode', []):
                Func.append(AmazonBrowseNode(arg_3))
        return Func

This browse node s children in the browse node tree .


def
Func
(
arg_0
,
arg_1
,
arg_2
=
arg_3
(
)
)
:
if
isinstance
(
arg_1
,
Constraint
)
:
if
arg_2
and
(
arg_3
(
arg_2
)
!=
arg_1
.
variables
)
:
raise
ValueError
(
"mismatched variables and Constraint"
)
elif
isinstance
(
arg_1
,
Callable
)
:
arg_1
=
Constraint
.
from_func
(
arg_1
,
arg_2
,
arg_0
.
vartype
)
elif
isinstance
(
arg_1
,
Iterable
)
:
arg_1
=
Constraint
.
from_configurations
(
arg_1
,
arg_2
,
arg_0
.
vartype
)
else
:
raise
TypeError
(
"Unknown constraint type given"
)
arg_0
.
constraints
.
append
(
arg_1
)
for
arg_4
in
arg_1
.
variables
:
arg_0
.
variables
[
arg_4
]
.
append
(
arg_1
)

def Func(arg_0, arg_1, arg_2=arg_3()):
        """Add a constraint.

        Args:
            constraint (function/iterable/:obj:`.Constraint`):
                Constraint definition in one of the supported formats:

                1. Function, with input arguments matching the order and
                   :attr:`~.ConstraintSatisfactionProblem.vartype` type of the `variables`
                   argument, that evaluates True when the constraint is satisfied.
                2. List explicitly specifying each allowed configuration as a tuple.
                3. :obj:`.Constraint` object built either explicitly or by :mod:`dwavebinarycsp.factories`.

            variables(iterable):
                Variables associated with the constraint. Not required when `constraint` is
                a :obj:`.Constraint` object.

        Examples:
            This example defines a function that evaluates True when the constraint is satisfied.
            The function's input arguments match the order and type of the `variables` argument.

            >>> import dwavebinarycsp
            >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)
            >>> def all_equal(a, b, c):  # works for both dwavebinarycsp.BINARY and dwavebinarycsp.SPIN
            ...     return (a == b) and (b == c)
            >>> csp.Func(all_equal, ['a', 'b', 'c'])
            >>> csp.check({'a': 0, 'b': 0, 'c': 0})
            True
            >>> csp.check({'a': 0, 'b': 0, 'c': 1})
            False

            This example explicitly lists allowed configurations.

            >>> import dwavebinarycsp
            >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.SPIN)
            >>> eq_configurations = {(-1, -1), (1, 1)}
            >>> csp.Func(eq_configurations, ['v0', 'v1'])
            >>> csp.check({'v0': -1, 'v1': +1})
            False
            >>> csp.check({'v0': -1, 'v1': -1})
            True

            This example uses a :obj:`.Constraint` object built by :mod:`dwavebinarycsp.factories`.

            >>> import dwavebinarycsp
            >>> import dwavebinarycsp.factories.constraint.gates as gates
            >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)
            >>> csp.Func(gates.and_gate(['a', 'b', 'c']))  # add an AND gate
            >>> csp.Func(gates.xor_gate(['a', 'c', 'd']))  # add an XOR gate
            >>> csp.check({'a': 1, 'b': 0, 'c': 0, 'd': 1})
            True

        """
        if isinstance(arg_1, Constraint):
            if arg_2 and (arg_3(arg_2) != arg_1.variables):
                raise ValueError("mismatched variables and Constraint")
        elif isinstance(arg_1, Callable):
            arg_1 = Constraint.from_func(arg_1, arg_2, arg_0.vartype)
        elif isinstance(arg_1, Iterable):
            arg_1 = Constraint.from_configurations(arg_1, arg_2, arg_0.vartype)
        else:
            raise TypeError("Unknown constraint type given")

        arg_0.constraints.append(arg_1)
        for arg_4 in arg_1.variables:
            arg_0.variables[arg_4].append(arg_1)

Add a constraint.

        Args:
            constraint (function/iterable/:obj:`.Constraint`):
                Constraint definition in one of the supported formats:

                1. Function, with input arguments matching the order and
                   :attr:`~.ConstraintSatisfactionProblem.vartype` type of the `variables`
                   argument, that evaluates True when the constraint is satisfied.
                2. List explicitly specifying each allowed configuration as a tuple.
                3. :obj:`.Constraint` object built either explicitly or by :mod:`dwavebinarycsp.factories`.

            variables(iterable):
                Variables associated with the constraint. Not required when `constraint` is
                a :obj:`.Constraint` object.

        Examples:
            This example defines a function that evaluates True when the constraint is satisfied.
            The function's input arguments match the order and type of the `variables` argument.

            >>> import dwavebinarycsp
            >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)
            >>> def all_equal(a, b, c):  # works for both dwavebinarycsp.BINARY and dwavebinarycsp.SPIN
            ...     return (a == b) and (b == c)
            >>> csp.add_constraint(all_equal, ['a', 'b', 'c'])
            >>> csp.check({'a': 0, 'b': 0, 'c': 0})
            True
            >>> csp.check({'a': 0, 'b': 0, 'c': 1})
            False

            This example explicitly lists allowed configurations.

            >>> import dwavebinarycsp
            >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.SPIN)
            >>> eq_configurations = {(-1, -1), (1, 1)}
            >>> csp.add_constraint(eq_configurations, ['v0', 'v1'])
            >>> csp.check({'v0': -1, 'v1': +1})
            False
            >>> csp.check({'v0': -1, 'v1': -1})
            True

            This example uses a :obj:`.Constraint` object built by :mod:`dwavebinarycsp.factories`.

            >>> import dwavebinarycsp
            >>> import dwavebinarycsp.factories.constraint.gates as gates
            >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)
            >>> csp.add_constraint(gates.and_gate(['a', 'b', 'c']))  # add an AND gate
            >>> csp.add_constraint(gates.xor_gate(['a', 'c', 'd']))  # add an XOR gate
            >>> csp.check({'a': 1, 'b': 0, 'c': 0, 'd': 1})
            True


return get_file_fingerprint(abspath, hashlib.md5, nbytes=nbytes, chunk_size=chunk_size)

def Func(arg_0, arg_1=0, arg_2=arg_3):
    """
    Return md5 hash value of a piece of a file

    Estimate processing time on:

    :param abspath: the absolute path to the file
    :param nbytes: only has first N bytes of the file. if 0 or None,
      hash all file

    CPU = i7-4600U 2.10GHz - 2.70GHz, RAM = 8.00 GB
    1 second can process 0.25GB data

    - 0.59G - 2.43 sec
    - 1.3G - 5.68 sec
    - 1.9G - 7.72 sec
    - 2.5G - 10.32 sec
    - 3.9G - 16.0 sec
    """
    return get_file_fingerprint(arg_0, hashlib.md5, arg_1=arg_1, arg_2=arg_2)