def Func ( arg_0 = 10 , arg_1 = [ 5 , 6 , 7 ] , arg_2 = 100 ) : arg_3 = range ( arg_0 ) arg_4 = [ ] for arg_5 in xrange ( arg_2 ) : if max ( arg_1 ) <= arg_0 : arg_4 . append ( random . sample ( arg_3 , random . choice ( arg_1 ) ) ) else : arg_6 = random . choice ( arg_1 ) arg_7 = [ ] for arg_8 in xrange ( arg_6 ) : arg_7 . append ( random . choice ( arg_3 ) ) arg_4 . append ( arg_7 ) return arg_4

def Func(arg_0=10, arg_1=[5,6,7], arg_2=100):
  """
  Generate a set of simple sequences. The elements of the sequences will be
  integers from 0 to 'nCoinc'-1. The length of each sequence will be
  randomly chosen from the 'seqLength' list.

  Parameters:
  -----------------------------------------------
  nCoinc:      the number of elements available to use in the sequences
  seqLength:   a list of possible sequence lengths. The length of each
               sequence will be randomly chosen from here.
  nSeq:        The number of sequences to generate

  retval:      a list of sequences. Each sequence is itself a list
               containing the coincidence indices for that sequence.
  """

  arg_3 = range(arg_0)
  arg_4  = []

  for arg_5 in xrange(arg_2):
    if max(arg_1) <= arg_0:
      arg_4.append(random.sample(arg_3, random.choice(arg_1)))
    else:
      arg_6 = random.choice(arg_1)
      arg_7 = []
      for arg_8 in xrange(arg_6):
        arg_7.append(random.choice(arg_3))
      arg_4.append(arg_7)

  return arg_4

Generate a set of simple sequences . The elements of the sequences will be integers from 0 to nCoinc - 1 . The length of each sequence will be randomly chosen from the seqLength list .


def Func ( arg_0 , arg_1 , arg_2 ) : arg_3 = [ l for l in arg_0 if l . type == arg_2 ] if not arg_3 : return False if arg_1 == 'any' : return arg_3 [ 0 ] arg_4 = filter_labels_by_language ( arg_3 , arg_1 ) if arg_4 : return arg_4 [ 0 ] arg_5 = filter_labels_by_language ( arg_3 , arg_1 , True ) if arg_5 : return arg_5 [ 0 ] return False

def Func(arg_0, arg_1, arg_2):
    '''
    Find the best label for a certain labeltype.

    :param list labels: A list of :class:`Label`.
    :param str language: An IANA language string, eg. `nl` or `nl-BE`.
    :param str labeltype: Type of label to look for, eg. `prefLabel`.
    '''
    arg_3 = [l for l in arg_0 if l.type == arg_2]
    if not arg_3:
        return False
    if arg_1 == 'any':
        return arg_3[0]
    arg_4 = filter_labels_by_language(arg_3, arg_1)
    if arg_4:
        return arg_4[0]
    arg_5 = filter_labels_by_language(arg_3, arg_1, True)
    if arg_5:
        return arg_5[0]
    return False

Find the best label for a certain labeltype .


Displays the contact form and sends the email

return render( request, 'contactform/contact.html', {'form': form})

def Func ( arg_0 ) : arg_1 = ContactForm ( arg_0 . POST or None ) if arg_1 . is_valid ( ) : arg_2 = arg_1 . cleaned_data [ 'subject' ] arg_3 = arg_1 . cleaned_data [ 'message' ] arg_4 = arg_1 . cleaned_data [ 'sender' ] arg_5 = arg_1 . cleaned_data [ 'cc_myself' ] arg_6 = settings . CONTACTFORM_RECIPIENTS if arg_5 : arg_6 . append ( arg_4 ) send_mail ( getattr ( settings , "CONTACTFORM_SUBJECT_PREFIX" , '' ) + arg_2 , arg_3 , arg_4 , arg_6 ) return render ( arg_0 , 'Funcform/thanks.html' ) return render ( arg_0 , 'Funcform/Func.html' , { 'form' : arg_1 } )

def Func(arg_0):
    """Displays the Func form and sends the email"""
    arg_1 = ContactForm(arg_0.POST or None)
    if arg_1.is_valid():
        arg_2 = arg_1.cleaned_data['subject']
        arg_3 = arg_1.cleaned_data['message']
        arg_4 = arg_1.cleaned_data['sender']
        arg_5 = arg_1.cleaned_data['cc_myself']

        arg_6 = settings.CONTACTFORM_RECIPIENTS
        if arg_5:
            arg_6.append(arg_4)

        send_mail(getattr(settings, "CONTACTFORM_SUBJECT_PREFIX", '') + arg_2, arg_3, arg_4, arg_6)

        return render(arg_0, 'Funcform/thanks.html')

    return render( arg_0, 'Funcform/Func.html', {'form': arg_1})


(filename, working_directory, url_source, extract=False, expected_bytes=None)

def Func(arg_0, arg_1, arg_2, arg_3=False, arg_4=None):
    """Checks if file exists in working_directory otherwise tries to dowload the file,
    and optionally also tries to extract the file if format is ".zip" or ".tar"

    Parameters
    -----------
    filename : str
        The name of the (to be) dowloaded file.
    working_directory : str
        A folder path to search for the file in and dowload the file to
    url : str
        The URL to download the file from
    extract : boolean
        If True, tries to uncompress the dowloaded file is ".tar.gz/.tar.bz2" or ".zip" file, default is False.
    expected_bytes : int or None
        If set tries to verify that the downloaded file is of the specified size, otherwise raises an Exception, defaults is None which corresponds to no check being performed.

    Returns
    ----------
    str
        File path of the dowloaded (uncompressed) file.

    Examples
    --------
    >>> down_file = tl.files.Func(filename='train-images-idx3-ubyte.gz',
    ...                                            working_directory='data/',
    ...                                            url_source='http://yann.lecun.com/exdb/mnist/')
    >>> tl.files.Func(filename='ADEChallengeData2016.zip',
    ...                                             working_directory='data/',
    ...                                             url_source='http://sceneparsing.csail.mit.edu/data/',
    ...                                             extract=True)

    """

    # We first define a download function, supporting both Python 2 and 3.
    def _download(arg_0, arg_1, arg_2):

        arg_5 = progressbar.ProgressBar()

        def _dlProgress(arg_6, arg_7, arg_8, arg_9=arg_5):
            if (arg_8 != 0):

                if not arg_9.max_value:
                    arg_10 = math.ceil(float(arg_8) / float(arg_7))
                    arg_9.max_value = int(arg_10)

                arg_9.update(arg_6, force=True)

        arg_12 = os.path.join(arg_1, arg_0)

        logging.info('Downloading %s...\n' % arg_0)

        urlretrieve(arg_2 + arg_0, arg_12, reporthook=_dlProgress)

    exists_or_mkdir(arg_1, verbose=False)
    arg_12 = os.path.join(arg_1, arg_0)

    if not os.path.exists(arg_12):

        _download(arg_0, arg_1, arg_2)
        arg_13 = os.stat(arg_12)
        logging.info('Succesfully downloaded %s %s bytes.' % (arg_0, arg_13.st_size))  # , 'bytes.')
        if (not (arg_4 is None) and (arg_4 != arg_13.st_size)):
            raise Exception('Failed to verify ' + arg_0 + '. Can you get to it with a browser?')
        if (arg_3):
            if tarfile.is_tarfile(arg_12):
                logging.info('Trying to extract tar file')
                tarfile.open(arg_12, 'r').extractall(arg_1)
                logging.info('... Success!')
            elif zipfile.is_zipfile(arg_12):
                logging.info('Trying to extract zip file')
                with zipfile.ZipFile(arg_12) as zf:
                    zf.extractall(arg_1)
                logging.info('... Success!')
            else:
                logging.info("Unknown compression_format only .tar.gz/.tar.bz2/.tar and .zip supported")
    return arg_12

Checks if file exists in working_directory otherwise tries to dowload the file,
    and optionally also tries to extract the file if format is ".zip" or ".tar"

    Parameters
    -----------
    filename : str
        The name of the (to be) dowloaded file.
    working_directory : str
        A folder path to search for the file in and dowload the file to
    url : str
        The URL to download the file from
    extract : boolean
        If True, tries to uncompress the dowloaded file is ".tar.gz/.tar.bz2" or ".zip" file, default is False.
    expected_bytes : int or None
        If set tries to verify that the downloaded file is of the specified size, otherwise raises an Exception, defaults is None which corresponds to no check being performed.

    Returns
    ----------
    str
        File path of the dowloaded (uncompressed) file.

    Examples
    --------
    >>> down_file = tl.files.maybe_download_and_extract(filename='train-images-idx3-ubyte.gz',
    ...                                            working_directory='data/',
    ...                                            url_source='http://yann.lecun.com/exdb/mnist/')
    >>> tl.files.maybe_download_and_extract(filename='ADEChallengeData2016.zip',
    ...                                             working_directory='data/',
    ...                                             url_source='http://sceneparsing.csail.mit.edu/data/',
    ...                                             extract=True)

Checks if file exists in working_directory otherwise tries to dowload the file and optionally also tries to extract the file if format is . zip or . tar


(y, orig_sr, target_sr, res_type='kaiser_best', fix=True, scale=False, **kwargs)

def Func(arg_0, arg_1, arg_2, arg_3='kaiser_best', arg_4=True, arg_5=False, **arg_6):
    """Resample a time series from orig_sr to target_sr

    Parameters
    ----------
    y : np.ndarray [shape=(n,) or shape=(2, n)]
        audio time series.  Can be mono or stereo.

    orig_sr : number > 0 [scalar]
        original sampling rate of `y`

    target_sr : number > 0 [scalar]
        target sampling rate

    res_type : str
        Func type (see note)

        .. note::
            By default, this uses `resampy`'s high-quality mode ('kaiser_best').

            To use a faster method, set `res_type='kaiser_fast'`.

            To use `scipy.signal.Func`, set `res_type='fft'` or `res_type='scipy'`.

            To use `scipy.signal.Func_poly`, set `res_type='polyphase'`.

        .. note::
            When using `res_type='polyphase'`, only integer sampling rates are
            supported.

    fix : bool
        adjust the length of the Funcd signal to be of size exactly
        `ceil(target_sr * len(y) / orig_sr)`

    scale : bool
        Scale the Funcd signal so that `y` and `y_hat` have approximately
        equal total energy.

    kwargs : additional keyword arguments
        If `fix==True`, additional keyword arguments to pass to
        `librosa.util.fix_length`.

    Returns
    -------
    y_hat : np.ndarray [shape=(n * target_sr / orig_sr,)]
        `y` Funcd from `orig_sr` to `target_sr`

    Raises
    ------
    ParameterError
        If `res_type='polyphase'` and `orig_sr` or `target_sr` are not both
        integer-valued.

    See Also
    --------
    librosa.util.fix_length
    scipy.signal.Func
    resampy.Func

    Notes
    -----
    This function caches at level 20.

    Examples
    --------
    Downsample from 22 KHz to 8 KHz

    >>> y, sr = librosa.load(librosa.util.example_audio_file(), sr=22050)
    >>> y_8k = librosa.Func(y, sr, 8000)
    >>> y.shape, y_8k.shape
    ((1355168,), (491671,))
    """

    # First, validate the audio buffer
    util.valid_audio(arg_0, mono=False)

    if arg_1 == arg_2:
        return arg_0

    arg_7 = float(arg_2) / arg_1

    arg_8 = int(np.ceil(arg_0.shape[-1] * arg_7))

    if arg_3 in ('scipy', 'fft'):
        arg_9 = scipy.signal.Func(arg_0, arg_8, axis=-1)
    elif arg_3 == 'polyphase':
        if int(arg_1) != arg_1 or int(arg_2) != arg_2:
            raise ParameterError('polyphase resampling is only supported for integer-valued sampling rates.')

        # For polyphase resampling, we need up- and down-sampling ratios
        # We can get those from the greatest common divisor of the rates
        # as long as the rates are integrable
        arg_1 = int(arg_1)
        arg_2 = int(arg_2)
        arg_10 = np.gcd(arg_1, arg_2)
        arg_9 = scipy.signal.Func_poly(arg_0, arg_2 // arg_10, arg_1 // arg_10, axis=-1)
    else:
        arg_9 = resampy.Func(arg_0, arg_1, arg_2, filter=arg_3, axis=-1)

    if arg_4:
        arg_9 = util.fix_length(arg_9, arg_8, **arg_6)

    if arg_5:
        arg_9 /= np.sqrt(arg_7)

    return np.ascontiguousarray(arg_9, dtype=arg_0.dtype)

Resample a time series from orig_sr to target_sr

    Parameters
    ----------
    y : np.ndarray [shape=(n,) or shape=(2, n)]
        audio time series.  Can be mono or stereo.

    orig_sr : number > 0 [scalar]
        original sampling rate of `y`

    target_sr : number > 0 [scalar]
        target sampling rate

    res_type : str
        resample type (see note)

        .. note::
            By default, this uses `resampy`'s high-quality mode ('kaiser_best').

            To use a faster method, set `res_type='kaiser_fast'`.

            To use `scipy.signal.resample`, set `res_type='fft'` or `res_type='scipy'`.

            To use `scipy.signal.resample_poly`, set `res_type='polyphase'`.

        .. note::
            When using `res_type='polyphase'`, only integer sampling rates are
            supported.

    fix : bool
        adjust the length of the resampled signal to be of size exactly
        `ceil(target_sr * len(y) / orig_sr)`

    scale : bool
        Scale the resampled signal so that `y` and `y_hat` have approximately
        equal total energy.

    kwargs : additional keyword arguments
        If `fix==True`, additional keyword arguments to pass to
        `librosa.util.fix_length`.

    Returns
    -------
    y_hat : np.ndarray [shape=(n * target_sr / orig_sr,)]
        `y` resampled from `orig_sr` to `target_sr`

    Raises
    ------
    ParameterError
        If `res_type='polyphase'` and `orig_sr` or `target_sr` are not both
        integer-valued.

    See Also
    --------
    librosa.util.fix_length
    scipy.signal.resample
    resampy.resample

    Notes
    -----
    This function caches at level 20.

    Examples
    --------
    Downsample from 22 KHz to 8 KHz

    >>> y, sr = librosa.load(librosa.util.example_audio_file(), sr=22050)
    >>> y_8k = librosa.resample(y, sr, 8000)
    >>> y.shape, y_8k.shape
    ((1355168,), (491671,))


def Func(arg_0):
        """
        Get name of the GTFS timezone

        Returns
        -------
        timezone_name : str
            name of the time zone, e.g. "Europe/Helsinki"
        """
        arg_1 = arg_0.conn.execute('SELECT timezone FROM agencies LIMIT 1').fetchone()
        if arg_1 is None:
            raise ValueError("This database does not have a timezone defined.")
        return arg_1[0]


GetConsoleTitle from Win32.
    Return str.

def Func ( ) -> str : arg_0 = ctypes . c_wchar * MAX_PATH arg_1 = arg_0 ( ) ctypes . windll . kernel32 . FuncW ( arg_1 , MAX_PATH ) return arg_1 . value

def Func() -> str:
    """
    Func from Win32.
    Return str.
    """
    arg_0 = ctypes.c_wchar * MAX_PATH
    arg_1 = arg_0()
    ctypes.windll.kernel32.FuncW(arg_1, MAX_PATH)
    return arg_1.value

GetConsoleTitle from Win32.
    Return str.

GetConsoleTitle from Win32 . Return str .


def Func ( arg_0 , arg_1 ) : arg_2 = [ ] arg_3 = arg_0 . client . pull_commits ( arg_1 ) for arg_4 in arg_3 : for arg_5 in json . loads ( arg_4 ) : arg_6 = arg_5 [ 'sha' ] arg_2 . append ( arg_6 ) return arg_2

def Func(arg_0, arg_1):
        """Get pull request commit hashes"""

        arg_2 = []
        arg_3 = arg_0.client.pull_commits(arg_1)

        for arg_4 in arg_3:

            for arg_5 in json.loads(arg_4):
                arg_6 = arg_5['sha']
                arg_2.append(arg_6)

        return arg_2


def Func ( arg_0 , arg_1 , arg_2 ) : if not arg_0 . package_set : arg_0 . package_set = True arg_1 . package = arg_4 . Package ( arg_2 = arg_2 ) return True else : raise CardinalityError ( 'Package::Name' )

def Func(arg_0, arg_1, arg_2):
        """Creates a package for the SPDX Document.
        name - any string.
        Raises CardinalityError if package already defined.
        """
        if not arg_0.package_set:
            arg_0.package_set = True
            arg_1.package = arg_4.Package(arg_2=arg_2)
            return True
        else:
            raise CardinalityError('Package::Name')

Creates a package for the SPDX Document . name - any string . Raises CardinalityError if package already defined .


def Func ( arg_0 ) : if PyFunceble . CONFIGURATION [ "mining" ] : Dict ( PyFunceble . INTERN [ "mined" ] ) . to_json ( arg_0 . file )

def Func(arg_0):
        """
        Backup the mined informations.
        """

        if PyFunceble.CONFIGURATION["mining"]:
            # The mining is activated.

            # We backup our mined informations.
            Dict(PyFunceble.INTERN["mined"]).to_json(arg_0.file)


def Func ( arg_0 , arg_1 ) : if arg_0 . profile not in arg_1 . data : raise UnknownProfileError ( arg_0 . profile )

def Func(arg_0, arg_1):
    """
    Verifies the profile name exists in the config.json file.

    Args:
        :msg: (Message class) an instance of a message class.
        :cfg: (jsonconfig.Config) config instance.
    """
    if arg_0.profile not in arg_1.data:
        raise UnknownProfileError(arg_0.profile)

Verifies the profile name exists in the config . json file .


def Func(arg_0, arg_1=[]):
    """
    Post to metadata server

    Parameters
    ----------

    repo: Repository object (result of lookup)
    """

    arg_2 = plugins_get_mgr()
    arg_3 = arg_2.search(what='metadata')
    arg_3 = arg_3['metadata']

    if len(arg_3) == 0:
        return

    # Incorporate pipeline information...
    if 'pipeline' in arg_0.options:
        for arg_4, arg_5 in arg_0.options['pipeline'].items():
            arg_6 = arg_5['files']
            arg_7 = arg_0.find_matching_files(arg_6)
            arg_7.sort()
            arg_5['files'] = arg_7
            for arg_8, arg_9 in enumerate(arg_7):
                arg_10 = arg_0.get_resource(arg_9)
                if 'pipeline' not in arg_10:
                    arg_10['pipeline'] = []
                arg_10['pipeline'].append(arg_4 + " [Step {}]".format(arg_8))

    if 'metadata-management' in arg_0.options:

        print("Collecting all the required metadata to Func")
        arg_11 = arg_0.options['metadata-management']

        # Add data repo history
        if 'include-data-history' in arg_11 and arg_11['include-data-history']:
            arg_0.package['history'] = get_history(arg_0.rootdir)

        # Add action history
        if 'include-action-history' in arg_11 and arg_11['include-action-history']:
            annotate_metadata_action(arg_0)

        # Add data repo history
        if 'include-preview' in arg_11:
            annotate_metadata_data(arg_0,
                                   task='preview',
                                   arg_6=arg_11['include-preview']['files'],
                                   size=arg_11['include-preview']['length'])

        if (('include-schema' in arg_11) and arg_11['include-schema']):
            annotate_metadata_data(arg_0,  task='schema')

        if 'include-code-history' in arg_11:
            annotate_metadata_code(arg_0, files=arg_11['include-code-history'])

        if 'include-platform' in arg_11:
            annotate_metadata_platform(arg_0)

        if 'include-validation' in arg_11:
            annotate_metadata_validation(arg_0)

        if 'include-dependencies' in arg_11:
            annotate_metadata_dependencies(arg_0)

        arg_13 = arg_0.package.get('history',None)
        if (('include-tab-diffs' in arg_11) and
            arg_11['include-tab-diffs'] and
            arg_13 is not None):
            annotate_metadata_diffs(arg_0)

        # Insert options as well
        arg_0.package['config'] = arg_0.options

    try:
        for arg_14 in arg_3:
            # print("Key", k)
            arg_15 = arg_2.get_by_key('metadata', arg_14)
            arg_16 = arg_15.url
            arg_17 = urlparse(arg_16)
            print("Posting to ", arg_17.netloc)
            arg_18 = arg_15.Func(arg_0)
            if isinstance(arg_18, str):
                print("Error while Funcing:", arg_18)
            elif arg_18.status_code in [400]:
                arg_19 = arg_18.json()
                print("Error while Funcing:")
                for arg_14 in arg_19:
                    print("   ", arg_14,"- ", ",".join(arg_19[arg_14]))
    except NetworkError as e:
        print("Unable to reach metadata server!")
    except NetworkInvalidConfiguration as e:
        print("Invalid network configuration in the INI file")
        print(e.message)
    except Exception as e:
        print("Could not Func. Unknown error")
        print(e)


(lat_min, lng_min, lat_max, lng_max, tags=None)

def
Func
(
arg_0
,
arg_1
,
arg_2
,
arg_3
,
arg_4
=
)
:
arg_5
=
make_osm_query
(
build_Func
(
arg_0
,
arg_1
,
arg_2
,
arg_3
,
arg_4
=
arg_4
)
)
if
len
(
arg_5
[
'elements'
]
)
==
0
:
raise
RuntimeError
(
'OSM query results contain no data.'
)
arg_6
=
[
process_node
(
n
)
for
n
in
arg_5
[
'elements'
]
]
return
pd
.
DataFrame
.
from_records
(
arg_6
,
index
=
'id'
)

def Func(arg_0, arg_1, arg_2, arg_3, arg_4=None):
    """
    Search for OSM nodes within a bounding box that match given tags.

    Parameters
    ----------
    lat_min, lng_min, lat_max, lng_max : float
    tags : str or list of str, optional
        Node tags that will be used to filter the search.
        See http://wiki.openstreetmap.org/wiki/Overpass_API/Language_Guide
        for information about OSM Overpass queries
        and http://wiki.openstreetmap.org/wiki/Map_Features
        for a list of tags.

    Returns
    -------
    nodes : pandas.DataFrame
        Will have 'lat' and 'lon' columns, plus other columns for the
        tags associated with the node (these will vary based on the query).
        Index will be the OSM node IDs.

    """
    arg_5 = make_osm_query(build_Func(
        arg_0, arg_1, arg_2, arg_3, arg_4=arg_4))

    if len(arg_5['elements']) == 0:
        raise RuntimeError('OSM query results contain no data.')

    arg_6 = [process_node(n) for n in arg_5['elements']]
    return pd.DataFrame.from_records(arg_6, index='id')

Search for OSM nodes within a bounding box that match given tags .


def Func(arg_0,arg_1=False,arg_2=False):
        """
        generate list of cells with links. keep this simple.
        automatically generates splash page and regnerates frames.
        """
        arg_0.makePics() # ensure all pics are converted
        # generate menu
        arg_3='./%s/
'%os.path.basename(arg_0.abfFolder)
        for arg_4 in smartSort(arg_0.fnamesByCell.keys()):
            arg_5=''
            if arg_4+".html" in arg_0.fnames2:
                arg_5='href="%s.html" target="content"'%arg_4
            arg_3+=('%s
'%(arg_5,arg_4)) # show the parent ABF (ID)
            if arg_2:
                for arg_6 in arg_0.fnamesByCell[arg_4]:
                    arg_7=os.path.splitext(arg_6)[0]
                    arg_8=[x for x in arg_0.fnames2 if x.startswith(arg_7) and not x.endswith(".html")]
                    arg_3+='%s'%arg_7 # show the child ABF
                    if len(arg_8):
                        arg_3+=' (%s)'%len(arg_8) # show number of supporting files
                    arg_3+='
'
                arg_3+="
"
        style.save(arg_3,arg_0.abfFolder2+"/index_menu.html")
        arg_0.Func_splash() # make splash page
        style.frames(arg_0.abfFolder2+"/index.html",arg_1=arg_1)

generate list of cells with links . keep this simple . automatically generates splash page and regnerates frames .


def Func(arg_0,arg_1,arg_2,arg_3,arg_4=False,**arg_5):
    '''
    Produce calibrated Stokes I for an observation given a noise diode
    measurement on the source and a diode spectrum with the same number of
    coarse channels

    Parameters
    ----------
    main_obs_name : str
        Path to filterbank file containing final data to be calibrated
    dio_name : str
        Path to filterbank file for observation on the target source with flickering noise diode
    dspec : 1D Array (float) or float
        Coarse channel spectrum (or average) of the noise diode in Jy (obtained from diode_spec())
    Tsys : 1D Array (float) or float
        Coarse channel spectrum (or average) of the system temperature in Jy
    fullstokes: boolean
        Use fullstokes=True if data is in IQUV format or just Stokes I, use fullstokes=False if
        it is in cross_pols format
    '''

    #Find folded spectra of the target source with the noise diode ON and OFF
    arg_6 = Waterfall(arg_0,max_load=150)
    arg_7 = arg_6.calc_n_coarse_chan()
    arg_8 = Waterfall(arg_1,max_load=150)
    arg_9 = arg_8.header['nchans']/arg_7
    arg_10,arg_11 = integrate_calib(arg_1,arg_9,arg_4,**arg_5)

    #Find Jy/count for each coarse channel using the diode spectrum
    arg_12 = arg_6.data
    arg_13 = arg_2/(arg_11-arg_10)
    print(arg_13)

    arg_14 = arg_6.header['nchans']
    arg_15 = arg_14/arg_7

    arg_16 = np.size(arg_12,0)
    arg_17 = np.size(arg_12,1)

    #Reshape data array of target observation and multiply coarse channels by the scale factors
    arg_12 = np.reshape(arg_12,(arg_16,arg_17,arg_7,arg_15))
    arg_12 = np.swapaxes(arg_12,2,3)

    arg_12 = arg_12*arg_13
    arg_12 = arg_12-arg_3
    arg_12 = np.swapaxes(arg_12,2,3)
    arg_12 = np.reshape(arg_12,(arg_16,arg_17,arg_14))

    #Write calibrated data to a new filterbank file with ".fluxcal" extension

    arg_6.data = arg_12
    arg_6.write_to_filterbank(arg_0[:-4]+'.fluxcal.fil')
    print('Finished: calibrated product written to ' + arg_0[:-4]+'.fluxcal.fil')


def Func(arg_0, arg_1, arg_2='\0'):
        r"""Return a word Funcd from BWT form.

        Parameters
        ----------
        code : str
            The word to transform from BWT form
        terminator : str
            A character added to signal the end of the string

        Returns
        -------
        str
            Word Funcd by BWT

        Raises
        ------
        ValueError
            Specified terminator absent from code.

        Examples
        --------
        >>> bwt = BWT()
        >>> bwt.Func('n\x00ilag')
        'align'
        >>> bwt.Func('annb\x00aa')
        'banana'
        >>> bwt.Func('annb@aa', '@')
        'banana'

        """
        if arg_1:
            if arg_2 not in arg_1:
                raise ValueError(
                    'Specified terminator, {}, absent from code.'.format(
                        arg_2 if arg_2 != '\0' else '\\0'
                    )
                )
            else:
                arg_3 = [''] * len(arg_1)
                for arg_4 in range(len(arg_1)):
                    arg_3 = sorted(
                        arg_1[arg_4] + arg_3[arg_4] for arg_4 in range(len(arg_1))
                    )
                arg_5 = [w for w in arg_3 if w[-1] == arg_2][0]
                return arg_5.rstrip(arg_2)
        else:
            return ''

r"""Return a word decoded from BWT form.

        Parameters
        ----------
        code : str
            The word to transform from BWT form
        terminator : str
            A character added to signal the end of the string

        Returns
        -------
        str
            Word decoded by BWT

        Raises
        ------
        ValueError
            Specified terminator absent from code.

        Examples
        --------
        >>> bwt = BWT()
        >>> bwt.decode('n\x00ilag')
        'align'
        >>> bwt.decode('annb\x00aa')
        'banana'
        >>> bwt.decode('annb@aa', '@')
        'banana'


def Func ( arg_0 , arg_1 ) : def decorator ( arg_2 ) : arg_0 . record_once ( lambda s : s . app . _register_error_handler ( arg_0 . name , arg_1 , arg_2 ) ) return arg_2 return decorator

def Func(arg_0, arg_1):
        """Registers an error handler that becomes active for this blueprint
        only.  Please be aware that routing does not happen local to a
        blueprint so an error handler for 404 usually is not handled by
        a blueprint unless it is caused inside a view function.  Another
        special case is the 500 internal server error which is always looked
        up from the application.

        Otherwise works as the :meth:`~flask.Flask.Func` decorator
        of the :class:`~flask.Flask` object.
        """
        def decorator(arg_2):
            arg_0.record_once(lambda s: s.app._register_error_handler(
                arg_0.name, arg_1, arg_2))
            return arg_2
        return decorator

Registers an error handler that becomes active for this blueprint
        only.  Please be aware that routing does not happen local to a
        blueprint so an error handler for 404 usually is not handled by
        a blueprint unless it is caused inside a view function.  Another
        special case is the 500 internal server error which is always looked
        up from the application.

        Otherwise works as the :meth:`~flask.Flask.errorhandler` decorator
        of the :class:`~flask.Flask` object.

Registers an error handler that becomes active for this blueprint only . Please be aware that routing does not happen local to a blueprint so an error handler for 404 usually is not handled by a blueprint unless it is caused inside a view function . Another special case is the 500 internal server error which is always looked up from the application .


def Func ( arg_0 , arg_1 = None , arg_2 = None ) : if arg_1 : arg_1 = arg_1 . upper ( ) if arg_1 is None or arg_1 == "ACTIVE" : return arg_0 . list_active_gen ( arg_2 ) if arg_1 == "ACTIVE.TIMES" : return arg_0 . list_active_times_gen ( ) if arg_1 == "DISTRIB.PATS" : return arg_0 . list_distrib_pats_gen ( ) if arg_1 == "HEADERS" : return arg_0 . list_headers_gen ( arg_2 ) if arg_1 == "NEWSGROUPS" : return arg_0 . list_newsgroups_gen ( arg_2 ) if arg_1 == "OVERVIEW.FMT" : return arg_0 . list_overview_fmt_gen ( ) if arg_1 == "EXTENSIONS" : return arg_0 . list_extensions_gen ( ) raise NotImplementedError ( )

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

        See list() for more information.

        Yields:
            An element in the list returned by list().
        """
        if arg_1:
            arg_1 = arg_1.upper()

        if arg_1 is None or arg_1 == "ACTIVE":
            return arg_0.list_active_gen(arg_2)
        if arg_1 == "ACTIVE.TIMES":
            return arg_0.list_active_times_gen()
        if arg_1 == "DISTRIB.PATS":
            return arg_0.list_distrib_pats_gen()
        if arg_1 == "HEADERS":
            return arg_0.list_headers_gen(arg_2)
        if arg_1 == "NEWSGROUPS":
            return arg_0.list_newsgroups_gen(arg_2)
        if arg_1 == "OVERVIEW.FMT":
            return arg_0.list_overview_fmt_gen()
        if arg_1 == "EXTENSIONS":
            return arg_0.list_extensions_gen()

        raise NotImplementedError()


def Func ( arg_0 ) : arg_0 . __fileobj . seek ( arg_0 . data_offset ) arg_0 . data = arg_0 . __fileobj . Func ( arg_0 . data_size )

def Func(arg_0):
        """Read the chunks data"""
        arg_0.__fileobj.seek(arg_0.data_offset)
        arg_0.data = arg_0.__fileobj.Func(arg_0.data_size)


return (
            self._iocb.aio_reqprio
            if self._iocb.u.c.flags & libaio.IOCB_FLAG_IOPRIO else
            None
        )

def Func ( arg_0 ) : return ( arg_0 . _iocb . aio_reqprio if arg_0 . _iocb . u . c . flags & libaio . IOCB_FLAG_IOPRIO else None )

def Func(arg_0):
        """
        IO priority for this instance.
        """
        return (
            arg_0._iocb.aio_reqprio
            if arg_0._iocb.u.c.flags & libaio.IOCB_FLAG_IOPRIO else
            None
        )


def Func ( arg_0 ) : if arg_0 . _prev_yank : arg_1 = arg_0 . _ring . Func ( ) if arg_1 : arg_0 . _skip_cursor = True arg_3 = arg_0 . _text_edit . textCursor ( ) arg_3 . movePosition ( QtGui . QTextCursor . Left , QtGui . QTextCursor . KeepAnchor , n = len ( arg_0 . _prev_yank ) ) arg_3 . insertText ( arg_1 ) arg_0 . _prev_yank = arg_1

def Func(arg_0):
        """ Rotate the kill ring, then yank back the new top.
        """
        if arg_0._prev_yank:
            arg_1 = arg_0._ring.Func()
            if arg_1:
                arg_0._skip_cursor = True
                arg_3 = arg_0._text_edit.textCursor()
                arg_3.movePosition(QtGui.QTextCursor.Left,
                                    QtGui.QTextCursor.KeepAnchor,
                                    n = len(arg_0._prev_yank))
                arg_3.insertText(arg_1)
                arg_0._prev_yank = arg_1

Rotate the kill ring then yank back the new top .


(self, local_ns=None, module=None, stack_depth=0,
                 display_banner=None, global_ns=None)

def Func(arg_0, arg_1=None, arg_2=None, arg_3=0,
                 arg_4=None, arg_5=None):
        """Embeds IPython into a running python program.

        Input:

          - header: An optional header message can be specified.

          - local_ns, module: working local namespace (a dict) and module (a
          module or similar object). If given as None, they are automatically
          taken from the scope where the shell was called, so that
          program variables become visible.

          - stack_depth: specifies how many levels in the stack to go to
          looking for namespaces (when local_ns or module is None).  This
          allows an intermediate caller to make sure that this function gets
          the namespace from the intended level in the stack.  By default (0)
          it will get its locals and globals from the immediate caller.

        Warning: it's possible to use this in a program which is being run by
        IPython itself (via %run), but some funny things will happen (a few
        globals get overwritten). In the future this will be cleaned up, as
        there is no fundamental reason why it can't work perfectly."""

        if (arg_5 is not None) and (arg_2 is None):
            class DummyMod(object):
                """A dummy module object for embedded IPython."""
                pass
            warnings.warn("global_ns is deprecated, use module instead.", DeprecationWarning)
            arg_2 = DummyMod()
            arg_2.__dict__ = arg_5

        # Get locals and globals from caller
        if (arg_1 is None or arg_2 is None) and arg_0.default_user_namespaces:
            arg_7 = sys._getframe(arg_3).f_back

            if arg_1 is None:
                arg_1 = arg_7.f_locals
            if arg_2 is None:
                arg_5 = arg_7.f_globals
                arg_2 = sys.modules[arg_5['__name__']]

        # Save original namespace and module so we can restore them after
        # embedding; otherwise the shell doesn't shut down correctly.
        arg_8 = arg_0.user_module
        arg_9 = arg_0.user_ns

        # Update namespaces and fire up interpreter

        # The global one is easy, we can just throw it in
        if arg_2 is not None:
            arg_0.user_module = arg_2

        # But the user/local one is tricky: ipython needs it to store internal
        # data, but we also need the locals. We'll throw our hidden variables
        # like _ih and get_ipython() into the local namespace, but delete them
        # later.
        if arg_1 is not None:
            arg_0.user_ns = arg_1
            arg_0.init_user_ns()

        # Patch for global embedding to make sure that things don't overwrite
        # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
        # FIXME. Test this a bit more carefully (the if.. is new)
        # N.B. This can't now ever be called. Not sure what it was for.
        # And now, since it wasn't called in the previous version, I'm
        # commenting out these lines so they can't be called with my new changes
        # --TK, 2011-12-10
        #if local_ns is None and module is None:
        #    self.user_global_ns.update(__main__.__dict__)

        # make sure the tab-completer has the correct frame information, so it
        # actually completes using the frame's locals/globals
        arg_0.set_completer_frame()

        with nested(arg_0.builtin_trap, arg_0.display_trap):
            arg_0.interact(arg_4=arg_4)

        # now, purge out the local namespace of IPython's hidden variables.
        if arg_1 is not None:
            for arg_12 in arg_0.user_ns_hidden:
                arg_1.pop(arg_12, None)

        # Restore original namespace so shell can shut down when we exit.
        arg_0.user_module = arg_8
        arg_0.user_ns = arg_9

Embeds IPython into a running python program .


def Func ( arg_0 , arg_1 ) : arg_2 = [ ( 'description' , 's' , 116 ) , ( 'subsystem_offset' , 's' , 8 ) , ( 'version' , 'H' , 2 ) , ( 'endian_test' , 's' , 2 ) ] arg_3 = { } for arg_4 , arg_5 , arg_6 in arg_2 : arg_7 = arg_0 . read ( arg_6 ) arg_3 [ arg_4 ] = unpack ( arg_1 , arg_5 , arg_7 ) arg_3 [ 'description' ] = arg_3 [ 'description' ] . strip ( ) arg_8 = arg_3 [ 'version' ] >> 8 arg_9 = arg_3 [ 'version' ] & 0xFF arg_3 [ '__version__' ] = '%d.%d' % ( arg_8 , arg_9 ) return arg_3

def Func(arg_0, arg_1):
    """Read mat 5 file header of the file fd.
    Returns a dict with header values.
    """
    arg_2 = [
        ('description', 's', 116),
        ('subsystem_offset', 's', 8),
        ('version', 'H', 2),
        ('endian_test', 's', 2)
    ]
    arg_3 = {}
    for arg_4, arg_5, arg_6 in arg_2:
        arg_7 = arg_0.read(arg_6)
        arg_3[arg_4] = unpack(arg_1, arg_5, arg_7)
    arg_3['description'] = arg_3['description'].strip()
    arg_8 = arg_3['version'] >> 8
    arg_9 = arg_3['version'] & 0xFF
    arg_3['__version__'] = '%d.%d' % (arg_8, arg_9)
    return arg_3

Read mat 5 file header of the file fd . Returns a dict with header values .


def Func ( arg_0 , arg_1 , arg_2 , arg_3 ) : arg_4 = { 'Accept' : 'application/json' , 'Connection' : 'keep-alive' } arg_5 = DAO . getURL ( arg_1 , arg_4 ) if arg_5 . status != 200 : raise DataFailureException ( arg_1 , arg_5 . status , arg_5 . data ) arg_6 = json . loads ( arg_5 . data ) arg_0 . next_page_url = arg_0 . _next_page ( arg_5 ) if arg_2 and arg_0 . next_page_url : if isinstance ( arg_6 , list ) : arg_6 . extend ( arg_0 . Func ( arg_0 . next_page_url , True , arg_3 ) ) elif isinstance ( arg_6 , dict ) and arg_3 is not None : arg_6 [ arg_3 ] . extend ( arg_0 . Func ( arg_0 . next_page_url , True , arg_3 ) [ arg_3 ] ) return arg_6

def Func(arg_0, arg_1, arg_2, arg_3):
        """
        Canvas GET method on a full url. Return representation of the
        requested resource, chasing pagination links to coalesce resources
        if indicated.
        """
        arg_4 = {'Accept': 'application/json',
                   'Connection': 'keep-alive'}
        arg_5 = DAO.getURL(arg_1, arg_4)

        if arg_5.status != 200:
            raise DataFailureException(arg_1, arg_5.status, arg_5.data)

        arg_6 = json.loads(arg_5.data)

        arg_0.next_page_url = arg_0._next_page(arg_5)
        if arg_2 and arg_0.next_page_url:
            if isinstance(arg_6, list):
                arg_6.extend(arg_0.Func(arg_0.next_page_url, True,
                                                   arg_3))
            elif isinstance(arg_6, dict) and arg_3 is not None:
                arg_6[arg_3].extend(arg_0.Func(
                    arg_0.next_page_url, True, arg_3)[arg_3])

        return arg_6

Canvas GET method on a full url . Return representation of the requested resource chasing pagination links to coalesce resources if indicated .


def Func ( arg_0 , arg_1 ) : if arg_1 == 1 : return np . array ( [ 0 ] ) arg_2 = arg_0 . coupling_map . size ( ) arg_3 = np . asarray ( arg_0 . coupling_map . get_edges ( ) ) arg_4 = np . ones_like ( arg_3 [ : , 0 ] ) arg_5 = sp . coo_matrix ( ( arg_4 , ( arg_3 [ : , 0 ] , arg_3 [ : , 1 ] ) ) , shape = ( arg_2 , arg_2 ) ) . tocsr ( ) arg_6 = 0 arg_7 = None for arg_8 in range ( arg_5 . shape [ 0 ] ) : arg_9 = cs . breadth_first_order ( arg_5 , i_start = arg_8 , directed = False , return_predecessors = False ) arg_10 = 0 arg_11 = [ ] for arg_12 in range ( arg_1 ) : arg_13 = arg_9 [ arg_12 ] for arg_14 in range ( arg_5 . indptr [ arg_13 ] , arg_5 . indptr [ arg_13 + 1 ] ) : arg_15 = arg_5 . indices [ arg_14 ] for arg_16 in range ( arg_1 ) : if arg_15 == arg_9 [ arg_16 ] : arg_10 += 1 arg_11 . append ( [ arg_13 , arg_15 ] ) break if arg_10 > arg_6 : arg_6 = arg_10 arg_7 = arg_9 [ 0 : arg_1 ] arg_17 = { } for arg_18 in range ( arg_7 . shape [ 0 ] ) : arg_17 [ arg_7 [ arg_18 ] ] = arg_18 arg_19 = [ [ arg_17 [ c [ 0 ] ] , arg_17 [ c [ 1 ] ] ] for c in arg_11 ] arg_20 = [ arg_18 [ 0 ] for arg_18 in arg_19 ] arg_21 = [ arg_18 [ 1 ] for arg_18 in arg_19 ] arg_4 = [ 1 ] * len ( arg_20 ) arg_22 = sp . coo_matrix ( ( arg_4 , ( arg_20 , arg_21 ) ) , shape = ( arg_1 , arg_1 ) ) . tocsr ( ) arg_23 = cs . reverse_cuthill_mckee ( arg_22 ) arg_7 = arg_7 [ arg_23 ] return arg_7

def Func(arg_0, arg_1):
        """Computes the qubit mapping with the best connectivity.

        Args:
            n_qubits (int): Number of subset qubits to consider.

        Returns:
            ndarray: Array of qubits to use for best connectivity mapping.
        """
        if arg_1 == 1:
            return np.array([0])

        arg_2 = arg_0.coupling_map.size()

        arg_3 = np.asarray(arg_0.coupling_map.get_edges())
        arg_4 = np.ones_like(arg_3[:, 0])
        arg_5 = sp.coo_matrix((arg_4, (arg_3[:, 0], arg_3[:, 1])),
                                shape=(arg_2, arg_2)).tocsr()
        arg_6 = 0
        arg_7 = None
        # do bfs with each node as starting point
        for arg_8 in range(arg_5.shape[0]):
            arg_9 = cs.breadth_first_order(arg_5, i_start=arg_8, directed=False,
                                         return_predecessors=False)

            arg_10 = 0
            arg_11 = []
            for arg_12 in range(arg_1):
                arg_13 = arg_9[arg_12]
                for arg_14 in range(arg_5.indptr[arg_13],
                               arg_5.indptr[arg_13 + 1]):
                    arg_15 = arg_5.indices[arg_14]
                    for arg_16 in range(arg_1):
                        if arg_15 == arg_9[arg_16]:
                            arg_10 += 1
                            arg_11.append([arg_13, arg_15])
                            break

            if arg_10 > arg_6:
                arg_6 = arg_10
                arg_7 = arg_9[0:arg_1]
                # Return a best mapping that has reduced bandwidth
                arg_17 = {}
                for arg_18 in range(arg_7.shape[0]):
                    arg_17[arg_7[arg_18]] = arg_18
                arg_19 = [[arg_17[c[0]], arg_17[c[1]]] for c in arg_11]
                arg_20 = [arg_18[0] for arg_18 in arg_19]
                arg_21 = [arg_18[1] for arg_18 in arg_19]
                arg_4 = [1]*len(arg_20)
                arg_22 = sp.coo_matrix((arg_4, (arg_20, arg_21)),
                                             shape=(arg_1, arg_1)).tocsr()
                arg_23 = cs.reverse_cuthill_mckee(arg_22)
                arg_7 = arg_7[arg_23]
        return arg_7

Computes the qubit mapping with the best connectivity .


def Func ( arg_0 ) : if PyFunceble . CONFIGURATION [ "inactive_database" ] : if PyFunceble . INTERN [ "to_test" ] in PyFunceble . INTERN [ "flatten_inactive_db" ] or ( PyFunceble . INTERN [ "file_to_test" ] in PyFunceble . INTERN [ "inactive_db" ] and PyFunceble . INTERN [ "inactive_db" ] [ PyFunceble . INTERN [ "file_to_test" ] ] and "to_test" in PyFunceble . INTERN [ "inactive_db" ] [ PyFunceble . INTERN [ "file_to_test" ] ] and PyFunceble . INTERN [ "to_test" ] in PyFunceble . INTERN [ "inactive_db" ] [ PyFunceble . INTERN [ "file_to_test" ] ] [ "to_test" ] ) : return True return False

def Func(arg_0):
        """
        Check if the currently tested element is into the database.
        """

        if PyFunceble.CONFIGURATION["inactive_database"]:
            # The database subsystem is activated.

            if PyFunceble.INTERN["to_test"] in PyFunceble.INTERN[
                "flatten_inactive_db"
            ] or (
                PyFunceble.INTERN["file_to_test"] in PyFunceble.INTERN["inactive_db"]
                and PyFunceble.INTERN["inactive_db"][PyFunceble.INTERN["file_to_test"]]
                and "to_test"
                in PyFunceble.INTERN["inactive_db"][PyFunceble.INTERN["file_to_test"]]
                and PyFunceble.INTERN["to_test"]
                in PyFunceble.INTERN["inactive_db"][PyFunceble.INTERN["file_to_test"]][
                    "to_test"
                ]
            ):
                return True

        return False

Check if the currently tested element is into the database .


def Func ( arg_0 , * arg_1 ) : arg_0 . _config_files = tuple ( pathlib . Path ( path ) for path in arg_1 )

def Func(arg_0, *arg_1):
        """Set the list of config files.

        Args:
            config_files (pathlike): path of config files, given in the order
                of reading.
        """
        arg_0._config_files = tuple(pathlib.Path(path) for path in arg_1)


def Func ( arg_0 ) : arg_1 = [ ] for arg_2 in arg_0 . conn . endpoints [ "self" ] . Func ( ) : arg_1 . append ( SkypeEvent . fromRaw ( arg_0 , arg_2 ) ) return arg_1

def Func(arg_0):
        """
        Retrieve a list of events since the last poll.  Multiple calls may be needed to retrieve all events.

        If no events occur, the API will block for up to 30 seconds, after which an empty list is returned.  As soon as
        an event is received in this time, it is returned immediately.

        Returns:
            :class:`.SkypeEvent` list: a list of events, possibly empty
        """
        arg_1 = []
        for arg_2 in arg_0.conn.endpoints["self"].Func():
            arg_1.append(SkypeEvent.fromRaw(arg_0, arg_2))
        return arg_1

Retrieve a list of events since the last poll . Multiple calls may be needed to retrieve all events .


def Func ( arg_0 , ** arg_1 ) : @ detail_route ( methods = [ 'post' ] , ** arg_1 ) def inner_func ( arg_2 , arg_3 , arg_4 = None , ** arg_1 ) : arg_5 = arg_2 . get_object ( ) arg_6 = getattr ( arg_5 , arg_0 ) arg_6 ( by = arg_2 . request . user ) if arg_2 . save_after_transition : arg_5 . save ( ) arg_7 = arg_2 . get_serializer ( arg_5 ) return Response ( arg_7 . data ) return inner_func

def Func(arg_0, **arg_1):
    '''
    Create a viewset method for the provided `transition_name`
    '''
    @detail_route(methods=['post'], **arg_1)
    def inner_func(arg_2, arg_3, arg_4=None, **arg_1):
        arg_5 = arg_2.get_object()
        arg_6 = getattr(arg_5, arg_0)

        arg_6(by=arg_2.request.user)

        if arg_2.save_after_transition:
            arg_5.save()

        arg_7 = arg_2.get_serializer(arg_5)
        return Response(arg_7.data)

    return inner_func

Create a viewset method for the provided transition_name


def Func(arg_0, arg_1, arg_2):
        """Parses all the values in the request that are in a form specific
        to the JSON AMP dialect.

        """
        for arg_3, arg_4 in arg_2.arguments:
            arg_5 = arg_4.__class__

            if arg_5 is exposed.ExposedResponderLocator:
                arg_1[arg_3] = arg_0._remote
                continue

            arg_6 = _decoders.get(arg_5)
            if arg_6 is not None:
                arg_7 = arg_1.get(arg_3)
                arg_1[arg_3] = arg_6(arg_7, arg_0)

Parses all the values in the request that are in a form specific to the JSON AMP dialect .


def
Func
(
arg_0
,
arg_1
=
False
,
arg_2
=
)
:
arg_3
=
[
COMBINED
,
IARC
,
NTP
]
if
arg_1
:
return
arg_3
if
not
arg_2
:
arg_2
=
arg_3
[
0
]
if
arg_2
==
IARC
:
if
arg_0
in
IARC_data
.
index
:
arg_4
=
IARC_codes
[
IARC_data
.
at
[
arg_0
,
'group'
]
]
else
:
arg_4
=
UNLISTED
elif
arg_2
==
NTP
:
if
arg_0
in
NTP_data
.
index
:
arg_4
=
NTP_codes
[
NTP_data
.
at
[
arg_0
,
'Listing'
]
]
else
:
arg_4
=
UNLISTED
elif
arg_2
==
COMBINED
:
arg_4
=
{
}
for
arg_5
in
arg_3
[
1
:
]
:
arg_4
[
arg_5
]
=
Func
(
arg_0
,
arg_2
=
arg_5
)
else
:
raise
Exception
(
'Failure in in function'
)
return
arg_4

def Func(arg_0, arg_1=False, arg_2=None):
    r'''Looks up if a chemical is listed as a carcinogen or not according to
    either a specifc method or with all methods.

    Returns either the status as a string for a specified method, or the
    status of the chemical in all available data sources, in the format
    {source: status}.

    Parameters
    ----------
    CASRN : string
        CASRN [-]

    Returns
    -------
    status : str or dict
        Func status information [-]
    methods : list, only returned if AvailableMethods == True
        List of methods which can be used to obtain carcinogen status with the
        given inputs

    Other Parameters
    ----------------
    Method : string, optional
        A string for the method name to use, as defined by constants in
        Func_methods
    AvailableMethods : bool, optional
        If True, function will determine which methods can be used to obtain
        if a chemical is listed as carcinogenic, and will return methods
        instead of the status

    Notes
    -----
    Supported methods are:

        * **IARC**: International Agency for Research on Cancer, [1]_. As
          extracted with a last update of  February 22, 2016. Has listing
          information of 843 chemicals with CAS numbers. Chemicals without
          CAS numbers not included here. If two listings for the same CAS
          were available, that closest to the CAS number was used. If two
          listings were available published at different times, the latest
          value was used. All else equal, the most pessimistic value was used.
        * **NTP**: National Toxicology Program, [2]_. Has data on 226
          chemicals.

    Examples
    --------
    >>> Func('61-82-5')
    {'National Toxicology Program 13th Report on Funcs': 'Reasonably Anticipated', 'International Agency for Research on Cancer': 'Not classifiable as to its carcinogenicity to humans (3)'}

    References
    ----------
    .. [1] International Agency for Research on Cancer. Agents Classified by
       the IARC Monographs, Volumes 1-115. Lyon, France: IARC; 2016 Available
       from: http://monographs.iarc.fr/ENG/Classification/
    .. [2] NTP (National Toxicology Program). 2014. Report on Funcs,
       Thirteenth Edition. Research Triangle Park, NC: U.S. Department of
       Health and Human Services, Public Health Service.
       http://ntp.niehs.nih.gov/pubhealth/roc/roc13/
    '''
    arg_3 = [COMBINED, IARC, NTP]
    if arg_1:
        return arg_3
    if not arg_2:
        arg_2 = arg_3[0]
    if arg_2 == IARC:
        if arg_0 in IARC_data.index:
            arg_4 = IARC_codes[IARC_data.at[arg_0, 'group']]
        else:
            arg_4 = UNLISTED
    elif arg_2 == NTP:
        if arg_0 in NTP_data.index:
            arg_4 = NTP_codes[NTP_data.at[arg_0, 'Listing']]
        else:
            arg_4 = UNLISTED
    elif arg_2 == COMBINED:
        arg_4 = {}
        for arg_5 in arg_3[1:]:
            arg_4[arg_5] = Func(arg_0, arg_2=arg_5)
    else:
        raise Exception('Failure in in function')
    return arg_4

r'''Looks up if a chemical is listed as a carcinogen or not according to
    either a specifc method or with all methods.

    Returns either the status as a string for a specified method, or the
    status of the chemical in all available data sources, in the format
    {source: status}.

    Parameters
    ----------
    CASRN : string
        CASRN [-]

    Returns
    -------
    status : str or dict
        Carcinogen status information [-]
    methods : list, only returned if AvailableMethods == True
        List of methods which can be used to obtain carcinogen status with the
        given inputs

    Other Parameters
    ----------------
    Method : string, optional
        A string for the method name to use, as defined by constants in
        Carcinogen_methods
    AvailableMethods : bool, optional
        If True, function will determine which methods can be used to obtain
        if a chemical is listed as carcinogenic, and will return methods
        instead of the status

    Notes
    -----
    Supported methods are:

        * **IARC**: International Agency for Research on Cancer, [1]_. As
          extracted with a last update of  February 22, 2016. Has listing
          information of 843 chemicals with CAS numbers. Chemicals without
          CAS numbers not included here. If two listings for the same CAS
          were available, that closest to the CAS number was used. If two
          listings were available published at different times, the latest
          value was used. All else equal, the most pessimistic value was used.
        * **NTP**: National Toxicology Program, [2]_. Has data on 226
          chemicals.

    Examples
    --------
    >>> Carcinogen('61-82-5')
    {'National Toxicology Program 13th Report on Carcinogens': 'Reasonably Anticipated', 'International Agency for Research on Cancer': 'Not classifiable as to its carcinogenicity to humans (3)'}

    References
    ----------
    .. [1] International Agency for Research on Cancer. Agents Classified by
       the IARC Monographs, Volumes 1-115. Lyon, France: IARC; 2016 Available
       from: http://monographs.iarc.fr/ENG/Classification/
    .. [2] NTP (National Toxicology Program). 2014. Report on Carcinogens,
       Thirteenth Edition. Research Triangle Park, NC: U.S. Department of
       Health and Human Services, Public Health Service.
       http://ntp.niehs.nih.gov/pubhealth/roc/roc13/

r Looks up if a chemical is listed as a carcinogen or not according to either a specifc method or with all methods .


def Func ( arg_0 , arg_1 ) : arg_2 = arg_0 . featured_image if arg_1 is None : if arg_2 : arg_2 . delete ( ) arg_0 . featured_image = None return if arg_1 [ 'image_id' ] is None : if arg_2 : arg_2 . delete ( ) arg_0 . featured_image = None return if not arg_2 : arg_2 = ImageAttachment ( ) arg_2 . image_id = arg_1 . get ( 'image_id' , arg_2 . image_id ) arg_2 . caption = arg_1 . get ( 'caption' , None ) arg_2 . credit = arg_1 . get ( 'credit' , None ) arg_7 = str ( type ( arg_0 ) ) . lower ( ) setattr ( arg_2 , arg_7 , arg_0 ) arg_2 . save ( ) arg_0 . featured_image = arg_2

def Func(arg_0, arg_1):
        """
        Handles saving the featured image.

        If data is None, the featured image will be removed.

        `data` should be dictionary with the following format:
          {
            'image_id': int,
            'caption': str,
            'credit': str
          }
        """

        arg_2 = arg_0.featured_image

        if arg_1 is None:
            if arg_2:
                arg_2.delete()

            arg_0.featured_image = None
            return

        if arg_1['image_id'] is None:
            if arg_2:
                arg_2.delete()

            arg_0.featured_image = None
            return

        if not arg_2:
            arg_2 = ImageAttachment()

        arg_2.image_id = arg_1.get('image_id', arg_2.image_id)
        arg_2.caption = arg_1.get('caption', None)
        arg_2.credit = arg_1.get('credit', None)

        arg_7 = str(type(arg_0)).lower()

        setattr(arg_2, arg_7, arg_0)

        arg_2.save()

        arg_0.featured_image = arg_2


def Func ( arg_0 , ** arg_1 ) : try : arg_1 [ 'project_id' ] = arg_0 arg_2 = _pybossa_req ( 'get' , 'result' , params = arg_1 ) if type ( arg_2 ) . __name__ == 'list' : return [ Result ( arg_3 ) for arg_3 in arg_2 ] else : return arg_2 except : raise

def Func(arg_0, **arg_1):
    """Return a list of matched results for a given project ID.

    :param project_id: PYBOSSA Project ID
    :type project_id: integer
    :param kwargs: PYBOSSA Results members
    :type info: dict
    :rtype: list
    :returns: A list of results that match the kwargs

    """
    try:
        arg_1['project_id'] = arg_0
        arg_2 = _pybossa_req('get', 'result', params=arg_1)
        if type(arg_2).__name__ == 'list':
            return [Result(arg_3) for arg_3 in arg_2]
        else:
            return arg_2
    except:  # pragma: no cover
        raise

Return a list of matched results for a given project ID .


includes the contents of a file on disk.
  takes a filename

def Func ( arg_0 ) : arg_1 = open ( arg_0 , 'r' ) arg_2 = arg_1 . read ( ) arg_1 . close ( ) return raw ( arg_2 )

def Func(arg_0):
  '''
  Funcs the contents of a file on disk.
  takes a filename
  '''
  arg_1 = open(arg_0, 'r')
  arg_2 = arg_1.read()
  arg_1.close()
  return raw(arg_2)

includes the contents of a file on disk . takes a filename


def Func ( arg_0 ) : if len ( arg_0 . __members ) != 0 : if arg_0 . __num_processes > 1 : arg_1 = [ arg_2 . get ( ) for arg_2 in arg_0 . __members ] else : arg_1 = arg_0 . __members return median ( [ arg_2 . cost_fn_val for arg_2 in arg_1 ] ) else : return None

def Func(arg_0):
        '''Returns median cost function return value for all members'''

        if len(arg_0.__members) != 0:
            if arg_0.__num_processes > 1:
                arg_1 = [arg_2.get() for arg_2 in arg_0.__members]
            else:
                arg_1 = arg_0.__members
            return median([arg_2.cost_fn_val for arg_2 in arg_1])
        else:
            return None


(self, name, metric, time_bucket_in_sec)

def Func(arg_0, arg_1, arg_2, arg_3):
    """Registers a new metric to this context"""
    arg_4 = arg_0.get_metrics_collector()
    arg_4.Func(arg_1, arg_2, arg_3)


def Func(arg_0, arg_1):
        """Display this help message."""
        if arg_1:
            arg_2 = getattr(arg_0, 'do_' + arg_1).__doc__
            print(cyan(arg_2.replace(' ' * 8, '')))
        else:
            print(magenta('Available commands:'))
            print(magenta('Type "HELP <command>" to get more info.'))
            arg_3 = arg_0.get_names()
            arg_3.sort()
            for arg_4 in arg_3:
                if arg_4[:3] != 'do_':
                    continue
                arg_2 = getattr(arg_0, arg_4).__doc__
                arg_2 = arg_2.split('\n')[0]
                print('{} {}'.format(yellow(arg_4[3:]),
                                     cyan(arg_2.replace(' ' * 8, ' ')
                                             .replace('\n', ''))))


def
Func
(
arg_0
)
:
arg_1
=
arg_0
.
Funcection
(
arg_0
.
pinot_broker_conn_id
)
arg_2
=
connect
(
host
=
arg_1
.
host
,
port
=
arg_1
.
port
,
path
=
arg_1
.
extra_dejson
.
get
(
'endpoint'
,
'/pql'
)
,
scheme
=
arg_1
.
extra_dejson
.
get
(
'schema'
,
'http'
)
)
arg_0
.
log
.
info
(
'Get the connection to pinot '
'broker on {host}'
.
format
(
host
=
arg_1
.
host
)
)
return
arg_2

def Func(arg_0):
        """
        Establish a connection to pinot broker through pinot dbqpi.
        """
        arg_1 = arg_0.Funcection(arg_0.pinot_broker_conn_id)
        arg_2 = connect(
            host=arg_1.host,
            port=arg_1.port,
            path=arg_1.extra_dejson.get('endpoint', '/pql'),
            scheme=arg_1.extra_dejson.get('schema', 'http')
        )
        arg_0.log.info('Get the connection to pinot '
                      'broker on {host}'.format(host=arg_1.host))
        return arg_2

Establish a connection to pinot broker through pinot dbqpi .


return MDR().fit_predict(np.column_stack((X, Y)), labels)

def Func ( arg_0 , arg_1 , arg_2 ) : return MDR ( ) . fit_predict ( np . column_stack ( ( arg_0 , arg_1 ) ) , arg_2 )

def Func(arg_0, arg_1, arg_2):
    """Fits a MDR model to variables X and Y with the given labels, then returns the resulting predictions

    This is a convenience method that should only be used internally.

    Parameters
    ----------
    X: array-like (# samples)
        An array of values corresponding to one feature in the MDR model
    Y: array-like (# samples)
        An array of values corresponding to one feature in the MDR model
    labels: array-like (# samples)
        The class labels corresponding to features X and Y

    Returns
    ----------
    predictions: array-like (# samples)
        The predictions from the fitted MDR model

    """
    return MDR().fit_predict(np.column_stack((arg_0, arg_1)), arg_2)

Fits a MDR model to variables X and Y with the given labels then returns the resulting predictions


(axes,
                         stimes,
                         smags,
                         serrs,
                         magsarefluxes=False,
                         ms=2.0)

def
Func
(
arg_0
,
arg_1
,
arg_2
,
arg_3
,
arg_4
=
False
,
arg_5
=
2.0
)
:
arg_6
=
arg_1
npmin
(
arg_1
)
arg_0
.
plot
(
arg_6
,
arg_2
,
marker
=
'o'
,
arg_5
=
arg_5
,
ls
=
'None'
,
mew
=
0
,
color
=
'green'
,
rasterized
=
True
)
if
not
arg_4
:
arg_7
=
arg_0
.
get_ylim
(
)
arg_0
.
set_ylim
(
(
arg_7
[
1
]
,
arg_7
[
0
]
)
)
arg_0
.
set_xlim
(
(
npmin
(
arg_6
)
1.0
,
npmax
(
arg_6
)
+
1.0
)
)
arg_0
.
grid
(
color
=
'#a9a9a9'
,
alpha
=
0.9
,
zorder
=
0
,
linewidth
=
1.0
,
linestyle
=
':'
)
arg_8
=
'JD - %.3f'
%
npmin
(
arg_1
)
if
arg_4
:
arg_9
=
'flux'
else
:
arg_9
=
'magnitude'
arg_0
.
set_xlabel
(
arg_8
)
arg_0
.
set_ylabel
(
arg_9
)
arg_0
.
get_yaxis
(
)
.
get_major_formatter
(
)
.
set_useOffset
(
False
)
arg_0
.
get_xaxis
(
)
.
get_major_formatter
(
)
.
set_useOffset
(
False
)

def Func(arg_0,
                         arg_1,
                         arg_2,
                         arg_3,
                         arg_4=False,
                         arg_5=2.0):
    '''Makes the mag-series plot tile for `checkplot_png` and
    `twolsp_checkplot_png`.

    axes : matplotlib.axes.Axes object
        The Axes object where the generated plot will go.

    stimes,smags,serrs : np.array
        The mag/flux time-series arrays along with associated errors. These
        should all have been run through nan-stripping and sigma-clipping
        beforehand.

    magsarefluxes : bool
        If True, indicates the input time-series is fluxes and not mags so the
        plot y-axis direction and range can be set appropriately.

    ms : float
        The `markersize` kwarg to use when making the mag-series plot.

    Returns
    -------

    Does not return anything, works on the input Axes object directly.

    '''

    arg_6 = arg_1 - npmin(arg_1)

    arg_0.plot(arg_6,
              arg_2,
              marker='o',
              arg_5=arg_5, ls='None',mew=0,
              color='green',
              rasterized=True)

    # flip y axis for mags
    if not arg_4:
        arg_7 = arg_0.get_ylim()
        arg_0.set_ylim((arg_7[1], arg_7[0]))

    # set the x axis limit
    arg_0.set_xlim((npmin(arg_6)-1.0,
                   npmax(arg_6)+1.0))

    # make a grid
    arg_0.grid(color='#a9a9a9',
              alpha=0.9,
              zorder=0,
              linewidth=1.0,
              linestyle=':')

    # make the x and y axis labels
    arg_8 = 'JD - %.3f' % npmin(arg_1)
    if arg_4:
        arg_9 = 'flux'
    else:
        arg_9 = 'magnitude'

    arg_0.set_xlabel(arg_8)
    arg_0.set_ylabel(arg_9)

    # fix the yaxis ticks (turns off offset and uses the full
    # value of the yaxis tick)
    arg_0.get_yaxis().get_major_formatter().set_useOffset(False)
    arg_0.get_xaxis().get_major_formatter().set_useOffset(False)

Makes the mag - series plot tile for checkplot_png and twolsp_checkplot_png .


def Func(arg_0, arg_1):
        """Returns an HDF5 node by the path specified in `name`"""
        arg_2 = arg_1.replace('.', '/')
        arg_3 = '/%s/%s' % (arg_0._trajectory_name, arg_2)
        return arg_0._hdf5file.get_node(arg_3=arg_3)

Returns an HDF5 node by the path specified in name


(store, request_args, institute_id, case_name)

def Func ( arg_0 , arg_1 , arg_2 , arg_3 ) : arg_4 , arg_5 = institute_and_case ( arg_0 , arg_2 , arg_3 ) arg_6 = CancerFiltersForm ( arg_1 ) arg_7 = arg_0 . variants ( arg_5 [ '_id' ] , category = 'cancer' , query = arg_6 . data ) . limit ( 50 ) arg_8 = dict ( institute = arg_4 , case = arg_5 , variants = ( parse_variant ( arg_0 , arg_4 , arg_5 , variant , update = True ) for variant in arg_7 ) , arg_6 = arg_6 , variant_type = arg_1 . get ( 'variant_type' , 'clinical' ) , ) return arg_8

def Func(arg_0, arg_1, arg_2, arg_3):
    """Fetch data related to cancer variants for a case."""
    arg_4, arg_5 = institute_and_case(arg_0, arg_2, arg_3)
    arg_6 = CancerFiltersForm(arg_1)
    arg_7 = arg_0.variants(arg_5['_id'], category='cancer', query=arg_6.data).limit(50)
    arg_8 = dict(
        institute=arg_4,
        case=arg_5,
        variants=(parse_variant(arg_0, arg_4, arg_5, variant, update=True) for
                  variant in arg_7),
        arg_6=arg_6,
        variant_type=arg_1.get('variant_type', 'clinical'),
    )
    return arg_8

Fetch data related to cancer variants for a case .


Actually draws the model of the given object to the render target.

        Note that if the batch used for this object already existed, drawing will be skipped as the batch should be drawn by the owner of it.

def Func ( arg_0 , arg_1 ) : arg_0 . ensureModelData ( arg_1 ) arg_2 = arg_1 . _modeldata if arg_2 . get ( "_manual_render" , False ) : arg_1 . batch3d . Func ( )

def Func(arg_0,arg_1):
        """
        Actually Funcs the model of the given object to the render target.

        Note that if the batch used for this object already existed, Funcing will be skipped as the batch should be Funcn by the owner of it.
        """
        arg_0.ensureModelData(arg_1)

        arg_2 = arg_1._modeldata
        if arg_2.get("_manual_render",False):
            arg_1.batch3d.Func()

Actually draws the model of the given object to the render target . Note that if the batch used for this object already existed drawing will be skipped as the batch should be drawn by the owner of it .


def Func(arg_0):
        """Index of the first produced mesh in the row that consumes it.

        :return: an index of the first produced mesh of rows produced meshes
        :rtype: int

        .. note:: If the instruction :meth:`produces meshes
          <Instruction.produces_meshes>`, this is the index of the first
          mesh the instruction produces in all the meshes of the row.
          If the instruction does not produce meshes, the index of the mesh is
          returned as if the instruction had produced a mesh.

        .. code::

            if instruction.produces_meshes():
                index = instruction.Func

        """
        arg_1 = 0
        for arg_2 in arg_0.row_instructions:
            if arg_2 is arg_0:
                break
            arg_1 += arg_2.number_of_produced_meshes
        else:
            arg_0._raise_not_found_error()
        return arg_1

Index of the first produced mesh in the row that consumes it.

        :return: an index of the first produced mesh of rows produced meshes
        :rtype: int

        .. note:: If the instruction :meth:`produces meshes
          <Instruction.produces_meshes>`, this is the index of the first
          mesh the instruction produces in all the meshes of the row.
          If the instruction does not produce meshes, the index of the mesh is
          returned as if the instruction had produced a mesh.

        .. code::

            if instruction.produces_meshes():
                index = instruction.index_of_first_produced_mesh_in_row

Index of the first produced mesh in the row that consumes it .


Handles requests to the user signup page.

return render(
        request,
        'registration/signup.html',
        {
            'form': form,
            'email': invite.email
        }
    )

def
Func
(
arg_0
,
arg_1
=
)
:
arg_2
=
get_object_or_404
(
Invite
.
objects
.
all
(
)
,
id
=
arg_1
)
if
arg_2
.
expiration_date
<
timezone
.
now
(
)
:
arg_2
.
delete
(
)
raise
Http404
(
'This page does not exist.'
)
if
arg_0
.
method
==
'POST'
:
arg_3
=
SignUpForm
(
arg_0
.
POST
)
if
arg_3
.
is_valid
(
)
:
arg_4
=
arg_3
.
save
(
commit
=
False
)
arg_4
.
email
=
arg_2
.
email
arg_4
.
person
=
arg_2
.
person
arg_4
.
save
(
)
if
arg_2
.
permissions
==
'admin'
:
arg_7
=
Group
.
objects
.
get
(
name
=
'Admin'
)
arg_4
.
groups
.
add
(
arg_7
)
arg_2
.
delete
(
)
return
redirect
(
'dispatch-admin'
)
else
:
return
render
(
arg_0
,
'registration/Func.html'
,
{
'form'
:
arg_3
,
'email'
:
arg_2
.
email
}
)
else
:
arg_3
=
SignUpForm
(
)
return
render
(
arg_0
,
'registration/Func.html'
,
{
'form'
:
arg_3
,
'email'
:
arg_2
.
email
}
)

def Func(arg_0, arg_1=None):
    """Handles requests to the user Func page."""

    arg_2 = get_object_or_404(Invite.objects.all(), id=arg_1)

    if arg_2.expiration_date < timezone.now():
        arg_2.delete()
        raise Http404('This page does not exist.')

    if arg_0.method == 'POST':
        arg_3 = SignUpForm(arg_0.POST)
        if arg_3.is_valid():
            arg_4 = arg_3.save(commit=False)

            arg_4.email = arg_2.email
            arg_4.person = arg_2.person

            arg_4.save()

            if arg_2.permissions == 'admin':
                arg_7 = Group.objects.get(name='Admin')
                arg_4.groups.add(arg_7)

            arg_2.delete()

            return redirect('dispatch-admin')
        else:
            return render(
                arg_0,
                'registration/Func.html',
                {
                    'form': arg_3,
                    'email': arg_2.email
                }
            )

    else:
        arg_3 = SignUpForm()

    return render(
        arg_0,
        'registration/Func.html',
        {
            'form': arg_3,
            'email': arg_2.email
        }
    )

Handles requests to the user signup page .


def Func(arg_0, arg_1, arg_2):
        """Return the prefix Funcilarity of two strings.

        Prefix Funcilarity is the ratio of the length of the shorter term that
        exactly matches the longer term to the length of the shorter term,
        beginning at the start of both terms.

        Parameters
        ----------
        src : str
            Source string for comparison
        tar : str
            Target string for comparison

        Returns
        -------
        float
            Prefix Funcilarity

        Examples
        --------
        >>> cmp = Prefix()
        >>> cmp.Func('cat', 'hat')
        0.0
        >>> cmp.Func('Niall', 'Neil')
        0.25
        >>> cmp.Func('aluminum', 'Catalan')
        0.0
        >>> cmp.Func('ATCG', 'TAGC')
        0.0

        """
        if arg_1 == arg_2:
            return 1.0
        if not arg_1 or not arg_2:
            return 0.0
        arg_3, arg_4 = (arg_1, arg_2) if len(arg_1) < len(arg_2) else (arg_2, arg_1)
        arg_5 = len(arg_3)
        for arg_6 in range(arg_5, 0, -1):
            if arg_3[:arg_6] == arg_4[:arg_6]:
                return arg_6 / arg_5
        return 0.0

Return the prefix similarity of two strings.

        Prefix similarity is the ratio of the length of the shorter term that
        exactly matches the longer term to the length of the shorter term,
        beginning at the start of both terms.

        Parameters
        ----------
        src : str
            Source string for comparison
        tar : str
            Target string for comparison

        Returns
        -------
        float
            Prefix similarity

        Examples
        --------
        >>> cmp = Prefix()
        >>> cmp.sim('cat', 'hat')
        0.0
        >>> cmp.sim('Niall', 'Neil')
        0.25
        >>> cmp.sim('aluminum', 'Catalan')
        0.0
        >>> cmp.sim('ATCG', 'TAGC')
        0.0

Return the prefix similarity of two strings .


def Func(arg_0):
        """
        Return instances of all other tabs that are members of the tab's
        tab group.
        """
        if arg_0.tab_group is None:
            raise ImproperlyConfigured(
                "%s requires a definition of 'tab_group'" %
                arg_0.__class__.__name__)
        arg_1 = [arg_2 for arg_2 in arg_0._registry if arg_2.tab_group == arg_0.tab_group]
        return [arg_2() for arg_2 in arg_1]

Return instances of all other tabs that are members of the tab s tab group .


def Func ( arg_0 , arg_1 ) : arg_2 = arg_0 . get_conn ( ) arg_3 = ( arg_2 . projects ( ) . allocateIds ( projectId = arg_0 . project_id , body = { 'keys' : arg_1 } ) . execute ( num_retries = arg_0 . num_retries ) ) return arg_3 [ 'keys' ]

def Func(arg_0, arg_1):
        """
        Allocate IDs for incomplete keys.

        .. seealso::
            https://cloud.google.com/datastore/docs/reference/rest/v1/projects/allocateIds

        :param partial_keys: a list of partial keys.
        :type partial_keys: list
        :return: a list of full keys.
        :rtype: list
        """
        arg_2 = arg_0.get_conn()

        arg_3 = (arg_2
                .projects()
                .allocateIds(projectId=arg_0.project_id, body={'keys': arg_1})
                .execute(num_retries=arg_0.num_retries))

        return arg_3['keys']


def Func ( arg_0 , arg_1 = None , arg_2 = None ) : return arg_0 . deepFunc ( arg_1 = arg_1 , arg_2 = arg_2 )

def Func(arg_0, arg_1=None, arg_2=None):
        """
        Create a shallow Func of the Polygon object.

        Parameters
        ----------
        exterior : list of imgaug.Keypoint or list of tuple or (N,2) ndarray, optional
            List of points defining the polygon. See :func:`imgaug.Polygon.__init__` for details.

        label : None or str, optional
            If not None, then the label of the copied object will be set to this value.

        Returns
        -------
        imgaug.Polygon
            Shallow Func.

        """
        return arg_0.deepFunc(arg_1=arg_1, arg_2=arg_2)

Create a shallow copy of the Polygon object.

        Parameters
        ----------
        exterior : list of imgaug.Keypoint or list of tuple or (N,2) ndarray, optional
            List of points defining the polygon. See :func:`imgaug.Polygon.__init__` for details.

        label : None or str, optional
            If not None, then the label of the copied object will be set to this value.

        Returns
        -------
        imgaug.Polygon
            Shallow copy.

Create a shallow copy of the Polygon object .


return GeneratedPyAST(
        node=ast.Name(
            id=Maybe(_MODULE_ALIASES.get(node.class_)).or_else_get(node.class_),
            ctx=ast.Load(),
        )
    )

def Func ( arg_0 : arg_1 , arg_2 : arg_3 ) -> GeneratedPyAST : assert arg_2 . op == NodeOp . MAYBE_CLASS return GeneratedPyAST ( arg_2 = ast . Name ( id = Maybe ( _MODULE_ALIASES . get ( arg_2 . class_ ) ) . or_else_get ( arg_2 . class_ ) , ctx = ast . Load ( ) , ) )

def Func(arg_0: arg_1, arg_2: arg_3) -> GeneratedPyAST:
    """Generate a Python AST node for accessing a potential Python module
    variable name."""
    assert arg_2.op == NodeOp.MAYBE_CLASS
    return GeneratedPyAST(
        arg_2=ast.Name(
            id=Maybe(_MODULE_ALIASES.get(arg_2.class_)).or_else_get(arg_2.class_),
            ctx=ast.Load(),
        )
    )

Generate a Python AST node for accessing a potential Python module variable name .


def Func ( arg_0 , arg_1 ) : if arg_0 . METADATA [ "data_type" ] == "raster" : if is_numpy_or_masked_array ( arg_1 ) : return arg_1 elif is_numpy_or_masked_array_with_tags ( arg_1 ) : arg_2 , arg_3 = arg_1 return arg_0 . Func ( arg_2 ) , arg_3 elif arg_0 . METADATA [ "data_type" ] == "vector" : return list ( arg_1 )

def Func(arg_0, arg_1):
        """
        Return verified and cleaned output.

        Parameters
        ----------
        process_data : raw process output

        Returns
        -------
        NumPy array or list of features.
        """
        if arg_0.METADATA["data_type"] == "raster":
            if is_numpy_or_masked_array(arg_1):
                return arg_1
            elif is_numpy_or_masked_array_with_tags(arg_1):
                arg_2, arg_3 = arg_1
                return arg_0.Func(arg_2), arg_3
        elif arg_0.METADATA["data_type"] == "vector":
            return list(arg_1)


def Func ( arg_0 ) : for arg_1 in arg_0 : for arg_2 in arg_1 . tokens : if OffsetType . CHARS in arg_2 . offsets : yield arg_2

def Func(arg_0):
    '''Convert stream item sentences to character ``Offset``s.'''
    for arg_1 in arg_0:
        for arg_2 in arg_1.tokens:
            if OffsetType.CHARS in arg_2.offsets:
                yield arg_2

Convert stream item sentences to character Offset s .


(name, date, description='', id='', granularity='sec', start=None,
  progressbar=False, progressbar_inversed=False, showpct=False)

'<div class="progress progress-striped active">'

'<div class="progress-bar"  role="progressbar" aria-valuenow="{pct}" aria-valuemin="0" aria-valuemax="100" style="width: {pct}%">'

def Func(arg_0, arg_1, arg_2='', arg_3='', arg_4='sec', arg_5=None,
  arg_6=False, arg_7=False, arg_8=False):
    '''
    Create a Func.
    '''

    arg_9 = dateparse.parse_datetime(arg_1)
    arg_10 = dateformat.format(arg_9, 'U')

    arg_11 = '
' + arg_0 + '
'
    arg_11 += '
' + arg_2 + '
'

    if arg_6:
        if not arg_10: raise Exception('For progressbar, start date is requried.')
        arg_12 = datetime.datetime.combine(
            dateparse.parse_date(arg_5), datetime.time())
        arg_13 = dateparse.parse_datetime(arg_5) or arg_12
        arg_14 = datetime.datetime.now()

        arg_15 = (arg_14 - arg_13).total_seconds() /\
            (arg_9 - arg_13).total_seconds()
        arg_15 = int(arg_15 * 100)

        if arg_7:
            arg_15 = 100 - arg_15

        # Note: the output is for bootstrap!
        arg_16 = '
'
        arg_16 += '
'
        arg_16 += '{pct}% Complete'
        arg_16 += '
'
        arg_16 += '
'

        if arg_8:
            arg_16 += '
{pct}%
'

        arg_16 = arg_16.format(arg_15=arg_15)

        arg_11 += arg_16

    arg_11 += '

'

    arg_17 = {
    	'class': 'Funcbox',
    	'data-datetime': arg_10,
    	'data-granularity': arg_4
    }
    if arg_3:
        arg_17['id'] = arg_3

    return html.tag('div', arg_11, arg_17)


(
    host,
    port=22223,
    version="1.19",
    on_event=None,
    on_disconnect=None,
    timeout=5,
    loop=None,
)

async def Func ( arg_0 , arg_1 = 22223 , arg_2 = "1.19" , arg_3 = None , arg_4 = None , arg_5 = 5 , arg_6 = None , ) -> QRTConnection : arg_6 = arg_6 or asyncio . get_event_loop ( ) try : arg_7 , arg_8 = await arg_6 . create_Funcion ( lambda : QTMProtocol ( arg_6 = arg_6 , arg_3 = arg_3 , arg_4 = arg_4 ) , arg_0 , arg_1 , ) except ( ConnectionRefusedError , TimeoutError , OSError ) as exception : LOG . error ( exception ) return None try : await arg_8 . set_version ( arg_2 ) except QRTCommandException as exception : LOG . error ( Exception ) return None except TypeError as exception : LOG . error ( exception ) return None return QRTConnection ( arg_8 , arg_5 = arg_5 )

async def Func(
    arg_0,
    arg_1=22223,
    arg_2="1.19",
    arg_3=None,
    arg_4=None,
    arg_5=5,
    arg_6=None,
) -> QRTConnection:
    """Async function to Func to QTM

    :param host: Address of the computer running QTM.
    :param port: Port number to Func to, should be the port configured for little endian.
    :param version: What version of the protocol to use, tested for 1.17 and above but could
        work with lower versions as well.
    :param on_disFunc: Function to be called when a disFunc from QTM occurs.
    :param on_event: Function to be called when there's an event from QTM.
    :param timeout: The default timeout time for calls to QTM.
    :param loop: Alternative event loop, will use asyncio default if None.

    :rtype: A :class:`.QRTConnection`
    """
    arg_6 = arg_6 or asyncio.get_event_loop()

    try:
        arg_7, arg_8 = await arg_6.create_Funcion(
            lambda: QTMProtocol(
                arg_6=arg_6, arg_3=arg_3, arg_4=arg_4
            ),
            arg_0,
            arg_1,
        )
    except (ConnectionRefusedError, TimeoutError, OSError) as exception:
        LOG.error(exception)
        return None

    try:
        await arg_8.set_version(arg_2)
    except QRTCommandException as exception:
        LOG.error(Exception)
        return None
    except TypeError as exception:  # TODO: fix test requiring this (test_Func_set_version)
        LOG.error(exception)
        return None

    return QRTConnection(arg_8, arg_5=arg_5)

Async function to connect to QTM

    :param host: Address of the computer running QTM.
    :param port: Port number to connect to, should be the port configured for little endian.
    :param version: What version of the protocol to use, tested for 1.17 and above but could
        work with lower versions as well.
    :param on_disconnect: Function to be called when a disconnect from QTM occurs.
    :param on_event: Function to be called when there's an event from QTM.
    :param timeout: The default timeout time for calls to QTM.
    :param loop: Alternative event loop, will use asyncio default if None.

    :rtype: A :class:`.QRTConnection`


return last.header.p_vaddr + last.header.p_memsz

def Func ( arg_0 ) : arg_1 = [ x for x in arg_0 . iter_segments ( ) if x . header . p_type == 'PT_LOAD' ] arg_2 = arg_1 [ - 1 ] return arg_2 . header . p_vaddr + arg_2 . header . p_memsz

def Func(arg_0):
        """
        Compute total load size of interpreter.

        :param ELFFile interp: interpreter ELF .so
        :return: total load size of interpreter, not aligned
        :rtype: int
        """
        arg_1 = [x for x in arg_0.iter_segments() if x.header.p_type == 'PT_LOAD']
        arg_2 = arg_1[-1]
        return arg_2.header.p_vaddr + arg_2.header.p_memsz

Compute total load size of interpreter .


(data, NFFT=None,  sampling=1., **kargs)

def Func(arg_0, arg_1=None,  arg_2=1., **arg_3):
    r"""Simple periodogram wrapper of numpy.psd function.

    :param A: the input data
    :param int NFFT: total length of the final data sets (padded
        with zero if needed; default is 4096)
    :param str window:

    :Technical documentation:

    When we calculate the periodogram of a set of data we get an estimation
    of the spectral density. In fact as we use a Fourier transform and a
    truncated segments the spectrum is the convolution of the data with a
    rectangular window which Fourier transform is

    .. math::

        W(s)= \frac{1}{N^2} \left[ \frac{\sin(\pi s)}{\sin(\pi s/N)} \right]^2

    Thus oscillations and sidelobes appears around the main frequency. One aim of t he tapering is to reduced this effects. We multiply data by a window whose  sidelobes are much smaller than the main lobe. Classical window is hanning window.  But other windows are available. However we must take into account this energy and divide the spectrum by energy of taper used. Thus periodogram becomes :

    .. math::

        D_k \equiv \sum_{j=0}^{N-1}c_jw_j \; e^{2\pi ijk/N}  \qquad k=0,...,N-1

    .. math::

        P(0)=P(f_0)=\frac{1}{2\pi W_{ss}}\arrowvert{D_0}\arrowvert^2

    .. math::

        P(f_k)=\frac{1}{2\pi W_{ss}} \left[\arrowvert{D_k}\arrowvert^2+\arrowvert{D_{N-k}}\arrowvert^2\right]        \qquad k=0,1,...,     \left( \frac{1}{2}-1 \right)

    .. math::

        P(f_c)=P(f_{N/2})= \frac{1}{2\pi W_{ss}} \arrowvert{D_{N/2}}\arrowvert^2

    with

    .. math::

        {W_{ss}} \equiv N\sum_{j=0}^{N-1}w_j^2

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

        from spectrum import Func, marple_data
        psd = Func(marple_data, 256)

    """
    from pylab import arg_6
    arg_4 = Spectrum(arg_0, arg_2=1.)

    arg_5 = arg_6(arg_0, arg_1, Fs=arg_2, **arg_3)
    arg_4.psd = arg_5[0]
    #spectrum.__Spectrum_sides = 'twosided'

    return arg_5, arg_4

r"""Simple periodogram wrapper of numpy.psd function.

    :param A: the input data
    :param int NFFT: total length of the final data sets (padded
        with zero if needed; default is 4096)
    :param str window:

    :Technical documentation:

    When we calculate the periodogram of a set of data we get an estimation
    of the spectral density. In fact as we use a Fourier transform and a
    truncated segments the spectrum is the convolution of the data with a
    rectangular window which Fourier transform is

    .. math::

        W(s)= \frac{1}{N^2} \left[ \frac{\sin(\pi s)}{\sin(\pi s/N)} \right]^2

    Thus oscillations and sidelobes appears around the main frequency. One aim of t he tapering is to reduced this effects. We multiply data by a window whose  sidelobes are much smaller than the main lobe. Classical window is hanning window.  But other windows are available. However we must take into account this energy and divide the spectrum by energy of taper used. Thus periodogram becomes :

    .. math::

        D_k \equiv \sum_{j=0}^{N-1}c_jw_j \; e^{2\pi ijk/N}  \qquad k=0,...,N-1

    .. math::

        P(0)=P(f_0)=\frac{1}{2\pi W_{ss}}\arrowvert{D_0}\arrowvert^2

    .. math::

        P(f_k)=\frac{1}{2\pi W_{ss}} \left[\arrowvert{D_k}\arrowvert^2+\arrowvert{D_{N-k}}\arrowvert^2\right]        \qquad k=0,1,...,     \left( \frac{1}{2}-1 \right)

    .. math::

        P(f_c)=P(f_{N/2})= \frac{1}{2\pi W_{ss}} \arrowvert{D_{N/2}}\arrowvert^2

    with

    .. math::

        {W_{ss}} \equiv N\sum_{j=0}^{N-1}w_j^2

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

        from spectrum import WelchPeriodogram, marple_data
        psd = WelchPeriodogram(marple_data, 256)

r Simple periodogram wrapper of numpy . psd function .


def Func ( arg_0 , arg_1 ) : print ( "Func:" ) arg_2 = [ ] for arg_3 in arg_1 [ : : 2 ] : arg_2 . append ( chr ( arg_3 ) ) print ( "" . join ( arg_2 ) )

def Func(arg_0, arg_1):
        """
        This method handles the incoming string data message from Firmata.
        The string is printed to the console

        :param data: Message data from Firmata

        :return: No return value.s
        """
        print("Func:")
        arg_2 = []
        for arg_3 in arg_1[::2]:
            arg_2.append(chr(arg_3))
        print("".join(arg_2))

This method handles the incoming string data message from Firmata . The string is printed to the console


(memory, att_size, mask, keep_prob=1.0, scope="simple_attention")

def Func ( arg_0 , arg_1 , arg_2 , arg_3 = 1.0 , arg_4 = "Func" ) : with tf . variable_scope ( arg_4 ) : arg_5 , arg_6 , arg_7 = tf . unstack ( tf . shape ( arg_0 ) ) arg_8 = tf . nn . dropout ( arg_0 , arg_3 = arg_3 , noise_shape = [ arg_5 , 1 , arg_7 ] ) arg_9 = tf . layers . dense ( tf . layers . dense ( arg_8 , arg_1 , activation = tf . nn . tanh ) , 1 , use_bias = False ) arg_9 = softmax_mask ( tf . squeeze ( arg_9 , [ 2 ] ) , arg_2 ) arg_10 = tf . expand_dims ( tf . nn . softmax ( arg_9 ) , axis = 2 ) arg_11 = tf . reduce_sum ( arg_10 * arg_0 , axis = 1 ) return arg_11

def Func(arg_0, arg_1, arg_2, arg_3=1.0, arg_4="Func"):
    """Simple attention without any conditions.

       Computes weighted sum of memory elements.
    """
    with tf.variable_scope(arg_4):
        arg_5, arg_6, arg_7 = tf.unstack(tf.shape(arg_0))
        arg_8 = tf.nn.dropout(arg_0, arg_3=arg_3, noise_shape=[arg_5, 1, arg_7])
        arg_9 = tf.layers.dense(tf.layers.dense(arg_8, arg_1, activation=tf.nn.tanh), 1, use_bias=False)
        arg_9 = softmax_mask(tf.squeeze(arg_9, [2]), arg_2)
        arg_10 = tf.expand_dims(tf.nn.softmax(arg_9), axis=2)
        arg_11 = tf.reduce_sum(arg_10 * arg_0, axis=1)
        return arg_11

Simple attention without any conditions .


def
Func
(
arg_0
,
arg_1
,
arg_2
)
->
str
:
arg_3
=
list
(
arg_1
.
QueryDatabases
(
{
"query"
:
"SELECT * FROM r WHERE r.id=@id"
,
"parameters"
:
[
{
"name"
:
"@id"
,
"value"
:
arg_2
}
]
}
)
)
if
len
(
arg_3
)
>
0
:
return
arg_3
[
0
]
[
'id'
]
else
:
arg_4
=
arg_1
.
CreateDatabase
(
{
'id'
:
arg_2
}
)
return
arg_4
[
'id'
]

def Func(arg_0, arg_1, arg_2) -> str:
        """Return the database link.

        Check if the database exists or create the db.

        :param doc_client:
        :param id:
        :return str:
        """
        # query CosmosDB for a database with that name/id
        arg_3 = list(arg_1.QueryDatabases({
            "query": "SELECT * FROM r WHERE r.id=@id",
            "parameters": [
                {"name": "@id", "value": arg_2}
            ]
        }))
        # if there are results, return the first (db names are unique)
        if len(arg_3) > 0:
            return arg_3[0]['id']
        else:
            # create the database if it didn't exist
            arg_4 = arg_1.CreateDatabase({'id': arg_2})
            return arg_4['id']


def
Func
(
arg_0
,
*
arg_1
)
:
arg_0
.
_borrowers
.
extend
(
arg_1
)
debug
.
logger
&
debug
.
flagCompiler
and
debug
.
logger
(
'current MIB borrower(s): %s'
%
', '
.
join
(
[
str
(
arg_2
)
for
arg_2
in
arg_0
.
_borrowers
]
)
)
return
arg_0

def Func(arg_0, *arg_1):
        """Add more transformed MIBs repositories to borrow MIBs from.

        Whenever MibCompiler.compile encounters MIB module which neither of
        the *searchers* can find or fetched ASN.1 MIB module can not be
        parsed (due to syntax errors), these *borrowers* objects will be
        invoked in order of their addition asking each if already transformed
        MIB can be fetched (borrowed).

        Args:
            borrowers: borrower object(s)

        Returns:
            reference to itself (can be used for call chaining)

        """
        arg_0._borrowers.extend(arg_1)

        debug.logger & debug.flagCompiler and debug.logger(
            'current MIB borrower(s): %s' % ', '.join([str(arg_2) for arg_2 in arg_0._borrowers]))

        return arg_0

Add more transformed MIBs repositories to borrow MIBs from .


def
Func
(
arg_0
,
arg_1
)
:
arg_2
=
doc_by_id
(
arg_1
)
if
not
arg_2
:
return
arg_0
.
error
(
'id "{}" not found'
.
format
(
arg_1
)
)
for
arg_3
in
config
.
FIELDS
:
arg_4
=
arg_3
[
'key'
]
if
arg_4
in
arg_2
:
arg_0
.
_print_field_index_details
(
arg_2
[
arg_4
]
,
arg_1
)

def Func(arg_0, arg_1):
        """Get index details for a document by its id.
        INDEX 772210180J"""
        arg_2 = doc_by_id(arg_1)
        if not arg_2:
            return arg_0.error('id "{}" not found'.format(arg_1))
        for arg_3 in config.FIELDS:
            arg_4 = arg_3['key']
            if arg_4 in arg_2:
                arg_0._print_field_index_details(arg_2[arg_4], arg_1)

Get index details for a document by its id . INDEX 772210180J


def
Func
(
arg_0
,
arg_1
,
arg_2
)
:
arg_3
=
sorted
(
np
.
unique
(
arg_2
)
)
if
len
(
arg_3
)
!=
2
:
raise
ValueError
(
'MDR only supports binary endpoints.'
)
arg_0
.
class_count_matrix
=
defaultdict
(
lambda
:
defaultdict
(
int
)
)
for
arg_5
in
range
(
arg_1
.
shape
[
0
]
)
:
arg_6
=
tuple
(
arg_1
[
arg_5
]
)
arg_0
.
class_count_matrix
[
arg_6
]
[
arg_2
[
arg_5
]
]
+=
1
arg_0
.
class_count_matrix
=
dict
(
arg_0
.
class_count_matrix
)
arg_7
=
float
(
sum
(
arg_2
==
arg_3
[
0
]
)
)
/
arg_2
.
size
arg_0
.
feature_map
=
{
}
for
arg_6
in
arg_0
.
class_count_matrix
:
arg_9
=
arg_0
.
class_count_matrix
[
arg_6
]
arg_10
=
float
(
arg_9
[
arg_3
[
0
]
]
)
/
np
.
sum
(
list
(
arg_9
.
values
(
)
)
)
if
arg_10
>
arg_7
:
arg_0
.
feature_map
[
arg_6
]
=
arg_3
[
0
]
elif
arg_10
==
arg_7
:
arg_0
.
feature_map
[
arg_6
]
=
arg_0
.
tie_break
else
:
arg_0
.
feature_map
[
arg_6
]
=
arg_3
[
1
]
return
arg_0

def Func(arg_0, arg_1, arg_2):
        """Constructs the MDR feature map from the provided training data.

        Parameters
        ----------
        features: array-like {n_samples, n_features}
            Feature matrix
        class_labels: array-like {n_samples}
            List of true class labels

        Returns
        -------
        self: A copy of the Functed model

        """
        arg_3 = sorted(np.unique(arg_2))
        if len(arg_3) != 2:
            raise ValueError('MDR only supports binary endpoints.')

        # Count the distribution of classes that fall into each MDR grid cell
        arg_0.class_count_matrix = defaultdict(lambda: defaultdict(int))
        for arg_5 in range(arg_1.shape[0]):
            arg_6 = tuple(arg_1[arg_5])
            arg_0.class_count_matrix[arg_6][arg_2[arg_5]] += 1
        arg_0.class_count_matrix = dict(arg_0.class_count_matrix)

        # Only applies to binary classification
        arg_7 = float(sum(arg_2 == arg_3[0])) / arg_2.size

        # If one class is more abundant in a MDR grid cell than it is overall, then assign the cell to that class
        arg_0.feature_map = {}
        for arg_6 in arg_0.class_count_matrix:
            arg_9 = arg_0.class_count_matrix[arg_6]
            arg_10 = float(arg_9[arg_3[0]]) / np.sum(list(arg_9.values()))
            if arg_10 > arg_7:
                arg_0.feature_map[arg_6] = arg_3[0]
            elif arg_10 == arg_7:
                arg_0.feature_map[arg_6] = arg_0.tie_break
            else:
                arg_0.feature_map[arg_6] = arg_3[1]

        return arg_0

Constructs the MDR feature map from the provided training data.

        Parameters
        ----------
        features: array-like {n_samples, n_features}
            Feature matrix
        class_labels: array-like {n_samples}
            List of true class labels

        Returns
        -------
        self: A copy of the fitted model

Constructs the MDR feature map from the provided training data .


def
Func
(
arg_0
,
arg_1
,
arg_2
)
:
if
arg_2
<=
0
:
raise
ValueError
(
"n must be strictly positive"
)
arg_3
=
numpy
.
linspace
(
arg_0
,
arg_1
,
arg_2
)
arg_4
=
numpy
.
cos
(
5
*
arg_3
)
*
numpy
.
exp
(
arg_3
**
2
/
2.
)
return
arg_4

def Func(arg_0, arg_1, arg_2):
    r"""Generate the Morlet waveform

    The Morlet waveform is defined as follows:

    .. math:: w[x] = \cos{5x}  \exp^{-x^2/2}

    :param lb: lower bound
    :param ub: upper bound
    :param int n: waveform data samples

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

        from spectrum import Func
        from pylab import plot
        plot(Func(0,10,100))

    """
    if arg_2 <= 0:
        raise ValueError("n must be strictly positive")

    arg_3 = numpy.linspace(arg_0, arg_1, arg_2)
    arg_4 = numpy.cos(5*arg_3) * numpy.exp(-arg_3**2/2.)
    return arg_4

r"""Generate the Morlet waveform

    The Morlet waveform is defined as follows:

    .. math:: w[x] = \cos{5x}  \exp^{-x^2/2}

    :param lb: lower bound
    :param ub: upper bound
    :param int n: waveform data samples

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

        from spectrum import morlet
        from pylab import plot
        plot(morlet(0,10,100))


return self._perform_delete(
            '/' + self.subscription_id + '/certificates/' + _str(thumbprint))

def Func ( arg_0 , arg_1 ) : _validate_not_none ( 'thumbprint' , arg_1 ) return arg_0 . _perform_delete ( '/' + arg_0 . subscription_id + '/certificates/' + _str ( arg_1 ) )

def Func(arg_0, arg_1):
        '''
        The Delete Management Certificate operation deletes a certificate from
        the list of management certificates. Management certificates, which
        are also known as subscription certificates, authenticate clients
        attempting to connect to resources associated with your Windows Azure
        subscription.

        thumbprint:
            The thumb print that uniquely identifies the management
            certificate.
        '''
        _validate_not_none('thumbprint', arg_1)
        return arg_0._perform_delete(
            '/' + arg_0.subscription_id + '/certificates/' + _str(arg_1))

The Delete Management Certificate operation deletes a certificate from the list of management certificates . Management certificates which are also known as subscription certificates authenticate clients attempting to connect to resources associated with your Windows Azure subscription .


def Func(arg_0, arg_1):
    """
    Return track selection url for the given course.

    Arguments:
        course_run (dict): A dictionary containing course run metadata.
        query_parameters (dict): A dictionary containing query parameters to be added to course selection url.

    Raises:
        (KeyError): Raised when course run dict does not have 'key' key.

    Returns:
        (str): Course track selection url.

    """
    try:
        arg_2 = reverse('course_modes_choose', kwargs={'course_id': arg_0['key']})
    except KeyError:
        LOGGER.exception(
            "KeyError while parsing course run data.\nCourse Run: \n[%s]", arg_0,
        )
        raise

    arg_3 = '{}{}'.format(
        settings.LMS_ROOT_URL,
        arg_2
    )
    arg_4 = update_query_parameters(arg_3, arg_1)

    return arg_4

Return track selection url for the given course .


return min(min_x), min(min_y), max(max_x), max(max_y)

def Func ( arg_0 ) : arg_1 , arg_2 , arg_3 , arg_4 = zip ( * list ( arg_0 . walk_rows ( lambda row : row . Func ) ) ) return min ( arg_1 ) , min ( arg_2 ) , max ( arg_3 ) , max ( arg_4 )

def Func(arg_0):
        """The minimum and maximum bounds of this layout.

        :return: ``(min_x, min_y, max_x, max_y)`` the bounding box
          of this layout
        :rtype: tuple
        """
        arg_1, arg_2, arg_3, arg_4 = zip(*list(arg_0.walk_rows(
            lambda row: row.Func)))
        return min(arg_1), min(arg_2), max(arg_3), max(arg_4)

The minimum and maximum bounds of this layout .


def Func ( arg_0 ) : arg_1 = { "type" : arg_0 . type , "data" : arg_0 . data , "name" : arg_0 . name , "priority" : arg_0 . priority , "port" : arg_0 . port , "ttl" : arg_0 . ttl , "weight" : arg_0 . weight , "flags" : arg_0 . flags , "tags" : arg_0 . tags } arg_2 = arg_0 . get_data ( "domains/%s/records" % ( arg_0 . domain ) , type = POST , params = arg_1 , ) if arg_2 : arg_0 . id = arg_2 [ 'domain_record' ] [ 'id' ]

def Func(arg_0):
        """
        Creates a new record for a domain.

        Args:
            type (str): The type of the DNS record (e.g. A, CNAME, TXT).
            name (str): The host name, alias, or service being defined by the
                record.
            data (int): Variable data depending on record type.
            priority (int): The priority for SRV and MX records.
            port (int): The port for SRV records.
            ttl (int): The time to live for the record, in seconds.
            weight (int): The weight for SRV records.
            flags (int): An unsigned integer between 0-255 used for CAA records.
            tags (string): The parameter tag for CAA records. Valid values are
                "issue", "wildissue", or "iodef"
        """
        arg_1 = {
            "type": arg_0.type,
            "data": arg_0.data,
            "name": arg_0.name,
            "priority": arg_0.priority,
            "port": arg_0.port,
            "ttl": arg_0.ttl,
            "weight": arg_0.weight,
            "flags": arg_0.flags,
            "tags": arg_0.tags
        }

        arg_2 = arg_0.get_data(
            "domains/%s/records" % (arg_0.domain),
            type=POST,
            params=arg_1,
        )

        if arg_2:
            arg_0.id = arg_2['domain_record']['id']


def Func ( arg_0 , arg_1 = None , arg_2 = False ) : if arg_1 is None : arg_1 = [ ] if arg_2 : raise errors . OptGram elif rand . maybe ( ) : return super ( STAR , arg_0 ) . Func ( arg_1 , arg_2 = arg_2 ) else : raise errors . OptGram

def Func(arg_0, arg_1=None, arg_2=False):
        """Build the STAR field.

        :param list pre: The prerequisites list
        :param bool shortest: Whether or not the shortest reference-chain (most minimal) version of the field should be generated.
        """
        if arg_1 is None:
            arg_1 = []

        if arg_2:
            raise errors.OptGram
        elif rand.maybe():
            return super(STAR, arg_0).Func(arg_1, arg_2=arg_2)
        else:
            raise errors.OptGram