,bio_main
0,"def show_slug_with_level(context, page, lang=None, fallback=True):
    """"""Display slug with level by language.""""""
    if not lang:
        lang = context.get('lang', pages_settings.PAGE_DEFAULT_LANGUAGE)

    page = get_page_from_string_or_id(page, lang)
    if not page:
        return ''

    return {'content': page.slug_with_level(lang)}"
1,"def show_revisions(context, page, content_type, lang=None):
    """"""Render the last 10 revisions of a page content with a list using
        the ``pages/revisions.html`` template""""""
    if not pages_settings.PAGE_CONTENT_REVISION:
        return {'revisions': None}
    revisions = Content.objects.filter(page=page, language=lang,
                                type=content_type).order_by('-creation_date')
    if len(revisions) < 2:
        return {'revisions': None}
    return {'revisions': revisions[0:10]}"
2,"def do_videoplaceholder(parser, token):
    """"""
    Method that parse the imageplaceholder template tag.
    """"""
    name, params = parse_placeholder(parser, token)
    return VideoPlaceholderNode(name, **params)"
3,"def do_get_pages_with_tag(parser, token):
    """"""
    Return Pages with given tag

    Syntax::

        {% get_pages_with_tag <tag name> as <varname> %}

    Example use:
        {% get_pages_with_tag ""footer"" as pages %}
    """"""
    bits = token.split_contents()
    if 4 != len(bits):
        raise TemplateSyntaxError('%r expects 2 arguments' % bits[0])
    if bits[-2] != 'as':
        raise TemplateSyntaxError(
            '%r expects ""as"" as the second last argument' % bits[0])
    varname = bits[-1]
    tag = parser.compile_filter(bits[1])
    varname = bits[-1]
    return GetPagesWithTagNode(tag, varname)"
4,"def parserunstats(self):
        """"""Parses the XML run statistics file (GenerateFASTQRunStatistics.xml). In some cases, the file is not
        available. Equivalent data can be pulled from Basespace.Generate a text file  name indexingQC.txt containing
        the copied tables from the Indexing QC tab of the run on Basespace""""""
        # metadata = GenObject()
        # If the default file GenerateFASTQRunStatistics.xml is present, parse it
        if os.path.isfile(os.path.join(self.path, ""GenerateFASTQRunStatistics.xml"")):
            # Create a list of keys for which values are to be extracted
            datalist = [""SampleNumber"", ""SampleID"", ""SampleName"", ""NumberOfClustersPF""]
            # Load the file as an xml ElementTree object
            runstatistics = ElementTree.ElementTree(file=os.path.join(self.path, ""GenerateFASTQRunStatistics.xml""))
            # Iterate through all the elements in the object
            # .iterfind() allow for the matching and iterating though matches
            # This is stored as a float to allow subsequent calculations
            tclusterspf = [float(element.text) for element in runstatistics.iterfind(""RunStats/NumberOfClustersPF"")][0]
            # Iterate through all the elements (strains) in the OverallSamples/SummarizedSampleStatistics category
            for element in runstatistics.iterfind(""OverallSamples/SummarizedSampleStatistics""):
                # List comprehension. Essentially iterate through each element for each category in datalist:
                # (element.iter(category) and pull out the value for nestedelement
                straindata = [nestedelement.text for category in datalist for nestedelement in element.iter(category)]
                # Try and replicate the Illumina rules to create file names from ""Sample_Name""
                samplename = samplenamer(straindata, 1)
                # Calculate the percentage of clusters associated with each strain
                # noinspection PyTypeChecker
                percentperstrain = ""{:.2f}"".format((float(straindata[3]) / tclusterspf * 100))
                try:
                    # Use the sample number -1 as the index in the list of objects created in parsesamplesheet
                    strainindex = int(straindata[0]) - 1
                    # Set run to the .run object of self.samples[index]
                    run = self.samples[strainindex].run
                    # An assertion that compares the sample computer above to the previously entered sample name
                    # to ensure that the samples are the same
                    assert self.samples[strainindex].name == samplename, \
                        ""Sample name does not match object name {0!r:s}"".format(straindata[1])
                    # Add the appropriate values to the strain metadata object
                    run.SampleNumber = straindata[0]
                    run.NumberofClustersPF = straindata[3]
                    run.TotalClustersinRun = tclusterspf
                    run.PercentOfClusters = percentperstrain
                    run.flowcell = self.flowcell
                    run.instrument = self.instrument
                except IndexError:
                    pass
        elif os.path.isfile(os.path.join(self.path, 'indexingQC.txt')):
            # Grab the first element from the second line in the file
            tclusterspf = float(getline(os.path.join(self.path, ""indexingQC.txt""), 2).split(""\t"")[0])
            # Open the file and extract the relevant data
            with open(os.path.join(""indexingQC.txt"")) as indexqc:
                # Iterate through the file
                for line in indexqc:
                    # Once ""Index"" is encountered, iterate through the rest of the file
                    if ""Index"" in line:
                        for subline in indexqc:
                            straindata = [x.rstrip() for x in subline.rstrip().split(""\t"")]
                            # Try and replicate the Illumina rules to create file names from ""Sample_Name""
                            samplename = samplenamer(straindata, 1)
                            # Use the sample number -1 as the index in the list of objects created in parsesamplesheet
                            strainindex = int(straindata[0]) - 1
                            # Set run to the .run object of self.samples[index]
                            run = self.samples[strainindex].run
                            # An assertion that compares the sample computer above to the previously entered sample name
                            # to ensure that the samples are the same
                            assert self.samples[strainindex].name == samplename, \
                                ""Sample name {} does not match object name {}"" \
                                .format(self.samples[strainindex].name, samplename)
                            # Extract and format the percent of reads (passing filter) associated with each sample
                            # noinspection PyTypeChecker
                            percentperstrain = float(""{:.2f}"".format(float(straindata[5])))
                            # Calculate the number of reads passing filter associated with each sample:
                            # percentage of reads per strain times the total reads passing filter divided by 100
                            numberofclusterspf = int(percentperstrain * tclusterspf / 100)
                            # Update the object with the variables
                            run.SampleNumber = straindata[0]
                            run.NumberofClustersPF = numberofclusterspf
                            run.TotalClustersinRun = tclusterspf
                            run.PercentOfClusters = percentperstrain
                            run.flowcell = self.flowcell
                            run.instrument = self.instrument
        else:
            strainindex = 0
            for i in range(len(self.samples)):
                # Set run to the .run object of self.samples[index]
                run = self.samples[strainindex].run
                # Update the object with the variables
                run.SampleNumber = strainindex + 1
                run.NumberofClustersPF = 'NA'
                run.TotalClustersinRun = 'NA'
                run.PercentOfClusters = 'NA'
                run.flowcell = self.flowcell
                run.instrument = self.instrument
                strainindex += 1"
5,"def fix_raw_path(path):
    """"""Prettify name of path

    :param path: path to fix
    :return: Good name for path
    """"""
    double_path_separator = PATH_SEPARATOR + PATH_SEPARATOR
    while path.find(
            double_path_separator) >= 0:  # there are double separators
        path = path.replace(double_path_separator,
                            PATH_SEPARATOR)  # remove double path separator

    if is_folder(path) and not path.endswith(""/""):
        path = path + ""/""

    return path"
6,"def remove_year(name):
    """"""Removes year from input

    :param name: path to edit
    :return: inputs with no years
    """"""
    for i in range(len(
            name) - 3):  # last index is length - 3 - 1 = length - 4
        if name[i: i + 4].isdigit():
            name = name[:i] + name[i + 4:]
            return remove_year(
                name)  # if there is a removal, start again
    return name"
7,"def remove_brackets(name):
    """"""Removes brackets form input

    :param name: path to fix
    :return: inputs with no brackets
    """"""
    name = re.sub(
        r""([(\[]).*?([)\]])"",
        r""\g<1>\g<2>"",
        name
    )  # remove anything in between brackets
    brackets = ""()[]{}""  # list of brackets
    for bracket in brackets:
        name = name.replace(bracket, """")
    return name"
8,"def extract_name_max_chars(name, max_chars=64, blank="" ""):
    """"""Extracts max chars in name truncated to nearest word

    :param name: path to edit
    :param max_chars: max chars of new name
    :param blank: char that represents the blank between words
    :return: Name edited to contain at most max_chars
    """"""
    new_name = name.strip()
    if len(new_name) > max_chars:
        new_name = new_name[:max_chars]  # get at most 64 chars
        if new_name.rfind(blank) > 0:
            new_name = new_name[:new_name.rfind(blank)]  # nearest word
    return new_name"
9,"def prettify(name, blank="" ""):
    """"""Prettify name of path

    :param name: path Name: to edit
    :param blank: default blanks in name
    :return: Prettier name from given one: replace bad chars with good ones
    """"""
    if name.startswith("".""):  # remove starting
        name = name[1:]

    for bad_char in BAD_CHARS:
        name = name.replace(bad_char, blank)  # remove token

    name = String(name).remove_all(blank)

    for i in range(1, len(name) - 2):
        try:
            are_blanks = name[i - 1] == blank and name[i + 1] == blank
            if are_blanks and name[i] in BAD_CHARS:
                name = name[:i - 1] + name[i + 2:]
        except:  # out of bounds
            pass

    if name.startswith(blank):
        name = name[1:]

    if name.endswith(blank):  # remove ending replacement
        name = name[:-1]

    return name"
10,"def get_parent_folder_name(file_path):
    """"""Finds parent folder of file

    :param file_path: path
    :return: Name of folder container
    """"""
    return os.path.split(os.path.split(os.path.abspath(file_path))[0])[-1]"
11,"def ls_dir(path, include_hidden=False):
    """"""Finds content of folder

    :param path: directory to get list of files and folders
    :param include_hidden: True iff include hidden files in list
    :return: List of paths in given directory
    """"""
    lst = []
    for file in os.listdir(path):
        hidden_file = FileSystem(file).is_hidden()
        if (hidden_file and include_hidden) or (not hidden_file):
            lst.append(os.path.join(path, file))
    return list(set(lst))"
12,"def ls_recurse(path, include_hidden=False):
    """"""Finds content of folder recursively

    :param path: directory to get list of files and folders
    :param include_hidden: True iff include hidden files in list
    :return: List of paths in given directory recursively
    """"""
    lst = []
    for file in os.listdir(path):
        hidden_file = FileSystem(file).is_hidden()
        if (hidden_file and include_hidden) or (not hidden_file):
            lst.append(os.path.join(path, file))
            if is_folder(os.path.join(path, file)):
                lst += ls_recurse(
                    os.path.join(path, file),
                    include_hidden=include_hidden
                )  # get list of files in directory
    return list(set(lst))"
13,"def list_content(path, recurse, include_hidden=False):
    """"""Finds content of folder (recursively)

    :param path: directory to get list of files and folders
    :param recurse: True iff recurse into subdirectories or not
    :param include_hidden: True iff include hidden files in list
    :return: List of paths in given directory recursively
    """"""
    if recurse:
        return ls_recurse(path, include_hidden=include_hidden)

    return ls_dir(path, include_hidden=include_hidden)"
14,"def is_russian(self):
        """"""Checks if file path is russian

        :return: True iff document has a russian name
        """"""

        russian_chars = 0
        for char in RUSSIAN_CHARS:
            if char in self.name:
                russian_chars += 1  # found a russian char
        return russian_chars > len(RUSSIAN_CHARS) / 2.0"
15,"def rename(self, new_path):
        """"""Renames to new path

        :param new_path: new path to use
        """"""
        rename_path = fix_raw_path(new_path)
        if is_folder(self.path):
            os.rename(self.path, rename_path)
        else:
            os.renames(self.path, rename_path)"
16,"def __start_waiting_for_events(self):
        '''
        This waits until the whole chain of callback methods triggered by
        ""trigger_connection_to_rabbit_etc()"" has finished, and then starts 
        waiting for publications.
        This is done by starting the ioloop.

        Note: In the pika usage example, these things are both called inside the run()
        method, so I wonder if this check-and-wait here is necessary. Maybe not.
        But the usage example does not implement a Thread, so it probably blocks during
        the opening of the connection. Here, as it is a different thread, the run()
        might get called before the __init__ has finished? I'd rather stay on the
        safe side, as my experience of threading in Python is limited.
        '''

        # Start ioloop if connection object ready:
        if self.thread._connection is not None:
            try:
                logdebug(LOGGER, 'Starting ioloop...')
                logtrace(LOGGER, 'ioloop is owned by connection %s...', self.thread._connection)

                # Tell the main thread that we're now open for events.
                # As soon as the thread._connection object is not None anymore, it
                # can receive events.
                self.thread.tell_publisher_to_stop_waiting_for_thread_to_accept_events() 
                self.thread.continue_gently_closing_if_applicable()
                self.thread._connection.ioloop.start()

            except PIDServerException as e:
                raise e

            # It seems that some connection problems do not cause
            # RabbitMQ to call any callback (on_connection_closed
            # or on_connection_error) - it just silently swallows the
            # problem.
            # So we need to manually trigger reconnection to the next
            # host here, which we do by manually calling the callback.
            # We start the ioloop, so it can handle the reconnection events,
            # or also receive events from the publisher in the meantime.


            except Exception as e:
                # This catches any error during connection startup and during the entire
                # time the ioloop runs, blocks and waits for events.

                time_passed = datetime.datetime.now() - self.__start_connect_time
                time_passed_seconds = time_passed.total_seconds()

                # Some pika errors:
                if isinstance(e, pika.exceptions.ProbableAuthenticationError):
                    errorname = self.__make_error_name(e, 'e.g. wrong user or password')

                elif isinstance(e, pika.exceptions.ProbableAccessDeniedError):
                    errorname = self.__make_error_name(e, 'e.g. wrong virtual host name')
                
                elif isinstance(e, pika.exceptions.IncompatibleProtocolError):
                    errorname = self.__make_error_name(e, 'e.g. trying TLS/SSL on wrong port')

                # Other errors:
                else:
                    errorname = self.__make_error_name(e)
                    logdebug(LOGGER, 'Unexpected error during event listener\'s lifetime (after %s seconds): %s', time_passed_seconds, errorname)

                # Now trigger reconnection:
                self.statemachine.set_to_waiting_to_be_available()
                self.on_connection_error(self.thread._connection, errorname)
                self.thread._connection.ioloop.start()
        
        else:
            # I'm quite sure that this cannot happen, as the connection object
            # is created in ""trigger_connection_...()"" and thus exists, no matter
            # if the actual connection to RabbitMQ succeeded (yet) or not.
            logdebug(LOGGER, 'This cannot happen: Connection object is not ready.')
            logerror(LOGGER, 'Cannot happen. Cannot properly start the thread. Connection object is not ready.')"
17,"def setClass(self, factoryclass):
        """"""Sets the constructor for the component type this label is to 
        represent

        :param factoryclass: a class that, when called, results in an instance of the desired class
        :type factoryclass: callable
        """"""
        self.factoryclass = factoryclass
        self.setText(str(factoryclass.name))"
18,"def mouseMoveEvent(self, event):
        """"""Determines if a drag is taking place, and initiates it""""""
        if (event.pos() - self.dragStartPosition).manhattanLength() < 10:
            return
        QtGui.QApplication.setOverrideCursor(QtGui.QCursor(QtCore.Qt.ClosedHandCursor))
        factory = self.factoryclass()

        mimeData = QtCore.QMimeData()
        try:
            mimeData.setData(""application/x-protocol"", factory.serialize())
        except:
            mimeData.setData(""application/x-protocol"", cPickle.dumps(factory))

        drag = QtGui.QDrag(self)
        drag.setMimeData(mimeData)

        pixmap = QtGui.QPixmap()
        pixmap = pixmap.grabWidget(self, self.frameRect())

        # below makes the pixmap half transparent
        # painter = QtGui.QPainter(pixmap)
        # painter.setCompositionMode(painter.CompositionMode_DestinationIn)
        # painter.fillRect(pixmap.rect(), QtGui.QColor(0, 0, 0, 127))
        # painter.end()

        drag.setPixmap(pixmap)

        drag.setHotSpot(QtCore.QPoint(pixmap.width()/2, pixmap.height()/2))
        drag.setPixmap(pixmap)

        self.dragActive.emit(True)
        result = drag.exec_(QtCore.Qt.MoveAction)

        QtGui.QApplication.restoreOverrideCursor()"
19,"def database(self):
        """"""
        Enters all the metadata into a database
        """"""
        import sqlite3
        try:
            os.remove('{}/metadatabase.sqlite'.format(self.reportpath))
        except OSError:
            pass
        # Set the name of the database
        db = sqlite3.connect('{}/metadatabase.sqlite'.format(self.reportpath))
        # Create a cursor to allow access to the database
        cursor = db.cursor()
        # Set up the db
        cursor.execute('''
          CREATE TABLE IF NOT EXISTS Samples (
            id     INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT UNIQUE,
            name   TEXT UNIQUE
          )
        ''')
        # Create a variable to store the names of the header values for each individual table
        # This will store a set of all the headers from all the strains, as there can be some variability present, as
        # not all analyses are available for all taxonomic groups
        columns = dict()
        for sample in self.metadata:
            # Create a metadata object to store the new tables
            data = MetadataObject()
            data.name = sample.name
            # Insert each strain name into the Samples table
            cursor.execute('''
              INSERT OR IGNORE INTO Samples (name)
              VALUES ( ? )
            ''', (sample.name, ))
            # Each header in the .json file represents a major category e.g. ARMI, GeneSeekr, commands, etc. and
            # will be made into a separate table
            for header in sample.datastore.items():
                # Allow for certain analyses, such as core genome, not being performed on all strains
                try:

                    # Key and value: data description and data value e.g. targets present: 1012, etc.
                    for key, value in sorted(header[1].datastore.items()):
                        # Only the values consisting of dictionaries are of interest
                        if type(value) == dict:
                            # Clean the column names so there are no issues entering names into the database
                            cleanedcolumn = self.columnclean(key)
                            # Set the table name
                            tablename = '{}_{}'.format(header[0].replace('.', '_'), cleanedcolumn)
                            # Create the table (if it doesn't already exist)
                            cursor.execute('''
                                          CREATE TABLE IF NOT EXISTS {} (
                                            sample_id INTEGER
                                          )
                                          '''.format(tablename))
                            # Add the attributes with the dictionaries (values) to the metadata object
                            setattr(data, tablename, GenObject(value))
                            for gene, result in sorted(value.items()):
                                # Add the data header to the dictionary
                                try:
                                    columns[tablename].add(gene)
                                # Initialise the dictionary the first time a table name is encountered
                                except KeyError:
                                    columns[tablename] = set()
                                    columns[tablename].add(str(gene))
                except (AttributeError, IndexError):
                    pass
            self.tabledata.append(data)
        # Iterate through the dictionary containing all the data headers
        for table, setofheaders in sorted(columns.items()):
            # Each header will be used as a column in the appropriate table
            for cleanedcolumn in sorted(setofheaders):
                # Alter the table by adding each header as a column
                cursor.execute('''
                  ALTER TABLE {}
                  ADD COLUMN {} TEXT
                '''.format(table, cleanedcolumn))
            # Iterate through the samples and pull out the data for each table/column
            # for sample in self.metadata:
            for sample in self.tabledata:
                # Find the id associated with each sample in the Sample table
                cursor.execute('''
                  SELECT id from Samples WHERE name=?
                ''', (sample.name,))
                sampleid = cursor.fetchone()[0]
                # Add the sample_id to the table
                cursor.execute('''
                  INSERT OR IGNORE INTO {}
                  (sample_id) VALUES (""{}"")
                  '''.format(table, sampleid))
                # Add the data to the table
                try:
                    # Find the data for each table/column
                    for item in sorted(sample[table].datastore.items()):
                        # Clean the names
                        cleanedcolumn = self.columnclean(str(item[0]))
                        # Add the data to the column of the appropriate table,
                        # where the sample_id matches the current strain
                        cursor.execute('''
                          UPDATE {}
                          SET {} = ?
                          WHERE sample_id = {}
                          '''.format(table, cleanedcolumn, sampleid), (str(item[1]), ))
                except KeyError:
                    pass
        # Commit the changes to the database
        db.commit()"
20,"def columnclean(column):
        """"""
        Modifies column header format to be importable into a database
        :param column: raw column header
        :return: cleanedcolumn: reformatted column header
        """"""
        cleanedcolumn = str(column) \
            .replace('%', 'percent') \
            .replace('(', '_') \
            .replace(')', '') \
            .replace('As', 'Adenosines') \
            .replace('Cs', 'Cytosines') \
            .replace('Gs', 'Guanines') \
            .replace('Ts', 'Thymines') \
            .replace('Ns', 'Unknowns') \
            .replace('index', 'adapterIndex')
        return cleanedcolumn"
21,"def getLabel(self, key):
        """"""Gets the label assigned to an axes

        :param key:???
        :type key: str
        """"""
        axisItem = self.getPlotItem().axes[key]['item']
        return axisItem.label.toPlainText()"
22,"def updateData(self, axeskey, x, y):
        """"""Replaces the currently displayed data

        :param axeskey: name of data plot to update. Valid options are 'stim' or 'response'
        :type axeskey: str
        :param x: index values associated with y to plot
        :type x: numpy.ndarray
        :param y: values to plot at x
        :type y: numpy.ndarray
        """"""
        if axeskey == 'stim':
            self.stimPlot.setData(x,y)
            # call manually to ajust placement of signal
            ranges = self.viewRange()
            self.rangeChange(self, ranges)
        if axeskey == 'response':
            self.clearTraces()
            if self._traceUnit == 'A':
                y = y * self._ampScalar
            if self.zeroAction.isChecked():
                start_avg = np.mean(y[5:25])
                y = y - start_avg
            self.tracePlot.setData(x,y*self._polarity)"
23,"def appendData(self, axeskey, bins, ypoints):
        """"""Appends data to existing plotted data

        :param axeskey: name of data plot to update. Valid options are 'stim' or 'response'
        :type axeskey: str
        :param bins: bins to plot a point for
        :type bin: numpy.ndarray
        :param ypoints: iteration number of raster, *should* match bins dimension, but really takes the first value in array for iteration number and plot row at proper place for included bins
        :type ypoints: numpy.ndarray
        """"""
        if axeskey == 'raster' and len(bins) > 0:
            x, y = self.rasterPlot.getData()
            # don't plot overlapping points
            bins = np.unique(bins)
            # adjust repetition number to response scale
            ypoints = np.ones_like(bins)*self.rasterYslots[ypoints[0]]
            x = np.append(x, bins)
            y = np.append(y, ypoints)
            self.rasterPlot.setData(x, y)"
24,"def setThreshold(self, threshold):
        """"""Sets the current threshold

        :param threshold: the y value to set the threshold line at
        :type threshold: float
        """"""
        self.threshLine.setValue(threshold)
        self.threshold_field.setValue(threshold)"
25,"def setRasterBounds(self, lims):
        """"""Sets the raster plot y-axis bounds, where in the plot the raster will appear between

        :param lims: the (min, max) y-values for the raster plot to be placed between
        :type lims: (float, float)
        """"""
        self.rasterBottom = lims[0]
        self.rasterTop = lims[1]
        self.updateRasterBounds()"
26,"def updateRasterBounds(self):
        """"""Updates the y-coordinate slots where the raster points 
        are plotted, according to the current limits of the y-axis""""""
        yrange = self.viewRange()[1]
        yrange_size = yrange[1] - yrange[0]
        rmax = self.rasterTop*yrange_size + yrange[0]
        rmin = self.rasterBottom*yrange_size + yrange[0]
        self.rasterYslots = np.linspace(rmin, rmax, self.nreps)
        self.rasterBoundsUpdated.emit((self.rasterBottom, self.rasterTop), self.getTitle())"
27,"def askRasterBounds(self):
        """"""Prompts the user to provide the raster bounds with a dialog. 
        Saves the bounds to be applied to the plot""""""
        dlg = RasterBoundsDialog(bounds= (self.rasterBottom, self.rasterTop))
        if dlg.exec_():
            bounds = dlg.values()
            self.setRasterBounds(bounds)"
28,"def rangeChange(self, pw, ranges):
        """"""Adjusts the stimulus signal to keep it at the top of a plot,
        after any ajustment to the axes ranges takes place.

        This is a slot for the undocumented pyqtgraph signal sigRangeChanged.
        From what I can tell the arguments are:

        :param pw: reference to the emitting object (plot widget in my case)
        :type pw: object
        :param ranges: I am only interested when this turns out to be a nested list of axis bounds
        :type ranges: object
        """"""
        if hasattr(ranges, '__iter__'):
            # adjust the stim signal so that it falls in the correct range
            yrange_size = ranges[1][1] - ranges[1][0]
            stim_x, stim_y = self.stimPlot.getData()
            if stim_y is not None:
                stim_height = yrange_size*STIM_HEIGHT
                # take it to 0
                stim_y = stim_y - np.amin(stim_y)
                # normalize
                if np.amax(stim_y) != 0:
                    stim_y = stim_y/np.amax(stim_y)
                # scale for new size
                stim_y = stim_y*stim_height
                # raise to right place in plot
                stim_y = stim_y + (ranges[1][1] - (stim_height*1.1 + (stim_height*0.2)))
                self.stimPlot.setData(stim_x, stim_y)
            # rmax = self.rasterTop*yrange_size + ranges[1][0]
            # rmin = self.rasterBottom*yrange_size + ranges[1][0]
            self.updateRasterBounds()"
29,"def update_thresh(self):
        """"""Emits a Qt signal thresholdUpdated with the current threshold value""""""
        thresh_val = self.threshLine.value()
        self.threshold_field.setValue(thresh_val)
        self.thresholdUpdated.emit(thresh_val, self.getTitle())"
30,"def fromFile(self, fname):
        """"""Displays a spectrogram of an audio file. Supported formats see :func:`sparkle.tools.audiotools.audioread`

        :param fname: file path of the audiofile to display
        :type fname: str
        :returns: float -- duration of audio recording (seconds)
        """"""
        spec, f, bins, dur = audiotools.spectrogram(fname, **self.specgramArgs)
        self.updateImage(spec, bins, f)
        return dur"
31,"def updateImage(self, imgdata, xaxis=None, yaxis=None):
        """"""Updates the Widget image directly.

        :type imgdata: numpy.ndarray, see :meth:`pyqtgraph:pyqtgraph.ImageItem.setImage`
        :param xaxis: x-axis values, length should match dimension 1 of imgdata
        :param yaxis: y-axis values, length should match dimension 0 of imgdata
        """"""
        imgdata = imgdata.T
        self.img.setImage(imgdata)
        if xaxis is not None and yaxis is not None:
            xscale = 1.0/(imgdata.shape[0]/xaxis[-1])
            yscale = 1.0/(imgdata.shape[1]/yaxis[-1])
            self.resetScale()        
            self.img.scale(xscale, yscale)
            self.imgScale = (xscale, yscale)
        self.imageArray = np.fliplr(imgdata)
        self.updateColormap()"
32,"def resetScale(self):
        """"""Resets the scale on this image. Correctly aligns time scale, undoes manual scaling""""""
        self.img.scale(1./self.imgScale[0], 1./self.imgScale[1])
        self.imgScale = (1.,1.)"
33,"def updateData(self, signal, fs):
        """"""Displays a spectrogram of the provided signal

        :param signal: 1-D signal of audio
        :type signal: numpy.ndarray
        :param fs: samplerate of signal
        :type fs: int
        """"""
        # use a separate thread to calculate spectrogram so UI doesn't lag
        t = threading.Thread(target=_doSpectrogram, args=(self.spec_done, (fs, signal),), kwargs=self.specgramArgs)
        t.start()"
34,"def setSpecArgs(**kwargs):
        """"""Sets optional arguments for the spectrogram appearance.

        Available options:

        :param nfft: size of FFT window to use
        :type nfft: int
        :param overlap: percent overlap of window
        :type overlap: number
        :param window: Type of window to use, choices are hanning, hamming, blackman, bartlett or none (rectangular)
        :type window: string
        :param colormap: Gets set by colormap editor. Holds the information to generate the colormap. Items: :meth:`lut<pyqtgraph:pyqtgraph.ImageItem.setLookupTable>`, :meth:`levels<pyqtgraph:pyqtgraph.ImageItem.setLevels>`, state (info for editor)
        :type colormap: dict
        """"""
        for key, value in kwargs.items():
            if key == 'colormap':
                SpecWidget.imgArgs['lut'] = value['lut']
                SpecWidget.imgArgs['levels'] = value['levels']
                SpecWidget.imgArgs['state'] = value['state']
                for w in SpecWidget.instances:
                    w.updateColormap()
            else:
                SpecWidget.specgramArgs[key] = value"
35,"def clearImg(self):
        """"""Clears the current image""""""
        self.img.setImage(np.array([[0]]))
        self.img.image = None"
36,"def editColormap(self):
        """"""Prompts the user with a dialog to change colormap""""""
        self.editor = pg.ImageView()
        # remove the ROI and Norm buttons
        self.editor.ui.roiBtn.setVisible(False)
        self.editor.ui.menuBtn.setVisible(False)
        self.editor.setImage(self.imageArray)
        if self.imgArgs['state'] is not None:
            self.editor.getHistogramWidget().item.gradient.restoreState(self.imgArgs['state'])
            self.editor.getHistogramWidget().item.setLevels(*self.imgArgs['levels'])
        
        self.editor.closeEvent = self._editor_close
        self.editor.setWindowModality(QtCore.Qt.ApplicationModal)
        self.editor.show()"
37,"def updateColormap(self):
        """"""Updates the currently colormap accoring to stored settings""""""
        if self.imgArgs['lut'] is not None:
            self.img.setLookupTable(self.imgArgs['lut'])
            self.img.setLevels(self.imgArgs['levels'])"
38,"def appendData(self, xdata, ydata, color='b', legendstr=None):
        """"""Adds the data to the plot

        :param xdata: index values for data, plotted on x-axis
        :type xdata: numpy.ndarray
        :param ydata: value data to plot, dimension must match xdata
        :type ydata: numpy.ndarray
        """"""
        item = self.plot(xdata, ydata, pen=color)
        if legendstr is not None:
            self.legend.addItem(item, legendstr)
        return item"
39,"def setLabels(self, xlabel=None, ylabel=None, title=None, xunits=None, yunits=None):
        """"""Sets the plot labels

        :param xlabel: X-axis label (do not include units)
        :type xlabel: str
        :param ylabel: Y-axis label (do not include units)
        :type ylabel: str
        :param title: Plot title
        :type title: str
        :param xunit: SI units for the x-axis. An appropriate label will be appended according to scale
        :type xunit: str
        :param yunit: SI units for the y-axis. An appropriate label will be appended according to scale
        :type yunit: str
        """"""
        if xlabel is not None:
            self.setLabel('bottom', xlabel, units=xunits)
        if ylabel is not None:
            self.setLabel('left', ylabel, units=yunits)
        if title is not None:
            self.setTitle(title)"
40,"def setPoint(self, x, group, y):
        """"""Sets the given point, connects line to previous point in group

        :param x: x value of point
        :type x: float
        :param group: group which plot point for
        :type group: float
        :param y: y value of point
        :type y: float
        """"""
        if x == -1:
            # silence window
            self.plot([0],[y], symbol='o')
        else:
            yindex = self.groups.index(group)
            xdata, ydata = self.lines[yindex].getData()
            if ydata is None:
                xdata = [x]
                ydata = [y]
            else:
                xdata = np.append(xdata, x)
                ydata = np.append(ydata, y)
            self.lines[yindex].setData(xdata, ydata)"
41,"def setLabels(self, name):
        """"""Sets plot labels, according to predefined options

        :param name: The type of plot to create labels for. Options: calibration, tuning, anything else labels for spike counts
        :type name: str
        """"""
        if name == ""calibration"":
            self.setWindowTitle(""Calibration Curve"")
            self.setTitle(""Calibration Curve"")
            self.setLabel('bottom', ""Frequency"", units='Hz')
            self.setLabel('left', 'Recorded Intensity (dB SPL)')
        elif name == ""tuning"":
            self.setWindowTitle(""Tuning Curve"")
            self.setTitle(""Tuning Curve"")
            self.setLabel('bottom', ""Frequency"", units=""Hz"")
            self.setLabel('left', ""Spike Count (mean)"")
        else:
            self.setWindowTitle(""Spike Counts"")
            self.setTitle(""Spike Counts"")
            self.setLabel('bottom', ""Test Number"", units='')
            self.setLabel('left', ""Spike Count (mean)"", units='')"
42,"def loadCurve(data, groups, thresholds, absvals, fs, xlabels):
        """"""Accepts a data set from a whole test, averages reps and re-creates the 
        progress plot as the same as it was during live plotting. Number of thresholds
        must match the size of the channel dimension""""""
        xlims = (xlabels[0], xlabels[-1])
        pw = ProgressWidget(groups, xlims)
        spike_counts = []
        # skip control
        for itrace in range(data.shape[0]):
            count = 0
            for ichan in range(data.shape[2]):
                flat_reps = data[itrace,:,ichan,:].flatten()
                count += len(spikestats.spike_times(flat_reps, thresholds[ichan], fs, absvals[ichan]))
            spike_counts.append(count/(data.shape[1]*data.shape[2])) #mean spikes per rep

        i = 0
        for g in groups:
            for x in xlabels:
                pw.setPoint(x, g, spike_counts[i])
                i +=1

        return pw"
43,"def setBins(self, bins):
        """"""Sets the bin centers (x values)

        :param bins: time bin centers
        :type bins: numpy.ndarray
        """"""
        self._bins = bins
        self._counts = np.zeros_like(self._bins)
        bar_width = bins[0]*1.5
        self.histo.setOpts(x=bins, height=self._counts, width=bar_width)
        self.setXlim((0, bins[-1]))"
44,"def clearData(self):
        """"""Clears all histograms (keeps bins)""""""
        self._counts = np.zeros_like(self._bins)
        self.histo.setOpts(height=self._counts)"
45,"def appendData(self, bins, repnum=None):
        """"""Increases the values at bins (indexes)

        :param bins: bin center values to increment counts for, to increment a time bin more than once include multiple items in list with that bin center value
        :type bins: numpy.ndarray
        """"""
        # only if the last sample was above threshold, but last-1 one wasn't
        bins[bins >= len(self._counts)] = len(self._counts) -1
        bin_totals = np.bincount(bins)
        self._counts[:len(bin_totals)] += bin_totals
        self.histo.setOpts(height=np.array(self._counts))"
46,"def processData(self, times, response, test_num, trace_num, rep_num):
        """"""Calulate spike times from raw response data""""""
        # invert polarity affects spike counting
        response = response * self._polarity

        if rep_num == 0:
            # reset
            self.spike_counts = []
            self.spike_latencies = []
            self.spike_rates = []

        fs = 1./(times[1] - times[0])

        # process response; calculate spike times
        spike_times = spikestats.spike_times(response, self._threshold, fs)
        self.spike_counts.append(len(spike_times))
        if len(spike_times) > 0:
            self.spike_latencies.append(spike_times[0])
        else:
            self.spike_latencies.append(np.nan)
        self.spike_rates.append(spikestats.firing_rate(spike_times, times))

        binsz = self._bins[1] - self._bins[0]
        response_bins = spikestats.bin_spikes(spike_times, binsz)
        # self.putnotify('spikes_found', (response_bins, rep_num))
        self.appendData(response_bins, rep_num)"
47,"def setSr(self, fs):
        """"""Sets the samplerate of the input operation being plotted""""""
        self.tracePlot.setSr(fs)
        self.stimPlot.setSr(fs)"
48,"def setWindowSize(self, winsz):
        """"""Sets the size of scroll window""""""
        self.tracePlot.setWindowSize(winsz)
        self.stimPlot.setWindowSize(winsz)"
49,"def addPlot(self, xdata, ydata, xlabel=None, ylabel=None, title=None, xunits=None, yunits=None):
        """"""Adds a new plot for the given set of data and/or labels, Generates a SimplePlotWidget

        :param xdata: index values for data, plotted on x-axis
        :type xdata: numpy.ndarray
        :param ydata: value data to plot, dimension must match xdata
        :type ydata: numpy.ndarray
        """"""
        p = SimplePlotWidget(xdata, ydata)
        p.setLabels(xlabel, ylabel, title, xunits, yunits)
        # self.plots.append(p)
        self.stacker.addWidget(p)"
50,"def addSpectrogram(self, ydata, fs, title=None):
        """"""Adds a new spectorgram plot for the given image. Generates a SpecWidget

        :param ydata: 2-D array of the image to display
        :type ydata: numpy.ndarray
        :param fs: the samplerate of the signal in the image, used to set time/ frequency scale
        :type fs: int
        :param title: Plot title
        :type title: str
        """"""
        p = SpecWidget()
        p.updateData(ydata, fs)
        if title is not None:
            p.setTitle(title)
        self.stacker.addWidget(p)"
51,"def nextPlot(self):
        """"""Moves the displayed plot to the next one""""""
        if self.stacker.currentIndex() < self.stacker.count():
            self.stacker.setCurrentIndex(self.stacker.currentIndex()+1)"
52,"def prevPlot(self):
        """"""Moves the displayed plot to the previous one""""""
        if self.stacker.currentIndex() > 0:
            self.stacker.setCurrentIndex(self.stacker.currentIndex()-1)"
53,"def most_even_chunk(string, group):
    """"""Divide a string into a list of strings as even as possible.""""""
    counts = [0] + most_even(len(string), group)
    indices = accumulate(counts)
    slices = window(indices, 2)
    return [string[slice(*one)] for one in slices]"
54,"def most_even(number, group):
    """"""Divide a number into a list of numbers as even as possible.""""""
    count, rest = divmod(number, group)
    counts = zip_longest([count] * group, [1] * rest, fillvalue=0)
    chunks = [sum(one) for one in counts]
    logging.debug('chunks: %s', chunks)
    return chunks"
55,"def window(seq, count=2):
    """"""Slide window.""""""
    iseq = iter(seq)
    result = tuple(islice(iseq, count))
    if len(result) == count:
        yield result
    for elem in iseq:
        result = result[1:] + (elem,)
        yield result"
56,"def _get_modules(path):
    """"""Finds modules in folder recursively

    :param path: directory
    :return: list of modules
    """"""
    lst = []
    folder_contents = os.listdir(path)
    is_python_module = ""__init__.py"" in folder_contents

    if is_python_module:
        for file in folder_contents:
            full_path = os.path.join(path, file)

            if is_file(full_path):
                lst.append(full_path)

            if is_folder(full_path):
                lst += _get_modules(full_path)  # recurse in folder

    return list(set(lst))"
57,"def get_modules(folder, include_meta=False):
    """"""Finds modules (recursively) in folder

    :param folder: root folder
    :param include_meta: whether include meta files like (__init__ or
        __version__)
    :return: list of modules
    """"""
    files = [
        file
        for file in _get_modules(folder)
        if is_file(file)  # just files
    ]

    if not include_meta:
        files = [
            file
            for file in files
            if not Document(file).name.startswith(""__"")
        ]

    return files"
58,"def _parse(self):
        """"""Parses file contents

        :return: Tree hierarchy of file
        """"""
        with open(self.path, ""rt"") as reader:
            return ast.parse(reader.read(), filename=self.path)"
59,"def _find_package(self, root_package):
        """"""Finds package name of file

        :param root_package: root package
        :return: package name
        """"""

        package = self.path.replace(root_package, """")
        if package.endswith("".py""):
            package = package[:-3]

        package = package.replace(os.path.sep, MODULE_SEP)
        root_package = get_folder_name(root_package)

        package = root_package + package  # add root
        return package"
60,"def _get_instances(self, instance):
        """"""Finds all instances of instance in tree

        :param instance: type of object
        :return: list of objects in tree of same instance
        """"""

        return [
            x
            for x in self.tree.body
            if isinstance(x, instance)
        ]"
61,"def get_classes(self):
        """"""Finds classes in file

        :return: list of top-level classes
        """"""
        instances = self._get_instances(ast.ClassDef)
        instances = [
            PyClass(instance, self.package)
            for instance in instances
        ]
        return instances"
62,"def get_functions(self):
        """"""Finds top-level functions in file

        :return: list of top-level functions
        """"""
        instances = self._get_instances(ast.FunctionDef)
        instances = [
            PyFunction(instance, self.package)
            for instance in instances
        ]
        return instances"
63,"def get_functions(self, include_meta=False):
        """"""Finds top-level functions in file

        :param include_meta: whether include meta functions like (__init__)
        :return: list of top-level functions
        """"""
        instances = self._get_instances(ast.FunctionDef)
        instances = [
            PyFunction(instance, self.full_package)  # fix package name
            for instance in instances
        ]

        if not include_meta:
            instances = [
                instance  # fix package name
                for instance in instances
                if not instance.get_name().startswith(""__"")
            ]

        return instances"
64,"def skesa_assemble(self):
        """"""
        Run skesa to assemble genomes
        """"""
        with progressbar(self.metadata) as bar:
            for sample in bar:
                # Initialise the assembly command
                sample.commands.assemble = str()
                try:
                    if sample.general.trimmedcorrectedfastqfiles:
                        # If the sample is a pure isolate, assemble it. Otherwise, run the pre-metagenome pipeline
                        try:
                            status = sample.run.Description
                        except AttributeError:
                            status = 'unknown'
                        if status == 'metagenome':
                            self.merge(sample)
                        else:
                            # Set the output directory
                            sample.general.assembly_output = os.path.join(sample.general.outputdirectory,
                                                                          'assembly_output')
                            make_path(sample.general.assembly_output)
                            sample.general.assemblyfile = os.path.join(sample.general.assembly_output,
                                                                       '{name}_unfiltered.fasta'
                                                                       .format(name=sample.name))
                            sample.general.bestassemblyfile = os.path.join(sample.general.assembly_output,
                                                                           '{name}.fasta'
                                                                           .format(name=sample.name))
                            fastqfiles = sample.general.trimmedcorrectedfastqfiles

                            # Set the the forward fastq files
                            sample.general.assemblyfastq = fastqfiles
                            forward = fastqfiles[0]
                            gz = True if '.gz' in forward else False
                            # If there are two fastq files
                            if len(fastqfiles) == 2:
                                # Set the reverse fastq name https://github.com/ncbi/SKESA/issues/7
                                sample.commands.assemble = 'skesa --fastq {fastqfiles} --cores {threads} ' \
                                                           '--use_paired_ends --vector_percent 1 ' \
                                                           '--contigs_out {contigs}'\
                                    .format(fastqfiles=','.join(fastqfiles),
                                            threads=self.cpus,
                                            contigs=sample.general.assemblyfile)
                            # Same as above, but use single read settings for the assembler
                            else:
                                sample.commands.assemble = 'skesa --fastq {fastqfiles} --cores {threads} ' \
                                                           '--vector_percent 1 --contigs_out {contigs}'\
                                    .format(fastqfiles=','.join(fastqfiles),
                                            threads=self.cpus,
                                            contigs=sample.general.assemblyfile)
                    # If there are no fastq files, populate the metadata appropriately
                    else:
                        sample.general.assembly_output = 'NA'
                        sample.general.assemblyfastq = 'NA'
                        sample.general.bestassemblyfile = 'NA'
                except AttributeError:
                    sample.general.assembly_output = 'NA'
                    sample.general.assemblyfastq = 'NA'
                    sample.general.trimmedcorrectedfastqfiles = 'NA'
                    sample.general.bestassemblyfile = 'NA'
                if sample.commands.assemble and not os.path.isfile(sample.general.assemblyfile):
                    # Run the assembly
                    out, err = run_subprocess(sample.commands.assemble)
                    write_to_logfile(sample.commands.assemble,
                                     sample.commands.assemble,
                                     self.logfile,
                                     sample.general.logout,
                                     sample.general.logerr,
                                     None,
                                     None)
                    write_to_logfile(out,
                                     err,
                                     self.logfile,
                                     sample.general.logout,
                                     sample.general.logerr,
                                     None,
                                     None)"
65,"def merge(self, sample):
        """"""
        Use bbmerge to merge paired FASTQ files for use in metagenomics pipelines. Create a report with the
        total number of reads, and the number of reads that could be paired
        :param sample: metadata sample object flagged as a metagenome
        """"""
        # Set the assembly file to 'NA' as assembly is not desirable for metagenomes
        sample.general.assemblyfile = 'NA'
        # Can only merge paired-end
        if len(sample.general.fastqfiles) == 2:
            outpath = os.path.join(sample.general.outputdirectory, 'merged_reads')
            make_path(outpath)
            # Merge path - keep all the merged FASTQ files in one directory
            merge_path = os.path.join(self.path, 'merged_reads')
            make_path(merge_path)
            # Set the name of the merged, and unmerged files
            sample.general.mergedreads = \
                os.path.join(merge_path, '{}_paired.fastq.gz'.format(sample.name))
            log = os.path.join(outpath, 'log')
            error = os.path.join(outpath, 'err')
            try:
                if not os.path.isfile(sample.general.mergedreads):
                    # Run the merging command
                    out, err, cmd = bbtools.bbmerge(forward_in=sorted(sample.general.trimmedcorrectedfastqfiles)[0],
                                                    merged_reads=sample.general.mergedreads,
                                                    mix=True,
                                                    returncmd=True,
                                                    threads=self.cpus)
                    write_to_logfile(out, err, self.logfile, sample.general.logout, sample.general.logerr, None, None)
                    with open(log, 'w') as log_file:
                        log_file.write(out)
                    with open(error, 'w') as error_file:
                        error_file.write(err)
            except (CalledProcessError, IndexError):
                delattr(sample.general, 'mergedreads')
            # Set the name of the report to store the metagenome file merging results
            report = os.path.join(self.reportpath, 'merged_metagenomes.csv')
            # Extract the total number of reads, and the number of reads that could be paired from the bbmerge
            # err stream
            num_reads, num_pairs = self.reads(error)
            # If the report doesn't exist, create it with the header and the results from the first sample
            if not os.path.isfile(report):
                with open(report, 'w') as report_file:
                    report_file.write('Sample,TotalReads,PairedReads\n{sample},{total},{paired}\n'
                                      .format(sample=sample.name,
                                              total=num_reads,
                                              paired=num_pairs))
            # If the report exists, open it to determine which samples have already been added - useful if re-running
            # the analysis
            else:
                lines = list()
                with open(report, 'r') as report_file:
                    for line in report_file:
                        lines.append(line.split(',')[0])
                # Add the results to the report
                if sample.name not in lines:
                    with open(report, 'a+') as report_file:
                        report_file.write('{sample},{total},{paired}\n'
                                          .format(sample=sample.name,
                                                  total=num_reads,
                                                  paired=num_pairs))"
66,"def reads(err_log):
        """"""
        Parse the outputs from bbmerge to extract the total number of reads, as well as the number of reads that
        could be paired
        :param err_log: bbmerge outputs the stats in the error file
        :return: num_reads, the total number of reads, paired_reads, number of paired readds
        """"""
        # Initialise variables
        num_reads = 0
        paired_reads = 0
        # Open the log file
        with open(err_log, 'r') as error_log:
            # Extract the necessary information
            for line in error_log:
                if 'Pairs:' in line:
                    num_reads = line.split('\t')[-1].rstrip()
                elif 'Joined:' in line:
                    paired_reads = line.split('\t')[-2].rstrip()
        return num_reads, paired_reads"
67,"def best_assemblyfile(self):
        """"""
        Determine whether the contigs.fasta output file from the assembler is present. If not, set the .bestassembly
        attribute to 'NA'
        """"""
        for sample in self.metadata:
            try:
                # Set the name of the filtered assembly file
                filtered_outputfile = os.path.join(self.path, 'raw_assemblies', '{}.fasta'.format(sample.name))
                # Set the name of the unfiltered spades assembly output file
                if os.path.isfile(sample.general.assemblyfile):
                    size = os.path.getsize(sample.general.assemblyfile)
                    # Ensure that the assembly isn't just an empty file
                    if size == 0:
                        sample.general.bestassemblyfile = 'NA'
                    else:
                        sample.general.bestassemblyfile = sample.general.assemblyfile
                        shutil.copyfile(sample.general.bestassemblyfile, filtered_outputfile)
                else:
                    sample.general.bestassemblyfile = 'NA'
                # Add the name and path of the filtered file to the metadata
                sample.general.filteredfile = filtered_outputfile
            except AttributeError:
                sample.general.assemblyfile = 'NA'
                sample.general.bestassemblyfile = 'NA'"
68,"def groups(self):
        """"""Component groups

        Special property which point to a :class:`~pylls.cachet.ComponentGroups`
        instance for convenience. This instance is initialized on first call.
        """"""
        if not self._groups:
            self._groups = ComponentGroups(self.api_client)
        return self._groups"
69,"def get(self, component_id=None, **kwargs):
        """"""Get components

        :param component_id: Component ID (optional)
        :return: Components data (:class:`Generator`)

        Additional named arguments may be passed and are directly transmitted
        to API. It is useful to use the API search features.

        .. seealso:: https://docs.cachethq.io/reference#get-components
        .. seealso:: https://docs.cachethq.io/docs/advanced-api-usage
        """"""
        path = 'components'
        if component_id is not None:
            path += '/%s' % component_id
        return self.paginate_get(path, data=kwargs)"
70,"def create(self, name, status, description="""", link="""", order=0,
               group_id=0, enabled=True):
        """"""Create a new component

        :param str name: Name of the component
        :param int status: Status of the component; 1-4
        :param str description: Description of the component (optional)
        :param str link: A hyperlink to the component (optional)
        :param int order: Order of the component (optional)
        :param int group_id: The group ID of the component (optional)
        :param bool enabled: Whether the component is enabled (optional)
        :return: Created component data (:class:`dict`)

        .. seealso:: https://docs.cachethq.io/reference#components
        .. seealso:: https://docs.cachethq.io/docs/component-statuses
        """"""
        data = ApiParams()
        data['name'] = name
        data['status'] = status
        data['description'] = description
        data['link'] = link
        data['order'] = order
        data['group_id'] = group_id
        data['enabled'] = enabled
        return self._post('components', data=data)['data']"
71,"def update(self, component_id, name=None, status=None, description=None,
               link=None, order=None, group_id=None, enabled=True):
        """"""Update a component

        :param int component_id: Component ID
        :param str name: Name of the component (optional)
        :param int status: Status of the component; 1-4
        :param str description: Description of the component (optional)
        :param str link: A hyperlink to the component (optional)
        :param int order: Order of the component (optional)
        :param int group_id: The group ID of the component (optional)
        :param bool enabled: Whether the component is enabled (optional)
        :return: Updated component data (:class:`dict`)

        .. seealso:: https://docs.cachethq.io/reference#components
        .. seealso:: https://docs.cachethq.io/docs/component-statuses
        """"""
        data = ApiParams()
        data['component'] = component_id
        data['name'] = name
        data['status'] = status
        data['description'] = description
        data['link'] = link
        data['order'] = order
        data['group_id'] = group_id
        data['enabled'] = enabled
        return self._put('components/%s' % component_id, data=data)['data']"
72,"def get(self, group_id=None, **kwargs):
        """"""Get component groups

        :param group_id: Component group ID (optional)
        :return: Component groups data (:class:`dict`)

        Additional named arguments may be passed and are directly transmitted
        to API. It is useful to use the API search features.

        .. seealso:: https://docs.cachethq.io/reference#get-componentgroups
        .. seealso:: https://docs.cachethq.io/docs/advanced-api-usage
        """"""
        path = 'components/groups'
        if group_id is not None:
            path += '/%s' % group_id
        return self.paginate_get(path, data=kwargs)"
73,"def create(self, name, order=None, collapsed=None):
        """"""Create a new Component Group

        :param str name: Name of the component group
        :param int order: Order of the component group
        :param int collapsed: Collapse the group? 0-2
        :return: Created component group data (:class:`dict`)

        .. seealso:: https://docs.cachethq.io/reference#post-componentgroups
        """"""
        data = ApiParams()
        data['name'] = name
        data['order'] = order
        data['collapsed'] = collapsed
        return self._post('components/groups', data=data)['data']"
74,"def update(self, group_id, name=None, order=None, collapsed=None):
        """"""Update a Component Group

        :param int group_id: Component Group ID
        :param str name: Name of the component group
        :param int order: Order of the group
        :param int collapsed: Collapse the group?
        :return: Updated component group data (:class:`dict`)

        .. seealso:: https://docs.cachethq.io/reference#put-component-group
        """"""
        data = ApiParams()
        data['group'] = group_id
        data['name'] = name
        data['order'] = order
        data['collapsed'] = collapsed
        return self._put('components/groups/%s' % group_id, data=data)['data']"
75,"def get(self, incident_id=None, **kwargs):
        """"""Get incidents

        :param int incident_id:
        :return: Incidents data (:class:`dict`)

        Additional named arguments may be passed and are directly transmitted
        to API. It is useful to use the API search features.

        .. seealso:: https://docs.cachethq.io/reference#get-incidents
        .. seealso:: https://docs.cachethq.io/docs/advanced-api-usage
        """"""
        path = 'incidents'
        if incident_id is not None:
            path += '/%s' % incident_id
        return self.paginate_get(path, data=kwargs)"
76,"def create(self, name, message, status, visible, component_id=None,
               component_status=None, notify=None, created_at=None,
               template=None, tplvars=None):
        """"""Create a new Incident

        :param str name: Name of the incident
        :param str message: Incident explanation message
        :param int status: Status of the incident
        :param int visible: Whether the incident is publicly visible
        :param int component_id: Component to update
        :param int component_status: The status to update the given component
        :param bool notify: Whether to notify subscribers
        :param str created_at: When the incident was created
        :param str template: The template slug to use
        :param list tplvars: The variables to pass to the template
        :return: Created incident data (:class:`dict`)

        .. seealso:: https://docs.cachethq.io/reference#incidents
        """"""
        data = ApiParams()
        data['name'] = name
        data['message'] = message
        data['status'] = status
        data['visible'] = visible
        data['component_id'] = component_id
        data['component_status'] = component_status
        data['notify'] = notify
        data['created_at'] = created_at
        data['template'] = template
        data['vars'] = tplvars
        return self._post('incidents', data=data)['data']"
77,"def update(self, incident_id, name=None, message=None, status=None,
               visible=None, component_id=None, component_status=None,
               notify=None, created_at=None, template=None, tpl_vars=None):
        """"""Update an Incident

        :param int incident_id: Incident ID
        :param str name: Name of the incident
        :param str message: Incident explanation message
        :param int status: Status of the incident
        :param int visible: Whether the incident is publicly visible
        :param int component_id: Component to update
        :param int component_status: The status to update the given component
        :param bool notify: Whether to notify subscribers
        :param str created_at: When the incident was created
        :param str template: The template slug to use
        :param list tpl_vars: The variables to pass to the template
        :return: Created incident data (:class:`dict`)

        .. seealso:: https://docs.cachethq.io/reference#update-an-incident
        """"""
        data = ApiParams()
        data['name'] = name
        data['message'] = message
        data['status'] = status
        data['visible'] = visible
        data['component_id'] = component_id
        data['component_status'] = component_status
        data['notify'] = notify
        data['created_at'] = created_at
        data['template'] = template
        data['vars'] = tpl_vars
        return self._put('incidents/%s' % incident_id, data=data)['data']"
78,"def points(self):
        """"""Metric points

        Special property which point to a :class:`~pylls.cachet.MetricPoints`
        instance for convenience. This instance is initialized on first call.
        """"""
        if not self._points:
            self._points = MetricPoints(self.api_client)
        return self._points"
79,"def get(self, metric_id=None, **kwargs):
        """"""Get metrics

        :param int metric_id: Metric ID
        :return: Metrics data (:class:`dict`)

        Additional named arguments may be passed and are directly transmitted
        to API. It is useful to use the API search features.

        .. seealso:: https://docs.cachethq.io/reference#get-metrics
        .. seealso:: https://docs.cachethq.io/docs/advanced-api-usage
        """"""
        path = 'metrics'
        if metric_id is not None:
            path += '/%s' % metric_id
        return self.paginate_get(path, data=kwargs)"
80,"def create(self, name, suffix, description, default_value, display=None):
        """"""Create a new Metric

        :param str name: Name of metric
        :param str suffix: Metric unit
        :param str description: Description of what the metric is measuring
        :param int default_value: Default value to use when a point is added
        :param int display: Display the chart on the status page
        :return: Created metric data (:class:`dict`)

        .. seealso:: https://docs.cachethq.io/reference#metrics
        """"""
        data = ApiParams()
        data['name'] = name
        data['suffix'] = suffix
        data['description'] = description
        data['default_value'] = default_value
        data['display'] = display
        return self._post('metrics', data=data)['data']"
81,"def create(self, metric_id, value, timestamp=None):
        """"""Add a Metric Point to a Metric

        :param int metric_id: Metric ID
        :param int value: Value to plot on the metric graph
        :param str timestamp: Unix timestamp of the point was measured
        :return: Created metric point data (:class:`dict`)

        .. seealso:: https://docs.cachethq.io/reference#post-metric-points
        """"""
        data = ApiParams()
        data['value'] = value
        data['timestamp'] = timestamp
        return self._post('metrics/%s/points' % metric_id, data=data)['data']"
82,"def create(self, email, verify=None, components=None):
        """"""Create a new subscriber

        :param str email: Email address to subscribe
        :param bool verify: Whether to send verification email
        :param list components: Components ID list, defaults to all
        :return: Created subscriber data (:class:`dict`)

        .. seealso:: https://docs.cachethq.io/reference#subscribers
        """"""
        data = ApiParams()
        data['email'] = email
        data['verify'] = verify
        data['components'] = components
        return self._post('subscribers', data=data)['data']"
83,"def parser(metadata, analysistype, fieldnames, cutoff, program):
        """"""
        Read in the BLAST outputs, and populate dictionaries with the parsed results
        :param metadata: type LIST: List of metadata objects
        :param analysistype: type STR: Current analysis type
        :param fieldnames: type LIST: List of fields used to in BLAST analyses
        :param cutoff: type INT: Percent identity cutoff to use to determine if a match is present
        :param program: type STR: BLAST program used in the analyses
        :return: metadata: List of updated metadata objects
        """"""
        for sample in metadata:
            # Initialise a dictionary attribute to store results
            sample[analysistype].blastresults = dict()
            try:
                # Open the sequence profile file as a dictionary
                blastdict = DictReader(open(sample[analysistype].report), fieldnames=fieldnames, dialect='excel-tab')
                resultdict = dict()
                resultset = dict()
                # Initialise a dictionary to store all the target sequences
                sample[analysistype].targetsequence = dict()
                coregenomes = list()
                # Create a list of all the names of the database files, replace - with _, remove path and extension
                for fasta in sample[analysistype].targets:
                    fastaname = os.path.basename(os.path.splitext(fasta)[0]).replace('-', '_')
                    fastaname = fastaname.split('.')[0]
                    coregenomes.append(fastaname)
                # Go through each BLAST result
                for row in blastdict:
                    # Ignore the headers
                    if row['query_id'].startswith(fieldnames[0]):
                        pass
                    else:
                        # Create the subject length variable - if the sequences are DNA (e.g. blastn), use the subject
                        # length as usual; if the sequences are protein (e.g. tblastx), use the subject length / 3
                        if program == 'blastn' or program == 'blastp' or program == 'blastx':
                            subject_length = float(row['subject_length'])

                        else:
                            subject_length = float(row['subject_length']) / 3
                        # Calculate the percent identity and extract the bitscore from the row
                        # Percent identity is: (length of the alignment - number of mismatches) / total subject length
                        percentidentity = float('{:0.2f}'.format((float(row['positives']) - float(row['gaps'])) /
                                                                 subject_length * 100))
                        # If the percent identity is greater than the cutoff
                        if percentidentity >= cutoff:
                            # Split off any | from the sample name
                            target = row['subject_id'].split('|')[0]
                            # As there are variable _ in the name, try to split off the last one only if there are
                            #  multiple and only keep the first part of the split if there is one _ in the name
                            underscored = '_'.join(target.split('_')[:-1]) if len(target.split('_')) > 2 else \
                                target.split('_')[0]
                            try:
                                # Update the dictionary with the reference genome and the target
                                resultset[underscored].add(target)
                            except KeyError:
                                # Initialise the dictionary with the first hit
                                resultset[underscored] = set()
                                resultset[underscored].add(target)
                # Get the number of unique genes per reference genome
                for underscored, target_set in resultset.items():
                    resultdict[underscored] = len(target_set)
                # Sort the dictionary on the number of hits - best at the top
                topcore = sorted(resultdict.items(), key=operator.itemgetter(1), reverse=True)
                # If there are no results, populate negative results
                if not resultdict:
                    sample[analysistype].blastresults = 'NA'
                # If results, add a string of the best number of hits, and a string of the total number of genes
                # This is currently 1013. If this changes, I may re-implement a dynamic method of determining
                # this value
                else:
                    sample[analysistype].blastresults[topcore[0][0]] = (str(topcore[0][1]), str(1013))
            except FileNotFoundError:
                sample[analysistype].blastresults = 'NA'
        return metadata"
84,"def reporter(metadata, analysistype, reportpath):
        """"""
        Create the core genome report
        :param metadata: type LIST: List of metadata objects
        :param analysistype: type STR: Current analysis type
        :param reportpath: type STR: Absolute path to folder in which the reports are to be created
        :return:
        """"""
        header = 'Strain,ClosestRef,GenesPresent/Total,\n'
        data = str()
        for sample in metadata:
            try:
                if sample[analysistype].blastresults != 'NA':
                    if sample.general.closestrefseqgenus == 'Listeria':
                        # Write the sample name, closest ref genome, and the # of genes found / total # of genes
                        closestref = list(sample[analysistype].blastresults.items())[0][0]
                        coregenes = list(sample[analysistype].blastresults.items())[0][1][0]
                        # Find the closest reference file
                        try:
                            ref = glob(os.path.join(sample[analysistype].targetpath, '{fasta}*'
                                                    .format(fasta=closestref)))[0]
                        except IndexError:
                            # Replace underscores with dashes to find files
                            closestref = closestref.replace('_', '-')
                            ref = glob(os.path.join(sample[analysistype].targetpath, '{fasta}*'
                                                    .format(fasta=closestref)))[0]
                        # Determine the number of core genes present in the closest reference file
                        totalcore = 0
                        for _ in SeqIO.parse(ref, 'fasta'):
                            totalcore += 1
                        # Add the data to the object
                        sample[analysistype].targetspresent = coregenes
                        sample[analysistype].totaltargets = totalcore
                        sample[analysistype].coreresults = '{cg}/{tc}'.format(cg=coregenes,
                                                                              tc=totalcore)
                        row = '{sn},{cr},{cg}/{tc}\n'.format(sn=sample.name,
                                                             cr=closestref,
                                                             cg=coregenes,
                                                             tc=totalcore)
                        # Open the report
                        with open(os.path.join(sample[analysistype].reportdir,
                                               '{sn}_{at}.csv'.format(sn=sample.name,
                                                                      at=analysistype)), 'w') as report:
                            # Write the row to the report
                            report.write(header)
                            report.write(row)
                        data += row
                    else:
                        sample[analysistype].targetspresent = 'NA'
                        sample[analysistype].totaltargets = 'NA'
                        sample[analysistype].coreresults = 'NA'
            except KeyError:
                sample[analysistype].targetspresent = 'NA'
                sample[analysistype].totaltargets = 'NA'
                sample[analysistype].coreresults = 'NA'
        with open(os.path.join(reportpath, 'coregenome.csv'), 'w') as report:
            # Write the data to the report
            report.write(header)
            report.write(data)"
85,"def annotatedcore(self):
        """"""
        Calculates the core genome of organisms using custom databases
        """"""
        logging.info('Calculating annotated core')
        # Determine the total number of core genes
        self.total_core()
        # Iterate through all the samples, and process all Escherichia
        for sample in self.metadata:
            if sample.general.bestassemblyfile != 'NA':
                # Create a set to store the names of all the core genes in this strain
                sample[self.analysistype].coreset = set()
                if sample.general.referencegenus == 'Escherichia':
                    # Add the Escherichia sample to the runmetadata
                    self.runmetadata.samples.append(sample)
                    # Parse the BLAST report
                    try:
                        report = sample[self.analysistype].report
                        self.blastparser(report=report,
                                         sample=sample,
                                         fieldnames=self.fieldnames)
                    except KeyError:
                        sample[self.analysistype].coreset = list()
        # Create the report
        self.reporter()"
86,"def total_core(self):
        """"""
        Determine the total number of core genes present
        """"""
        corefile = os.path.join(self.reffilepath, self.analysistype, 'Escherichia', 'core_combined.fasta')
        for record in SeqIO.parse(corefile, 'fasta'):
            gene_name = record.id.split('-')[0]
            if gene_name not in self.coregenomes:
                self.coregenomes.append(gene_name)"
87,"def blastparser(self, report, sample, fieldnames):
        """"""
        Parse the number of core genes present in the strain from the BLAST outputs
        :param report: the name and path of the BLAST outputs
        :param sample: the sample object
        :param fieldnames: type LIST: List of fields used to in BLAST analyses
        """"""
        try:
            # Open the sequence profile file as a dictionary
            blastdict = DictReader(open(report), fieldnames=self.fieldnames, dialect='excel-tab')
            # Go through each BLAST result
            for row in blastdict:
                # Ignore the headers
                if row['query_id'].startswith(fieldnames[0]):
                    pass
                else:
                    # Calculate the percent identity and extract the bitscore from the row
                    # Percent identity is the (length of the alignment - number of mismatches) / total subject length
                    percentidentity = float('{:0.2f}'.format((float(row['positives']) - float(row['gaps'])) /
                                                             float(row['subject_length']) * 100))
                    # Split off any | and - from the sample name
                    target = row['subject_id'].split('|')[0].split('-')[0]
                    # If the hit passes the cutoff threshold, add it to the set of core genes present
                    if percentidentity >= self.cutoff:
                        sample[self.analysistype].coreset.add(target)
        except FileNotFoundError:
            pass"
88,"def reporter(self):
        """"""
        Create a .csv file with the strain name, and the number of core genes present/the total number of core genes
        """"""
        with open(os.path.join(self.reportpath, 'Escherichia_core.csv'), 'w') as report:
            data = 'Strain,Genes Present/Total\n'
            for sample in self.runmetadata.samples:
                # Convert the set to a list for JSON serialization
                sample[self.analysistype].coreset = list(sample[self.analysistype].coreset)
                sample[self.analysistype].coreresults = '{cs}/{cg}'.format(cs=len(sample[self.analysistype].coreset),
                                                                           cg=len(self.coregenomes))
                # Add strain name, the number of core genes present, and the number of total core genes to the string
                data += '{sn},{cr}\n'.format(sn=sample.name,
                                             cr=sample[self.analysistype].coreresults)
            report.write(data)

        for sample in self.metadata:
            # Remove the messy blast results and set/list of core genes from the object
            try:
                delattr(sample[self.analysistype], ""blastresults"")
            except AttributeError:
                pass
            try:
                delattr(sample[self.analysistype], 'coreset')
            except AttributeError:
                pass"
89,"def get_simple_output(self, stderr=STDOUT):
        """"""Executes a simple external command and get its output
        The command contains no pipes. Error messages are
        redirected to the standard output by default

        :param stderr: where to put stderr
        :return: output of command
        """"""
        args = shlex.split(self.cmd)
        proc = Popen(args, stdout=PIPE, stderr=stderr)
        return proc.communicate()[0].decode(""utf8"")"
90,"def get_complex_output(self, stderr=STDOUT):
        """"""Executes a piped command and get the lines of the output in a list

        :param stderr: where to put stderr
        :return: output of command
        """"""
        proc = Popen(self.cmd, shell=True, stdout=PIPE, stderr=stderr)
        return proc.stdout.readlines()"
91,"def get_output_from_pipe(self, input_file):
        """"""Executes an external command and get its output. The command
        receives its input_file from the stdin through a pipe
        
        :param input_file: input file
        :return: output of command
        """"""
        args = shlex.split(self.cmd)
        p = Popen(args, stdout=PIPE, stdin=PIPE)  # | grep es
        p.stdin.write(bytearray(input_file.encode(""utf8"")))  # echo test |
        return p.communicate()[0].decode(""utf8"")"
92,"def get_return_code(self, stderr=STDOUT):
        """"""Executes a simple external command and return its exit status
        
        :param stderr: where to put stderr
        :return: return code of command
        """"""
        args = shlex.split(self.cmd)
        return call(args, stdout=PIPE, stderr=stderr)"
93,"def get_exit_code(self):
        """"""Executes the external command and get its exitcode, stdout and stderr
        
        :return: exit code of command
        """"""
        args = shlex.split(self.cmd)

        proc = Popen(args, stdout=PIPE, stderr=PIPE)
        out, err = proc.communicate()
        out, err = out.decode(""utf8""), err.decode(""utf8"")
        exitcode = proc.returncode
        #
        return exitcode, out, err"
94,"def execute_in_background(self):
        """"""Executes a (shell) command in the background

        :return: the process' pid
        """"""
        # http://stackoverflow.com/questions/1605520
        args = shlex.split(self.cmd)
        p = Popen(args)
        return p.pid"
95,"def keep_alive(self):
        """"""Keeps a process alive. If the process terminates, it will restart it
        The terminated processes become zombies. They die when their parent
        terminates
        """"""
        while True:
            pid = self.execute_in_background()
            p = psutil.Process(pid)
            while p.is_running() and str(p.status) != 'zombie':
                os.system('sleep 5')"
96,"def get_free_mb(folder):
    """""" Return folder/drive free space (in bytes)
    """"""
    if platform.system() == 'Windows':
        free_bytes = ctypes.c_ulonglong(0)
        ctypes.windll.kernel32.GetDiskFreeSpaceExW(ctypes.c_wchar_p(folder), None, None, ctypes.pointer(free_bytes))
        return free_bytes.value/1024/1024
    else:
        st = os.statvfs(folder)
        return st.f_bavail * st.f_frsize/1024/1024"
97,"def increment_title(title):
    """"""
    Increments a string that ends in a number
    """"""
    count = re.search('\d+$', title).group(0)
    new_title = title[:-(len(count))] + str(int(count)+1)
    return new_title"
98,"def check_limit(self, limit):
        """"""
        Checks if the given limit is valid.

        A limit must be > 0 to be considered valid.

        Raises ValueError when the *limit* is not > 0.
        """"""
        if limit > 0:
            self.limit = limit
        else:
            raise ValueError(""Rule limit must be strictly > 0 ({0} given)""
                             .format(limit))

        return self"
99,"def build_filter(self, filter):
        """"""
        Tries to build a :class:`filter.Filter` instance from the given filter.

        Raises ValueError if the :class:`filter.Filter` object can't be build
        from the given filter.
        """"""
        try:
            self.filter = Filter.from_string(filter, self.limit)
        except ValueError:
            raise

        return self"
100,"def build_action(self, action):
        """"""
        Tries to build an :class:`action.Action` instance from the given
        action.

        Raises ValueError if the :class:`action.Action` object can't be build
        from the given action.
        """"""
        try:
            self.action = Action.from_string(action)
        except ValueError:
            raise

        return self"
101,"def get_args():
    """"""
    request the arguments for running
    """"""
    ap = argparse.ArgumentParser(description=""Create frames for a movie that can be compiled using ffmpeg"")
    ap.add_argument(""start"", help=""date string as start time"")
    ap.add_argument(""end"", help=""date string as end time"")
    ap.add_argument(""step"", type=float, help=""fraction of a day to step by"")
    ap.add_argument(""--config"", help=""path to a config file"", default=""config.json"")
    return ap.parse_args()"
102,"def make_three_color(data, time, step, config, shape=(1280, 1280), lower_val=(0, 0, 0), upper_val=(2.5, 2.5, 2.5)):
    """"""
    create a three color image according to the config file
    :param data: a dictionary of fetched data where keys correspond to products
    :param config: a config object
    :param shape: the size of a composite image
    :param lower_val: a tuple of lower values for RGB, any value below this is set to the low value
    :param upper_val: a tuple of upper values for RGB, any value above this is set to the high value
    :return: a (m,n,3) numpy array for a three color image where all values are between 0 and 1
    """"""
    order = {'red': 0, 'green': 1, 'blue': 2}

    three_color = np.zeros((shape[0], shape[1], 3))
    channel_colors = {color: config.default[color] for color in ['red', 'green', 'blue']}

    for color, channel in channel_colors.items():
        if data[channel][1] is None or \
                abs((time - date_parser.parse(data[channel][0]['date-end'])).total_seconds()) > step.total_seconds()/2.0:
            return np.zeros((shape[0], shape[1], 3))

        three_color[:, :, order[color]] = data[channel][1]

        # scale the image by the power
        three_color[:, :, order[color]] = np.power(three_color[:, :, order[color]],
                                                   config.default[""{}_power"".format(color)])

        # adjust the percentile thresholds
        lower = lower_val[order[color]]
        upper = upper_val[order[color]]
        three_color[np.where(three_color[:, :, order[color]] < lower)] = lower
        three_color[np.where(three_color[:, :, order[color]] > upper)] = upper

    # image values must be between (0,1) so scale image
    for color, index in order.items():
        three_color[:, :, index] /= upper_val[order[color]]
    return three_color"
103,"def main():
    """"""
    process the main task
    """"""
    args = get_args()
    args.start = date_parser.parse(args.start)
    args.end = date_parser.parse(args.end)
    args.step = timedelta(args.step)
    config = Config(args.config)

    times = [args.start + i * args.step for i in range(int((args.end - args.start) / args.step))]

    for i, time in enumerate(times):
        make_plot(time, config, args.step)"
104,"def make_plot(time, config, step):
    """"""
    create a three color and all composite images for a given time
    NOTE: channel mins and maxes are currently hardcoded since this is a very specific script
    :param i: the index to save the file as
    :param time:
    :param config:
    :return:
    """"""
    fig, ax = plt.subplots()
    try:
        result = Fetcher(time, products=config.products,
                         suvi_composite_path=config.suvi_composite_path).fetch(multithread=False)
        if result:
            arr = make_three_color(result, time, step, config, upper_val=(2.4, 2.4, 2.4))
        else:
            arr = np.zeros((1280, 1280, 3))
    except ValueError:

        arr = np.zeros((1280, 1280, 3))

    ax.imshow(arr, origin='lower')
    timestr = time.strftime(""%Y-%m-%d %H:%M:%S"")
    fnextend = time.strftime(""%Y%m%d%H%M%S"")
    ax.set_title(timestr)
    ax.set_axis_off()
    fig.savefig(""three_{}.png"".format(fnextend), bbox_inches='tight', dpi=300)
    plt.close(fig)

    channel_min = {'suvi-l2-ci094': 0,
                   'suvi-l2-ci131': 0,
                   'suvi-l2-ci171': 0,
                   'suvi-l2-ci195': 0,
                   'suvi-l2-ci284': 0,
                   'suvi-l2-ci304': 0}
    channel_max = {'suvi-l2-ci094': 1,
                   'suvi-l2-ci131': 1,
                   'suvi-l2-ci171': 1.8,
                   'suvi-l2-ci195': 1.8,
                   'suvi-l2-ci284': 1.8,
                   'suvi-l2-ci304': 2.5}

    for channel in channel_min:
        fig, ax = plt.subplots()
        if result[channel][1] is not None and \
                abs((time - date_parser.parse(result[channel][0]['date-end'])).total_seconds()) < step.total_seconds()/2.0:
            dat = np.power(result[channel][1], 0.25)
            ax.set_title(date_parser.parse(result[channel][0]['date-obs']).strftime(""%Y-%m-%d %H:%M:%S""))
            dat[np.isnan(dat)] = 0
        else:
            dat = np.zeros((1280, 1280))
            ax.set_title(timestr)
        ax.imshow(dat, vmin=channel_min[channel], vmax=channel_max[channel], cmap='gray', origin='lower')
        ax.set_axis_off()
        fig.savefig(""{}_{}.png"".format(channel, fnextend), bbox_inches='tight', dpi=300)
        plt.close(fig)"
105,"def overall():
        """""" The overall grammer for pulling apart the main input files. """"""
        return ZeroOrMore(Grammar.comment) + Dict(ZeroOrMore(Group(
            Grammar._section + ZeroOrMore(Group(Grammar.line)))
            ))"
106,"def file():
        """""" Grammar for files found in the overall input files.	""""""
        return (
            Optional(Word(alphanums).setResultsName('alias') +
                Suppress(Literal('.'))) + Suppress(White()) +
            Word(approved_printables).setResultsName('filename')
            )"
107,"def command_lines():
        """""" Grammar for commands found in the overall input files. """"""
        return ZeroOrMore(Group(
            Group(ZeroOrMore(Group(Grammar.comment))) + Grammar._non_comment_line
        ))"
108,"def command():
        """""" Grammar for commands found in the overall input files. """"""
        return (
            OneOrMore(
                Word(approved_printables+' ').setResultsName('command',
                    listAllMatches=True) ^
                Grammar.__command_input_output.setResultsName('_in',
                    listAllMatches=True)
                )
            )"
109,"def listen_to_event_updates():
    """"""Subscribe to events.""""""
    def callback(event):
        print('Event:', event)

    client.create_event_subscription(instance='simulator', on_data=callback)

    sleep(5)"
110,"def get_current_scene_node():
    """"""Return the name of the jb_sceneNode, that describes the current scene or None if there is no scene node.

    :returns: the full name of the node or none, if there is no scene node
    :rtype: str | None
    :raises: None
    """"""
    c = cmds.namespaceInfo(':', listOnlyDependencyNodes=True, absoluteName=True, dagPath=True)
    l = cmds.ls(c, type='jb_sceneNode', absoluteName=True)
    if not l:
        return
    else:
        for n in sorted(l):
            if not cmds.listConnections(""%s.reftrack"" % n, d=False):
                return n"
111,"def updateSpec(self, *args, **kwargs):
        """"""Updates the spectrogram. First argument can be a filename, 
        or a data array. If no arguments are given, clears the spectrograms.

        For other arguments, see: :meth:`SpecWidget.updateData<sparkle.gui.plotting.pyqtgraph_widgets.SpecWidget.updateData>`
        """"""
        if args[0] is None:
            self.specPlot.clearImg()
        elif isinstance(args[0], basestring):
            self.specPlot.fromFile(*args, **kwargs)
        else:
            self.specPlot.updateData(*args,**kwargs)"
112,"def showSpec(self, fname):
        """"""Draws the spectrogram if it is currently None""""""
        if not self.specPlot.hasImg() and fname is not None:
            self.specPlot.fromFile(fname)"
113,"def updateSpiketrace(self, xdata, ydata, plotname=None):
        """"""Updates the spike trace

        :param xdata: index values
        :type xdata: numpy.ndarray
        :param ydata: values to plot
        :type ydata: numpy.ndarray
        """"""
        if plotname is None:
            plotname = self.responsePlots.keys()[0]

        if len(ydata.shape) == 1:
            self.responsePlots[plotname].updateData(axeskey='response', x=xdata, y=ydata)
        else:
            self.responsePlots[plotname].addTraces(xdata, ydata)"
114,"def addRasterPoints(self, xdata, repnum, plotname=None):
        """"""Add a list (or numpy array) of points to raster plot, 
        in any order.

        :param xdata: bin centers
        :param ydata: rep number 
        """"""
        if plotname is None:
            plotname = self.responsePlots.keys()[0]
        ydata = np.ones_like(xdata)*repnum
        self.responsePlots[plotname].appendData('raster', xdata, ydata)"
115,"def updateSignal(self, xdata, ydata, plotname=None):
        """"""Updates the trace of the outgoing signal

        :param xdata: time points of recording
        :param ydata: brain potential at time points
        """"""
        if plotname is None:
            plotname = self.responsePlots.keys()[0]
        self.responsePlots[plotname].updateData(axeskey='stim', x=xdata, y=ydata)"
116,"def setXlimits(self, lims):
        """"""Sets the X axis limits of the trace plot

        :param lims: (min, max) of x axis, in same units as data
        :type lims: (float, float)
        """"""
        # update all ""linked"", plots
        self.specPlot.setXlim(lims)
        for plot in self.responsePlots.values():
            plot.setXlim(lims)
        # ridiculous...
        sizes = self.splittersw.sizes()
        if len(sizes) > 1:
            if self.badbadbad:
                sizes[0] +=1
                sizes[1] -=1
            else:
                sizes[0] -=1
                sizes[1] +=1
            self.badbadbad = not self.badbadbad
            self.splittersw.setSizes(sizes)

        self._ignore_range_signal = False"
117,"def setNreps(self, nreps):
        """"""Sets the number of reps before the raster plot resets""""""
        for plot in self.responsePlots.values():
            plot.setNreps(nreps)"
118,"def specAutoRange(self):
        """"""Auto adjusts the visible range of the spectrogram""""""
        trace_range = self.responsePlots.values()[0].viewRange()[0]
        vb = self.specPlot.getViewBox()
        vb.autoRange(padding=0)
        self.specPlot.setXlim(trace_range)"
119,"def interpret_header(self):
        """"""
        Read pertinent information from the image headers,
         especially location and radius of the Sun to calculate the default thematic map
        :return: setes self.date, self.cy, self.cx, and self.sun_radius_pixel
        """"""
        # handle special cases since date-obs field changed names
        if 'DATE_OBS' in self.header:
            self.date = self.header['DATE_OBS']
        elif 'DATE-OBS' in self.header:
            self.date = self.header['DATE-OBS']
        else:
            raise Exception(""Image does not have a DATE_OBS or DATE-OBS field"")

        self.cy, self.cx = self.header['CRPIX1'], self.header['CRPIX2']
        sun_radius_angular = sun.solar_semidiameter_angular_size(t=time.parse_time(self.date)).arcsec
        arcsec_per_pixel = self.header['CDELT1']
        self.sun_radius_pixel = (sun_radius_angular / arcsec_per_pixel)"
120,"def save(self):
        """""" Save as a FITS file and attempt an upload if designated in the configuration file """"""
        out = Outgest(self.output, self.selection_array.astype('uint8'), self.headers, self.config_path)
        out.save()
        out.upload()"
121,"def on_exit(self):
        """""" When you click to exit, this function is called, prompts whether to save""""""
        answer = messagebox.askyesnocancel(""Exit"", ""Do you want to save as you quit the application?"")
        if answer:
            self.save()
            self.quit()
            self.destroy()
        elif answer is None:
            pass # the cancel action
        else:
            self.quit()
            self.destroy()"
122,"def make_gui(self):
        """""" Setups the general structure of the gui, the first function called """"""
        self.option_window = Toplevel()
        self.option_window.protocol(""WM_DELETE_WINDOW"", self.on_exit)
        self.canvas_frame = tk.Frame(self, height=500)
        self.option_frame = tk.Frame(self.option_window, height=300)
        self.canvas_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        self.option_frame.pack(side=tk.RIGHT, fill=None, expand=False)
        self.make_options_frame()
        self.make_canvas_frame()
        self.disable_singlecolor()"
123,"def configure_threecolor_image(self):
        """"""
        configures the three color image according to the requested parameters
        :return: nothing, just updates self.image
        """"""
        order = {'red': 0, 'green': 1, 'blue': 2}
        self.image = np.zeros((self.shape[0], self.shape[1], 3))
        for color, var in self.multicolorvars.items():
            channel = var.get()  # determine which channel should be plotted as this color
            self.image[:, :, order[color]] = self.data[channel]

            # scale the image by the power
            self.image[:, :, order[color]] = np.power(self.image[:, :, order[color]],
                                                      self.multicolorpower[color].get())

            # adjust the percentile thresholds
            lower = np.nanpercentile(self.image[:, :, order[color]], self.multicolormin[color].get())
            upper = np.nanpercentile(self.image[:, :, order[color]], self.multicolormax[color].get())
            self.image[np.where(self.image[:, :, order[color]] < lower)] = lower
            self.image[np.where(self.image[:, :, order[color]] > upper)] = upper

        # image values must be between (0,1) so scale image
        for color, index in order.items():
            self.image[:, :, index] /= np.nanmax(self.image[:, :, index])"
124,"def configure_singlecolor_image(self, scale=False):
        """"""
        configures the single color image according to the requested parameters
        :return: nothing, just updates self.image
        """"""
        # determine which channel to use
        self.image = self.data[self.singlecolorvar.get()]

        # scale the image by requested power
        self.image = np.power(self.image, self.singlecolorpower.get())

        # adjust the percentile thresholds
        lower = np.nanpercentile(self.image, self.singlecolormin.get())
        upper = np.nanpercentile(self.image, self.singlecolormax.get())
        self.image[self.image < lower] = lower
        self.image[self.image > upper] = upper

        # image values must be between (0,1) so scale image
        self.image /= np.nanmax(self.image)"
125,"def updateArray(self, array, indices, value):
        """"""
        updates array so that pixels at indices take on value
        :param array: (m,n) array to adjust
        :param indices: flattened image indices to change value
        :param value: new value to assign
        :return: the changed (m,n) array
        """"""
        lin = np.arange(array.size)
        new_array = array.flatten()
        new_array[lin[indices]] = value
        return new_array.reshape(array.shape)"
126,"def onlasso(self, verts):
        """"""
        Main function to control the action of the lasso, allows user to draw on data image and adjust thematic map
        :param verts: the vertices selected by the lasso
        :return: nothin, but update the selection array so lassoed region now has the selected theme, redraws canvas
        """"""
        p = path.Path(verts)
        ind = p.contains_points(self.pix, radius=1)
        self.history.append(self.selection_array.copy())
        self.selection_array = self.updateArray(self.selection_array,
                                                ind,
                                                self.solar_class_var.get())
        self.mask.set_data(self.selection_array)
        self.fig.canvas.draw_idle()"
127,"def make_canvas_frame(self):
        """""" Create the data and thematic map images for the first time """"""

        self.fig, (self.imageax, self.previewax) = plt.subplots(ncols=2,
                                                                figsize=self.canvas_size,
                                                                sharex=True, sharey=True,
                                                                gridspec_kw=self.subplot_grid_spec)
        self.canvas = FigureCanvasTkAgg(self.fig, master=self.canvas_frame)
        self.canvas.mpl_connect('button_press_event', self.onclick)
        self.canvas.mpl_connect('key_press_event', self.onpress)

        # set up the channel data view
        self.configure_threecolor_image()
        self.imageplot = self.imageax.imshow(self.image)
        self.imageax.set_xlim([0, self.shape[0]])
        self.imageax.set_ylim([0, self.shape[0]])
        self.imageax.set_axis_off()
        self.history.append(self.selection_array)
        cmap = self.config.solar_cmap
        self.mask = self.previewax.imshow(self.selection_array,
                                          origin='lower',
                                          interpolation='nearest',
                                          cmap=cmap,
                                          vmin=-1, vmax=max([num for _, num in self.config.solar_classes])+1)
        self.previewax.set_xlim([0, self.shape[0]])
        self.previewax.set_ylim([0, self.shape[0]])
        self.previewax.set_aspect(""equal"")
        self.previewax.set_axis_off()

        # add selection layer for lasso
        self.pix = np.arange(self.shape[0])  # assumes square image
        xv, yv = np.meshgrid(self.pix, self.pix)
        self.pix = np.vstack((xv.flatten(), yv.flatten())).T

        lineprops = dict(color=self.config.default['lasso_color'],
                         linewidth=self.config.default['lasso_width'])
        self.lasso = LassoSelector(self.imageax, self.onlasso, lineprops=lineprops)

        # display everything
        self.canvas.show()
        self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)
        self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)

        # add the tool bar
        self.toolbarcenterframe = tk.LabelFrame(self.canvas_frame,
                                                borderwidth=0,
                                                text=""Draw: unlabeled"",
                                                relief=tk.FLAT,
                                                labelanchor=tk.N,
                                                background='red')
        toolbarframe = tk.Frame(self.toolbarcenterframe)
        toolbar = CustomToolbar(self.canvas, toolbarframe, self.toolbarcenterframe, self)
        toolbar.update()
        self.fig.canvas.toolbar.set_message = lambda x: """"  # remove state reporting
        toolbarframe.pack()
        self.toolbarcenterframe.pack(side=tk.BOTTOM, fill=tk.X)"
128,"def onpress(self, event):
        """"""
        Reacts to key commands
        :param event: a keyboard event
        :return: if 'c' is pressed, clear all region patches
        """"""
        if event.key == 'c':  # clears all the contours
            for patch in self.region_patches:
                patch.remove()
            self.region_patches = []
            self.fig.canvas.draw_idle()
        elif event.key == ""u"":  # undo a label
            self.undobutton_action()"
129,"def onclick(self, event):
        """"""
        Draw contours on the data for a click in the thematic map
        :param event: mouse click on thematic map preview
        """"""
        if event.inaxes == self.previewax:
            y, x = int(event.xdata), int(event.ydata)
            label = self.selection_array[x, y]
            contiguous_regions = scipy.ndimage.label(self.selection_array == label)[0]
            this_region = contiguous_regions == (contiguous_regions[x, y])

            # remove the boundaries so any region touching the edge isn't drawn odd
            this_region[0, :] = 0
            this_region[:, 0] = 0
            this_region[this_region.shape[0]-1, :] = 0
            this_region[:, this_region.shape[1]-1] = 0

            # convert the region mask into just a true/false array of its boundary pixels
            edges = binary_erosion(this_region) ^ this_region

            # convert the boundary pixels into a path, moving around instead of just where
            x, y = np.where(edges)
            coords = np.dstack([x, y])[0]
            path = [coords[0]]
            coords = coords[1:]

            while len(coords):
                dist = np.sum(np.abs(path[-1] - coords), axis=1)
                neighbor_index = np.argmin(dist)

                if dist[neighbor_index] < 5:
                    path.append(coords[neighbor_index].copy())
                    coords[neighbor_index:-1] = coords[neighbor_index + 1:]
                    coords = coords[:-1]
                else:
                    break

            path = np.array(path)

            clips = []
            while len(coords) > 5:
                dist = np.sum(np.abs(path[-1] - coords), axis=1)
                neighbor_index = np.argmin(dist)
                clip = [coords[neighbor_index].copy()]
                coords[neighbor_index:-1] = coords[neighbor_index + 1:]
                coords = coords[:-1]
                while len(coords):
                    dist = np.sum(np.abs(clip[-1] - coords), axis=1)
                    neighbor_index = np.argmin(dist)
                    if dist[neighbor_index] < 5:
                        clip.append(coords[neighbor_index].copy())
                        coords[neighbor_index:-1] = coords[neighbor_index + 1:]
                        coords = coords[:-1]
                    else:
                        break
                clips.append(np.array(clip))

            # draw the continguous  on the selection area
            self.region_patches.append(PatchCollection(
                [Polygon(np.dstack([path[:, 1], path[:, 0]])[0], False,
                         fill=False, facecolor=None,
                         edgecolor=""black"", alpha=1, lw=2.5)] +
                [Polygon(np.dstack([clip[:, 1], clip[:, 0]])[0], False,
                         fill=False, facecolor=None,
                         edgecolor=""black"", alpha=1, lw=2.0) for clip in clips],
                match_original=True))
            self.imageax.add_collection(self.region_patches[-1])
            self.fig.canvas.draw_idle()"
130,"def make_options_frame(self):
        """""" make the frame that allows for configuration and classification""""""
        self.tab_frame = ttk.Notebook(self.option_frame, width=800)
        self.tab_configure = tk.Frame(self.tab_frame)
        self.tab_classify = tk.Frame(self.tab_frame)
        self.make_configure_tab()
        self.make_classify_tab()

        self.tab_frame.add(self.tab_configure, text=""Configure"")
        self.tab_frame.add(self.tab_classify, text=""Classify"")
        self.tab_frame.pack(fill=tk.BOTH, expand=True)"
131,"def disable_multicolor(self):
        """""" swap from the multicolor image to the single color image """"""
        # disable the multicolor image
        for color in ['red', 'green', 'blue']:
            self.multicolorscales[color].config(state=tk.DISABLED, bg='grey')
            self.multicolorframes[color].config(bg='grey')
            self.multicolorlabels[color].config(bg='grey')
            self.multicolordropdowns[color].config(bg='grey', state=tk.DISABLED)
            self.multicolorminscale[color].config(bg='grey', state=tk.DISABLED)
            self.multicolormaxscale[color].config(bg='grey', state=tk.DISABLED)

        # enable the single color
        self.singlecolorscale.config(state=tk.NORMAL, bg=self.single_color_theme)
        self.singlecolorframe.config(bg=self.single_color_theme)
        self.singlecolorlabel.config(bg=self.single_color_theme)
        self.singlecolordropdown.config(bg=self.single_color_theme, state=tk.NORMAL)
        self.singlecolorminscale.config(bg=self.single_color_theme, state=tk.NORMAL)
        self.singlecolormaxscale.config(bg=self.single_color_theme, state=tk.NORMAL)"
132,"def update_button_action(self):
        """""" when update button is clicked, refresh the data preview""""""
        if self.mode.get() == 3:  # threecolor
            self.configure_threecolor_image()
        elif self.mode.get() == 1:  # singlecolor
            self.configure_singlecolor_image()
        else:
            raise ValueError(""mode can only be singlecolor or threecolor"")

        self.imageplot.set_data(self.image)
        if self.mode.get() == 1:  # singlecolor
            self.imageplot.set_cmap('gist_gray')
        self.fig.canvas.draw_idle()"
133,"def make_configure_tab(self):
        """""" initial set up of configure tab""""""
        # Setup the choice between single and multicolor
        modeframe = tk.Frame(self.tab_configure)
        self.mode = tk.IntVar()
        singlecolor = tk.Radiobutton(modeframe, text=""Single color"", variable=self.mode,
                                     value=1, command=lambda: self.disable_multicolor())
        multicolor = tk.Radiobutton(modeframe, text=""Three color"", variable=self.mode,
                                    value=3, command=lambda: self.disable_singlecolor())
        self.mode.set(3)
        singlecolor.pack(side=tk.LEFT)
        multicolor.pack(side=tk.LEFT)

        updatebutton = tk.Button(master=modeframe, text=""Update"",
                                 command=self.update_button_action)
        updatebutton.pack(side=tk.RIGHT)
        modeframe.grid(row=0, column=0)
        self.setup_multicolor()
        self.setup_singlecolor()"
134,"def make_classify_tab(self):
        """""" initial set up of classification tab""""""
        self.pick_frame = tk.Frame(self.tab_classify)
        self.pick_frame2 = tk.Frame(self.tab_classify)

        self.solar_class_var = tk.IntVar()
        self.solar_class_var.set(0)  # initialize to unlabeled
        buttonnum = 0
        frame = [self.pick_frame, self.pick_frame2]
        for text, value in self.config.solar_classes:
            b = tk.Radiobutton(frame[buttonnum % 2], text=text,
                               variable=self.solar_class_var,
                               value=value, background=self.config.solar_colors[text],
                               indicatoron=0, width=50, height=2, command=self.change_class)
            b.pack(fill=tk.BOTH, expand=1)
            buttonnum += 1


        self.pick_frame.grid(row=0, column=0, rowspan=5, sticky=tk.W + tk.E + tk.N + tk.S)
        self.pick_frame2.grid(row=0, column=1, rowspan=5, sticky=tk.W + tk.E + tk.N + tk.S)

        undobutton = tk.Button(master=self.tab_classify, text=""Undo"",
                               command=self.undobutton_action)
        undobutton.grid(row=6, column=0, columnspan=2, sticky=tk.W + tk.E)"
135,"def setup_singlecolor(self):
        """""" initial setup of single color options and variables""""""
        self.singlecolorframe = tk.Frame(self.tab_configure, bg=self.single_color_theme)
        channel_choices = sorted(list(self.data.keys()))
        self.singlecolorlabel = tk.Label(self.singlecolorframe, text=""single"", bg=self.single_color_theme, width=10)
        self.singlecolorvar = tk.StringVar()
        self.singlecolorpower = tk.DoubleVar()
        self.singlecolormin = tk.DoubleVar()
        self.singlecolormax = tk.DoubleVar()
        self.singlecolordropdown = tk.OptionMenu(self.singlecolorframe, self.singlecolorvar, *channel_choices)
        self.singlecolorscale = tk.Scale(self.singlecolorframe, variable=self.singlecolorpower,
                                         orient=tk.HORIZONTAL, from_=self.config.ranges['single_color_power_min'],
                                         bg=self.single_color_theme,
                                         to_=self.config.ranges['single_color_power_max'],
                                         resolution=self.config.ranges['single_color_power_resolution'],
                                         length=200)
        self.singlecolorminscale = tk.Scale(self.singlecolorframe, variable=self.singlecolormin,
                                            orient=tk.HORIZONTAL, from_=0,
                                            bg=self.single_color_theme,
                                            to_=self.config.ranges['single_color_vmin'],
                                            resolution=self.config.ranges['single_color_vresolution'], length=200)

        self.singlecolormaxscale = tk.Scale(self.singlecolorframe, variable=self.singlecolormax,
                                            orient=tk.HORIZONTAL, from_=self.config.ranges['single_color_vmax'],
                                            bg=self.single_color_theme,
                                            to_=100, resolution=self.config.ranges['single_color_vresolution'],
                                            length=200)

        self.singlecolorvar.set(self.config.products_map[self.config.default['single']])
        self.singlecolorpower.set(self.config.default['single_power'])
        self.singlecolormin.set(0)
        self.singlecolormax.set(100)
        self.singlecolordropdown.config(bg=self.single_color_theme, width=10)
        self.singlecolorlabel.pack(side=tk.LEFT)
        self.singlecolorscale.pack(side=tk.RIGHT)
        self.singlecolormaxscale.pack(side=tk.RIGHT)
        self.singlecolorminscale.pack(side=tk.RIGHT)
        self.singlecolordropdown.pack()
        self.singlecolorframe.grid(row=4, columnspan=5, rowspan=1)"
136,"def setup_multicolor(self):
        """""" initial setup of multicolor options and variables""""""
        # Setup the options for multicolor
        multicolormasterframe = tk.Frame(self.tab_configure)
        channel_choices = sorted(list(self.data.keys()))
        rgb = ['red', 'green', 'blue']
        self.multicolorframes = {color: tk.Frame(multicolormasterframe, bg=color) for color in rgb}
        self.multicolorlabels = {color: tk.Label(self.multicolorframes[color], text=color, bg=color, width=10) for color
                                 in rgb}
        self.multicolorvars = {color: tk.StringVar() for color in rgb}
        self.multicolorpower = {color: tk.DoubleVar() for color in rgb}
        self.multicolormin = {color: tk.DoubleVar() for color in rgb}
        self.multicolormax = {color: tk.DoubleVar() for color in rgb}

        self.multicolordropdowns = {color: tk.OptionMenu(self.multicolorframes[color],
                                                         self.multicolorvars[color],
                                                         *channel_choices) for color in rgb}

        self.multicolorscales = {color: tk.Scale(self.multicolorframes[color],
                                                 variable=self.multicolorpower[color],
                                                 orient=tk.HORIZONTAL,
                                                 from_=self.config.ranges['multi_color_power_min'],
                                                 to_=self.config.ranges['multi_color_power_max'], bg=color,
                                                 resolution=self.config.ranges['multi_color_power_resolution'],
                                                 length=200) for color in rgb}
        self.multicolorminscale = {color: tk.Scale(self.multicolorframes[color],
                                                   variable=self.multicolormin[color],
                                                   orient=tk.HORIZONTAL, from_=0,
                                                   to_=self.config.ranges['multi_color_vmin'], bg=color,
                                                   resolution=self.config.ranges['multi_color_vresolution'],
                                                   length=200) for color in rgb}
        self.multicolormaxscale = {color: tk.Scale(self.multicolorframes[color],
                                                   variable=self.multicolormax[color],
                                                   orient=tk.HORIZONTAL, from_=self.config.ranges['multi_color_vmax'],
                                                   to_=100, bg=color,
                                                   resolution=self.config.ranges['multi_color_vresolution'],
                                                   length=200) for color in rgb}

        for color in rgb:
            self.multicolorvars[color].set(self.config.products_map[self.config.default[color]])
            self.multicolorpower[color].set(self.config.default[color + ""_power""])

            self.multicolormin[color].set(0)
            self.multicolormax[color].set(100)
            self.multicolordropdowns[color].config(bg=color, width=10)
            self.multicolorlabels[color].pack(side=tk.LEFT)

            self.multicolorscales[color].pack(side=tk.RIGHT)
            self.multicolormaxscale[color].pack(side=tk.RIGHT)
            self.multicolorminscale[color].pack(side=tk.RIGHT)
            self.multicolordropdowns[color].pack()
            self.multicolorframes[color].pack(fill=tk.BOTH)
        multicolormasterframe.grid(row=1, column=0, columnspan=5, rowspan=3)"
137,"def undobutton_action(self):
        """""" when undo is clicked, revert the thematic map to the previous state""""""
        if len(self.history) > 1:
            old = self.history.pop(-1)
            self.selection_array = old
            self.mask.set_data(old)
            self.fig.canvas.draw_idle()"
138,"def change_class(self):
        """""" ""on changing the classification label, update the ""draw"" text """"""
        self.toolbarcenterframe.config(text=""Draw: {}"".format(self.config.solar_class_name[self.solar_class_var.get()]))"
139,"def draw_circle(self, center, radius, array, value, mode=""set""):
        """"""
        Draws a circle of specified radius on the input array and fills it with specified value
        :param center: a tuple for the center of the circle
        :type center: tuple (x,y)
        :param radius: how many pixels in radius the circle is
        :type radius: int
        :param array: image to draw circle on
        :type array: size (m,n) numpy array
        :param value: what value to fill the circle with
        :type value: float
        :param mode: if ""set"" will assign the circle interior value, if ""add"" will add the value to the circle interior,
            throws exception otherwise
        :type mode: string, either ""set"" or ""add""
        :return: updates input array
        """"""
        ri, ci = draw.circle(center[0], center[1],
                             radius=radius,
                             shape=array.shape)
        if mode == ""add"":
            array[ri, ci] += value
        elif mode == ""set"":
            array[ri, ci] = value
        else:
            raise ValueError(""draw_circle mode must be 'set' or 'add' but {} used"".format(mode))
        return ri, ci, array[ri,ci]"
140,"def draw_annulus(self, center, inner_radius, outer_radius, array, value, mode=""set""):
        """"""
        Draws an annulus of specified radius on the input array and fills it with specified value
        :param center: a tuple for the center of the annulus
        :type center: tuple (x,y)
        :param inner_radius: how many pixels in radius the interior empty circle is, where the annulus begins
        :type inner_radius: int
        :param outer_radius: how many pixels in radius the larger outer circle is, where the annulus ends
        :typde outer_radius: int
        :param array: image to draw annulus on
        :type array: size (m,n) numpy array
        :param value: what value to fill the annulus with
        :type value: float
        :param mode: if ""set"" will assign the circle interior value, if ""add"" will add the value to the circle interior,
            throws exception otherwise
        :type mode: string, either ""set"" or ""add""
        :return: updates input array and then returns it with the annulus coordinates as a tuple
        """"""
        if mode == ""add"":
            self.draw_circle(center, outer_radius, array, value)
            self.draw_circle(center, inner_radius, array, -value)
        elif mode == ""set"":
            ri, ci, existing = self.draw_circle(center, inner_radius, array, -value)
            self.draw_circle(center, outer_radius, array, value)
            array[ri, ci] = existing
        else:
            raise ValueError(""draw_annulus mode must be 'set' or 'add' but {} used"".format(mode))"
141,"def draw_default(self, inside=5, outside=15):
        """"""
        Draw suggested sun disk, limb, and empty background
        :param inside: how many pixels from the calculated solar disk edge to go inward for the limb
        :param outside: how many pixels from the calculated solar disk edge to go outward for the limb
        :return: updates the self.selection_array
        """"""
        # fill everything with empty outer space
        if 'outer_space' in self.config.solar_class_index:
            self.selection_array[:, :] = self.config.solar_class_index['outer_space']
        elif 'empty_outer_space' in self.config.solar_class_index:
            self.selection_array[:, :] = self.config.solar_class_index['empty_outer_space']
        else:
            raise ValueError(""outer_space or empty_outer_space must be classes with colors."")

        # draw the limb label in its location
        self.draw_annulus((self.cx, self.cy),
                          self.sun_radius_pixel - inside,
                          self.sun_radius_pixel + outside,
                          self.selection_array,
                          self.config.solar_class_index['limb'])

        # draw quiet sun in its location
        self.draw_circle((self.cx, self.cy),
                         self.sun_radius_pixel - inside,
                         self.selection_array,
                         self.config.solar_class_index['quiet_sun'])"
142,"def values(self):
        """"""Gets the parameter values

        :returns: dict of inputs:
        |        *'nfft'*: int -- length, in samples, of FFT chunks
        |        *'window'*: str -- name of window to apply to FFT chunks
        |        *'overlap'*: float -- percent overlap of windows 
        """"""
        self.vals['nfft'] = self.ui.nfftSpnbx.value()
        self.vals['window'] = str(self.ui.windowCmbx.currentText()).lower()
        self.vals['overlap'] = self.ui.overlapSpnbx.value()
        return self.vals"
143,"def main():
    """""" Parses the command-line args, and calls run. """"""
    parser = argparse.ArgumentParser(
        description='A pipeline that generates analysis pipelines.')
    parser.add_argument('input', nargs='?',
                   help='A valid metapipe configuration file.')
    parser.add_argument('-o', '--output',
                   help='An output destination. If none is provided, the '
                   'results will be printed to stdout.',
                   default=sys.stdout)
    parser.add_argument('-t', '--temp',
                   help='A desired metapipe binary file. This is used to store '
                   'temp data between generation and execution. '
                   '(Default: ""%(default)s"")', default='.metapipe')
    parser.add_argument('-s', '--shell',
                   help='The path to the shell to be used when executing the '
                   'pipeline. (Default: ""%(default)s)""',
                   default='/bin/bash')
    parser.add_argument('-r', '--run',
                   help='Run the pipeline as soon as it\'s ready.',
                   action='store_true')
    parser.add_argument('-n', '--name',
                   help='A name for the pipeline.',
                   default='')
    parser.add_argument('-j', '--job-type',
                   help='The destination for calculations (i.e. local, a PBS '
                   'queue on a cluster, etc).\nOptions: {}. '
                   '(Default: ""%(default)s)""'.format(JOB_TYPES.keys()),
                   default='local')
    parser.add_argument('-p', '--max-jobs',
                   help='The maximum number of concurrent jobs allowed. '
                   'Defaults to maximum available cores.',
                   default=None)
    parser.add_argument('--report-type',
                   help='The output report type. By default metapipe will '
                   'print updates to the console. \nOptions: {}. '
                   '(Default: ""%(default)s)""'.format(QUEUE_TYPES.keys()),
                   default='text')
    parser.add_argument('-v','--version',
                    help='Displays the current version of the application.',
                    action='store_true')
    args = parser.parse_args()

    if args.version:
        print('Version: {}'.format(__version__))
        sys.exit(0)

    try:
        with open(args.input) as f:
            config = f.read()
    except IOError:
        print('No valid config file found.')
        return -1

    run(config, args.max_jobs, args.output, args.job_type, args.report_type,
        args.shell, args.temp, args.run)"
144,"def run(config, max_jobs, output=sys.stdout, job_type='local',
        report_type='text', shell='/bin/bash', temp='.metapipe', run_now=False):
    """""" Create the metapipe based on the provided input. """"""
    if max_jobs == None:
        max_jobs = cpu_count()

    parser = Parser(config)
    try:
        command_templates = parser.consume()
    except ValueError as e:
        raise SyntaxError('Invalid config file. \n%s' % e)
    options = '\n'.join(parser.global_options)

    queue_type = QUEUE_TYPES[report_type]
    pipeline = Runtime(command_templates,queue_type,JOB_TYPES,job_type,max_jobs)

    template = env.get_template('output_script.tmpl.sh')
    with open(temp, 'wb') as f:
        pickle.dump(pipeline, f, 2)
        script = template.render(shell=shell,
            temp=os.path.abspath(temp), options=options)

    if run_now:
        output = output if output != sys.stdout else PIPELINE_ALIAS
        submit_job = make_submit_job(shell, output, job_type)
        submit_job.submit()

    try:
        f = open(output, 'w')
        output = f
    except TypeError:
        pass

    output.write(script)
    f.close()"
145,"def make_submit_job(shell, output, job_type):
    """""" Preps the metapipe main job to be submitted. """"""
    run_cmd = [shell, output]
    submit_command = Command(alias=PIPELINE_ALIAS, cmds=run_cmd)
    submit_job = get_job(submit_command, job_type)
    submit_job.make()
    return submit_job"
146,"def yaml(modules_to_register: Iterable[Any] = None, classes_to_register: Iterable[Any] = None) -> ruamel.yaml.YAML:
    """""" Create a YAML object for loading a YAML configuration.

    Args:
        modules_to_register: Modules containing classes to be registered with the YAML object. Default: None.
        classes_to_register: Classes to be registered with the YAML object. Default: None.
    Returns:
        A newly creating YAML object, configured as apporpirate.
    """"""
    # Defein a round-trip yaml object for us to work with. This object should be imported by other modules
    # NOTE: ""typ"" is a not a typo. It stands for ""type""
    yaml = ruamel.yaml.YAML(typ = ""rt"")

    # Register representers and constructors
    # Numpy
    yaml.representer.add_representer(np.ndarray, numpy_to_yaml)
    yaml.constructor.add_constructor(""!numpy_array"", numpy_from_yaml)
    # Register external classes
    yaml = register_module_classes(yaml = yaml, modules = modules_to_register)
    yaml = register_classes(yaml = yaml, classes = classes_to_register)

    return yaml"
147,"def register_classes(yaml: ruamel.yaml.YAML, classes: Optional[Iterable[Any]] = None) -> ruamel.yaml.YAML:
    """""" Register externally defined classes. """"""
    # Validation
    if classes is None:
        classes = []

    # Register the classes
    for cls in classes:
        logger.debug(f""Registering class {cls} with YAML"")
        yaml.register_class(cls)

    return yaml"
148,"def register_module_classes(yaml: ruamel.yaml.YAML, modules: Optional[Iterable[Any]] = None) -> ruamel.yaml.YAML:
    """""" Register all classes in the given modules with the YAML object.

    This is a simple helper function.
    """"""
    # Validation
    if modules is None:
        modules = []

    # Extract the classes from the modules
    classes_to_register = set()
    for module in modules:
        module_classes = [member[1] for member in inspect.getmembers(module, inspect.isclass)]
        classes_to_register.update(module_classes)

    # Register the extracted classes
    return register_classes(yaml = yaml, classes = classes_to_register)"
149,"def numpy_to_yaml(representer: Representer, data: np.ndarray) -> Sequence[Any]:
    """""" Write a numpy array to YAML.

    It registers the array under the tag ``!numpy_array``.

    Use with:

    .. code-block:: python

        >>> yaml = ruamel.yaml.YAML()
        >>> yaml.representer.add_representer(np.ndarray, yaml.numpy_to_yaml)

    Note:
        We cannot use ``yaml.register_class`` because it won't register the proper type.
        (It would register the type of the class, rather than of `numpy.ndarray`). Instead,
        we use the above approach to register this method explicitly with the representer.
    """"""
    return representer.represent_sequence(
        ""!numpy_array"",
        data.tolist()
    )"
150,"def numpy_from_yaml(constructor: Constructor, data: ruamel.yaml.nodes.SequenceNode) -> np.ndarray:
    """""" Read an array from YAML to numpy.

    It reads arrays registered under the tag ``!numpy_array``.

    Use with:

    .. code-block:: python

        >>> yaml = ruamel.yaml.YAML()
        >>> yaml.constructor.add_constructor(""!numpy_array"", yaml.numpy_from_yaml)

    Note:
        We cannot use ``yaml.register_class`` because it won't register the proper type.
        (It would register the type of the class, rather than of `numpy.ndarray`). Instead,
        we use the above approach to register this method explicitly with the representer.
    """"""
    # Construct the contained values so that we properly construct int, float, etc.
    # We just leave this to YAML because it already stores this information.
    values = [constructor.construct_object(n) for n in data.value]
    logger.debug(f""{data}, {values}"")
    return np.array(values)"
151,"def enum_to_yaml(cls: Type[T_EnumToYAML], representer: Representer, data: T_EnumToYAML) -> ruamel.yaml.nodes.ScalarNode:
    """""" Encodes YAML representation.

    This is a mixin method for writing enum values to YAML. It needs to be added to the enum
    as a classmethod. See the module docstring for further information on this approach and how
    to implement it.

    This method writes whatever is used in the string representation of the YAML value.
    Usually, this will be the unique name of the enumeration value. If the name is used,
    the corresponding ``EnumFromYAML`` mixin can be used to recreate the value. If the name
    isn't used, more care may be necessary, so a ``from_yaml`` method for that particular
    enumeration may be necessary.

    Note:
        This method assumes that the name of the enumeration value should be stored as a scalar node.

    Args:
        representer: Representation from YAML.
        data: Enumeration value to be encoded.
    Returns:
        Scalar representation of the name of the enumeration value.
    """"""
    return representer.represent_scalar(
        f""!{cls.__name__}"",
        f""{str(data)}""
    )"
152,"def enum_from_yaml(cls: Type[T_EnumFromYAML], constructor: Constructor, node: ruamel.yaml.nodes.ScalarNode) -> T_EnumFromYAML:
    """""" Decode YAML representation.

    This is a mixin method for reading enum values from YAML. It needs to be added to the enum
    as a classmethod. See the module docstring for further information on this approach and how
    to implement it.

    Note:
        This method assumes that the name of the enumeration value was stored as a scalar node.

    Args:
        constructor: Constructor from the YAML object.
        node: Scalar node extracted from the YAML being read.
    Returns:
        The constructed YAML value from the name of the enumerated value.
    """"""
    # mypy doesn't like indexing to construct the enumeration.
    return cls[node.value]"
153,"def is_error(self):
        """""" Checks to see if the job errored out. """"""
        try:
            if self._task.is_alive():
                if len(self._task.stderr.readlines()) > 0:
                    self._task.join()
                    self._write_log()
                    return True
        except AttributeError:
            pass
        return False"
154,"def add_splash_ids(splash_mapping_file_pth, conn, db_type='sqlite'):
    """""" Add splash ids to database (in case stored in a different file to the msp files like for MoNA)

    Example:
        >>> from msp2db.db import get_connection
        >>> from msp2db.parse import add_splash_ids
        >>> conn = get_connection('sqlite', 'library.db')
        >>> add_splash_ids('splash_mapping_file.csv', conn, db_type='sqlite')


    Args:
        splash_mapping_file_pth (str): Path to the splash mapping file (needs to be csv format and have no headers,
                                       should contain two columns. The first the accession number the second the splash.
                                       e.g. AU100601, splash10-0a4i-1900000000-d2bc1c887f6f99ed0f74 \n

    """"""
    # get dictionary of accession and library_spectra_meta_id
    cursor = conn.cursor()
    cursor.execute(""SELECT id, accession FROM library_spectra_meta"")

    accession_d = {row[1]: row[0] for row in cursor}

    if db_type == 'sqlite':
        type_sign = '?'
    else:
        type_sign = '%s'

    rows = []
    c = 0
    # loop through splash mapping file
    with open(splash_mapping_file_pth, ""r"") as f:

        for line in f:
            c+=1
            line = line.rstrip()
            line_l = line.split(',')

            accession = line_l[0]
            splash = line_l[1]
            try:
                aid = accession_d[accession]
            except KeyError as e:
                print(""can't find accession {}"".format(accession))
                continue

            row = (splash, aid)
            rows.append(row)

            if c > 200:
                print(row)
                cursor.executemany(""UPDATE library_spectra_meta SET splash = {t} WHERE id = {t} "".format(t=type_sign), rows)
                conn.commit()
                rows = []
                c = 0

    cursor.executemany(""UPDATE library_spectra_meta SET splash = {t} WHERE id = {t} "".format(t=type_sign), rows)
    conn.commit()"
155,"def _get_current_ids(self, source=True, meta=True, spectra=True, spectra_annotation=True):
        """"""Get the current id for each table in the database

        Args:
            source (boolean): get the id for the table ""library_spectra_source"" will update self.current_id_origin
            meta (boolean): get the id for the table ""library_spectra_meta"" will update self.current_id_meta
            spectra (boolean): get the id for the table ""library_spectra"" will update self.current_id_spectra
            spectra_annotation (boolean): get the id for the table ""library_spectra_annotation"" will update
                                          self.current_id_spectra_annotation

        """"""
        # get the cursor for the database connection
        c = self.c
        # Get the last uid for the spectra_info table
        if source:
            c.execute('SELECT max(id) FROM library_spectra_source')
            last_id_origin = c.fetchone()[0]
            if last_id_origin:
                self.current_id_origin = last_id_origin + 1
            else:
                self.current_id_origin = 1

        if meta:
            c.execute('SELECT max(id) FROM library_spectra_meta')
            last_id_meta = c.fetchone()[0]

            if last_id_meta:
                self.current_id_meta = last_id_meta + 1
            else:
                self.current_id_meta = 1

        if spectra:
            c.execute('SELECT max(id) FROM library_spectra')
            last_id_spectra = c.fetchone()[0]

            if last_id_spectra:
                self.current_id_spectra = last_id_spectra + 1
            else:
                self.current_id_spectra = 1

        if spectra_annotation:
            c.execute('SELECT max(id) FROM library_spectra_annotation')
            last_id_spectra_annotation = c.fetchone()[0]

            if last_id_spectra_annotation:
                self.current_id_spectra_annotation = last_id_spectra_annotation + 1
            else:
                self.current_id_spectra_annotation = 1"
156,"def _parse_files(self, msp_pth, chunk, db_type, celery_obj=False):
        """"""Parse the MSP files and insert into database

        Args:
            msp_pth (str): path to msp file or directory [required]
            db_type (str): The type of database to submit to (either 'sqlite', 'mysql' or 'django_mysql') [required]
            chunk (int): Chunks of spectra to parse data (useful to control memory usage) [required]
            celery_obj (boolean): If using Django a Celery task object can be used to keep track on ongoing tasks
                              [default False]
        """"""

        if os.path.isdir(msp_pth):
            c = 0
            for folder, subs, files in sorted(os.walk(msp_pth)):
                for msp_file in sorted(files):
                    msp_file_pth = os.path.join(folder, msp_file)
                    if os.path.isdir(msp_file_pth) or not msp_file_pth.lower().endswith(('txt', 'msp')):
                        continue
                    print('MSP FILE PATH', msp_file_pth)

                    self.num_lines = line_count(msp_file_pth)
                    # each file is processed separately but we want to still process in chunks so we save the number
                    # of spectra currently being processed with the c variable
                    with open(msp_file_pth, ""r"") as f:
                        c = self._parse_lines(f, chunk, db_type, celery_obj, c)
        else:
            self.num_lines = line_count(msp_pth)
            with open(msp_pth, ""r"") as f:
                self._parse_lines(f, chunk, db_type, celery_obj)

        self.insert_data(remove_data=True, db_type=db_type)"
157,"def _parse_lines(self, f, chunk, db_type, celery_obj=False, c=0):
        """"""Parse the MSP files and insert into database

        Args:
            f (file object): the opened file object
            db_type (str): The type of database to submit to (either 'sqlite', 'mysql' or 'django_mysql') [required]
            chunk (int): Chunks of spectra to parse data (useful to control memory usage) [required]
            celery_obj (boolean): If using Django a Celery task object can be used to keep track on ongoing tasks
                              [default False]
            c (int): Number of spectra currently processed (will reset to 0 after that chunk of spectra has been
                     inserted into the database
        """"""
        old = 0

        for i, line in enumerate(f):

            line = line.rstrip()

            if i == 0:
                old = self.current_id_meta

            self._update_libdata(line)

            if self.current_id_meta > old:
                old = self.current_id_meta
                c += 1

            if c > chunk:

                if celery_obj:
                    celery_obj.update_state(state='current spectra {}'.format(str(i)),
                                            meta={'current': i, 'total': self.num_lines})
                print(self.current_id_meta)
                self.insert_data(remove_data=True, db_type=db_type)
                self.update_source = False
                c = 0
        return c"
158,"def _update_libdata(self, line):
        """"""Update the library meta data from the current line being parsed

        Args:
            line (str): The current line of the of the file being parsed
        """"""
        ####################################################
        # parse MONA Comments line
        ####################################################
        # The mona msp files contain a ""comments"" line that contains lots of other information normally separated
        # into by """"
        if re.match('^Comment.*$', line, re.IGNORECASE):
            comments = re.findall('""([^""]*)""', line)
            for c in comments:
                self._parse_meta_info(c)
                self._parse_compound_info(c)

        ####################################################
        # parse meta and compound info lines
        ####################################################
        # check the current line for both general meta data
        # and compound information
        self._parse_meta_info(line)
        self._parse_compound_info(line)

        ####################################################
        # End of meta data
        ####################################################
        # Most MSP files have the a standard line of text before the spectra information begins. Here we check
        # for this line and store the relevant details for the compound and meta information to be ready for insertion
        # into the database
        if self.collect_meta and (re.match('^Num Peaks(.*)$', line, re.IGNORECASE) or re.match('^PK\$PEAK:(.*)', line,
                re.IGNORECASE) or re.match('^PK\$ANNOTATION(.*)', line, re.IGNORECASE)):

            self._store_compound_info()

            self._store_meta_info()

            # Reset the temp meta and compound information
            self.meta_info = get_blank_dict(self.meta_regex)
            self.compound_info = get_blank_dict(self.compound_regex)
            self.other_names = []
            self.collect_meta = False

        # ignore additional information in the 3rd column if using the MassBank spectra schema
        if re.match('^PK\$PEAK: m/z int\. rel\.int\.$', line, re.IGNORECASE):
            self.ignore_additional_spectra_info = True

        # Check if annnotation or spectra is to be in the next lines to be parsed
        if re.match('^Num Peaks(.*)$', line, re.IGNORECASE) or re.match('^PK\$PEAK:(.*)', line, re.IGNORECASE):
            self.start_spectra = True
            return
        elif re.match('^PK\$ANNOTATION(.*)', line, re.IGNORECASE):
            self.start_spectra_annotation = True

            match = re.match('^PK\$ANNOTATION:(.*)', line, re.IGNORECASE)
            columns = match.group(1)
            cl = columns.split()

            self.spectra_annotation_indexes = {i: cl.index(i) for i in cl}
            return

        ####################################################
        # Process annotation details
        ####################################################
        # e.g. molecular formula for each peak in the spectra
        if self.start_spectra_annotation:
            self._parse_spectra_annotation(line)

        ####################################################
        # Process spectra
        ####################################################
        if self.start_spectra:
            self._parse_spectra(line)"
159,"def get_compound_ids(self):
        """"""Extract the current compound ids in the database. Updates the self.compound_ids list
        """"""
        cursor = self.conn.cursor()
        cursor.execute('SELECT inchikey_id FROM metab_compound')
        self.conn.commit()
        for row in cursor:
            if not row[0] in self.compound_ids:
                self.compound_ids.append(row[0])"
160,"def _store_compound_info(self):
        """"""Update the compound_info dictionary with the current chunk of compound details

        Note that we use the inchikey as unique identifier. If we can't find an appropiate inchikey we just use
        a random string (uuid4) suffixed with UNKNOWN
        """"""
        other_name_l = [name for name in self.other_names if name != self.compound_info['name']]
        self.compound_info['other_names'] = ' <#> '.join(other_name_l)

        if not self.compound_info['inchikey_id']:
            self._set_inchi_pcc(self.compound_info['pubchem_id'], 'cid', 0)

        if not self.compound_info['inchikey_id']:
            self._set_inchi_pcc(self.compound_info['smiles'], 'smiles', 0)

        if not self.compound_info['inchikey_id']:
            self._set_inchi_pcc(self.compound_info['name'], 'name', 0)

        if not self.compound_info['inchikey_id']:
            print('WARNING, cant get inchi key for ', self.compound_info)
            print(self.meta_info)
            print('#########################')
            self.compound_info['inchikey_id'] = 'UNKNOWN_' + str(uuid.uuid4())

        if not self.compound_info['pubchem_id'] and self.compound_info['inchikey_id']:
            self._set_inchi_pcc(self.compound_info['inchikey_id'], 'inchikey', 0)

        if not self.compound_info['name']:
            self.compound_info['name'] = 'unknown name'

        if not self.compound_info['inchikey_id'] in self.compound_ids:
            self.compound_info_all.append(tuple(self.compound_info.values()) + (
                str(datetime.datetime.now()),
                str(datetime.datetime.now()),
            ))
            self.compound_ids.append(self.compound_info['inchikey_id'])"
161,"def _store_meta_info(self):
        """"""Update the meta dictionary with the current chunk of meta data details
        """"""
        # In the mass bank msp files, sometimes the precursor_mz is missing but we have the neutral mass and
        # the precursor_type (e.g. adduct) so we can calculate the precursor_mz
        if not self.meta_info['precursor_mz'] and self.meta_info['precursor_type'] and \
                self.compound_info['exact_mass']:
            self.meta_info['precursor_mz'] = get_precursor_mz(float(self.compound_info['exact_mass']),
                                                              self.meta_info['precursor_type'])

        if not self.meta_info['polarity']:
            # have to do special check for polarity (as sometimes gets missed)
            m = re.search('^\[.*\](\-|\+)', self.meta_info['precursor_type'], re.IGNORECASE)
            if m:
                polarity = m.group(1).strip()
                if polarity == '+':
                    self.meta_info['polarity'] = 'positive'
                elif polarity == '-':
                    self.meta_info['polarity'] = 'negative'

        if not self.meta_info['accession']:
            self.meta_info['accession'] = 'unknown accession'

        self.meta_info_all.append(
            (str(self.current_id_meta),) +
            tuple(self.meta_info.values()) +
            (str(self.current_id_origin), self.compound_info['inchikey_id'],)
        )"
162,"def _parse_spectra_annotation(self, line):
        """"""Parse and store the spectral annotation details
        """"""
        if re.match('^PK\$NUM_PEAK(.*)', line, re.IGNORECASE):
            self.start_spectra_annotation = False
            return

        saplist = line.split()

        sarow = (
            self.current_id_spectra_annotation,
            float(saplist[self.spectra_annotation_indexes['m/z']]) if 'm/z' in self.spectra_annotation_indexes else None,
            saplist[self.spectra_annotation_indexes[
                'tentative_formula']] if 'tentative_formula' in self.spectra_annotation_indexes else None,
            float(saplist[self.spectra_annotation_indexes[
                'mass_error(ppm)']]) if 'mass_error(ppm)' in self.spectra_annotation_indexes else None,
            self.current_id_meta)

        self.spectra_annotation_all.append(sarow)

        self.current_id_spectra_annotation += 1"
163,"def _parse_spectra(self, line):
        """"""Parse and store the spectral details
        """"""
        if line in ['\n', '\r\n', '//\n', '//\r\n', '', '//']:
            self.start_spectra = False
            self.current_id_meta += 1
            self.collect_meta = True
            return

        splist = line.split()

        if len(splist) > 2 and not self.ignore_additional_spectra_info:
            additional_info = ''.join(map(str, splist[2:len(splist)]))
        else:
            additional_info = ''

        srow = (
            self.current_id_spectra, float(splist[0]), float(splist[1]), additional_info,
            self.current_id_meta)

        self.spectra_all.append(srow)

        self.current_id_spectra += 1"
164,"def _set_inchi_pcc(self, in_str, pcp_type, elem):
        """"""Check pubchem compounds via API for both an inchikey and any available compound details
        """"""
        if not in_str:
            return 0

        try:
            pccs = pcp.get_compounds(in_str, pcp_type)
        except pcp.BadRequestError as e:
            print(e)
            return 0
        except pcp.TimeoutError as e:
            print(e)
            return 0
        except pcp.ServerError as e:
            print(e)
            return 0
        except URLError as e:
            print(e)
            return 0
        except BadStatusLine as e:
            print(e)
            return 0

        if pccs:
            pcc = pccs[elem]
            self.compound_info['inchikey_id'] = pcc.inchikey
            self.compound_info['pubchem_id'] = pcc.cid
            self.compound_info['molecular_formula'] = pcc.molecular_formula
            self.compound_info['molecular_weight'] = pcc.molecular_weight
            self.compound_info['exact_mass'] = pcc.exact_mass
            self.compound_info['smiles'] = pcc.canonical_smiles

            if len(pccs) > 1:
                print('WARNING, multiple compounds for ', self.compound_info)"
165,"def _get_other_names(self, line):
        """"""Parse and extract any other names that might be recorded for the compound

        Args:
             line (str): line of the msp file
        """"""
        m = re.search(self.compound_regex['other_names'][0], line, re.IGNORECASE)
        if m:
            self.other_names.append(m.group(1).strip())"
166,"def _parse_meta_info(self, line):
        """"""Parse and extract all meta data by looping through the dictionary of meta_info regexs

        updates self.meta_info

        Args:
             line (str): line of the msp file
        """"""
        if self.mslevel:
            self.meta_info['ms_level'] = self.mslevel

        if self.polarity:
            self.meta_info['polarity'] = self.polarity

        for k, regexes in six.iteritems(self.meta_regex):
            for reg in regexes:

                m = re.search(reg, line, re.IGNORECASE)

                if m:
                    self.meta_info[k] = m.group(1).strip()"
167,"def _parse_compound_info(self, line):
        """"""Parse and extract all compound data by looping through the dictionary of compound_info regexs

        updates self.compound_info

        Args:
             line (str): line of the msp file

        """"""
        for k, regexes in six.iteritems(self.compound_regex):
            for reg in regexes:
                if self.compound_info[k]:
                    continue
                m = re.search(reg, line, re.IGNORECASE)
                if m:
                    self.compound_info[k] = m.group(1).strip()

        self._get_other_names(line)"
168,"def insert_data(self, remove_data=False, db_type='sqlite'):
        """"""Insert data stored in the current chunk of parsing into the selected database


        Args:
             remove_data (boolean): Remove the data stored within the LibraryData object for the current chunk of
                                    processing
             db_type (str): The type of database to submit to
                            either 'sqlite', 'mysql' or 'django_mysql' [default sqlite]
        """"""
        if self.update_source:
            # print ""insert ref id""
            import msp2db
            self.c.execute(
                ""INSERT INTO library_spectra_source (id, name, parsing_software) VALUES""
                "" ({a}, '{b}', 'msp2db-v{c}')"".format(a=self.current_id_origin, b=self.source, c=msp2db.__version__))
            self.conn.commit()

        if self.compound_info_all:
            self.compound_info_all = _make_sql_compatible(self.compound_info_all)

            cn = ', '.join(self.compound_info.keys()) + ',created_at,updated_at'

            insert_query_m(self.compound_info_all, columns=cn, conn=self.conn, table='metab_compound',
                           db_type=db_type)

        self.meta_info_all = _make_sql_compatible(self.meta_info_all)

        cn = 'id,' + ', '.join(self.meta_info.keys()) + ',library_spectra_source_id, inchikey_id'

        insert_query_m(self.meta_info_all, columns=cn, conn=self.conn, table='library_spectra_meta',
                       db_type=db_type)


        cn = ""id, mz, i, other, library_spectra_meta_id""
        insert_query_m(self.spectra_all, columns=cn, conn=self.conn, table='library_spectra', db_type=db_type)
        if self.spectra_annotation_all:
            cn = ""id, mz, tentative_formula, mass_error, library_spectra_meta_id""
            insert_query_m(self.spectra_annotation_all, columns=cn, conn=self.conn,
                           table='library_spectra_annotation', db_type=db_type)


        # self.conn.close()
        if remove_data:
            self.meta_info_all = []
            self.spectra_all = []
            self.spectra_annotation_all = []
            self.compound_info_all = []
            self._get_current_ids(source=False)"
169,"def line(line_def, **kwargs):
    """"""Highlights a character in the line""""""
    def replace(s):
        return ""(%s)"" % ansi.aformat(s.group()[1:], attrs=[""bold"", ])
    return ansi.aformat(
        re.sub('@.?', replace, line_def),
        **kwargs)"
170,"def try_and_error(*funcs):
    """"""Apply multiple validation functions

    Parameters
    ----------
    ``*funcs``
        Validation functions to test

    Returns
    -------
    function""""""
    def validate(value):
        exc = None
        for func in funcs:
            try:
                return func(value)
            except (ValueError, TypeError) as e:
                exc = e
        raise exc
    return validate"
171,"def validate_text(value):
    """"""Validate a text formatoption

    Parameters
    ----------
    value: see :attr:`psyplot.plotter.labelplotter.text`

    Raises
    ------
    ValueError""""""
    possible_transform = ['axes', 'fig', 'data']
    validate_transform = ValidateInStrings('transform', possible_transform,
                                           True)
    tests = [validate_float, validate_float, validate_str,
             validate_transform, dict]
    if isinstance(value, six.string_types):
        xpos, ypos = rcParams['texts.default_position']
        return [(xpos, ypos, value, 'axes', {'ha': 'right'})]
    elif isinstance(value, tuple):
        value = [value]
    try:
        value = list(value)[:]
    except TypeError:
        raise ValueError(""Value must be string or list of tuples!"")
    for i, val in enumerate(value):
        try:
            val = tuple(val)
        except TypeError:
            raise ValueError(
                ""Text must be an iterable of the form ""
                ""(x, y, s[, trans, params])!"")
        if len(val) < 3:
            raise ValueError(
                ""Text tuple must at least be like [x, y, s], with floats x, ""
                ""y and string s!"")
        elif len(val) == 3 or isinstance(val[3], dict):
            val = list(val)
            val.insert(3, 'data')
            if len(val) == 4:
                val += [{}]
            val = tuple(val)
        if len(val) > 5:
            raise ValueError(
                ""Text tuple must not be longer then length 5. It can be ""
                ""like (x, y, s[, trans, params])!"")
        value[i] = (validate(x) for validate, x in zip(tests, val))
    return value"
172,"def validate_none(b):
    """"""Validate that None is given

    Parameters
    ----------
    b: {None, 'none'}
        None or string (the case is ignored)

    Returns
    -------
    None

    Raises
    ------
    ValueError""""""
    if isinstance(b, six.string_types):
        b = b.lower()
    if b is None or b == 'none':
        return None
    else:
        raise ValueError('Could not convert ""%s"" to None' % b)"
173,"def validate_axiscolor(value):
    """"""Validate a dictionary containing axiscolor definitions

    Parameters
    ----------
    value: dict
        see :attr:`psyplot.plotter.baseplotter.axiscolor`

    Returns
    -------
    dict

    Raises
    ------
    ValueError""""""
    validate = try_and_error(validate_none, validate_color)
    possible_keys = {'right', 'left', 'top', 'bottom'}
    try:
        value = dict(value)
        false_keys = set(value) - possible_keys
        if false_keys:
            raise ValueError(""Wrong keys (%s)!"" % (', '.join(false_keys)))
        for key, val in value.items():
            value[key] = validate(val)
    except:
        value = dict(zip(possible_keys, repeat(validate(value))))
    return value"
174,"def validate_cbarpos(value):
    """"""Validate a colorbar position

    Parameters
    ----------
    value: bool or str
        A string can be a combination of 'sh|sv|fl|fr|ft|fb|b|r'

    Returns
    -------
    list
        list of strings with possible colorbar positions

    Raises
    ------
    ValueError""""""
    patt = 'sh|sv|fl|fr|ft|fb|b|r'
    if value is True:
        value = {'b'}
    elif not value:
        value = set()
    elif isinstance(value, six.string_types):
        for s in re.finditer('[^%s]+' % patt, value):
            warn(""Unknown colorbar position %s!"" % s.group(), RuntimeWarning)
        value = set(re.findall(patt, value))
    else:
        value = validate_stringset(value)
        for s in (s for s in value
                  if not re.match(patt, s)):
            warn(""Unknown colorbar position %s!"" % s)
            value.remove(s)
    return value"
175,"def validate_cmap(val):
    """"""Validate a colormap

    Parameters
    ----------
    val: str or :class:`mpl.colors.Colormap`

    Returns
    -------
    str or :class:`mpl.colors.Colormap`

    Raises
    ------
    ValueError""""""
    from matplotlib.colors import Colormap
    try:
        return validate_str(val)
    except ValueError:
        if not isinstance(val, Colormap):
            raise ValueError(
                ""Could not find a valid colormap!"")
        return val"
176,"def validate_cmaps(cmaps):
    """"""Validate a dictionary of color lists

    Parameters
    ----------
    cmaps: dict
        a mapping from a colormap name to a list of colors

    Raises
    ------
    ValueError
        If one of the values in `cmaps` is not a color list

    Notes
    -----
    For all items (listname, list) in `cmaps`, the reversed list is
    automatically inserted with the ``listname + '_r'`` key.""""""
    cmaps = {validate_str(key): validate_colorlist(val) for key, val in cmaps}
    for key, val in six.iteritems(cmaps):
        cmaps.setdefault(key + '_r', val[::-1])
    return cmaps"
177,"def validate_lineplot(value):
    """"""Validate the value for the LinePlotter.plot formatoption

    Parameters
    ----------
    value: None, str or list with mixture of both
        The value to validate""""""
    if value is None:
        return value
    elif isinstance(value, six.string_types):
        return six.text_type(value)
    else:
        value = list(value)
        for i, v in enumerate(value):
            if v is None:
                pass
            elif isinstance(v, six.string_types):
                value[i] = six.text_type(v)
            else:
                raise ValueError('Expected None or string, found %s' % (v, ))
    return value"
178,"def validate_err_calc(val):
    """"""Validation function for the
    :attr:`psy_simple.plotter.FldmeanPlotter.err_calc` formatoption""""""
    try:
        val = validate_float(val)
    except (ValueError, TypeError):
        pass
    else:
        if val <= 100 and val >= 0:
            return val
        raise ValueError(""Percentiles for the error calculation must lie ""
                         ""between 0 and 100, not %s"" % val)
    try:
        val = ValidateList(float, 2)(val)
    except (ValueError, TypeError):
        pass
    else:
        if all((v <= 100 and v >= 0) for v in val):
            return val
        raise ValueError(""Percentiles for the error calculation must lie ""
                         ""between 0 and 100, not %s"" % val)
    try:
        val = validate_str(val)
    except ValueError:
        pass
    else:
        if 'std' not in val:
            raise ValueError(
                'A string for the error calculation must contain std!')
    return val"
179,"def visit_GpxModel(self, gpx_model, *args, **kwargs):
        """"""Render a GPXModel as a single JSON structure.""""""
        result = OrderedDict()

        put_scalar = lambda name, json_name=None: self.optional_attribute_scalar(result, gpx_model, name, json_name)
        put_list = lambda name, json_name=None: self.optional_attribute_list(result, gpx_model, name, json_name)

        put_scalar('creator')
        put_scalar('metadata')
        put_list('waypoints')
        put_list('routes')
        put_list('tracks')
        put_list('extensions')

        return result"
180,"def visit_Metadata(self, metadata, *args, **kwargs):
        """"""Render GPX Metadata as a single JSON structure.""""""
        result = OrderedDict()
        put_scalar = lambda name, json_name=None: self.optional_attribute_scalar(result, metadata, name, json_name)
        put_list = lambda name, json_name=None: self.optional_attribute_list(result, metadata, name, json_name)

        put_scalar('name')
        put_scalar('description')
        put_scalar('author')
        put_scalar('copyright')
        put_list('links')
        put_scalar('time')
        put_scalar('keywords')
        put_scalar('bounds')
        put_list('extensions')

        return result"
181,"def swap_default(mode, equation, symbol_names, default, **kwargs):
    '''
    Given a `sympy` equation or equality, along with a list of symbol names,
    substitute the specified default value for each symbol for which a value is
    not provided through a keyword argument.

    For example, consider the following equality:

    >>> sp.pprint(H)
    V₂   Z₂
    ── = ──
    V₁   Z₁

    Let us substitute a default value of 1 for terms Z1 and Z2:

    >>> sp.pprint(subs_default(H, ['Z1', 'Z2'], 1))
    V₂
    ── = 1
    V₁

    Now, let us specify a default value of 1 for terms Z1 and Z2, but provide
    an overriding value for Z1:

    >>> sp.pprint(subs_default(H, ['Z1', 'Z2'], 1, Z1=4))
    V₂
    ── = 1/4
    V₁

    Note that keyword arguments for terms not specified in the list of symbol
    names are ignored:

    >>> sp.pprint(subs_default(H, ['Z1', 'Z2'], 1, Z1=4, Q=7))
    V₂
    ── = 1/4
    V₁
    '''
    if mode == 'subs':
        swap_f = _subs
        default_swap_f = _subs
    elif mode == 'limit':
        swap_f = _limit
        default_swap_f = _subs
    elif mode == 'limit_default':
        swap_f = _subs
        default_swap_f = _limit
    else:
        raise ValueError('''Unsupported mode.  `mode` must be one of: '''
                         '''('subs', 'limit').''')

    result = equation
    for s in symbol_names:
        if s in kwargs:
            if isinstance(kwargs[s], Iterable):
                continue
            else:
                result = swap_f(result, s, kwargs[s])
        else:
            result = default_swap_f(result, s, default)
    return result"
182,"def z_transfer_functions():
    r'''
    Return a symbolic equality representation of the transfer function of RMS
    voltage measured by either control board analog feedback circuits.

    According to the figure below, the transfer function describes the
    following relationship::

          # Hardware V1 #                        # Hardware V2 #

            V₂      V₁                               V₂   Z₁
            ── = ───────                             ── = ──
            Z₂   Z₁ + Z₂                             V₁   Z₂

    where $V_{1}$ denotes the high-voltage actuation signal from the amplifier
    output and $V_{2}$ denotes the signal sufficiently attenuated to fall
    within the measurable input range of the analog-to-digital converter
    *(approx. 5V)*.  The feedback circuits for control board **hardware version
    1** and **hardware version 2** are shown below.

    .. code-block:: none

          # Hardware V1 #                        # Hardware V2 #

          V_1 @ frequency                        V_1 @ frequency
              ┯                                      ┯
            ┌─┴─┐                                  ┌─┴─┐    ┌───┐
            │Z_1│                                  │Z_1│  ┌─┤Z_2├─┐
            └─┬─┘                                  └─┬─┘  │ └───┘ │
              ├───⊸ V_2                              │    │  │╲   ├───⊸ V_2
            ┌─┴─┐                                    └────┴──│-╲__│
            │Z_2│                                         ┌──│+╱
            └─┬─┘                                         │  │╱
             ═╧═                                          │
              ¯                                          ═╧═
                                                          ¯

    Notes
    -----

     - The symbolic equality can be solved for any symbol, _e.g.,_ $V_{1}$ or
       $V_{2}$.
     - A symbolically solved representation can be converted to a Python function
       using `sympy.utilities.lambdify.lambdify`_, to compute results for
       specific values of the remaining parameters.

    .. _`sympy.utilities.lambdify.lambdify`: http://docs.sympy.org/dev/modules/utilities/lambdify.html
    '''
    # Define transfer function as a symbolic equality using SymPy.
    V1, V2, Z1, Z2 = sp.symbols('V1 V2 Z1 Z2')
    xfer_funcs = pd.Series([sp.Eq(V2 / Z2, V1 / (Z1 + Z2)),
                            sp.Eq(V2 / V1, Z2 / Z1)],
                           # Index by hardware version.
                           index=[1, 2])
    xfer_funcs.index.name = 'Hardware version'
    return xfer_funcs"
183,"def has_option(section, name):
    """"""
    Wrapper around ConfigParser's ``has_option`` method.
    """"""
    cfg = ConfigParser.SafeConfigParser({""working_dir"": ""/tmp"", ""debug"": ""0""})
    cfg.read(CONFIG_LOCATIONS)
    return cfg.has_option(section, name)"
184,"def get(section, name):
    """"""
    Wrapper around ConfigParser's ``get`` method.
    """"""
    cfg = ConfigParser.SafeConfigParser({""working_dir"": ""/tmp"", ""debug"": ""0""})
    cfg.read(CONFIG_LOCATIONS)
    val = cfg.get(section, name)
    return val.strip(""'"").strip('""')"
185,"def run(**options):
    """"""
    _run_

    Run the dockerstache process to render templates
    based on the options provided

    If extend_context is passed as options it will be used to
    extend the context with the contents of the dictionary provided
    via context.update(extend_context)

    """"""
    with Dotfile(options) as conf:
        if conf['context'] is None:
            msg = ""No context file has been provided""
            LOGGER.error(msg)
            raise RuntimeError(msg)
        if not os.path.exists(conf['context_path']):
            msg = ""Context file {} not found"".format(conf['context_path'])
            LOGGER.error(msg)
            raise RuntimeError(msg)
        LOGGER.info(
            (
                ""{{dockerstache}}: In: {}\n""
                ""{{dockerstache}}: Out: {}\n""
                ""{{dockerstache}}: Context: {}\n""
                ""{{dockerstache}}: Defaults: {}\n""
            ).format(conf['input'], conf['output'], conf['context'], conf['defaults'])
        )
        context = Context(conf['context'], conf['defaults'])
        context.load()
        if 'extend_context' in options:
            LOGGER.info(""{{dockerstache}} Extended context provided"")
            context.update(options['extend_context'])

        process_templates(
            conf['input'],
            conf['output'],
            context
            )
        if conf['inclusive']:
            process_copies(
                conf['input'],
                conf['output'],
                conf['exclude']
            )
    return dict(conf)"
186,"def make_key(table_name, objid):
    """"""Create an object key for storage.""""""
    key = datastore.Key()
    path = key.path_element.add()
    path.kind = table_name
    path.name = str(objid)
    return key"
187,"def write_rec(table_name, objid, data, index_name_values):
    """"""Write (upsert) a record using a tran.""""""
    with DatastoreTransaction() as tx:
        entity = tx.get_upsert()

        entity.key.CopyFrom(make_key(table_name, objid))

        prop = entity.property.add()
        prop.name = 'id'
        prop.value.string_value = objid

        prop = entity.property.add()
        prop.name = 'value'
        prop.value.string_value = data

        for name, val in index_name_values:
            prop = entity.property.add()
            prop.name = name
            prop.value.string_value = str(val)"
188,"def extract_entity(found):
    """"""Copy found entity to a dict.""""""
    obj = dict()
    for prop in found.entity.property:
        obj[prop.name] = prop.value.string_value
    return obj"
189,"def read_rec(table_name, objid):
    """"""Generator that yields keyed recs from store.""""""
    req = datastore.LookupRequest()
    req.key.extend([make_key(table_name, objid)])

    for found in datastore.lookup(req).found:
        yield extract_entity(found)"
190,"def read_by_indexes(table_name, index_name_values=None):
    """"""Index reader.""""""
    req = datastore.RunQueryRequest()

    query = req.query
    query.kind.add().name = table_name

    if not index_name_values:
        index_name_values = []
    for name, val in index_name_values:
        queryFilter = query.filter.property_filter
        queryFilter.property.name = name
        queryFilter.operator = datastore.PropertyFilter.EQUAL
        queryFilter.value.string_value = str(val)

    loop_its = 0
    have_more = True

    while have_more:
        resp = datastore.run_query(req)

        found_something = False
        for found in resp.batch.entity_result:
            yield extract_entity(found)
            found_something = True

        if not found_something:
            # This is a guard against bugs or excessive looping - as long we
            # can keep yielding records we'll continue to execute
            loop_its += 1
            if loop_its > 5:
                raise ValueError(""Exceeded the excessive query threshold"")

        if resp.batch.more_results != datastore.QueryResultBatch.NOT_FINISHED:
            have_more = False
        else:
            have_more = True
            end_cursor = resp.batch.end_cursor
            query.start_cursor.CopyFrom(end_cursor)"
191,"def delete_table(table_name):
    """"""Mainly for testing.""""""
    to_delete = [
        make_key(table_name, rec['id'])
        for rec in read_by_indexes(table_name, [])
    ]

    with DatastoreTransaction() as tx:
        tx.get_commit_req().mutation.delete.extend(to_delete)"
192,"def get_commit_req(self):
        """"""Lazy commit request getter.""""""
        if not self.commit_req:
            self.commit_req = datastore.CommitRequest()
            self.commit_req.transaction = self.tx
        return self.commit_req"
193,"def find_one(self, cls, id):
        """"""Required functionality.""""""
        db_result = None
        for rec in read_rec(cls.get_table_name(), id):
            db_result = rec
            break  # Only read the first returned - which should be all we get
        if not db_result:
            return None

        obj = cls.from_data(db_result['value'])
        return obj"
194,"def find_all(self, cls):
        """"""Required functionality.""""""
        final_results = []
        for db_result in read_by_indexes(cls.get_table_name(), []):
            obj = cls.from_data(db_result['value'])
            final_results.append(obj)

        return final_results"
195,"def find_by_index(self, cls, index_name, value):
        """"""Required functionality.""""""
        table_name = cls.get_table_name()
        index_name_vals = [(index_name, value)]

        final_results = []
        for db_result in read_by_indexes(table_name, index_name_vals):
            obj = cls.from_data(db_result['value'])
            final_results.append(obj)

        return final_results"
196,"def save(self, obj):
        """"""Required functionality.""""""
        if not obj.id:
            obj.id = uuid()

        index_names = obj.__class__.index_names() or []
        index_dict = obj.indexes() or {}
        index_name_values = [
            (key, index_dict.get(key, ''))
            for key in index_names
        ]

        write_rec(
            obj.__class__.get_table_name(),
            obj.id,
            obj.to_data(),
            index_name_values
        )"
197,"def call(command, stdin=None, stdout=subprocess.PIPE, env=os.environ, cwd=None,
         shell=False, output_log_level=logging.INFO, sensitive_info=False):
    """""" Better, smarter call logic """"""
    if not sensitive_info:
        logger.debug(""calling command: %s"" % command)
    else:
        logger.debug(""calling command with sensitive information"")
    try:
        args = command if shell else whitespace_smart_split(command)
        kw = {}
        if not shell and not which(args[0], cwd=cwd):
            raise CommandMissingException(args[0])
        if shell:
            kw['shell'] = True
        process = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=stdout,
                                   stderr=subprocess.STDOUT, env=env, cwd=cwd,
                                   **kw)
        output = process.communicate(input=stdin)[0]
        if output is not None:
            try:
                logger.log(output_log_level, output.decode('utf-8'))
            except UnicodeDecodeError:
                pass
        return (process.returncode, output)
    except OSError:
        e = sys.exc_info()[1]
        if not sensitive_info:
            logger.exception(""Error running command: %s"" % command)
            logger.error(""Root directory: %s"" % cwd)
            if stdin:
                logger.error(""stdin: %s"" % stdin)
        raise e"
198,"def whitespace_smart_split(command):
    """"""
    Split a command by whitespace, taking care to not split on
    whitespace within quotes.

    >>> whitespace_smart_split(""test this \\\""in here\\\"" again"")
    ['test', 'this', '""in here""', 'again']

    """"""
    return_array = []
    s = """"
    in_double_quotes = False
    escape = False
    for c in command:
        if c == '""':
            if in_double_quotes:
                if escape:
                    s += c
                    escape = False
                else:
                    s += c
                    in_double_quotes = False
            else:
                in_double_quotes = True
                s += c
        else:
            if in_double_quotes:
                if c == '\\':
                    escape = True
                    s += c
                else:
                    escape = False
                    s += c
            else:
                if c == ' ':
                    return_array.append(s)
                    s = """"
                else:
                    s += c
    if s != """":
        return_array.append(s)
    return return_array"
199,"def skip(stackframe=1):
  """"""
  Must be called from within `__enter__()`. Performs some magic to have a
  #ContextSkipped exception be raised the moment the with context is entered.
  The #ContextSkipped must then be handled in `__exit__()` to suppress the
  propagation of the exception.

  > Important: This function does not raise an exception by itself, thus
  > the `__enter__()` method will continue to execute after using this function.
  """"""

  def trace(frame, event, args):
    raise ContextSkipped

  sys.settrace(lambda *args, **kwargs: None)
  frame = sys._getframe(stackframe + 1)
  frame.f_trace = trace"
200,"def sync(self):
        """"""
        execute the steps required to have the
        feature end with the desired state.
        """"""
        phase = _get_phase(self._formula_instance)
        self.logger.info(""%s %s..."" % (phase.verb.capitalize(), self.feature_name))
        message = ""...finished %s %s."" % (phase.verb, self.feature_name)
        result = getattr(self, phase.name)()
        if result or phase in (PHASE.INSTALL, PHASE.REMOVE):
            self.logger.info(message)
        else:
            self.logger.debug(message)
        return result"
201,"def linear_insert(self, item, priority):
    """"""Linear search. Performance is O(n^2).""""""

    with self.lock:
        self_data = self.data
        rotate = self_data.rotate
        maxlen = self._maxlen
        length = len(self_data)
        count = length

        # in practice, this is better than doing a rotate(-1) every
        # loop and getting self.data[0] each time only because deque
        # implements a very efficient iterator in C
        for i in self_data:
            if priority > i[1]:
                break
            count -= 1

        rotate(-count)
        self_data.appendleft((item, priority))
        rotate(length-count)

        try:
            self.items[item] += 1
        except TypeError:
            self.items[repr(item)] += 1

        if maxlen is not None and maxlen < len(self_data):
                self._poplast()"
202,"def binary_insert(self, item, priority):
    """"""Traditional binary search. Performance: O(n log n)""""""

    with self.lock:
        self_data = self.data
        rotate = self_data.rotate
        maxlen = self._maxlen
        length = len(self_data)

        index = 0
        min = 0
        max = length - 1

        while max - min > 10:

            mid = (min + max) // 2

            # If index in 1st half of list
            if priority > self_data[mid][1]:
                max = mid - 1

            # If index in 2nd half of list
            else:
                min = mid + 1

        for i in range(min, max + 1):
            if priority > self_data[i][1]:
                index = i
                break
            elif i == max:
                index = max + 1

        shift = length - index

        # Never shift more than half length of depq
        if shift > length // 2:
            shift = length % shift
            rotate(-shift)
            self_data.appendleft((item, priority))
            rotate(shift)
        else:
            rotate(shift)
            self_data.append((item, priority))
            rotate(-shift)

        try:
            self.items[item] += 1
        except TypeError:
            self.items[repr(item)] += 1

        if maxlen is not None and maxlen < len(self_data):
                self._poplast()"
203,"def isloaded(self, name):
        """"""Checks if given hook module has been loaded

        Args:
            name (str): The name of the module to check

        Returns:
            bool.  The return code::

                True -- Loaded
                False -- Not Loaded
        """"""
        if name is None:
            return True

        if isinstance(name, str):
            return (name in [x.__module__ for x in self])

        if isinstance(name, Iterable):
            return set(name).issubset([x.__module__ for x in self])

        return False"
204,"def hook(self, function, dependencies=None):
        """"""Tries to load a hook

        Args:
            function (func): Function that will be called when the event is called

        Kwargs:
            dependencies (str): String or Iterable with modules whose hooks should be called before this one

        Raises:
            :class:TypeError

        Note that the dependencies are module-wide, that means that if
        `parent.foo` and `parent.bar` are both subscribed to `example` event
        and `child` enumerates `parent` as dependcy, **both** `foo` and `bar`
        must be called in order for the dependcy to get resolved.
        """"""
        if not isinstance(dependencies, (Iterable, type(None), str)):
            raise TypeError(""Invalid list of dependencies provided!"")

        # Tag the function with its dependencies
        if not hasattr(function, ""__deps__""):
            function.__deps__ = dependencies

        # If a module is loaded before all its dependencies are loaded, put
        # it in _later list and don't load yet
        if self.isloaded(function.__deps__):
            self.append(function)
        else:
            self._later.append(function)

        # After each module load, retry to resolve dependencies
        for ext in self._later:
            if self.isloaded(ext.__deps__):
                self._later.remove(ext)
                self.hook(ext)"
205,"def parse_from_json(json_str):
    """"""
    Given a Unified Uploader message, parse the contents and return a
    MarketOrderList or MarketHistoryList instance.

    :param str json_str: A Unified Uploader message as a JSON string.
    :rtype: MarketOrderList or MarketHistoryList
    :raises: MalformedUploadError when invalid JSON is passed in.
    """"""
    try:
        message_dict = json.loads(json_str)
    except ValueError:
        raise ParseError(""Mal-formed JSON input."")

    upload_keys = message_dict.get('uploadKeys', False)
    if upload_keys is False:
        raise ParseError(
            ""uploadKeys does not exist. At minimum, an empty array is required.""
        )
    elif not isinstance(upload_keys, list):
        raise ParseError(
            ""uploadKeys must be an array object.""
        )

    upload_type = message_dict['resultType']

    try:
        if upload_type == 'orders':
            return orders.parse_from_dict(message_dict)
        elif upload_type == 'history':
            return history.parse_from_dict(message_dict)
        else:
            raise ParseError(
                'Unified message has unknown upload_type: %s' % upload_type)
    except TypeError as exc:
        # MarketOrder and HistoryEntry both raise TypeError exceptions if
        # invalid input is encountered.
        raise ParseError(exc.message)"
206,"def encode_to_json(order_or_history):
    """"""
    Given an order or history entry, encode it to JSON and return.

    :type order_or_history: MarketOrderList or MarketHistoryList
    :param order_or_history: A MarketOrderList or MarketHistoryList instance to
        encode to JSON.
    :rtype: str
    :return: The encoded JSON string.
    """"""
    if isinstance(order_or_history, MarketOrderList):
        return orders.encode_to_json(order_or_history)
    elif isinstance(order_or_history, MarketHistoryList):
        return history.encode_to_json(order_or_history)
    else:
        raise Exception(""Must be one of MarketOrderList or MarketHistoryList."")"
207,"def event_subscriber(event):
    """"""
    Register a method, which gets called when this event triggers.
    :param event: the event to register the decorator method on.
    """"""
    def wrapper(method):
        Registry.register_event(event.name, event, method)
    return wrapper"
208,"def dispatch_event(event, subject='id'):
    """"""
    Dispatch an event when the decorated method is called.
    :param event: the event class to instantiate and dispatch.
    :param subject_property: the property name to get the subject.
    """"""
    def wrapper(method):
        def inner_wrapper(*args, **kwargs):
            resource = method(*args, **kwargs)
            if isinstance(resource, dict):
                subject_ = resource.get(subject)
                data = resource
            else:
                subject_ = getattr(resource, subject)
                data = resource.__dict__
            event(subject_, data).dispatch()
            return resource
        return inner_wrapper
    return wrapper"
209,"def add(self, classifier, threshold, begin=None, end=None):
    """"""Adds a new strong classifier with the given threshold to the cascade.

    **Parameters:**

    classifier : :py:class:`bob.learn.boosting.BoostedMachine`
      A strong classifier to add

    ``threshold`` : float
      The classification threshold for this cascade step

    ``begin``, ``end`` : int or ``None``
      If specified, only the weak machines with the indices ``range(begin,end)`` will be added.
    """"""
    boosted_machine = bob.learn.boosting.BoostedMachine()
    if begin is None: begin = 0
    if end is None: end = len(classifier.weak_machines)
    for i in range(begin, end):
      boosted_machine.add_weak_machine(classifier.weak_machines[i], classifier.weights[i])
    self.cascade.append(boosted_machine)
    self.thresholds.append(threshold)
    self._indices()"
210,"def create_from_boosted_machine(self, boosted_machine, classifiers_per_round, classification_thresholds=-5.):
    """"""Creates this cascade from the given boosted machine, by simply splitting off strong classifiers that have classifiers_per_round weak classifiers.

    **Parameters:**

    ``boosted_machine`` : :py:class:`bob.learn.boosting.BoostedMachine`
      The strong classifier to split into a regular cascade.

    ``classifiers_per_round`` : int
      The number of classifiers that each cascade step should contain.

    ``classification_threshold`` : float
      A single threshold that will be applied in all rounds of the cascade.
    """"""
    indices = list(range(0, len(boosted_machine.weak_machines), classifiers_per_round))
    if indices[-1] != len(boosted_machine.weak_machines): indices.append(len(boosted_machine.weak_machines))
    self.cascade = []
    self.indices = []
    for i in range(len(indices)-1):
      machine = bob.learn.boosting.BoostedMachine()
      for index in range(indices[i], indices[i+1]):
        machine.add_weak_machine(boosted_machine.weak_machines[index], boosted_machine.weights[index, 0])
      self.cascade.append(machine)
    if isinstance(classification_thresholds, (int, float)):
      self.thresholds = [classification_thresholds] * len(self.cascade)
    else:
      self.thresholds = classification_thresholds"
211,"def generate_boosted_machine(self):
    """"""generate_boosted_machine() -> strong

    Creates a single strong classifier from this cascade by concatenating all strong classifiers.

    **Returns:**

    ``strong`` : :py:class:`bob.learn.boosting.BoostedMachine`
      The strong classifier as a combination of all classifiers in this cascade.
    """"""
    strong = bob.learn.boosting.BoostedMachine()
    for machine, index in zip(self.cascade, self.indices):
      weak = machine.weak_machines
      weights = machine.weights
      for i in range(len(weak)):
        strong.add_weak_machine(weak[i], weights[i])

    return strong"
212,"def save(self, hdf5):
    """"""Saves this cascade into the given HDF5 file.

    **Parameters:**

    ``hdf5`` : :py:class:`bob.io.base.HDF5File`
      An HDF5 file open for writing
    """"""
    # write the cascade to file
    hdf5.set(""Thresholds"", self.thresholds)
    for i in range(len(self.cascade)):
      hdf5.create_group(""Classifier_%d"" % (i+1))
      hdf5.cd(""Classifier_%d"" % (i+1))
      self.cascade[i].save(hdf5)
      hdf5.cd("".."")
    hdf5.create_group(""FeatureExtractor"")
    hdf5.cd(""FeatureExtractor"")
    self.extractor.save(hdf5)
    hdf5.cd("".."")"
213,"def load(self, hdf5):
    """"""Loads this cascade from the given HDF5 file.

    **Parameters:**

    ``hdf5`` : :py:class:`bob.io.base.HDF5File`
      An HDF5 file open for reading
    """"""
    # write the cascade to file
    self.thresholds = hdf5.read(""Thresholds"")
    self.cascade = []
    for i in range(len(self.thresholds)):
      hdf5.cd(""Classifier_%d"" % (i+1))
      self.cascade.append(bob.learn.boosting.BoostedMachine(hdf5))
      hdf5.cd("".."")
    hdf5.cd(""FeatureExtractor"")
    self.extractor = FeatureExtractor(hdf5)
    hdf5.cd("".."")
    self._indices()"
214,"def check(ctx, repository, config):
    """"""Check commits.""""""
    ctx.obj = Repo(repository=repository, config=config)"
215,"def message(obj, commit='HEAD', skip_merge_commits=False):
    """"""Check the messages of the commits.""""""
    from ..kwalitee import check_message
    options = obj.options
    repository = obj.repository

    if options.get('colors') is not False:
        colorama.init(autoreset=True)
        reset = colorama.Style.RESET_ALL
        yellow = colorama.Fore.YELLOW
        green = colorama.Fore.GREEN
        red = colorama.Fore.RED
    else:
        reset = yellow = green = red = ''

    try:
        sha = 'oid'
        commits = _pygit2_commits(commit, repository)
    except ImportError:
        try:
            sha = 'hexsha'
            commits = _git_commits(commit, repository)
        except ImportError:
            click.echo('To use this feature, please install pygit2. '
                       'GitPython will also work but is not recommended '
                       '(python <= 2.7 only).',
                       file=sys.stderr)
            return 2

    template = '{0}commit {{commit.{1}}}{2}\n\n'.format(yellow, sha, reset)
    template += '{message}{errors}'

    count = 0
    ident = '    '
    re_line = re.compile('^', re.MULTILINE)
    for commit in commits:
        if skip_merge_commits and _is_merge_commit(commit):
            continue
        message = commit.message
        errors = check_message(message, **options)
        message = re.sub(re_line, ident, message)
        if errors:
            count += 1
            errors.insert(0, red)
        else:
            errors = [green, 'Everything is OK.']
        errors.append(reset)

        click.echo(template.format(commit=commit,
                                   message=message.encode('utf-8'),
                                   errors='\n'.join(errors)))

    if min(count, 1):
        raise click.Abort"
216,"def files(obj, commit='HEAD', skip_merge_commits=False):
    """"""Check the files of the commits.""""""
    from ..kwalitee import check_file, SUPPORTED_FILES
    from ..hooks import run
    options = obj.options
    repository = obj.repository

    if options.get('colors') is not False:
        colorama.init(autoreset=True)
        reset = colorama.Style.RESET_ALL
        yellow = colorama.Fore.YELLOW
        green = colorama.Fore.GREEN
        red = colorama.Fore.RED
    else:
        reset = yellow = green = red = ''

    try:
        sha = 'oid'
        commits = _pygit2_commits(commit, repository)
    except ImportError:
        try:
            sha = 'hexsha'
            commits = _git_commits(commit, repository)
        except ImportError:
            click.echo(
                'To use this feature, please install pygit2. GitPython will '
                'also work but is not recommended (python <= 2.7 only).',
                file=sys.stderr)
            click.exit(2)

    template = '{0}commit {{commit.{1}}}{2}\n\n'.format(yellow, sha, reset)
    template += '{message}{errors}\n'

    error_template = '\n{0}{{filename}}\n{1}{{errors}}{0}'.format(reset, red)
    no_errors = ['\n{0}Everything is OK.{1}'.format(green, reset)]
    msg_file_excluded = '\n{0}{{filename}} excluded.{1}'.format(yellow, reset)

    def _get_files_modified(commit):
        """"""Get the list of modified files that are Python or Jinja2.""""""
        cmd = ""git show --no-commit-id --name-only --diff-filter=ACMRTUXB {0}""
        _, files_modified, _ = run(cmd.format(commit))

        extensions = [re.escape(ext)
                      for ext in list(SUPPORTED_FILES) + ["".rst""]]
        test = ""(?:{0})$"".format(""|"".join(extensions))
        return list(filter(lambda f: re.search(test, f), files_modified))

    def _ensure_directory(filename):
        dir_ = os.path.dirname(filename)
        if not os.path.exists(dir_):
            os.makedirs(dir_)

    def _format_errors(args):
        filename, errors = args
        if errors is None:
            return msg_file_excluded.format(filename=filename)
        else:
            return error_template.format(filename=filename, errors='\n'.join(
                errors if len(errors) else no_errors))

    count = 0
    ident = '    '
    re_line = re.compile('^', re.MULTILINE)
    for commit in commits:
        if skip_merge_commits and _is_merge_commit(commit):
            continue
        message = commit.message
        commit_sha = getattr(commit, sha)
        tmpdir = mkdtemp()
        errors = {}
        try:
            for filename in _get_files_modified(commit):
                cmd = ""git show {commit_sha}:{filename}""
                _, out, _ = run(cmd.format(commit_sha=commit_sha,
                                           filename=filename),
                                raw_output=True)

                destination = os.path.join(tmpdir, filename)
                _ensure_directory(destination)

                with open(destination, 'w+') as f:
                    f.write(out)

                errors[filename] = check_file(destination, **options)
        finally:
            shutil.rmtree(tmpdir, ignore_errors=True)

        message = re.sub(re_line, ident, message)
        if len(errors):
            count += 1
            errors = map(_format_errors, errors.items())
        else:
            errors = no_errors

        click.echo(template.format(commit=commit,
                                   message=message.encode('utf-8'),
                                   errors='\n'.join(errors)))

    if min(count, 1):
        raise click.Abort"
217,"def get_obj_subcmds(obj):
    """"""Fetch action in callable attributes which and commands

    Callable must have their attribute 'command' set to True to
    be recognised by this lookup.

    Please consider using the decorator ``@cmd`` to declare your
    subcommands in classes for instance.

    """"""
    subcmds = []
    for label in dir(obj.__class__):
        if label.startswith(""_""):
            continue
        if isinstance(getattr(obj.__class__, label, False), property):
            continue
        rvalue = getattr(obj, label)
        if not callable(rvalue) or not is_cmd(rvalue):
            continue
        if isinstance(obj, types.MethodType) and \
               label in (""im_func"", ""im_self"", ""im_class""):
            continue
        ## potential command
        command_name = getattr(rvalue, ""command_name"",
                               label[:-1] if label.endswith(""_"") else
                               label)
        subcmds.append((command_name, rvalue))
    return OrderedDict(subcmds)"
218,"def get_module_resources(mod):
    """"""Return probed sub module names from given module""""""

    path = os.path.dirname(os.path.realpath(mod.__file__))
    prefix = kf.basename(mod.__file__, ("".py"", "".pyc""))

    if not os.path.exists(mod.__file__):
        import pkg_resources
        for resource_name in pkg_resources.resource_listdir(mod.__name__, ''):
            if resource_name.startswith(""%s_"" % prefix) and resource_name.endswith("".py""):
                module_name, _ext = os.path.splitext(kf.basename(resource_name))
                yield module_name

    for f in glob.glob(os.path.join(path, '%s_*.py' % prefix)):
        module_name, _ext = os.path.splitext(kf.basename(f))
        yield module_name"
219,"def get_mod_subcmds(mod):
    """"""Fetch action in same directory in python module

    python module loaded are of this form: '%s_*.py' % prefix

    """"""

    ## Look in modules attributes

    subcmds = get_obj_subcmds(mod)

    path = os.path.dirname(os.path.realpath(mod.__file__))
    if mod.__package__ is None:
        sys.path.insert(0, os.path.dirname(path))
        mod.__package__ = kf.basename(path)

    for module_name in get_module_resources(mod):
        try:
            mod = importlib.import_module("".%s"" % module_name, mod.__package__)
        except ImportError as e:
            msg.warn(""%r could not be loaded: %s""
                     % (module_name, e.message))
            continue
        except IOError as e:
            print(""%s"" % module_name)
            raise
        if hasattr(mod, ""Command"") and is_cmd(mod.Command):
            obj = mod.Command
            if obj.__doc__ is None:
                msg.warn(""Missing doc string for command from ""
                         ""module %s"" % module_name)
                continue
            if isinstance(obj, type):
                obj = obj()  ## instanciate it.
            name = module_name.split(""_"", 1)[1]
            if name in subcmds:
                raise ValueError(
                    ""Module command %r conflicts with already defined object ""
                    ""command.""
                    % name)
            subcmds[name] = obj

    return subcmds"
220,"def get_help(obj, env, subcmds):
    """"""Interpolate complete help doc of given object

    Assumption that given object as a specific interface:

    obj.__doc__ is the basic help object.
    obj.get_actions_titles() returns the subcommand if any.


    """"""
    doc = txt.dedent(obj.__doc__ or """")
    env = env.copy()  ## get a local copy

    doc = doc.strip()
    if not re.search(r""^usage:\s*$"", doc, flags=re.IGNORECASE | re.MULTILINE):
        doc += txt.dedent(""""""

            Usage:
              %(std_usage)s

            Options:
              %(std_options)s"""""")

    help_line = (""  %%-%ds  %%s""
                 % (max([5] + [len(a) for a in subcmds]), ))
    env[""actions""] = ""\n"".join(
        help_line % (
            name,
            get_help(subcmd, subcmd_env(env, name), {}).split(""\n"")[0])
        for name, subcmd in subcmds.items())
    env[""actions_help""] = """" if not env[""actions""] else (
        ""ACTION could be one of:\n\n""
        ""%(actions)s\n\n""
        ""See '%(surcmd)s help ACTION' for more information ""
        ""on a specific command.""
        % env)
    if ""%(std_usage)s"" in doc:
        env[""std_usage""] = txt.indent(
            (""%(surcmd)s --help\n""
             ""%(surcmd)s --version"" +
             ((""\n%(surcmd)s help [COMMAND]""
               ""\n%(surcmd)s ACTION [ARGS...]"") if subcmds else """"))
            % env,
            _find_prefix(doc, ""%(std_usage)s""),
            first="""")
    if ""%(std_options)s"" in doc:
        env[""std_options""] = txt.indent(
            ""--help          Show this screen.\n""
            ""--version       Show version."",
            _find_prefix(doc, ""%(std_options)s""),
            first="""")

    if subcmds and ""%(actions_help)s"" not in doc:
        doc += ""\n\n%(actions_help)s""
    try:
        output = doc % env
    except KeyError as e:
        msg.err(""Doc interpolation of %s needed missing key %r""
                % (aformat(env[""surcmd""], attrs=[""bold"", ]),
                   e.args[0]))
        exit(1)
    except Exception as e:
        msg.err(
            ""Documentation of %s is not valid. Please check it:\n%s""
            % (aformat(env[""surcmd""], attrs=[""bold"", ]),
               doc))
        exit(1)
    return output"
221,"def get_calling_prototype(acallable):
    """"""Returns actual working calling prototype

    This means that the prototype given can be used directly
    in the same way by bound method, method, function, lambda::

        >>> def f1(a, b, c=1): pass
        >>> get_calling_prototype(f1)
        (['a', 'b', 'c'], (1,))
        >>> get_calling_prototype(lambda a, b: None)
        (['a', 'b'], ())
        >>> get_calling_prototype(lambda a=None: None)
        (['a'], (None,))
        >>> get_calling_prototype(lambda : None)
        ([], ())
        >>> class A(object):
        ...     def m1(self, a, b, c=None): pass
        ...     @classmethod
        ...     def cm(cls, a, b, c=None): pass
        ...     @staticmethod
        ...     def st(a, b, c=None): pass
        ...     def __call__(self, a, b, c=None): pass

        >>> get_calling_prototype(A.m1)
        (['self', 'a', 'b', 'c'], (None,))
        >>> A.m1(A(), 1, 2, 3)
        >>> get_calling_prototype(A().m1)
        (['a', 'b', 'c'], (None,))
        >>> get_calling_prototype(A.cm)
        (['a', 'b', 'c'], (None,))
        >>> get_calling_prototype(A().cm)
        (['a', 'b', 'c'], (None,))
        >>> get_calling_prototype(A.st)
        (['a', 'b', 'c'], (None,))
        >>> get_calling_prototype(A().st)
        (['a', 'b', 'c'], (None,))
        >>> get_calling_prototype(A())
        (['a', 'b', 'c'], (None,))



    """"""
    assert callable(acallable)
    if inspect.ismethod(acallable) or inspect.isfunction(acallable):
        args, vargs, vkwargs, defaults = inspect.getargspec(acallable)
    elif not inspect.isfunction(acallable) and hasattr(acallable, ""__call__""):
        ## a class instance ? which is callable...
        args, vargs, vkwargs, defaults = inspect.getargspec(acallable.__call__)
        ## remove the 'self' argument
        args = args[1:]
    else:
        raise ValueError(""Hum, %r is a callable, but not a function/method, ""
                         ""nor a instance with __call__ arg...""
                         % acallable)

    if vargs or vkwargs:
        raise SyntaxError(""variable *arg or **kwarg are not supported."")

    if is_bound(acallable):
        args = args[1:]

    if defaults is None:
        defaults = ()  ## be coherent

    return args, defaults"
222,"def match_prototype(acallable, arguments):
    """"""Return tuple (pos args, kwargs) to call given callable

    Let's define a callable that will printout

    >>> arguments = {'alphonse': 1, 'bertrand': 2, 'charlie': 3}

    >>> match_prototype(lambda arguments: None, arguments)
    ([{'bertrand': 2, 'charlie': 3, 'alphonse': 1}], {})
    >>> match_prototype(lambda args: None, arguments)
    ([{'bertrand': 2, 'charlie': 3, 'alphonse': 1}], {})


    >>> match_prototype(lambda bertrand, arguments: None, arguments)
    ([2, {'charlie': 3, 'alphonse': 1}], {})

    >>> match_prototype(lambda bertrand, arguments, foo=None: None, arguments)
    ([2, {'charlie': 3, 'alphonse': 1}], {})

    >>> match_prototype(lambda bertrand, arguments, charlie=None: None,
    ...                 arguments)
    ([2, {'alphonse': 1}], {'charlie': 3})

    """"""

    args, defaults = get_calling_prototype(acallable)
    arguments = arguments.copy()
    defaults = [] if defaults is None else defaults
    p = []
    kw = {}

    pos_args = len(args) - len(defaults)
    has_args = any(k in ('args', 'arguments')
                   for k in args)
    args_label_pos = None
    for i, arg in enumerate(args):
        is_pos = i < pos_args
        val = None
        if not args_label_pos and arg in ('arguments', 'args'):
            val = arguments  ## copy by reference here is important
        else:
            k = None
            for k in arguments:
                norm = k
                if norm.startswith(""--""):
                    if is_pos:
                        continue
                    norm = norm[2:]
                elif k.startswith(""-""):
                    if is_pos:
                        continue
                    norm = norm[1:]
                norm = norm.lower()
                norm = norm.replace('-', '_')
                if norm == arg:
                    break
            else:
                if not has_args:
                    raise SyntaxError(
                        ""Can't match your function argument %r with ""
                        ""command line keys (%s).""
                        % (arg, "", "".join(arguments.keys())))
                else:
                    k = None
            if k is not None:
                ## inplace removal is important here
                val = arguments.pop(k)
        if is_pos:
            p.append(val)
        else:
            if val is not None:
                ## we should only have strings if it was set.
                kw[arg] = val
    return p, kw"
223,"def initialize(self):
        """""" Generate the root directory root if it doesn't already exist """"""
        if not os.path.exists(self.root_dir):
            os.makedirs(self.root_dir)
        assert os.path.isdir(self.root_dir), ""%s is not a directory! Please move or remove it."" % self.root_dir
        for d in [""bin"", ""lib"", ""include""]:
            target_path = os.path.join(self.root_dir, d)
            if not os.path.exists(target_path):
                os.makedirs(target_path)
        if not os.path.exists(self.manifest_path):
            open(self.manifest_path, ""w+"").close()
        self.new = False"
224,"def finalize(self):
        """""" finalize any open file handles """"""
        if self.rc_file:
            self.rc_file.close()
        if self.env_file:
            self.env_file.close()"
225,"def remove(self):
        """""" Removes the sprinter directory, if it exists """"""
        if self.rc_file:
            self.rc_file.close()
        if self.env_file:
            self.env_file.close()
        shutil.rmtree(self.root_dir)"
226,"def symlink_to_bin(self, name, path):
        """""" Symlink an object at path to name in the bin folder. """"""
        self.__symlink_dir(""bin"", name, path)
        os.chmod(os.path.join(self.root_dir, ""bin"", name), os.stat(path).st_mode | stat.S_IXUSR | stat.S_IRUSR)"
227,"def remove_from_bin(self, name):
        """""" Remove an object from the bin folder. """"""
        self.__remove_path(os.path.join(self.root_dir, ""bin"", name))"
228,"def remove_from_lib(self, name):
        """""" Remove an object from the bin folder. """"""
        self.__remove_path(os.path.join(self.root_dir, ""lib"", name))"
229,"def remove_feature(self, feature_name):
        """""" Remove an feature from the environment root folder. """"""
        self.clear_feature_symlinks(feature_name)
        if os.path.exists(self.install_directory(feature_name)):
            self.__remove_path(self.install_directory(feature_name))"
230,"def clear_feature_symlinks(self, feature_name):
        """""" Clear the symlinks for a feature in the symlinked path """"""
        logger.debug(""Clearing feature symlinks for %s"" % feature_name)
        feature_path = self.install_directory(feature_name)
        for d in ('bin', 'lib'):
            if os.path.exists(os.path.join(self.root_dir, d)):
                for link in os.listdir(os.path.join(self.root_dir, d)):
                    path = os.path.join(self.root_dir, d, link)
                    if feature_path in os.path.realpath(path):
                        getattr(self, 'remove_from_%s' % d)(link)"
231,"def add_to_env(self, content):
        """"""
        add content to the env script.
        """"""
        if not self.rewrite_config:
            raise DirectoryException(""Error! Directory was not intialized w/ rewrite_config."")
        if not self.env_file:
            self.env_path, self.env_file = self.__get_env_handle(self.root_dir)
        self.env_file.write(content + '\n')"
232,"def add_to_rc(self, content):
        """"""
        add content to the rc script.
        """"""
        if not self.rewrite_config:
            raise DirectoryException(""Error! Directory was not intialized w/ rewrite_config."")
        if not self.rc_file:
            self.rc_path, self.rc_file = self.__get_rc_handle(self.root_dir)
        self.rc_file.write(content + '\n')"
233,"def add_to_gui(self, content):
        """"""
        add content to the gui script.
        """"""
        if not self.rewrite_config:
            raise DirectoryException(""Error! Directory was not intialized w/ rewrite_config."")
        if not self.gui_file:
            self.gui_path, self.gui_file = self.__get_gui_handle(self.root_dir)
        self.gui_file.write(content + '\n')"
234,"def __remove_path(self, path):
        """""" Remove an object """"""
        curpath = os.path.abspath(os.curdir)
        if not os.path.exists(path):
            logger.warn(""Attempted to remove a non-existent path %s"" % path)
            return
        try:
            if os.path.islink(path):
                os.unlink(path)
            elif os.path.isdir(path):
                shutil.rmtree(path)
            else:
                os.unlink(path)

            # in the case we just deleted ourselves out of a valid directory,
            # we move to a valid directory.
            if curpath == path:
                os.chdir(tempfile.gettempdir())

        except OSError:
            logger.error(""Unable to remove object at path %s"" % path)
            raise DirectoryException(""Unable to remove object at path %s"" % path)"
235,"def __get_env_handle(self, root_dir):
        """""" get the filepath and filehandle to the .env file for the environment """"""
        env_path = os.path.join(root_dir, '.env')
        gui_path = os.path.join(root_dir, '.gui')
        fh = open(env_path, ""w+"")
        # .env will source utils.sh if it hasn't already
        fh.write(source_template % (gui_path, gui_path))
        fh.write(source_template % (self.shell_util_path,
                                    self.shell_util_path))
        return (env_path, fh)"
236,"def __get_rc_handle(self, root_dir):
        """""" get the filepath and filehandle to the rc file for the environment """"""
        rc_path = os.path.join(root_dir, '.rc')
        env_path = os.path.join(root_dir, '.env')
        fh = open(rc_path, ""w+"")
        # .rc will always source .env
        fh.write(source_template % (env_path, env_path))
        return (rc_path, fh)"
237,"def __get_gui_handle(self, root_dir):
        """""" get the filepath and filehandle to the .env file for the environment """"""
        gui_path = os.path.join(root_dir, '.gui')
        fh = open(gui_path, ""w+"")
        return (gui_path, fh)"
238,"def __symlink_dir(self, dir_name, name, path):
        """"""
        Symlink an object at path to name in the dir_name folder. remove it if it already exists.
        """"""
        target_dir = os.path.join(self.root_dir, dir_name)
        if not os.path.exists(target_dir):
            os.makedirs(target_dir)
        target_path = os.path.join(self.root_dir, dir_name, name)
        logger.debug(""Attempting to symlink %s to %s..."" % (path, target_path))
        if os.path.exists(target_path):
            if os.path.islink(target_path):
                os.remove(target_path)
            else:
                logger.warn(""%s is not a symlink! please remove it manually."" % target_path)
                return
        os.symlink(path, target_path)"
239,"def create(self, options=None):
        """"""Create a new document job (sync or async).""""""
        if options is None:
            raise ValueError(""Please pass in an options dict"")

        if not _has_content(options):
            raise NoContentError(""must supply 'document_content' or 'document_url'"")

        default_options = {
            ""name"": ""default"",
            ""document_type"": ""pdf"",
            ""test"": False,
            ""async"": False,
            ""raise_exception_on_failure"": False,
        }
        options = dict(list(default_options.items()) + list(options.items()))
        raise_exception_on_failure = options.pop(""raise_exception_on_failure"")
        query = {""user_credentials"": self.api_key}
        if options[""async""]:
            query[""output""] = ""json""

        resp = requests.post(
            ""%sdocs"" % (self._url), json=options, params=query, timeout=self._timeout
        )

        if raise_exception_on_failure and resp.status_code != 200:
            raise DocumentCreationFailure(resp.content, resp.status_code)

        if options[""async""]:
            return json.loads(resp.content.decode(""utf-8""))
        else:
            return resp"
240,"def list_docs(self, options=None):
        """"""Return list of previously created documents.""""""
        if options is None:
            raise ValueError(""Please pass in an options dict"")

        default_options = {
            ""page"": 1,
            ""per_page"": 100,
            ""raise_exception_on_failure"": False,
            ""user_credentials"": self.api_key,
        }
        options = dict(list(default_options.items()) + list(options.items()))
        raise_exception_on_failure = options.pop(""raise_exception_on_failure"")

        resp = requests.get(
            ""%sdocs"" % (self._url), params=options, timeout=self._timeout
        )

        if raise_exception_on_failure and resp.status_code != 200:
            raise DocumentListingFailure(resp.content, resp.status_code)
        return resp"
241,"def status(self, status_id, raise_exception_on_failure=False):
        """"""Return the status of the generation job.""""""
        query = {""output"": ""json"", ""user_credentials"": self.api_key}

        resp = requests.get(
            ""%sstatus/%s"" % (self._url, status_id), params=query, timeout=self._timeout
        )

        if raise_exception_on_failure and resp.status_code != 200:
            raise DocumentStatusFailure(resp.content, resp.status_code)

        if resp.status_code == 200:
            as_json = json.loads(resp.content)
            if as_json[""status""] == ""completed"":
                as_json[""download_key""] = _get_download_key(as_json[""download_url""])
            return as_json
        return resp"
242,"def download(self, download_key, raise_exception_on_failure=False):
        """"""Download the file represented by the download_key.""""""
        query = {""output"": ""json"", ""user_credentials"": self.api_key}
        resp = requests.get(
            ""%sdownload/%s"" % (self._url, download_key),
            params=query,
            timeout=self._timeout,
        )

        if raise_exception_on_failure and resp.status_code != 200:
            raise DocumentDownloadFailure(resp.content, resp.status_code)
        return resp"
243,"def merge_INIConf(a, b):
    """"""用 b 的内容覆盖 a 的内容（若重名），并返回 a
    """"""
    for sname in b.sections():
        if a.has_section(sname):
            for oname in b.options(sname):
                a[sname][oname] = b[sname][oname]
        else:
            a[sname] = b[sname]
    return a"
244,"def copy_from_dict(self, adict, parent=None):
        """"""从一个已经存在的 dict 中复制所有的值。

        :param adict: 被复制的 dict。
        :type adict: dict
        :param parent:  复制到哪个父对象。
                        若为 None 则复制到 self 。
        :type parent: rookout.PYConf

        """"""
        if not parent:
            parent = self
        for k,v in adict.items():
            if isinstance(v, dict):
                vDict = PYConf(v)
                self.copy_from_dict(v, vDict)
                parent[k] = vDict
            else:
                parent[k] = v"
245,"def dump(self, human=False):
        """"""将自身内容打印成字符串

        :param bool human: 若值为 True ，则打印成易读格式。

        """"""
        txt = str(self)
        if human:
            txt = txt.replace("", '"", "",\n'"")
            txt = txt.replace(""{"", ""{\n"")
            txt = txt.replace(""}"", ""\n}"")
            txt = txt.replace(""["", ""[\n"")
            txt = txt.replace(""]"", ""\n]"")
        return txt"
246,"def save_to_file(self, path, human=True):
        """"""将自身内容保存到文件。

        :param str path: 保存的文件路径。
        :param bool human: 参见 :func:`dump()`

        """"""
        write_file(path, self.dump(human))
        slog.info(""Save %a done."", path)"
247,"def read_from_file(self, path):
        """"""从一个文本文件中读入信息。
        假设该文本文件的格式与 :func:`dump()` 相同。

        :param str path: 待读入的文件路径。

        """"""
        if not os.path.exists(path):
            slog.warning(""The file %s is not exist."", path)
            return False
        txt = read_file(path)
        dic = eval(txt)
        self.copy_from_dict(dic)
        return True"
248,"def _set_parameters(self, parameters):
        """"""Sort out the various possible parameter inputs and return a config
        object (dict)

        We have multiple input formats:

        1) a list, tuple, or numpy.ndarray, containing the linear parameters
        in the following order:
        * for single term: rho0, m1, tau1, c1
        * for multiple termss: rho0, m1, m2, ..., tau1, tau2, ..., c1, c2, ...

        2) a dictionary with the entries ""rho0"", ""m"", ""tau"", ""c""

        2b) if the dictionary entries for ""m"", ""tau"", and ""c"" are lists, the
        entries correspond to mulitple polarisazion terms

        """"""
        nr_f = self.f.size

        # sort out parameters
        rho0, m, tau, c = self._sort_parameters(parameters)

        newsize = (nr_f, len(m))
        # rho0_resized = np.resize(rho0, newsize)
        m_resized = np.resize(m, newsize)
        tau_resized = np.resize(tau, newsize)
        c_resized = np.resize(c, newsize)

        omega = np.atleast_2d(2 * np.pi * self.f).T
        self.w = np.resize(omega, (len(m), nr_f)).T
        self.rho0 = rho0
        self.m = m_resized
        self.tau = tau_resized
        self.c = c_resized

        # compute some common terms
        self.otc = (self.w * self.tau) ** self.c
        self.otc2 = (self.w * self.tau) ** (2 * self.c)
        self.ang = self.c * np.pi / 2.0  # rad
        self.denom = 1 + 2 * self.otc * np.cos(self.ang) + self.otc2"
249,"def response(self, parameters):
        r""""""Complex response of the Cole-Cole model::
        :math:`\hat{\rho} = \rho_0 \left(1 - \sum_i m_i (1 - \frac{1}{1 + (j
        \omega \tau_i)^c_i})\right)`

        Parameters
        ----------
        parameters: list or tuple or numpy.ndarray
            Cole-Cole model parameters: rho0, m, tau, c (all linear)

        Returns
        -------
        response: :class:`sip_models.sip_response.sip_response`
            model response object
        """"""
        # get a config object
        self._set_parameters(parameters)
        terms = self.m * (1 - (1 / (1 + (1j * self.w * self.tau) ** self.c)))
        # sum up terms
        specs = np.sum(terms, axis=1)
        rcomplex = self.rho0 * (1 - specs)
        response = sip_response.sip_response(self.f, rcomplex=rcomplex)

        return response"
250,"def dre_drho0(self, pars):
        r"""""" Compute partial derivative of real parts with respect to
        :math:`\rho_0`

        :math:`\frac{\partial \hat{\rho'}(\omega)}{\partial \rho_0} = 1 -
        \frac{m (\omega \tau)^c cos(\frac{c \pi}{2}) + (\omega \tau)^c}{1 + 2
        (\omega \tau)^c cos(\frac{c \pi}{2}) + (\omega \tau)^{2 c}}`

        Note that partial derivatives towards :math:`\rho_0` are 1D, in
        contrast to the other parameter derivatives, which usually return 2D
        arrays!

        Returns
        -------
        dre_drho0: :class:`numpy.ndarray`
            Size N (nr of frequencies) array with the derivatives

        """"""
        self._set_parameters(pars)
        numerator = self.m * self.otc * (np.cos(self.ang) + self.otc)
        term = numerator / self.denom
        specs = np.sum(term, axis=1)

        result = 1 - specs
        return result"
251,"def dre_dlog10rho0(self, pars):
        """"""Compute partial derivative of real parts to log10(rho0)
        """"""

        # first call the linear response to set the parameters
        linear_response = self.dre_drho0(pars)
        result = np.log(10) * self.rho0 * linear_response
        return result"
252,"def dre_dm(self, pars):
        r""""""
        :math:`\frac{\partial \hat{\rho'}(\omega)}{\partial m} = - \rho_0 m
        (\omega \tau)^c \frac{(cos(\frac{c \pi}{2}) + (\omega \tau)^c)}{1 + 2
        (\omega \tau)^c cos(\frac{c \pi}{2}) + (\omega \tau)^{2 c}}`
        """"""
        self._set_parameters(pars)
        numerator = -self.otc * (np.cos(self.ang) + self.otc)
        result = numerator / self.denom
        result *= self.rho0
        return result"
253,"def dim_dm(self, pars):
        r""""""
        :math:`\frac{\partial \hat{\rho''}(\omega)}{\partial m} = - \rho_0 m
        (\omega \tau)^c \frac{sin(\frac{c \pi}{2})}{1 + 2 (\omega \tau)^c
        cos(\frac{c \pi}{2}) + (\omega \tau)^{2 c}}`
        """"""
        self._set_parameters(pars)
        numerator = -self.otc * np.sin(self.ang)
        result = numerator / self.denom
        result *= self.rho0
        return result"
254,"def dim_dtau(self, pars):
        r""""""
        :math:`\frac{\partial \hat{\rho''}(\omega)}{\partial \tau} = \rho_0
        \frac{-m \omega^c c \tau^{c-1} sin(\frac{c \pi}{2} }{1 + 2 (\omega
        \tau)^c cos(\frac{c \pi}{2}) + (\omega \tau)^{2 c}} +
        \rho_0 \frac{\left[-m (\omega \tau)^c sin(\frac{c \pi}{2}
        \right] \cdot \left[ 2 \omega^c c \tau^{c-1} cos(\frac{c
        \pi}{2}) + 2 c \omega^{2 c} \tau^{2 c - 1}\right]}{\left[1 + 2 (\omega
        \tau)^c cos(\frac{c \pi}{2}) + (\omega \tau)^{2 c}\right]^2}`
        """"""
        self._set_parameters(pars)
        # term1
        nom1 = - self.m * np.sin(self.ang) * self.w ** self.c *\
            self.c * self.tau ** (self.c - 1)
        term1 = nom1 / self.denom

        # term2
        nom2 = (self.m * self.otc * np.sin(self.ang)) *\
            (2 * self.w ** self.c * self.c * self.tau ** (self.c - 1) *
             np.cos(self.ang) + 2 * self.c * self.w ** (2 * self.c) *
             self.tau ** (2 * self.c - 1))
        term2 = nom2 / self.denom ** 2

        result = term1 + term2
        result *= self.rho0
        return result"
255,"def dim_dc(self, pars):
        r""""""
        :math:`\frac{\partial \hat{\rho''}(\omega)}{\partial c} = \rho_0
        \frac{-m sin(\frac{c \pi}{2}) ln(\omega \tau)(\omega \tau)^c - m
        (\omega \tau)^c \frac{\pi}{2} cos(\frac{\pi}{2}}{1 + 2 (\omega \tau)^c
        cos(\frac{c \pi}{2}) + (\omega \tau)^{2 c}} + \rho_0 \frac{\left[-m
        (\omega \tau)^c cos(\frac{c \pi}{2}) \right] \cdot \left[ -2 ln(\omega
        \tau) (\omega \tau)^c cos(\frac{c \pi}{2}) + 2 (\omega \tau)^c
        \frac{\pi}{2} cos(\frac{c \pi}{2}) \right] + \left[2 ln(\omega \tau)
        (\omega \tau)^{2 c}\right]}{\left[1 + 2 (\omega \tau)^c cos(\frac{c
        \pi}{2}) + (\omega \tau)^{2 c}\right]^2}`
        """"""
        self._set_parameters(pars)
        # term1
        nom1a = - self.m * np.log(self.w * self.tau) * self.otc *\
            np.sin(self.ang)
        nom1b = - self.m * self.otc * (np.pi / 2.0) * np.cos(self.ang)
        term1 = (nom1a + nom1b) / self.denom

        # term2
        nom2 = (self.m * self.otc * np.sin(self.ang)) *\
            (2 * np.log(self.w * self.tau) * self.otc * np.cos(self.ang) -
             2 * self.otc * (np.pi / 2.0) * np.sin(self.ang) +
             2 * np.log(self.w * self.tau) * self.otc2)
        term2 = nom2 / self.denom ** 2
        result = term1 + term2

        result *= self.rho0
        return result"
256,"def Jacobian_re_im(self, pars):
        r""""""
        :math:`J`

        >>> import sip_models.res.cc as cc
        >>> import numpy as np
        >>> f = np.logspace(-3, 3, 20)
        >>> pars = [100, 0.1, 0.04, 0.8]
        >>> obj = cc.cc(f)
        >>> J = obj.Jacobian_re_im(pars)
        """"""
        partials = []

        # partials.append(self.dre_dlog10rho0(pars)[:, np.newaxis, :])
        partials.append(self.dre_drho0(pars)[:, np.newaxis])
        partials.append(self.dre_dm(pars))
        # partials.append(self.dre_dlog10tau(pars))
        partials.append(self.dre_dtau(pars))
        partials.append(self.dre_dc(pars))
        # partials.append(self.dim_dlog10rho0(pars)[:, np.newaxis, :])
        partials.append(self.dim_drho0(pars)[:, np.newaxis])
        partials.append(self.dim_dm(pars))
        # partials.append(self.dim_dlog10tau(pars))
        partials.append(self.dim_dtau(pars))
        partials.append(self.dim_dc(pars))

        print('SHAPES')
        for x in partials:
            print(x.shape)

        J = np.concatenate(partials, axis=1)
        return J"
257,"def read_dict_or_list_from_json(desired_type: Type[dict], file_object: TextIOBase,
                                logger: Logger, conversion_finder: ConversionFinder, **kwargs) -> Dict[str, Any]:
    """"""
    Helper method to read a dictionary from a .json file using json library
    :param file_object:
    :return:
    """"""
    # lazy import in order not to force use of jprops
    import json
    res = json.load(file_object)

    # convert if required
    return ConversionFinder.convert_collection_values_according_to_pep(res, desired_type, conversion_finder, logger, **kwargs)"
258,"def get_default_collection_parsers(parser_finder: ParserFinder, conversion_finder: ConversionFinder) -> List[AnyParser]:
    """"""
    Utility method to return the default parsers able to parse a dictionary from a file.
    :return:
    """"""
    return [SingleFileParserFunction(parser_function=read_dict_or_list_from_json,
                                     streaming_mode=True, custom_name='read_dict_or_list_from_json',
                                     supported_exts={'.json'},
                                     supported_types={dict, list},
                                     function_args={'conversion_finder': conversion_finder}),
            MultifileCollectionParser(parser_finder)
            ]"
259,"def get_default_collection_converters(conversion_finder: ConversionFinder) -> List[Union[Converter[Any, dict], Converter[dict, Any]]]:
    """"""
    Utility method to return the default converters associated to dict (from dict to other type,
    and from other type to dict)
    :return:
    """"""
    return [ConverterFunction(from_type=List, to_type=Set, conversion_method=list_to_set, custom_name='list_to_set',
                              function_args={'conversion_finder': conversion_finder}),
            ConverterFunction(from_type=List, to_type=Tuple, conversion_method=list_to_tuple,
                              custom_name='list_to_tuple', function_args={'conversion_finder': conversion_finder})]"
260,"def _get_parsing_plan_for_multifile_children(self, obj_on_fs: PersistedObject, desired_type: Type[Any],
                                                 logger: Logger) -> Dict[str, Any]:
        """"""
        Simply inspects the required type to find the base type expected for items of the collection,
        and relies on the ParserFinder to find the parsing plan

        :param obj_on_fs:
        :param desired_type:
        :param logger:
        :return:
        """"""
        # nb of file children
        n_children = len(obj_on_fs.get_multifile_children())

        # first extract base collection type
        subtypes, key_type = _extract_collection_base_type(desired_type)

        if isinstance(subtypes, tuple):
            # -- check the tuple length
            if n_children != len(subtypes):
                raise FolderAndFilesStructureError.create_for_multifile_tuple(obj_on_fs, len(subtypes),
                                                                              len(obj_on_fs.get_multifile_children()))
        else:
            # -- repeat the subtype n times
            subtypes = [subtypes] * n_children

        # -- for each child create a plan with the appropriate parser
        children_plan = OrderedDict()
        # use sorting for reproducible results in case of multiple errors
        for (child_name, child_fileobject), child_typ in zip(sorted(obj_on_fs.get_multifile_children().items()),
                                                           subtypes):
            # -- use the parserfinder to find the plan
            t, child_parser = self.parser_finder.build_parser_for_fileobject_and_desiredtype(child_fileobject, 
                                                                                             child_typ, logger)
            children_plan[child_name] = child_parser.create_parsing_plan(t, child_fileobject, logger,
                                                                         _main_call=False)

        return children_plan"
261,"def _parse_multifile(self, desired_type: Type[Union[Dict, List, Set, Tuple]], obj: PersistedObject,
                         parsing_plan_for_children: Dict[str, ParsingPlan], logger: Logger,
                         options: Dict[str, Dict[str, Any]]) \
            -> Union[Dict, List, Set, Tuple]:
        """"""
        Options may contain a section with id 'MultifileCollectionParser' containing the following options:
        * lazy_parsing: if True, the method will return immediately without parsing all the contents. Instead, the
        returned collection will perform the parsing the first time an item is required.
        * background_parsing: if True, the method will return immediately while a thread parses all the contents in
        the background. Note that users cannot set both lazy_parsing and background_parsing to True at the same time

        :param desired_type:
        :param obj:
        :param parsing_plan_for_children:
        :param logger:
        :param options:
        :return:
        """"""

        # first get the options and check them
        lazy_parsing = False
        background_parsing = False

        opts = self._get_applicable_options(options)
        for opt_key, opt_val in opts.items():
            if opt_key is 'lazy_parsing':
                lazy_parsing = opt_val
            elif opt_key is 'background_parsing':
                background_parsing = opt_val
            else:
                raise Exception('Invalid option in MultiFileCollectionParser : ' + opt_key)

        check_var(lazy_parsing, var_types=bool, var_name='lazy_parsing')
        check_var(background_parsing, var_types=bool, var_name='background_parsing')

        if lazy_parsing and background_parsing:
            raise ValueError('lazy_parsing and background_parsing cannot be set to true at the same time')

        if lazy_parsing:
            # build a lazy dictionary
            results = LazyDictionary(sorted(list(parsing_plan_for_children.keys())),
                                     loading_method=lambda x: parsing_plan_for_children[x].execute(logger, options))
            # logger.debug('Assembling a ' + get_pretty_type_str(desired_type) + ' from all children of ' + str(obj)
            #             + ' (lazy parsing: children will be parsed when used) ')
            logger.debug('(P) {loc} : lazy parsing ON, children will be parsed only if/when used'.format(
                loc=obj.get_pretty_location(blank_parent_part=(not GLOBAL_CONFIG.full_paths_in_logs),
                                            compact_file_ext=True)))

        elif background_parsing:
            # -- TODO create a thread to perform the parsing in the background
            raise ValueError('Background parsing is not yet supported')

        else:
            # Parse right now
            results = OrderedDict()

            # parse all children according to their plan
            # -- use key-based sorting on children to lead to reproducible results
            # (in case of multiple errors, the same error will show up first everytime)
            for child_name, child_plan in sorted(parsing_plan_for_children.items()):
                results[child_name] = child_plan.execute(logger, options)
            # logger.debug('Assembling a ' + get_pretty_type_str(desired_type) + ' from all parsed children of '
            #             + str(obj))

        if issubclass(desired_type, list):
            # return a list facade
            return KeySortedListFacadeForDict(results)
        elif issubclass(desired_type, tuple):
            # return a tuple facade
            return KeySortedTupleFacadeForDict(results)
        elif issubclass(desired_type, set):
            # return a set facade
            return SetFacadeForDict(results)
        elif issubclass(desired_type, dict):
            # return the dict directly
            return results
        else:
            raise TypeError('Cannot build the desired collection out of the multifile children: desired type is not '
                            'supported: ' + get_pretty_type_str(desired_type))"
262,"def dispatch(self, producer=None):
        """"""
        Dispatch the event, sending a message to the queue using a producer.
        :param producer: optional `Producer` to replace the default one.
        """"""
        log.info('@Event.dispatch `{}` with subject `{}`'
                 .format(self.name, self.subject))
        producer = (producer or Registry.get_producer())
        if not producer:
            raise MissingProducerError('You have not registered a Producer')
        try:
            producer.produce(self.topic, self.name, self.subject, self.data)
        except:
            fallback = Registry.get_fallback()
            fallback(self)
            raise"
263,"def read_annotation_file(annotation_file, annotation_type):
  """"""read_annotation_file(annotation_file, annotation_type) -> annotations
  Reads annotations from the given ``annotation_file``.

  The way, how annotations are read depends on the given ``annotation_type``.
  Depending on the type, one or several annotations might be present in the annotation file.
  Currently, these variants are implemented:

  - ``'lr-eyes'``: Only the eye positions are stored, in a single row, like: ``le_x le_y re_x re_y``, comment lines starting with ``'#'`` are ignored.
  - ``'named'``: Each line of the file contains a name and two floats, like ``reye x y``; empty lines separate between sets of annotations.
  - ``'idiap'``: A special 22 point format, where each line contains the index and the locations, like ``1 x y``.
  - ``'fddb'``: a special format for the FDDB database; empty lines separate between sets of annotations

  Finally, a list of ``annotations`` is returned in the format: ``[{name: (y,x)}]``.

  **Parameters:**

  ``annotation_file`` : str
    The file name of the annotation file to read

  ``annotation_type`` : str (see above)
    The style of annotation file, in which the given ``annotation_file`` is

  **Returns:**

  ``annotations`` : [dict]
    A list of annotations read from the given file, grouped by annotated objects (faces).
    Each annotation is generally specified as the two eye coordinates, i.e., ``{'reye' : (rey, rex), 'leye' : (ley, lex)}``, but other types of annotations might occur as well.
  """"""
  annotations = [{}]
  with open(annotation_file) as f:
    if annotation_type == 'idiap':
      # This is a special format where we have enumerated annotations, and a 'gender'
      for line in f:
        positions = line.rstrip().split()
        if positions:
          if positions[0].isdigit():
            # position field
            assert len(positions) == 3
            id = int(positions[0])
            annotations[-1]['key%d'%id] = (float(positions[2]),float(positions[1]))
          else:
            # another field, we take the first entry as key and the rest as values
            annotations[-1][positions[0]] = positions[1:]
        elif len(annotations[-1]) > 0:
          # empty line; split between annotations
          annotations.append({})
      # finally, we add the eye center coordinates as the center between the eye corners; the annotations 3 and 8 seem to be the pupils...
      for annotation in annotations:
        if 'key1' in annotation and 'key5' in annotation:
          annotation['reye'] = ((annotation['key1'][0] + annotation['key5'][0])/2., (annotation['key1'][1] + annotation['key5'][1])/2.)
        if 'key6' in annotation and 'key10' in annotation:
          annotation['leye'] = ((annotation['key6'][0] + annotation['key10'][0])/2., (annotation['key6'][1] + annotation['key10'][1])/2.)
    elif annotation_type == 'lr-eyes':
      # In this format, the eyes are given in a single row ""le_x le_y re_x re_y"", possibly with a comment line
      # There is only a single annotation per image
      for line in f:
        if len(line) and line[0] != '#':
          positions = line.rstrip().split()
          annotations[0]['leye'] = (float(positions[1]),float(positions[0]))
          annotations[0]['reye'] = (float(positions[3]),float(positions[2]))
    elif annotation_type == 'named':
      # In this format, each line contains three entries: ""keyword x y""
      for line in f:
        positions = line.rstrip().split()
        if positions:
          annotations[-1][positions[0]] = (float(positions[2]),float(positions[1]))
        elif len(annotations[-1]) > 0:
          # empty line; split between annotations
          annotations.append({})
    elif annotation_type == 'fddb':
      # This is a special format for the FDDB database
      for line in f:
        positions = line.rstrip().split()
        if not len(positions):
          if len(annotations[-1]) > 0:
            # empty line; split between annotations
            annotations.append({})
        elif len(positions) == 2:
          annotations[-1][positions[0]] = float(positions[1])
        elif len(positions) == 3:
          annotations[-1][positions[0]] = (float(positions[2]),float(positions[1]))
        else:
          raise ValueError(""Could not interpret line %s of the annotation file"" % line)
    else:
      raise ValueError(""The given annotation type %s is not known"" % annotation_type)
  if not annotations[-1]:
    del annotations[-1]

  return annotations"
264,"def _build_opstackd():
  """"""
  Builds a dictionary that maps the name of an op-code to the number of elemnts
  it adds to the stack when executed. For some opcodes, the dictionary may
  contain a function which requires the #dis.Instruction object to determine
  the actual value.

  The dictionary mostly only contains information for instructions
  used in expressions.
  """"""

  def _call_function_argc(argc):
    func_obj = 1
    args_pos = (argc & 0xff)
    args_kw = ((argc >> 8) & 0xff) * 2
    return func_obj + args_pos + args_kw

  def _make_function_argc(argc):
    args_pos = (argc + 0xff)
    args_kw = ((argc >> 8) & 0xff) * 2
    annotations = (argc >> 0x7fff)
    anootations_names = 1 if annotations else 0
    code_obj = 1
    qualname = 1
    return args_pos + args_kw + annotations + anootations_names + code_obj + qualname

  result = {
    'NOP': 0,
    'POP_TOP': -1,
    'ROT_TWO': 0,
    'ROT_THREE': 0,
    'DUP_TOP': 1,
    'DUP_TOP_TWO': 2,

    # Unary operations
    'GET_ITER': 0,

    # Miscellaneous operations
    'PRINT_EXPR': -1,
    'BREAK_LOOP': 0,  # xxx: verify
    'CONTINUE_LOOP': 0,  # xxx: verify
    'SET_ADD': -1,  # xxx: verify
    'LIST_APPEND': -1,  # xxx: verify
    'MAP_ADD': -2,  # xxx: verify
    'RETURN_VALUE': -1,  # xxx: verify
    'YIELD_VALUE': -1,
    'YIELD_FROM': -1,
    'IMPORT_STAR': -1,

    # 'POP_BLOCK':
    # 'POP_EXCEPT':
    # 'END_FINALLY':
    # 'LOAD_BUILD_CLASS':
    # 'SETUP_WITH':
    # 'WITH_CLEANUP_START':
    # 'WITH_CLEANUP_FINISH':
    'STORE_NAME': -1,
    'DELETE_NAME': 0,
    'UNPACK_SEQUENCE': lambda op: op.arg,
    'UNPACK_EX': lambda op: (op.arg & 0xff) - (op.arg >> 8 & 0xff),  # xxx: check
    'STORE_ATTR': -2,
    'DELETE_ATTR': -1,
    'STORE_GLOBAL': -1,
    'DELETE_GLOBAL': 0,
    'LOAD_CONST': 1,
    'LOAD_NAME': 1,
    'BUILD_TUPLE': lambda op: 1 - op.arg,
    'BUILD_LIST': lambda op: 1 - op.arg,
    'BUILD_SET': lambda op: 1 - op.arg,
    'BUILD_MAP': lambda op: 1 - op.arg,
    'LOAD_ATTR': 0,
    'COMPARE_OP': 1,  # xxx: check
    # 'IMPORT_NAME':
    # 'IMPORT_FROM':
    # 'JUMP_FORWARD':
    # 'POP_JUMP_IF_TRUE':
    # 'POP_JUMP_IF_FALSE':
    # 'JUMP_IF_TRUE_OR_POP':
    # 'JUMP_IF_FALSE_OR_POP':
    # 'JUMP_ABSOLUTE':
    # 'FOR_ITER':
    'LOAD_GLOBAL': 1,
    # 'SETUP_LOOP'
    # 'SETUP_EXCEPT'
    # 'SETUP_FINALLY':
    'LOAD_FAST': 1,
    'STORE_FAST': -1,
    'DELETE_FAST': 0,
    # 'LOAD_CLOSURE':
    'LOAD_DEREF': 1,
    'LOAD_CLASSDEREF': 1,
    'STORE_DEREF': -1,
    'DELETE_DEREF': 0,
    'RAISE_VARARGS': lambda op: -op.arg,
    'CALL_FUNCTION': lambda op: 1 - _call_function_argc(op.arg),
    'MAKE_FUNCTION': lambda op: 1 - _make_function_argc(op.arg),
    # 'MAKE_CLOSURE':
    'BUILD_SLICE': lambda op: 1 - op.arg,
    # 'EXTENDED_ARG':
    'CALL_FUNCTION_KW': lambda op: 1 - _call_function_argc(op.arg),
  }

  if sys.version >= '3.5':
    result.update({
      'BEFORE_ASYNC_WITH': 0,
      'SETUP_ASYNC_WITH': 0,
      # Coroutine operations
      'GET_YIELD_FROM_ITER': 0,
      'GET_AWAITABLE': 0,
      'GET_AITER': 0,
      'GET_ANEXT': 0,
    })

  if sys.version <= '3.5':
    result.update({
      'CALL_FUNCTION_VAR': lambda op: 1 - _call_function_argc(op.arg),
      'CALL_FUNCTION_VAR_KW': lambda op: 1 - _call_function_argc(op.arg),
    })

  for code in dis.opmap.keys():
    if code.startswith('UNARY_'):
      result[code] = 0
    elif code.startswith('BINARY_') or code.startswith('INPLACE_'):
      result[code] = -1

  return result"
265,"def get_stackdelta(op):
  """"""
  Returns the number of elements that the instruction *op* adds to the stack.

  # Arguments
  op (dis.Instruction): The instruction to retrieve the stackdelta value for.

  # Raises
  KeyError: If the instruction *op* is not supported.
  """"""

  res = opstackd[op.opname]
  if callable(res):
    res = res(op)
  return res"
266,"def get_assigned_name(frame):
  """"""
  Checks the bytecode of *frame* to find the name of the variable a result is
  being assigned to and returns that name. Returns the full left operand of the
  assignment. Raises a #ValueError if the variable name could not be retrieved
  from the bytecode (eg. if an unpack sequence is on the left side of the
  assignment).

  > **Known Limitations**:  The expression in the *frame* from which this
  > function is called must be the first part of that expression. For
  > example, `foo = [get_assigned_name(get_frame())] + [42]` works,
  > but `foo = [42, get_assigned_name(get_frame())]` does not!

  ```python
  >>> var = get_assigned_name(sys._getframe())
  >>> assert var == 'var'
  ```

  __Available in Python 3.4, 3.5__
  """"""

  SEARCHING, MATCHED = 1, 2
  state = SEARCHING
  result = ''
  stacksize = 0

  for op in dis.get_instructions(frame.f_code):
    if state == SEARCHING and op.offset == frame.f_lasti:
      if not op.opname.startswith('CALL_FUNCTION'):
        raise RuntimeError('get_assigned_name() requires entry at CALL_FUNCTION')
      state = MATCHED

      # For a top-level expression, the stack-size should be 1 after
      # the function at which we entered was executed.
      stacksize = 1
    elif state == MATCHED:
      # Update the would-be size of the stack after this instruction.
      # If we're at zero, we found the last instruction of the expression.
      try:
        stacksize += get_stackdelta(op)
      except KeyError:
        raise RuntimeError('could not determined assigned name, instruction '
            '{} is not supported'.format(op.opname))
      if stacksize == 0:
        if op.opname not in ('STORE_NAME', 'STORE_ATTR', 'STORE_GLOBAL', 'STORE_FAST'):
          raise ValueError('expression is not assigned or branch is not first part of the expression')
        return result + op.argval
      elif stacksize < 0:
        raise ValueError('not a top-level expression')

      if op.opname.startswith('CALL_FUNCTION'):
        # Chained or nested function call.
        raise ValueError('inside a chained or nested function call')
      elif op.opname == 'LOAD_ATTR':
        result += op.argval + '.'

  if not result:
    raise RuntimeError('last frame instruction not found')
  assert False"
267,"def load_actions(spec, group=None, expr_parser=None):
    """"""Each item can be an action name as a string or a dict. When using a dict,
    one key/item pair must be the action name and its options and the rest action
    decorator names and their options.
    Example:
        load_actions([""login_required"", {""flash"": {""message"": ""hello world"", ""label"": ""warning""}}])
    """"""
    if expr_parser is None:
        expr_parser = ExpressionParser()
    actions = ActionList()

    for name in spec:
        options = {}
        as_ = None
        decorators = []

        if isinstance(name, dict):
            actionspec = dict(name)
            as_ = actionspec.pop(""as"", None)
            for dec, dec_cls in action_decorators:
                if dec in actionspec:
                    decorators.append((dec_cls, expr_parser.compile(actionspec.pop(dec))))
            name, options = actionspec.popitem()
            if options:
                options = expr_parser.compile(options)

        if isinstance(name, Action):
            action = name
        elif isinstance(name, ActionFunction):
            action = name.action
        else:
            action = action_resolver.resolve_or_delayed(name, options, group, as_)

        for dec_cls, arg in decorators:
            action = dec_cls(action, arg)

        actions.append(action)

    return actions"
268,"def load_grouped_actions(spec, default_group=None, key_prefix=""actions"", pop_keys=False, expr_parser=None):
    """"""Instanciates actions from a dict. Will look for a key name key_prefix and
    for key starting with key_prefix followed by a dot and a group name. A group
    name can be any string and will can be used later to filter actions.
    Values associated to these keys should be lists that will be loaded using load_actions()
    """"""
    actions = ActionList()
    if expr_parser is None:
        expr_parser = ExpressionParser()
    for key in spec.keys():
        if key != key_prefix and not key.startswith(key_prefix + "".""):
            continue
        group = default_group
        if ""."" in key:
            (_, group) = key.split(""."")
        actions.extend(load_actions(spec[key], group, expr_parser))
        if pop_keys:
            spec.pop(key)
    return actions"
269,"def create_action_from_dict(name, spec, base_class=ActionsAction, metaclass=type, pop_keys=False):
    """"""Creates an action class based on a dict loaded using load_grouped_actions()
    """"""
    actions = load_grouped_actions(spec, pop_keys=pop_keys)
    attrs = {""actions"": actions, ""name"": name}
    if ""as"" in spec:
        attrs[""as_""] = spec[""as""]
        if pop_keys:
            del spec[""as""]
    for k in (""requires"", ""methods"", ""defaults"", ""default_option""):
        if k in spec:
            attrs[k] = spec[k]
            if pop_keys:
                del spec[k]
    return metaclass(name, (base_class,), attrs)"
270,"def plot_stat_summary(df, fig=None):
    '''
    Plot stats grouped by test capacitor load _and_ frequency.

    In other words, we calculate the mean of all samples in the data
    frame for each test capacitance and frequency pairing, plotting
    the following stats:

     - Root mean squared error
     - Coefficient of variation
     - Bias

    ## [Coefficient of variation][1] ##

    > In probability theory and statistics, the coefficient of
    > variation (CV) is a normalized measure of dispersion of a
    > probability distribution or frequency distribution. It is defined
    > as the ratio of the standard deviation to the mean.

    [1]: http://en.wikipedia.org/wiki/Coefficient_of_variation
    '''
    if fig is None:
        fig = plt.figure(figsize=(8, 8))

    # Define a subplot layout, 3 rows, 2 columns
    grid = GridSpec(3, 2)
    stats = calculate_stats(df, groupby=['test_capacitor',
                                         'frequency']).dropna()

    for i, stat in enumerate(['RMSE %', 'cv %', 'bias %']):
        axis = fig.add_subplot(grid[i, 0])
        axis.set_title(stat)
        # Plot a colormap to show how the statistical value changes
        # according to frequency/capacitance pairs.
        plot_colormap(stats, stat, axis=axis, fig=fig)
        axis = fig.add_subplot(grid[i, 1])
        axis.set_title(stat)
        # Plot a histogram to show the distribution of statistical
        # values across all frequency/capacitance pairs.
        try:
            axis.hist(stats[stat].values, bins=50)
        except AttributeError:
            print stats[stat].describe()
    fig.tight_layout()"
271,"def calculate_inverse_document_frequencies(self):
		""""""Q.calculate_inverse_document_frequencies() -- measures how much
		information the term provides, i.e. whether the term is common or
		rare across all documents.

		This is obtained by dividing the total number of documents 
		by the number of documents containing the term, 
		and then taking the logarithm of that quotient.
		""""""
		for doc in self.processed_corpus:
			for word in doc:
				self.inverse_document_frequencies[word] += 1
		for key,value in self.inverse_document_frequencies.iteritems():
			idf = log((1.0 * len(self.corpus)) / value)
			self.inverse_document_frequencies[key] = idf"
272,"def calculate_term_frequencies(self):
		""""""Q.calculate_term_frequencies() -- calculate the number of times 
		each term t occurs in document d.
		""""""
		for doc in self.processed_corpus:
			term_frequency_doc = defaultdict(int)
			for word in doc:
				term_frequency_doc[word] += 1
			
			for key,value in term_frequency_doc.iteritems():
				term_frequency_doc[key] = (1.0 * value) / len(doc)
			self.term_frequencies.append(term_frequency_doc)"
273,"def match_query_to_corpus(self):
		""""""Q.match_query_to_corpus() -> index -- return the matched corpus 
		index of the user query 
		""""""
		ranking = []
		for i,doc in enumerate(self.processed_corpus):
			rank = 0.0
			for word in self.processed_query:
				if word in doc:
					rank += self.term_frequencies[i][word] * self.inverse_document_frequencies[word]
			ranking.append((rank,i))
		matching_corpus_index = 0
		max_rank = 0
		for rank,index in ranking:
			if rank > max_rank:
				matching_corpus_index = index
				max_rank = rank
		return matching_corpus_index"
274,"def process_corpus(self):
		""""""Q.process_corpus() -- processes the queries defined by us, 
		by tokenizing, stemming, and removing stop words.
		""""""
		for doc in self.corpus_list:
			doc = wt(doc)
			sentence = []
			for word in doc:
				if word not in self.stop_words and word not in self.punctuation:
					word = self.stemmer.stem(word)
					sentence.append(word)
			self.processed_corpus.append(sentence)"
275,"def process_query(self):
		""""""Q.process_query() -- processes the user query, 
		by tokenizing and stemming words.
		""""""
		self.query = wt(self.query)
		self.processed_query = []
		for word in self.query:
			if word not in self.stop_words and word not in self.punctuation:
				self.processed_query.append(self.stemmer.stem(word))"
276,"def query(self, query):
		""""""Q.query(query string) -> category string -- return the matched 
		category for any user query
		""""""
		self.query = query
		self.process_query()
		matching_corpus_index = self.match_query_to_corpus()
		return self.category_list[matching_corpus_index].strip()"
277,"def load_manifest(raw_manifest, namespace=None, **kwargs):
    """""" wrapper method which generates the manifest from various sources """"""
    if isinstance(raw_manifest, configparser.RawConfigParser):
        return Manifest(raw_manifest)

    manifest = create_configparser()

    if not manifest.has_section('config'):
        manifest.add_section('config')

    _load_manifest_interpret_source(manifest,
                                    raw_manifest,
                                    **kwargs)
    return Manifest(manifest, namespace=namespace)"
278,"def _load_manifest_interpret_source(manifest, source, username=None, password=None, verify_certificate=True, do_inherit=True):
    """""" Interpret the <source>, and load the results into <manifest> """"""
    try:
        if isinstance(source, string_types):
            if source.startswith(""http""):
                # if manifest is a url
                _load_manifest_from_url(manifest, source,
                                        verify_certificate=verify_certificate,
                                        username=username, password=password)
            else:
                _load_manifest_from_file(manifest, source)
            if not manifest.has_option('config', 'source'):
                manifest.set('config', 'source', str(source))
        else:
            # assume source is a file pointer
            manifest.readfp(source)
        if manifest.has_option('config', 'extends') and do_inherit:
            parent_manifest = configparser.RawConfigParser()
            _load_manifest_interpret_source(parent_manifest,
                                            manifest.get('config', 'extends'),
                                            username=username,
                                            password=password,
                                            verify_certificate=verify_certificate)
            for s in parent_manifest.sections():
                for k, v in parent_manifest.items(s):
                    if not manifest.has_option(s, k):
                        manifest.set(s, k, v)

    except configparser.Error:
        logger.debug("""", exc_info=True)
        error_message = sys.exc_info()[1]
        raise ManifestException(""Unable to parse manifest!: {0}"".format(error_message))"
279,"def _load_manifest_from_url(manifest, url, verify_certificate=True, username=None, password=None):
    """""" load a url body into a manifest """"""
    try:
        if username and password:
            manifest_file_handler = StringIO(lib.authenticated_get(username, password, url,
                                                                   verify=verify_certificate).decode(""utf-8""))
        else:
            manifest_file_handler = StringIO(lib.cleaned_request(
                'get', url, verify=verify_certificate
            ).text)
        manifest.readfp(manifest_file_handler)
    except requests.exceptions.RequestException:
        logger.debug("""", exc_info=True)
        error_message = sys.exc_info()[1]
        raise ManifestException(""There was an error retrieving {0}!\n {1}"".format(url, str(error_message)))"
280,"def _load_manifest_from_file(manifest, path):
    """""" load manifest from file """"""
    path = os.path.abspath(os.path.expanduser(path))
    if not os.path.exists(path):
        raise ManifestException(""Manifest does not exist at {0}!"".format(path))
    manifest.read(path)
    if not manifest.has_option('config', 'source'):
        manifest.set('config', 'source', str(path))"
281,"def formula_sections(self):
        """"""
        Return all sections related to a formula, re-ordered according to the ""depends"" section.
        """"""
        if self.dtree is not None:
            return self.dtree.order
        else:
            return [s for s in self.manifest.sections() if s != ""config""]"
282,"def is_affirmative(self, section, option):
        """"""
        Return true if the section option combo exists and it is set
        to a truthy value.
        """"""
        return self.has_option(section, option) and \
            lib.is_affirmative(self.get(section, option))"
283,"def write(self, file_handle):
        """""" write the current state to a file manifest """"""
        for k, v in self.inputs.write_values().items():
            self.set('config', k, v)
        self.set('config', 'namespace', self.namespace)
        self.manifest.write(file_handle)"
284,"def get_context_dict(self):
        """""" return a context dict of the desired state """"""
        context_dict = {}
        for s in self.sections():
            for k, v in self.manifest.items(s):
                context_dict[""%s:%s"" % (s, k)] = v
        for k, v in self.inputs.values().items():
            context_dict[""config:{0}"".format(k)] = v
        context_dict.update(self.additional_context_variables.items())
        context_dict.update(dict([(""%s|escaped"" % k, re.escape(str(v) or """")) for k, v in context_dict.items()]))
        return context_dict"
285,"def get(self, section, key, default=MANIFEST_NULL_KEY):
        """""" Returns the value if it exist, or default if default is set """"""
        if not self.manifest.has_option(section, key) and default is not MANIFEST_NULL_KEY:
            return default
        return self.manifest.get(section, key)"
286,"def __parse_namespace(self):
        """"""
        Parse the namespace from various sources
        """"""
        if self.manifest.has_option('config', 'namespace'):
            return self.manifest.get('config', 'namespace')
        elif self.manifest.has_option('config', 'source'):
            return NAMESPACE_REGEX.search(self.manifest.get('config', 'source')).groups()[0]
        else:
            logger.warn('Could not parse namespace implicitely')
            return None"
287,"def __generate_dependency_tree(self):
        """"""
        Generate the dependency tree object
        """"""
        dependency_dict = {}
        for s in self.manifest.sections():
            if s != ""config"":
                if self.manifest.has_option(s, 'depends'):
                    dependency_list = [d.strip() for d in re.split('\n|,', self.manifest.get(s, 'depends'))]
                    dependency_dict[s] = dependency_list
                else:
                    dependency_dict[s] = []
        try:
            return DependencyTree(dependency_dict)
        except DependencyTreeException:
            dte = sys.exc_info()[1]
            raise ManifestException(""Dependency tree for manifest is invalid! %s"" % str(dte))"
288,"def __substitute_objects(self, value, context_dict):
        """"""
        recursively substitute value with the context_dict
        """"""
        if type(value) == dict:
            return dict([(k, self.__substitute_objects(v, context_dict)) for k, v in value.items()])
        elif type(value) == str:
            try:
                return value % context_dict
            except KeyError:
                e = sys.exc_info()[1]
                logger.warn(""Could not specialize %s! Error: %s"" % (value, e))
                return value
        else:
            return value"
289,"def __setup_inputs(self):
        """""" Setup the inputs object """"""
        input_object = Inputs()
        # populate input schemas
        for s in self.manifest.sections():
            if self.has_option(s, 'inputs'):
                input_object.add_inputs_from_inputstring(self.get(s, 'inputs'))
        # add in values
        for k, v in self.items('config'):
            if input_object.is_input(s):
                input_object.set_input(k, v)
        return input_object"
290,"def validate(self):
        """"""
        validates the feature configuration, and returns a list of errors (empty list if no error)

        validate should:

        * required variables
        * warn on unused variables

        errors should either be reported via self._log_error(), or raise an exception
        """"""
        if self.target:
            for k in self.target.keys():
                if k in self.deprecated_options:
                    self.logger.warn(
                        self.deprecated_options[k].format(option=k, feature=self.feature_name))
                elif (k not in self.valid_options and k not in self.required_options and
                      '*' not in self.valid_options):
                    self.logger.warn(""Unused option %s in %s!"" % (k, self.feature_name))
            for k in self.required_options:
                if not self.target.has(k):
                    self._log_error(
                        ""Required option %s not present in feature %s!"" % (k, self.feature_name))"
291,"def should_run(self):
        """""" Returns true if the feature should run """"""
        should_run = True
        config = self.target or self.source
        if config.has('systems'):
            should_run = False
            valid_systems = [s.lower() for s in config.get('systems').split("","")]
            for system_type, param in [('is_osx', 'osx'),
                                       ('is_debian', 'debian')]:
                if param in valid_systems and getattr(system, system_type)():
                    should_run = True
        return should_run"
292,"def resolve(self):
        """""" Resolve differences between the target and the source configuration """"""
        if self.source and self.target:
            for key in self.source.keys():
                if (key not in self.dont_carry_over_options
                        and not self.target.has(key)):
                    self.target.set(key, self.source.get(key))"
293,"def _log_error(self, message):
        """""" Log an error for the feature """"""
        key = (self.feature_name, self.target.get('formula'))
        self.environment.log_feature_error(key, ""ERROR: "" + message)"
294,"def _prompt_value(self, key, prompt_string, default=None, only_if_empty=True):
        """"""prompts the user for a value, and saves it to either the target or
        source manifest (whichever is appropriate for the phase)

        this method takes will default to the original value passed by
        the user in the case one exists. e.g. if a user already
        answered 'yes' to a question, it will use 'yes' as the default
        vs the one passed into this method.
        """"""
        main_manifest = self.target or self.source

        if only_if_empty and main_manifest.has(key):
            return main_manifest.get(key)

        prompt_default = default
        if self.source and self.source.has(key):
            prompt_default = self.source.get(key)

        main_manifest.set(key,
                          lib.prompt(prompt_string,
                                     default=prompt_default))"
295,"def jinja_fragment_extension(tag, endtag=None, name=None, tag_only=False, allow_args=True, callblock_args=None):
    """"""Decorator to easily create a jinja extension which acts as a fragment.
    """"""
    if endtag is None:
        endtag = ""end"" + tag

    def decorator(f):
        def parse(self, parser):
            lineno = parser.stream.next().lineno
            args = []
            kwargs = []
            if allow_args:
                args, kwargs = parse_block_signature(parser)

            call = self.call_method(""support_method"", args, kwargs, lineno=lineno)
            if tag_only:
                return nodes.Output([call], lineno=lineno)

            call_args = []
            if callblock_args is not None:
                for arg in callblock_args:
                    call_args.append(nodes.Name(arg, 'param', lineno=lineno))

            body = parser.parse_statements(['name:' + endtag], drop_needle=True)
            return nodes.CallBlock(call, call_args, [], body, lineno=lineno)

        def support_method(self, *args, **kwargs):
            return f(*args, **kwargs)

        attrs = {""tags"": set([tag]), ""parse"": parse, ""support_method"": support_method}
        return type(name or f.__name__, (Extension,), attrs)

    return decorator"
296,"def jinja_block_as_fragment_extension(name, tagname=None, classname=None):
    """"""Creates a fragment extension which will just act as a replacement of the
    block statement.
    """"""
    if tagname is None:
        tagname = name
    if classname is None:
        classname = ""%sBlockFragmentExtension"" % name.capitalize()
    return type(classname, (BaseJinjaBlockAsFragmentExtension,), {
        ""tags"": set([tagname]), ""end_tag"": ""end"" + tagname, ""block_name"": name})"
297,"def dir_visitor(dirname, visitor):
    """"""
    _dir_visitor_

    walk through all files in dirname, find
    directories and call the callable on them.

    :param dirname: Name of directory to start visiting,
      all subdirs will be visited
    :param visitor: Callable invoked on each dir visited
    """"""
    visitor(dirname)
    for obj in os.listdir(dirname):
        obj_path = os.path.join(dirname, obj)
        if os.path.isdir(obj_path):
            dir_visitor(obj_path, visitor)"
298,"def replicate_directory_tree(input_dir, output_dir):
    """"""
    _replicate_directory_tree_

    clone dir structure under input_dir into output dir
    All subdirs beneath input_dir will be created under
    output_dir
    :param input_dir: path to dir tree to be cloned
    :param output_dir: path to new dir where dir structure will
       be created
    """"""
    def transplant_dir(target, dirname):
        x = dirname.replace(input_dir, target)
        if not os.path.exists(x):
            LOGGER.info('Creating: {}'.format(x))
            os.makedirs(x)

    dir_visitor(
        input_dir,
        functools.partial(transplant_dir, output_dir)
    )"
299,"def find_templates(input_dir):
    """"""
    _find_templates_

    traverse the input_dir structure and return a list
    of template files ending with .mustache

    :param input_dir: Path to start recursive search for
       mustache templates
    :returns: List of file paths corresponding to templates
    """"""
    templates = []

    def template_finder(result, dirname):
        for obj in os.listdir(dirname):
            if obj.endswith('.mustache'):
                result.append(os.path.join(dirname, obj))

    dir_visitor(
        input_dir,
        functools.partial(template_finder, templates)
    )
    return templates"
300,"def find_copies(input_dir, exclude_list):
    """"""
    find files that are not templates and not
    in the exclude_list for copying from template to image
    """"""
    copies = []

    def copy_finder(copies, dirname):
        for obj in os.listdir(dirname):
            pathname = os.path.join(dirname, obj)
            if os.path.isdir(pathname):
                continue
            if obj in exclude_list:
                continue
            if obj.endswith('.mustache'):
                continue

            copies.append(os.path.join(dirname, obj))

    dir_visitor(
        input_dir,
        functools.partial(copy_finder, copies)
    )
    return copies"
301,"def render_template(template_in, file_out, context):
    """"""
    _render_template_

    Render a single template file, using the context provided
    and write the file out to the location specified

    #TODO: verify the template is completely rendered, no
       missing values

    """"""
    renderer = pystache.Renderer()
    result = renderer.render_path(template_in, context)
    with open(file_out, 'w') as handle:
        LOGGER.info('Rendering: {} to {}'.format(template_in, file_out))
        handle.write(result)
    shutil.copymode(template_in, file_out)"
302,"def copy_file(src, target):
    """"""
    copy_file

    copy source to target

    """"""
    LOGGER.info(""Copying {} to {}"".format(src, target))
    shutil.copyfile(src, target)
    shutil.copymode(src, target)"
303,"def process_templates(input_dir, target_dir, context):
    """"""
    _process_templates_

    Given the input dir containing a set of template,
    clone the structure under that directory into the target dir
    using the context to process any mustache templates that
    are encountered

    """"""
    if not target_dir.endswith('/'):
        target_dir = ""{}/"".format(target_dir)
    if not os.path.exists(target_dir):
        LOGGER.info('Creating: {}'.format(target_dir))
        os.makedirs(target_dir)
    replicate_directory_tree(input_dir, target_dir)
    templates = find_templates(input_dir)
    for templ in templates:
        output_file = templ.replace(input_dir, target_dir)
        output_file = output_file[:-len('.mustache')]
        render_template(templ,  output_file, context)"
304,"def process_copies(input_dir, target_dir, excludes):
    """"""
    _process_copies_

    Handles files to be copied across, assumes
    that dir structure has already been replicated

    """"""
    copies = find_copies(input_dir, excludes)
    for c in copies:
        output_file = c.replace(input_dir, target_dir)
        copy_file(c,  output_file)"
305,"def newDevice(deviceJson, lupusec):
    """"""Create new device object for the given type.""""""
    type_tag = deviceJson.get('type')

    if not type_tag:
        _LOGGER.info('Device has no type')

    if type_tag in CONST.TYPE_OPENING:
        return LupusecBinarySensor(deviceJson, lupusec)
    elif type_tag in CONST.TYPE_SENSOR:
        return LupusecBinarySensor(deviceJson, lupusec)
    elif type_tag in CONST.TYPE_SWITCH:
        return LupusecSwitch(deviceJson, lupusec)
    else:
        _LOGGER.info('Device is not known')
    return None"
306,"def get_devices(self, refresh=False, generic_type=None):
        """"""Get all devices from Lupusec.""""""
        _LOGGER.info(""Updating all devices..."")
        if refresh or self._devices is None:
            if self._devices is None:
                self._devices = {}

            responseObject = self.get_sensors()
            if (responseObject and
                    not isinstance(responseObject, (tuple, list))):
                responseObject = responseObject

            for deviceJson in responseObject:
                # Attempt to reuse an existing device
                device = self._devices.get(deviceJson['name'])

                # No existing device, create a new one
                if device:
                    device.update(deviceJson)
                else:
                    device = newDevice(deviceJson, self)

                    if not device:
                        _LOGGER.info('Device is unknown')
                        continue

                    self._devices[device.device_id] = device

            # We will be treating the Lupusec panel itself as an armable device.
            panelJson = self.get_panel()
            _LOGGER.debug(""Get the panel in get_devices: %s"", panelJson)

            self._panel.update(panelJson)

            alarmDevice = self._devices.get('0')

            if alarmDevice:
                alarmDevice.update(panelJson)
            else:
                alarmDevice = ALARM.create_alarm(panelJson, self)
                self._devices['0'] = alarmDevice

            # Now we will handle the power switches
            switches = self.get_power_switches()
            _LOGGER.debug(
                'Get active the power switches in get_devices: %s', switches)

            for deviceJson in switches:
                # Attempt to reuse an existing device
                device = self._devices.get(deviceJson['name'])

                # No existing device, create a new one
                if device:
                    device.update(deviceJson)
                else:
                    device = newDevice(deviceJson, self)
                    if not device:
                        _LOGGER.info('Device is unknown')
                        continue
                    self._devices[device.device_id] = device

        if generic_type:
            devices = []
            for device in self._devices.values():
                if (device.type is not None and
                        device.type in generic_type[0]):
                    devices.append(device)
            return devices

        return list(self._devices.values())"
307,"def parse_from_dict(json_dict):
    """"""
    Given a Unified Uploader message, parse the contents and return a
    MarketHistoryList instance.

    :param dict json_dict: A Unified Uploader message as a dict.
    :rtype: MarketOrderList
    :returns: An instance of MarketOrderList, containing the orders
        within.
    """"""
    history_columns = json_dict['columns']

    history_list = MarketHistoryList(
        upload_keys=json_dict['uploadKeys'],
        history_generator=json_dict['generator'],
    )

    for rowset in json_dict['rowsets']:
        generated_at = parse_datetime(rowset['generatedAt'])
        region_id = rowset['regionID']
        type_id = rowset['typeID']
        history_list.set_empty_region(region_id, type_id, generated_at)

        for row in rowset['rows']:
            history_kwargs = _columns_to_kwargs(
                SPEC_TO_KWARG_CONVERSION, history_columns, row)
            historical_date = parse_datetime(history_kwargs['historical_date'])

            history_kwargs.update({
                'type_id': type_id,
                'region_id': region_id,
                'historical_date': historical_date,
                'generated_at': generated_at,
            })

            history_list.add_entry(MarketHistoryEntry(**history_kwargs))

    return history_list"
308,"def encode_to_json(history_list):
    """"""
    Encodes this MarketHistoryList instance to a JSON string.

    :param MarketHistoryList history_list: The history instance to serialize.
    :rtype: str
    """"""
    rowsets = []
    for items_in_region_list in history_list._history.values():
        region_id = items_in_region_list.region_id
        type_id = items_in_region_list.type_id
        generated_at = gen_iso_datetime_str(items_in_region_list.generated_at)

        rows = []
        for entry in items_in_region_list.entries:
            historical_date = gen_iso_datetime_str(entry.historical_date)

            # The order in which these values are added is crucial. It must
            # match STANDARD_ENCODED_COLUMNS.
            rows.append([
                historical_date,
                entry.num_orders,
                entry.total_quantity,
                entry.low_price,
                entry.high_price,
                entry.average_price,
            ])

        rowsets.append(dict(
            generatedAt = generated_at,
            regionID = region_id,
            typeID = type_id,
            rows = rows,
        ))

    json_dict = {
        'resultType': 'history',
        'version': '0.1',
        'uploadKeys': history_list.upload_keys,
        'generator': history_list.history_generator,
        'currentTime': gen_iso_datetime_str(now_dtime_in_utc()),
        # This must match the order of the values in the row assembling portion
        # above this.
        'columns': STANDARD_ENCODED_COLUMNS,
        'rowsets': rowsets,
    }

    return json.dumps(json_dict)"
309,"def load(self, configuration):
        """"""
        Load a YAML configuration file.

        :param configuration: Configuration filename or YAML string
        """"""
        try:
            self.config = yaml.load(open(configuration, ""rb""))
        except IOError:
            try:
                self.config = yaml.load(configuration)
            except ParserError, e:
                raise ParserError('Error parsing config: %s' % e)

        # put customer data into self.customer
        if isinstance(self.config, dict):
            self.customer = self.config.get('customer', {})
            self.instances_dict = self.config.get('instances', {})
            self.web2py_dir = self.config.get('web2py', None)
            self.api_type = self.config.get('api_type', 'jsonrpc')
            self.valid = True
        else:
            self.customer = {}
            self.instances_dict = {}
            self.web2py_dir = None
            self.valid = False"
310,"def instances(self, test_type="".*""):
        """"""
        Returns a dict of all instances defined using a regex

        :param test_type: Regular expression to match for self.instance['test_type'] value names
        """"""
        import re
        data = {}
        for k, v in self.instances_dict.iteritems():
            if re.match(test_type, v.get('test_type'), re.IGNORECASE):
                if 'filter_type' in v:
                    hostfilter = {
                        'filtertype': v['filter_type'],
                        'content': v['filter_value']
                    }
                else:
                    hostfilter = {}
                data[k] = {
                    'name': v.get('name'),
                    'start': v.get('start'),
                    'end': v.get('end'),
                    'url': v.get('url'),
                    'hostfilter': hostfilter,
                    'test_type': v.get('test_type')
                }
        return data"
311,"def none_to_blank(s, exchange=''):
    """"""Replaces NoneType with ''

    >>> none_to_blank(None, '')
    ''
    >>> none_to_blank(None)
    ''
    >>> none_to_blank('something', '')
    u'something'
    >>> none_to_blank(['1', None])
    [u'1', '']

    :param s: String to replace
    :para exchange: Character to return for None, default is blank ('')
    :return: If s is None, returns exchange
    """"""
    if isinstance(s, list):
        return [none_to_blank(z) for y, z in enumerate(s)]
    return exchange if s is None else unicode(s)"
312,"def make_good_url(url=None, addition=""/""):
    """"""Appends addition to url, ensuring the right number of slashes
    exist and the path doesn't get clobbered.

    >>> make_good_url('http://www.server.com/anywhere', 'else')
    'http://www.server.com/anywhere/else'
    >>> make_good_url('http://test.com/', '/somewhere/over/the/rainbow/')
    'http://test.com/somewhere/over/the/rainbow/'
    >>> make_good_url('None')
    'None/'
    >>> make_good_url()
    >>> make_good_url({})
    >>> make_good_url(addition='{}')

    :param url: URL
    :param addition: Something to add to the URL
    :return: New URL with addition""""""

    if url is None:
        return None

    if isinstance(url, str) and isinstance(addition, str):
        return ""%s/%s"" % (url.rstrip('/'), addition.lstrip('/'))
    else:
        return None"
313,"def build_kvasir_url(
        proto=""https"", server=""localhost"", port=""8443"",
        base=""Kvasir"", user=""test"", password=""test"",
        path=KVASIR_JSONRPC_PATH):
    """"""
    Creates a full URL to reach Kvasir given specific data

    >>> build_kvasir_url('https', 'localhost', '8443', 'Kvasir', 'test', 'test')
    'https://test@test/localhost:8443/Kvasir/api/call/jsonrpc'
    >>> build_kvasir_url()
    'https://test@test/localhost:8443/Kvasir/api/call/jsonrpc'
    >>> build_kvasir_url(server='localhost', port='443', password='password', path='bad/path')
    'https://test@password/localhost:443/Kvasir/bad/path'

    :param proto: Protocol type - http or https
    :param server: Hostname or IP address of Web2py server
    :param port: Port to reach server
    :param base: Base application name
    :param user: Username for basic auth
    :param password: Password for basic auth
    :param path: Full path to JSONRPC (/api/call/jsonrpc)
    :return: A full URL that can reach Kvasir's JSONRPC interface
    """"""
    uri = proto + '://' + user + '@' + password + '/' + server + ':' + port + '/' + base
    return make_good_url(uri, path)"
314,"def get_default(parser, section, option, default):
    """"""helper to get config settings with a default if not present""""""
    try:
        result = parser.get(section, option)
    except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
        result = default
    return result"
315,"def set_db_application_prefix(prefix, sep=None):
    """"""Set the global app prefix and separator.""""""
    global _APPLICATION_PREFIX, _APPLICATION_SEP
    _APPLICATION_PREFIX = prefix
    if (sep is not None):
        _APPLICATION_SEP = sep"
316,"def find_by_index(self, cls, index_name, value):
        """"""Find records matching index query - defer to backend.""""""
        return self.backend.find_by_index(cls, index_name, value)"
317,"def humanTime(seconds):
  '''
  Convert seconds to something more human-friendly
  '''
  intervals = ['days', 'hours', 'minutes', 'seconds']
  x = deltaTime(seconds=seconds)
  return ' '.join('{} {}'.format(getattr(x, k), k) for k in intervals if getattr(x, k))"
318,"def humanTimeConverter():
  '''
  Cope whether we're passed a time in seconds on the command line or via stdin
  '''
  if len(sys.argv) == 2:
    print humanFriendlyTime(seconds=int(sys.argv[1]))
  else:
    for line in sys.stdin:
      print humanFriendlyTime(int(line))
      sys.exit(0)"
319,"def train(self, data, **kwargs):
        """"""
        Calculate the standard deviations and means in the training data
        """"""
        self.data = data
        for i in xrange(0,data.shape[1]):
            column_mean = np.mean(data.icol(i))
            column_stdev = np.std(data.icol(i))

            #Have to do += or ""list"" type will fail (ie with append)
            self.column_means += [column_mean]
            self.column_stdevs += [column_stdev]

        self.data = self.predict(data)"
320,"def predict(self, test_data, **kwargs):
        """"""
        Adjust new input by the values in the training data
        """"""
        if test_data.shape[1]!=self.data.shape[1]:
            raise Exception(""Test data has different number of columns than training data."")
        for i in xrange(0,test_data.shape[1]):
            test_data.loc[:,i] = test_data.icol(i) - self.column_means[i]
            if int(self.column_stdevs[i])!=0:
                test_data.loc[:,i] = test_data.icol(i) / self.column_stdevs[i]
        return test_data"
321,"def action_decorator(name):
    """"""Decorator to register an action decorator
    """"""
    def decorator(cls):
        action_decorators.append((name, cls))
        return cls
    return decorator"
322,"def load_global_config(config_path):
    """""" Load a global configuration object, and query for any required variables along the way """"""
    config = configparser.RawConfigParser()
    if os.path.exists(config_path):
        logger.debug(""Checking and setting global parameters..."")
        config.read(config_path)
    else:
        _initial_run()
        logger.info(""Unable to find a global sprinter configuration!"")
        logger.info(""Creating one now. Please answer some questions"" +
                    "" about what you would like sprinter to do."")
        logger.info("""")
    # checks and sets sections
    if not config.has_section('global'):
        config.add_section('global')

    configure_config(config)
    write_config(config, config_path)

    return config"
323,"def print_global_config(global_config):
    """""" print the global configuration """"""
    if global_config.has_section('shell'):
        print(""\nShell configurations:"")
        for shell_type, set_value in global_config.items('shell'):
            print(""{0}: {1}"".format(shell_type, set_value))

    if global_config.has_option('global', 'env_source_rc'):
        print(""\nHave sprinter env source rc: {0}"".format(
            global_config.get('global', 'env_source_rc')))"
324,"def create_default_config():
    """""" Create a default configuration object, with all parameters filled """"""
    config = configparser.RawConfigParser()
    config.add_section('global')
    config.set('global', 'env_source_rc', False)
    config.add_section('shell')
    config.set('shell', 'bash', ""true"")
    config.set('shell', 'zsh', ""true"")
    config.set('shell', 'gui', ""true"")
    return config"
325,"def _initial_run():
    """""" Check things during the initial setting of sprinter's global config """"""
    if not system.is_officially_supported():
        logger.warn(warning_template
                    + ""===========================================================\n""
                    + ""Sprinter is not officially supported on {0}! Please use at your own risk.\n\n"".format(system.operating_system())
                    + ""You can find the supported platforms here:\n""
                    + ""(http://sprinter.readthedocs.org/en/latest/index.html#compatible-systems)\n\n""
                    + ""Conversely, please help us support your system by reporting on issues\n""
                    + ""(http://sprinter.readthedocs.org/en/latest/faq.html#i-need-help-who-do-i-talk-to)\n""
                    + ""==========================================================="")
    else:
        logger.info(
            ""\nThanks for using \n"" +
            ""="" * 60 +
            sprinter_template +
            ""="" * 60
        )"
326,"def _configure_shell(config):
    """""" Checks and queries values for the shell """"""
    config.has_section('shell') or config.add_section('shell')
    logger.info(
        ""What shells or environments would you like sprinter to work with?\n""
        ""(Sprinter will not try to inject into environments not specified here.)\n""
        ""If you specify 'gui', sprinter will attempt to inject it's state into graphical programs as well.\n""
        ""i.e. environment variables sprinter set will affect programs as well, not just shells\n""
        ""WARNING: injecting into the GUI can be very dangerous. it usually requires a restart\n""
        "" to modify any environmental configuration.""
    )
    environments = list(enumerate(sorted(SHELL_CONFIG), start=1))
    logger.info(""[0]: All, "" + "", "".join([""[%d]: %s"" % (index, val) for index, val in environments]))
    desired_environments = lib.prompt(""type the environment, comma-separated"", default=""0"")
    for index, val in environments:
        if str(index) in desired_environments or ""0"" in desired_environments:
            config.set('shell', val, 'true')
        else:
            config.set('shell', val, 'false')"
327,"def _configure_env_source_rc(config):
    """""" Configures wether to have .env source .rc """"""
    config.set('global', 'env_source_rc', False)
    if system.is_osx():
        logger.info(""On OSX, login shells are default, which only source sprinter's 'env' configuration."")
        logger.info(""I.E. environment variables would be sourced, but not shell functions ""
                    + ""or terminal status lines."")
        logger.info(""The typical solution to get around this is to source your rc file (.bashrc, .zshrc) ""
                    + ""from your login shell."")
        env_source_rc = lib.prompt(""would you like sprinter to source the rc file too?"", default=""yes"",
                                   boolean=True)
        config.set('global', 'env_source_rc', env_source_rc)"
328,"def get_members(self):
        """"""Return all members in the group as CSHMember objects""""""
        res = self.__con__.search_s(
                self.__ldap_base_dn__,
                ldap.SCOPE_SUBTREE,
                ""(memberof=%s)"" % self.__dn__,
                ['uid'])

        ret = []
        for val in res:
            val = val[1]['uid'][0]
            try:
                ret.append(val.decode('utf-8'))
            except UnicodeDecodeError:
                ret.append(val)
            except KeyError:
                continue

        return [CSHMember(self.__lib__,
                result,
                uid=True)
                for result in ret]"
329,"def check_member(self, member, dn=False):
        """"""Check if a Member is in the bound group.

        Arguments:
        member -- the CSHMember object (or distinguished name) of the member to
                  check against

        Keyword arguments:
        dn -- whether or not member is a distinguished name
        """"""

        if dn:
            res = self.__con__.search_s(
                    self.__dn__,
                    ldap.SCOPE_BASE,
                    ""(member=%s)"" % dn,
                    ['ipaUniqueID'])
        else:
            res = self.__con__.search_s(
                    self.__dn__,
                    ldap.SCOPE_BASE,
                    ""(member=%s)"" % member.get_dn(),
                    ['ipaUniqueID'])
        return len(res) > 0"
330,"def add_member(self, member, dn=False):
        """"""Add a member to the bound group

        Arguments:
        member -- the CSHMember object (or distinguished name) of the member

        Keyword arguments:
        dn -- whether or not member is a distinguished name
        """"""

        if dn:
            if self.check_member(member, dn=True):
                return
            mod = (ldap.MOD_ADD, 'member', member.encode('ascii'))
        else:
            if self.check_member(member):
                return
            mod = (ldap.MOD_ADD, 'member', member.get_dn().encode('ascii'))

        if self.__lib__.__batch_mods__:
            self.__lib__.enqueue_mod(self.__dn__, mod)
        elif not self.__lib__.__ro__:
            mod_attrs = [mod]
            self.__con__.modify_s(self.__dn__, mod_attrs)
        else:
            print(""ADD VALUE member = {} FOR {}"".format(mod[2], self.__dn__))"
331,"def read_object_from_yaml(desired_type: Type[Any], file_object: TextIOBase, logger: Logger,
                          fix_imports: bool = True, errors: str = 'strict', *args, **kwargs) -> Any:
    """"""
    Parses a yaml file.

    :param desired_type:
    :param file_object:
    :param logger:
    :param fix_imports:
    :param errors:
    :param args:
    :param kwargs:
    :return:
    """"""
    return yaml.load(file_object)"
332,"def read_collection_from_yaml(desired_type: Type[Any], file_object: TextIOBase, logger: Logger,
                              conversion_finder: ConversionFinder, fix_imports: bool = True, errors: str = 'strict',
                              **kwargs) -> Any:
    """"""
    Parses a collection from a yaml file.

    :param desired_type:
    :param file_object:
    :param logger:
    :param fix_imports:
    :param errors:
    :param args:
    :param kwargs:
    :return:
    """"""
    res = yaml.load(file_object)

    # convert if required
    return ConversionFinder.convert_collection_values_according_to_pep(res, desired_type, conversion_finder, logger,
                                                                       **kwargs)"
333,"def get_default_yaml_parsers(parser_finder: ParserFinder, conversion_finder: ConversionFinder) -> List[AnyParser]:
    """"""
    Utility method to return the default parsers able to parse an object from a file.
    Note that MultifileObjectParser is not provided in this list, as it is already added in a hardcoded way in
    RootParser
    :return:
    """"""
    return [# yaml for any object
            SingleFileParserFunction(parser_function=read_object_from_yaml,
                                     streaming_mode=True,
                                     supported_exts={'.yaml','.yml'},
                                     supported_types={AnyObject},
                                     ),
            # yaml for collection objects
            SingleFileParserFunction(parser_function=read_collection_from_yaml,
                                     custom_name='read_collection_from_yaml',
                                     streaming_mode=True,
                                     supported_exts={'.yaml','.yml'},
                                     supported_types={Tuple, Dict, List, Set},
                                     function_args={'conversion_finder': conversion_finder}
                                     )
    ]"
334,"def pass_feature(*feature_names):
    """"""Injects a feature instance into the kwargs
    """"""
    def decorator(f):
        @functools.wraps(f)
        def wrapper(*args, **kwargs):
            for name in feature_names:
                kwargs[name] = feature_proxy(name)
            return f(*args, **kwargs)
        return wrapper
    return decorator"
335,"def extract_tar(url, target_dir, additional_compression="""", remove_common_prefix=False, overwrite=False):
    """""" extract a targz and install to the target directory """"""
    try:
        if not os.path.exists(target_dir):
            os.makedirs(target_dir)
        tf = tarfile.TarFile.open(fileobj=download_to_bytesio(url))
        if not os.path.exists(target_dir):
            os.makedirs(target_dir)
        common_prefix = os.path.commonprefix(tf.getnames())
        if not common_prefix.endswith('/'):
            common_prefix += ""/""
        for tfile in tf.getmembers():
            if remove_common_prefix:
                tfile.name = tfile.name.replace(common_prefix, """", 1)
            if tfile.name != """":
                target_path = os.path.join(target_dir, tfile.name)
                if target_path != target_dir and os.path.exists(target_path):
                    if overwrite:
                        remove_path(target_path)
                    else:
                        continue
                tf.extract(tfile, target_dir)
    except OSError:
        e = sys.exc_info()[1]
        raise ExtractException(str(e))
    except IOError:
        e = sys.exc_info()[1]
        raise ExtractException(str(e))"
336,"def remove_path(target_path):
    """""" Delete the target path """"""
    if os.path.isdir(target_path):
        shutil.rmtree(target_path)
    else:
        os.unlink(target_path)"
337,"def ids(cls, values, itype=None):
        '''
        http://www.elasticsearch.org/guide/reference/query-dsl/ids-filter.html
Filters documents that only have the provided ids. Note, this filter does not require the _id field to be indexed since it works using the _uid field.

        '''
        instance = cls(ids={'values': values})
        if itype is not None:
            instance['ids']['type'] = itype

        return instance"
338,"def geo_bounding_box(cls, field, top_left, bottom_right):
        '''
        http://www.elasticsearch.org/guide/reference/query-dsl/geo-bounding-box-filter.html

        > bounds = ElasticFilter().geo_bounding_box('pin.location', [40.73, -74.1], [40.717, -73.99])
        > bounds = ElasticFilter().geo_bounding_box('pin.location', dict(lat=40.73, lon=-74.1), dict(lat=40.717, lon=-73.99))
        > bounds = ElasticFilter().geo_bounding_box('pin.location', ""40.73, -74.1"", ""40.717, -73.99"")
        And geohash
        > bounds = ElasticFilter().geo_bounding_box('pin.location', ""drm3btev3e86"", ""drm3btev3e86"")

        '''
        return cls(geo_bounding_box={field: {'top_left': top_left, 'bottom_right': bottom_right}})"
339,"def geo_distance(cls, field, center, distance, distance_type=None):
        '''
        http://www.elasticsearch.org/guide/reference/query-dsl/geo-distance-filter.html
        Filters documents that include only hits that exists within a specific distance from a geo point.
        field - Field name
        center - Center point (Geo point)
        distance - String for the distance
        distance_type - (arc | plane) How to compute the distance. Can either be arc (better precision) or plane (faster). Defaults to arc
        > bounds = ElasticFilter().geo_distance('pin.location', [40.73, -74.1], '300km')
        '''

        instance = cls(geo_distance={'distance': distance, field: center})
        if distance_type is not None:
            instance['geo_distance']['distance_type'] = distance_type
        return instance"
340,"def geo_distance_range(cls, field, center, from_distance, to_distance, distance_type=None):
        '''
        http://www.elasticsearch.org/guide/reference/query-dsl/geo-distance-range-filter.html
        Filters documents that exists within a range from a specific point


        '''
        instance = cls(geo_distance_range={'from': from_distance, 'to': to_distance, field: center})
        if distance_type is not None:
            instance['geo_distance_range']['distance_type'] = distance_type
        return instance"
341,"def numeric_range(cls, field, from_value, to_value, include_lower=None, include_upper=None):
        '''
        http://www.elasticsearch.org/guide/reference/query-dsl/numeric-range-filter.html
        Filters documents with fields that have values within a certain numeric range. Similar to range filter, except that it works only with numeric values, and the filter execution works differently.
        '''
        instance = cls(numeric_range={field: {'from': from_value, 'to': to_value}})
        if include_lower is not None:
            instance['numeric_range'][field]['include_lower'] = include_lower
        if include_upper is not None:
            instance['numeric_range'][field]['include_upper'] = include_upper
        return instance"
342,"def range(cls, field, from_value=None, to_value=None, include_lower=None, include_upper=None):
        '''
        http://www.elasticsearch.org/guide/reference/query-dsl/range-filter.html

        Filters documents with fields that have terms within a certain range. Similar to range query, except that it acts as a filter. Can be placed within queries that accept a filter.
        '''

        instance = cls({'range': {field: {}}})
        if from_value is not None:
            instance['range'][field]['from'] = from_value
        if to_value is not None:
            instance['range'][field]['to'] = to_value
        if include_lower is not None:
            instance['range'][field]['include_lower'] = include_lower
        if include_upper is not None:
            instance['range'][field]['include_upper'] = include_upper

        return instance"
343,"def save(self, obj, id_code):
        """"""
        Save an object, and use id_code in the filename
        obj - any object
        id_code - unique identifier
        """"""
        filestream = open('{0}/{1}'.format(self.data_path, id_code), 'w+')
        pickle.dump(obj, filestream)
        filestream.close()"
344,"def load(self, id_code):
        """"""
        Loads a workflow identified by id_code
        id_code - unique identifier, previously must have called save with same id_code
        """"""
        filestream = open('{0}/{1}'.format(self.data_path, id_code), 'rb')
        workflow = pickle.load(filestream)
        return workflow"
345,"def init(self):
        """"""init `todo` file
        if file exists, then initialization self.todos
        and record current max index of todos
        : when add a new todo, the `idx` via only `self.current_max_idx + 1`
        """"""
        if os.path.isdir(self.path):
            raise InvalidTodoFile
        if os.path.exists(self.path):
            with open(self.path, 'r') as f:
                tls = [tl.strip() for tl in f if tl]
                todos = map(_todo_from_file, tls)
                self.todos = todos
                for todo in todos:
                    if self.current_max_idx < todo['idx']:
                        self.current_max_idx = todo['idx']
        else:
            logger.warning('No todo files found, initialization a empty todo file')
            with open(self.path, 'w') as f:
                f.flush()"
346,"def _show(self, status=None, idx=None):
        """"""show todos after format
        :param status: what status's todos wants to show.
        default is None, means show all
        """"""
        _show('', 50)
        if not self.todos:
            self._show_no_todos()
        elif idx is not None:
            for todo in self.todos:
                if todo['idx'] == idx:
                    self._show_todos(todo)
        elif status is not None:
            if status not in STATUS_CODE:
                raise InvalidTodoStatus
            _todos = []
            for todo in self.todos:
                if todo['status'] == status:
                    _todos.append(todo)
            if not _todos:
                self._show_no_todos(text_fix='No {} todos...'.format(
                                    STATUS_CODE.get(status, None)))
            else:
                for todo in _todos:
                    self._show_todos(todo)
        else:
            for todo in self.todos:
                self._show_todos(todo)
        _show('', 50)"
347,"def write(self, delete_if_empty=False):
        """"""flush todos to file
        :param delete_if_empty: delete if todo is empty
        """"""
        with open(self.path, 'w') as f:
            if not self.todos:
                f.flush()
            else:
                for todo in _todo_to_file(self.todos):
                    f.write(todo)"
348,"def read_object_from_pickle(desired_type: Type[T], file_path: str, encoding: str,
                            fix_imports: bool = True, errors: str = 'strict', *args, **kwargs) -> Any:
    """"""
    Parses a pickle file.

    :param desired_type:
    :param file_path:
    :param encoding:
    :param fix_imports:
    :param errors:
    :param args:
    :param kwargs:
    :return:
    """"""
    import pickle
    file_object = open(file_path, mode='rb')
    try:
        return pickle.load(file_object, fix_imports=fix_imports, encoding=encoding, errors=errors)
    finally:
        file_object.close()"
349,"def should_display_warnings_for(to_type):
    """""" Central method where we control whether warnings should be displayed """"""
    if not hasattr(to_type, '__module__'):
        return True
    elif to_type.__module__ in {'builtins'} or to_type.__module__.startswith('parsyfiles') \
            or to_type.__name__ in {'DataFrame'}:
        return False
    elif issubclass(to_type, int) or issubclass(to_type, str) \
            or issubclass(to_type, float) or issubclass(to_type, bool):
        return False
    else:
        return True"
350,"def _is_valid_for_dict_to_object_conversion(strict_mode: bool, from_type: Type, to_type: Type) -> bool:
    """"""
    Returns true if the provided types are valid for dict_to_object conversion

    Explicitly declare that we are not able to parse collections nor able to create an object from a dictionary if the
    object's constructor is non correctly PEP484-specified.

    None should be treated as a Joker here (but we know that never from_type and to_type will be None at the same time)

    :param strict_mode:
    :param from_type:
    :param to_type:
    :return:
    """"""
    # cache previous results
    try:
        res, subclasses_hash = _cache_valid_for_dict_to_object[to_type][strict_mode]
        # Check if are any new subclasses are available
        if not strict_mode and to_type is not None and not is_any_type(to_type):
            if hash(tuple(get_all_subclasses(to_type))) != subclasses_hash:
                raise KeyError('fake error to recompute the cache entry')
    except KeyError:
        res = __is_valid_for_dict_to_object_conversion(strict_mode=strict_mode, from_type=from_type, to_type=to_type)
        # Store an entry in the cache containing the result and the hash of the subclasses list
        subclasses_hash = None
        if not strict_mode and to_type is not None and not is_any_type(to_type):
            subclasses_hash = hash(tuple(get_all_subclasses(to_type)))
        entry = (res, subclasses_hash)
        try:
            _cache_valid_for_dict_to_object[to_type][strict_mode] = entry
        except KeyError:
            _cache_valid_for_dict_to_object[to_type] = {strict_mode: entry}
    return res"
351,"def __is_valid_for_dict_to_object_conversion(strict_mode: bool, from_type: Type, to_type: Type) -> bool:
    """"""
    Returns true if the provided types are valid for dict_to_object conversion

    Explicitly declare that we are not able to parse collections nor able to create an object from a dictionary if the
    object's constructor is non correctly PEP484-specified.

    None should be treated as a Joker here (but we know that never from_type and to_type will be None at the same time)

    :param strict_mode:
    :param from_type:
    :param to_type:
    :return:
    """"""
    # right now we're stuck with the default logger..
    logr = default_logger

    if to_type is None or is_any_type(to_type):
        # explicitly handle the 'None' (joker) or 'any' type
        return True

    elif is_collection(to_type, strict=True):
        # if the destination type is 'strictly a collection' (not a subclass of a collection) we know that we can't
        # handle it here, the constructor is not pep484-typed
        return False

    else:
        # (1) Try the type itself
        try:
            # can we find enough pep-484 information in the constructor to be able to understand what is required ?
            get_constructor_attributes_types(to_type)
            return True
        except TypeInformationRequiredError as main_e:
            # # failed: we cant guess the required types of constructor arguments
            # if strict_mode:
            #     # Warning and return NO
            #     if should_display_warnings_for(to_type):
            #         logr.warn('Object constructor signature for type {} does not allow parsyfiles to '
            #                    'automatically create instances from dict content. Caught {}: {}'
            #                    ''.format(get_pretty_type_str(to_type), type(main_e).__name__, main_e))
            #     return False
            #
            # # non-strict mode: (2) Check if any subclasses exist
            # subclasses = get_all_subclasses(to_type)
            # if len(subclasses) > GLOBAL_CONFIG.dict_to_object_subclass_limit:
            #     logr.warn('WARNING: Type {} has {} subclasses, only {} will be tried by parsyfiles when attempting to '
            #               'create it from a subclass. You can raise this limit by setting the appropriate option with '
            #               '`parsyfiles_global_config()`'
            #               ''.format(to_type, len(subclasses), GLOBAL_CONFIG.dict_to_object_subclass_limit))
            #
            # # Then for each subclass also try (with a configurable limit in nb of subclasses)
            # for subclass in subclasses[0:GLOBAL_CONFIG.dict_to_object_subclass_limit]:
            #     try:
            #         get_constructor_attributes_types(subclass)
            #         # OK, but issue warning for the root type still
            #         if should_display_warnings_for(to_type):
            #             logr.warn('WARNING: Object constructor signature for type {} does not allow parsyfiles to '
            #                       'automatically create instances from dict content, but it can for at least one of '
            #                       'its subclasses ({}) so it might be ok for you. Caught {}: {}'
            #                       ''.format(get_pretty_type_str(to_type), get_pretty_type_str(subclass),
            #                                  type(main_e).__name__, main_e))
            #         return True
            #     except TypeInformationRequiredError as e:
            #         # failed: we cant guess the required types of constructor arguments
            #         if should_display_warnings_for(to_type):
            #             logr.warn('WARNING: Object constructor signature for type {} does not allow parsyfiles to '
            #                       'automatically create instances from dict content. Caught {}: {}'
            #                       ''.format(subclass, type(e).__name__, e))
            #
            # # Nothing succeeded

            if should_display_warnings_for(to_type):
                logr.warn('WARNING: Object constructor signature for type {} does not allow parsyfiles to '
                          'automatically create instances from dict content. Caught {}: {}'
                          ''.format(get_pretty_type_str(to_type), type(main_e).__name__, main_e))

            return False"
352,"def dict_to_object(desired_type: Type[T], contents_dict: Dict[str, Any], logger: Logger,
                   options: Dict[str, Dict[str, Any]], conversion_finder: ConversionFinder = None,
                   is_dict_of_dicts: bool = False) -> T:
    """"""
    Utility method to create an object from a dictionary of constructor arguments. Constructor arguments that dont have
    the correct type are intelligently converted if possible

    :param desired_type:
    :param contents_dict:
    :param logger:
    :param options:
    :param conversion_finder:
    :param is_dict_of_dicts:
    :return:
    """"""
    check_var(desired_type, var_types=type, var_name='obj_type')
    check_var(contents_dict, var_types=dict, var_name='contents_dict')

    if is_collection(desired_type, strict=True):
        # if the destination type is 'strictly a collection' (not a subclass of a collection) we know that we can't
        # handle it here, the constructor is not pep484-typed
        raise TypeError('Desired object type \'' + get_pretty_type_str(desired_type) + '\' is a collection, '
                        'so it cannot be created using this generic object creator')
    else:
        # Try the type itself
        # try:
        return _dict_to_object(desired_type, contents_dict, logger=logger, options=options,
                               conversion_finder=conversion_finder, is_dict_of_dicts=is_dict_of_dicts)"
353,"def _dict_to_object(desired_type: Type[T], contents_dict: Dict[str, Any], logger: Logger,
                    options: Dict[str, Dict[str, Any]], conversion_finder: ConversionFinder = None,
                    is_dict_of_dicts: bool = False) -> T:
    """"""
    Utility method to create an object from a dictionary of constructor arguments. Constructor arguments that dont have
    the correct type are intelligently converted if possible

    :param desired_type:
    :param contents_dict:
    :param logger:
    :param options:
    :param conversion_finder:
    :param is_dict_of_dicts:
    :return:
    """"""
    # collect pep-484 information in the constructor to be able to understand what is required
    constructor_args_types_and_opt = get_constructor_attributes_types(desired_type)

    try:
        # for each attribute, convert the types of its parsed values if required
        dict_for_init = dict()
        for attr_name, provided_attr_value in contents_dict.items():

            # check if this attribute name is required by the constructor
            if attr_name in constructor_args_types_and_opt.keys():

                # check the theoretical type wanted by the constructor
                attr_type_required = constructor_args_types_and_opt[attr_name][0]

                # resolve forward references
                attr_type_required = resolve_forward_ref(attr_type_required)

                if not is_dict_of_dicts:
                    if is_valid_pep484_type_hint(attr_type_required):
                        # this will not fail if type information is not present;the attribute will only be used 'as is'
                        full_attr_name = get_pretty_type_str(desired_type) + '.' + attr_name

                        dict_for_init[attr_name] = ConversionFinder.try_convert_value(conversion_finder, full_attr_name,
                                                                                      provided_attr_value,
                                                                                      attr_type_required, logger,
                                                                                      options)

                    else:
                        warn(""Constructor for type <{t}> has no valid PEP484 Type hint for attribute {att}, trying to ""
                             ""use the parsed value in the dict directly"".format(t=get_pretty_type_str(desired_type),
                                                                         att=attr_name))
                        dict_for_init[attr_name] = provided_attr_value

                else:
                    # in that mode, the attribute value itself is a dict, so the attribute needs to be built from that
                    # dict first
                    if isinstance(provided_attr_value, dict):
                        # recurse : try to build this attribute from the dictionary provided. We need to know the type
                        # for this otherwise we wont be able to call the constructor :)
                        if (attr_type_required is None) or (attr_type_required is Parameter.empty):
                            raise TypeInformationRequiredError.create_for_object_attributes(desired_type, attr_name,
                                                                                            attr_type_required)

                        elif not is_valid_pep484_type_hint(attr_type_required):
                            raise InvalidPEP484TypeHint.create_for_object_attributes(desired_type, attr_name,
                                                                                     attr_type_required)

                        else:
                            # we can build the attribute from the sub-dict
                            dict_for_init[attr_name] = dict_to_object(attr_type_required, provided_attr_value,
                                                                      logger, options,
                                                                      conversion_finder=conversion_finder)

                    else:
                        raise ValueError('Error while trying to build object of type ' + str(desired_type) + ' from a '
                                         'dictionary of dictionaries. Entry \'' + attr_name + '\' is not a dictionary')
            else:
                if is_dict_of_dicts and attr_name is 'DEFAULT':
                    # -- tolerate but ignore - this is probably due to a configparser
                    # warning('Property name \'' + attr_name + '\' is not an attribute of the object constructor. <'
                    #         + get_pretty_type_str(desired_type) + '> constructor attributes are : '
                    #         + list(set(constructor_args_types.keys()) - {'self'}) + '. However it is named DEFAULT')
                    pass
                else:
                    # the dictionary entry does not correspond to a valid attribute of the object
                    raise InvalidAttributeNameForConstructorError.create(desired_type,
                                                                         list(set(constructor_args_types_and_opt.keys()) - {'self'}),
                                                                         attr_name)

        # create the object using its constructor
        try:
            return desired_type(**dict_for_init)
        except Exception as e:
            # Wrap into an Exception
            raise ObjectInstantiationException.create(desired_type, dict_for_init, e)

    except TypeError as e:
        raise CaughtTypeErrorDuringInstantiation.create(desired_type, contents_dict, e)"
354,"def print_dict(dict_name, dict_value, logger: Logger = None):
    """"""
    Utility method to print a named dictionary

    :param dict_name:
    :param dict_value:
    :return:
    """"""
    if logger is None:
        print(dict_name + ' = ')
        try:
            from pprint import pprint
            pprint(dict_value)
        except:
            print(dict_value)
    else:
        logger.info(dict_name + ' = ')
        try:
            from pprint import pformat
            logger.info(pformat(dict_value))
        except:
            logger.info(dict_value)"
355,"def get_default_object_parsers(parser_finder: ParserFinder, conversion_finder: ConversionFinder) -> List[AnyParser]:
    """"""
    Utility method to return the default parsers able to parse an object from a file.
    Note that MultifileObjectParser is not provided in this list, as it is already added in a hardcoded way in
    RootParser
    :return:
    """"""
    return [SingleFileParserFunction(parser_function=read_object_from_pickle,
                                     streaming_mode=False,
                                     supported_exts={'.pyc'},
                                     supported_types={AnyObject}),
            MultifileObjectParser(parser_finder, conversion_finder)
            ]"
356,"def get_default_object_converters(conversion_finder: ConversionFinder) \
        -> List[Union[Converter[Any, Type[None]], Converter[Type[None], Any]]]:
    """"""
    Utility method to return the default converters associated to dict (from dict to other type,
    and from other type to dict)
    :return:
    """"""

    return [
            ConverterFunction(from_type=b64str, to_type=AnyObject, conversion_method=base64_ascii_str_pickle_to_object),
            ConverterFunction(from_type=DictOfDict, to_type=Any, conversion_method=dict_to_object,
                              custom_name='dict_of_dict_to_object',
                              is_able_to_convert_func=_is_valid_for_dict_to_object_conversion, unpack_options=False,
                              function_args={'conversion_finder': conversion_finder, 'is_dict_of_dicts': True}),
            ConverterFunction(from_type=dict, to_type=AnyObject, conversion_method=dict_to_object,
                              custom_name='dict_to_object', unpack_options=False,
                              is_able_to_convert_func=_is_valid_for_dict_to_object_conversion,
                              function_args={'conversion_finder': conversion_finder, 'is_dict_of_dicts': False})
            ]"
357,"def create(obj: PersistedObject, obj_type: Type[Any], arg_name: str):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param obj:
        :param obj_type:
        :param arg_name:
        :return:
        """"""

        return MissingMandatoryAttributeFiles('Multifile object ' + str(obj) + ' cannot be built from constructor of '
                                              'type ' + get_pretty_type_str(obj_type) +
                                              ', mandatory constructor argument \'' + arg_name + '\'was not found on '
                                              'filesystem')"
358,"def create(item_type: Type[Any], constructor_atts: List[str], invalid_property_name: str):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param item_type:
        :return:
        """"""
        return InvalidAttributeNameForConstructorError('Cannot parse object of type <' + get_pretty_type_str(item_type)
                                                       + '> using the provided configuration file: configuration '
                                                       + 'contains a property name (\'' + invalid_property_name + '\')'\
                                                       + 'that is not an attribute of the object constructor. <'
                                                       + get_pretty_type_str(item_type) + '> constructor attributes '
                                                       + 'are : ' + str(constructor_atts))"
359,"def create(item_type: Type[Any], constructor_args: Dict[str, Any], cause: Exception):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param item_type:
        :return:
        """"""
        return ObjectInstantiationException('Error while building object of type <' + get_pretty_type_str(item_type)
                                            + '> using its constructor and parsed contents : ' + str(constructor_args)
                                            + ' : \n' + str(cause.__class__) + ' ' + str(cause)
                                            ).with_traceback(cause.__traceback__)"
360,"def create(desired_type: Type[Any], contents_dict: Dict, caught: Exception):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param desired_type:
        :param contents_dict:
        :param caught:
        :return:
        """"""
        msg = 'Error while trying to instantiate object of type ' + str(desired_type) + ' using dictionary input_dict:'\
              + 'Caught error message is : ' + caught.__class__.__name__ + ' : ' + str(caught) + '\n'
        try:
            from pprint import pformat
            msg += 'Dict provided was ' + pformat(contents_dict)
        except:
            msg += 'Dict provided was ' + str(contents_dict)

        return CaughtTypeErrorDuringInstantiation(msg).with_traceback(caught.__traceback__)"
361,"def is_able_to_parse_detailed(self, desired_type: Type[Any], desired_ext: str, strict: bool):
        """"""
        Explicitly declare that we are not able to parse collections

        :param desired_type:
        :param desired_ext:
        :param strict:
        :return:
        """"""

        if not _is_valid_for_dict_to_object_conversion(strict, None, None if desired_type is JOKER else desired_type):
            return False, None
        else:
            return super(MultifileObjectParser, self).is_able_to_parse_detailed(desired_type, desired_ext, strict)"
362,"def _get_parsing_plan_for_multifile_children(self, obj_on_fs: PersistedObject, desired_type: Type[Any],
                                                 logger: Logger) -> Dict[str, Any]:
        """"""
        Simply inspects the required type to find the names and types of its constructor arguments.
        Then relies on the inner ParserFinder to parse each of them.

        :param obj_on_fs:
        :param desired_type:
        :param logger:
        :return:
        """"""

        if is_collection(desired_type, strict=True):
            # if the destination type is 'strictly a collection' (not a subclass of a collection) we know that we can't
            # handle it here, the constructor is not pep484-typed
            raise TypeError('Desired object type \'' + get_pretty_type_str(desired_type) + '\' is a collection, '
                            'so it cannot be parsed with this default object parser')

        else:
            # First get the file children
            children_on_fs = obj_on_fs.get_multifile_children()

            # Try the type itself
            # try:
            return self.__get_parsing_plan_for_multifile_children(obj_on_fs, desired_type, children_on_fs,
                                                                  logger=logger)"
363,"def __get_parsing_plan_for_multifile_children(self, obj_on_fs: PersistedObject, desired_type: Type[Any],
                                                  children_on_fs: Dict[str, PersistedObject], logger: Logger) \
            -> Dict[str, Any]:
        """"""
        Simply inspects the required type to find the names and types of its constructor arguments.
        Then relies on the inner ParserFinder to parse each of them.

        :param obj_on_fs:
        :param desired_type:
        :param children_on_fs:
        :param logger:
        :return:
        """"""

        # -- (a) collect pep-484 information in the class constructor to be able to understand what is required
        constructor_args_types_and_opt = get_constructor_attributes_types(desired_type)

        # -- (b) plan to parse each attribute required by the constructor
        children_plan = dict()  # results will be put in this object

        # --use sorting in order to lead to reproducible results in case of multiple errors
        for attribute_name, att_desc in sorted(constructor_args_types_and_opt.items()):
            attribute_is_mandatory = att_desc[1]
            attribute_type = att_desc[0]

            # get the child
            if attribute_name in children_on_fs.keys():
                child_on_fs = children_on_fs[attribute_name]

                # find a parser
                t, parser_found = self.parser_finder.build_parser_for_fileobject_and_desiredtype(child_on_fs,
                                                                                                 attribute_type,
                                                                                                 logger=logger)
                # create a parsing plan
                children_plan[attribute_name] = parser_found.create_parsing_plan(t, child_on_fs,
                                                                                 logger=logger, _main_call=False)
            else:
                if attribute_is_mandatory:
                    raise MissingMandatoryAttributeFiles.create(obj_on_fs, desired_type, attribute_name)
                else:
                    # we don't care : optional attribute
                    # dont use warning since it does not show up nicely
                    msg = 'NOT FOUND - This optional constructor attribute for type ' \
                          + get_pretty_type_str(desired_type) + ' was not found on file system, but this may be normal'\
                          ' - this message is displayed \'just in case\'.'
                    if logger.isEnabledFor(DEBUG):
                        logger.warning('(B) ' + obj_on_fs.get_pretty_child_location(attribute_name,
                                                                                    blank_parent_part=True) + ': '
                                       + msg)
                    else:
                        logger.warning('WARNING parsing [{loc}] as a [{typ}]: optional constructor attribute [{att}] '
                                       'not found on file system. This may be normal - this message is displayed \'just'
                                       ' in case\'.'.format(
                            loc=obj_on_fs.get_pretty_location(blank_parent_part=False, append_file_ext=False),
                            typ=get_pretty_type_str(desired_type),
                            att=attribute_name))

        return children_plan"
364,"def parsyfiles_global_config(multiple_errors_tb_limit: int = None, full_paths_in_logs: bool = None, 
                             dict_to_object_subclass_limit: int = None):
    """"""
    This is the method you should use to configure the parsyfiles library

    :param multiple_errors_tb_limit: the traceback size (default is 3) of individual parsers exceptions displayed when
    parsyfiles tries several parsing chains and all of them fail.
    :param full_paths_in_logs: if True, full file paths will be displayed in logs. Otherwise only the parent path will
    be displayed and children paths will be indented (default is False)
    :param dict_to_object_subclass_limit: the number of subclasses that the <dict_to_object> converter will try, when 
    instantiating an object from a dictionary. Default is 50
    :return:
    """"""
    if multiple_errors_tb_limit is not None:
        GLOBAL_CONFIG.multiple_errors_tb_limit = multiple_errors_tb_limit
    if full_paths_in_logs is not None:
        GLOBAL_CONFIG.full_paths_in_logs = full_paths_in_logs
    if dict_to_object_subclass_limit is not None:
        GLOBAL_CONFIG.dict_to_object_subclass_limit = dict_to_object_subclass_limit"
365,"def is_valid(self, context):
        """"""Checks through the previous_actions iterable if required actions have
        been executed
        """"""
        if self.requires:
            for r in self.requires:
                if not r in context.executed_actions:
                    raise RequirementMissingError(""Action '%s' requires '%s'"" % (self.name, r))
        return True"
366,"def get_file_contents(file_path):
  """"""Get the context of the file using full path name""""""
  full_path = os.path.join(package_dir, file_path)
  return open(full_path, 'r').read()"
367,"def refresh(self):
        """"""Refresh a device""""""
        # new_device = {}
        if self.type in CONST.BINARY_SENSOR_TYPES:
            response = self._lupusec.get_sensors()
            for device in response:
                if device['device_id'] == self._device_id:
                    self.update(device)

            return device

        elif self.type == CONST.ALARM_TYPE:
            response = self._lupusec.get_panel()
            self.update(response)
            return response
        
        elif self.type == CONST.TYPE_POWER_SWITCH:
            response = self._lupusec.get_power_switches()
            for pss in response:
                if pss['device_id'] == self._device_id:
                    self.update(pss)
            return pss"
368,"def update(self, json_state):
        """"""Update the json data from a dictionary.

        Only updates if it already exists in the device.
        """"""
        if self._type in CONST.BINARY_SENSOR_TYPES:
            self._json_state['status'] = json_state['status']
        else:
            self._json_state.update(
                {k: json_state[k] for k in json_state if self._json_state.get(k)})"
369,"def desc(self):
        """"""Get a short description of the device.""""""
        return '{0} (ID: {1}) - {2} - {3}'.format(
            self.name, self.device_id, self.type, self.status)"
370,"def list(declared, undeclared):
    """"""List configured queues.""""""
    queues = current_queues.queues.values()
    if declared:
        queues = filter(lambda queue: queue.exists, queues)
    elif undeclared:
        queues = filter(lambda queue: not queue.exists, queues)
    queue_names = [queue.routing_key for queue in queues]
    queue_names.sort()
    for queue in queue_names:
        click.secho(queue)"
371,"def declare(queues):
    """"""Initialize the given queues.""""""
    current_queues.declare(queues=queues)
    click.secho(
        'Queues {} have been declared.'.format(
            queues or current_queues.queues.keys()),
        fg='green'
    )"
372,"def purge_queues(queues=None):
    """"""Purge the given queues.""""""
    current_queues.purge(queues=queues)
    click.secho(
        'Queues {} have been purged.'.format(
            queues or current_queues.queues.keys()),
        fg='green'
    )"
373,"def delete_queue(queues):
    """"""Delete the given queues.""""""
    current_queues.delete(queues=queues)
    click.secho(
        'Queues {} have been deleted.'.format(
            queues or current_queues.queues.keys()),
        fg='green'
    )"
374,"def find_needed_formatter(input_format, output_format):
    """"""
    Find a data formatter given an input and output format
    input_format - needed input format.  see utils.input.dataformats
    output_format - needed output format.  see utils.input.dataformats
    """"""
    #Only take the formatters in the registry
    selected_registry = [re.cls for re in registry if re.category==RegistryCategories.formatters]
    needed_formatters = []
    for formatter in selected_registry:
        #Initialize the formatter (needed so it can discover its formats)
        formatter_inst = formatter()
        if input_format in formatter_inst.input_formats and output_format in formatter_inst.output_formats:
            needed_formatters.append(formatter)
    if len(needed_formatters)>0:
        return needed_formatters[0]
    return None"
375,"def find_needed_input(input_format):
    """"""
    Find a needed input class
    input_format - needed input format, see utils.input.dataformats
    """"""
    needed_inputs = [re.cls for re in registry if re.category==RegistryCategories.inputs and re.cls.input_format == input_format]
    if len(needed_inputs)>0:
        return needed_inputs[0]
    return None"
376,"def exists_in_registry(category, namespace, name):
    """"""
    See if a given category, namespace, name combination exists in the registry
    category - See registrycategories.  Type of module
    namespace - Namespace of the module, defined in settings
    name - the lowercase name of the module
    """"""
    selected_registry = [re for re in registry if re.category==category and re.namespace==namespace and re.name == name]
    if len(selected_registry)>0:
        return True
    return False"
377,"def register(cls):
    """"""
    Register a given model in the registry
    """"""
    registry_entry = RegistryEntry(category = cls.category, namespace = cls.namespace, name = cls.name, cls=cls)
    if registry_entry not in registry and not exists_in_registry(cls.category, cls.namespace, cls.name):
        registry.append(registry_entry)
    else:
        log.warn(""Class {0} already in registry"".format(cls))"
378,"def _set_fields(self):
        """"""
        Initialize the fields for data caching.
        """"""
        self.fields = []
        self.required_input = []
        for member_name, member_object in inspect.getmembers(self.__class__):
            if inspect.isdatadescriptor(member_object) and not member_name.startswith(""__""):
                self.fields.append(member_name)
                if member_object.required_input:
                    self.required_input.append(member_name)"
379,"def subscriber(address,topics,callback,message_type):
    """"""
    Creates a subscriber binding to the given address and 
    subscribe the given topics.
    The callback is invoked for every message received.

        Args:
            - address: the address to bind the PUB socket to.
            - topics: the topics to subscribe
            - callback: the callback to invoke for every message. Must accept 2 variables - topic and message
            - message_type: the type of message to receive
    """"""
    return Subscriber(address,topics,callback,message_type)"
380,"def start(self):
        """"""
        Start a thread that consumes the messages and invokes the callback
        """"""
        t=threading.Thread(target=self._consume)
        t.start()"
381,"def _get_forecast(api_result: dict) -> List[SmhiForecast]:
    """"""Converts results fråm API to SmhiForeCast list""""""
    forecasts = []

    # Need the ordered dict to get
    # the days in order in next stage
    forecasts_ordered = OrderedDict()

    forecasts_ordered = _get_all_forecast_from_api(api_result)

    # Used to calc the daycount
    day_nr = 1

    for day in forecasts_ordered:
        forecasts_day = forecasts_ordered[day]

        if day_nr == 1:
            # Add the most recent forecast
            forecasts.append(copy.deepcopy(forecasts_day[0]))

        total_precipitation = float(0.0)
        forecast_temp_max = -100.0
        forecast_temp_min = 100.0
        forecast = None
        for forcast_day in forecasts_day:
            temperature = forcast_day.temperature
            if forecast_temp_min > temperature:
                forecast_temp_min = temperature
            if forecast_temp_max < temperature:
                forecast_temp_max = temperature

            if forcast_day.valid_time.hour == 12:
                forecast = copy.deepcopy(forcast_day)

            total_precipitation = total_precipitation + \
                forcast_day._total_precipitation

        if forecast is None:
            # We passed 12 noon, set to current
            forecast = forecasts_day[0]

        forecast._temperature_max = forecast_temp_max
        forecast._temperature_min = forecast_temp_min
        forecast._total_precipitation = total_precipitation
        forecast._mean_precipitation = total_precipitation/24
        forecasts.append(forecast)
        day_nr = day_nr + 1

    return forecasts"
382,"def _get_all_forecast_from_api(api_result: dict) -> OrderedDict:
    """"""Converts results fråm API to SmhiForeCast list""""""
    # Total time in hours since last forecast
    total_hours_last_forecast = 1.0

    # Last forecast time
    last_time = None

    # Need the ordered dict to get
    # the days in order in next stage
    forecasts_ordered = OrderedDict()

    # Get the parameters
    for forecast in api_result['timeSeries']:

        valid_time = datetime.strptime(
            forecast['validTime'], ""%Y-%m-%dT%H:%M:%SZ"")
        for param in forecast['parameters']:
            if param['name'] == 't':
                temperature = float(param['values'][0])  # Celcisus
            elif param['name'] == 'r':
                humidity = int(param['values'][0])  # Percent
            elif param['name'] == 'msl':
                pressure = int(param['values'][0])  # hPa
            elif param['name'] == 'tstm':
                thunder = int(param['values'][0])  # Percent
            elif param['name'] == 'tcc_mean':
                octa = int(param['values'][0])  # Cloudiness in octas
                if 0 <= octa <= 8:  # Between 0 -> 8
                    cloudiness = round(100*octa/8)  # Convert octas to percent
                else:
                    cloudiness = 100  # If not determined use 100%
            elif param['name'] == 'Wsymb2':
                symbol = int(param['values'][0])  # category
            elif param['name'] == 'pcat':
                precipitation = int(param['values'][0])  # percipitation
            elif param['name'] == 'pmean':
                mean_precipitation = float(
                    param['values'][0])  # mean_percipitation
            elif param['name'] == 'ws':
                wind_speed = float(param['values'][0])  # wind speed
            elif param['name'] == 'wd':
                wind_direction = int(param['values'][0])  # wind direction
            elif param['name'] == 'vis':
                horizontal_visibility = float(param['values'][0])  # Visibility
            elif param['name'] == 'gust':
                wind_gust = float(param['values'][0])  # wind gust speed

        roundedTemp = int(round(temperature))

        if last_time is not None:
            total_hours_last_forecast = (valid_time - last_time).seconds/60/60

        # Total precipitation, have to calculate with the nr of
        # hours since last forecast to get correct total value
        tp = round(mean_precipitation*total_hours_last_forecast, 2)

        forecast = \
            SmhiForecast(roundedTemp, roundedTemp, roundedTemp,
                         humidity, pressure, thunder, cloudiness,
                         precipitation, wind_direction, wind_speed,
                         horizontal_visibility, wind_gust,
                         round(mean_precipitation, 1), tp, symbol,
                         valid_time)

        if valid_time.day not in forecasts_ordered:
            # add a new list
            forecasts_ordered[valid_time.day] = []

        forecasts_ordered[valid_time.day].append(forecast)

        last_time = valid_time

    return forecasts_ordered"
383,"def get_forecast_api(self, longitude: str, latitude: str) -> {}:
        """"""gets data from API""""""
        api_url = APIURL_TEMPLATE.format(longitude, latitude)

        response = urlopen(api_url)
        data = response.read().decode('utf-8')
        json_data = json.loads(data)

        return json_data"
384,"async def async_get_forecast_api(self, longitude: str,
                                     latitude: str) -> {}:
        """"""gets data from API asyncronious""""""
        api_url = APIURL_TEMPLATE.format(longitude, latitude)

        if self.session is None:
            self.session = aiohttp.ClientSession()

        async with self.session.get(api_url) as response:
            if response.status != 200:
                raise SmhiForecastException(
                    ""Failed to access weather API with status code {}"".format(
                        response.status)
                )
            data = await response.text()
            return json.loads(data)"
385,"def get_forecast(self) -> List[SmhiForecast]:
        """"""
        Returns a list of forecasts. The first in list are the current one
        """"""
        json_data = self._api.get_forecast_api(self._longitude, self._latitude)
        return _get_forecast(json_data)"
386,"async def async_get_forecast(self) -> List[SmhiForecast]:
        """"""
        Returns a list of forecasts. The first in list are the current one
        """"""
        json_data = await self._api.async_get_forecast_api(self._longitude,
                                                           self._latitude)
        return _get_forecast(json_data)"
387,"def _make_decorator(measuring_func):
    """"""morass of closures for making decorators/descriptors""""""
    def _decorator(name = None, metric = call_default):
        def wrapper(func):

            name_ = name if name is not None else func.__module__ + '.' +func.__name__
            class instrument_decorator(object): # must be a class for descriptor magic to work
                @wraps(func)
                def __call__(self, *args, **kwargs):
                    return measuring_func(func(*args, **kwargs), name_, metric)

                def __get__(self, instance, class_):
                    name_ = name if name is not None else\
                        ""."".join((class_.__module__, class_.__name__, func.__name__))
                    @wraps(func)
                    def wrapped_method(*args, **kwargs):
                        return measuring_func(func(instance, *args, **kwargs), name_, metric)
                    return wrapped_method
            return instrument_decorator()

        return wrapper
    return _decorator"
388,"def all(iterable = None, *, name = None, metric = call_default):
    """"""Measure total time and item count for consuming an iterable

    :arg iterable: any iterable
    :arg function metric: f(name, count, total_time)
    :arg str name: name for the metric
    """"""
    if iterable is None:
        return _iter_decorator(name, metric)
    else:
        return _do_all(iterable, name, metric)"
389,"def each(iterable = None, *, name = None, metric = call_default):
    """"""Measure time elapsed to produce each item of an iterable

    :arg iterable: any iterable
    :arg function metric: f(name, 1, time)
    :arg str name: name for the metric
    """"""
    if iterable is None:
        return _each_decorator(name, metric)
    else:
        return _do_each(iterable, name, metric)"
390,"def first(iterable = None, *, name = None, metric = call_default):
    """"""Measure time elapsed to produce first item of an iterable

    :arg iterable: any iterable
    :arg function metric: f(name, 1, time)
    :arg str name: name for the metric
    """"""
    if iterable is None:
        return _first_decorator(name, metric)
    else:
        return _do_first(iterable, name, metric)"
391,"def _iterable_to_varargs_method(func):
    """"""decorator to convert a method taking a iterable to a *args one""""""
    def wrapped(self, *args, **kwargs):
        return func(self, args, **kwargs)
    return wrapped"
392,"def _varargs_to_iterable_method(func):
    """"""decorator to convert a *args method to one taking a iterable""""""
    def wrapped(self, iterable, **kwargs):
        return func(self, *iterable, **kwargs)
    return wrapped"
393,"def reducer(*, name = None, metric = call_default):
    """"""Decorator to measure a function that consumes many items.

    The wrapped ``func`` should take either a single ``iterable`` argument or
    ``*args`` (plus keyword arguments).

    :arg function metric: f(name, count, total_time)
    :arg str name: name for the metric
    """"""
    class instrument_reducer_decorator(object):
        def __init__(self, func):
            self.orig_func = func
            self.wrapping = wraps(func)
            self.metric_name = name if name is not None else func.__module__ + '.' +func.__name__
            self.varargs = inspect.getargspec(func).varargs is not None
            if self.varargs:
                self.method = _varargs_to_iterable_method(func)
                self.func = _varargs_to_iterable_func(func)
                self.callme = _iterable_to_varargs_func(self._call)
            else:
                self.method = func
                self.func = func
                self.callme = self._call

        # we need _call/callme b/c CPython short-circurits CALL_FUNCTION to
        # directly access __call__, bypassing our varargs decorator
        def __call__(self, *args, **kwargs):
            return self.callme(*args, **kwargs)

        def _call(self, iterable, **kwargs):
            it = counted_iterable(iterable)
            t = time.time()
            try:
                return self.func(it, **kwargs)
            finally:
                metric(self.metric_name, it.count, time.time() - t)

        def __get__(self, instance, class_):
            metric_name = name if name is not None else\
                ""."".join((class_.__module__, class_.__name__, self.orig_func.__name__))

            def wrapped_method(iterable, **kwargs):
                it = counted_iterable(iterable)
                t = time.time()
                try:
                    return self.method(instance, it, **kwargs)
                finally:
                    metric(metric_name, it.count, time.time() - t)

            # wrap in func version b/c self is handled for us by descriptor (ie, `instance`)
            if self.varargs: wrapped_method = _iterable_to_varargs_func(wrapped_method)
            wrapped_method = self.wrapping(wrapped_method)
            return wrapped_method

    return instrument_reducer_decorator"
394,"def producer(*, name = None, metric = call_default):
    """"""Decorator to measure a function that produces many items.

    The function should return an object that supports ``__len__`` (ie, a
    list). If the function returns an iterator, use :func:`all` instead.

    :arg function metric: f(name, count, total_time)
    :arg str name: name for the metric
    """"""

    def wrapper(func):
        def instrumenter(name_, *args, **kwargs):
            t = time.time()
            try:
                ret = func(*args, **kwargs)
            except Exception:
                # record a metric for other exceptions, than raise
                metric(name_, 0, time.time() - t)
                raise
            else:
                # normal path, record metric & return
                metric(name_, len(ret), time.time() - t)
                return ret

        name_ = name if name is not None else func.__module__ + '.' +func.__name__
        class instrument_decorator(object): # must be a class for descriptor magic to work
            @wraps(func)
            def __call__(self, *args, **kwargs):
                return instrumenter(name_, *args, **kwargs)

            def __get__(self, instance, class_):
                name_ = name if name is not None else\
                    ""."".join((class_.__module__, class_.__name__, func.__name__))
                @wraps(func)
                def wrapped_method(*args, **kwargs):
                    return instrumenter(name_, instance, *args, **kwargs)
                return wrapped_method

        return instrument_decorator()
    return wrapper"
395,"def block(*, name = None, metric = call_default, count = 1):
    """"""Context manager to measure execution time of a block

    :arg function metric: f(name, 1, time)
    :arg str name: name for the metric
    :arg int count: user-supplied number of items, defaults to 1
    """"""
    t = time.time()
    try:
        yield
    finally:
        metric(name, count, time.time() - t)"
396,"def import_from_string(import_string):
    """"""
    Import a class from a string
    import_string - string path to module to import using dot notation (foo.bar)
    """"""
    import_split = import_string.split(""."")
    import_class = import_split[-1]
    module_path = ""."".join(import_split[:-1])
    mod = __import__(module_path, fromlist=[import_class])
    klass = getattr(mod, import_class)
    return klass"
397,"def send(self,message,message_type,topic=''):
        """"""
        Send the message on the socket.
        
        Args:
            - message: the message to publish
            - message_type: the type of message being sent
            - topic: the topic on which to send the message. Defaults to ''.
        """"""
        if message_type == RAW:
            self._sock.send(message)
        elif message_type == PYOBJ:
            self._sock.send_pyobj(message)
        elif message_type == JSON:
            self._sock.send_json(message)
        elif message_type == MULTIPART:
            self._sock.send_multipart([topic, message])
        elif message_type == STRING:
            self._sock.send_string(message)
        elif message_type == UNICODE:
            self._sock.send_unicode(message)
        else:
            raise Exception(""Unknown message type %s""%(message_type,))"
398,"def receive(self,message_type):
        """"""
        Receive the message of the specified type and retun
        
            Args:
                - message_type: the type of the message to receive
                
            Returns:
                - the topic of the message
                - the message received from the socket
        """"""
        topic = None
        message = None
        if message_type == RAW:
            message = self._sock.recv(flags=zmq.NOBLOCK)
        elif message_type == PYOBJ:
            message = self._sock.recv_pyobj(flags=zmq.NOBLOCK)
        elif message_type == JSON:
            message = self._sock.recv_json(flags=zmq.NOBLOCK)
        elif message_type == MULTIPART:
            data = self._sock.recv_multipart(flags=zmq.NOBLOCK)
            message = data[1]
            topic = data[0]
        elif message_type == STRING:
            message = self._sock.recv_string(flags=zmq.NOBLOCK)
        elif message_type == UNICODE:
            message = self._sock.recv_unicode(flags=zmq.NOBLOCK)
        else:
            raise Exception(""Unknown message type %s""%(self._message_type,))
            
        return (topic, message)"
399,"def dynamic_exec(code, resolve, assign=None, delete=None, automatic_builtins=True,
                 filename=None, module_name=None, _type='exec'):
  """"""
  Transforms the Python source code *code* and evaluates it so that the
  *resolve* and *assign* functions are called respectively for when a global
  variable is access or assigned.

  If *resolve* is a mapping, *assign* must be omitted. #KeyError#s raised by
  the mapping are automatically converted to #NameError#s.

  Otherwise, *resolve* and *assign* must be callables that have the same
  interface as `__getitem__()`, and `__setitem__()`. If *assign* is omitted
  in that case, assignments will be redirected to a separate dictionary and
  keys in that dictionary will be checked before continuing with the *resolve*
  callback.
  """"""

  parse_filename = filename or '<string>'
  ast_node = transform(ast.parse(code, parse_filename, mode=_type))
  code = compile(ast_node, parse_filename, _type)
  if hasattr(resolve, '__getitem__'):
    if assign is not None:
      raise TypeError('""assign"" parameter specified where ""resolve"" is a mapping')
    if delete is not None:
      raise TypeError('""delete"" parameter specified where ""resolve"" is a mapping')
    input_mapping = resolve

    def resolve(x):
      try:
        return input_mapping[x]
      except KeyError:
        raise NameError(x)

    assign = input_mapping.__setitem__

    delete = input_mapping.__delitem__
  else:
    input_mapping = False

  class DynamicMapping(object):
    _data = {}
    _deleted = set()
    def __repr__(self):
      if input_mapping:
        return 'DynamicMapping({!r})'.format(input_mapping)
      else:
        return 'DynamicMapping(resolve={!r}, assign={!r})'.format(resolve, assign)
    def __getitem__(self, key):
      if key in self._deleted:
        raise NameError(key)
      if assign is None:
        try:
          return self._data[key]
        except KeyError:
          pass  # Continue with resolve()
      try:
        return resolve(key)
      except NameError as exc:
        if automatic_builtins and not key.startswith('_'):
          try:
            return getattr(builtins, key)
          except AttributeError:
            pass
        raise exc
    def __setitem__(self, key, value):
      self._deleted.discard(key)
      if assign is None:
        self._data[key] = value
      else:
        assign(key, value)
    def __delitem__(self, key):
      if delete is None:
        self._deleted.add(key)
      else:
        delete(key)
    def get(self, key, default=None):
      try:
        return self[key]
      except NameError:
        return default

  mapping = DynamicMapping()
  globals_ = {'__dict__': mapping}

  if filename:
    mapping['__file__'] = filename
    globals_['__file__'] = filename

  if module_name:
    mapping['__name__'] = module_name
    globals_['__name__'] = module_name

  return (exec_ if _type == 'exec' else eval)(code, globals_)"
400,"def __get_subscript(self, name, ctx=None):
    """"""
    Returns `<data_var>[""<name>""]`
    """"""

    assert isinstance(name, string_types), name
    return ast.Subscript(
      value=ast.Name(id=self.data_var, ctx=ast.Load()),
      slice=ast.Index(value=ast.Str(s=name)),
      ctx=ctx)"
401,"def __get_subscript_assign(self, name):
    """"""
    Returns `<data_var>[""<name>""] = <name>`.
    """"""

    return ast.Assign(
      targets=[self.__get_subscript(name, ast.Store())],
      value=ast.Name(id=name, ctx=ast.Load()))"
402,"def __get_subscript_delete(self, name):
    """"""
    Returns `del <data_var>[""<name>""]`.
    """"""

    return ast.Delete(targets=[self.__get_subscript(name, ast.Del())])"
403,"def __visit_target(self, node):
    """"""
    Call this method to visit assignment targets and to add local variables
    to the current stack frame. Used in #visit_Assign() and
    #__visit_comprehension().
    """"""

    if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store):
      self.__add_variable(node.id)
    elif isinstance(node, (ast.Tuple, ast.List)):
      [self.__visit_target(x) for x in node.elts]"
404,"def __get_package_manager(self):
        """"""
        Installs and verifies package manager
        """"""
        package_manager = """"
        args = """"
        sudo_required = True
        if system.is_osx():
            package_manager = ""brew""
            sudo_required = False
            args = "" install""
        elif system.is_debian():
            package_manager = ""apt-get""
            args = "" -y install""
        elif system.is_fedora():
            package_manager = ""yum""
            args = "" install""
        elif system.is_arch():
            package_manager = ""pacman""
            args = "" --noconfirm -S""
        if lib.which(package_manager) is None:
            self.logger.warn(""Package manager %s not installed! Packages will not be installed.""
                             % package_manager)
            self.package_manager = None
        self.package_manager = package_manager
        self.sudo_required = sudo_required
        self.args = args"
405,"def eval_expr(expr, context):
    """"""Recursively evaluates a compiled expression using the specified context.
    Dict instances can contain a ""__kwargs"" key which will be used to update the
    dict with its content
    """"""
    if isinstance(expr, list):
        rv = []
        for item in expr:
            rv.append(eval_expr(item, context))
        return rv
    if isinstance(expr, dict):
        rv = {}
        for k, v in expr.iteritems():
            rv[k] = eval_expr(v, context)
        kwargs = rv.pop(""__kwargs"", None)
        if kwargs:
            rv.update(kwargs)
        return rv
    if isinstance(expr, Expression):
        return expr.eval(context)
    return expr"
406,"def can_convert(strict: bool, from_type: Type[S], to_type: Type[T]):
    """"""
    None should be treated as a Joker here (but we know that never from_type and to_type will be None at the same time)

    :param strict:
    :param from_type:
    :param to_type:
    :return:
    """"""
    if (to_type is not None) and (to_type not in (all_primitive_types + all_np_primitive_types)):
        return False
    else:
        return True"
407,"def parse(self, data, doctype):
        '''
        Parse an input string, and return an AST
        doctype must have WCADocument as a baseclass
        '''
        self.doctype = doctype
        self.lexer.lineno = 0
        del self.errors[:]
        del self.warnings[:]
        self.lexer.lexerror = False
        ast = self.parser.parse(data, lexer=self.lexer)
        if self.lexer.lexerror:
            ast = None
        if ast is None:
            self.errors.append(""Couldn't build AST."")
        else:
            for check in self.sema[self.doctype]:
                visitor = check()
                if not visitor.visit(ast):
                    self.errors.append(""Couldn't visit AST."")
                self.errors.extend(visitor.errors)
                self.warnings.extend(visitor.warnings)
        return (ast, list(self.errors), list(self.warnings))"
408,"def _act_on_list(self, lhs):
        '''
        Act on the following rule :
            items : items item
                  | item
        '''
        lhs[0] = []
        if len(lhs) == 3:
            lhs[0] = lhs[1]
        # lhs[len(lhs)-1] may be different from lhs[-1]
        # Yacc use some internal method to get the element, see yacc.py:240
        item = lhs[len(lhs) - 1]
        if item:
            lhs[0].append(item)"
409,"def p_content(self, content):
        '''content : TITLE opttexts VERSION opttexts sections
                   | TITLE STATESTAG VERSION opttexts states_sections'''
        content[0] = self.doctype(content[1], content[3], content[4], content[5])
        if self.toc:
            self.toc.set_articles([a for a in content[0].sections if isinstance(a, Article)])"
410,"def p_text(self, text):
        '''text : TEXT PARBREAK
                | TEXT
                | PARBREAK'''
        item = text[1]
        text[0] = item if item[0] != ""\n"" else u""""
        if len(text) > 2:
            text[0] += ""\n"""
411,"def p_toc(self, toc):
        '''toc : HEADERSEC opttexts TOC opttexts'''
        toc[0] = TableOfContent(toc[1], toc[2], [])
        self.toc = toc[0]"
412,"def p_article(self, article):
        '''article : ARTICLEHEADER opttexts rules opttexts'''
        article[0] = Article(article[1][4], article[2], article[3], article[1][0],
                             article[1][1], article[1][2], article[1][3], article[1][5])"
413,"def p_regularsec(self, regularsec):
        '''regularsec : HEADERSEC opttexts optsubsections'''
        texts = []
        sections = regularsec[2]
        if len(regularsec) > 3:
            texts = regularsec[2]
            sections = regularsec[3]
        regularsec[0] = Section(regularsec[1], texts, sections)"
414,"def p_subsection(self, subsection):
        '''subsection : HEADERSUBSEC texts
                      | HEADERSUBSEC texts labeldecls opttexts'''
        content = subsection[3] if len(subsection) > 3 else []
        subsection[0] = Subsection(subsection[1], subsection[2], content)"
415,"def p_rule(self, rule):
        '''rule : GUIDELINE
                | REGULATION'''
        if len(rule[1]) == 4:
            # This is a guideline
            rule[0] = Guideline(rule[1][1], rule[1][2], rule[1][3])
        else:
            # This is a regulation
            indentsize = rule[1][0]
            number = rule[1][1]
            text = rule[1][2]
            parent = None

            # If we just ""un""nested, shrink the current rule to our level
            if self.prev_indent > indentsize:
                self.current_rule = self.current_rule[0:indentsize+1]

            # We just added a nested level, the parent is the list's last elem
            if self.prev_indent < indentsize:
                parent = self.current_rule[-1]
            # Else, if we are nested the parent is the one before the last elem
            elif len(self.current_rule) > 1:
                parent = self.current_rule[-2]
            # Else if we are not nested, then we are a root rule and parent is none
            # (do nothing as parent is initialized to none)

            # Create the regulation node
            reg = Regulation(number, text, parent)

            # Let our parent knows he has a new child, if we don't have a parent
            # let's create an item in the article rules list
            if parent:
                parent.add_child(reg)
            else:
                rule[0] = reg

            # Unless we nested, pop and replace the last rule by ourself
            # If we added a nesting level, we just need to add ourself
            if self.prev_indent >= indentsize:
                self.current_rule.pop()
            self.current_rule.append(reg)
            self.prev_indent = indentsize"
416,"def p_state(self, state):
        '''state : STATE opttexts'''
        state[0] = State(state[1][0], state[1][1], state[1][2], state[1][3], state[2])"
417,"def p_error(self, elem):
        '''Handle syntax error'''
        self.errors.append(""Syntax error on line "" + str(self.lexer.lineno)
                           + "". Got unexpected token "" + elem.type)"
418,"def set_progress_brackets(self, start, end):
        """"""Set brackets to set around a progress bar.""""""
        self.sep_start = start
        self.sep_end = end"
419,"def add_progress(self, count, symbol='#',
                     color=None, on_color=None, attrs=None):
        """"""Add a section of progress to the progressbar.

        The progress is captured by ""count"" and displayed as a fraction
        of the statusbar width proportional to this count over the total
        progress displayed. The progress will be displayed using the ""symbol""
        character and the foreground and background colours and display style
        determined by the the ""color"", ""on_color"" and ""attrs"" parameters.
        These parameters work as the termcolor.colored function.
        """"""
        chunk = _ProgressChunk(count, symbol, color, on_color, attrs)
        self._progress_chunks.append(chunk)"
420,"def format_progress(self, width):
        """"""Create the formatted string that displays the progress.""""""
        chunk_widths = self._get_chunk_sizes(width)
        progress_chunks = [chunk.format_chunk(chunk_width)
                           for (chunk, chunk_width)
                           in zip(self._progress_chunks, chunk_widths)]
        return ""{sep_start}{progress}{sep_end}"".format(
            sep_start=self.sep_start,
            progress="""".join(progress_chunks),
            sep_end=self.sep_end
        )"
421,"def summary_width(self):
        """"""Calculate how long a string is needed to show a summary string.

        This is not simply the length of the formatted summary string
        since that string might contain ANSI codes.
        """"""
        chunk_counts = [chunk.count for chunk in self._progress_chunks]
        numbers_width = sum(max(1, ceil(log10(count + 1)))
                            for count in chunk_counts)
        separators_with = len(chunk_counts) - 1
        return numbers_width + separators_with"
422,"def format_summary(self):
        """"""Generate a summary string for the progress bar.""""""
        chunks = [chunk.format_chunk_summary()
                  for chunk in self._progress_chunks]
        return ""/"".join(chunks)"
423,"def add_progress(self, count, symbol='#',
                     color=None, on_color=None, attrs=None):
        """"""Add a section of progress to the progressbar.

        The progress is captured by ""count"" and displayed as a fraction
        of the statusbar width proportional to this count over the total
        progress displayed. The progress will be displayed using the ""symbol""
        character and the foreground and background colours and display style
        determined by the the ""fg"", ""bg"" and ""style"" parameters. For these,
        use the colorama package to set up the formatting.
        """"""
        self._progress.add_progress(count, symbol, color, on_color, attrs)"
424,"def format_status(self, width=None,
                      label_width=None,
                      progress_width=None,
                      summary_width=None):
        """"""Generate the formatted status bar string.""""""
        if width is None:  # pragma: no cover
            width = shutil.get_terminal_size()[0]

        if label_width is None:
            label_width = len(self.label)
        if summary_width is None:
            summary_width = self.summary_width()
        if progress_width is None:
            progress_width = width - label_width - summary_width - 2

        if len(self.label) > label_width:
            # FIXME: This actually *will* break if we ever have fewer than
            # three characters assigned to format the label, but that would
            # be an extreme situation so I won't fix it just yet.
            label = self.label[:label_width - 3] + ""...""
        else:
            label_format = ""{{label:{fill_char}<{width}}}"".format(
                width=label_width,
                fill_char=self.fill_char)
            label = label_format.format(label=self.label)

        summary_format = ""{{:>{width}}}"".format(width=summary_width)
        summary = summary_format.format(self._progress.format_summary())

        progress = self._progress.format_progress(width=progress_width)

        return ""{label} {progress} {summary}"".format(
            label=label,
            progress=progress,
            summary=summary
        )"
425,"def add_status_line(self, label):
        """"""Add a status bar line to the table.

        This function returns the status bar and it can be modified
        from this return value.
        """"""
        status_line = StatusBar(label,
                                self._sep_start, self._sep_end,
                                self._fill_char)
        self._lines.append(status_line)
        return status_line"
426,"def calculate_field_widths(self, width=None,
                               min_label_width=10,
                               min_progress_width=10):
        """"""Calculate how wide each field should be so we can align them.

        We always find room for the summaries since these are short and
        packed with information. If possible, we will also find room for
        labels, but if this would make the progress bar width shorter than
        the specified minium then we will shorten the labels, though never
        below the minium there. If this mean we have bars that are too wide
        for the terminal, then your terminal needs to be wider.
        """"""
        if width is None:  # pragma: no cover
            width = shutil.get_terminal_size()[0]

        summary_width = self.summary_width()
        label_width = self.label_width()
        remaining = width - summary_width - label_width - 2

        if remaining >= min_progress_width:
            progress_width = remaining
        else:
            progress_width = min_progress_width
            remaining = width - summary_width - progress_width - 2
            if remaining >= min_label_width:
                label_width = remaining
            else:
                label_width = min_label_width

        return (label_width, progress_width, summary_width)"
427,"def format_table(self, width=None,
                     min_label_width=10, min_progress_width=10):
        """"""Format the entire table of progress bars.

        The function first computes the widths of the fields so they can be
        aligned across lines and then returns formatted lines as a list of
        strings.
        """"""
        # handle the special case of an empty table.
        if len(self._lines) == 0:
            return []

        if width is None:  # pragma: no cover
            width = shutil.get_terminal_size()[0]

        labelw, progw, summaryw = self.calculate_field_widths(
            width=width,
            min_label_width=min_label_width,
            min_progress_width=min_progress_width
        )
        output = [
            sb.format_status(
                label_width=labelw,
                progress_width=progw,
                summary_width=summaryw
            )
            for sb in self._lines
        ]

        return output"
428,"def create_log_dict(request, response):
    """"""
    Create a dictionary with logging data.
    """"""
    remote_addr = request.META.get('REMOTE_ADDR')
    if remote_addr in getattr(settings, 'INTERNAL_IPS', []):
        remote_addr = request.META.get(
            'HTTP_X_FORWARDED_FOR') or remote_addr

    user_email = ""-""
    if hasattr(request, 'user'):
        user_email = getattr(request.user, 'email', '-')

    if response.streaming:
        content_length = 'streaming'
    else:
        content_length = len(response.content)

    return {
        # 'event' makes event-based filtering possible in logging backends
        # like logstash
        'event': settings.LOGUTILS_LOGGING_MIDDLEWARE_EVENT,
        'remote_address': remote_addr,
        'user_email': user_email,
        'method': request.method,
        'url': request.get_full_path(),
        'status': response.status_code,
        'content_length': content_length,
        'request_time': -1,  # NA value: real value added by LoggingMiddleware
    }"
429,"def create_log_message(log_dict, use_sql_info=False, fmt=True):
    """"""
    Create the logging message string.
    """"""
    log_msg = (
        ""%(remote_address)s %(user_email)s %(method)s %(url)s %(status)d ""
        ""%(content_length)d (%(request_time).2f seconds)""
    )
    if use_sql_info:
        sql_time = sum(
            float(q['time']) for q in connection.queries) * 1000
        extra_log = {
            'nr_queries': len(connection.queries),
            'sql_time': sql_time}
        log_msg += "" (%(nr_queries)d SQL queries, %(sql_time)f ms)""
        log_dict.update(extra_log)
    return log_msg % log_dict if fmt else log_msg"
430,"def process_response(self, request, response):
        """"""
        Create the logging message..
        """"""
        try:
            log_dict = create_log_dict(request, response)

            # add the request time to the log_dict; if no start time is
            # available, use -1 as NA value
            request_time = (
                time.time() - self.start_time if hasattr(self, 'start_time')
                and self.start_time else -1)
            log_dict.update({'request_time': request_time})

            is_request_time_too_high = (
                request_time > float(settings.LOGUTILS_REQUEST_TIME_THRESHOLD))
            use_sql_info = settings.DEBUG or is_request_time_too_high

            log_msg = create_log_message(log_dict, use_sql_info, fmt=False)

            if is_request_time_too_high:
                logger.warning(log_msg, log_dict, extra=log_dict)
            else:
                logger.info(log_msg, log_dict, extra=log_dict)
        except Exception as e:
            logger.exception(e)

        return response"
431,"def synchronized(obj):
  """"""
  This function has two purposes:

  1. Decorate a function that automatically synchronizes access to the object
     passed as the first argument (usually `self`, for member methods)
  2. Synchronize access to the object, used in a `with`-statement.

  Note that you can use #wait(), #notify() and #notify_all() only on
  synchronized objects.

  # Example
  ```python
  class Box(Synchronizable):
    def __init__(self):
      self.value = None
    @synchronized
    def get(self):
      return self.value
    @synchronized
    def set(self, value):
      self.value = value

  box = Box()
  box.set('foobar')
  with synchronized(box):
    box.value = 'taz\'dingo'
  print(box.get())
  ```

  # Arguments
  obj (Synchronizable, function): The object to synchronize access to, or a
    function to decorate.

  # Returns
  1. The decorated function.
  2. The value of `obj.synchronizable_condition`, which should implement the
     context-manager interface (to be used in a `with`-statement).
  """"""

  if hasattr(obj, 'synchronizable_condition'):
    return obj.synchronizable_condition
  elif callable(obj):
    @functools.wraps(obj)
    def wrapper(self, *args, **kwargs):
      with self.synchronizable_condition:
        return obj(self, *args, **kwargs)
    return wrapper
  else:
    raise TypeError('expected Synchronizable instance or callable to decorate')"
432,"def wait(obj, timeout=None):
  """"""
  Wait until *obj* gets notified with #notify() or #notify_all(). If a timeout
  is specified, the function can return without the object being notified if
  the time runs out.

  Note that you can only use this function on #synchronized() objects.

  # Arguments
  obj (Synchronizable): An object that can be synchronized.
  timeout (number, None): The number of seconds to wait for the object to get
    notified before returning. If not value or the value #None is specified,
    the function will wait indefinetily.
  """"""

  if timeout is None:
    return obj.synchronizable_condition.wait()
  else:
    return obj.synchronizable_condition.wait(timeout)"
433,"def wait_for_condition(obj, cond, timeout=None):
  """"""
  This is an extended version of #wait() that applies the function *cond* to
  check for a condition to break free from waiting on *obj*. Note that *obj*
  must be notified when its state changes in order to check the condition.
  Note that access to *obj* is synchronized when *cond* is called.

  # Arguments
  obj (Synchronizable): The object to synchronize and wait for *cond*.
  cond (function): A function that accepts *obj* as an argument. Must return
    #True if the condition is met.
  timeout (number, None): The maximum number of seconds to wait.

  # Returns
  bool: #True if the condition was met, #False if not and a timeout ocurred.
  """"""

  with synchronized(obj):
    if timeout is None:
      while not cond(obj):
        wait(obj)
    else:
      t_start = time.time()
      while not cond(obj):
        t_delta = time.time() - t_start
        if t_delta >= timeout:
          return False
        wait(obj, timeout - t_delta)
  return True"
434,"def as_completed(jobs):
  ''' Generator function that yields the jobs in order of their
  completion. Attaches a new listener to each job. '''

  jobs = tuple(jobs)
  event = threading.Event()
  callback = lambda f, ev: event.set()
  [job.add_listener(Job.SUCCESS, callback, once=True) for job in jobs]
  [job.add_listener(Job.ERROR, callback, once=True) for job in jobs]

  while jobs:
    event.wait()
    event.clear()

    jobs, finished = split_list_by(jobs, lambda x: x.finished)
    for job in finished:
      yield job"
435,"def split_list_by(lst, key):
  """"""
  Splits a list by the callable *key* where a negative result will cause the
  item to be put in the first list and a positive into the second list.
  """"""

  first, second = [], []
  for item in lst:
    if key(item):
      second.append(item)
    else:
      first.append(item)
  return (first, second)"
436,"def reraise(tpe, value, tb=None):
  "" Reraise an exception from an exception info tuple. ""

  Py3 = (sys.version_info[0] == 3)
  if value is None:
    value = tpe()
  if Py3:
    if value.__traceback__ is not tb:
      raise value.with_traceback(tb)
    raise value
  else:
      exec('raise tpe, value, tb')"
437,"def result(self):
    """"""
    The result of the jobs execution. Accessing this property while the job is
    pending or running will raise #InvalidState. If an exception occured during
    the jobs execution, it will be raised.

    # Raises
    InvalidState: If the job is not in state #FINISHED.
    Cancelled: If the job was cancelled.
    any: If an exception ocurred during the job's execution.
    """"""

    if self.__cancelled:
      raise Job.Cancelled
    elif self.__state in (Job.PENDING, Job.RUNNING):
      raise Job.InvalidState('job is {0}'.format(self.__state))
    elif self.__state == Job.ERROR:
      reraise(*self.__exception)
    elif self.__state == Job.SUCCESS:
      return self.__result
    else:
      raise RuntimeError('invalid job state {0!r}'.format(self.__state))"
438,"def exception(self):
    """"""
    The exception that occured while the job executed. The value is #None if
    no exception occurred.

    # Raises
    InvalidState: If the job is #PENDING or #RUNNING.
    """"""

    if self.__state in (Job.PENDING, Job.RUNNING):
      raise self.InvalidState('job is {0}'.format(self.__state))
    elif self.__state == Job.ERROR:
      assert self.__exception is not None
      return self.__exception
    elif self.__state in (Job.RUNNING, Job.SUCCESS, Job.CANCELLED):
      assert self.__exception is None
      return None
    else:
      raise RuntimeError('invalid job state {0!r}'.format(self.__state))"
439,"def finished(self):
    """"""
    True if the job run and finished. There is no difference if the job
    finished successfully or errored.
    """"""

    return self.__state in (Job.ERROR, Job.SUCCESS, Job.CANCELLED)"
440,"def get(self, default=None):
    """"""
    Get the result of the Job, or return *default* if the job is not finished
    or errored. This function will never explicitly raise an exception. Note
    that the *default* value is also returned if the job was cancelled.

    # Arguments
    default (any): The value to return when the result can not be obtained.
    """"""

    if not self.__cancelled and self.__state == Job.SUCCESS:
      return self.__result
    else:
      return default"
441,"def cancel(self):
    """"""
    Cancels the job. Functions should check the #Job.cancelled flag from time
    to time to be able to abort pre-emptively if the job was cancelled instead
    of running forever.
    """"""

    with synchronized(self):
      cancelled = self.__cancelled
      if not cancelled:
        self.__cancelled = True
        notify_all(self)

    if not cancelled:
      self._trigger_event(Job.CANCELLED)"
442,"def _trigger_event(self, event):
    """"""
    Private. Triggers and event and removes all one-off listeners for that event.
    """"""

    if event is None or event not in self.__listeners:
      raise ValueError('invalid event type: {0!r}'.format(event))

    # Check the event has not already been triggered, then mark
    # the event as triggered.
    if event in self.__event_set:
      raise RuntimeError('event already triggered: {0!r}'.format(event))
    self.__event_set.add(event)
    listeners = self.__listeners[event] + self.__listeners[None]

    # Remove one-off listeners.
    self.__listeners[event][:] = (l for l in self.__listeners[event] if not l.once)
    self.__listeners[None][:] = (l for l in self.__listeners[None] if not l.once)

    for listener in listeners:
      # XXX: What to do on exceptions? Catch and make sure all listeners
      # run through? What to do with the exception(s) then?
      listener.callback(self, event)"
443,"def add_listener(self, event, callback, once=False):
    """"""
    Register a *callback* for the specified *event*. The function will be
    called with the #Job as its first argument. If *once* is #True, the
    listener will be removed after it has been invoked once or when the
    job is re-started.

    Note that if the event already ocurred, *callback* will be called
    immediately!

    # Arguments
    event (str, list of str): The name or multiple names of an event, or None
      to register the callback to be called for any event.
    callback (callable): A function.
    once (bool): Whether the callback is valid only once.
    """"""

    if not callable(callback):
      raise TypeError('callback must be callable')
    if isinstance(event, str):
      event = [event]
    for evn in event:
      if evn not in self.__listeners:
        raise ValueError('invalid event type: {0!r}'.format(evn))
    for evn in event:
      event_passed = False
      with synchronized(self):
        event_passed = (evn in self.__event_set)
        if not (once and event_passed):
          self.__listeners[evn].append(Job._Listener(callback, once))

    # If the event already happened, we'll invoke the callback
    # immediately to make up for what it missed.
    if event_passed:
      callback(self, event)"
444,"def wait(self, timeout=None):
    """"""
    Waits for the job to finish and returns the result.

    # Arguments
    timeout (number, None): A number of seconds to wait for the result
      before raising a #Timeout exception.

    # Raises
    Timeout: If the timeout limit is exceeded.
    """"""

    def cond(self):
      return self.__state not in (Job.PENDING, Job.RUNNING) or self.__cancelled
    if not wait_for_condition(self, cond, timeout):
      raise Job.Timeout
    return self.result"
445,"def start(self, as_thread=True, daemon=False, __state_check=True):
    """"""
    Starts the job. If the job was run once before, resets it completely. Can
    not be used while the job is running (raises #InvalidState).

    # Arguments
    as_thread (bool): Start the job in a separate thread. This is #True by
      default. Classes like the #ThreadPool calls this function from its own
      thread and passes #False for this argument.
    daemon (bool): If a thread is created with *as_thread* set to #True,
      defines whether the thread is started as a daemon or not. Defaults to
      #False.

    # Returns
    Job: The job object itself.
    """"""

    if __state_check:
      # We need to manually manage the lock to be able to release it
      # pre-emptively when needed.
      with synchronized(self):
        if self.__cancelled and self.__state == Job.PENDING:
          # Cancelled in PENDING state. Do not run the target function at all.
          self.__state = Job.CANCELLED
          assert self.__exception is None
          assert self.__result is None
          self._trigger_event(Job.CANCELLED)
          return None

        if self.__state == Job.RUNNING:
          raise Job.InvalidState('job is already running')
        elif self.__state not in (Job.PENDING, Job.ERROR, Job.SUCCESS, Job.CANCELLED):
          raise RuntimeError('invalid job state {0!r}'.format(self.__state))

        # Reset the Job attributes.
        self.__state = Job.RUNNING
        self.__cancelled = False
        self.__result = None
        self.__exception = None
        self.__event_set.clear()
        self.__thread = None

        # Remove all listeners that have been registered with the ""once"" flag.
        for listeners in self.__listeners.values():
          listeners[:] = (l for l in listeners if not l.once)

    if as_thread:
      thread = threading.Thread(target=self.start, args=(False, False, False))
      thread.setDaemon(daemon)
      with synchronized(self):
        assert not self.__thread or not self.__thread.running
        self.__thread = thread
      thread.start()
      return self

    try:
      result = None
      exception = None
      try:
        result = self.run()
        state = Job.SUCCESS
      except Exception:  # XXX: Catch BaseException?
        if self.print_exc:
          traceback.print_exc()
        exception = Job.ExceptionInfo(*sys.exc_info())
        state = Job.ERROR

      with synchronized(self):
        cancelled = self.__cancelled
        self.__result = result
        self.__exception = exception
        self.__state = Job.CANCELLED if cancelled else state

      self._trigger_event(state)
    finally:
      with synchronized(self):
        notify_all(self)
      if self.__dispose_inputs:
        self.__target = None
        self.__args = None
        self.__kwargs = None
        self.data = None
        for listeners in self.__listeners.values():
          listeners[:] = []

    return self"
446,"def run(self):
    """"""
    This method is the actual implementation of the job. By default, it calls
    the target function specified in the #Job constructor.
    """"""

    if self.__target is not None:
      return self.__target(self, *self.__args, **self.__kwargs)
    raise NotImplementedError"
447,"def factory(start_immediately=True):
    """"""
    This is a decorator function that creates new `Job`s with the wrapped
    function as the target.

    # Example
    ```python
    @Job.factory()
    def some_longish_function(job, seconds):
      time.sleep(seconds)
      return 42

    job = some_longish_function(2)
    print(job.wait())
    ```

    # Arguments
    start_immediately (bool): #True if the factory should call #Job.start()
      immediately, #False if it should return the job in pending state.
    """"""

    def decorator(func):
      def wrapper(*args, **kwargs):
        job = Job(task=lambda j: func(j, *args, **kwargs))
        if start_immediately:
          job.start()
        return job
      return wrapper
    return decorator"
448,"def start(self):
    """"""
    Starts the #ThreadPool. Must be ended with #stop(). Use the context-manager
    interface to ensure starting and the #ThreadPool.
    """"""

    if self.__running:
      raise RuntimeError('ThreadPool already running')
    [t.start() for t in self.__threads]
    self.__running = True"
449,"def current_jobs(self):
    """"""
    Returns a snapshot of the Jobs that are currently being processed by the
    ThreadPool. These jobs can not be found in the #pending_jobs() list.
    """"""

    jobs = []
    with synchronized(self.__queue):
      for worker in self.__threads:
        with synchronized(worker):
          if worker.current:
            jobs.append(worker.current)
    return jobs"
450,"def clear(self):
    """"""
    Removes all pending Jobs from the queue and return them in a list. This
    method does **no**t call #Job.cancel() on any of the jobs. If you want
    that, use #cancel_all() or call it manually.
    """"""

    with synchronized(self.__queue):
      jobs = self.__queue.snapshot()
      self.__queue.clear()
    return jobs"
451,"def cancel_all(self, cancel_current=True):
    """"""
    Similar to #clear(), but this function also calls #Job.cancel() on all
    jobs. Also, it **includes** all jobs that are currently being executed if
    *cancel_current* is True.

    # Arguments
    cancel_current (bool): Also cancel currently running jobs and include them
      in the returned list of jobs.

    # Returns
    list: A list of the #Job#s that were canceled.
    """"""

    with synchronized(self.__queue):
      jobs = self.clear()
      if cancel_current:
        jobs.extend(self.current_jobs())

    [j.cancel() for j in jobs]
    return jobs"
452,"def submit(self, target=None, task=None, args=(), kwargs=None, front=False,
             dispose_inputs=None):
    """"""
    Submit a new #Job to the ThreadPool.

    # Arguments
    task (function, Job): Either a function that accepts a #Job, *args* and
      *kwargs* or a #Job object that is in #~Job.PENDING state.
    target (function): A function object that accepts *args* and *kwargs*.
      Only if *task* is not specified.
    args (list, tuple): A list of arguments to be passed to *job*, if it is
      a function.
    kwargs (dict): A dictionary to be passed as keyword arguments to *job*,
      if it is a function.
    front (bool): If #True, the job will be inserted in the front of the queue.

    # Returns
    Job: The job that was added to the queue.

    # Raises
    TypeError: If a #Job object was passed but *args* or *kwargs* are non-empty.
    RuntimeError: If the ThreadPool is not running (ie. if it was shut down).
    """"""

    if not self.__running:
      raise RuntimeError(""ThreadPool ain't running"")
    if dispose_inputs is None:
      dispose_inputs = self.dispose_inputs

    if isinstance(task, Job):
      if args or kwargs:
        raise TypeError('can not provide additional arguments for Job')
      if task.state != Job.PENDING:
        raise RuntimeError('job is not pending')
      job = task
    elif task is not None:
      if kwargs is None:
        kwargs = {}
      job = Job(task=task, args=args, kwargs=kwargs, dispose_inputs=dispose_inputs)
    elif target is not None:
      if kwargs is None:
        kwargs = {}
      job = Job(target=target, args=args, kwargs=kwargs, dispose_inputs=dispose_inputs)
    else:
      raise TypeError('expected Job or callable')

    job.print_exc = self.print_exc
    if front:
      self.__queue.appendleft(job)
    else:
      self.__queue.append(job)
    return job"
453,"def wait(self, timeout=None):
    """"""
    Block until all jobs in the ThreadPool are finished. Beware that this can
    make the program run into a deadlock if another thread adds new jobs to the
    pool!

    # Raises
    Timeout: If the timeout is exceeded.
    """"""

    if not self.__running:
      raise RuntimeError(""ThreadPool ain't running"")
    self.__queue.wait(timeout)"
454,"def shutdown(self, wait=True):
    """"""
    Shut down the ThreadPool.

    # Arguments
    wait (bool): If #True, wait until all worker threads end. Note that pending
      jobs are still executed. If you want to cancel any pending jobs, use the
      #clear() or #cancel_all() methods.
    """"""

    if self.__running:
      # Add a Non-entry for every worker thread we have.
      for thread in self.__threads:
        assert thread.isAlive()
        self.__queue.append(None)
      self.__running = False

    if wait:
      self.__queue.wait()
      for thread in self.__threads:
        thread.join()"
455,"def submit_multiple(self, functions, target=False, task=False):
    """"""
    Submits a #Job for each element in *function* and returns a #JobCollection.
    """"""

    if target or not task:
      return JobCollection([self.submit(target=func) for func in functions])
    else:
      return JobCollection([self.submit(task=func) for func in functions])"
456,"def new_event_type(self, name, mergeable=False):
    ''' Declare a new event. May overwrite an existing entry. '''

    self.event_types[name] = self.EventType(name, mergeable)"
457,"def add_event(self, name, data=None):
    '''
    Add an event of type *name* to the queue. May raise a
    `ValueError` if the event type is mergeable and *data* is not None
    or if *name* is not a declared event type (in strict mode).
    '''

    try:
      mergeable = self.event_types[name].mergeable
    except KeyError:
      if self.strict:
        raise ValueError('unknown event type {0!r}'.format(name))
      mergeable = False

    if mergeable and data is not None:
      raise ValueError('mergable event can not have data attached')

    with self.lock:
      if mergeable:
        # Check if such an event already exists.
        for ev in self.events:
          if ev.type == name:
            return

      self.events.append(self.Event(name, data, time.clock()))"
458,"def pop_event(self):
    '''
    Pop the next queued event from the queue.

    :raise ValueError: If there is no event queued.
    '''

    with self.lock:
      if not self.events:
        raise ValueError('no events queued')
      return self.events.popleft()"
459,"def pop_events(self):
    '''
    Pop all events and return a `collections.deque` object. The
    returned container can be empty. This method is preferred over
    `pop_event()` as it is much faster as the lock has to be acquired
    only once and also avoids running into an infinite loop during
    event processing.
    '''

    with self.lock:
      events = self.events
      self.events = collections.deque()
      return events"
460,"def clear(self):
    """"""
    Clears the queue. Note that calling #wait*( immediately after clear can
    still block when tasks are currently being processed since this method can
    only clear queued items.
    """"""

    self._tasks -= len(self._deque)
    self._deque.clear()
    notify_all(self)"
461,"def get(self, block=True, timeout=None, method='pop'):
    """"""
    If *block* is True, this method blocks until an element can be removed from
    the deque with the specified *method*. If *block* is False, the function
    will raise #Empty if no elements are available.

    # Arguments
    block (bool): #True to block and wait until an element becomes available,
      #False otherwise.
    timeout (number, None): The timeout in seconds to use when waiting for
      an element (only with `block=True`).
    method (str): The name of the method to use to remove an element from the
      queue. Must be either `'pop'` or `'popleft'`.

    # Raises
    ValueError: If *method* has an invalid value.
    Timeout: If the *timeout* is exceeded.
    """"""

    if method not in ('pop', 'popleft'):
      raise ValueError('method must be ""pop"" or ""popleft"": {0!r}'.format(method))

    t_start = time.clock()
    while not self:
      if not block:
        raise self.Empty

      if timeout is None:
        wait(self)
      else:
        t_delta = time.clock() - t_start
        if t_delta > timeout:
          raise Timeout
        wait(self, timeout - t_delta)

    return getattr(self, method)()"
462,"def wait(self, timeout=None):
    """"""
    Waits until all tasks completed or *timeout* seconds passed.

    # Raises
    Timeout: If the *timeout* is exceeded.
    """"""

    t_start = time.clock()
    if not wait_for_condition(self, lambda s: s._tasks == 0, timeout):
      raise Timeout"
463,"def sleep(self):
    """"""
    Sleeps until the interval has passed since the last time this function was
    called. This is a synonym for #__call__(). The first time the function is
    called will return immediately and not block. Therefore, it is important to
    put the call at the beginning of the timed block, like this:

    # Example
    ```python
    clock = Clock(fps=50)
    while True:
      clock.sleep()
      # Processing ...
    ```
    """"""

    current = time.time()
    if self.last < 0:
      self.last = current
      return

    delta = current - self.last
    if delta < self.seconds:
      time.sleep(self.seconds - delta)
      self.last = time.time()"
464,"def read_config(desired_type: Type[ConfigParser], file_object: TextIOBase,
                logger: Logger, *args, **kwargs) -> ConfigParser:
    """"""
    Helper method to read a configuration file according to the 'configparser' format, and return it as a dictionary
    of dictionaries (section > [property > value])

    :param file_object:
    :return:
    """"""

    # see https://docs.python.org/3/library/configparser.html for details
    config = ConfigParser()
    config.read_file(file_object)

    return config"
465,"def get_default_config_parsers() -> List[AnyParser]:
    """"""
    Utility method to return the default parsers able to parse a dictionary from a file.
    :return:
    """"""
    return [SingleFileParserFunction(parser_function=read_config,
                                     streaming_mode=True,
                                     supported_exts={'.cfg', '.ini'},
                                     supported_types={ConfigParser}),
            ]"
466,"def config_to_dict_of_dict(desired_type: Type[T], config: ConfigParser, logger: Logger,
                           conversion_finder: ConversionFinder, **kwargs) -> DictOfDict:
    """"""
    Helper method to read a configuration file according to the 'configparser' format, and return it as a dictionary
    of dictionaries [section > [property > value]].

    :param file_object:
    :return:
    """"""
    # return dict(config)

    # get the base collection type if provided
    base_typ, discarded = _extract_collection_base_type(desired_type, exception_if_none=False)
    # if none, at least declare dict
    base_typ = base_typ or Dict

    # convert the whole config to a dictionary by flattening all sections. If a key is found twice in two different
    # sections an error is raised
    results = dict()
    for section, props in config.items():
        # convert all values of the sub-dictionary
        results[section] = ConversionFinder.convert_collection_values_according_to_pep(props, base_typ,
                                                                                       conversion_finder, logger,
                                                                                       **kwargs)

    return results"
467,"def merge_all_config_sections_into_a_single_dict(desired_type: Type[T], config: ConfigParser, logger: Logger,
                                                 conversion_finder: ConversionFinder, **kwargs) -> Dict[str, Any]:
    """"""
    Helper method to convert a 'configparser' into a dictionary [property > value].
    Properties from all sections are collected. If the same key appears in several sections, an
    error will be thrown

    :param file_object:
    :return:
    """"""

    # convert the whole config to a dictionary by flattening all sections. If a key is found twice in two different
    # sections an error is raised
    results = dict()
    for section, props in config.items():
        for key, value in props.items():
            if key in results.keys():
                # find all sections where it appears
                sections_where_it_appears = [s for s, p in config.items() if key in p.keys()]
                raise MultipleKeyOccurenceInConfigurationError.create(key, sections_where_it_appears)
            else:
                results[key] = value

    return ConversionFinder.convert_collection_values_according_to_pep(results, desired_type, conversion_finder,
                                                                       logger, **kwargs)"
468,"def get_default_config_converters(conv_finder: ConversionFinder) -> List[Union[Converter[Any, ConfigParser], Converter[ConfigParser, Any]]]:
    """"""
    Utility method to return the default converters associated to ConfigParser (from ConfigParser to other type,
    and from other type to ConfigParser)
    :return:
    """"""
    return [ConverterFunction(ConfigParser, DictOfDict, config_to_dict_of_dict, custom_name='config_to_dict_of_dict',
                              function_args={'conversion_finder': conv_finder}),
            ConverterFunction(ConfigParser, dict, merge_all_config_sections_into_a_single_dict,
                              custom_name='merge_all_config_sections_into_a_single_dict',
                              function_args={'conversion_finder': conv_finder})]"
469,"def create(key_name: str, sections: List[str]): # -> NoParserFoundForObject:
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param key_name:
        :param sections:
        :return:
        """"""
        return MultipleKeyOccurenceInConfigurationError('Cannot read the provided config file as a flat dictionary : '
                                                        'key \'' + key_name + '\' appears several times, in sections'
                                                                              '\'' + str(sections) + '\'.')"
470,"def logger(message, level=10):
    """"""Handle logging.""""""
    logging.getLogger(__name__).log(level, str(message))"
471,"async def get_data(self):
        """"""Get Tautulli data.""""""
        try:
            await self.get_session_data()
            await self.get_home_data()
            await self.get_users()
            await self.get_user_data()
        except (asyncio.TimeoutError, aiohttp.ClientError, socket.gaierror):
            msg = ""Can not load data from Tautulli.""
            logger(msg, 40)"
472,"async def get_session_data(self):
        """"""Get Tautulli sessions.""""""
        cmd = 'get_activity'
        url = self.base_url + cmd
        try:
            async with async_timeout.timeout(8, loop=self._loop):
                response = await self._session.get(url)

            logger(""Status from Tautulli: "" + str(response.status))
            self.tautulli_session_data = await response.json()
            logger(self.tautulli_session_data)

        except (asyncio.TimeoutError, aiohttp.ClientError, socket.gaierror,
                AttributeError) as error:
            msg = ""Can not load data from Tautulli: {} - {}"".format(url, error)
            logger(msg, 40)"
473,"async def get_home_data(self):
        """"""Get Tautulli home stats.""""""
        cmd = 'get_home_stats'
        url = self.base_url + cmd
        data = {}
        try:
            async with async_timeout.timeout(8, loop=self._loop):
                request = await self._session.get(url)
                response = await request.json()
                for stat in response.get('response', {}).get('data', {}):
                    if stat.get('stat_id') == 'top_movies':
                        try:
                            row = stat.get('rows', {})[0]
                            data['movie'] = row.get('title')
                        except (IndexError, KeyError):
                            data['movie'] = None
                    if stat.get('stat_id') == 'top_tv':
                        try:
                            row = stat.get('rows', {})[0]
                            data['tv'] = row.get('title')
                        except (IndexError, KeyError):
                            data['tv'] = None
                    if stat.get('stat_id') == 'top_users':
                        try:
                            row = stat.get('rows', {})[0]
                            data['user'] = row.get('user')
                        except (IndexError, KeyError):
                            data['user'] = None
            logger(""Status from Tautulli: "" + str(request.status))
            self.tautulli_home_data = data
            logger(self.tautulli_home_data)

        except (asyncio.TimeoutError, aiohttp.ClientError, socket.gaierror,
                AttributeError) as error:
            msg = ""Can not load data from Tautulli: {} - {}"".format(url, error)
            logger(msg, 40)"
474,"async def get_users(self):
        """"""Get Tautulli users.""""""
        cmd = 'get_users'
        url = self.base_url + cmd
        users = []
        try:
            async with async_timeout.timeout(8, loop=self._loop):
                response = await self._session.get(url)

            logger(""Status from Tautulli: "" + str(response.status))
            all_user_data = await response.json()
            for user in all_user_data['response']['data']:
                if user['username'] != 'Local':
                    users.append(user['username'])
            self.tautulli_users = users
            logger(self.tautulli_users)

        except (asyncio.TimeoutError, aiohttp.ClientError, socket.gaierror,
                AttributeError) as error:
            msg = ""Can not load data from Tautulli: {} - {}"".format(url, error)
            logger(msg, 40)"
475,"async def get_user_data(self):
        """"""Get Tautulli userdata.""""""
        userdata = {}
        sessions = self.session_data.get('sessions', {})
        try:
            async with async_timeout.timeout(8, loop=self._loop):
                for username in self.tautulli_users:
                    userdata[username] = {}
                    userdata[username]['Activity'] = None
                    for session in sessions:
                        if session['username'].lower() == username.lower():
                            userdata[username]['Activity'] = session['state']
                            for key in session:
                                if key != 'Username':
                                    userdata[username][key] = session[key]
                            break

            self.tautulli_user_data = userdata
        except (asyncio.TimeoutError, aiohttp.ClientError, KeyError):
            msg = ""Can not load data from Tautulli.""
            logger(msg, 40)"
476,"def import_string(impstr, attr=None):
    """"""Imports a string. Can import an attribute of the imported
    class/module using a double colon as a separator
    """"""
    if ""::"" in impstr:
        impstr, attr = impstr.split(""::"")
    imported = wz_import_string(impstr)
    if attr is not None:
        return getobjpath(imported, attr)
    return imported"
477,"def getobjpath(obj, path):
    """"""Returns an item or attribute of the object recursively.
    Item names are specified between brackets, eg: [item].
    Attribute names are prefixed with a dot (the first one is optional), eg: .attr
    Example: getobjpath(obj, ""attr1.attr2[item].attr3"")
    """"""
    if not path:
        return obj
    if path.startswith(""[""):
        item = path[1:path.index(""]"")]
        return getobjpath(obj[item], path[len(item) + 2:])
    if path.startswith("".""):
        path = path[1:]
    if ""."" in path or ""["" in path:
        dot_idx = path.find(""."")
        bracket_idx = path.find(""["")
        if dot_idx == -1 or bracket_idx < dot_idx:
            idx = bracket_idx
            next_idx = idx
        else:
            idx = dot_idx
            next_idx = idx + 1
        attr = path[:idx]
        return getobjpath(getattr(obj, attr), path[next_idx:])
    return getattr(obj, path)"
478,"def find_classes_in_module(module, clstypes):
    """"""Find classes of clstypes in module
    """"""
    classes = []
    for item in dir(module):
        item = getattr(module, item)
        try:
            for cls in clstypes:
                if issubclass(item, cls) and item != cls:
                    classes.append(item)
        except Exception as e:
            pass
    return classes"
479,"def remove_yaml_frontmatter(source, return_frontmatter=False):
    """"""If there's one, remove the YAML front-matter from the source
    """"""
    if source.startswith(""---\n""):
        frontmatter_end = source.find(""\n---\n"", 4)
        if frontmatter_end == -1:
            frontmatter = source
            source = """"
        else:
            frontmatter = source[0:frontmatter_end]
            source = source[frontmatter_end + 5:]
        if return_frontmatter:
            return (source, frontmatter)
        return source
    if return_frontmatter:
        return (source, None)
    return source"
480,"def populate_obj(obj, attrs):
    """"""Populates an object's attributes using the provided dict
    """"""
    for k, v in attrs.iteritems():
        setattr(obj, k, v)"
481,"def insert_element_to_dict_of_list(dict_of_list, key, parser):
    """"""
    Utility method

    :param dict_of_list:
    :param key:
    :param parser:
    :return:
    """"""
    if key in dict_of_list.keys():
        dict_of_list[key].append(parser)
    else:
        dict_of_list[key] = [parser]"
482,"def insert_element_to_dict_of_dicts_of_list(dict_of_dict_of_list, first_key, second_key, parser):
    """"""
    Utility method

    :param dict_of_dict_of_list:
    :param first_key:
    :param second_key:
    :param parser:
    :return:
    """"""
    list_to_insert = parser if isinstance(parser, list) else [parser]

    if first_key not in dict_of_dict_of_list.keys():
        dict_of_dict_of_list[first_key] = {second_key: list_to_insert}
    else:
        if second_key not in dict_of_dict_of_list[first_key].keys():
            dict_of_dict_of_list[first_key][second_key] = list_to_insert
        else:
            dict_of_dict_of_list[first_key][second_key] += list_to_insert"
483,"def insert_element_to_dict_of_dicts(dict_of_dicts: Dict[str, Dict[str, str]], first_key: str, second_key: str, contents):
    """"""
    Utility method

    :param dict_of_dicts:
    :param first_key:
    :param second_key:
    :param contents:
    :return:
    """"""

    if first_key not in dict_of_dicts.keys():
        dict_of_dicts[first_key] = {second_key: contents}
    else:
        if second_key not in dict_of_dicts[first_key].keys():
            dict_of_dicts[first_key][second_key] = contents
        else:
            warn('Overriding contents for ' + first_key + '/' + second_key)
            dict_of_dicts[first_key][second_key] = contents"
484,"def build_parser_for_fileobject_and_desiredtype(self, obj_on_filesystem: PersistedObject, object_type: Type[T],
                                                    logger: Logger = None) -> Parser:
        """"""
        Returns the most appropriate parser to use to parse object obj_on_filesystem as an object of type object_type

        :param obj_on_filesystem: the filesystem object to parse
        :param object_type: the type of object that the parser is expected to produce
        :param logger:
        :return:
        """"""
        pass"
485,"def create(obj: PersistedObject, obj_type: Type[T], extensions_supported: Iterable[str]):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param obj:
        :param obj_type:
        :param extensions_supported:
        :return:
        """"""

        # base message
        msg = ""{obj} cannot be parsed as a {typ} because no parser supporting that extension ({ext}) is able to "" \
              ""create this type of object."" \
              """".format(obj=obj, typ=get_pretty_type_str(obj_type), ext=obj.get_pretty_file_ext())

        # add details
        if extensions_supported is not None and len(extensions_supported) > 0:
            msg += "" If you wish to parse this fileobject to that precise type, you may wish to either "" \
                   ""(1) replace the file with any of the following extensions currently supported : {exts} "" \
                   ""(see get_capabilities_for_type({typ}, strict_type_matching=False) for details)."" \
                   "" Or (2) register a new parser."" \
                   """".format(exts=extensions_supported, typ=get_pretty_type_str(obj_type))
        else:
            raise ValueError('extensions_supported should be provided to create a NoParserFoundForObjectExt. If no '
                             'extension is supported, use NoParserFoundForObjectType.create instead')

        e = NoParserFoundForObjectExt(msg)

        # save the extensions supported
        e.extensions_supported = extensions_supported

        return e"
486,"def create(obj: PersistedObject, obj_type: Type[T], types_supported: Iterable[str]):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param obj:
        :param obj_type:
        :param types_supported:
        :return:
        """"""

        # base message
        msg = str(obj) + ' cannot be parsed as a ' + get_pretty_type_str(obj_type) + ' because no parser supporting ' \
              'that type is registered for ' + obj.get_pretty_file_ext() + '.\n'

        # add details
        if types_supported is not None and len(types_supported) > 0:
            msg += ' If you wish to parse this object from this extension, you may wish to parse it as one of the ' \
                   'following supported types : ' + str(types_supported) + '. \n' \
                   + 'Otherwise, please register a new parser for type ' + get_pretty_type_str(obj_type) \
                   + ' and extension ' + obj.get_pretty_file_ext() + '\n Reminder: use print_capabilities_by_ext()' \
                   + ' and print_capabilities_by_type() to diagnose what are the parsers available'
        else:
            raise ValueError('extensions_supported should be provided to create a NoParserFoundForObjectExt. If no '
                             'extension is supported, use NoParserFoundForObjectType.create instead')

        e = NoParserFoundForObjectType(msg)

        # save the extensions supported
        e.types_supported = types_supported

        return e"
487,"def create(obj: PersistedObject, obj_type: Type[T], errors: Dict[Type, Exception]):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param obj:
        :param errors: a dictionary of the errors raised for each alternate type tried
        :return:
        """"""

        e = NoParserFoundForUnionType('{obj} cannot be parsed as a {typ} because no parser could be found for any of '
                                      'the alternate types. Caught exceptions: {errs}'
                                      ''.format(obj=obj, typ=get_pretty_type_str(obj_type), errs=errors))

        # save the errors
        e.errors = errors

        return e"
488,"def register_parsers(self, parsers: List[Parser]):
        """"""
        Utility method to register any list of parsers.
        :return:
        """"""
        check_var(parsers, var_types=list, var_name='parsers')
        for parser in parsers:
            self.register_parser(parser)"
489,"def print_capabilities_by_ext(self, strict_type_matching: bool = False):
        """"""
        Used to print the list of all file extensions that can be parsed by this parser registry.
        :return:
        """"""
        print('\nCapabilities by file extension: ')
        l = self.get_capabilities_by_ext(strict_type_matching=strict_type_matching)
        pprint({ext: get_pretty_type_keys_dict(parsers) for ext, parsers in l.items()})
        print('\n')"
490,"def print_capabilities_by_type(self, strict_type_matching: bool = False):
        """"""
        Used to print the list of all file extensions that can be parsed by this parser registry.
        :return:
        """"""
        print('\nCapabilities by object type: ')
        l = self.get_capabilities_by_type(strict_type_matching=strict_type_matching)
        pprint({get_pretty_type_str(typ): parsers for typ, parsers in l.items()})
        print('\n')"
491,"def get_capabilities_by_type(self, strict_type_matching: bool = False) -> Dict[Type, Dict[str, Dict[str, Parser]]]:
        """"""
        For all types that are supported,
        lists all extensions that can be parsed into such a type.
        For each extension, provides the list of parsers supported. The order is ""most pertinent first""

        This method is for monitoring and debug, so we prefer to not rely on the cache, but rather on the query engine.
        That will ensure consistency of the results.

        :param strict_type_matching:
        :return:
        """"""

        check_var(strict_type_matching, var_types=bool, var_name='strict_matching')

        res = dict()

        # List all types that can be parsed
        for typ in self.get_all_supported_types():
            res[typ] = self.get_capabilities_for_type(typ, strict_type_matching)

        return res"
492,"def get_capabilities_by_ext(self, strict_type_matching: bool = False) -> Dict[str, Dict[Type, Dict[str, Parser]]]:
        """"""
        For all extensions that are supported,
        lists all types that can be parsed from this extension.
        For each type, provide the list of parsers supported. The order is ""most pertinent first""

        This method is for monitoring and debug, so we prefer to not rely on the cache, but rather on the query engine.
        That will ensure consistency of the results.

        :param strict_type_matching:
        :return:
        """"""
        check_var(strict_type_matching, var_types=bool, var_name='strict_matching')
        res = dict()

        # For all extensions that are supported,
        for ext in self.get_all_supported_exts_for_type(type_to_match=JOKER, strict=strict_type_matching):
            res[ext] = self.get_capabilities_for_ext(ext, strict_type_matching)

        return res"
493,"def get_capabilities_for_ext(self, ext, strict_type_matching: bool = False) -> Dict[Type, Dict[str, Parser]]:
        """"""
        Utility method to return, for a given file extension, all known ways to parse a file with this extension,
        organized by target object type.

        :param ext:
        :param strict_type_matching:
        :return:
        """"""
        r = dict()
        # List all types that can be parsed from this extension.
        for typ in self.get_all_supported_types_for_ext(ext):
            # Use the query to fill
            matching = self.find_all_matching_parsers(strict_type_matching, desired_type=typ, required_ext=ext)[0]
            # matching_list = matching[0] + matching[1] + matching[2]
            # insert_element_to_dict_of_dicts_of_list(res, ext, typ, list(reversed(matching_list)))
            r[typ] = dict()
            exact = list(reversed(matching[2]))
            if len(exact) > 0:
                r[typ]['1_exact_match'] = exact

            approx = list(reversed(matching[1]))
            if len(approx) > 0:
                r[typ]['2_approx_match'] = approx

            generic = list(reversed(matching[0]))
            if len(generic) > 0:
                r[typ]['3_generic'] = generic

            # insert_element_to_dict_of_dicts(res, ext, typ, matching_dict)
        return r"
494,"def register_parser(self, parser: Parser):
        """"""
        Utility method to register any parser. Parsers that support any type will be stored in the ""generic""
        list, and the others will be stored in front of the types they support
        :return:
        """"""
        check_var(parser, var_types=Parser, var_name='parser')
        if (not parser.supports_multifile()) and (not parser.supports_singlefile()):
            # invalid
            raise _InvalidParserException.create(parser)

        # (0) sanity check : check that parser handles jokers properly
        res = parser.is_able_to_parse_detailed(desired_type=JOKER, desired_ext=JOKER, strict=True)
        if not (res[0] is True and res[1] is None):
            raise ValueError('Parser ' + str(parser) + ' can not be registered since it does not handle the JOKER cases '
                             'correctly')

        # (1) store in the main lists
        if parser.is_generic():
            self._generic_parsers.append(parser)
        else:
            self._specific_parsers.append(parser)

        # (2) simpler : simply store the ext <> type maps
        for ext in parser.supported_exts:
            for typ in parser.supported_types:
                insert_element_to_dict_of_list(self._strict_types_to_ext, typ, ext)
                insert_element_to_dict_of_list(self._ext_to_strict_types, ext, typ)"
495,"def get_all_parsers(self, strict_type_matching: bool = False) -> List[Parser]:
        """"""
        Returns the list of all parsers in order of relevance.
        :return:
        """"""
        matching = self.find_all_matching_parsers(strict=strict_type_matching)[0]

        # matching[1] (approx match) is supposed to be empty since we use a joker on type and a joker on ext : only
        # exact and generic match should exist, no approx match
        if len(matching[1]) > 0:
            raise Exception('Internal error - this matching[1] list is supposed to be empty for such a query')
        return matching[0] + matching[2]"
496,"def get_all_supported_types_for_ext(self, ext_to_match: str, strict_type_matching: bool = False) -> Set[Type]:
        """"""
        Utility method to return the set of all supported types that may be parsed from files with the given extension.
        ext=JOKER is a joker that means all extensions

        :param ext_to_match:
        :param strict_type_matching:
        :return:
        """"""
        matching = self.find_all_matching_parsers(required_ext=ext_to_match, strict=strict_type_matching)[0]
        return {typ for types in [p.supported_types for p in (matching[0] + matching[1] + matching[2])]
                for typ in types}"
497,"def get_all_supported_exts_for_type(self, type_to_match: Type[Any], strict: bool) -> Set[str]:
        """"""
        Utility method to return the set of all supported file extensions that may be converted to objects of the given
        type. type=JOKER is a joker that means all types

        :param type_to_match:
        :param strict:
        :return:
        """"""
        matching = self.find_all_matching_parsers(desired_type=type_to_match, strict=strict)[0]
        return {ext for exts in [p.supported_exts for p in (matching[0] + matching[1] + matching[2])]
                for ext in exts}"
498,"def find_all_matching_parsers(self, strict: bool, desired_type: Type[Any] = JOKER, required_ext: str = JOKER) \
            -> Tuple[Tuple[List[Parser], List[Parser], List[Parser]],
                     List[Parser], List[Parser], List[Parser]]:
        """"""
        Implementation of the parent method by lookin into the registry to find the most appropriate parsers to use in
        order

        :param strict:
        :param desired_type: the desired type, or 'JOKER' for a wildcard
        :param required_ext:
        :return: match=(matching_parsers_generic, matching_parsers_approx, matching_parsers_exact),
                 no_type_match_but_ext_match, no_ext_match_but_type_match, no_match
        """"""

        # if desired_type is JOKER and required_ext is JOKER:
        #     # Easy : return everything (GENERIC first, SPECIFIC then) in order (make a copy first :) )
        #     matching_parsers_generic = self._generic_parsers.copy()
        #     matching_parsers_approx = []
        #     matching_parsers_exact = self._specific_parsers.copy()
        #     no_type_match_but_ext_match = []
        #     no_ext_match_but_type_match = []
        #     no_match = []
        # else:
        #
        # Although the above could be thought as an easy way to accelerate the process, it does not any more since the
        # JOKER  special cases are handled in parser.is_able_to_parse and converter.is_able_to_convert functions.
        #
        # It was also dangerous since it prevented us to get consistency across views - hence parser/converter
        # implementors could get the feeling that their parser was correctly registered where it wasn't

        check_var(strict, var_types=bool, var_name='strict')
        # first transform any 'Any' type requirement into the official class for that
        desired_type = get_validated_type(desired_type, 'desired_type', enforce_not_joker=False)

        matching_parsers_generic = []
        matching_parsers_approx = []
        matching_parsers_exact = []
        no_type_match_but_ext_match = []
        no_ext_match_but_type_match = []
        no_match = []

        # handle generic parsers first - except if desired type is Any
        for p in self._generic_parsers:
            match = p.is_able_to_parse(desired_type=desired_type, desired_ext=required_ext, strict=strict)
            if match:
                # match
                if is_any_type(desired_type):
                    # special case : what is required is Any, so put in exact match
                    matching_parsers_exact.append(p)
                else:
                    matching_parsers_generic.append(p)

            else:
                # check if by releasing the constraint on ext it makes a match
                if p.is_able_to_parse(desired_type=desired_type, desired_ext=JOKER, strict=strict):
                    no_ext_match_but_type_match.append(p)
                else:
                    # there will be no way to use this: it is a generic parser that is not able to parse this type...
                    # no_type_match_but_ext_match.append(p)
                    pass

        # then the specific
        for p in self._specific_parsers:
            match, exact_match = p.is_able_to_parse_detailed(desired_type=desired_type,
                                                             desired_ext=required_ext,
                                                             strict=strict)
            if match:
                if is_any_type(desired_type):
                    # special case: dont register as a type match
                    no_type_match_but_ext_match.append(p)
                else:
                    if exact_match is None or exact_match:
                        matching_parsers_exact.append(p)
                    else:
                        matching_parsers_approx.append(p)

            else:
                # try to set the type to a supported type to see if that makes a match
                if p.is_able_to_parse(desired_type=JOKER, desired_ext=required_ext, strict=strict):
                    no_type_match_but_ext_match.append(p)

                # try to set the ext to a supported ext to see if that makes a match
                elif p.is_able_to_parse(desired_type=desired_type, desired_ext=JOKER, strict=strict):
                    no_ext_match_but_type_match.append(p)

                # no match at all
                else:
                    no_match.append(p)

        return (matching_parsers_generic, matching_parsers_approx, matching_parsers_exact), \
               no_type_match_but_ext_match, no_ext_match_but_type_match, no_match"
499,"def _create_parsing_plan(self, desired_type: Type[T], filesystem_object: PersistedObject, logger: Logger,
                             log_only_last: bool = False) -> ParsingPlan[T]:
        """"""
        Implementation of Parser API
        Relies on the underlying registry of parsers to provide the best parsing plan
        :param desired_type:
        :param filesystem_object:
        :param logger:
        :param log_only_last: a flag to only log the last part of the file path (default False)
        :return:
        """"""
        # find the parser for this object
        t, combined_parser = self.build_parser_for_fileobject_and_desiredtype(filesystem_object, desired_type,
                                                                           logger=logger)
        # ask the parser for the parsing plan
        return combined_parser.create_parsing_plan(t, filesystem_object, logger)"
500,"def build_parser_for_fileobject_and_desiredtype(self, obj_on_filesystem: PersistedObject, object_type: Type[T],
                                                    logger: Logger = None) -> Tuple[Type, Parser]:
        """"""
        Builds from the registry, a parser to parse object obj_on_filesystem as an object of type object_type.

        To do that, it iterates through all registered parsers in the list in reverse order (last inserted first),
        and checks if they support the provided object format (single or multifile) and type.
        If several parsers match, it returns a cascadingparser that will try them in order.

        If several alternatives are requested (through a root Union type), this is done independently for each
        alternative.

        :param obj_on_filesystem:
        :param object_type:
        :param logger:
        :return: a type to use and a parser. The type to use is either directly the one provided, or a resolved one in
        case of TypeVar
        """"""
        # First resolve TypeVars and Unions to get a list of compliant types
        object_types = get_alternate_types_resolving_forwardref_union_and_typevar(object_type)

        if len(object_types) == 1:
            # One type: proceed as usual
            parsers = self._build_parser_for_fileobject_and_desiredtype(obj_on_filesystem, object_typ=object_types[0],
                                                                        logger=logger)
            if len(parsers) > 1:
                return object_types[0], CascadingParser(parsers)
            else:
                return next(iter(parsers.items()))
        else:
            # Several alternate types are supported: try to build a parser for each
            parsers = OrderedDict()
            errors = OrderedDict()
            for typ in object_types:
                try:
                    parsers.update(self._build_parser_for_fileobject_and_desiredtype(obj_on_filesystem, object_typ=typ,
                                                                                     logger=logger))
                except NoParserFoundForObjectExt as e:
                    logger.warning(""{} - {}"".format(type(e).__name__, e))
                    errors[e] = e
                except NoParserFoundForObjectType as f:
                    logger.warning(""{} - {}"".format(type(f).__name__, f))
                    errors[f] = f

            # Combine if there are remaining, otherwise raise
            if len(parsers) > 0:
                return object_type, CascadingParser(parsers)
            else:
                raise NoParserFoundForUnionType.create(obj_on_filesystem, object_type, errors)"
501,"def _build_parser_for_fileobject_and_desiredtype(self, obj_on_filesystem: PersistedObject, object_typ: Type[T],
                                                     logger: Logger = None) -> Dict[Type, Parser]:
        """"""
        Builds a parser for each subtype of object_typ

        :param obj_on_filesystem:
        :param object_typ:
        :param logger:
        :return:
        """"""

        parsers = OrderedDict()
        errors = OrderedDict()
        try:
            p = self.__build_parser_for_fileobject_and_desiredtype(obj_on_filesystem,
                                                                   object_typ=object_typ,
                                                                   logger=logger)
            parsers[object_typ] = p
        except NoParserFoundForObjectExt as e:
            logger.warning(""{} - {}"".format(type(e).__name__, e))
            errors[e] = e
        except NoParserFoundForObjectType as f:
            logger.warning(""{} - {}"".format(type(f).__name__, f))
            errors[f] = f

        # do not explore subclasses for collections
        if is_collection(object_typ, strict=True):
            if len(errors) > 0:
                raise next(iter(errors.values()))
            else:
                return parsers

        # Finally create one such parser for each subclass
        subclasses = get_all_subclasses(object_typ)

        # Then for each subclass also try (with a configurable limit in nb of subclasses)
        for subclass in subclasses[0:GLOBAL_CONFIG.dict_to_object_subclass_limit]:
            try:
                parsers[subclass] = self.__build_parser_for_fileobject_and_desiredtype(obj_on_filesystem,
                                                                                       object_typ=subclass,
                                                                                       logger=logger)
            except NoParserFoundForObjectExt as e:
                logger.warning(""{} - {}"".format(type(e).__name__, e))
                errors[e] = e
            except NoParserFoundForObjectType as f:
                logger.warning(""{} - {}"".format(type(f).__name__, f))
                errors[f] = f

        if len(subclasses) > GLOBAL_CONFIG.dict_to_object_subclass_limit:
            warn('Type {} has more than {} subclasses, only {} were tried to convert it, with no success. You '
                 'can raise this limit by setting the appropriate option with `parsyfiles_global_config()`'
                 ''.format(object_typ, len(subclasses), GLOBAL_CONFIG.dict_to_object_subclass_limit))

        return parsers"
502,"def __build_parser_for_fileobject_and_desiredtype(self, obj_on_filesystem: PersistedObject, object_typ: Type[T],
                                                      logger: Logger = None) -> Parser:
        """"""
        Builds from the registry, a parser to parse object obj_on_filesystem as an object of type object_type.

        To do that, it iterates through all registered parsers in the list in reverse order (last inserted first),
        and checks if they support the provided object format (single or multifile) and type.
        If several parsers match, it returns a cascadingparser that will try them in order.

        :param obj_on_filesystem:
        :param object_typ:
        :param logger:
        :return:
        """"""

        # first remove any non-generic customization
        object_type = get_base_generic_type(object_typ)

        # find all matching parsers for this
        matching, no_type_match_but_ext_match, no_ext_match_but_type_match, no_match = \
            self.find_all_matching_parsers(strict=self.is_strict, desired_type=object_type,
                                           required_ext=obj_on_filesystem.ext)
        matching_parsers = matching[0] + matching[1] + matching[2]

        if len(matching_parsers) == 0:
            # No match. Do we have a close match ? (correct type, but not correct extension ?)
            if len(no_ext_match_but_type_match) > 0:
                raise NoParserFoundForObjectExt.create(obj_on_filesystem, object_type,
                                                       set([ext_ for ext_set in
                                                        [p.supported_exts for p in no_ext_match_but_type_match]
                                                        for ext_ in ext_set]))
            else:
                # no, no match at all
                raise NoParserFoundForObjectType.create(obj_on_filesystem, object_type,
                                                        set([typ_ for typ_set in
                                                        [p.supported_types for p in no_type_match_but_ext_match]
                                                        for typ_ in typ_set]))

        elif len(matching_parsers) == 1:
            # return the match directly
            return matching_parsers[0]
        else:
            # return a cascade of all parsers, in reverse order (since last is our preferred one)
            # print('----- WARNING : Found several parsers able to parse this item. Combining them into a cascade.')
            return CascadingParser(list(reversed(matching_parsers)))"
503,"def create(att_name: str, parsed_att: S, attribute_type: Type[T], caught_exec: Dict[Converter[S, T], Exception]):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param att_name:
        :param parsed_att:
        :param attribute_type:
        :param caught_exec:
        :return:
        """"""
        base_msg = ""Error while trying to convert value for attribute '{a}' to type <{t}>:\n"" \
                   ""   - parsed value is : '{v}' of type <{tv}>\n"" \
                   """".format(a=str(att_name), t=get_pretty_type_str(attribute_type), v=parsed_att,
                             tv=get_pretty_type_str(type(parsed_att)))

        msg = StringIO()
        if len(list(caught_exec.keys())) > 0:
            msg.writelines('   - converters tried are : \n      * ')
            msg.writelines('\n      * '.join([str(converter) for converter in caught_exec.keys()]))
            msg.writelines(' \n Caught the following exceptions: \n')

            for converter, err in caught_exec.items():
                msg.writelines('--------------- From ' + str(converter) + ' caught: \n')
                print_error_to_io_stream(err, msg)
                msg.write('\n')

        return AttrConversionException(base_msg + msg.getvalue())"
504,"def create(conversion_finder, parsed_att: Any, attribute_type: Type[Any], errors: Dict[Type, Exception] = None):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param parsed_att:
        :param attribute_type:
        :param conversion_finder:
        :return:
        """"""
        if conversion_finder is None:
            msg = ""No conversion finder provided to find a converter between parsed attribute '{patt}' of type "" \
                  ""'{typ}' and expected type '{expt}'."".format(patt=str(parsed_att),
                                                               typ=get_pretty_type_str(type(parsed_att)),
                                                               expt=get_pretty_type_str(attribute_type))
        else:
            msg = ""No conversion chain found between parsed attribute '{patt}' of type '{typ}' and expected type "" \
                  ""'{expt}' using conversion finder {conv}."".format(patt=parsed_att,
                                                                    typ=get_pretty_type_str(type(parsed_att)),
                                                                    expt=get_pretty_type_str(attribute_type),
                                                                    conv=conversion_finder)
        if errors is not None:
            msg = msg + ' ' + str(errors)

        return NoConverterFoundForObjectType(msg)"
505,"def get_all_conversion_chains_to_type(self, to_type: Type[Any])\
            -> Tuple[List[Converter], List[Converter], List[Converter]]:
        """"""
        Utility method to find all converters to a given type

        :param to_type:
        :return:
        """"""
        return self.get_all_conversion_chains(to_type=to_type)"
506,"def get_all_conversion_chains_from_type(self, from_type: Type[Any]) \
            -> Tuple[List[Converter], List[Converter], List[Converter]]:
        """"""
        Utility method to find all converters from a given type.

        :param from_type:
        :return:
        """"""
        return self.get_all_conversion_chains(from_type=from_type)"
507,"def get_all_conversion_chains(self, from_type: Type[Any] = JOKER, to_type: Type[Any] = JOKER)\
            -> Tuple[List[Converter], List[Converter], List[Converter]]:
        """"""
        Utility method to find all converters or conversion chains matching the provided query.

        :param from_type: a required type of input object, or JOKER for 'wildcard'(*) .
        WARNING: ""from_type=AnyObject/object/Any"" means
        ""all converters able to source from anything"", which is different from ""from_type=JOKER"" which means ""all
        converters whatever their source type"".
        :param to_type: a required type of output object, or JOKER for 'wildcard'(*) .
        WARNING: ""to_type=AnyObject/object/Any"" means ""all
        converters able to produce any type of object"", which is different from ""to_type=JOKER"" which means ""all
        converters whatever type they are able to produce"".
        :return: a tuple of lists of matching converters, by type of *dest_type* match : generic, approximate, exact
        """"""
        pass"
508,"def find_and_convert(self, attr_name: str, attr_value: S, desired_attr_type: Type[T], logger: Logger,
                         options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        Utility method to convert some value into the desired type. It relies on get_all_conversion_chains to find the
        converters, and apply them in correct order
        :return:
        """"""

        if robust_isinstance(attr_value, desired_attr_type) and not is_collection(desired_attr_type):
            # value is already of the correct type
            return attr_value

        else:
            # try to find conversion chains
            generic, approx, exact = self.get_all_conversion_chains(type(attr_value), desired_attr_type)
            all_chains = generic + approx + exact

            if len(all_chains) > 0:
                all_errors = dict()
                for chain in reversed(all_chains):
                    try:
                        return chain.convert(desired_attr_type, attr_value, logger, options)
                    except Exception as e:
                        all_errors[chain] = e
                raise AttrConversionException.create(attr_name, attr_value, desired_attr_type, all_errors)

            else:
                # did not find any conversion chain
                raise NoConverterFoundForObjectType.create(self, attr_value, desired_attr_type)"
509,"def convert_collection_values_according_to_pep(coll_to_convert: Union[Dict, List, Set, Tuple],
                                                   desired_type: Type[T],
                                                   conversion_finder: 'ConversionFinder', logger: Logger, **kwargs) \
            -> T:
        """"""
        Helper method to convert the values of a collection into the required (pep-declared) value type in desired_type.
        If desired_type does not explicitly mention a type for its values, the collection will be returned as is, otherwise
        a  copy will be created and filled with conversions of the values, performed by the provided conversion_finder

        :param coll_to_convert:
        :param desired_type:
        :param conversion_finder:
        :param logger:
        :param kwargs:
        :return:
        """"""
        base_desired_type = get_base_generic_type(desired_type)

        if issubclass(base_desired_type, Mapping):  # or issubclass(base_desired_type, dict):
            # get the base collection type if provided (this raises an error if key type is not str)
            item_typ, _ = _extract_collection_base_type(desired_type, exception_if_none=False)

            if item_typ is None:
                # nothing is required in terms of dict values: use the base method
                return ConversionFinder.try_convert_value(conversion_finder, '', coll_to_convert, desired_type,
                                                          logger=logger, options=kwargs)
            else:
                # TODO resuse appropriate container type (not necessary a dict) according to type of coll_to_convert
                # there is a specific type required for the dict values.
                res = dict()
                # convert if required
                for key, val in coll_to_convert.items():
                    res[key] = ConversionFinder.try_convert_value(conversion_finder, key, val, item_typ, logger,
                                                                  options=kwargs)
                return res

        elif issubclass(base_desired_type, Sequence):  # or issubclass(base_desired_type, list):
            # get the base collection type if provided
            item_typ, _ = _extract_collection_base_type(desired_type, exception_if_none=False)

            if item_typ is None:
                # nothing is required in terms of dict values: use the base method
                return ConversionFinder.try_convert_value(conversion_finder, '', coll_to_convert, desired_type,
                                                          logger=logger, options=kwargs)
            else:
                # TODO resuse appropriate container type (not necessary a list) according to type of coll_to_convert
                # there is a specific type required for the list values.
                res = list()

                # special case where base_desired_type is a Tuple: in that case item_typ may be a tuple or else
                if type(item_typ) != tuple:
                    # convert each item if required
                    for val in coll_to_convert:
                        res.append(ConversionFinder.try_convert_value(conversion_finder, '', val, item_typ, logger,
                                                                      options=kwargs))
                else:
                    if len(item_typ) == 1:
                        item_typ_tuple = item_typ * len(coll_to_convert)
                    elif len(item_typ) == len(coll_to_convert):
                        item_typ_tuple = item_typ
                    else:
                        raise ValueError('Collection to convert is of length {} which is not compliant with desired '
                                         'type {}'.format(len(coll_to_convert), item_typ))
                    for val, item_t in zip(coll_to_convert, item_typ_tuple):
                        res.append(ConversionFinder.try_convert_value(conversion_finder, '', val, item_t, logger,
                                                                      options=kwargs))
                    res = tuple(res)

                return res

        elif issubclass(base_desired_type, AbstractSet):  # or issubclass(base_desired_type, set):
            # get the base collection type if provided
            item_typ, _ = _extract_collection_base_type(desired_type, exception_if_none=False)

            if item_typ is None:
                # nothing is required in terms of dict values: use the base method
                return ConversionFinder.try_convert_value(conversion_finder, '', coll_to_convert, desired_type,
                                                          logger=logger, options=kwargs)
            else:
                # TODO resuse appropriate container type (not necessary a set) according to type of coll_to_convert
                # there is a specific type required for the list values.
                res = set()
                # convert if required
                for val in coll_to_convert:
                    res.add(ConversionFinder.try_convert_value(conversion_finder, '', val, item_typ, logger,
                                                               options=kwargs))
                return res

        else:
            raise TypeError('Cannot convert collection values, expected type is not a supported collection '
                            '(dict, list, set, Mapping, Sequence, AbstractSet)! : ' + str(desired_type))"
510,"def _try_convert_value(conversion_finder, attr_name: str, attr_value: S, desired_attr_type: Type[T], logger: Logger,
                           options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        Utility method to try to use provided conversion_finder to convert attr_value into desired_attr_type.
        If no conversion is required, the conversion finder is not even used (it can be None)

        :param conversion_finder:
        :param attr_name:
        :param attr_value:
        :param desired_attr_type:
        :param logger:
        :param options:
        :return:
        """"""

        # check if we need additional conversion

        # (a) a collection with details about the internal item type
        if is_typed_collection(desired_attr_type):
            return ConversionFinder.convert_collection_values_according_to_pep(coll_to_convert=attr_value,
                                                                               desired_type=desired_attr_type,
                                                                               conversion_finder=conversion_finder,
                                                                               logger=logger,
                                                                               **options)
        # --- typing types do not work with isinstance so there is a special check here
        elif not robust_isinstance(attr_value, desired_attr_type):
            if conversion_finder is not None:
                return conversion_finder.find_and_convert(attr_name,
                                                          attr_value,
                                                          desired_attr_type,
                                                          logger, options)
            else:
                raise NoConverterFoundForObjectType.create(conversion_finder,
                                                           attr_value,
                                                           desired_attr_type)
        else:
            # we can safely use the value: it is already of the correct type
            return attr_value"
511,"def register_converter(self, converter: Converter[S, T]):
        """"""
        Utility method to register any converter. Converters that support any type will be stored in the ""generic""
        lists, and the others will be stored in front of the types they support
        :return:
        """"""
        check_var(converter, var_types=Converter, var_name='converter')

        # (0) sanity check : check that parser handles jokers properly
        res = converter.is_able_to_convert_detailed(from_type=JOKER, to_type=JOKER, strict=True)
        if not (res[0] is True and res[1] is None and res[2] is None):
            raise ValueError('Converter ' + str(converter) + ' can not be registered since it does not handle the JOKER'
                             ' cases correctly')

        # compute all possible chains and save them
        generic_chains, generic_nonstrict_chains, specific_chains, specific_nonstrict_chains \
            = self._create_all_new_chains(converter)
        self._generic_nonstrict_conversion_chains += generic_nonstrict_chains
        self._generic_conversion_chains += generic_chains
        self._specific_non_strict_conversion_chains += specific_nonstrict_chains
        self._specific_conversion_chains += specific_chains

        # sort all lists by length
        self._generic_nonstrict_conversion_chains = sorted(self._generic_nonstrict_conversion_chains, key=len,
                                                           reverse=True)
        self._generic_conversion_chains = sorted(self._generic_conversion_chains, key=len, reverse=True)
        self._specific_non_strict_conversion_chains = sorted(self._specific_non_strict_conversion_chains, key=len,
                                                             reverse=True)
        self._specific_conversion_chains = sorted(self._specific_conversion_chains, key=len, reverse=True)"
512,"def _create_all_new_chains(self, converter) -> Tuple[List[Converter], List[Converter],
                                                         List[Converter], List[Converter]]:
        """"""
        Creates all specific and generic chains that may be built by adding this converter to the existing chains.

        :param converter:
        :return: generic_chains, generic_nonstrict_chains, specific_chains, specific_nonstrict_chains
        """"""

        specific_chains, specific_nonstrict_chains, generic_chains, generic_nonstrict_chains = [], [], [], []

        if converter.is_generic():
            # the smaller chain : the singleton :)
            generic_chains.append(ConversionChain(initial_converters=[converter], strict_chaining=True))
        else:
            specific_chains.append(ConversionChain(initial_converters=[converter], strict_chaining=True))


        # 1) create new specific chains by adding this converter at the beginning or end of all *non-generic* ones
        # -- non-strict
        new_c_at_end_ns = []
        new_c_at_beginning_ns = []
        if not self.strict:
            # then there are non-strict chains already. Try to connect to them
            for existing_specific_nonstrict in self._specific_non_strict_conversion_chains:
                if converter.can_be_appended_to(existing_specific_nonstrict, strict=False):
                    if ConversionChain.are_worth_chaining(existing_specific_nonstrict, converter):
                        new_c_at_end_ns.append(ConversionChain.chain(existing_specific_nonstrict, converter,
                                                                     strict=False))
                if existing_specific_nonstrict.can_be_appended_to(converter, strict=False):
                    if ConversionChain.are_worth_chaining(converter, existing_specific_nonstrict):
                        new_c_at_beginning_ns.append(ConversionChain.chain(converter, existing_specific_nonstrict,
                                                                           strict=False))

        # -- strict
        new_c_at_end = []
        new_c_at_beginning = []
        for existing_specific in self._specific_conversion_chains:
            # first try *strict* mode
            if converter.can_be_appended_to(existing_specific, strict=True):
                if ConversionChain.are_worth_chaining(existing_specific, converter):
                    new_c_at_end.append(ConversionChain.chain(existing_specific, converter, strict=True))
            elif (not self.strict) and converter.can_be_appended_to(existing_specific, strict=False):
                if ConversionChain.are_worth_chaining(existing_specific, converter):
                    new_c_at_end_ns.append(ConversionChain.chain(existing_specific, converter, strict=False))

            if existing_specific.can_be_appended_to(converter, strict=True):
                if ConversionChain.are_worth_chaining(converter, existing_specific):
                    # TODO this is where when chaining a generic to a specific, we would actually have to restrict it
                    # note: but maybe we dont care since now this is checked and prevented in the convert() method
                    new_c_at_beginning.append(ConversionChain.chain(converter, existing_specific, strict=True))
            elif (not self.strict) and existing_specific.can_be_appended_to(converter, strict=False):
                if ConversionChain.are_worth_chaining(converter, existing_specific):
                    # TODO this is where when chaining a generic to a specific, we would actually have to restrict it
                    # note: but maybe we dont care since now this is checked and prevented in the convert() method
                    new_c_at_beginning_ns.append(ConversionChain.chain(converter, existing_specific, strict=False))

        # append to the right list depending on the nature of this converter
        if converter.is_generic():
            generic_chains += new_c_at_end
            generic_nonstrict_chains += new_c_at_end_ns
        else:
            specific_chains += new_c_at_end
            specific_nonstrict_chains += new_c_at_end_ns
        # common for both types
        specific_chains += new_c_at_beginning
        specific_nonstrict_chains += new_c_at_beginning_ns

        # by combining all created chains into a big one
        for a in new_c_at_end:
            for b in new_c_at_beginning:
                b_ = b.remove_first()
                if b_.can_be_appended_to(a, strict=True):
                    if ConversionChain.are_worth_chaining(a, b_):
                        specific_chains.append(ConversionChain.chain(a, b_, strict=True))
            for b in new_c_at_beginning_ns:
                b_ = b.remove_first()
                if b_.can_be_appended_to(a, strict=False):
                    if ConversionChain.are_worth_chaining(a, b_):
                        specific_nonstrict_chains.append(ConversionChain.chain(a, b_, strict=False))
        for a in new_c_at_end_ns:
            for b in (new_c_at_beginning_ns + new_c_at_beginning):
                b_ = b.remove_first()
                if b_.can_be_appended_to(a, strict=False):
                    if ConversionChain.are_worth_chaining(a, b_):
                        specific_nonstrict_chains.append(ConversionChain.chain(a, b_, strict=False))

        # by inserting this converter at the beginning of an existing *generic*
        if converter.is_generic():
            # we want to avoid chaining generic converters together
            pass
        else:
            new_c_at_beginning_generic = []
            new_c_at_beginning_generic_ns = []
            for existing_specific in self._generic_conversion_chains:
                # start with strict
                if existing_specific.can_be_appended_to(converter, strict=True):
                    if ConversionChain.are_worth_chaining(converter, existing_specific):
                        new_c_at_beginning_generic.append(ConversionChain.chain(converter, existing_specific,
                                                                                strict=True))
                elif (not self.strict) and existing_specific.can_be_appended_to(converter, strict=False):
                    if ConversionChain.are_worth_chaining(converter, existing_specific):
                        new_c_at_beginning_generic_ns.append(ConversionChain.chain(converter, existing_specific,
                                                                                   strict=False))

            for existing_specific_ns in self._generic_nonstrict_conversion_chains:
                if existing_specific_ns.can_be_appended_to(converter, strict=False):
                    if ConversionChain.are_worth_chaining(converter, existing_specific_ns):
                        new_c_at_beginning_generic_ns.append(ConversionChain.chain(converter, existing_specific_ns,
                                                                               strict=False))
            generic_chains += new_c_at_beginning_generic
            generic_nonstrict_chains += new_c_at_beginning_generic_ns

            # by combining specific and generic created chains into a big one
            for a in new_c_at_end:
                for b in new_c_at_beginning_generic:
                    b_ = b.remove_first()
                    if b_.can_be_appended_to(a, strict=True):
                        if ConversionChain.are_worth_chaining(a, b_):
                            generic_chains.append(ConversionChain.chain(a, b_, strict=True))
                for b in new_c_at_beginning_generic_ns:
                    b_ = b.remove_first()
                    if b_.can_be_appended_to(a, strict=False):
                        if ConversionChain.are_worth_chaining(a, b_):
                            generic_nonstrict_chains.append(ConversionChain.chain(a, b_, strict=False))
            for a in new_c_at_end_ns:
                for b in (new_c_at_beginning_generic_ns + new_c_at_beginning_generic):
                    b_ = b.remove_first()
                    if b_.can_be_appended_to(a, strict=False):
                        if ConversionChain.are_worth_chaining(a, b_):
                            generic_nonstrict_chains.append(ConversionChain.chain(a, b_, strict=False))

        return generic_chains, generic_nonstrict_chains, specific_chains, specific_nonstrict_chains"
513,"def get_all_conversion_chains(self, from_type: Type[Any] = JOKER, to_type: Type[Any] = JOKER) \
            -> Tuple[List[Converter], List[Converter], List[Converter]]:
        """"""
        Utility method to find matching converters or conversion chains.

        :param from_type: a required type of input object, or JOKER for 'wildcard'(*) .
        WARNING: ""from_type=AnyObject/object/Any"" means
        ""all converters able to source from anything"", which is different from ""from_type=JOKER"" which means ""all
        converters whatever their source type"".
        :param to_type: a required type of output object, or JOKER for 'wildcard'(*) .
        WARNING: ""to_type=AnyObject/object/Any"" means ""all
        converters able to produce any type of object"", which is different from ""to_type=JOKER"" which means ""all
        converters whatever type they are able to produce"".
        :return: a tuple of lists of matching converters, by type of *dest_type* match : generic, approximate, exact.
        The order of each list is from *less relevant* to *most relevant*
        """"""

        if from_type is JOKER and to_type is JOKER:
            matching_dest_generic = self._generic_nonstrict_conversion_chains.copy() + \
                                    self._generic_conversion_chains.copy()
            matching_dest_approx = []
            matching_dest_exact = self._specific_non_strict_conversion_chains.copy() + \
                                  self._specific_conversion_chains.copy()

        else:
            matching_dest_generic, matching_dest_approx, matching_dest_exact = [], [], []

            # first transform any 'Any' type requirement into the official class for that
            to_type = get_validated_type(to_type, 'to_type', enforce_not_joker=False)

            # handle generic converters first
            for c in (self._generic_nonstrict_conversion_chains + self._generic_conversion_chains):
                match, source_exact, dest_exact = c.is_able_to_convert_detailed(strict=self.strict,
                                                                                from_type=from_type,
                                                                                to_type=to_type)
                if match:
                    # match
                    if is_any_type(to_type):
                        # special case where desired to_type is already Any : in that case a generic converter will
                        # appear in 'exact match'
                        matching_dest_exact.append(c)
                    else:
                        # this is a match from a generic parser to a specific type : add in 'generic' cataegory
                        matching_dest_generic.append(c)

            # then the specific
            for c in (self._specific_non_strict_conversion_chains + self._specific_conversion_chains):
                match, source_exact, dest_exact = c.is_able_to_convert_detailed(strict=self.strict,
                                                                                from_type=from_type,
                                                                                to_type=to_type)
                if match:
                    if not is_any_type(to_type):
                        if dest_exact:
                            # we dont care if source is exact or approximate as long as dest is exact
                            matching_dest_exact.append(c)
                        else:
                            # this means that dest is approximate.
                            matching_dest_approx.append(c)
                    else:
                        # we only want to keep the generic ones, and they have already been added
                        pass

        return matching_dest_generic, matching_dest_approx, matching_dest_exact"
514,"def find_all_matching_parsers(self, strict: bool, desired_type: Type[Any] = JOKER, required_ext: str = JOKER) \
        -> Tuple[Tuple[List[Parser], List[Parser], List[Parser]],
                 List[Parser], List[Parser], List[Parser]]:
        """"""
        Overrides the parent method to find parsers appropriate to a given extension and type.
        This leverages both the parser registry and the converter registry to propose parsing chains in a relevant order

        :param strict:
        :param desired_type: the type of object to match.
        :param required_ext: the required extension.
        :return: match=(matching_parsers_generic, matching_parsers_approx, matching_parsers_exact),
                 no_type_match_but_ext_match, no_ext_match_but_type_match, no_match
        """"""
        # transform any 'Any' type requirement into the official class for that
        desired_type = get_validated_type(desired_type, 'desired_type', enforce_not_joker=False)

        # (1) call the super method to find all parsers
        matching, no_type_match_but_ext_match, no_ext_match_but_type_match, no_match = \
            super(ParserRegistryWithConverters, self).find_all_matching_parsers(strict=self.is_strict,
                                                                                desired_type=desired_type,
                                                                                required_ext=required_ext)
        # these are ordered with 'preferred last'
        matching_p_generic, matching_p_approx, matching_p_exact = matching

        if desired_type is JOKER:
            # then we want to try to append every possible converter chain, even if we have already found an exact match
            # (exact match will probably contain all parsers in that case?...)
            parsers_to_complete_with_converters = no_type_match_but_ext_match + matching_p_generic + matching_p_approx \
                                                  + matching_p_exact
        else:
            # then we can try to complete all the ones matching the extension (even the generic because combining them
            # with a conversion chain might provide another way to reach the result - different from using the generic
            # alone to reach the to_type)
            parsers_to_complete_with_converters = no_type_match_but_ext_match + matching_p_generic + matching_p_approx

        # (2) find all conversion chains that lead to the expected result
        matching_c_generic_to_type, matching_c_approx_to_type, matching_c_exact_to_type = \
            self.get_all_conversion_chains_to_type(to_type=desired_type)
        all_matching_converters = matching_c_generic_to_type + matching_c_approx_to_type + matching_c_exact_to_type

        # (3) combine both (parser + conversion chain), and append to the appropriate list depending on the match
        # -- (a) first Parsers matching EXT (not type) + Converters matching their type
        # for all parsers able to parse this extension, and for all the types they support
        #
        # (we have to reverse the list because now we want 'preferred first'. Indeed we wish to prepend to the match
        # lists in order not to hide the parser direct matches)
        matching_p_generic_with_approx_chain, matching_p_approx_with_approx_chain, matching_p_exact_with_approx_chain\
            = [], [], []
        for parser in reversed(parsers_to_complete_with_converters):
            for typ in parser.supported_types:
                match_results = self._complete_parsers_with_converters(parser, typ, desired_type,
                                                                       matching_c_generic_to_type,
                                                                       matching_c_approx_to_type,
                                                                       matching_c_exact_to_type)
                # prepend the existing lists with the new match
                matching_p_generic = match_results[1] + matching_p_generic
                matching_p_approx = match_results[3] + matching_p_approx
                matching_p_exact = match_results[5] + matching_p_exact

                # store the approximate matchs in the separate lists
                matching_p_generic_with_approx_chain = match_results[0] + matching_p_generic_with_approx_chain
                matching_p_approx_with_approx_chain = match_results[2] + matching_p_approx_with_approx_chain
                matching_p_exact_with_approx_chain = match_results[4] + matching_p_exact_with_approx_chain

        # finally prepend the approximate match lists
        matching_p_generic = matching_p_generic_with_approx_chain + matching_p_generic
        matching_p_approx = matching_p_approx_with_approx_chain + matching_p_approx
        matching_p_exact = matching_p_exact_with_approx_chain + matching_p_exact

        # -- (b) then parsers that do not match at all (not the file extension nor the type): we can find parsing chains
        # that make them at least match the type
        #
        # (we have to reverse it because it was 'best last', now it will be 'best first')
        for parser in reversed(no_match):
            for typ in parser.supported_types:
                for converter in reversed(all_matching_converters):
                    # if converter is able to source from this parser
                    if converter.is_able_to_convert(self.is_strict, from_type=typ, to_type=desired_type):
                        if ParsingChain.are_worth_chaining(parser, typ, converter):
                            # insert it at the beginning since it should have less priority
                            no_ext_match_but_type_match.insert(0, ParsingChain(parser, converter, strict=self.is_strict,
                                                                               base_parser_chosen_dest_type=typ))

        # Finally sort by chain length
        matching_p_generic = sorted(matching_p_generic, key=len, reverse=True)
        matching_p_approx = sorted(matching_p_approx, key=len, reverse=True)
        matching_p_exact = sorted(matching_p_exact, key=len, reverse=True)

        # Return
        return (matching_p_generic, matching_p_approx, matching_p_exact), no_type_match_but_ext_match, \
               no_ext_match_but_type_match, no_match"
515,"def _complete_parsers_with_converters(self, parser, parser_supported_type, desired_type, matching_c_generic_to_type,
                                          matching_c_approx_to_type, matching_c_exact_to_type):
        """"""
        Internal method to create parsing chains made of a parser and converters from the provided lists.
        Once again a JOKER for a type means 'joker' here.

        :param parser:
        :param parser_supported_type:
        :param desired_type:
        :param matching_c_generic_to_type:
        :param matching_c_approx_to_type:
        :param matching_c_exact_to_type:
        :return:
        """"""

        matching_p_generic, matching_p_generic_with_approx_chain, \
        matching_p_approx, matching_p_approx_with_approx_chain,\
        matching_p_exact, matching_p_exact_with_approx_chain = [], [], [], [], [], []

        # resolve Union and TypeVar
        desired_types = get_alternate_types_resolving_forwardref_union_and_typevar(desired_type)

        for desired_type in desired_types:

            # first transform any 'Any' type requirement into the official class for that
            desired_type = get_validated_type(desired_type, 'desired_type', enforce_not_joker=False)

            # ---- Generic converters - only if the parsed type is not already 'any'
            if not is_any_type(parser_supported_type):
                for cv in matching_c_generic_to_type:
                    # if the converter can attach to this parser, we have a matching parser !

                    # --start from strict
                    if cv.is_able_to_convert(strict=True,
                                             from_type=parser_supported_type,
                                             to_type=desired_type):
                        if ParsingChain.are_worth_chaining(parser, parser_supported_type, cv):
                            chain = ParsingChain(parser, cv, strict=True,
                                                 base_parser_chosen_dest_type=parser_supported_type)
                            # insert it at the beginning since it should have less priority
                            matching_p_generic.append(chain)

                    # --then non-strict
                    elif (not self.strict) \
                            and cv.is_able_to_convert(strict=False,
                                                      from_type=parser_supported_type,
                                                      to_type=desired_type):
                        if ParsingChain.are_worth_chaining(parser, parser_supported_type, cv):
                            chain = ParsingChain(parser, cv, strict=False,
                                                 base_parser_chosen_dest_type=parser_supported_type)
                            # insert it at the beginning since it should have less priority
                            matching_p_generic_with_approx_chain.append(chain)

            # ---- Approx to_type
            for cv in matching_c_approx_to_type:
                # if the converter can attach to this parser, we have a matching parser !
                # -- start from strict
                if cv.is_able_to_convert(strict=True,
                                         from_type=parser_supported_type,
                                         to_type=desired_type):
                    if ParsingChain.are_worth_chaining(parser, parser_supported_type, cv):
                        chain = ParsingChain(parser, cv, strict=True,
                                             base_parser_chosen_dest_type=parser_supported_type)
                        # insert it at the beginning since it should have less priority
                        matching_p_approx.append(chain)
                # then non-strict
                elif (not self.strict) \
                        and cv.is_able_to_convert(strict=False,
                                                  from_type=parser_supported_type,
                                                  to_type=desired_type):
                    if ParsingChain.are_worth_chaining(parser, parser_supported_type, cv):
                        chain = ParsingChain(parser, cv, strict=False,
                                             base_parser_chosen_dest_type=parser_supported_type)
                        # insert it at the beginning since it should have less priority
                        matching_p_approx_with_approx_chain.append(chain)

            # ---- Exact to_type
            for cv in matching_c_exact_to_type:
                # if the converter can attach to this parser, we have a matching parser !
                if cv.is_able_to_convert(strict=True,
                                         from_type=parser_supported_type,
                                         to_type=desired_type):
                    if ParsingChain.are_worth_chaining(parser, parser_supported_type, cv):
                        chain = ParsingChain(parser, cv, strict=True,
                                             base_parser_chosen_dest_type=parser_supported_type)
                        # insert it at the beginning since it should have less priority
                        matching_p_exact.append(chain)
                elif (not self.strict) \
                        and cv.is_able_to_convert(strict=False,
                                                  from_type=parser_supported_type,
                                                  to_type=desired_type):
                    if ParsingChain.are_worth_chaining(parser, parser_supported_type, cv):
                        chain = ParsingChain(parser, cv, strict=False,
                                             base_parser_chosen_dest_type=parser_supported_type)
                        # insert it at the beginning since it should have less priority
                        matching_p_exact_with_approx_chain.append(chain)

        # Preferred is LAST, so approx should be first
        return matching_p_generic_with_approx_chain, matching_p_generic, \
               matching_p_approx_with_approx_chain, matching_p_approx, \
               matching_p_exact_with_approx_chain, matching_p_exact"
516,"def parse_config(filename):
  """"""
  Parses a versionupgrade configuration file. Example:

      tag v{VERSION}
      branch v{VERSION}
      message Prepare {VERSION} release
      upgrade setup.py:  version = '{VERSION}'
      upgrade __init__.py:__version__ = '{VERSION}'
      sub docs/changelog/v{VERSION}.md:# v{VERSION} (unreleased):# v{VERSION} ({DATE})

  Available commands:

    - tag: Create a Git tag with the specified name.
    - branch: Create a Git branch with the specified name.
    - message: The commit message for upgraded version numbers.
    - upgrade: Upgrade the version number in the file matching the pattern.
               The same file may be listed multiple times. The pattern may
               actually be a regular expression and will be searched in
               every line of the file.
    - sub: Specify a file where the part of the file matching the first string
           will be replaced by the second string.

  Returns a #Config object.
  """"""

  tag = None
  branch = None
  message = 'Prepare {VERSION} release.'
  upgrades = {}
  subs = {}

  with open(filename) as fp:
    for i, line in enumerate(fp):
      line = line.strip()
      if not line or line.startswith('#'): continue

      key, sep, value = line.partition(' ')
      if not key or not value:
        raise ValueError('invalid configuration file at line {}'.format(i+1))

      if key == 'tag':
        tag = value.strip()
      elif key == 'branch':
        branch = value.strip()
      elif key == 'message':
        message = value.strip()
      elif key == 'upgrade':
        filename, sep, pattern = value.partition(':')
        if not filename or not sep or not pattern or '{VERSION}' not in pattern:
          raise ValueError('invalid upgrade argument at line {}'.format(i+1))
        upgrade = upgrades.setdefault(filename, [])
        upgrade.append(pattern)
      elif key == 'sub':
        filename, sep, pattern = value.partition(':')
        pattern = pattern.partition(':')[::2]
        if not pattern[0] or not pattern[1]:
          raise ValueError('invalid sub argument at line {}'.format(i+1))
        subs.setdefault(filename, []).append(pattern)
      else:
        raise ValueError('invalid command {!r} at line {}'.format(key, i+1))

  return Config(tag, branch, message, upgrades, subs)"
517,"def match_version_pattern(filename, pattern):
  """"""
  Matches a single version upgrade pattern in the specified *filename*
  and returns the match information. Returns a #Match object or #None
  if the *pattern* did not match.
  """"""

  if ""{VERSION}"" not in pattern:
    raise ValueError(""pattern does not contain a {VERSION} reference"")
  pattern = pattern.replace('{VERSION}', '(?P<v>[\d\w\.\-_]+)')
  expr = re.compile(pattern)
  with open(filename) as fp:
    lines = fp.read().split('\n')
  for i, line in enumerate(lines):
    match = expr.search(line)
    if match:
      return Match(filename, lines, line_index=i,
          version=Version(match.group('v')), span=match.span('v'))
  return None"
518,"def get_changed_files(include_staged=False):
  """"""
  Returns a list of the files that changed in the Git repository. This is
  used to check if the files that are supposed to be upgraded have changed.
  If so, the upgrade will be prevented.
  """"""

  process = subprocess.Popen(['git', 'status', '--porcelain'],
    stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
  stdout, __ = process.communicate()
  if process.returncode != 0:
    raise ValueError(stdout)
  files = []
  for line in stdout.decode().split('\n'):
    if not line or line.startswith('#'): continue
    assert line[2] == ' '
    if not include_staged and line[1] == ' ': continue
    files.append(line[3:])
  return files"
519,"def _parse_doc(docs):
    """"""
        Converts a well-formed docstring into documentation
        to be fed into argparse.

        See signature_parser for details.

        shorts: (-k for --keyword -k, or ""from"" for ""frm/from"")
        metavars: (FILE for --input=FILE)
        helps: (docs for --keyword: docs)
        description: the stuff before
        epilog: the stuff after
    """"""

    name = ""(?:[a-zA-Z][a-zA-Z0-9-_]*)""

    re_var = re.compile(r""^ *(%s)(?: */(%s))? *:(.*)$"" % (name, name))
    re_opt = re.compile(r""^ *(?:(-[a-zA-Z0-9]),? +)?--(%s)(?: *=(%s))? *:(.*)$""
                        % (name, name))

    shorts, metavars, helps, description, epilog = {}, {}, {}, """", """"

    if docs:

        for line in docs.split(""\n""):

            line = line.strip()

            # remove starting ':param'
            if line.startswith(':param'):
                line = line[len(':param'):]

            # skip ':rtype:' row
            if line.startswith(':rtype:'):
                continue

            if line.strip() == ""----"":
                break

            m = re_var.match(line)
            if m:
                if epilog:
                    helps[prev] += epilog.strip()
                    epilog = """"

                if m.group(2):
                    shorts[m.group(1)] = m.group(2)

                helps[m.group(1)] = m.group(3).strip()
                prev = m.group(1)
                previndent = len(line) - len(line.lstrip())
                continue

            m = re_opt.match(line)
            if m:
                if epilog:
                    helps[prev] += epilog.strip()
                    epilog = """"
                name = m.group(2).replace(""-"", ""_"")
                helps[name] = m.group(4)
                prev = name

                if m.group(1):
                    shorts[name] = m.group(1)
                if m.group(3):
                    metavars[name] = m.group(3)

                previndent = len(line) - len(line.lstrip())
                continue

            if helps:
                if line.startswith("" "" * (previndent + 1)):
                    helps[prev] += ""\n"" + line.strip()
                else:
                    epilog += ""\n"" + line.strip()
            else:
                description += ""\n"" + line.strip()

            if line.strip():
                previndent = len(line) - len(line.lstrip())

    return shorts, metavars, helps, description, epilog"
520,"def signature_parser(func):
    """"""
        Creates an argparse.ArgumentParser from the function's signature.

        Arguments with no default are compulsary positional arguments,
        Arguments with defaults are optional --flags.

        If the default is True or False, the action of the flag will
        toggle the argument and the flag takes no parameters.

        If the default is None or a unicode string, the flag takes a
        string argument that passed to the function as a unicode string
        decoded using entrypoint.ENCODING

        If the default is a string, then the argument is passed as a binary
        string (be careful!), an int and a float cause parsing of those too.

        If you want the arguments to be a file, consider using the
        @withfile decorator.

        Documentation can be read out of the function's docstring, which should
        be of the basic form:
        '''
            A short introduction to your program.

                arg: Help for positional parameter.
                frm/from: Help for a positional parameter
                          with a reserved public name
                          (i.e. this displays to the user as ""from""
                          but sets the ""frm"" variable)
                --opt: Help for optional parameter.
                -f --flag: An optional parameter that has a short version.
                --mode=MODE: An optional parameter that takes a MODE
                -t --type: A combination of both of the above, and one
                                which requires continuing of the documentation
                                on an indented line

            An epilog explaining anything you feel needs further clarity.

            ----

            Any documentation for the function itself that isn't covered by the
            public documentation above the line.
        '''

        All sections, and indeed the presence of a docstring, are not required.

        NOTE: for this to work, the function's signature must be in-tact
              some decorators (like @acceptargv for example) destroy, or
              mutilate the signature.
    """"""

    args, trail, kwargs, defaults = inspect.getargspec(func)

    if not args:
        args = []

    if not defaults:
        defaults = []

    if kwargs:
        raise Exception(""Can't wrap a function with **kwargs"")

    # Compulsary positional options
    needed = args[0:len(args) - len(defaults)]

    # Optional flag options
    params = args[len(needed):]

    shorts, metavars, helps, description, epilog = _parse_doc(func.__doc__)

    parser = argparse.ArgumentParser(
        description=description,
        epilog=epilog,
        formatter_class=ParagraphPreservingArgParseFormatter)

    # special flags
    special_flags = []

    special_flags += ['debug']
    defaults += (False,)
    helps['debug'] = 'set logging level to DEBUG'
    if module_version(func):
        special_flags += ['version']
        defaults += (False,)
        helps['version'] = ""show program's version number and exit""
    params += special_flags

    # Optional flag options
    used_shorts = set()
    for param, default in zip(params, defaults):
        args = [""--%s"" % param.replace(""_"", ""-"")]
        short = None
        if param in shorts:
            short = shorts[param]
        else:
            if param not in special_flags and len(param) > 1:
                first_char = param[0]
                if first_char not in used_shorts:
                    used_shorts.add(first_char)
                    short = '-' + first_char
        # -h conflicts with 'help'
        if short and short != '-h':
            args = [short] + args

        kwargs = {'default': default, 'dest': param.replace(""-"", ""_"")}

        if param == 'version':
            kwargs['action'] = 'version'
            kwargs['version'] = module_version(func)
        elif default is True:
            kwargs['action'] = 'store_false'
        elif default is False:
            kwargs['action'] = 'store_true'
        elif isinstance(default, list):
            kwargs['action'] = 'append'
#  default is not working
#            if len(default):
#                first = default[0]
#                if type(first) in [type(None), unicode]:
#                    kwargs['type'] = unidecode
#                else:
#                    kwargs['type'] = type(first)
#                kwargs['default'] = []
#            else:
            kwargs['type'] = unidecode
        else:
            kwargs['action'] = 'store'
            if type(default) in [type(None), unicode]:
                kwargs['type'] = unidecode
            else:
                kwargs['type'] = type(default)

        if param in helps:
            kwargs['help'] = helps[param]

        if param in metavars:
            kwargs['metavar'] = metavars[param]

        parser.add_argument(*args, **kwargs)

    # Compulsary positional options
    for need in needed:

        kwargs = {'action': 'store', 'type': unidecode}

        if need in helps:
            kwargs['help'] = helps[need]

        if need in shorts:
            args = [shorts[need]]
        else:
            args = [need]

        parser.add_argument(*args, **kwargs)

    # The trailing arguments
    if trail:
        kwargs = {'action': 'store', 'type': unidecode, 'nargs': ""*""}

        if trail in helps:
            kwargs['help'] = helps[trail]

        if trail in shorts:
            kwargs['metavar'] = shorts[trail]
        else:
            kwargs['metavar'] = trail

        parser.add_argument('__args', **kwargs)

    return parser"
521,"def _correct_args(func, kwargs):
    """"""
        Convert a dictionary of arguments including __argv into a list
        for passing to the function.
    """"""
    args = inspect.getargspec(func)[0]
    return [kwargs[arg] for arg in args] + kwargs['__args']"
522,"def entrypoint(func):
    """"""
        A decorator for your main() function.

        Really a combination of @autorun and @acceptargv, so will run the
        function if __name__ == '__main__' with arguments extricated from
        argparse.

        As with @acceptargv, this must either be the innermost decorator, or
        separated only by ""well-behaved"" decorators that preserve the __doc__
        attribute AND the function signature.

        As with @autorun, this must be theoutermost decorator, as any
        decorators further out will not be applied to the function until after
        it is run.
    """"""
    frame_local = sys._getframe(1).f_locals
    if '__name__' in frame_local and frame_local['__name__'] == '__main__':
        argv = sys.argv[1:]

        parser = signature_parser(func)
        try:
            kwargs = parser.parse_args(argv).__dict__

            # special cli flags

            # --version is handled by ArgParse
            # if kwargs.get('version'):
            #    print module_version(func)
            #    return
            if 'version' in kwargs.keys():
                del kwargs['version']

            # --debug
            FORMAT = '%(asctime)-6s: %(name)s - %(levelname)s - %(message)s'
            if kwargs.get('debug'):
                logging.basicConfig(
                    level=logging.DEBUG,
                    format=FORMAT,
                )
            del kwargs['debug']

            if ""__args"" in kwargs:
                return func(*_correct_args(func, kwargs))
            else:
                return func(**kwargs)

        except UsageError, e:
            parser.error(e.message)

    return func"
523,"def autorun(func, _depth=1):
    """"""
        Runs the function if the module in which it is declared is being run
        directly from the commandline. Putting the following after the function
        definition would be similar:

        if __name__ == '__main__':
            func()

        NOTE: This will work most expectedly as the outermost decorator, as it
        will call the function before any more outwards decorators have been
        applied.
    """"""

    frame_local = sys._getframe(_depth).f_locals
    if '__name__' in frame_local and frame_local['__name__'] == '__main__':
        func(argv=sys.argv[1:])

    return func"
524,"def acceptargv(func):
    """"""
        Transforms the signature of the function, and it's associated __doc__
        into an argparse-parser, then calls the function with the results of
        using said parser.

        The function returned takes an optional argument, which is the list of
        parameters, if they are not given, sys.argv[1:] is used instead.

        The function may raise a UsageError() if it wants to signal an error
        that the user has made with the parameters, this is done by
        @withuserfile for example.

        CAVEAT: this relies on the argument signature of the function, if that
                has been destroyed, perhaps by a badly behaved decorator, this
                won't work as expected.

        CAVEAT2: this destroys the argument signature of the function ;)
    """"""

    parser = signature_parser(func)

    def main(*args, **kw):
        argv = kw.get('argv', None)
        if argv == None:
            return func(*args, **kw)
        else:
            try:
                kwargs = parser.parse_args(argv).__dict__

                # special cli flags

                # --version is handled by ArgParse
                # if kwargs.get('version'):
                #    print module_version(func)
                #    return
                if 'version' in kwargs.keys():
                    del kwargs['version']

                # --debug
                if kwargs.get('debug'):
                    logging.basicConfig(level=logging.DEBUG)
                del kwargs['debug']

                if ""__args"" in kwargs:
                    return func(*_correct_args(func, kwargs))
                else:
                    return func(**kwargs)
            except UsageError, e:
                parser.error(e.message)

    main.__doc__ = func.__doc__
    main.__name__ = func.__name__
    main.__module__ = func.__module__
    main.__dict__ = func.__dict__.copy()

    return main"
525,"def quote(text):
  'Handle quote characters'

  # Convert to unicode.
  if not isinstance(text, unicode):
    text = text.decode('utf-8')

  # Look for quote characters. Keep the text as is if it's already quoted.
  for qp in QUOTEPAIRS:
    if text[0] == qp[0] and text[-1] == qp[-1] and len(text) >= 2:
      return text

  # If it's not quoted, try quoting
  for qp in QUOTEPAIRS:
    if qp[1] not in text:
      return qp[0] + text + qp[1]

  #Darn
  raise ValueError(u'The value ""%s"" is not quoted and contains too many quote characters to quote' % text)"
526,"def register_opener(suffix, opener=None):
  """"""
  Register a callback that opens an archive with the specified *suffix*.
  The object returned by the *opener* must implement the #tarfile.Tarfile
  interface, more specifically the following methods:

  - `add(filename, arcname) -> None`
  - `getnames() -> list of str`
  - `getmember(filename) -> TarInfo`
  - `extractfile(filename) -> file obj`

  This function can be used as a decorator when *opener* is not provided.

  The opener must accept the following arguments:

  %%arglist
  file (file-like): A file-like object to read the archive data from.
  mode (str): The mode to open the file in. Valid values are
    `'w'`, `'r'` and `'a'`.
  options (dict): A dictionary with possibly additional arguments.
  """"""

  if opener is None:
    def decorator(func):
      register_opener(suffix, func)
      return func
    return decorator
  if suffix in openers:
    raise ValueError('opener suffix {0!r} already registered'.format(suffix))
  openers[suffix] = opener"
527,"def get_opener(filename):
  """"""
  Finds a matching opener that is registed with :func:`register_opener`
  and returns a tuple ``(suffix, opener)``. If there is no opener that
  can handle this filename, :class:`UnknownArchive` is raised.
  """"""

  for suffix, opener in openers.items():
    if filename.endswith(suffix):
      return suffix, opener
  raise UnknownArchive(filename)"
528,"def open(filename=None, file=None, mode='r', suffix=None, options=None):
  """"""
  Opens the archive at the specified *filename* or from the file-like
  object *file* using the appropriate opener. A specific opener can be
  specified by passing the *suffix* argument.

  # Parameters
  filename (str): A filename to open the archive from.
  file (file-like): A file-like object as source/destination.
  mode (str): The mode to open the archive in.
  suffix (str): Possible override for the *filename* suffix. Must be
    specified when *file* is passed instead of *filename*.
  options (dict): A dictionary that will be passed to the opener
    with which additional options can be specified.
  return (archive-like): An object that represents the archive and follows
    the interface of the #tarfile.TarFile class.
  """"""

  if mode not in ('r', 'w', 'a'):
    raise ValueError(""invalid mode: {0!r}"".format(mode))

  if suffix is None:
    suffix, opener = get_opener(filename)
    if file is not None:
      filename = None  # We don't need it anymore.
  else:
    if file is not None and filename is not None:
      raise ValueError(""filename must not be set with file & suffix specified"")
    try:
      opener = openers[suffix]
    except KeyError:
      raise UnknownArchive(suffix)

  if options is None:
    options = {}

  if file is not None:
    if mode in 'wa' and not hasattr(file, 'write'):
      raise TypeError(""file.write() does not exist"", file)
    if mode == 'r' and not hasattr(file, 'read'):
      raise TypeError(""file.read() does not exist"", file)

  if [filename, file].count(None) != 1:
    raise ValueError(""either filename or file must be specified"")
  if filename is not None:
    file = builtins.open(filename, mode + 'b')

  try:
    return opener(file, mode, options)
  except:
    if filename is not None:
      file.close()
    raise"
529,"def extract(archive, directory, suffix=None, unpack_single_dir=False,
    check_extract_file=None, progress_callback=None, default_mode='755'):
  """"""
  Extract the contents of *archive* to the specified *directory*. This
  function ensures that no file is extracted outside of the target directory
  (which can theoretically happen if the arcname is not relative or points
  to a parent directory).

  # Parameters
  archive (str, archive-like): The filename of an archive or an already
    opened archive.
  directory (str): Path to the directory to unpack the contents to.
  unpack_single_dir (bool): If this is True and if the archive contains only
    a single top-level directory, its contents will be placed directly into
    the target *directory*.
  """"""

  if isinstance(archive, str):
    with open(archive, suffix=suffix) as archive:
      return extract(archive, directory, None, unpack_single_dir,
          check_extract_file, progress_callback, default_mode)

  if isinstance(default_mode, str):
    default_mode = int(default_mode, 8)

  if progress_callback:
    progress_callback(-1, 0, None)
  names = archive.getnames()

  # Find out if we have only one top-level directory.
  toplevel_dirs = set()
  for name in names:
    parts = name.split('/')
    if len(parts) > 1:
      toplevel_dirs.add(parts[0])
  if unpack_single_dir and len(toplevel_dirs) == 1:
    stripdir = next(iter(toplevel_dirs)) + '/'
  else:
    stripdir = None

  for index, name in enumerate(names):
    if progress_callback:
      progress_callback(index + 1, len(names), name)
    if name.startswith('..') or name.startswith('/') or os.path.isabs(name):
      continue
    if check_extract_file and not check_extract_file(name):
      continue
    if name.endswith('/'):
      continue
    if stripdir:
      filename = name[len(stripdir):]
      if not filename:
        continue
    else:
      filename = name

    info = archive.getmember(name)
    src = archive.extractfile(name)
    if not src:
      continue

    try:
      filename = os.path.join(directory, filename)
      dirname = os.path.dirname(filename)
      if not os.path.exists(dirname):
        os.makedirs(dirname)
      with builtins.open(filename, 'wb') as dst:
        shutil.copyfileobj(src, dst)
      os.chmod(filename, info.mode or default_mode)
      os.utime(filename, (-1, info.mtime))
    finally:
      src.close()

  if progress_callback:
    progress_callback(len(names), len(names), None)"
530,"def transitions_to(self, dst):
    '''
    returns enumerable of (prevstate, t) tuples
    this is super slow and needs to be sped up
    '''
    if dst in self._transitions_to:
      for t in self._transitions_to[dst]:
        for s in self._transitions_to[dst][t]:
          yield (s, t)"
531,"def reltags(self, src, cache=None):
    '''
    returns all the tags that are relevant at this state
    cache should be a dictionary and it is updated
    by the function
    '''
    if not self._tag_assocs:
      return set()

    # fucking python and it's terrible support for recursion makes this
    # far more complicated than it needs to be
    if cache == None:
      cache = {}

    q = _otq()
    q.append(src)
    updateq = _otq()


    while q:
      i = q.popleft()
      if i in cache:
        continue

      cache[i] = set()
      for (s,t) in self.transitions_to(i):
        q.append(s)
        if self.is_tagged(t,s,i):
          cache[i].add((self.tag(t,s,i),s, i))
        updateq.appendleft((i, s))

    while updateq:
      i = updateq.popleft()
      cache[i[0]].update(cache[i[1]])

    return cache[src]"
532,"def _add_epsilon_states(self, stateset, gathered_epsilons):
    '''
    stateset is the list of initial states
    gathered_epsilons is a dictionary of (dst: src) epsilon dictionaries
    '''
    for i in list(stateset):
      if i not in gathered_epsilons:
        gathered_epsilons[i] = {}
        q = _otq()
        q.append(i)
        while q:
          s = q.popleft()
          for j in self._transitions.setdefault(s, {}).setdefault(NFA.EPSILON, set()):
            gathered_epsilons[i][j] = s if j not in gathered_epsilons[i] else self.choose(s, j)
            q.append(j)
      stateset.update(gathered_epsilons[i].keys())"
533,"def _states_to_dfa_bytecode(self, states, \
      tran=None, \
      debug=False, \
      compiled_states=None, \
      gathered_epsilons=None, \
      cached_transitions=None, \
      cached_tcode=None, \
      reltags_cache=None \
      ):
    '''returns the instruction pointer to the bytecode added'''
    pstates = copy.copy(states)

    if reltags_cache == None:
      reltags_cache = {}

    if cached_tcode == None:
      cached_tcode = {}

    if cached_transitions == None:
      cached_transitions = {}

    if gathered_epsilons == None:
      gathered_epsilons = {}

    self._add_epsilon_states(states, gathered_epsilons)

    if tran != None:
      states = self.nextstates(states, tran)
      self._add_epsilon_states(states, gathered_epsilons)

    if self._magic != None:
      states = states.union(self._magic(states))

    tstates = tuple(states)

    # this is used so we only compile each stateset once
    if compiled_states == None:
      compiled_states = {}

    if tstates in compiled_states:
      return compiled_states[tstates]

    # grab the ip from our codeblock
    ip = self._bytecode.newblock(tstates)
    compiled_states[tstates] = ip

    # TODO
    # epsilon transitions are never 'taken' so we need
    # to insert any ltagv/utagv instructions required
    # for all epsilon transitions
    # gathered_epsilons[state] holds a dictionary of dst: src mappings, so we can use that data

    if self.do_tags:
      tags = set()
      rtags = set()
  
      for ts in pstates:
        for dst in gathered_epsilons[ts]:
          rtags.update(self.reltags(dst, reltags_cache))
          src = gathered_epsilons[ts][dst]
          if self.is_tagged(NFA.EPSILON, src, dst):
            tags.add((self.tag(NFA.EPSILON, src, dst), dst))
  
      self._write_transition_code(tags, rtags, ip)

    # run any defined state hooks
    for s in tstates:
      if s in self._state_hooks:
        ip.append(VM.PyCode(self._state_hooks[s]))

    # do a multi-match for any final states
    finals = self._final_states.intersection(states)
    if len(finals) > 0:
      ip.append(VM.MultiMatch(finals))

    # do any interupts required
    interupts = self._interupt_states.intersection(states)
    if len(interupts) > 0:
      ip.append(VM.MultiInterupt(interupts))

    # consume a character
    ip.append(VM.Consume())

    ts = self.transitions(states, cached_transitions)

    if debug:
      print 'compiling bytecode for stateset:\n\t%s\n\t0x%x: %s' % (states,ip,(defaults,ts))

    def mkbytecode(t):
      return lambda: self._transitions_to_dfa_bytecode(states, t, cached_tcode, debug=debug, compiled_states=compiled_states, gathered_epsilons=gathered_epsilons, cached_transitions=cached_transitions, reltags_cache=reltags_cache)

    # for any of the non-default states add a conditional jmp
    for k in ts:

      if k in (NFA.ANY, NFA.EPSILON):
        continue

      jmppoint = VM.DelayedArg(mkbytecode(k))
      ip.append(VM.Compare(k))
      ip.append(VM.CondJmp(jmppoint))

    # jmp to default state if there is one, otherwise leave
    defaults = self.nextstates(states, NFA.ANY)
    if len(defaults) > 0:
      jmppoint = VM.DelayedArg(mkbytecode(NFA.ANY))
      ip.append(VM.Jmp(jmppoint))
    else:
      ip.append(VM.Leave())

    # return the instruction pointer
    return ip"
534,"def _add_training_data(self, src, dst, symbol):
        """"""
        Training_data is a dictionary from strings to lists.
        - Each string (key) is an access string
        - Each list (value) is a list of tuples (target_state, [symbols directed to that
        state]). These represent that a transition exists from the state used as key to the first
        part of the training_data to the dst state which is the first part of the tuple
        with all the symbols in the list in the SECOND part of the tuple.
        Args:
            src (str): The source state
            dst (str): The target state
            symbol (str): The transition symbol
        Returns:
            None
        """"""
        src_data = self.training_data[src]
        for (s, v) in src_data:
            if s == dst:
                v.append(symbol)
                return
        src_data.append((dst, [symbol]))"
535,"def is_closed(self):
        """"""
        _check if the observation table is closed.
        Args:
            None
        Returns:
            tuple (bool, str): True if the observation table is closed and false otherwise.
                               If the table is not closed the escaping string is returned.
        """"""
        old_training_data = self.training_data
        self.training_data = {x: [] for x in self.sm_vector}
        for t in self.smi_vector:
            src_state = t[:-1]
            symbol = t[-1:]
            found = False
            for dst_state in self.sm_vector:
                if self.observation_table[dst_state] == self.observation_table[t]:
                    self._add_training_data(src_state, dst_state, symbol)
                    found = True
                    break
            if not found:
                return False, t

        assert self.training_data != old_training_data, \
            ""No update happened from previous round. The algo will loop infinetely""
        return True, None"
536,"def _fill_table_entry(self, row, col):
        """"""""""
        Fill an entry of the observation table.
        Args:
            row (str): The row of the observation table
            col (str): The column of the observation table
        Returns:
            None
        """"""
        self.observation_table[row, col] = self._membership_query(row + col)"
537,"def _run_in_hypothesis(self, mma, w_string, index):
        """"""""""
        Run the string in the hypothesis automaton for index steps and then
        return the access string for the state reached concatanated with the
        rest of the string w.
        Args:
            mma (DFA): The hypothesis automaton
            w_string (str): The examined string to be consumed
            index (int): The index value for selecting the prefix of w
        Return:
            str: The access string
        """"""
        state = mma.states[0]
        s_index = 0
        for i in range(index):
            for arc in state:
                if arc.guard.is_sat(w_string[i]):
                    state = mma.states[arc.dst_state]
                    s_index = arc.dst_state

        # The id of the state is its index inside the Sm list
        access_string = self.observation_table.sm_vector[s_index]
        logging.debug(
            'Access string for %d: %s - %d ',
            index,
            access_string,
            s_index)
        return access_string"
538,"def _process_counter_example(self, mma, w_string):
        """"""""
        Process a counterexample in the Rivest-Schapire way.
        Args:
            mma (DFA): The hypothesis automaton
            w_string (str): The examined string to be consumed
        Return:
            None
        """"""
        if len(w_string) == 1:
            self.observation_table.smi_vector.append(w_string)
            for exp in self.observation_table.em_vector:
                self._fill_table_entry(w_string, exp)

        diff = len(w_string)
        same = 0
        membership_answer = self._membership_query(w_string)
        while True:
            i = (same + diff) / 2
            access_string = self._run_in_hypothesis(mma, w_string, i)
            if membership_answer != self._membership_query(access_string + w_string[i:]):
                diff = i
            else:
                same = i
            if diff - same == 1:
                break

        # First check if the transition is part of our training data.
        access_string = self._run_in_hypothesis(mma, w_string, diff - 1)
        wrong_transition = access_string + w_string[diff - 1]
        if wrong_transition not in self.observation_table.smi_vector:
            # If transition is not part of our training data add s_ib to Smi and
            # return to checking table closedness.
            self.observation_table.smi_vector.append(wrong_transition)
            for exp in self.observation_table.em_vector:
                self._fill_table_entry(wrong_transition, exp)
            return

        # This point presents a tradeoff between equivalence and membership
        # queries. If the transition in the counterexample'input_string breakpoint is not
        # part of our current training data (i.e. s_ib is not part of our Smi
        # set), then we assume a wrong transition and return to checking table
        # closure by adding s_ib to our training data. This saves a number of
        # membership queries since we don't add a row in our table unless
        # absolutely necessary. Notice that even if Equivalence queries are
        # expensive in general caching the result will be able to discover that
        # this iteration required a new state in the next equivalence query.

        exp = w_string[diff:]
        self.observation_table.em_vector.append(exp)
        for row in self.observation_table.sm_vector + self.observation_table.smi_vector:
            self._fill_table_entry(row, exp)"
539,"def _get_predicate_guards(self, state, state_training_data):
        """"""
        Args:
            state (DFA state): The dfa state
            state_training_data (list): The training data set
        Returns:
            list: A list of transitions
        """"""
        # choose the sink transition.

        # First option: Just the maximum transition
        # sink = max(state_training_data, key=lambda x: len(x[1]))[0]

        # Second option: Heuristics based on RE filters properties
        max_size_trans = max(state_training_data, key=lambda x: len(x[1]))
        max_size_trans_l = [x for x in state_training_data if
                            len(x[1]) == len(max_size_trans[1])]

        target_states = [t[0] for t in max_size_trans_l]
        if len(max_size_trans_l) == 1:
            sink = max_size_trans[0]
        elif '' in target_states:
            sink = ''
        elif state in target_states:
            sink = state
        else:
            sink = random.choice(target_states)
        # End of sink selection

        transitions = []
        known_symbols = []
        for (t, data) in state_training_data:
            if t == sink:
                continue
            pred = SetPredicate(data)
            transitions.append((t, pred))
            known_symbols += data
        transitions.append(
            (sink, SetPredicate(set(self.alphabet) - set(known_symbols))))
        return transitions"
540,"def get_sfa_conjecture(self):
        """"""
        Utilize the observation table to construct a Mealy Machine.
        The library used for representing the Mealy Machine is the python
        bindings of the openFST library (pyFST).
        Args:
            None
        Returns:
            MealyMachine: A mealy machine build based on a closed and consistent
        observation table.
        """"""
        sfa = SFA(self.alphabet)
        for s in self.observation_table.sm_vector:
            transitions = self._get_predicate_guards(
                s, self.observation_table.training_data[s])
            for (t, pred) in transitions:
                src_id = self.observation_table.sm_vector.index(s)
                dst_id = self.observation_table.sm_vector.index(t)
                assert isinstance(
                    pred, SetPredicate), ""Invalid type for predicate {}"".format(pred)
                sfa.add_arc(src_id, dst_id, pred)

        # Mark the final states in the hypothesis automaton.
        i = 0
        for s in self.observation_table.sm_vector:
            sfa.states[i].final = self.observation_table[s, self.epsilon]
            i += 1
        return sfa"
541,"def _init_table(self):
        """"""
        Initialize the observation table.
        """"""
        self.observation_table.sm_vector.append(self.epsilon)
        self.observation_table.smi_vector = [random.choice(self.alphabet)]
        self.observation_table.em_vector.append(self.epsilon)

        self._fill_table_entry(self.epsilon, self.epsilon)
        for s in self.observation_table.smi_vector:
            self._fill_table_entry(s, self.epsilon)"
542,"def _init_table_from_dfa(self, mma):
        """"""
        Initializes table form a DFA
        Args:
            mma: The input automaton
        Returns:
            None
        """"""
        observation_table_init = ObservationTableInit(self.epsilon, self.alphabet)
        sm_vector, smi_vector, em_vector = observation_table_init.initialize(mma, True)
        self.observation_table.sm_vector = sm_vector
        self.observation_table.smi_vector = smi_vector
        self.observation_table.em_vector = em_vector

        logging.info('Initialized from DFA em_vector table is the following:')
        logging.info(em_vector)

        self._fill_table_entry(self.epsilon, self.epsilon)

        # list(set([])) is used to remove duplicates, [1:0] to remove epsilon
        for row in sorted(list(set(sm_vector + smi_vector)), key=len)[1:]:
            for column in em_vector:
                self._fill_table_entry(str(row), str(column))"
543,"def learn_sfa(self, mma=None):
        """"""
        Implements the high level loop of the algorithm for learning a
        Mealy machine.
        Args:
            mma:
        Returns:
            MealyMachine: A model for the Mealy machine to be learned.
        """"""
        logging.info('Initializing learning procedure.')
        if mma:
            self._init_table_from_dfa(mma)
        else:
            self._init_table()

        logging.info('Generating a closed and consistent observation table.')
        while True:

            closed = False
            # Make sure that the table is closed
            while not closed:
                logging.debug('Checking if table is closed.')
                closed, s = self.observation_table.is_closed()
                if not closed:
                    logging.debug('Closing table.')
                    self._ot_make_closed(s)
                else:
                    logging.debug('Table closed.')

            # Create conjecture
            sfa = self.get_sfa_conjecture()

            logging.info('Generated conjecture machine with %d states.',
                         len(list(sfa.states)))

            # _check correctness
            logging.debug('Running equivalence query.')
            found, counter_example = self._equivalence_query(sfa)

            # Are we done?
            if found:
                logging.info('No counterexample found. Hypothesis is correct!')
                break

            # Add the new experiments into the table to reiterate the
            # learning loop
            logging.info(
                'Processing counterexample %s with length %d.',
                counter_example,
                len(counter_example))
            self._process_counter_example(sfa, counter_example)

        logging.info('Learning complete.')
        return '', sfa"
544,"def make_log_metric(level=logging.INFO, msg=""%d items in %.2f seconds""):
    """"""Make a new metric function that logs at the given level

    :arg int level: logging level, defaults to ``logging.INFO``
    :arg string msg: logging message format string, taking ``count`` and ``elapsed``
    :rtype: function
    """"""
    def log_metric(name, count, elapsed):
        log_name = 'instrument.{}'.format(name) if name else 'instrument'
        logging.getLogger(log_name).log(level, msg, count, elapsed)
    return log_metric"
545,"def _auto_init(self, *args, **kwrds):
    """"""Our decorator will add this as __init__ to target classes.""""""
    for fld in getattr(self, '__fields__', []):
        val = kwrds.get(fld.name, _NO_VAL)
        if val is _NO_VAL:
            val = fld.get_default_val()
        setattr(self, fld.name, val)

    if callable(getattr(self, 'setup', None)):
        self.setup(*args, **kwrds)"
546,"def ctor_overridable(cls):
    """"""Return true if cls has on overridable __init__.""""""
    prev_init = getattr(cls, ""__init__"", None)
    if not callable(prev_init):
        return True
    if prev_init in [object.__init__, _auto_init]:
        return True
    if getattr(prev_init, '_clobber_ok', False):
        return True

    print(cls, prev_init, getattr(prev_init, '_clobber_ok', 'missing'))
    return False"
547,"def DBObject(table_name, versioning=VersioningTypes.NONE):
    """"""Classes annotated with DBObject gain persistence methods.""""""
    def wrapped(cls):
        field_names = set()
        all_fields = []

        for name in dir(cls):
            fld = getattr(cls, name)
            if fld and isinstance(fld, Field):
                fld.name = name
                all_fields.append(fld)
                field_names.add(name)

        def add_missing_field(name, default='', insert_pos=None):
            if name not in field_names:
                fld = Field(default=default)
                fld.name = name
                all_fields.insert(
                    len(all_fields) if insert_pos is None else insert_pos,
                    fld
                )

        add_missing_field('id', insert_pos=0)
        add_missing_field('_create_date')
        add_missing_field('_last_update')
        if versioning == VersioningTypes.DELTA_HISTORY:
            add_missing_field('_version_hist', default=list)

        # Things we count on as part of our processing
        cls.__table_name__ = table_name
        cls.__versioning__ = versioning
        cls.__fields__ = all_fields

        # Give them a ctor for free - but make sure we aren't clobbering one
        if not ctor_overridable(cls):
            raise TypeError(
                'Classes with user-supplied __init__ should not be decorated '
                'with DBObject. Use the setup method'
            )
        cls.__init__ = _auto_init

        # Duck-type the class for our data methods
        cls.get_table_name = classmethod(_get_table_name)
        cls.get_id = _get_id
        cls.set_id = _set_id
        cls.to_data = _to_data
        cls.from_data = classmethod(_from_data)
        cls.index_names = classmethod(_index_names)
        cls.indexes = _indexes
        # Bonus methods they get for using gludb.simple
        cls.get_version_hist = _get_version_hist

        # Register with our abc since we actually implement all necessary
        # functionality
        Storable.register(cls)

        # And now that we're registered, we can also get the database
        # read/write functionality for free
        cls = DatabaseEnabled(cls)

        if versioning == VersioningTypes.DELTA_HISTORY:
            cls.save = _delta_save(cls.save)

        return cls

    return wrapped"
548,"def get_default_val(self):
        """"""Helper to expand default value (support callables).""""""
        val = self.default
        while callable(val):
            val = val()
        return val"
549,"def train(self, data, target, **kwargs):
        """"""
        Used in the training phase.  Override.
        """"""
        non_predictors = [i.replace("" "", ""_"").lower() for i in list(set(data['team']))] + [""team"", ""next_year_wins""]
        self.column_names = [l for l in list(data.columns) if l not in non_predictors]
        results, folds = self.cross_validate(data, non_predictors, **kwargs)
        self.gather_results(results, folds, data)"
550,"def compile(self, code):
        """"""
        Compile a simex code (e.g. <a href=""{{ url }}"">{{ anything }}</a>) to regex.

        Returns regex.
        """"""
        is_plain_text = True
        compiled_regex = r""""
        for chunk in self.delimiter_regex().split(code):
            if is_plain_text:
                compiled_regex = compiled_regex + simex_escape(chunk, flexible_whitespace=self._flexible_whitespace)
            else:
                stripped_chunk = chunk.strip()
                if stripped_chunk in self._regexes.keys():
                    compiled_regex = u""{0}{1}"".format(
                        compiled_regex,
                        self._regexes[stripped_chunk]
                    )
                else:
                    raise KeyNotFound(""'{0}' not found in keys"")
            is_plain_text = not is_plain_text
        if self._exact:
            compiled_regex = r""^"" + compiled_regex + r""$""
        return compile(compiled_regex)"
551,"def as_command(self):
        """"""Creates the click command wrapping the function
        """"""
        try:
            params = self.unbound_func.__click_params__
            params.reverse()
            del self.unbound_func.__click_params__
        except AttributeError:
            params = []
        help = inspect.getdoc(self.real_func)
        if isinstance(help, bytes):
            help = help.decode('utf-8')
        self.options.setdefault('help', help)
        @pass_script_info_decorator
        def callback(info, *args, **kwargs):
            if self.with_reloader:
                app = info.load_app()
                if app.debug:
                    def inner():
                        return self.command_callback(info, *args, **kwargs)
                    run_with_reloader(inner, extra_files=get_reloader_extra_files())
                    return
            self.command_callback(info, *args, **kwargs)
        return self.cls(name=self.name, callback=callback, params=params, **self.options)"
552,"def command_line_options(command_line_arguments):
  """"""Parse the program options""""""

  # set up command line parser
  parser = argparse.ArgumentParser(description=__doc__,
      formatter_class=argparse.ArgumentDefaultsHelpFormatter)

  parser.add_argument('-d', '--files', required=True, nargs='+', help = ""A list of score files to evaluate."")
  parser.add_argument('-b', '--baselines', default=[], nargs='+', help = ""A list of baseline results to add to the plot"")

  parser.add_argument('-D', '--directory', default = '.', help = ""A directory, where to find the --files"")
  parser.add_argument('-B', '--baseline-directory', default = '.', help = ""A directory, where to find the --baselines"")

  parser.add_argument('-R', '--auto-baselines', choices = ('bioid', 'mit-cmu'), help = ""Automatically add the baselines for the given database"")

  parser.add_argument('-l', '--legends', nargs='+', help = ""A list of legend strings used for ROC, CMC and DET plots; if given, must be the same number than --files plus --baselines."")
  parser.add_argument('-w', '--output', default = 'FROC.pdf', help = ""If given, FROC curves will be plotted into the given pdf file."")
  parser.add_argument('-c', '--count-detections', action='store_true', help = ""Counts the number of detections (positive is higher than negative, per file)."")
  parser.add_argument('-n', '--max', type=int, nargs=2, default=(160,70), help = ""The highest false alarms and the lowest detection rate to plot"")
  parser.add_argument('-t', '--title', default='FROC', help = ""The title of the plot"")

  parser.add_argument('--self-test', action='store_true', help=argparse.SUPPRESS)

  # add verbosity option
  bob.core.log.add_command_line_option(parser)
  args = parser.parse_args(command_line_arguments)
  bob.core.log.set_verbosity_level(logger, args.verbose)

  if args.legends is not None:
    count = len(args.files) + (len(args.baselines) if args.baselines is not None else 0)
    if len(args.legends) != count:
      logger.error(""The number of --files (%d) plus --baselines (%d) must be the same as --legends (%d)"", len(args.files), len(args.baselines) if args.baselines else 0, len(args.legends))
      args.legends = None

  # update legends when they are not specified on command line
  if args.legends is None:
    args.legends = args.files if not args.baselines else args.files + args.baselines
    args.legends = [l.replace(""_"",""-"") for l in args.legends]

  if args.auto_baselines == 'bioid':
    args.baselines.extend([""baselines/baseline_detection_froba_mct_BIOID"", ""cosmin/BIOID/face.elbp.proj0.var.levels10.roc""])
    args.legends.extend([""Froba"", ""Cosmin""])
  elif args.auto_baselines == 'mit-cmu':
    args.baselines.extend([""baselines/baseline_detection_fcboost_MIT+CMU"", ""baselines/baseline_detection_viola_rapid1_MIT+CMU"", ""cosmin/MIT+CMU/face.elbp.proj0.var.levels10.roc""])
    args.legends.extend([""FcBoost"", ""Viola"", ""Cosmin""])

  return args"
553,"def main(command_line_arguments=None):
  """"""Reads score files, computes error measures and plots curves.""""""

  args = command_line_options(command_line_arguments)

  # get some colors for plotting
  cmap = mpl.cm.get_cmap(name='hsv')
  count = len(args.files) + (len(args.baselines) if args.baselines else 0)
  colors = [cmap(i) for i in numpy.linspace(0, 1.0, count+1)]

  # First, read the score files
  logger.info(""Loading %d score files"" % len(args.files))

  scores = [read_score_file(os.path.join(args.directory, f)) for f in args.files]

  false_alarms = []
  detection_rate = []
  logger.info(""Computing FROC curves"")
  for score in scores:
    # compute some thresholds
    tmin = min(score[2])
    tmax = max(score[2])
    count = 100
    thresholds = [tmin + float(x)/count * (tmax - tmin) for x in range(count+2)]
    false_alarms.append([])
    detection_rate.append([])
    for threshold in thresholds:
      detection_rate[-1].append(numpy.count_nonzero(numpy.array(score[1]) >= threshold) / float(score[0]))
      false_alarms[-1].append(numpy.count_nonzero(numpy.array(score[2]) >= threshold))
    # to display 0 in a semilogx plot, we have to add a little
#    false_alarms[-1][-1] += 1e-8

  # also read baselines
  if args.baselines is not None:
    for baseline in args.baselines:
      dr = []
      fa = []
      with open(os.path.join(args.baseline_directory, baseline)) as f:
        for line in f:
          splits = line.rstrip().split()
          dr.append(float(splits[0]))
          fa.append(int(splits[1]))
      false_alarms.append(fa)
      detection_rate.append(dr)

  logger.info(""Plotting FROC curves to file '%s'"", args.output)
  # create a multi-page PDF for the ROC curve
  pdf = PdfPages(args.output)
  figure = _plot_froc(false_alarms, detection_rate, colors, args.legends, args.title, args.max)
  mpl.xlabel('False Alarm (of %d pruned)' % len(scores[0][2]))
  mpl.ylabel('Detection Rate in \%% (total %d faces)' % scores[0][0])
  pdf.savefig(figure)
  pdf.close()

  if args.count_detections:
    for i, f in enumerate(args.files):
      det, all = count_detections(f)
      print(""The number of detected faces for %s is %d out of %d"" % (args.legends[i], det, all))"
554,"def priority(var):
    """"""Prioritizes resource position in the final HTML. To be fed into sorted(key=).

    Javascript consoles throw errors if Bootstrap's js file is mentioned before jQuery. Using this function such errors
    can be avoided. Used internally.

    Positional arguments:
    var -- value sent by list.sorted(), which is a value in Statics().all_variables.

    Returns:
    Either a number if sorting is enforced for the value in `var`, or returns `var` itself.
    """"""
    order = dict(JQUERY='0', BOOTSTRAP='1')
    return order.get(var, var)"
555,"def get_resources(minify=False):
    """"""Find all resources which subclass ResourceBase.

    Keyword arguments:
    minify -- select minified resources if available.

    Returns:
    Dictionary of available resources. Keys are resource names (part of the config variable names), values are dicts
    with css and js keys, and tuples of resources as values.
    """"""
    all_resources = dict()
    subclasses = resource_base.ResourceBase.__subclasses__() + resource_definitions.ResourceAngular.__subclasses__()
    for resource in subclasses:
        obj = resource(minify)
        all_resources[resource.RESOURCE_NAME] = dict(css=tuple(obj.resources_css), js=tuple(obj.resources_js))
    return all_resources"
556,"def citedby_pid(self, pid, metaonly=False, from_heap=True):
        """"""
        Retrieve citedby documents from a given PID number.

        pid: SciELO PID number
        metaonly: will retrieve only the metadata of the requested article citations including the number of citations it has received.
        from_heap: will retrieve the number of citations from a preproduced report, it will not fetch the api. Much faster results but not extremely updated.
        """"""

        if from_heap is True:
            result = citations.raw_data(pid)

            if result and 'cited_by' in result and metaonly is True:
                del(result['cited_by'])
                return result

            if result:
                return result

        url = urljoin(self.CITEDBY_URL, self.PID_ENDPOINT)

        params = {
            ""q"": pid,
            ""metaonly"": ""true"" if metaonly is True else ""false""
        }

        result = self._do_request(url, params=params)

        return result"
557,"def citedby_pid(self, pid, metaonly=False, from_heap=True):
        """"""
        Retrieve citedby documents from a given PID number.

        pid: SciELO PID number
        metaonly: will retrieve only the metadata of the requested article citations including the number of citations it has received.
        from_heap: will retrieve the number of citations from a preproduced report, it will not fetch the api. Much faster results but not extremelly updated.
        """"""

        if from_heap is True:
            result = citations.raw_data(pid)

            if result and 'cited_by' in result and metaonly is True:
                del(result['cited_by'])
                return result

            if result:
                return result

        result = self.client.citedby_pid(pid, metaonly=metaonly)

        try:
            return json.loads(result)
        except:
            return None"
558,"def search(self, dsl, params):
        """"""
        Free queries to ES index.

        dsl (string): with DSL query
        params (list): [(key, value), (key, value)]
            where key is a query parameter, and value is the value required for parameter, ex: [('size', '0'), ('search_type', 'count')]
        """"""

        query_parameters = []
        for key, value in params:
            query_parameters.append(self.CITEDBY_THRIFT.kwargs(str(key), str(value)))

        try:
            result = self.client.search(dsl, query_parameters)
        except self.CITEDBY_THRIFT.ServerError:
            raise ServerError('you may trying to run a bad DSL Query')

        try:
            return json.loads(result)
        except:
            return None"
559,"def raise_error(error):
    """"""Intakes a dict of remote error information and raises a DashiError
    """"""
    exc_type = error.get('exc_type')
    if exc_type and exc_type.startswith(ERROR_PREFIX):
        exc_type = exc_type[len(ERROR_PREFIX):]
        exc_cls = ERROR_TYPE_MAP.get(exc_type, DashiError)
    else:
        exc_cls = DashiError

    raise exc_cls(**error)"
560,"def fire(self, name, operation, args=None, **kwargs):
        """"""Send a message without waiting for a reply

        @param name: name of destination service queue
        @param operation: name of service operation to invoke
        @param args: dictionary of keyword args to pass to operation.
                     Use this OR kwargs.
        @param kwargs: additional args to pass to operation
        """"""

        if args:
            if kwargs:
                raise TypeError(""specify args dict or keyword arguments, not both"")
        else:
            args = kwargs

        d = dict(op=operation, args=args)
        headers = {'sender': self.add_sysname(self.name)}

        dest = self.add_sysname(name)

        def _fire(channel):
            with Producer(channel) as producer:
                producer.publish(d, routing_key=dest,
                    headers=headers, serializer=self._serializer,
                    exchange=self._exchange, declare=[self._exchange])

        log.debug(""sending message to %s"", dest)
        with connections[self._pool_conn].acquire(block=True) as conn:
            _, channel = self.ensure(conn, _fire)
            conn.maybe_close_channel(channel)"
561,"def call(self, name, operation, timeout=10, args=None, **kwargs):
        """"""Send a message and wait for reply

        @param name: name of destination service queue
        @param operation: name of service operation to invoke
        @param timeout: RPC timeout to await a reply
        @param args: dictionary of keyword args to pass to operation.
                     Use this OR kwargs.
        @param kwargs: additional args to pass to operation
        """"""

        if args:
            if kwargs:
                raise TypeError(""specify args dict or keyword arguments, not both"")
        else:
            args = kwargs

        # create a direct queue for the reply. This may end up being a
        # bottleneck for performance: each rpc call gets a brand new
        # exclusive queue. However this approach is used nova.rpc and
        # seems to have carried them pretty far. If/when this
        # becomes a bottleneck we can set up a long-lived backend queue and
        # use correlation_id to deal with concurrent RPC calls. See:
        #   http://www.rabbitmq.com/tutorials/tutorial-six-python.html
        msg_id = uuid.uuid4().hex

        # expire the reply queue shortly after the timeout. it will be
        # (lazily) deleted by the broker if we don't clean it up first
        queue_arguments = {'x-expires': int((timeout + 1) * 1000)}
        queue = Queue(name=msg_id, exchange=self._exchange, routing_key=msg_id,
                      durable=False, queue_arguments=queue_arguments)

        messages = []
        event = threading.Event()

        def _callback(body, message):
            messages.append(body)
            message.ack()
            event.set()

        d = dict(op=operation, args=args)
        headers = {'reply-to': msg_id, 'sender': self.add_sysname(self.name)}
        dest = self.add_sysname(name)

        def _declare_and_send(channel):
            consumer = Consumer(channel, (queue,), callbacks=(_callback,))
            with Producer(channel) as producer:
                producer.publish(d, routing_key=dest, headers=headers,
                    exchange=self._exchange, serializer=self._serializer)
            return consumer

        log.debug(""sending call to %s:%s"", dest, operation)
        with connections[self._pool_conn].acquire(block=True) as conn:
            consumer, channel = self.ensure(conn, _declare_and_send)
            try:
                self._consume(conn, consumer, timeout=timeout, until_event=event)

                # try to delete queue, but don't worry if it fails (will expire)
                try:
                    queue = queue.bind(channel)
                    queue.delete(nowait=True)
                except Exception:
                    log.exception(""error deleting queue"")

            finally:
                conn.maybe_close_channel(channel)

        msg_body = messages[0]
        if msg_body.get('error'):
            raise_error(msg_body['error'])
        else:
            return msg_body.get('result')"
562,"def handle(self, operation, operation_name=None, sender_kwarg=None):
        """"""Handle an operation using the specified function

        @param operation: function to call for this operation
        @param operation_name: operation name. if unspecified operation.__name__ is used
        @param sender_kwarg: optional keyword arg on operation to feed in sender name
        """"""
        if not self._consumer:
            self._consumer = DashiConsumer(self, self._conn,
                    self._name, self._exchange, sysname=self._sysname)
        self._consumer.add_op(operation_name or operation.__name__, operation,
                              sender_kwarg=sender_kwarg)"
563,"def cancel(self, block=True):
        """"""Cancel a call to consume() happening in another thread

        This could take up to DashiConnection.consumer_timeout to complete.

        @param block: if True, waits until the consumer has returned
        """"""
        if self._consumer:
            self._consumer.cancel(block=block)"
564,"def link_exceptions(self, custom_exception=None, dashi_exception=None):
        """"""Link a custom exception thrown on the receiver to a dashi exception
        """"""
        if custom_exception is None:
            raise ValueError(""custom_exception must be set"")
        if dashi_exception is None:
            raise ValueError(""dashi_exception must be set"")

        self._linked_exceptions[custom_exception] = dashi_exception"
565,"def ensure(self, connection, func, *args, **kwargs):
        """"""Perform an operation until success

        Repeats in the face of connection errors, pursuant to retry policy.
        """"""
        channel = None
        while 1:
            try:
                if channel is None:
                    channel = connection.channel()
                return func(channel, *args, **kwargs), channel
            except (connection.connection_errors, IOError):
                self._call_errback()

            channel = self.connect(connection)"
566,"def re_tab(s):
    """"""Return a tabbed string from an expanded one.""""""
    l = []
    p = 0
    for i in range(8, len(s), 8):
        if s[i - 2:i] == ""  "":
            # collapse two or more spaces into a tab
            l.append(s[p:i].rstrip() + ""\t"")
            p = i

    if p == 0:
        return s
    else:
        l.append(s[p:])
        return """".join(l)"
567,"def read_next_line(self):
        """"""Read another line from the file.""""""

        next_line = self.file.readline()

        if not next_line or next_line[-1:] != '\n':
            # no newline on last line of file
            self.file = None
        else:
            # trim newline characters
            next_line = next_line[:-1]

        expanded = next_line.expandtabs()

        edit = urwid.Edit("""", expanded, allow_tab=True)
        edit.set_edit_pos(0)
        edit.original_text = next_line
        self.lines.append(edit)

        return next_line"
568,"def _get_at_pos(self, pos):
        """"""Return a widget for the line number passed.""""""

        if pos < 0:
            # line 0 is the start of the file, no more above
            return None, None

        if len(self.lines) > pos:
            # we have that line so return it
            return self.lines[pos], pos

        if self.file is None:
            # file is closed, so there are no more lines
            return None, None

        assert pos == len(self.lines), ""out of order request?""

        self.read_next_line()

        return self.lines[-1], pos"
569,"def split_focus(self):
        """"""Divide the focus edit widget at the cursor location.""""""

        focus = self.lines[self.focus]
        pos = focus.edit_pos
        edit = urwid.Edit("""", focus.edit_text[pos:], allow_tab=True)
        edit.original_text = """"
        focus.set_edit_text(focus.edit_text[:pos])
        edit.set_edit_pos(0)
        self.lines.insert(self.focus + 1, edit)"
570,"def combine_focus_with_prev(self):
        """"""Combine the focus edit widget with the one above.""""""

        above, ignore = self.get_prev(self.focus)
        if above is None:
            # already at the top
            return

        focus = self.lines[self.focus]
        above.set_edit_pos(len(above.edit_text))
        above.set_edit_text(above.edit_text + focus.edit_text)
        del self.lines[self.focus]
        self.focus -= 1"
571,"def combine_focus_with_next(self):
        """"""Combine the focus edit widget with the one below.""""""

        below, ignore = self.get_next(self.focus)
        if below is None:
            # already at bottom
            return

        focus = self.lines[self.focus]
        focus.set_edit_text(focus.edit_text + below.edit_text)
        del self.lines[self.focus + 1]"
572,"def handle_keypress(self, k):
        """"""Last resort for keypresses.""""""
        if k == ""esc"":
            self.save_file()
            raise urwid.ExitMainLoop()
        elif k == ""delete"":
            # delete at end of line
            self.walker.combine_focus_with_next()
        elif k == ""backspace"":
            # backspace at beginning of line
            self.walker.combine_focus_with_prev()
        elif k == ""enter"":
            # start new line
            self.walker.split_focus()
            # move the cursor to the new line and reset pref_col
            self.view.keypress(size, ""down"")
            self.view.keypress(size, ""home"")"
573,"def save_file(self):
        """"""Write the file out to disk.""""""

        l = []
        walk = self.walker
        for edit in walk.lines:
            # collect the text already stored in edit widgets
            if edit.original_text.expandtabs() == edit.edit_text:
                l.append(edit.original_text)
            else:
                l.append(re_tab(edit.edit_text))

        # then the rest
        while walk.file is not None:
            l.append(walk.read_next_line())

        # write back to disk
        outfile = open(self.save_name, ""w"")

        l_iter = iter(l)

        line = next(l_iter)
        prefix = """"

        while True:
            try:
                outfile.write(prefix + line)
                prefix = ""\n""
                line = next(l_iter)
            except StopIteration:
                if line != ""\n"":
                    outfile.write(""\n"")
                break"
574,"def _media(self):
        """"""
        Returns a forms.Media instance with the basic editor media and media
        from all registered extensions.
        """"""
        css = ['markymark/css/markdown-editor.css']
        iconlibrary_css = getattr(
            settings,
            'MARKYMARK_FONTAWESOME_CSS',
            'markymark/fontawesome/fontawesome.min.css'
        )
        if iconlibrary_css:
            css.append(iconlibrary_css)

        media = forms.Media(
            css={'all': css},
            js=('markymark/js/markdown-editor.js',)
        )

        # Use official extension loading to initialize all extensions
        # and hook in extension-defined media files.
        renderer = initialize_renderer()

        for extension in renderer.registeredExtensions:
            if hasattr(extension, 'media'):
                media += extension.media
        return media"
575,"def rel(path, parent=None, par=False):
  """"""
  Takes *path* and computes the relative path from *parent*. If *parent* is
  omitted, the current working directory is used.

  If *par* is #True, a relative path is always created when possible.
  Otherwise, a relative path is only returned if *path* lives inside the
  *parent* directory.
  """"""

  try:
    res = os.path.relpath(path, parent)
  except ValueError:
    # Raised eg. on Windows for differing drive letters.
    if not par:
      return abs(path)
    raise
  else:
    if not par and not issub(res):
      return abs(path)
    return res"
576,"def issub(path):
  """"""
  Returns #True if *path* is a relative path that does not point outside
  of its parent directory or is equal to its parent directory (thus, this
  function will also return False for a path like `./`).
  """"""

  if isabs(path):
    return False
  if path.startswith(curdir + sep) or path.startswith(pardir + sep) or \
      path == curdir or path == pardir:
    return False
  return True"
577,"def glob(patterns, parent=None, excludes=None, include_dotfiles=False,
         ignore_false_excludes=False):
  """"""
  Wrapper for #glob2.glob() that accepts an arbitrary number of
  patterns and matches them. The paths are normalized with #norm().

  Relative patterns are automaticlly joined with *parent*. If the
  parameter is omitted, it defaults to the current working directory.

  If *excludes* is specified, it must be a string or a list of strings
  that is/contains glob patterns or filenames to be removed from the
  result before returning.

  > Every file listed in *excludes* will only remove **one** match from
  > the result list that was generated from *patterns*. Thus, if you
  > want to exclude some files with a pattern except for a specific file
  > that would also match that pattern, simply list that file another
  > time in the *patterns*.

  # Parameters
  patterns (list of str): A list of glob patterns or filenames.
  parent (str): The parent directory for relative paths.
  excludes (list of str): A list of glob patterns or filenames.
  include_dotfiles (bool): If True, `*` and `**` can also capture
    file or directory names starting with a dot.
  ignore_false_excludes (bool): False by default. If True, items listed
    in *excludes* that have not been globbed will raise an exception.

  # Returns
  list of str: A list of filenames.
  """"""

  if not glob2:
    raise glob2_ext

  if isinstance(patterns, str):
    patterns = [patterns]

  if not parent:
    parent = os.getcwd()

  result = []
  for pattern in patterns:
    if not os.path.isabs(pattern):
      pattern = os.path.join(parent, pattern)
    result += glob2.glob(canonical(pattern))

  for pattern in (excludes or ()):
    if not os.path.isabs(pattern):
      pattern = os.path.join(parent, pattern)
    pattern = canonical(pattern)
    if not isglob(pattern):
      try:
        result.remove(pattern)
      except ValueError as exc:
        if not ignore_false_excludes:
          raise ValueError('{} ({})'.format(exc, pattern))
    else:
      for item in glob2.glob(pattern):
        try:
          result.remove(item)
        except ValueError as exc:
          if not ignore_false_excludes:
            raise ValueError('{} ({})'.format(exc, pattern))

  return result"
578,"def addtobase(subject, base_suffix):
  """"""
  Adds the string *base_suffix* to the basename of *subject*.
  """"""

  if not base_suffix:
    return subject
  base, ext = os.path.splitext(subject)
  return base + base_suffix + ext"
579,"def addprefix(subject, prefix):
  """"""
  Adds the specified *prefix* to the last path element in *subject*.
  If *prefix* is a callable, it must accept exactly one argument, which
  is the last path element, and return a modified value.
  """"""

  if not prefix:
    return subject
  dir_, base = split(subject)
  if callable(prefix):
    base = prefix(base)
  else:
    base = prefix + base
  return join(dir_, base)"
580,"def addsuffix(subject, suffix, replace=False):
  """"""
  Adds the specified *suffix* to the *subject*. If *replace* is True, the
  old suffix will be removed first. If *suffix* is callable, it must accept
  exactly one argument and return a modified value.
  """"""

  if not suffix and not replace:
    return subject
  if replace:
    subject = rmvsuffix(subject)
  if suffix and callable(suffix):
    subject = suffix(subject)
  elif suffix:
    subject += suffix
  return subject"
581,"def rmvsuffix(subject):
  """"""
  Remove the suffix from *subject*.
  """"""

  index = subject.rfind('.')
  if index > subject.replace('\\', '/').rfind('/'):
    subject = subject[:index]
  return subject"
582,"def getsuffix(subject):
  """"""
  Returns the suffix of a filename. If the file has no suffix, returns None.
  Can return an empty string if the filenam ends with a period.
  """"""

  index = subject.rfind('.')
  if index > subject.replace('\\', '/').rfind('/'):
    return subject[index+1:]
  return None"
583,"def makedirs(path, exist_ok=True):
  """"""
  Like #os.makedirs(), with *exist_ok* defaulting to #True.
  """"""

  try:
    os.makedirs(path)
  except OSError as exc:
    if exist_ok and exc.errno == errno.EEXIST:
      return
    raise"
584,"def chmod_update(flags, modstring):
  """"""
  Modifies *flags* according to *modstring*.
  """"""

  mapping = {
    'r': (_stat.S_IRUSR, _stat.S_IRGRP, _stat.S_IROTH),
    'w': (_stat.S_IWUSR, _stat.S_IWGRP, _stat.S_IWOTH),
    'x': (_stat.S_IXUSR, _stat.S_IXGRP, _stat.S_IXOTH)
  }

  target, direction = 'a', None
  for c in modstring:
    if c in '+-':
      direction = c
      continue
    if c in 'ugoa':
      target = c
      direction = None  # Need a - or + after group specifier.
      continue
    if c in 'rwx' and direction in '+-':
      if target == 'a':
        mask = functools.reduce(operator.or_, mapping[c])
      else:
        mask = mapping[c]['ugo'.index(target)]
      if direction == '-':
        flags &= ~mask
      else:
        flags |= mask
      continue
    raise ValueError('invalid chmod: {!r}'.format(modstring))

  return flags"
585,"def chmod_repr(flags):
  """"""
  Returns a string representation of the access flags *flags*.
  """"""

  template = 'rwxrwxrwx'
  order = (_stat.S_IRUSR, _stat.S_IWUSR, _stat.S_IXUSR,
           _stat.S_IRGRP, _stat.S_IWGRP, _stat.S_IXGRP,
           _stat.S_IROTH, _stat.S_IWOTH, _stat.S_IXOTH)
  return ''.join(template[i] if flags&x else '-'
                 for i, x in enumerate(order))"
586,"def compare_timestamp(src, dst):
  """"""
  Compares the timestamps of file *src* and *dst*, returning #True if the
  *dst* is out of date or does not exist. Raises an #OSError if the *src*
  file does not exist.
  """"""

  try:
    dst_time = os.path.getmtime(dst)
  except OSError as exc:
    if exc.errno == errno.ENOENT:
      return True  # dst does not exist

  src_time = os.path.getmtime(src)
  return src_time > dst_time"
587,"def init_app(self, app):
        """"""Initialize the extension.""""""
        # Set default Flask config option.
        app.config.setdefault('STATICS_MINIFY', False)

        # Select resources.
        self.all_resources = ALL_RESOURCES_MINIFIED if app.config.get('STATICS_MINIFY') else ALL_RESOURCES
        self.all_variables = ALL_VARIABLES

        # Add this instance to app.extensions.
        if not hasattr(app, 'extensions'):
            app.extensions = dict()
        if 'statics' in app.extensions:
            raise ValueError('Already registered extension STATICS.')
        app.extensions['statics'] = _StaticsState(self, app)

        # Initialize blueprint.
        name = 'flask_statics_helper'
        static_url_path = '{0}/{1}'.format(app.static_url_path, name)
        self.blueprint = Blueprint(name, __name__, template_folder='templates', static_folder='static',
                                   static_url_path=static_url_path)
        self.blueprint.add_app_template_global(self.all_variables, '_flask_statics_helper_all_variables')
        self.blueprint.add_app_template_global(self.all_resources, '_flask_statics_helper_all_resources')
        app.register_blueprint(self.blueprint)"
588,"def measure_board_rms(control_board, n_samples=10, sampling_ms=10,
                      delay_between_samples_ms=0):
    '''
    Read RMS voltage samples from control board high-voltage feedback circuit.
    '''
    try:
        results = control_board.measure_impedance(n_samples, sampling_ms,
                                                  delay_between_samples_ms,
                                                  True, True, [])
    except RuntimeError:
        # `RuntimeError` may be raised if, for example, current limit was
        # reached during measurement.  In such cases, return an empty frame.
        logger.warning('Error encountered during high-voltage RMS '
                       'measurement.', exc_info=True)
        data = pd.DataFrame(None, columns=['board measured V',
                                           'divider resistor index'])
    else:
        data = pd.DataFrame({'board measured V': results.V_hv})
        data['divider resistor index'] = results.hv_resistor
    return data"
589,"def find_good(control_board, actuation_steps, resistor_index, start_index,
              end_index):
    '''
    Use a binary search over the range of provided actuation_steps to find the
    maximum actuation voltage that is measured by the board feedback circuit
    using the specified feedback resistor.
    '''
    lower = start_index
    upper = end_index
    while lower < upper - 1:
        index = lower + (upper - lower) / 2
        v = actuation_steps[index]
        control_board.set_waveform_voltage(v)
        data = measure_board_rms(control_board)
        valid_data = data[data['divider resistor index'] >= 0]

        if (valid_data['divider resistor index'] < resistor_index).sum():
            # We have some measurements from another resistor.
            upper = index
        else:
            lower = index
    control_board.set_waveform_voltage(actuation_steps[lower])
    data = measure_board_rms(control_board)
    return lower, data"
590,"def resistor_max_actuation_readings(control_board, frequencies,
                                    oscope_reading_func):
    '''
    For each resistor in the high-voltage feedback resistor bank, read the
    board measured voltage and the oscilloscope measured voltage for an
    actuation voltage that nearly saturates the feedback resistor.

    By searching for an actuation voltage near saturation, the signal-to-noise
    ratio is minimized.
    '''
    # Set board amplifier gain to 1.
    # __NB__ This is likely _far_ lower than the actual gain _(which may be a
    # factor of several hundred)_..
    control_board.set_waveform_voltage(0)
    control_board.auto_adjust_amplifier_gain = False
    control_board.amplifier_gain = 1.

    # Set waveform voltage to a low value and obtain the corresponding
    # oscilloscope reading to calculate an approximate gain of the amplifier.
    target_voltage = 0.1
    control_board.set_waveform_voltage(target_voltage)
    oscope_rms = oscope_reading_func()
    estimated_amplifier_gain = oscope_rms / target_voltage

    # Based on the maximum amplified RMS voltage, define a set of actuation
    # voltages to search when performing calibration.
    max_post_gain_V = 0.8 * control_board.max_waveform_voltage
    max_actuation_V = max_post_gain_V / estimated_amplifier_gain
    actuation_steps = np.linspace(0.005, max_actuation_V, num=50)

    resistor_count = len(control_board.a0_series_resistance)

    # Define frequency/resistor index pairs to take measurements at.
    conditions = pd.DataFrame([[r, f] for r in range(resistor_count - 1, -1, -1)
                               for f in frequencies],
                              columns=['resistor index', 'frequency'])

    # Define function to process each frequency/resistor index pair.
    def max_actuation_reading(x):
        '''
        Measure maximum board RMS voltage using specified feedback resistor, at
        the specified frequency.

        Request corresponding oscilloscope RMS voltage reading.
        '''
        r = x['resistor index'].values[0]
        f = x['frequency'].values[0]
        control_board.set_waveform_frequency(f)

        actuation_index, data = find_good(control_board, actuation_steps, r, 0,
                                          len(actuation_steps) - 1)
        board_measured_rms = data.loc[data['divider resistor index'] >= 0,
                                      'board measured V'].mean()
        oscope_rms = oscope_reading_func()
        print 'R=%s, f=%s' % (r, f)
        return pd.DataFrame([[r, f, actuation_index, board_measured_rms,
                              oscope_rms]],
                            columns=['resistor index', 'frequency',
                                     'actuation index', 'board measured V',
                                     'oscope measured V'])

    # Return board-measured RMS voltage and oscilloscope-measured RMS voltage
    # for each frequency/feedback resistor pair.
    return (conditions.groupby(['resistor index', 'frequency'])
            .apply(max_actuation_reading).reset_index(drop=True))"
591,"def fit_feedback_params(calibration, max_resistor_readings):
    '''
    Fit model of control board high-voltage feedback resistor and
    parasitic capacitance values based on measured voltage readings.
    '''
    R1 = 10e6

    # Get transfer function to compute the amplitude of the high-voltage input
    # to the control board _(i.e., the output of the amplifier)_ based on the
    # attenuated voltage measured by the analog-to-digital converter on the
    # control board.
    #
    # The signature of the transfer function is:
    #
    #     H(V1, R1, C1, R2, C2, f)
    #
    # See the `z_transfer_functions` function docstring for definitions of the
    # parameters based on the control board major version.
    def fit_resistor_params(x):
        resistor_index = x['resistor index'].values[0]
        p0 = [calibration.R_hv[resistor_index],
              calibration.C_hv[resistor_index]]

        def error(p, df, R1):
            v1 = compute_from_transfer_function(calibration.hw_version.major,
                                                'V1',
                                                V2=df['board measured V'],
                                                R1=R1, R2=p[0], C2=p[1],
                                                f=df['frequency'].values)
            e = df['oscope measured V'] - v1
            return e

        p1, success = optimize.leastsq(error, p0, args=(x, R1))
        # take the absolute value of the fitted values, since is possible
        # for the fit to produce negative resistor and capacitor values
        p1 = np.abs(p1)
        return pd.DataFrame([p0 + p1.tolist()],
                            columns=['original R', 'original C',
                                     'fitted R', 'fitted C']).T

    results = (max_resistor_readings
               [max_resistor_readings['resistor index'] >= 0]
               .groupby(['resistor index']).apply(fit_resistor_params))
    data = results.unstack()
    data.columns = data.columns.droplevel()
    return data"
592,"def plot_feedback_params(hw_major_version, max_resistor_readings,
                         feedback_params, axis=None):
    '''
    Plot the effective attenuation _(i.e., gain less than 1)_ of the control
    board measurements of high-voltage AC input according to:

     - AC signal frequency.
     - feedback resistor used _(varies based on amplitude of AC signal)_.

    Each high-voltage feedback resistor (unintentionally) forms a low-pass
    filter, resulting in attenuation of the voltage measured on the control
    board.  The plot generated by this function plots each of the following
    trends for each feedback resistor:

     - Oscilloscope measurements.
     - Previous model of attenuation.
     - Newly fitted model of attenuation, based on oscilloscope readings.
    '''
    R1 = 10e6

    # Since the feedback circuit changed in version 2 of the control board, we
    # use the transfer function that corresponds to the current control board
    # version that the fitted attenuation model is based on.
    if axis is None:
        fig = plt.figure()
        axis = fig.add_subplot(111)

    markers = MarkerStyle.filled_markers

    def plot_resistor_params(args):
        resistor_index, x = args

        try:
            color = axis._get_lines.color_cycle.next()
        except: # make compatible with matplotlib v1.5
            color = axis._get_lines.prop_cycler.next()['color']

        F = feedback_params.loc[resistor_index]
        # Broadcast values in case sympy function simplifies to scalar value.
        values = np.empty_like(x['frequency'])
        values[:] = compute_from_transfer_function(hw_major_version, 'V2',
                                                   V1=1., R1=R1,
                                                   R2=F['original R'],
                                                   C2=F['original C'],
                                                   f=x['frequency'])
        axis.loglog(x['frequency'], values, color=color, linestyle='--',
                    label='R$_{%d}$ (previous fit)' % resistor_index)

        values[:] = compute_from_transfer_function(hw_major_version, 'V2',
                                                   V1=1., R1=R1,
                                                   R2=F['fitted R'],
                                                   C2=F['fitted C'],
                                                   f=x['frequency'])
        axis.loglog(x['frequency'], values, color=color, linestyle='-',
                    alpha=0.6, label='R$_{%d}$ (new fit)' % resistor_index)
        attenuation = x['board measured V'] / x['oscope measured V']
        axis.plot(x['frequency'], attenuation, color='none',
                  marker=markers[resistor_index % len(markers)],
                  label='R$_{%d}$ (scope measured)' % resistor_index,
                  linestyle='none', markeredgecolor=color, markeredgewidth=2,
                  markersize=8)
        return 0

    map(plot_resistor_params, max_resistor_readings.groupby('resistor index'))
    legend = axis.legend(ncol=3)
    legend.draw_frame(False)
    axis.set_xlabel('Frequency (Hz)')
    axis.set_ylabel(r'$\frac{V_{BOARD}}'
                    r'{V_{SCOPE}}$', fontsize=25)"
593,"def update_control_board_calibration(control_board, fitted_params):
    '''
    Update the control board with the specified fitted parameters.
    '''
    # Update the control board with the new fitted capacitor and resistor
    # values for the reference load analog input (channel 0).
    control_board.a0_series_resistance = fitted_params['fitted R'].values
    control_board.a0_series_capacitance = fitted_params['fitted C'].values"
594,"def load(self):
        """""" Load each path in order. Remember paths already loaded and only load new ones. """"""
        data = self.dict_class()
        
        for path in self.paths:
            if path in self.paths_loaded: continue
            
            try:
                with open(path, 'r') as file:
                    path_data = yaml.load(file.read())
                    data = dict_merge(data, path_data)
                self.paths_loaded.add(path)
            except IOError:
                # TODO: Log this correctly once logging is implemented
                if not path.endswith('.local.yml'):
                    print 'CONFIG NOT FOUND: %s' % (path)

        self.data = data"
595,"def _initialize(self, settings_module):
        """"""
        Initialize the settings from a given settings_module
        settings_module - path to settings module
        """"""
        #Get the global settings values and assign them as self attributes
        self.settings_list = []
        for setting in dir(global_settings):
            #Only get upper case settings
            if setting == setting.upper():
                setattr(self, setting, getattr(global_settings, setting))
                self.settings_list.append(setting)

        #If a settings module was passed in, import it, and grab settings from it
        #Overwrite global settings with theses
        if settings_module is not None:
            self.SETTINGS_MODULE = settings_module

            #Try to import the settings module
            try:
                mod = import_module(self.SETTINGS_MODULE)
            except ImportError:
                error_message = ""Could not import settings at {0}"".format(self.SETTINGS_MODULE)
                log.exception(error_message)
                raise ImportError(error_message)

            #Grab uppercased settings as set them as self attrs
            for setting in dir(mod):
                if setting == setting.upper():
                    if setting == ""INSTALLED_APPS"":
                        self.INSTALLED_APPS += getattr(mod, setting)
                    else:
                        setattr(self, setting, getattr(mod, setting))
                    self.settings_list.append(setting)

        #If PATH_SETTINGS is in the settings file, extend the system path to include it
        if hasattr(self, ""PATH_SETTINGS""):
            for path in self.PATH_SETTINGS:
                sys.path.extend(getattr(self,path))

        self.settings_list = list(set(self.settings_list))"
596,"def _setup(self):
        """"""
        Perform initial setup of the settings class, such as getting the settings module and setting the settings
        """"""
        settings_module  = None
        #Get the settings module from the environment variables
        try:
            settings_module = os.environ[global_settings.MODULE_VARIABLE]
        except KeyError:
            error_message = ""Settings not properly configured.  Cannot find the environment variable {0}"".format(global_settings.MODULE_VARIABLE)
            log.exception(error_message)

        self._initialize(settings_module)
        self._configure_logging()"
597,"def _configure_logging(self):
        """"""
        Setting up logging from logging config in settings
        """"""
        if not self.LOGGING_CONFIG:
            #Fallback to default logging in global settings if needed
            dictConfig(self.DEFAULT_LOGGING)
        else:
            dictConfig(self.LOGGING_CONFIG)"
598,"def ensure_context(**vars):
    """"""Ensures that a context is in the stack, creates one otherwise.
    """"""
    ctx = _context_stack.top
    stacked = False
    if not ctx:
        ctx = Context()
        stacked = True
        _context_stack.push(ctx)
    ctx.update(vars)
    try:
        yield ctx
    finally:
        if stacked:
            _context_stack.pop()"
599,"def request_context(app, request):
    """"""Creates a Context instance from the given request object
    """"""
    vars = {}
    if request.view_args is not None:
        vars.update(request.view_args)
    vars.update({
        ""request"": request,
        ""GET"": AttrDict(request.args.to_dict()),
        ""POST"" : AttrDict(request.form.to_dict()),
        ""app"": app,
        ""config"": app.config,
        ""session"": session,
        ""g"": g,
        ""now"": datetime.datetime.now,
        ""utcnow"": datetime.datetime.utcnow,
        ""today"": datetime.date.today})
    context = Context(vars)
    context.vars[""current_context""] = context
    return context"
600,"def clone(self, **override_vars):
        """"""Creates a copy of this context""""""
        c = Context(self.vars, self.data)
        c.executed_actions = set(self.executed_actions)
        c.vars.update(override_vars)
        return c"
601,"def setup():
    """"""import the matplotlib modules and set the style

    Returns
    -------
    plt: pylab
        imported pylab module
    mpl: matplotlib module
        imported matplotlib module

    """"""
    # Latex support can be activated using an environment variable, otherwise
    # the default settings are:
    # - for windows: off
    # - else: on
    use_latex = False
    if('DD_USE_LATEX' in os.environ):
        if os.environ['DD_USE_LATEX'] == '1':
            use_latex = True
    else:
        if platform.system() == ""Windows"":
            use_latex = False
        else:
            use_latex = True

    already_loaded = 'matplotlib' in sys.modules

    # just make sure we can access matplotlib as mpl
    import matplotlib as mpl

    if not already_loaded:
        mpl.use('Agg')

    import matplotlib.pyplot as plt

    plt.style.use('seaborn')

    # general settings
    mpl.rcParams['font.size'] = 7.0
    mpl.rcParams['axes.labelsize'] = 7.0
    mpl.rcParams['xtick.labelsize'] = 7.0
    mpl.rcParams['ytick.labelsize'] = 7.0
    mpl.rcParams[""lines.linewidth""] = 1.5
    mpl.rcParams[""lines.markeredgewidth""] = 3.0
    mpl.rcParams[""lines.markersize""] = 3.0
    # mpl.rcParams['font.sans-serif'] = 'Droid Sans'

    # mpl.rcParams['font.family'] = 'Open Sans'
    # mpl.rcParams['font.weight'] = 400
    mpl.rcParams['mathtext.default'] = 'regular'

    # mpl.rcParams['font.family'] = 'Droid Sans'

    if use_latex:
        mpl.rcParams['text.usetex'] = True

        mpl.rc(
            'text.latex',
            preamble=''.join((
                # r'\usepackage{droidsans}',
                # r'\usepackage[T1]{fontenc} ',
                r'\usepackage{sfmath} \renewcommand{\rmfamily}{\sffamily}',
                r'\renewcommand\familydefault{\sfdefault} ',
                # r'\usepackage{mathastext} '
            ))
        )
    else:
        mpl.rcParams['text.usetex'] = False
    import mpl_toolkits.axes_grid1 as axes_grid1
    axes_grid1
    return plt, mpl"
602,"def mpl_get_cb_bound_below_plot(ax):
    """"""
    Return the coordinates for a colorbar axes below the provided axes object.
    Take into account the changes of the axes due to aspect ratio settings.

    Parts of this code are taken from the transforms.py file from matplotlib

    Important: Use only AFTER fig.subplots_adjust(...)

    Use as:
    =======
    """"""
    position = ax.get_position()

    figW, figH = ax.get_figure().get_size_inches()
    fig_aspect = figH / figW
    box_aspect = ax.get_data_ratio()
    pb = position.frozen()
    pb1 = pb.shrunk_to_aspect(box_aspect, pb, fig_aspect).bounds

    ax_size = ax.get_position().bounds

    # the colorbar is set to 0.01 width
    sizes = [ax_size[0], ax_size[1] - 0.14, pb1[2], 0.03]

    return sizes"
603,"def main():
    """"""Generate an XLS with specified content.""""""
    table = """"""<table>
    <thead>
    <tr><th>First Name</th><th>Last Name</th></tr>
    </thead>
    <tbody>
    <tr><td>Paul</td><td>McGrath</td></tr>
    <tr><td>Liam</td><td>Brady</td></tr>
    <tr><td>John</td><td>Giles</td></tr>
    </tbody>
    </table>""""""
    docraptor = DocRaptor()

    print(""Create test_basic.xls"")
    with open(""test_basic.xls"", ""wb"") as pdf_file:
        pdf_file.write(
            docraptor.create(
                {""document_content"": table, ""document_type"": ""xls"", ""test"": True}
            ).content
        )"
604,"def restore_gc_state():
    """"""
    Restore the garbage collector state on leaving the with block.

    """"""
    old_isenabled = gc.isenabled()
    old_flags = gc.get_debug()
    try:
        yield
    finally:
        gc.set_debug(old_flags)
        (gc.enable if old_isenabled else gc.disable)()"
605,"def develop_link(options, info):
    '''
    Prepare development environment.

    Perform the following steps:

     - Uninstall ``dmf_control_board_firmware`` if installed as Conda package.
     - Install build and run-time Conda dependencies.
     - Link working ``.pioenvs`` directory into Conda ``Library`` directory to
       make development versions of compiled firmware binaries available to
       Python API.
     - Link ``dmf_control_board_firmware`` Python package into site packages
       directory.

    See Also
    --------
    :func:`develop_unlink`
    '''
    project_dir = ph.path(__file__).realpath().parent

    # Uninstall ``dmf_control_board_firmware`` if installed as Conda package.
    info('Check if Conda package is installed...')
    version_info = ch.conda_version_info('dmf-control-board-firmware')
    if version_info.get('installed') is not None:
        info('Uninstall `dmf-control-board-firmware` package...')
        ch.conda_exec('uninstall', '-y', 'dmf-control-board-firmware',
                      verbose=True)
    else:
        info('`dmf-control-board-firmware` package is not installed.')

    # Install build and run-time Conda dependencies.
    info('Install build and run-time Conda dependencies...')
    recipe_dir = project_dir.joinpath('.conda-recipe').realpath()
    ch.conda_exec('install', '-y', '-n', 'root', 'conda-build', verbose=True)
    ch.development_setup(recipe_dir, verbose=True)

    # Link working ``.pioenvs`` directory into Conda ``Library`` directory.
    info('Link working firmware directories into Conda environment.')
    pio_bin_dir = pioh.conda_bin_path()

    fw_bin_dir = pio_bin_dir.joinpath('dmf-control-board-firmware')

    if not fw_bin_dir.exists():
        project_dir.joinpath('.pioenvs').junction(fw_bin_dir)

    fw_config_ini = fw_bin_dir.joinpath('platformio.ini')
    if not fw_config_ini.exists():
        project_dir.joinpath('platformio.ini').link(fw_config_ini)

    # Link ``dmf_control_board_firmware`` Python package `conda.pth` in site
    # packages directory.
    info('Link working Python directory into Conda environment...')
    ch.conda_exec('develop', project_dir, verbose=True)
    info(72 * '-' + '\nFinished')"
606,"def develop_unlink(options, info):
    '''
    Prepare development environment.

    Perform the following steps:

     - Unlink working ``.pioenvs`` directory into Conda ``Library`` directory.
     - Unlink ``dmf_control_board_firmware`` Python package from site packages
       directory.

    See Also
    --------
    :func:`develop_link`
    '''
    project_dir = ph.path(__file__).realpath().parent

    # Unlink working ``.pioenvs`` directory into Conda ``Library`` directory.
    info('Unlink working firmware directories from Conda environment.')
    pio_bin_dir = pioh.conda_bin_path()
    fw_bin_dir = pio_bin_dir.joinpath('dmf-control-board-firmware')

    if fw_bin_dir.exists():
        fw_config_ini = fw_bin_dir.joinpath('platformio.ini')
        if fw_config_ini.exists():
            fw_config_ini.unlink()
        fw_bin_dir.unlink()

    # Remove link to ``dmf_control_board_firmware`` Python package in
    # `conda.pth` in site packages directory.
    info('Unlink working Python directory from Conda environment...')
    ch.conda_exec('develop', '-u', project_dir, verbose=True)
    info(72 * '-' + '\nFinished')"
607,"def response(self, parameters):
        r""""""Return the forward response in base dimensions
        :math:`\hat{\sigma }(\omega ) = \sigma _\infty \left(1 - \sum_i \frac
        {m_i}{1 + (j \omega \tau_i)^c_i}\right)`

        Parameters
        ----------
        pars:

        Returns
        -------
        response: Nx2 array, first axis denotes frequencies, seconds real and
                  imaginary parts
        """"""
        # get a config object
        self._set_parameters(parameters)
        terms = self.m / (1 + (1j * self.w * self.tau) ** self.c)
        # sum up terms
        specs = np.sum(terms, axis=1)
        ccomplex = self.sigmai * (1 - specs)

        response = sip_response.sip_response(self.f, ccomplex=ccomplex)

        return response"
608,"def dre_dsigmai(self, pars):
        r""""""
        :math:Add formula
        """"""
        self._set_parameters(pars)
        terms = self.m * self.num / self.denom
        specs = np.sum(terms, axis=1)
        result = 1 - specs

        return result"
609,"def dre_dm(self, pars):
        r""""""
        :math:Add formula
        """"""
        self._set_parameters(pars)
        terms = self.num / self.denom
        result = - self.sigmai * terms

        return result"
610,"def dre_dtau(self, pars):
        r""""""
        :math:Add formula
        """"""
        self._set_parameters(pars)
        # term 1
        num1 = self.c * self.w * self.otc1 * np.cos(self.ang)
        term1 = num1/self.denom

        # term 2
        num2a = self.otc * np.cos(self.ang)
        num2b = 1 + num2a
        denom2 = self.denom ** 2
        term2 = num2b / denom2

        # term 3
        term3 = 2 * self.c * self.w * self.otc1 * np.cos(self.ang) + self.otc2

        result = self.sigmai * self.m * (term1 + term2 * term3)

        return result"
611,"def dre_dc(self, pars):
        r""""""
        :math:Add formula
        """"""
        self._set_parameters(pars)
        # term 1
        num1a = np.log(self.w * self.tau) * self.otc * np.sin(self.ang)
        num1b = self.otc * np.cos(self.ang) * np.pi / 2.0
        term1 = (num1a + num1b) / self.denom

        # term 2
        num2 = self.otc * np.sin(self.c / np.pi) * 2
        denom2 = self.denom ** 2
        term2 = num2 / denom2

        # term 3
        num3a = 2 * np.log(self.w * self.tau) * self.otc * np.cos(self.ang)
        num3b = 2 * ((self.w * self.tau) ** 2) * np.pi / 2.0 * np.sin(self.ang)
        num3c = 2 * np.log(self.w * self.tau) * self.otc2
        term3 = num3a - num3b + num3c

        result = self.sigmai * self.m * (term1 + term2 * term3)

        return result"
612,"def dim_dsigmai(self, pars):
        r""""""
        :math:Add formula
        """"""
        self._set_parameters(pars)
        result = np.sum(- self.m * self.otc * np.sin(self.ang) / self.denom,
                        axis=1)

        return result"
613,"def dim_dm(self, pars):
        r""""""
        :math:Add formula
        """"""
        self._set_parameters(pars)
        num1 = self.otc * np.sin(self.ang)
        result = -self.sigmai * num1 / self.denom

        return result"
614,"def dim_dtau(self, pars):
        r""""""
        :math:Add formula
        """"""
        self._set_parameters(pars)
        # term 1
        num1 = -self.m * (self.w ** self.c) * self.c\
            * (self.tau ** (self.c - 1)) * np.sin(self.ang)
        term1 = self.sigmai * num1 / self.denom

        # term 2
        num2a = -self.m * self.otc * np.sin(self.ang)
        num2b = 2 * (self.w ** 2.0) * self.c * (self.tau ** (self.c - 1)) *\
            np.cos(self.ang)
        num2c = 2 * self.c * (self.w ** (self.c * 2)) *\
            (self.tau ** (2 * self.c - 1))
        term2 = self.sigma0 * num2a * (num2b + num2c) / (self.denom ** 2)

        result = term1 + term2

        return result"
615,"def dim_dc(self, pars):
        r""""""
        :math:Add formula
        """"""
        self._set_parameters(pars)
        # term 1
        num1a = self.m * np.sin(self.ang) * np.log(self.w * self.tau)\
            * self.otc
        num1b = self.m * self.otc * np.pi / 2 * np.cos(np.pi / 2)
        term1 = self.sigma0 * (-num1a - num1b) / self.denom

        # term 2
        num2a = -self.m * self.otc * np.cos(self.ang)
        num2b = -2 * np.log(self.w * self.tau) * self.otc * np.cos(self.ang)
        num2c = 2 * self.otc * np.pi / 2 * np.cos(self.ang)
        num2d = 2 * np.log(self.w * self.tau) * self.otc2
        numerator = num2a * (num2b + num2c) + num2d
        term2 = self.sigma0 * numerator / (self.denom ** 2)

        result = term1 + term2

        return result"
616,"def add_view_file_mapping(self, pattern, cls):
        """"""Adds a mapping between a file and a view class.
        Pattern can be an extension in the form .EXT or a filename.
        """"""
        if isinstance(pattern, str):
            if not pattern.endswith(""*""):
                _, ext = os.path.splitext(pattern)
                self.allowed_extensions.add(ext)
            pattern = re.compile(""^"" + re.escape(pattern).replace(""\\*"", "".+"") + ""$"", re.I)
        self.view_class_files_map.append((pattern, cls))"
617,"def load_file(self, app, pathname, relpath, pypath):
        """"""Loads a file and creates a View from it. Files are split
        between a YAML front-matter and the content (unless it is a .yml file).
        """"""
        try:
            view_class = self.get_file_view_cls(relpath)
            return create_view_from_file(pathname, source_template=relpath, view_class=view_class)
        except DeclarativeViewError:
            pass"
618,"def get_file_view_cls(self, filename):
        """"""Returns the view class associated to a filename
        """"""
        if filename is None:
            return self.default_view_class
        for pattern, cls in self.view_class_files_map:
            if pattern.match(filename):
                return cls
        return self.default_view_class"
619,"def children(self, vertex):
        """"""
        Return the list of immediate children of the given vertex.

        """"""
        return [self.head(edge) for edge in self.out_edges(vertex)]"
620,"def parents(self, vertex):
        """"""
        Return the list of immediate parents of this vertex.

        """"""
        return [self.tail(edge) for edge in self.in_edges(vertex)]"
621,"def references(self):
        """"""
        Return (tail, head) pairs for each edge in the
        graph.

        """"""
        return [
            (tail, head)
            for tail in self.vertices
            for head in self.children(tail)
        ]"
622,"def descendants(self, start, generations=None):
        """"""
        Return the subgraph of all nodes reachable
        from the given start vertex, including that vertex.

        If specified, the optional `generations` argument specifies how
        many generations to limit to.

        """"""
        visited = self.vertex_set()
        visited.add(start)
        to_visit = deque([(start, 0)])
        while to_visit:
            vertex, depth = to_visit.popleft()
            if depth == generations:
                continue
            for child in self.children(vertex):
                if child not in visited:
                    visited.add(child)
                    to_visit.append((child, depth+1))
        return self.full_subgraph(visited)"
623,"def ancestors(self, start, generations=None):
        """"""
        Return the subgraph of all nodes from which the given vertex is
        reachable, including that vertex.

        If specified, the optional `generations` argument specifies how
        many generations to limit to.

        """"""
        visited = self.vertex_set()
        visited.add(start)
        to_visit = deque([(start, 0)])
        while to_visit:
            vertex, depth = to_visit.popleft()
            if depth == generations:
                continue
            for parent in self.parents(vertex):
                if parent not in visited:
                    visited.add(parent)
                    to_visit.append((parent, depth+1))
        return self.full_subgraph(visited)"
624,"def _component_graph(self):
        """"""
        Compute the graph of strongly connected components.

        Each strongly connected component is itself represented as a list of
        pairs, giving information not only about the vertices belonging to
        this strongly connected component, but also the edges leading from
        this strongly connected component to other components.

        Each pair is of the form ('EDGE', v) or ('VERTEX', v) for some vertex
        v.  In the first case, that indicates that there's an edge from this
        strongly connected component to the given vertex v (which will belong
        to another component); in the second, it indicates that v is a member
        of this strongly connected component.

        Each component will begin with a vertex (the *root* vertex of the
        strongly connected component); the following edges are edges from that
        vertex.

        Algorithm is based on that described in ""Path-based depth-first search
        for strong and biconnected components"" by Harold N. Gabow,
        Inf.Process.Lett. 74 (2000) 107--114.

        """"""
        sccs = []
        stack = []
        boundaries = []
        identified = self.vertex_set()
        index = self.vertex_dict()
        to_do = []

        def visit_vertex(v):
            index[v] = len(stack)
            stack.append(('VERTEX', v))
            boundaries.append(index[v])
            to_do.append((leave_vertex, v))
            to_do.extend((visit_edge, w) for w in self.children(v))

        def visit_edge(v):
            if v in identified:
                stack.append(('EDGE', v))
            elif v in index:
                while index[v] < boundaries[-1]:
                    boundaries.pop()
            else:
                to_do.append((visit_vertex, v))

        def leave_vertex(v):
            if boundaries[-1] == index[v]:
                root = boundaries.pop()
                scc = stack[root:]
                del stack[root:]
                for item_type, w in scc:
                    if item_type == 'VERTEX':
                        identified.add(w)
                        del index[w]
                sccs.append(scc)
                stack.append(('EDGE', v))

        # Visit every vertex of the graph.
        for v in self.vertices:
            if v not in identified:
                to_do.append((visit_vertex, v))
                while to_do:
                    operation, v = to_do.pop()
                    operation(v)
                stack.pop()

        return sccs"
625,"def source_components(self):
        """"""
        Return the strongly connected components not reachable from any other
        component.  Any component in the graph is reachable from one of these.

        """"""
        raw_sccs = self._component_graph()

        # Construct a dictionary mapping each vertex to the root of its scc.
        vertex_to_root = self.vertex_dict()

        # And keep track of which SCCs have incoming edges.
        non_sources = self.vertex_set()

        # Build maps from vertices to roots, and identify the sccs that *are*
        # reachable from other components.
        for scc in raw_sccs:
            root = scc[0][1]
            for item_type, w in scc:
                if item_type == 'VERTEX':
                    vertex_to_root[w] = root
                elif item_type == 'EDGE':
                    non_sources.add(vertex_to_root[w])

        sccs = []
        for raw_scc in raw_sccs:
            root = raw_scc[0][1]
            if root not in non_sources:
                sccs.append([v for vtype, v in raw_scc if vtype == 'VERTEX'])

        return [self.full_subgraph(scc) for scc in sccs]"
626,"def strongly_connected_components(self):
        """"""
        Return list of strongly connected components of this graph.

        Returns a list of subgraphs.

        Algorithm is based on that described in ""Path-based depth-first search
        for strong and biconnected components"" by Harold N. Gabow,
        Inf.Process.Lett. 74 (2000) 107--114.

        """"""
        raw_sccs = self._component_graph()

        sccs = []
        for raw_scc in raw_sccs:
            sccs.append([v for vtype, v in raw_scc if vtype == 'VERTEX'])

        return [self.full_subgraph(scc) for scc in sccs]"
627,"def save(self, *args, **kwargs):
        """"""
        **uid**: :code:`person:{slug}`
        """"""
        if not self.full_name:
            self.full_name = '{0}{1}{2}'.format(
                self.first_name,
                '{}'.format(
                    ' ' + self.middle_name + ' ' if self.middle_name else ' ',
                ),
                self.last_name,
                '{}'.format(' ' + self.suffix if self.suffix else '')
            )

        self.slug = uuslug(
            self.full_name,
            instance=self,
            max_length=100,
            separator='-',
            start_no=2
        )
        if not self.uid:
            self.uid = 'person:{}'.format(self.slug)

        super(Person, self).save(*args, **kwargs)"
628,"def signature(self):
        """"""
        Compute the ORDER_HASH of the request.

        The hashable string is composed by getting the values from:
            MERCHANT
            ORDER_REF
            ORDER_DATE
            ORDER_PNAME[]
            ORDER_PCODE[]
            ORDER_PINFO[]
            ORDER_PRICE[]
            ORDER_QTY[]
            ORDER_VAT[]
            ORDER_SHIPPING
            PRICES_CURRENCY
            DISCOUNT
            DESTINATION_CITY
            DESTINATION_STATE
            DESTINATION_COUNTRY
            PAY_METHOD
            ORDER_PRICE_TYPE[]
            SELECTED_INSTALLMENTS_NO
            TESTORDER
        in this exact order. Next, we need to concatenate their lenghts with
        thier values, resulting in a string like:

        8PAYUDEMO9789456123192016-10-05 11:12:279CD Player12MobilePhone6Laptop
        10PROD_0489110PROD_0740910PROD_0496527Extended Warranty - 5 Years8
        Dual SIM1117""Display482.371945.7545230171311220220220103RON2559
        Bucuresti9Bucuresti2RO8CCVISAMC5GROSS5GROSS5GROSS4TRUE

        Using this string and the MERCHANT_KEY, we compute the HMAC.
        """"""

        hashable_fields = ['MERCHANT', 'ORDER_REF', 'ORDER_DATE',
                           'ORDER_SHIPPING', 'PRICES_CURRENCY', 'DISCOUNT',
                           'DESTINATION_CITY', 'DESTINATION_STATE',
                           'DESTINATION_COUNTRY', 'PAY_METHOD',
                           'SELECTED_INSTALLMENTS_NO', 'TESTORDER']
        result = text_type()

        # We need this hack since payU is not consistent
        # with the order of fields in hash string

        suffix = text_type()
        for field in self:
            if field.name == 'ORDER_HASH':
                continue

            field_value = field.value()

            if field.name in hashable_fields and field_value:
                encoded_value = text_type('{length}{value}').format(
                    length=len(text_type(field_value).encode('utf-8')), value=field_value
                )
                if field.name == 'TESTORDER' or \
                    field.name == 'SELECTED_INSTALLMENTS_NO':
                    suffix += encoded_value
                else:
                    result += encoded_value

            if field.name == 'ORDER':
                for detail in PAYU_ORDER_DETAILS:
                    if any([detail in order and order[detail]
                            for order in field_value]):

                        for order in field_value:
                            value = order.get(detail, '')

                            item = text_type('{length}{value}').format(
                                length=len(text_type(value).encode('utf-8')), value=value
                            )

                            if detail == 'PRICE_TYPE':
                                suffix += item
                            else:
                                result += item

        result += suffix
        result = result.encode('utf-8')
        return hmac.new(PAYU_MERCHANT_KEY, result).hexdigest()"
629,"def _prepare_orders(self, orders):
        """"""
        Each order needs to have all it's details filled with default value,
        or None, in case those are not already filled.
        """"""

        for detail in PAYU_ORDER_DETAILS:
            if not any([detail in order for order in orders]):
                for order in orders:
                    order[detail] = PAYU_ORDER_DETAILS_DEFAULTS.get(detail, None)

        return orders"
630,"def staticfiles_url_fetcher(url):
    """"""
    Returns the file matching url.

    This method will handle any URL resources that rendering HTML requires
    (eg: images pointed my ``img`` tags, stylesheets, etc).

    The default behaviour will fetch any http(s) files normally, and will
    also attempt to resolve staticfiles internally (this should mostly
    affect development scenarios, but also works if static files are served
    under a relative url).

    Returns a dictionary with two entries: ``string``, which is the
    resources data as a string and ``mime_type``, which is the identified
    mime type for the resource.
    """"""
    if url.startswith('/'):
        base_url = staticfiles_storage.base_url
        filename = url.replace(base_url, '', 1)

        path = finders.find(filename)
        if path:
            # This should match most cases. Manifest static files with relative
            # URLs will only be picked up in DEBUG mode here.
            with open(path, 'rb') as f:
                data = f.read()
        else:
            # This should just match things like Manifest static files with
            # relative URLs. While this code path will expect `collectstatic`
            # to have run, it should only be reached on if DEBUG = False.

            # XXX: Only Django >= 2.0 supports using this as a context manager:
            f = staticfiles_storage.open(filename)
            data = f.read()
            f.close()

        return {
            'string': data,
            'mime_type': mimetypes.guess_type(url)[0],
        }
    else:
        return default_url_fetcher(url)"
631,"def render_pdf(
    template,
    file_,
    url_fetcher=staticfiles_url_fetcher,
    context=None,
):
    """"""
    Writes the PDF data into ``file_``. Note that ``file_`` can actually be a
    Django Response object as well.

    This function may be used as a helper that can be used to save a PDF file
    to a file (or anything else outside of a request/response cycle), eg::

    :param str html: A rendered HTML.
    :param file file_: A file like object (or a Response) where to output
        the rendered PDF.
    """"""
    context = context or {}

    html = get_template(template).render(context)
    HTML(
        string=html,
        base_url='not-used://',
        url_fetcher=url_fetcher,
    ).write_pdf(
        target=file_,
    )"
632,"def encode_bytes(src_buf, dst_file):
    """"""Encode a buffer length followed by the bytes of the buffer
    itself.

    Parameters
    ----------
    src_buf: bytes
        Source bytes to be encoded.  Function asserts that
        0 <= len(src_buf) <= 2**16-1.
    dst_file: file
        File-like object with write method.

    Returns
    -------
    int
        Number of bytes written to `dst_file`.
    """"""
    if not isinstance(src_buf, bytes):
        raise TypeError('src_buf must by bytes.')

    len_src_buf = len(src_buf)
    assert 0 <= len_src_buf <= 2**16-1
    num_written_bytes = len_src_buf + 2

    len_buf = FIELD_U16.pack(len_src_buf)
    dst_file.write(len_buf)
    dst_file.write(src_buf)

    return num_written_bytes"
633,"def decode_bytes(f):
    """"""Decode a buffer length from a 2-byte unsigned int then read the
    subsequent bytes.

    Parameters
    ----------
    f: file
        File-like object with read method.

    Raises
    ------
    UnderflowDecodeError
        When the end of stream is encountered before the end of the
        encoded bytes.

    Returns
    -------
    int
        Number of bytes read from `f`.
    bytes
        Value bytes decoded from `f`.
    """"""

    buf = f.read(FIELD_U16.size)
    if len(buf) < FIELD_U16.size:
        raise UnderflowDecodeError()

    (num_bytes,) = FIELD_U16.unpack_from(buf)
    num_bytes_consumed = FIELD_U16.size + num_bytes

    buf = f.read(num_bytes)
    if len(buf) < num_bytes:
        raise UnderflowDecodeError()

    return num_bytes_consumed, buf"
634,"def encode_utf8(s, f):
    """"""UTF-8 encodes string `s` to file-like object `f` according to
    the MQTT Version 3.1.1 specification in section 1.5.3.

    The maximum length for the encoded string is 2**16-1 (65535) bytes.
    An assertion error will result if the encoded string is longer.

    Parameters
    ----------
    s: str
        String to be encoded.
    f: file
        File-like object.

    Returns
    -------
    int
        Number of bytes written to f.
    """"""
    encode = codecs.getencoder('utf8')

    encoded_str_bytes, num_encoded_chars = encode(s)
    num_encoded_str_bytes = len(encoded_str_bytes)
    assert 0 <= num_encoded_str_bytes <= 2**16-1
    num_encoded_bytes = num_encoded_str_bytes + 2

    f.write(FIELD_U8.pack((num_encoded_str_bytes & 0xff00) >> 8))
    f.write(FIELD_U8.pack(num_encoded_str_bytes & 0x00ff))
    f.write(encoded_str_bytes)

    return num_encoded_bytes"
635,"def decode_utf8(f):
    """"""Decode a utf-8 string encoded as described in MQTT Version
    3.1.1 section 1.5.3 line 177.  This is a 16-bit unsigned length
    followed by a utf-8 encoded string.

    Parameters
    ----------
    f: file
        File-like object with read method.

    Raises
    ------
    UnderflowDecodeError
        Raised when a read failed to extract enough bytes from the
        underlying stream to decode the string.
    Utf8DecodeError
        When any code point in the utf-8 string is invalid.

    Returns
    -------
    int
        Number of bytes consumed.
    str
        A string utf-8 decoded from ``f``.
    """"""
    decode = codecs.getdecoder('utf8')

    buf = f.read(FIELD_U16.size)
    if len(buf) < FIELD_U16.size:
        raise UnderflowDecodeError()

    (num_utf8_bytes,) = FIELD_U16.unpack_from(buf)
    num_bytes_consumed = FIELD_U16.size + num_utf8_bytes

    buf = f.read(num_utf8_bytes)
    if len(buf) < num_utf8_bytes:
        raise UnderflowDecodeError()

    try:
        s, num_chars = decode(buf, 'strict')
    except UnicodeError as e:
        raise Utf8DecodeError(e)

    return num_bytes_consumed, s"
636,"def encode_varint(v, f):
    """"""Encode integer `v` to file `f`.

    Parameters
    ----------
    v: int
        Integer v >= 0.
    f: file
        Object containing a write method.

    Returns
    -------
    int
        Number of bytes written.
    """"""
    assert v >= 0
    num_bytes = 0

    while True:
        b = v % 0x80
        v = v // 0x80

        if v > 0:
            b = b | 0x80

        f.write(FIELD_U8.pack(b))

        num_bytes += 1
        if v == 0:
            break

    return num_bytes"
637,"def decode_varint(f, max_bytes=4):
    """"""Decode variable integer using algorithm similar to that described
    in MQTT Version 3.1.1 line 297.

    Parameters
    ----------
    f: file
        Object with a read method.
    max_bytes: int or None
        If a varint cannot be constructed using `max_bytes` or fewer
        from f then raises a `DecodeError`.  If None then there is no
        maximum number of bytes.

    Raises
    -------
    DecodeError
        When length is greater than max_bytes.
    UnderflowDecodeError
        When file ends before enough bytes can be read to construct the
        varint.

    Returns
    -------
    int
        Number of bytes consumed.
    int
        Value extracted from `f`.

    """"""
    num_bytes_consumed = 0

    value = 0
    m = 1

    while True:
        buf = f.read(1)
        if len(buf) == 0:
            raise UnderflowDecodeError()

        (u8,) = FIELD_U8.unpack(buf)
        value += (u8 & 0x7f) * m
        m *= 0x80
        num_bytes_consumed += 1

        if u8 & 0x80 == 0:
            # No further bytes
            break
        elif max_bytes is not None and num_bytes_consumed >= max_bytes:
            raise DecodeError('Variable integer contained more than maximum bytes ({}).'.format(max_bytes))

    return num_bytes_consumed, value"
638,"def unpack(self, struct):
        """"""Read as many bytes as are required to extract struct then
        unpack and return a tuple of the values.

        Raises
        ------
        UnderflowDecodeError
            Raised when a read failed to extract enough bytes from the
            underlying stream to extract the bytes.

        Parameters
        ----------
        struct: struct.Struct

        Returns
        -------
        tuple
            Tuple of extracted values.
        """"""
        v = struct.unpack(self.read(struct.size))
        return v"
639,"def unpack_utf8(self):
        """"""Decode a utf-8 string encoded as described in MQTT Version
        3.1.1 section 1.5.3 line 177.  This is a 16-bit unsigned length
        followed by a utf-8 encoded string.

        Raises
        ------
        UnderflowDecodeError
            Raised when a read failed to extract enough bytes from the
            underlying stream to decode the string.
        DecodeError
            When any code point in the utf-8 string is invalid.

        Returns
        -------
        int
            Number of bytes consumed.
        str
            A string utf-8 decoded from the underlying stream.
        """"""
        num_bytes_consumed, s = decode_utf8(self.__f)
        self.__num_bytes_consumed += num_bytes_consumed
        return num_bytes_consumed, s"
640,"def unpack_bytes(self):
        """"""Unpack a utf-8 string encoded as described in MQTT Version
        3.1.1 section 1.5.3 line 177.  This is a 16-bit unsigned length
        followed by a utf-8 encoded string.

        Returns
        -------
        int
            Number of bytes consumed
        bytes
            A bytes object extracted from the underlying stream.
        """"""
        num_bytes_consumed, b = decode_bytes(self.__f)
        self.__num_bytes_consumed += num_bytes_consumed
        return num_bytes_consumed, b"
641,"def unpack_varint(self, max_bytes):
        """"""Decode variable integer using algorithm similar to that described
        in MQTT Version 3.1.1 line 297.

        Parameters
        ----------
        max_bytes: int or None
            If a varint cannot be constructed using `max_bytes` or fewer
            from f then raises a `DecodeError`.  If None then there is no
            maximum number of bytes.

        Raises
        -------
        DecodeError
            When length is greater than max_bytes.
        UnderflowDecodeError
            When file ends before enough bytes can be read to construct the
            varint.

        Returns
        -------
        int
            Number of bytes consumed.
        int
            Value extracted from `f`.

        """"""
        num_bytes_consumed, value = decode_varint(self.__f, max_bytes)
        self.__num_bytes_consumed += num_bytes_consumed
        return num_bytes_consumed, value"
642,"def read(self, num_bytes):
        """"""Read `num_bytes` and return them.

        Parameters
        ----------
        num_bytes : int
            Number of bytes to extract from the underlying stream.

        Raises
        ------
        UnderflowDecodeError
            Raised when a read failed to extract enough bytes from the
            underlying stream to extract the bytes.

        Returns
        -------
        bytes
            A bytes object extracted from underlying stream.
        """"""
        buf = self.__f.read(num_bytes)
        assert len(buf) <= num_bytes
        if len(buf) < num_bytes:
            raise UnderflowDecodeError()
        self.__num_bytes_consumed += num_bytes

        return buf"
643,"def read(self, max_bytes=1):
        """"""Read at most `max_bytes` from internal buffer.

        Parameters
        -----------
        max_bytes: int
            Maximum number of bytes to read.

        Returns
        --------
        bytes
            Bytes extracted from internal buffer.  Length may be less
            than ``max_bytes``.  On end-of file returns a bytes object
            with zero-length.
        """"""

        if self.limit is None:
            b = self.__f.read(max_bytes)
        else:
            if self.__num_bytes_consumed + max_bytes > self.limit:
                max_bytes = self.limit - self.__num_bytes_consumed
            b = self.__f.read(max_bytes)
        self.__num_bytes_consumed += len(b)

        return b"
644,"def read(self, max_bytes=1):
        """"""Read at most `max_bytes` from internal buffer.

        Parameters
        -----------
        max_bytes: int
            Maximum number of bytes to read.

        Raises
        ------
        ValueError
            If read is called after close has been called.

        Returns
        --------
        bytes
            Bytes extracted from internal buffer.  Length may be less
            than `max_bytes`.  On end-of file returns a bytes object
            with zero-length.
        """"""
        if self.__num_bytes_consumed is None:
            raise ValueError('I/O operation on closed file.')

        if self.__num_bytes_consumed + max_bytes >= len(self.__buf):
            max_bytes = len(self.__buf) - self.__num_bytes_consumed

        b = self.__buf[self.__num_bytes_consumed:self.__num_bytes_consumed + max_bytes]
        self.__num_bytes_consumed += max_bytes

        if isinstance(b, bytearray):
            b = bytes(b)

        assert isinstance(b, bytes)
        return b"
645,"def timeout(self, value):
        '''
        Specifies a timeout on the search query
        '''
        if not self.params:
            self.params = dict(timeout=value)
            return self
        self.params['timeout'] = value
        return self"
646,"def filtered(self, efilter):
        '''
        Applies a filter to the search
        '''
        if not self.params:
            self.params={'filter' : efilter}
            return self
        if not self.params.has_key('filter'):
            self.params['filter'] = efilter
            return self
        self.params['filter'].update(efilter)
        return self"
647,"def size(self,value):
        '''
        The number of hits to return. Defaults to 10
        '''
        if not self.params:
            self.params = dict(size=value)
            return self
        self.params['size'] = value
        return self"
648,"def from_offset(self, value):
        '''
        The starting from index of the hits to return. Defaults to 0.
        '''
        if not self.params:
            self.params = dict({'from':value})
            return self
        self.params['from'] = value
        return self"
649,"def sort(self, *args, **kwargs):
        '''
        http://www.elasticsearch.org/guide/reference/api/search/sort.html
        Allows to add one or more sort on specific fields. Each sort can be reversed as well. The sort is defined on a per field level, with special field name for _score to sort by score.

        standard arguments are ordered ascending, keyword arguments are fields and you specify the order either asc or desc
        '''
        if not self.params:
            self.params = dict()
        self.params['sort'] = list()
        for arg in args:
            self.params['sort'].append(arg)
        for k,v in kwargs.iteritems():
            self.params['sort'].append({k : v})

        return self"
650,"def sorted(self, fsort):
        '''
        Allows to add one or more sort on specific fields. Each sort can be reversed as well. The sort is defined on a per field level, with special field name for _score to sort by score.
        '''
        if not self.params:
            self.params = dict()
        self.params['sort'] = fsort

        return self"
651,"def search_simple(self, index,itype, key, search_term):
        '''
        ElasticSearch.search_simple(index,itype,key,search_term)
        Usage:
        > es = ElasticSearch()
        > es.search_simple('twitter','users','name','kim')
        '''
        request = self.session
        url = 'http://%s:%s/%s/%s/_search?q=%s:%s' % (self.host,self.port,index,itype,key,search_term)
        response = request.get(url)

        return response"
652,"def search_advanced(self, index, itype, query):
        '''
        Advanced search interface using specified query
        > query = ElasticQuery().term(user='kimchy')
        > ElasticSearch().search_advanced('twitter','posts',query)
         ... Search results ...

        '''
        request = self.session
        url = 'http://%s:%s/%s/%s/_search' % (self.host,self.port,index,itype)
        if self.params:
            query_header = dict(query=query, **self.params)
        else:
            query_header = dict(query=query)
        if self.verbose:
            print query_header
        response = request.post(url,query_header)

        return response"
653,"def doc_create(self,index,itype,value):
        '''
        Creates a document
        '''
        request = self.session
        url = 'http://%s:%s/%s/%s/' % (self.host, self.port, index, itype)
        if self.verbose:
            print value
        response = request.post(url,value)
        return response"
654,"def search_index_simple(self,index,key,search_term):
        '''
        Search the index using a simple key and search_term
        @param index Name of the index
        @param key Search Key
        @param search_term The term to be searched for
        '''
        request = self.session
        url = 'http://%s:%s/%s/_search?q=%s:%s' % (self.host,self.port,index,key,search_term)
        response = request.get(url)
        return response"
655,"def search_index_advanced(self, index, query):
        '''
        Advanced search query against an entire index

        > query = ElasticQuery().query_string(query='imchi')
        > search = ElasticSearch()
        '''
        request = self.session
        url = 'http://%s:%s/%s/_search' % (self.host, self.port, index)
        if self.params:
            content = dict(query=query, **self.params)
        else:
            content = dict(query=query)
        if self.verbose:
            print content
        response = request.post(url,content)
        return response"
656,"def index_create(self, index, number_of_shards=5,number_of_replicas=1):
        '''
        Creates the specified index
        > search = ElasticSearch()
        > search.index_create('twitter')
          {""ok"":true,""acknowledged"":true}
        '''
        request = self.session
        content = {'settings' : dict(number_of_shards=number_of_shards, number_of_replicas=number_of_replicas)}
        if self.verbose:
            print content
        url = 'http://%s:%s/%s' % (self.host, self.port, index)
        response = request.put(url,content)
        return response"
657,"def index_delete(self, index):
        '''
        Delets the specified index
        > search = ElasticSearch()
        > search.index_delete('twitter')
          {""ok"" : True, ""acknowledged"" : True }
        '''
        request = self.session
        url = 'http://%s:%s/%s' % (self.host, self.port, index)
        response = request.delete(url)
        return response"
658,"def index_open(self, index):
        '''
        Opens the speicified index.
        http://www.elasticsearch.org/guide/reference/api/admin-indices-open-close.html

        > ElasticSearch().index_open('my_index')
        '''
        request = self.session
        url = 'http://%s:%s/%s/_open' % (self.host, self.port, index)
        response = request.post(url,None)
        return response"
659,"def river_couchdb_create(self, index_name,index_type='',couchdb_db='', river_name='',couchdb_host='localhost', couchdb_port='5984',couchdb_user=None, couchdb_password=None, couchdb_filter=None,script=''):
        '''
        https://github.com/elasticsearch/elasticsearch-river-couchdb

        Creates a river for the specified couchdb_db.

        > search = ElasticSearch()
        > search.river_couchdb_create('feeds','feeds','feeds')
          {u'_id': u'_meta',
         u'_index': u'_river',
         u'_type': u'test_db',
         u'_version': 1,
         u'ok': True}
        '''
        request = self.session
        if not index_type:
            index_type = index_name
        if not couchdb_db:
            couchdb_db = index_name
        content = {
            'type' : 'couchdb',
            'couchdb' : {
                'host' : couchdb_host,
                'port' : couchdb_port,
                'db' : couchdb_db,
                'filter' : couchdb_filter
            },
            'index' : {
                'index' : index_name,
                'type' : index_type
            }
        }
        if couchdb_user and couchdb_password:
            content['couchdb']['user'] = couchdb_user
            content['couchdb']['password'] = couchdb_password
        if script:
            content['couchdb']['script'] = script
        if self.verbose:
            print content
        url = 'http://%s:%s/_river/%s/_meta' %(self.host, self.port, river_name or index_name)
        response = request.post(url,content)
        return response"
660,"def river_couchdb_delete(self, index_name):
        '''
        https://github.com/elasticsearch/elasticsearch-river-couchdb

        Delete's a river for the specified index
        WARNING: It DOES NOT delete the index, only the river, so the only effects of this are that the index will no longer poll CouchDB for updates.
        '''
        request = self.session
        url = 'http://%s:%s/_river/%s' % (self.host, self.port, index_name)
        response = request.delete(url)
        return response"
661,"def index_list(self):
        '''
        Lists indices
        '''
        request = self.session
        url = 'http://%s:%s/_cluster/state/' % (self.host, self.port)
        response = request.get(url)
        if request.status_code==200:
            return response.get('metadata',{}).get('indices',{}).keys()
        else:
            return response"
662,"def map(self,index_name, index_type, map_value):
        '''
        Enable a specific map for an index and type
        '''
        request = self.session
        url = 'http://%s:%s/%s/%s/_mapping' % (self.host, self.port, index_name, index_type)
        content = { index_type : { 'properties' : map_value } }
        if self.verbose:
            print content
        response = request.put(url,content)
        return response"
663,"def list_types(index_name, host='localhost',port='9200'):
        '''
        Lists the context types available in an index
        '''
        return ElasticSearch(host=host, port=port).type_list(index_name)"
664,"def type_list(self, index_name):
        '''
        List the types available in an index
        '''
        request = self.session
        url = 'http://%s:%s/%s/_mapping' % (self.host, self.port, index_name)
        response = request.get(url)
        if request.status_code == 200:
            return response[index_name].keys()
        else:
            return response"
665,"def raw(self, module, method='GET', data=None):
        '''
        Submits or requsts raw input
        '''
        request = self.session
        url = 'http://%s:%s/%s' % (self.host, self.port, module)
        if self.verbose:
            print data
        if method=='GET':
            response = request.get(url)
        elif method=='POST':
            response = request.post(url,data)
        elif method=='PUT':
            response = request.put(url,data)
        elif method=='DELETE':
            response = request.delete(url)
        else:
            return {'error' : 'No such request method %s' % method}

        return response"
666,"def inverse(self, N):
        """"""
        Returns the modular inverse of an integer with respect to the field
        characteristic, P.

        Use the Extended Euclidean Algorithm:
        https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm
        """"""
        if N == 0:
            return 0
        lm, hm = 1, 0
        low, high = N % self.P, self.P
        while low > 1:
            r = high//low
            nm, new = hm - lm * r, high - low * r
            lm, low, hm, high = nm, new, lm, low

        return lm % self.P"
667,"def is_on_curve(self, point):
        """"""
        Checks whether a point is on the curve.

        Args:
            point (AffinePoint): Point to be checked.

        Returns:
            bool: True if point is on the curve, False otherwise.
        """"""
        X, Y = point.X, point.Y
        return (
                pow(Y, 2, self.P) - pow(X, 3, self.P) - self.a * X - self.b
            ) % self.P == 0"
668,"def generate_private_key(self):
        """"""
        Generates a private key based on the password.

        SHA-256 is a member of the SHA-2 cryptographic hash functions designed by
        the NSA. SHA stands for Secure Hash Algorithm. The password is converted
        to bytes and hashed with SHA-256. The binary output is converted to a hex
        representation.

        Args:
            data (str): The data to be hashed with SHA-256.

        Returns:
            bytes: The hexadecimal representation of the hashed binary data.
        """"""
        random_string = base64.b64encode(os.urandom(4096)).decode('utf-8')
        binary_data = bytes(random_string, 'utf-8')
        hash_object = hashlib.sha256(binary_data)
        message_digest_bin = hash_object.digest()
        message_digest_hex = binascii.hexlify(message_digest_bin)
        return message_digest_hex"
669,"def generate_public_key(self):
        """"""
        Generates a public key from the hex-encoded private key using elliptic
        curve cryptography. The private key is multiplied by a predetermined point
        on the elliptic curve called the generator point, G, resulting in the
        corresponding private key. The generator point is always the same for all
        Bitcoin users.

        Jacobian coordinates are used to represent the elliptic curve point G.
        https://en.wikibooks.org/wiki/Cryptography/Prime_Curve/Jacobian_Coordinates

        The exponentiating by squaring (also known by double-and-add) method is
        used for the elliptic curve multiplication that results in the public key.
        https://en.wikipedia.org/wiki/Exponentiation_by_squaring

        Bitcoin public keys are 65 bytes. The first byte is 0x04, next 32
        bytes correspond to the X coordinate, and last 32 bytes correspond
        to the Y coordinate. They are typically encoded as 130-length hex
        characters.

        Args:
            private_key (bytes): UTF-8 encoded hexadecimal
        Returns:
            str: The public key in hexadecimal representation.
        """"""
        private_key = int(self.private_key, 16)
        if private_key >= self.N:
            raise Exception('Invalid private key.')

        G = JacobianPoint(self.Gx, self.Gy, 1)
        public_key = G * private_key

        x_hex = '{0:0{1}x}'.format(public_key.X, 64)
        y_hex = '{0:0{1}x}'.format(public_key.Y, 64)
        return '04' + x_hex + y_hex"
670,"def generate_address(self):
        """"""
        Creates a Bitcoin address from the public key.
        
        Details of the steps for creating the address are outlined in this link:
        https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses
        
        The last step is Base58Check encoding, which is similar to Base64 encoding but
        slightly different to create a more human-readable string where '1' and 'l' won't
        get confused. More on Base64Check encoding here:
        https://en.bitcoin.it/wiki/Base58Check_encoding
        """"""
        binary_pubkey = binascii.unhexlify(self.public_key)
        binary_digest_sha256 = hashlib.sha256(binary_pubkey).digest()
        binary_digest_ripemd160 = hashlib.new('ripemd160', binary_digest_sha256).digest()

        binary_version_byte = bytes([0])
        binary_with_version_key = binary_version_byte + binary_digest_ripemd160

        checksum_intermed = hashlib.sha256(binary_with_version_key).digest()
        checksum_intermed = hashlib.sha256(checksum_intermed).digest()
        checksum = checksum_intermed[:4]

        binary_address = binary_digest_ripemd160 + checksum

        leading_zero_bytes = 0
        
        for char in binary_address:
            if char == 0:
                leading_zero_bytes += 1

        inp = binary_address + checksum
        result = 0

        while len(inp) > 0:
            result *= 256
            result += inp[0]
            inp = inp[1:]
        
        result_bytes = bytes()
        while result > 0:
            curcode = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'[result % 58]
            result_bytes = bytes([ord(curcode)]) + result_bytes
            result //= 58

        pad_size = 0 - len(result_bytes)
        padding_element = b'1'

        if pad_size > 0:
            result_bytes = padding_element * pad_size + result_bytes
        result = ''.join([chr(y) for y in result_bytes])
        address = '1' * leading_zero_bytes + result
        return address"
671,"def double(self):
        """"""
        Doubles this point.

        Returns:
            JacobianPoint: The point corresponding to `2 * self`.
        """"""
        X1, Y1, Z1 = self.X, self.Y, self.Z

        if Y1 == 0:
            return POINT_AT_INFINITY
        S = (4 * X1 * Y1 ** 2) % self.P
        M = (3 * X1 ** 2 + self.a * Z1 ** 4) % self.P
        X3 = (M ** 2 - 2 * S) % self.P
        Y3 = (M * (S - X3) - 8 * Y1 ** 4) % self.P
        Z3 = (2 * Y1 * Z1) % self.P
        return JacobianPoint(X3, Y3, Z3)"
672,"def to_affine(self):
        """"""
        Converts this point to an affine representation.

        Returns:
            AffinePoint: The affine reprsentation.
        """"""
        X, Y, Z = self.x, self.y, self.inverse(self.z)
        return ((X * Z ** 2) % P, (Y * Z ** 3) % P)"
673,"def double(self):
        """"""
        Doubles this point.

        Returns:
            AffinePoint: The point corresponding to `2 * self`.
        """"""
        X1, Y1, a, P = self.X, self.Y, self.a, self.P

        if self.infinity:
            return self

        S = ((3 * X1 ** 2 + a) * self.inverse(2 * Y1)) % P
        X2 = (S ** 2 - (2 * X1)) % P
        Y2 = (S * (X1 - X2) - Y1) % P
        return AffinePoint(X2, Y2)"
674,"def slope(self, other):
        """"""
        Determines the slope between this point and another point.

        Args:
            other (AffinePoint): The second point.

        Returns:
            int: Slope between self and other.
        """"""
        X1, Y1, X2, Y2 = self.X, self.Y, other.X, other.Y
        Y3 = Y1 - Y2
        X3 = X1 - X2
        return (Y3 * self.inverse(X3)) % self.P"
675,"def to_jacobian(self):
        """"""
        Converts this point to a Jacobian representation.

        Returns:
            JacobianPoint: The Jacobian representation.
        """"""
        if not self:
            return JacobianPoint(X=0, Y=0, Z=0)
        return JacobianPoint(X=self.X, Y=self.Y, Z=1)"
676,"def import_model(self, name, path=""floyd.db.models""):
    """"""imports a model of name from path, returning from local model
    cache if it has been previously loaded otherwise importing""""""
    if name in self._model_cache:
      return self._model_cache[name]
  
    try:
      model = getattr(__import__(path, None, None, [name]), name)
      self._model_cache[name] = model
    except ImportError:
      return False
    return model"
677,"def parse_md(self):
    """"""Takes a post path and returns a dictionary of variables""""""
    post_content = _MARKDOWN.convert(self.raw_src)

    if hasattr(_MARKDOWN, 'Meta'):
      # 'Meta' in _MARKDOWN and _MARKDOWN.Meta:
      for key in _MARKDOWN.Meta:
        print ""\t meta: %s: %s (%s)"" % (key, _MARKDOWN.Meta[key][0], type(_MARKDOWN.Meta[key][0]))
        if key == 'pubdate':
          setattr(self, key, datetime.datetime.fromtimestamp(float(_MARKDOWN.Meta[key][0])))
        else:
          setattr(self, key, _MARKDOWN.Meta[key][0])
      
    self.content = post_content
    self.stub = self.__key__
  
    # set required fields
    # @TODO required in schema rather than here
    
    if not hasattr(self, 'pubdate'):
      print '\t Notice: setting default pubdate'
      setattr(self, 'pubdate', datetime.datetime.now())"
678,"def filter(self, **kwargs):
    # @TODO refactor with models as dicts
    """"""filter results of dataset eg.
    
    Query('Posts').filter(post_type='post')
    """"""
    f_field = kwargs.keys()[0]
    f_value = kwargs[f_field]
    _newset = []
    
    for m in self._dataset:
      if hasattr(m, f_field):
        if getattr(m, f_field) == f_value:
          _newset.append(m)
    self._dataset = _newset
    return self"
679,"def sort_by(self, sb):
    """"""Sort results""""""
    
    self._dataset = self._dataset.sort(key=lambda x: x.pubdate, reverse=True)
    return self"
680,"def execute_train_task_with_dependencies(self, task_cls, **kwargs):
        """"""
        Run the training, as well as any dependencies of the training
        task_cls - class of a task
        """"""
        log.info(""Task {0}"".format(get_task_name(task_cls)))
        #Instantiate the task
        task_inst = task_cls()
        #Grab arguments from the task instance and set them
        for arg in task_inst.args:
            if arg not in kwargs:
                kwargs[arg] = task_inst.args[arg]
        #Check for dependencies defined by the task
        if hasattr(task_inst, ""dependencies""):
            deps = task_inst.dependencies
            dep_results = []
            #Run the dependencies through recursion (in case of dependencies of dependencies, etc)
            for dep in deps:
                log.info(""Dependency {0}"".format(get_task_name(dep)))
                dep_results.append(self.execute_train_task_with_dependencies(dep.cls, **dep.args))
            trained_dependencies = []
            #Add executed dependency to trained_dependencies list on the task
            for i in xrange(0,len(deps)):
                dep = deps[i]
                dep_result = dep_results[i]
                name = dep.name
                namespace = dep.namespace
                category = dep.category
                trained_dependencies.append(TrainedDependency(category=category, namespace=namespace, name = name, inst = dep))
            task_inst.trained_dependencies = trained_dependencies
        #Finally, run the task
        task_inst.train(**kwargs)
        return task_inst"
681,"def execute_predict_task(self, task_inst, predict_data, **kwargs):
        """"""
        Do a prediction
        task_inst - instance of a task
        """"""
        result = task_inst.predict(predict_data, **task_inst.args)
        return result"
682,"def train(self, **kwargs):
        """"""
        Do the workflow training
        """"""
        log.info(""Starting to train..."")
        if not self.setup_run:
            self.setup()
        self.trained_tasks = []
        for task in self.tasks:
            data = self.reformatted_input[task.data_format]['data']
            target = self.reformatted_input[task.data_format]['target']
            if data is None:
                raise Exception(""Data cannot be none.  Check the config file to make sure the right input is being read."")
            kwargs['data']=data
            kwargs['target']=target
            trained_task = self.execute_train_task_with_dependencies(task, **kwargs)
            self.trained_tasks.append(trained_task)
            #If the trained task alters the data in any way, pass it down the chain to the next task
            if hasattr(trained_task, 'data'):
                self.reformatted_input[task.data_format]['data'] = trained_task.data
        log.info(""Finished training."")"
683,"def predict(self, **kwargs):
        """"""
        Do the workflow prediction (done after training, with new data)
        """"""
        reformatted_predict = self.reformat_predict_data()
        results = {}
        for task_inst in self.trained_tasks:
            predict = reformatted_predict[task_inst.data_format]['predict']
            kwargs['predict']=predict
            results.update({get_task_name(task_inst) : self.execute_predict_task(task_inst, predict, **kwargs)})
        return results"
684,"def read_input(self, input_cls, filename, **kwargs):
        """"""
        Read in input and do some minimal preformatting
        input_cls - the class to use to read the input
        filename - input filename
        """"""
        input_inst = input_cls()
        input_inst.read_input(filename)
        return input_inst.get_data()"
685,"def reformat_file(self, input_file, input_format, output_format):
        """"""
        Reformat input data files to a format the tasks can use
        """"""
        #Return none if input_file or input_format do not exist
        if input_file is None or input_format is None:
            return None
        #Find the needed input class and read the input stream
        try:
            input_cls = self.find_input(input_format)
            input_inst = input_cls()
        except TypeError:
            #Return none if input_cls is a Nonetype
            return None
        #If the input file cannot be found, return None
        try:
            input_inst.read_input(self.absolute_filepath(input_file))
        except IOError:
            return None

        formatter = find_needed_formatter(input_format, output_format)
        if formatter is None:
            raise Exception(""Cannot find a formatter that can convert from {0} to {1}"".format(self.input_format, output_format))
        formatter_inst = formatter()
        formatter_inst.read_input(input_inst.get_data(), input_format)
        data = formatter_inst.get_data(output_format)
        return data"
686,"def reformat_input(self, **kwargs):
        """"""
        Reformat input data
        """"""
        reformatted_input = {}
        needed_formats = []
        for task_cls in self.tasks:
            needed_formats.append(task_cls.data_format)
        self.needed_formats = list(set(needed_formats))

        for output_format in self.needed_formats:
            reformatted_input.update(
                {
                    output_format :
                        {
                        'data' : self.reformat_file(self.input_file, self.input_format, output_format),
                        'target' : self.reformat_file(self.target_file, self.target_format, output_format)
                        }
                }
            )
        return reformatted_input"
687,"def _create_modulename(cdef_sources, source, sys_version):
    """"""
    This is the same as CFFI's create modulename except we don't include the
    CFFI version.
    """"""
    key = '\x00'.join([sys_version[:3], source, cdef_sources])
    key = key.encode('utf-8')
    k1 = hex(binascii.crc32(key[0::2]) & 0xffffffff)
    k1 = k1.lstrip('0x').rstrip('L')
    k2 = hex(binascii.crc32(key[1::2]) & 0xffffffff)
    k2 = k2.lstrip('0').rstrip('L')
    return '_xprintidle_cffi_{0}{1}'.format(k1, k2)"
688,"def server_identity_is_verified(self):
        """""" GPGAuth stage0 """"""
        # Encrypt a uuid token for the server
        server_verify_token = self.gpg.encrypt(self._nonce0,
                                               self.server_fingerprint, always_trust=True)
        if not server_verify_token.ok:
            raise GPGAuthStage0Exception(
                'Encryption of the nonce0 (%s) '
                'to the server fingerprint (%s) failed.' %
                (self._nonce0, self.server_fingerprint)
            )

        server_verify_response = post_server_verify_token(
            self,
            keyid=self.user_fingerprint,
            server_verify_token=str(server_verify_token)
        )

        if not check_server_verify_response(server_verify_response):
            raise GPGAuthStage0Exception(""Verify endpoint wrongly formatted"")

        if server_verify_response.headers.get('X-GPGAuth-Verify-Response') != self._nonce0:
            raise GPGAuthStage0Exception(
                'The server decrypted something different than what we sent '
                '(%s <> %s)' %
                (server_verify_response.headers.get('X-GPGAuth-Verify-Response'), self._nonce0))
        logger.info('server_identity_is_verified: OK')
        return True"
689,"def user_auth_token(self):
        """""" GPGAuth Stage1 """"""

        # stage0 is a prequisite
        if not self.server_identity_is_verified:
            return False

        server_login_response = post_log_in(
            self,
            keyid=self.user_fingerprint
        )

        if not check_server_login_stage1_response(server_login_response):
            raise GPGAuthStage1Exception(""Login endpoint wrongly formatted"")

        # Get the encrypted User Auth Token
        encrypted_user_auth_token = unquote_plus(
            server_login_response.headers.get('X-GPGAuth-User-Auth-Token')
            .replace('\\\\', '\\')
        ).replace('\\ ', ' ')

        logger.debug('User token to decrypt: %s', encrypted_user_auth_token)
        logger.info('Decrypting the user authentication token; '
                    'password prompt expected')

        passphrase = None
        # For the sake of tests, allow one to set the passphrase onto
        # the object
        if hasattr(self, '_user_passphrase'):
            passphrase = self._user_passphrase

        user_auth_token = self.gpg.decrypt(encrypted_user_auth_token, always_trust=True, passphrase=passphrase)

        if not user_auth_token.ok:
            raise GPGAuthStage1Exception(""Auth token decryption failed: %s"", user_auth_token.status)

        logger.info('user_auth_token: %s', user_auth_token)
        return str(user_auth_token)"
690,"def is_authenticated_with_token(self):
        """""" GPGAuth Stage 2 """"""
        """""" Send back the token to the server to get auth cookie """"""

        server_login_response = post_log_in(
            self,
            keyid=self.user_fingerprint,
            user_token_result=self.user_auth_token
        )

        if not check_server_login_stage2_response(server_login_response):
            raise GPGAuthStage2Exception(""Login endpoint wrongly formatted"")
        self.cookies.save(ignore_discard=True)
        logger.info('is_authenticated_with_token: OK')
        return True"
691,"def publish(self,message,message_type,topic=''):
        """"""
        Publish the message on the PUB socket with the given topic name.
        
        Args:
            - message: the message to publish
            - message_type: the type of message being sent
            - topic: the topic on which to send the message. Defaults to ''.
        """"""
        if message_type == MULTIPART:
            raise Exception(""Unsupported request type"")

        super(Publisher,self).send(message,message_type,topic)"
692,"def load(self, cls, run_id):
        """"""
        Load a workflow
        cls - workflow class (to get __name__ from)
        run_id - id given to the specific run
        """"""
        id_code = self.generate_load_identifier(cls, run_id)
        inst = self.store.load(id_code)
        return inst"
693,"def save(self, obj, run_id):
        """"""
        Save a workflow
        obj - instance of a workflow to save
        run_id - unique id to give the run
        """"""
        id_code = self.generate_save_identifier(obj, run_id)
        self.store.save(obj, id_code)"
694,"def setup_tasks(self, tasks):
        """"""
        Find task classes from category.namespace.name strings
        tasks - list of strings
        """"""
        task_classes = []
        for task in tasks:
            category, namespace, name = task.split(""."")
            try:
                cls = find_in_registry(category=category, namespace=namespace, name=name)[0]
            except TypeError:
                log.error(""Could not find the task with category.namespace.name {0}"".format(task))
                raise TypeError
            task_classes.append(cls)
        self.tasks = task_classes"
695,"def initialize_workflow(self, workflow):
        """"""
        Create a workflow
        workflow - a workflow class
        """"""
        self.workflow = workflow()
        self.workflow.tasks = self.tasks

        self.workflow.input_file = self.input_file
        self.workflow.input_format = self.input_format
        self.workflow.target_file = self.target_file
        self.workflow.target_format = self.target_format
        self.workflow.run_id = self.run_id

        self.workflow.setup()"
696,"def reformat_filepath(self, config_file, filename):
        """"""
        Convert relative paths in config file to absolute
        """"""
        if not filename.startswith(""/""):
            filename = self.config_file_format.format(config_file, filename)
        return filename"
697,"def item_lister(command, _connection, page_size, page_number, sort_by,
    sort_order, item_class, result_set, **kwargs):
    """"""
    A generator function for listing Video and Playlist objects.
    """"""
    # pylint: disable=R0913
    page = page_number
    while True:
        item_collection = _connection.get_list(command,
                                             page_size=page_size,
                                             page_number=page,
                                             sort_by=sort_by,
                                             sort_order=sort_order,
                                             item_class=item_class,
                                             **kwargs)
        result_set.total_count = item_collection.total_count
        result_set.page_number = page
        for item in item_collection.items:
            yield item
        if item_collection.total_count < 0 or item_collection.page_size == 0:
            break
        if len(item_collection.items) > 0:
            page += 1
        else:
            break"
698,"def get_manifest(self, asset_xml):
        """"""
        Construct and return the xml manifest to deliver along with video file.
        """"""
        # pylint: disable=E1101
        manifest = '<?xml version=""1.0"" encoding=""utf-8""?>'
        manifest += '<publisher-upload-manifest publisher-id=""%s"" ' % \
            self.publisher_id
        manifest += 'preparer=""%s"" ' % self.preparer
        if self.report_success:
            manifest += 'report-success=""TRUE"">\n'
        for notify in self.notifications:
            manifest += '<notify email=""%s""/>' % notify
        if self.callback:
            manifest += '<callback entity-url=""%s""/>' % self.callback
        manifest += asset_xml
        manifest += '</publisher-upload-manifest>'
        return manifest"
699,"def _send_file(self, filename):
        """"""
        Sends a file via FTP.
        """"""
        # pylint: disable=E1101
        ftp = ftplib.FTP(host=self.host)
        ftp.login(user=self.user, passwd=self.password)
        ftp.set_pasv(True)
        ftp.storbinary(""STOR %s"" % os.path.basename(filename),
            file(filename, 'rb'))"
700,"def _post(self, data, file_to_upload=None):
        """"""
        Make the POST request.
        """"""
        # pylint: disable=E1101
        params = {""JSONRPC"": simplejson.dumps(data)}
        req = None
        if file_to_upload:
            req = http_core.HttpRequest(self.write_url)
            req.method = 'POST'
            req.add_body_part(""JSONRPC"", simplejson.dumps(data), 'text/plain')
            upload = file(file_to_upload, ""rb"")
            req.add_body_part(""filePath"", upload, 'application/octet-stream')
            req.end_of_parts()
            content_type = ""multipart/form-data; boundary=%s"" % \
                http_core.MIME_BOUNDARY
            req.headers['Content-Type'] = content_type
            req.headers['User-Agent'] = config.USER_AGENT

            req = http_core.ProxiedHttpClient().request(req)
        else:
            msg = urllib.urlencode({'json': params['JSONRPC']})
            req = urllib2.urlopen(self.write_url, msg)

        if req:
            result = simplejson.loads(req.read())
            if 'error' in result and result['error']:
                exceptions.BrightcoveError.raise_exception(
                    result['error'])
            return result['result']"
701,"def _get_response(self, **kwargs):
        """"""
        Make the GET request.
        """"""
        # pylint: disable=E1101
        url = self.read_url + ""?output=JSON&token=%s"" % self.read_token
        for key in kwargs:
            if key and kwargs[key]:
                val = kwargs[key]
                if isinstance(val, (list, tuple)):
                    val = "","".join(val)
                url += ""&%s=%s"" % (key, val)
        self._api_url = url
        req = urllib2.urlopen(url)
        data = simplejson.loads(req.read())
        self._api_raw_data = data
        if data and data.get('error', None):
            exceptions.BrightcoveError.raise_exception(
                data['error'])
        if data == None:
            raise exceptions.NoDataFoundError(
                ""No data found for %s"" % repr(kwargs))
        return data"
702,"def get_list(self, command, item_class, page_size, page_number, sort_by,
        sort_order, **kwargs):
        """"""
        Not intended to be called directly, but rather through an by the
        ItemResultSet object iterator.
        """"""
        # pylint: disable=R0913,W0221
        data = self._get_response(command=command,
                                  page_size=page_size,
                                  page_number=page_number,
                                  sort_by=sort_by,
                                  sort_order=sort_order,
                                  video_fields=None,
                                  get_item_count=""true"",
                                  **kwargs)
        return ItemCollection(data=data,
                              item_class=item_class,
                              _connection=self)"
703,"def initialize_renderer(extensions=None):
    """"""
    Initializes the renderer by setting up the extensions (taking a comma separated
    string or iterable of extensions). These extensions are added alongside with the
    configured always-on extensions.

    Returns a markdown renderer instance.
    """"""
    if extensions is None:
        extensions = []

    if isinstance(extensions, str):
        extensions = [extension.strip() for extension in extensions.split(',')]

    for extension in getattr(settings, 'MARKYMARK_EXTENSIONS', DEFAULT_MARKYMARK_EXTENSIONS):
        extensions.append(extension)

    return markdown.Markdown(extensions=extensions)"
704,"def setup_formats(self):
        """"""
        Inspects its methods to see what it can convert from and to
        """"""
        methods = self.get_methods()
        for m in methods:
            #Methods named ""from_X"" will be assumed to convert from format X to the common format
            if m.startswith(""from_""):
                self.input_formats.append(re.sub(""from_"" , """",m))
            #Methods named ""to_X"" will be assumed to convert from the common format to X
            elif m.startswith(""to_""):
                self.output_formats.append(re.sub(""to_"","""",m))"
705,"def read_input(self, input_data, data_format):
        """"""
        Reads the input data and converts to common format
        input_data - the output from one of the input classes (ie CSVInput)
        data_format - the format of the data.  See utils.input.dataformats
        """"""
        if data_format not in self.input_formats:
            raise Exception(""Input format {0} not available with this class. Available formats are {1}."".format(data_format, self.input_formats))
        data_converter = getattr(self, ""from_"" + data_format)
        self.data = data_converter(input_data)"
706,"def get_data(self, data_format):
        """"""
        Reads the common format and converts to output data
        data_format - the format of the output data.  See utils.input.dataformats
        """"""
        if data_format not in self.output_formats:
            raise Exception(""Output format {0} not available with this class. Available formats are {1}."".format(data_format, self.output_formats))
        data_converter = getattr(self, ""to_"" + data_format)
        return data_converter()"
707,"def from_csv(self, input_data):
        """"""
        Reads csv format input data and converts to json.
        """"""
        reformatted_data = []
        for (i,row) in enumerate(input_data):
            if i==0:
                headers = row
            else:
                data_row = {}
                for (j,h) in enumerate(headers):
                    data_row.update({h : row[j]})
                reformatted_data.append(data_row)
        return reformatted_data"
708,"def to_dataframe(self):
        """"""
        Reads the common format self.data and writes out to a dataframe.
        """"""
        keys = self.data[0].keys()
        column_list =[]
        for k in keys:
            key_list = []
            for i in xrange(0,len(self.data)):
                key_list.append(self.data[i][k])
            column_list.append(key_list)
        df = DataFrame(np.asarray(column_list).transpose(), columns=keys)
        for i in xrange(0,df.shape[1]):
            if is_number(df.iloc[:,i]):
                df.iloc[:,i] = df.iloc[:,i].astype(float)
        return df"
709,"def check_extensions(extensions: Set[str], allow_multifile: bool = False):
    """"""
    Utility method to check that all extensions in the provided set are valid

    :param extensions:
    :param allow_multifile:
    :return:
    """"""
    check_var(extensions, var_types=set, var_name='extensions')

    # -- check them one by one
    for ext in extensions:
        check_extension(ext, allow_multifile=allow_multifile)"
710,"def check_extension(extension: str, allow_multifile: bool = False):
    """"""
    Utility method to check that the provided extension is valid. Extension should either be MULTIFILE_EXT
    (='multifile') or start with EXT_SEPARATOR (='.') and contain only one occurence of EXT_SEPARATOR

    :param extension:
    :param allow_multifile:
    :return:
    """"""
    check_var(extension, var_types=str, var_name='extension')

    # Extension should either be 'multifile' or start with EXT_SEPARATOR and contain only one EXT_SEPARATOR
    if (extension.startswith(EXT_SEPARATOR) and extension.count(EXT_SEPARATOR) == 1) \
            or (allow_multifile and extension is MULTIFILE_EXT):
        # ok
        pass
    else:
        raise ValueError('\'extension\' should start with \'' + EXT_SEPARATOR + '\' and contain not other '
                         'occurrence of \'' + EXT_SEPARATOR + '\'' + (', or be equal to \'' + MULTIFILE_EXT + '\' (for '
                         'multifile object parsing)' if allow_multifile else ''))"
711,"def get_parsing_plan_log_str(obj_on_fs_to_parse, desired_type, log_only_last: bool, parser):
    """"""
    Utility method used by several classes to log a message indicating that a given file object is planned to be parsed
    to the given object type with the given parser. It is in particular used in str(ParsingPlan), but not only.

    :param obj_on_fs_to_parse:
    :param desired_type:
    :param log_only_last: a flag to only log the last part of the file path (default False). Note that this can be
    overriden by a global configuration 'full_paths_in_logs'
    :param parser:
    :return:
    """"""
    loc = obj_on_fs_to_parse.get_pretty_location(blank_parent_part=(log_only_last
                                                                    and not GLOBAL_CONFIG.full_paths_in_logs),
                                                 compact_file_ext=True)
    return '{loc} -> {type} ------- using {parser}'.format(loc=loc, type=get_pretty_type_str(desired_type),
                                                           parser=str(parser))"
712,"def is_able_to_parse_detailed(self, desired_type: Type[Any], desired_ext: str, strict: bool) -> Tuple[bool, bool]:
        """"""
        Utility method to check if a parser is able to parse a given type, either in
        * strict mode (desired_type must be one of the supported ones, or the parser should be generic)
        * inference mode (non-strict) : desired_type may be a parent class of one the parser is able to produce

        :param desired_type: the type of the object that should be parsed,
        :param desired_ext: the file extension that should be parsed
        :param strict: a boolean indicating whether to evaluate in strict mode or not
        :return: a first boolean indicating if there was a match, and a second boolean indicating if that match was
        strict (None if no match)
        """"""

        # (1) first handle the easy joker+joker case
        if desired_ext is JOKER and desired_type is JOKER:
            return True, None

        # (2) if ext is not a joker we can quickly check if it is supported
        if desired_ext is not JOKER:
            check_var(desired_ext, var_types=str, var_name='desired_ext')
            if desired_ext not in self.supported_exts:
                # ** no match on extension - no need to go further
                return False, None

            # (3) if type=joker and ext is supported => easy
            if desired_type is JOKER:
                # ** only extension match is required - ok.
                return True, None

        # (4) at this point, ext is JOKER OR supported and type is not JOKER. Check type match
        check_var(desired_type, var_types=type, var_name='desired_type_of_output')
        check_var(strict, var_types=bool, var_name='strict')

        # -- first call custom checker if provided
        if self.is_able_to_parse_func is not None and not self.is_able_to_parse_func(strict, desired_type):
            return False, None

        # -- strict match : either the parser is able to parse Anything, or the type is in the list of supported types
        if self.is_generic() or (desired_type in self.supported_types):
            return True, True  # exact match

        # -- non-strict match : if the parser is able to parse a subclass of the desired type, it is ok
        elif (not strict) \
                and any(issubclass(supported, desired_type) for supported in self.supported_types):
            return True, False  # approx match

        # -- no match at all
        else:
            return False, None"
713,"def are_worth_chaining(parser, to_type: Type[S], converter: Converter[S, T]) -> bool:
        """"""
        Utility method to check if it makes sense to chain this parser with the given destination type, and the given
        converter to create a parsing chain. Returns True if it brings value to chain them.

        To bring value,
        * the converter's output should not be a parent class of the parser's output. Otherwise
        the chain does not even make any progress :)
        * The parser has to allow chaining (with converter.can_chain=True)

        :param parser:
        :param to_type:
        :param converter:
        :return:
        """"""
        if not parser.can_chain:
            # The base parser prevents chaining
            return False

        elif not is_any_type(to_type) and is_any_type(converter.to_type):
            # we gain the capability to generate any type. So it is interesting.
            return True

        elif issubclass(to_type, converter.to_type):
            # Not interesting : the outcome of the chain would be not better than one of the parser alone
            return False

        # Note: we dont say that chaining a generic parser with a converter is useless. Indeed it might unlock some
        # capabilities for the user (new file extensions, etc.) that would not be available with the generic parser
        # targetting to_type alone. For example parsing object A from its constructor then converting A to B might
        # sometimes be interesting, rather than parsing B from its constructor

        else:
            # Interesting
            return True"
714,"def create_for_caught_error(parser: _BaseParserDeclarationForRegistries, desired_type: Type[T],
                                obj: PersistedObject, caught: Exception, options: Dict[str, Dict[str, Any]]):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param parser:
        :param desired_type:
        :param obj:
        :param caught:
        :param options:
        :return:
        """"""
        try:
            typ = get_pretty_type_str(desired_type)
        except:
            typ = str(desired_type)

        e = ParsingException('Error while parsing ' + str(obj) + ' as a ' + typ + ' with parser \''
                                + str(parser) + '\' using options=(' + str(options) + ') : caught \n  '
                                + str(caught.__class__.__name__) + ' : ' + str(caught))\
            .with_traceback(caught.__traceback__) # 'from e' was hiding the inner traceback. This is much better for debug
        e.__cause__ = None
        # e.__cause__ = caught
        # store the exception still, to be able to handle it later
        e.caught = caught
        return e"
715,"def create_for_wrong_result_type(parser: _BaseParserDeclarationForRegistries, desired_type: Type[T],
                                     obj: PersistedObject, result: T, options: Dict[str, Dict[str, Any]]):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param parser:
        :param desired_type:
        :param obj:
        :param result:
        :param options:
        :return:
        """"""
        msg = ""Error while parsing {obj} as a {typ} with parser {p} using options=({opts}) - parser returned an object "" \
              ""of wrong type {tret}: {ret}"".format(obj=obj, typ=get_pretty_type_str(desired_type), p=parser,
                                                   opts=options, tret=type(result), ret=result)
        return WrongTypeCreatedError(msg)"
716,"def execute(self, logger: Logger, options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        Called to parse the object as described in this parsing plan, using the provided arguments for the parser.
        * Exceptions are caught and wrapped into ParsingException
        * If result does not match expected type, an error is thrown

        :param logger: the logger to use during parsing (optional: None is supported)
        :param options: a dictionary of option sets. Each option set is identified with an id in the dictionary.
        :return:
        """"""
        try:
            res = self._execute(logger, options)
        except Exception as e:
            raise ParsingException.create_for_caught_error(self.parser, self.obj_type, self.obj_on_fs_to_parse, e,
                                                           options)

        # Check that the returned parsed object has the correct type
        if res is not None:
            if robust_isinstance(res, self.obj_type):
                return res

        # wrong type : error
        raise WrongTypeCreatedError.create_for_wrong_result_type(self.parser, self.obj_type, self.obj_on_fs_to_parse,
                                                                 res, options)"
717,"def _execute(self, logger: Logger, options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        Implementing classes should perform the parsing here, possibly using custom methods of self.parser.

        :param logger:
        :param options:
        :return:
        """"""
        pass"
718,"def _get_applicable_options(self, options: Dict[str, Dict[str, Any]]):
        """"""
        Returns the options that are applicable to this particular parser, from the full map of options.
        It first uses 'get_id_for_options()' to know the id of this parser, and then simply extracts the contents of
        the options corresponding to this id, or returns an empty dict().

        :param options: a dictionary parser_id > options
        :return:
        """"""
        return get_options_for_id(options, self.get_id_for_options())"
719,"def create_parsing_plan(self, desired_type: Type[T], filesystem_object: PersistedObject, logger: Logger,
                            options: Dict[str, Dict[str, Any]]) -> ParsingPlan[T]:
        """"""
        Creates a parsing plan to parse the given filesystem object into the given desired_type.
        Implementing classes may wish to support additional parameters.

        :param desired_type: the type of object that should be created as the output of parsing plan execution.
        :param filesystem_object: the persisted object that should be parsed
        :param logger: an optional logger to log all parsing plan creation and execution information
        :param options: a dictionary additional implementation-specific parameters (one dict per parser id).
        Implementing classes may use 'self._get_applicable_options()' to get the options that are of interest for this
        parser.
        :return:
        """"""
        pass"
720,"def add(self, f_ipaddr, f_macaddr, f_hostname, f_netbios_name, f_engineer, f_asset_group, f_confirmed):
        """"""
        Add a t_hosts record

        :param f_ipaddr: IP address
        :param f_macaddr: MAC Address
        :param f_hostname: Hostname
        :param f_netbios_name: NetBIOS Name
        :param f_engineer: Engineer username
        :param f_asset_group: Asset group
        :param f_confirmed: Confirmed boolean
        :return: (True/False, t_hosts.id or response message)
        """"""
        return self.send.host_add(f_ipaddr, f_macaddr, f_hostname, f_netbios_name, f_engineer,
                                  f_asset_group, f_confirmed)"
721,"def parse_now_field(s):
    """"""Return a datetime instance from a string generated by now_field.
    IMPORTANT: the datetime will be in UTC""""""
    if not s.startswith('UTC:'):
        return None  # Invalid string
    s = s[4:]

    # isoformat can return strings both with and without microseconds - we
    # account for both
    try:
        dt = datetime.datetime.strptime(s, '%Y-%m-%dT%H:%M:%S.%f')
    except ValueError:
        dt = datetime.datetime.strptime(s, '%Y-%m-%dT%H:%M:%S')

    return dt"
722,"def get_ftp(ftp_conf, debug=0):
    """"""得到一个 已经打开的FTP 实例，和一个 ftp 路径。

    :param dict ftp_conf: ftp配置文件，格式如下：
    
        >>> {
        >>>     'server':'127.0.0.1',
        >>>     'start_path':None,
        >>>     'user':'admin',
        >>>     'password':'123456',
        >>> }

    :returns: ftp, ftpserverstr
    :rtype: :class:`ftplib.FTP` , str

    """"""
    server = ftp_conf.get('server')
    user = ftp_conf.get('user')
    password = ftp_conf.get('password')
    start_path = ftp_conf.get('start_path')
    slog.info(""Connecting FTP server %s ......"", server)
    ftpStr = 'ftp://%s/'%server
    if start_path:
        ftpStr = ftpStr+start_path
    ftp = ftplib.FTP(server, user, password)
    ftp.set_debuglevel(debug)
    if start_path:
        ftp.cwd(start_path)
    serverFiles = ftp.nlst()
    slog.info('There are some files in %s:\n[%s]'%(ftpStr, ', '.join(serverFiles)))
    return ftp, ftpStr"
723,"def upload_file(file_path, remote_path, ftp_conf, remove_file=False):
    """"""上传第一个指定的文件到 FTP 服务器。

    :param str file_path: 待上传文件的绝对路径。
    :param str remote_path: 文件在 FTP 服务器上的相对路径（相对于 FTP 服务器的初始路径）。
    :param dict ftp_conf: ftp配置文件，详见 :func:`get_ftp` 。
    :param bool remove_file: 上传成功后是否删除本地文件。
    :returns: FTP 服务器上的文件列表
    :rtype: list

    """"""
    check_ftp_conf(ftp_conf)

    ftp, ftpStr = get_ftp(ftp_conf)
    lf = open(file_path, 'rb')
    slog.info('Uploading ""%s"" to ""%s/%s"" ......'%(file_path, ftpStr, remote_path))
    ftp.storbinary(""STOR %s""%remote_path, lf)
    filelist = ftp.nlst()
    ftp.quit()
    lf.close()
    if remove_file:
        os.remove(file_path)
    slog.info('Upload done.')
    return filelist"
724,"def retrieve_data(self):
        """"""
        Retrives data as a DataFrame.
        """"""

        #==== Retrieve data ====#

        df = self.manager.get_historic_data(self.start.date(), self.end.date())
        df.replace(0, np.nan, inplace=True)
        return df"
725,"def get_min_risk(self, weights, cov_matrix):
        """"""
        Minimizes the variance of a portfolio.
        """"""

        def func(weights):
            """"""The objective function that minimizes variance.""""""
            return np.matmul(np.matmul(weights.transpose(), cov_matrix), weights)

        def func_deriv(weights):
            """"""The derivative of the objective function.""""""
            return (
                np.matmul(weights.transpose(), cov_matrix.transpose()) +
                np.matmul(weights.transpose(), cov_matrix)
            )

        constraints = ({'type': 'eq', 'fun': lambda weights: (weights.sum() - 1)})
        solution = self.solve_minimize(func, weights, constraints, func_deriv=func_deriv)
        # NOTE: `min_risk` is unused, but may be helpful later.
        # min_risk = solution.fun
        allocation = solution.x

        return allocation"
726,"def get_max_return(self, weights, returns):
        """"""
        Maximizes the returns of a portfolio.
        """"""

        def func(weights):
            """"""The objective function that maximizes returns.""""""
            return np.dot(weights, returns.values) * -1

        constraints = ({'type': 'eq', 'fun': lambda weights: (weights.sum() - 1)})
        solution = self.solve_minimize(func, weights, constraints)
        max_return = solution.fun * -1

        # NOTE: `max_risk` is not used anywhere, but may be helpful in the future.
        # allocation = solution.x
        # max_risk = np.matmul(
        #     np.matmul(allocation.transpose(), cov_matrix), allocation
        # )

        return max_return"
727,"def efficient_frontier(
        self,
        returns,
        cov_matrix,
        min_return,
        max_return,
        count
    ):
        """"""
        Returns a DataFrame of efficient portfolio allocations for `count` risk
        indices.
        """"""

        columns = [coin for coin in self.SUPPORTED_COINS]
        # columns.append('Return')
        # columns.append('Risk')
        values = pd.DataFrame(columns=columns)
        weights = [1/len(self.SUPPORTED_COINS)] * len(self.SUPPORTED_COINS)

        def func(weights):
            """"""The objective function that minimizes variance.""""""
            return np.matmul(np.matmul(weights.transpose(), cov_matrix), weights)

        def func_deriv(weights):
            """"""The derivative of the objective function.""""""
            return (
                np.matmul(weights.transpose(), cov_matrix.transpose()) +
                np.matmul(weights.transpose(), cov_matrix)
            )

        for point in np.linspace(min_return, max_return, count):
            constraints = (
                {'type': 'eq', 'fun': lambda weights: (weights.sum() - 1)},
                {'type': 'ineq', 'fun': lambda weights, i=point: (
                    np.dot(weights, returns.values) - i
                )}
            )

            solution = self.solve_minimize(func, weights, constraints, func_deriv=func_deriv)

            columns = {}
            for index, coin in enumerate(self.SUPPORTED_COINS):
                columns[coin] = math.floor(solution.x[index] * 100 * 100) / 100

            # NOTE: These lines could be helpful, but are commented out right now.
            # columns['Return'] = round(np.dot(solution.x, returns), 6)
            # columns['Risk'] = round(solution.fun, 6)

            values = values.append(columns, ignore_index=True)

        return values"
728,"def solve_minimize(
        self,
        func,
        weights,
        constraints,
        lower_bound=0.0,
        upper_bound=1.0,
        func_deriv=False
    ):
        """"""
        Returns the solution to a minimization problem.
        """"""

        bounds = ((lower_bound, upper_bound), ) * len(self.SUPPORTED_COINS)
        return minimize(
            fun=func, x0=weights, jac=func_deriv, bounds=bounds,
            constraints=constraints, method='SLSQP', options={'disp': False}
        )"
729,"def allocate(self):
        """"""
        Returns an efficient portfolio allocation for the given risk index.
        """"""
        df = self.manager.get_historic_data()[self.SUPPORTED_COINS]

        #==== Calculate the daily changes ====#
        change_columns = []
        for column in df:
            if column in self.SUPPORTED_COINS:
                change_column = '{}_change'.format(column)
                values = pd.Series(
                    (df[column].shift(-1) - df[column]) /
                    -df[column].shift(-1)
                ).values
                df[change_column] = values
                change_columns.append(change_column)

        # print(df.head())
        # print(df.tail())

        #==== Variances and returns ====#
        columns = change_columns
        # NOTE: `risks` is not used, but may be used in the future
        risks = df[columns].apply(np.nanvar, axis=0)
        # print('\nVariance:\n{}\n'.format(risks))
        returns = df[columns].apply(np.nanmean, axis=0)
        # print('\nExpected returns:\n{}\n'.format(returns))

        #==== Calculate risk and expected return ====#
        cov_matrix = df[columns].cov()
        # NOTE: The diagonal variances weren't calculated correctly, so here is a fix.
        cov_matrix.values[[np.arange(len(self.SUPPORTED_COINS))] * 2] = df[columns].apply(np.nanvar, axis=0)
        weights = np.array([1/len(self.SUPPORTED_COINS)] * len(self.SUPPORTED_COINS)).reshape(len(self.SUPPORTED_COINS), 1)

        #==== Calculate portfolio with the minimum risk ====#
        min_risk = self.get_min_risk(weights, cov_matrix)
        min_return = np.dot(min_risk, returns.values)

        #==== Calculate portfolio with the maximum return ====#
        max_return = self.get_max_return(weights, returns)

        #==== Calculate efficient frontier ====#
        frontier = self.efficient_frontier(
            returns, cov_matrix, min_return, max_return, 6
        )
        return frontier"
730,"def handle_default_options(options):
    """"""
    Pass in a Values instance from OptionParser.  Handle settings and pythonpath
    options - Values from OptionParser
    """"""
    if options.settings:
        #Set the percept_settings_module (picked up by settings in conf.base)
        os.environ['PERCEPT_SETTINGS_MODULE'] = options.settings
    if options.pythonpath:
        #Append the pythonpath and the directory one up from the pythonpath to sys.path for importing

        options.pythonpath = os.path.abspath(os.path.expanduser(options.pythonpath))
        up_one_path = os.path.abspath(os.path.join(options.pythonpath, ""..""))
        sys.path.append(options.pythonpath)
        sys.path.append(up_one_path)
    return options"
731,"def create_parser(self, prog_name, subcommand):
        """"""
        Create an OptionParser
        prog_name - Name of a command
        subcommand - Name of a subcommand
        """"""
        parser = OptionParser(prog=prog_name,
                              usage=self.usage(subcommand),
                              option_list=self.option_list)
        return parser"
732,"def hook(name=None, *args, **kwargs):
    """"""Decorator to register the function as a hook
    """"""
    def decorator(f):
        if not hasattr(f, ""hooks""):
            f.hooks = []
        f.hooks.append((name or f.__name__, args, kwargs))
        return f
    return decorator"
733,"def register_hooks(func, hooks, obj):
    """"""Register func on obj via hooks.
    Hooks should be a tuple of (name, args, kwargs) where
    name is a method name of obj. If args or kwargs are not empty,
    the method will be called first and expect a new function as return.
    """"""
    for name, args, kwargs in hooks:
        hook = getattr(obj, name)
        force_call = kwargs.pop(""_force_call"", False)
        if force_call or len(args) > 0 or len(kwargs) > 0:
            hook = hook(*args, **kwargs)
        hook(func)"
734,"def action(*args, **kwargs):
    """"""Transforms functions or class methods into actions.
    Optionnaly, you can define a function to be used as the view initializer:

        @action()
        def my_action():
            pass

        @my_action.init_view
        def my_action_init_view(view, options):
            pass
    """"""
    def decorator(f):
        return ActionFunction(f, *args, **kwargs)
    return decorator"
735,"def with_actions(actions_or_group_name, actions=None):
    """"""Executes the list of actions before/after the function
    Actions should be a list where items are action names as
    strings or a dict. See frasco.actions.loaders.load_action().
    """"""
    group = None
    if isinstance(actions_or_group_name, str):
        group = actions_or_group_name
    else:
        actions = actions_or_group_name
    def decorator(f):
        if isinstance(f, WithActionsDecorator):
            dec = f
        else:
            dec = WithActionsDecorator(f)
        dec.actions.extend(load_actions(actions, group=group))
        return dec
    return decorator"
736,"def expose(rule, **options):
    """"""Decorator to add an url rule to a function
    """"""
    def decorator(f):
        if not hasattr(f, ""urls""):
            f.urls = []
        if isinstance(rule, (list, tuple)):
            f.urls.extend(rule)
        else:
            f.urls.append((rule, options))
        return f
    return decorator"
737,"def plot_channel_sweep(proxy, start_channel):
    '''
    Parameters
    ----------
    proxy : DMFControlBoard
    start_channel : int
        Channel number from which to start a channel sweep (should be a
        multiple of 40, e.g., 0, 40, 80).

    Returns
    -------
    pandas.DataFrame
        See description of return of :func:`sweep_channels`.
    '''
    test_loads = TEST_LOADS.copy()
    test_loads.index += start_channel

    results = sweep_channels(proxy, test_loads)
    normalized_measurements = (results['measured capacitance']
                               / results['expected capacitance'])
    fig, axis = plt.subplots(figsize=(10, 8))
    axis.bar(normalized_measurements.index - 0.3, normalized_measurements,
             width=0.6, edgecolor='none', facecolor='limegreen')
    axis.set_xlim(left=test_loads.index.min() - 0.5,
                  right=test_loads.index.max() + 0.5)
    axis.set_xlabel('channel')
    axis.set_ylabel(r'$\frac{C_{\tt{measured}}}{C_{\tt{expected}}}$',
                    fontsize=28)
    return results"
738,"def _create_unicode_map():
    """"""
    Create the inverse map from unicode to betacode.

    Returns:
    The hash map to convert unicode characters to the beta code representation.
    """"""
    unicode_map = {}

    for beta, uni in _map.BETACODE_MAP.items():
        # Include decomposed equivalent where necessary.
        norm = unicodedata.normalize('NFC', uni)
        unicode_map[norm] = beta
        unicode_map[uni] = beta

    # Add the final sigmas.
    final_sigma_norm = unicodedata.normalize('NFC', _FINAL_LC_SIGMA)
    unicode_map[final_sigma_norm] = 's'
    unicode_map[_FINAL_LC_SIGMA] = 's'

    return unicode_map"
739,"def _create_conversion_trie(strict):
    """"""
    Create the trie for betacode conversion.

    Args:
    text: The beta code text to convert. All of this text must be betacode.
    strict: Flag to allow for flexible diacritic order on input.

    Returns:
    The trie for conversion.
    """"""
    t = pygtrie.CharTrie()

    for beta, uni in _map.BETACODE_MAP.items():
        if strict:
            t[beta] = uni
        else:
            # The order of accents is very strict and weak. Allow for many orders of
            # accents between asterisk and letter or after letter. This does not
            # introduce ambiguity since each betacode token only has one letter and
            # either starts with a asterisk or a letter.
            diacritics = beta[1:]

            perms = itertools.permutations(diacritics)
            for perm in perms:
                perm_str = beta[0] + ''.join(perm)
                t[perm_str.lower()] = uni
                t[perm_str.upper()] = uni

    return t"
740,"def _find_max_beta_token_len():
    """"""
    Finds the maximum length of a single betacode token.

    Returns:
    The length of the longest key in the betacode map, which corresponds to the
    longest single betacode token.
    """"""
    max_beta_len = -1
    for beta, uni in _map.BETACODE_MAP.items():
        if len(beta) > max_beta_len:
            max_beta_len = len(beta)

    return max_beta_len"
741,"def beta_to_uni(text, strict=False):
    """"""
    Converts the given text from betacode to unicode.

    Args:
    text: The beta code text to convert. All of this text must be betacode.
    strict: Flag to allow for flexible diacritic order on input.

    Returns:
    The converted text.
    """"""
    # Check if the requested configuration for conversion already has a trie
    # stored otherwise convert it.
    param_key = (strict,)
    try:
       t = _BETA_CONVERSION_TRIES[param_key]
    except KeyError:
        t = _create_conversion_trie(*param_key)
        _BETA_CONVERSION_TRIES[param_key] = t

    transform = []
    idx = 0
    possible_word_boundary = False

    while idx < len(text):
        if possible_word_boundary and _penultimate_sigma_word_final(transform):
            transform[-2] = _FINAL_LC_SIGMA

        step = t.longest_prefix(text[idx:idx + _MAX_BETA_TOKEN_LEN])

        if step:
            possible_word_boundary = text[idx] in _BETA_PUNCTUATION

            key, value = step
            transform.append(value)
            idx += len(key)
        else:
            possible_word_boundary = True

            transform.append(text[idx])
            idx += 1

    # Check one last time in case there is some whitespace or punctuation at the
    # end and check if the last character is a sigma.
    if possible_word_boundary and _penultimate_sigma_word_final(transform):
        transform[-2] = _FINAL_LC_SIGMA
    elif len(transform) > 0 and transform[-1] == _MEDIAL_LC_SIGMA:
        transform[-1] = _FINAL_LC_SIGMA

    converted = ''.join(transform)
    return converted"
742,"def uni_to_beta(text):
    """"""
    Convert unicode text to a betacode equivalent.

    This method can handle tónos or oxeîa characters in the input.

    Args:
    text: The text to convert to betacode. This text does not have to all be
        Greek polytonic text, and only Greek characters will be converted. Note
        that in this case, you cannot convert to beta and then back to unicode.

    Returns:
    The betacode equivalent of the inputted text where applicable.
    """"""
    u = _UNICODE_MAP

    transform = []

    for ch in text:
        try:
            conv = u[ch]
        except KeyError:
            conv = ch

        transform.append(conv)

    converted = ''.join(transform)
    return converted"
743,"def __calculate_order(self, node_dict):
        """"""
        Determine a valid ordering of the nodes in which a node is not called before all of it's dependencies.

        Raise an error if there is a cycle, or nodes are missing.
        """"""
        if len(node_dict.keys()) != len(set(node_dict.keys())):
            raise DependencyTreeException(""Duplicate Keys Exist in node dictionary!"")
        valid_order = [node for node, dependencies in node_dict.items() if len(dependencies) == 0]
        remaining_nodes = [node for node in node_dict.keys() if node not in valid_order]
        while len(remaining_nodes) > 0:
            node_added = False
            for node in remaining_nodes:
                dependencies = [d for d in node_dict[node] if d not in valid_order]
                if len(dependencies) == 0:
                    valid_order.append(node)
                    remaining_nodes.remove(node)
                    node_added = True
            if not node_added:
                # the tree must be invalid, as it was not possible to remove a node.
                # it's hard to find all the errors, so just spit out the first one you can find.
                invalid_node = remaining_nodes[0]
                invalid_dependency = ', '.join(node_dict[invalid_node])
                if invalid_dependency not in remaining_nodes:
                    raise DependencyTreeException(
                        ""Missing dependency! One or more of ({dependency}) are missing for {dependant}."".format(
                            dependant=invalid_node, dependency=invalid_dependency))
                else:
                    raise DependencyTreeException(""The dependency %s is cyclic or dependent on a cyclic dependency"" % invalid_dependency)
        return valid_order"
744,"def read_input(self, filename, has_header=True):
        """"""
        filename is any filename, or something on which open() can be called
        for example:
        csv_input = CSVInput()
        csv_input.read_input(""csvfile.csv"")
        """"""
        stream = open(filename)
        reader = csv.reader(stream)
        csv_data = []
        for (i, row) in enumerate(reader):
            if i==0:
                if not has_header:
                    csv_data.append([str(i) for i in xrange(0,len(row))])
            csv_data.append(row)
        self.data = csv_data"
745,"def pprint_out(dct: Dict):
    """"""
    Utility methods to pretty-print a dictionary that is typically outputted by parsyfiles (an ordered dict)
    :param dct:
    :return:
    """"""
    for name, val in dct.items():
        print(name + ':')
        pprint(val, indent=4)"
746,"def warn_import_error(type_of_obj_support: str, caught: ImportError):
    """"""
    Utility method to print a warning message about failed import of some modules

    :param type_of_obj_support:
    :param caught:
    :return:
    """"""
    msg = StringIO()
    msg.writelines('Import Error while trying to add support for ' + type_of_obj_support + '. You may continue but '
                   'the associated parsers and converters wont be available : \n')
    traceback.print_tb(caught.__traceback__, file=msg)
    msg.writelines(str(caught.__class__.__name__) + ' : ' + str(caught) + '\n')
    warn(msg.getvalue())"
747,"def create_parser_options(lazy_mfcollection_parsing: bool = False) -> Dict[str, Dict[str, Any]]:
    """"""
    Utility method to create a default options structure with the lazy parsing inside

    :param lazy_mfcollection_parsing:
    :return: the options structure filled with lazyparsing option (for the MultifileCollectionParser)
    """"""
    return {MultifileCollectionParser.__name__: {'lazy_parsing': lazy_mfcollection_parsing}}"
748,"def add_parser_options(options: Dict[str, Dict[str, Any]], parser_id: str, parser_options: Dict[str, Dict[str, Any]],
                       overwrite: bool = False):
    """"""
    Utility method to add options for a given parser, to the provided options structure
    :param options:
    :param parser_id:
    :param parser_options:
    :param overwrite: True to silently overwrite. Otherwise an error will be thrown
    :return:
    """"""
    if parser_id in options.keys() and not overwrite:
        raise ValueError('There are already options in this dictionary for parser id ' + parser_id)
    options[parser_id] = parser_options
    return options"
749,"def register_default_plugins(root_parser: ParserRegistryWithConverters):
    """"""
    Utility method to register all default plugins on the given parser+converter registry

    :param root_parser:
    :return:
    """"""
    # -------------------- CORE ---------------------------
    try:
        # -- primitive types
        from parsyfiles.plugins_base.support_for_primitive_types import get_default_primitive_parsers, \
            get_default_primitive_converters
        root_parser.register_parsers(get_default_primitive_parsers())
        root_parser.register_converters(get_default_primitive_converters())
    except ImportError as e:
        warn_import_error('primitive types', e)
    try:
        # -- collections
        from parsyfiles.plugins_base.support_for_collections import get_default_collection_parsers, \
            get_default_collection_converters
        root_parser.register_parsers(get_default_collection_parsers(root_parser, root_parser))
        root_parser.register_converters(get_default_collection_converters(root_parser))
    except ImportError as e:
        warn_import_error('dict', e)
    try:
        # -- objects
        from parsyfiles.plugins_base.support_for_objects import get_default_object_parsers, \
            get_default_object_converters
        root_parser.register_parsers(get_default_object_parsers(root_parser, root_parser))
        root_parser.register_converters(get_default_object_converters(root_parser))
    except ImportError as e:
        warn_import_error('objects', e)
    try:
        # -- config
        from parsyfiles.plugins_base.support_for_configparser import get_default_config_parsers, \
            get_default_config_converters
        root_parser.register_parsers(get_default_config_parsers())
        root_parser.register_converters(get_default_config_converters(root_parser))
    except ImportError as e:
        warn_import_error('config', e)

    # ------------------------- OPTIONAL -----------------
    try:
        # -- jprops
        from parsyfiles.plugins_optional.support_for_jprops import get_default_jprops_parsers
        root_parser.register_parsers(get_default_jprops_parsers(root_parser, root_parser))
        # root_parser.register_converters()
    except ImportError as e:
        warn_import_error('jprops', e)
    try:
        # -- yaml
        from parsyfiles.plugins_optional.support_for_yaml import get_default_yaml_parsers
        root_parser.register_parsers(get_default_yaml_parsers(root_parser, root_parser))
        # root_parser.register_converters()
    except ImportError as e:
        warn_import_error('yaml', e)
    try:
        # -- numpy
        from parsyfiles.plugins_optional.support_for_numpy import get_default_np_parsers, get_default_np_converters
        root_parser.register_parsers(get_default_np_parsers())
        root_parser.register_converters(get_default_np_converters())
    except ImportError as e:
        warn_import_error('numpy', e)
    try:
        # -- pandas
        from parsyfiles.plugins_optional.support_for_pandas import get_default_pandas_parsers, \
            get_default_pandas_converters
        root_parser.register_parsers(get_default_pandas_parsers())
        root_parser.register_converters(get_default_pandas_converters())
    except ImportError as e:
        warn_import_error('pandas', e)"
750,"def parse_item(location: str, item_type: Type[T], item_name_for_log: str = None,
               file_mapping_conf: FileMappingConfiguration = None,
               logger: Logger = default_logger, lazy_mfcollection_parsing: bool = False) -> T:
    """"""
    Creates a RootParser() and calls its parse_item() method

    :param location:
    :param item_type:
    :param item_name_for_log:
    :param file_mapping_conf:
    :param logger:
    :param lazy_mfcollection_parsing:
    :return:
    """"""
    rp = _create_parser_from_default(logger)
    opts = create_parser_options(lazy_mfcollection_parsing=lazy_mfcollection_parsing)
    return rp.parse_item(location, item_type, item_name_for_log=item_name_for_log, file_mapping_conf=file_mapping_conf,
                         options=opts)"
751,"def parse_collection(location: str, base_item_type: Type[T], item_name_for_log: str = None,
                     file_mapping_conf: FileMappingConfiguration = None, logger: Logger = default_logger,
                     lazy_mfcollection_parsing: bool = False)\
        -> Dict[str, T]:
    """"""
    Utility method to create a RootParser() with default configuration and call its parse_collection() method

    :param location:
    :param base_item_type:
    :param item_name_for_log:
    :param file_mapping_conf:
    :param logger:
    :param lazy_mfcollection_parsing:
    :return:
    """"""
    rp = _create_parser_from_default(logger)
    opts = create_parser_options(lazy_mfcollection_parsing=lazy_mfcollection_parsing)
    return rp.parse_collection(location, base_item_type, item_name_for_log=item_name_for_log,
                               file_mapping_conf=file_mapping_conf, options=opts)"
752,"def install_basic_multifile_support(self):
        """"""
        Utility method for users who created a RootParser with register_default_plugins=False, in order to register only
         the multifile support
        :return:
        """"""
        if not self.multifile_installed:
            self.register_parser(MultifileCollectionParser(self))
            self.register_parser(MultifileObjectParser(self, self))
            self.multifile_installed = True
        else:
            raise Exception('Multifile support has already been installed')"
753,"def parse_collection(self, item_file_prefix: str, base_item_type: Type[T], item_name_for_log: str = None,
                         file_mapping_conf: FileMappingConfiguration = None,
                         options: Dict[str, Dict[str, Any]] = None) -> Dict[str, T]:
        """"""
        Main method to parse a collection of items of type 'base_item_type'.

        :param item_file_prefix:
        :param base_item_type:
        :param item_name_for_log:
        :param file_mapping_conf:
        :param options:
        :return:
        """"""
        # -- item_name_for_log
        item_name_for_log = item_name_for_log or ''
        check_var(item_name_for_log, var_types=str, var_name='item_name_for_log')

        # creating the wrapping dictionary type
        collection_type = Dict[str, base_item_type]
        if len(item_name_for_log) > 0:
            item_name_for_log = item_name_for_log + ' '
        self.logger.debug('**** Starting to parse ' + item_name_for_log + 'collection of <'
                          + get_pretty_type_str(base_item_type) + '> at location ' + item_file_prefix +' ****')

        # common steps
        return self._parse__item(collection_type, item_file_prefix, file_mapping_conf, options=options)"
754,"def parse_item(self, location: str, item_type: Type[T], item_name_for_log: str = None,
                   file_mapping_conf: FileMappingConfiguration = None, options: Dict[str, Dict[str, Any]] = None) -> T:
        """"""
        Main method to parse an item of type item_type

        :param location:
        :param item_type:
        :param item_name_for_log:
        :param file_mapping_conf:
        :param options:
        :return:
        """"""

        # -- item_name_for_log
        item_name_for_log = item_name_for_log or ''
        check_var(item_name_for_log, var_types=str, var_name='item_name_for_log')

        if len(item_name_for_log) > 0:
            item_name_for_log = item_name_for_log + ' '
        self.logger.debug('**** Starting to parse single object ' + item_name_for_log + 'of type <'
                          + get_pretty_type_str(item_type) + '> at location ' + location + ' ****')

        # common steps
        return self._parse__item(item_type, location, file_mapping_conf, options=options)"
755,"def _parse__item(self, item_type: Type[T], item_file_prefix: str,
                     file_mapping_conf: FileMappingConfiguration = None,
                     options: Dict[str, Dict[str, Any]] = None) -> T:
        """"""
        Common parsing steps to parse an item

        :param item_type:
        :param item_file_prefix:
        :param file_mapping_conf:
        :param options:
        :return:
        """"""

        # for consistency : if options is None, default to the default values of create_parser_options
        options = options or create_parser_options()

        # creating the persisted object (this performs required checks)
        file_mapping_conf = file_mapping_conf or WrappedFileMappingConfiguration()
        obj = file_mapping_conf.create_persisted_object(item_file_prefix, logger=self.logger)
        # print('')
        self.logger.debug('')

        # create the parsing plan
        pp = self.create_parsing_plan(item_type, obj, logger=self.logger)
        # print('')
        self.logger.debug('')

        # parse
        res = pp.execute(logger=self.logger, options=options)
        # print('')
        self.logger.debug('')

        return res"
756,"def findSubCommand(args):
  """"""
  Given a list ['foo','bar', 'baz'], attempts to create a command name in the
  format 'foo-bar-baz'. If that command exists, we run it. If it doesn't, we
  check to see if foo-bar exists, in which case we run `foo-bar baz`. We keep
  taking chunks off the end of the command name and adding them to the argument
  list until we find a valid command name we can run.

  This allows us to easily make git-style command drivers where for example we
  have a driver script, foo, and subcommand scripts foo-bar and foo-baz, and when
  the user types `foo bar foobar` we find the foo-bar script and run it as
  `foo-bar foobar`

  :param list|tuple args: list to try and convert to a command args pair
  :returns: command and arguments list
  :rtype: tuple
  :raises StandardError: if the args can't be matched to an executable subcommand
  """"""
  # If the only command we find is the first element of args, we've found the
  # driver script itself and re-executing it will cause an infinite loop, so
  # don't even look at the first element on its own.
  for n in range(len(args) - 1):
    command = '-'.join(args[:(len(args) - n)])
    commandArgs = args[len(args) - n:]
    if isProgram(command):
      return (command, commandArgs)
  raise StandardError(""Could not find a %s subcommand executable"" % command)"
757,"def SpamsumDistance(ssA, ssB):
    '''
    returns the spamsum distance between ssA and ssB
    if they use a different block size, assume maximum distance
    otherwise returns the LevDistance
    '''
    mA = re.match('^(\d+)[:](.*)$', ssA)
    mB = re.match('^(\d+)[:](.*)$', ssB)

    if mA == None or mB == None:
      raise ""do not appear to be spamsum signatures""

    if mA.group(1) != mB.group(1):
      return max([len(mA.group(2)), len(mB.group(2))])
    else:
      return LevDistance(mA.group(2), mB.group(2))"
758,"def terms(cls, tags, minimum_match=None):
        '''
        A query that match on any (configurable) of the provided terms. This is a simpler syntax query for using a bool query with several term queries in the should clauses. For example:

        {
            ""terms"" : {
                ""tags"" : [ ""blue"", ""pill"" ],
                ""minimum_match"" : 1
            }
        }'''
        instance = cls(terms={'tags': tags})
        if minimum_match is not None:
            instance['terms']['minimum_match'] = minimum_match
        return instance"
759,"def field(cls, field, query, boost=None, enable_position_increments=None):
        '''
        A query that executes a query string against a specific field. It is a simplified version of query_string query (by setting the default_field to the field this query executed against). In its simplest form:

        {
            ""field"" : {
                ""name.first"" : ""+something -else""
            }
        }
        Most of the query_string parameters are allowed with the field query as well, in such a case, the query should be formatted as follows:

        {
            ""field"" : {
                ""name.first"" : {
                    ""query"" : ""+something -else"",
                    ""boost"" : 2.0,
                    ""enable_position_increments"": false
                }
            }
        }
        '''
        instance = cls(field={field: {'query': query}})
        if boost is not None:
            instance['field']['boost'] = boost
        if enable_position_increments is not None:
            instance['field']['enable_position_increments'] = enable_position_increments
        return instance"
760,"def match(cls, field, query, operator=None):
        '''
        A family of match queries that accept text/numerics/dates, analyzes it, and constructs a query out of it. For example:

        {
            ""match"" : {
                ""message"" : ""this is a test""
            }
        }
        Note, message is the name of a field, you can subsitute the name of any field (including _all) instead.
        '''
        instance = cls(match={field: {'query': query}})
        if operator is not None:
            instance['match'][field]['operator'] = operator

        return instance"
761,"def bool(cls, must=None, should=None, must_not=None, minimum_number_should_match=None, boost=None):
        '''
        http://www.elasticsearch.org/guide/reference/query-dsl/bool-query.html
        A query that matches documents matching boolean combinations of other queris. The bool query maps to Lucene BooleanQuery. It is built using one of more boolean clauses, each clause with a typed occurrence. The occurrence types are:
        'must' - The clause(query) must appear in matching documents.
        'should' - The clause(query) should appear in the matching document. A boolean query with no 'must' clauses, one or more 'should' clauses must match a document. The minimum number of 'should' clauses to match can be set using 'minimum_number_should_match' parameter.
        'must_not' - The clause(query) must not appear in the matching documents. Note that it is not possible to search on documents that only consists of a 'must_not' clause(s).

        'minimum_number_should_match' - Minimum number of documents that should match
        'boost' - boost value
        > term = ElasticQuery()
        > term.term(user='kimchy')
        > query = ElasticQuery()
        > query.bool(should=term)
        > query.query()
          { 'bool' : { 'should' : { 'term' : {'user':'kimchy'}}}}


        '''
        instance = cls(bool={})
        if must is not None:
            instance['bool']['must'] = must
        if should is not None:
            instance['bool']['should'] = should
        if must_not is not None:
            instance['bool']['must_not'] = must_not
        if minimum_number_should_match is not None:
            instance['bool']['minimum_number_should_match'] = minimum_number_should_match
        if boost is not None:
            instance['bool']['boost'] = boost

        return instance"
762,"def fuzzy(cls, field, value, boost=None, min_similarity=None, prefix_length=None):
        '''
        http://www.elasticsearch.org/guide/reference/query-dsl/fuzzy-query.html
        A fuzzy based query that uses similarity based on Levenshtein (edit distance) algorithm.
        '''
        instance = cls(fuzzy={field: {'value': value}})
        if boost is not None:
            instance['fuzzy'][field]['boost'] = boost
        if min_similarity is not None:
            instance['fuzzy'][field]['min_similarity'] = min_similarity
        if prefix_length is not None:
            instance['fuzzy'][field]['prefix_length'] = prefix_length
        return instance"
763,"def fuzzy_like_this(cls, like_text, fields=None, ignore_tf=None, max_query_terms=None, min_similarity=None, prefix_length=None, boost=None, analyzer=None):
        '''
        http://www.elasticsearch.org/guide/reference/query-dsl/flt-query.html
        Fuzzy like this query find documents that are ""like"" provided text by running it against one or more fields.

        > query = ElasticQuery().fuzzy_like_this('text like this one', fields=['name.first', 'name.last'], max_query_terms=12)
        > query
            {'fuzze_like_this': {'boost': 1.0,
              'fields': ['name.first', 'name.last'],
              'ifgnore_tf': False,
              'like_text': 'text like this one',
              'max_query_terms': 12,
              'min_similarity': 0.5,
              'prefix_length': 0}}

        '''
        instance = cls(fuzzy_like_this={'like_text': like_text})
        if fields is not None:
            instance['fuzzy_like_this']['fields'] = fields
        if ignore_tf is not None:
            instance['fuzzy_like_this']['ignore_tf'] = ignore_tf
        if max_query_terms is not None:
            instance['fuzzy_like_this']['max_query_terms'] = max_query_terms
        if min_similarity is not None:
            instance['fuzzy_like_this']['min_similarity'] = min_similarity
        if prefix_length is not None:
            instance['fuzzy_like_this']['prefix_length'] = prefix_length
        if boost is not None:
            instance['fuzzy_like_this']['boost'] = boost
        if analyzer is not None:
            instance['fuzzy_like_this']['analyzer'] = analyzer

        return instance"
764,"def has_child(cls, child_type, query):
        '''
        http://www.elasticsearch.org/guide/reference/query-dsl/has-child-query.html
        The has_child query accepts a query and the child type to run against, and results in parent documents that have child docs matching the query.

        > child_query = ElasticQuery().term(tag='something')
        > query = ElasticQuery().has_Child('blog_tag', child_query)
        '''

        instance = cls(has_child={'type': child_type, 'query': query})
        return instance"
765,"def mlt(cls, like_text, fields=None, percent_terms_to_match=None, min_term_freq=None, max_query_terms=None, stop_words=None, min_doc_freq=None, max_doc_freq=None, min_word_len=None, max_word_len=None, boost_terms=None, boost=None, analyzer=None):
        '''
        http://www.elasticsearch.org/guide/reference/query-dsl/mlt-query.html
        More like this query find documents that are ""like"" provided text by running it against one or more fields.
        > query = ElasticQuery().mlt('text like this one', fields=['post.content'])
        '''

        instance = cls(more_like_this={'like_text': like_text})
        if fields is not None:
            instance['more_like_this']['fields'] = fields
        if percent_terms_to_match is not None:
            instance['more_like_this']['percent_terms_to_match'] = percent_terms_to_match
        if min_term_freq is not None:
            instance['more_like_this']['min_term_freq'] = min_term_freq
        if max_query_terms is not None:
            instance['more_like_this']['max_query_terms'] = max_query_terms
        if stop_words is not None:
            instance['more_like_this']['stop_words'] = stop_words
        if min_doc_freq is not None:
            instance['more_like_this']['min_doc_freq'] = min_doc_freq
        if max_doc_freq is not None:
            instance['more_like_this']['max_doc_freq'] = max_doc_freq
        if min_word_len is not None:
            instance['more_like_this']['min_word_len'] = min_word_len
        if max_word_len is not None:
            instance['more_like_this']['max_word_len'] = max_word_len
        if boost_terms is not None:
            instance['more_like_this']['boost_terms'] = boost_terms
        if boost is not None:
            instance['more_like_this']['boost'] = boost
        if analyzer is not None:
            instance['more_like_this']['analyzer'] = analyzer
        return instance"
766,"def query_string(cls,
                     query,
                     default_field=None,
                     default_operator=None,
                     analyzer=None,
                     allow_leading_wildcard=None,
                     lowercase_expanded_terms=None,
                     enable_position_increments=None,
                     fuzzy_prefix_length=None,
                     fuzzy_min_sim=None,
                     phrase_slop=None,
                     boost=None,
                     analyze_wildcard=None,
                     auto_generate_phrase_queries=None,
                     minimum_should_match=None):
        '''
        http://www.elasticsearch.org/guide/reference/query-dsl/query-string-query.html
        A query that uses a query parser in order to parse its content.

        > query = ElasticQuery().query_string('this AND that OR thus', default_field='content')
        '''
        instance = cls(query_string={'query': query})
        if default_field is not None:
            instance['query_string']['default_field'] = default_field
        if default_operator is not None:
            instance['query_string']['default_operator'] = default_operator
        if analyzer is not None:
            instance['query_string']['analyzer'] = analyzer
        if allow_leading_wildcard is not None:
            instance['query_string']['allow_leading_wildcard'] = allow_leading_wildcard
        if lowercase_expanded_terms is not None:
            instance['query_string']['lowercase_expanded_terms'] = lowercase_expanded_terms
        if enable_position_increments is not None:
            instance['query_string']['enable_position_increments'] = enable_position_increments
        if fuzzy_prefix_length is not None:
            instance['query_string']['fuzzy_prefix_length'] = fuzzy_prefix_length
        if fuzzy_min_sim is not None:
            instance['query_string']['fuzzy_min_sim'] = fuzzy_min_sim
        if phrase_slop is not None:
            instance['query_string']['phrase_slop'] = phrase_slop
        if boost is not None:
            instance['query_string']['boost'] = boost
        if analyze_wildcard is not None:
            instance['query_string']['analyze_wildcard'] = analyze_wildcard
        if auto_generate_phrase_queries is not None:
            instance['query_string']['auto_generate_phrase_queries'] = auto_generate_phrase_queries
        if minimum_should_match is not None:
            instance['query_string']['minimum_should_match'] = minimum_should_match
        return instance"
767,"def an_text_url(identifiant, code):
    """"""
    Port of the PHP function used by the National Assembly:

    public function urlOpaque($identifiant, $codeType = NULL)
    {
        $datas = array(
            'PRJL' => array('repertoire' => 'projets', 'prefixe' => 'pl', 'suffixe' => ''),
            'PION' => array('repertoire' => 'propositions', 'prefixe' => 'pion', 'suffixe' => ''),
            'PNRECOMENQ' => array('repertoire' => 'propositions', 'prefixe' => 'pion', 'suffixe' => ''),
            'PNREAPPART341' => array('repertoire' => 'propositions', 'prefixe' => 'pion', 'suffixe' => ''),
            'PNREMODREGLTAN' => array('repertoire' => 'propositions', 'prefixe' => 'pion', 'suffixe' => ''),
            'AVCE' => array('repertoire' => 'projets', 'prefixe' => 'pl', 'suffixe' => '-ace'),
            'ETDI' => array('repertoire' => 'projets', 'prefixe' => 'pl', 'suffixe' => '-ei'),
            'ACIN' => array('repertoire' => 'projets', 'prefixe' => 'pl', 'suffixe' => '-ai'),
            'LETT' => array('repertoire' => 'projets', 'prefixe' => 'pl', 'suffixe' => '-l'),
            'PNRETVXINSTITEUROP' => array('repertoire' => 'europe/resolutions', 'prefixe' => 'ppe', 'suffixe' => ''),
            'PNRE' => array('repertoire' => 'europe/resolutions', 'prefixe' => 'ppe', 'suffixe' => ''),
            'RION' => array('repertoire' => '', 'prefixe' => '', 'suffixe' => ''),
            'TCOM' => array('repertoire' => 'ta-commission', 'prefixe' => 'r', 'suffixe' => '-a0'),
            'TCOMMODREGLTAN' => array('repertoire' => 'ta-commission', 'prefixe' => 'r', 'suffixe' => '-a0'),
            'TCOMTVXINSTITEUROP' => array('repertoire' => 'ta-commission', 'prefixe' => 'r', 'suffixe' => '-a0'),
            'TCOMCOMENQ' => array('repertoire' => 'ta-commission', 'prefixe' => 'r', 'suffixe' => '-a0'),
            'TADO' => array('repertoire' => 'ta', 'prefixe' => 'ta', 'suffixe' => ''),
        );
        preg_match('/(.{4})([ANS]*)(R[0-9])([LS]*)([0-9]*)([BTACP]*)(.*)/', $identifiant, $matches);
        $leg = $matches[5];
        $typeTa = $matches[6];
        $num = $matches[7];
        switch ($typeTa) {
            case 'BTC':
                $type = 'TCOM';
                break;
            case 'BTA':
                $type = 'TADO';
                break;
            default:
                $type = $codeType;
        }
        $host = ""http://www.assemblee-nationale.fr/"";
        return $host . $leg . ""/"" . $datas[$type]['repertoire'] . ""/"" . $datas[$type]['prefixe'] . $num . $datas[$type]['suffixe'] . "".pdf"";
    }
    """"""
    datas = {
        'PRJL': {
            'repertoire': 'projets',
            'prefixe': 'pl',
            'suffixe': '',
        },
        'PION': {
            'repertoire': 'propositions',
            'prefixe': 'pion',
            'suffixe': '',
        },
        'PNRECOMENQ': {
            'repertoire': 'propositions',
            'prefixe': 'pion',
            'suffixe': '',
        },
        'PNREAPPART341': {
            'repertoire': 'propositions',
            'prefixe': 'pion',
            'suffixe': '',
        },
        'PNREMODREGLTAN': {
            'repertoire': 'propositions',
            'prefixe': 'pion',
            'suffixe': '',
        },
        'AVCE': {
            'repertoire': 'projets',
            'prefixe': 'pl',
            'suffixe': '-ace',
        },
        'ETDI': {
            'repertoire': 'projets',
            'prefixe': 'pl',
            'suffixe': '-ei',
        },
        'ACIN': {
            'repertoire': 'projets',
            'prefixe': 'pl',
            'suffixe': '-ai',
        },
        'LETT': {
            'repertoire': 'projets',
            'prefixe': 'pl',
            'suffixe': '-l',
        },
        'PNRETVXINSTITEUROP': {
            'repertoire': 'europe/resolutions',
            'prefixe': 'ppe',
            'suffixe': '',
        },
        'PNRE': {
            'repertoire': 'propositions',
            'prefixe': 'pion',
            'suffixe': '',
        },
        'RION': {
            'repertoire': '',
            'prefixe': '',
            'suffixe': '',
        },
        'TCOM': {
            'repertoire': 'ta-commission',
            'prefixe': 'r',
            'suffixe': '-a0',
        },
        'TCOMMODREGLTAN': {
            'repertoire': 'ta-commission',
            'prefixe': 'r',
            'suffixe': '-a0',
        },
        'TCOMTVXINSTITEUROP': {
            'repertoire': 'ta-commission',
            'prefixe': 'r',
            'suffixe': '-a0',
        },
        'TCOMCOMENQ': {
            'repertoire': 'ta-commission',
            'prefixe': 'r',
            'suffixe': '-a0',
        },
        'TADO': {
            'repertoire': 'ta',
            'prefixe': 'ta',
            'suffixe': '',
        },
        # NOT IN NATIONAL ASSEMBLY PHP CODE
        'RAPP': {
            'repertoire': 'rapports',
            'prefixe': 'r',
            'suffixe': '',
        },
        'RINF': {
            'repertoire': 'rapports',
            'prefixe': 'r',
            'suffixe': '',
        }
    }
    match = re.match(r'(.{4})([ANS]*)(R[0-9])([LS]*)([0-9]*)([BTACP]*)(.*)', identifiant)
    leg = match.group(5)
    typeTa = match.group(6)
    num = match.group(7)
    if typeTa == 'BTC':
        type = 'TCOM'
    elif typeTa == 'BTA':
        type = 'TADO'
    else:
        type = code
    host = ""http://www.assemblee-nationale.fr/""

    if type not in datas:
        # ex: ALCNANR5L15B0002 (allocution du président)
        raise Exception('Unknown document type for %s' % identifiant)

    return host + leg + ""/"" + datas[type]['repertoire'] + ""/"" + datas[type]['prefixe'] + num + datas[type]['suffixe'] + "".asp"""
768,"def queryByPortSensor(portiaConfig, edgeId, port, sensor, last=False, params={ 'from': None, 'to': None, 'order': None, 'precision': 'ms', 'limit': None }):
    """"""Returns a pandas data frame with the portia select resultset""""""

    header = {'Accept': 'text/csv'}

    if last == False:
        endpoint = '/select/device/{0}/port/{1}/sensor/{2}{3}'.format( edgeId, port, sensor, utils.buildGetParams(params) )
    else:
        endpoint = '/select/device/{0}/port/{1}/sensor/{2}/last{3}'.format( edgeId, port, sensor, utils.buildGetParams(params) )

    response = utils.httpGetRequest(portiaConfig, endpoint, header)

    if response.status_code == 200:
        try:

            dimensionSeries = pandas.read_csv( StringIO(response.text), sep=';' )
            if portiaConfig['debug']:
                print( '[portia-debug]: {0} rows'.format( len(dimensionSeries.index) ) )

            return dimensionSeries

        except:
            raise Exception('couldn\'t create pandas data frame')
    else:
        raise Exception('couldn\'t retrieve data')"
769,"def try_parse_num_and_booleans(num_str):
    """"""
    Tries to parse the provided string as a number or boolean
    :param num_str:
    :return:
    """"""
    if isinstance(num_str, str):
        # bool
        if num_str.lower() == 'true':
            return True
        elif num_str.lower() == 'false':
            return False
        # int
        if num_str.isdigit():
            return int(num_str)
        # float
        try:
            return float(num_str)
        except ValueError:
            # give up
            return num_str
    else:
        # dont try
        return num_str"
770,"def read_dict_from_properties(desired_type: Type[dict], file_object: TextIOBase,
                              logger: Logger, conversion_finder: ConversionFinder, **kwargs) -> Dict[str, Any]:
    """"""
    Helper method to read a dictionary from a .properties file (java-style) using jprops.
    Since jprops does not provide automatic handling for boolean and numbers, this tries to add the feature.

    :param file_object:
    :return:
    """"""

    # right now jprops relies on a byte stream. So we convert back our nicely decoded Text stream to a unicode
    # byte stream ! (urgh)
    class Unicoder:
        def __init__(self, file_object):
            self.f = file_object

        def __iter__(self):
            return self

        def __next__(self):
            line = self.f.__next__()
            return line.encode(encoding='utf-8')

    res = jprops.load_properties(Unicoder(file_object))

    # first automatic conversion of strings > numbers
    res = {key: try_parse_num_and_booleans(val) for key, val in res.items()}

    # further convert if required
    return ConversionFinder.convert_collection_values_according_to_pep(res, desired_type, conversion_finder, logger, 
                                                                       **kwargs)"
771,"def get_default_jprops_parsers(parser_finder: ParserFinder, conversion_finder: ConversionFinder) -> List[AnyParser]:
    """"""
    Utility method to return the default parsers able to parse a dictionary from a properties file.
    :return:
    """"""
    return [SingleFileParserFunction(parser_function=read_dict_from_properties,
                                     streaming_mode=True, custom_name='read_dict_from_properties',
                                     supported_exts={'.properties', '.txt'},
                                     supported_types={dict},
                                     function_args={'conversion_finder': conversion_finder}),
            # SingleFileParserFunction(parser_function=read_list_from_properties,
            #                          streaming_mode=True,
            #                          supported_exts={'.properties', '.txt'},
            #                          supported_types={list}),
        ]"
772,"def hook(event=None, dependencies=None):
    """"""Hooking decorator. Just `@hook(event, dependencies)` on your function

    Kwargs:
        event (str): String or Iterable with events to hook
        dependencies (str): String or Iterable with modules whose hooks have
        to be called before this one for **this** event

    Wraps :func:`EventList.hook`
    """"""

    def wrapper(func):
        """"""I'm a simple wrapper that manages event hooking""""""
        func.__deps__ = dependencies
        EVENTS.hook(func, event, dependencies)
        return func
    return wrapper"
773,"def load(path):
    """"""Helper function that tries to load a filepath (or python module notation)
    as a python module and on failure `exec` it.

    Args:
        path (str): Path or module to load

    The function tries to import `example.module` when either `example.module`,
    `example/module` or `example/module.py` is given.
    """"""

    importpath = path.replace(""/"", ""."").replace(""\\"", ""."")
    if importpath[-3:] == "".py"":
        importpath = importpath[:-3]

    try:
        importlib.import_module(importpath)
    except (ModuleNotFoundError, TypeError):
        exec(open(path).read())"
774,"def add_image(self, image_path, annotations):
    """"""Adds an image and its bounding boxes to the current list of files

    The bounding boxes are automatically estimated based on the given annotations.

    **Parameters:**

    ``image_path`` : str
      The file name of the image, including its full path

    ``annotations`` : [dict]
      A list of annotations, i.e., where each annotation can be anything that :py:func:`bounding_box_from_annotation` can handle; this list can be empty, in case the image does not contain any faces
    """"""
    self.image_paths.append(image_path)
    self.bounding_boxes.append([bounding_box_from_annotation(**a) for a in annotations])"
775,"def add_from_db(self, database, files):
    """"""Adds images and bounding boxes for the given files of a database that follows the :py:ref:`bob.bio.base.database.BioDatabase <bob.bio.base>` interface.

    **Parameters:**

    ``database`` : a derivative of :py:class:`bob.bio.base.database.BioDatabase`
      The database interface, which provides file names and annotations for the given ``files``

    ``files`` : :py:class:`bob.bio.base.database.BioFile` or compatible
      The files (as returned by :py:meth:`bob.bio.base.database.BioDatabase.objects`) which should be added to the training list
    """"""
    for f in files:
      annotation = database.annotations(f)
      image_path = database.original_file_name(f)
      self.add_image(image_path, [annotation])"
776,"def save(self, list_file):
    """"""Saves the current list of annotations to the given file.

    **Parameters:**

    ``list_file`` : str
      The name of a list file to write the currently stored list into
    """"""
    bob.io.base.create_directories_safe(os.path.dirname(list_file))
    with open(list_file, 'w') as f:
      for i in range(len(self.image_paths)):
        f.write(self.image_paths[i])
        for bbx in self.bounding_boxes[i]:
          f.write(""\t[%f %f %f %f]"" % (bbx.top_f, bbx.left_f, bbx.size_f[0], bbx.size_f[1]))
        f.write(""\n"")"
777,"def load(self, list_file):
    """"""Loads the list of annotations from the given file and **appends** it to the current list.

    ``list_file`` : str
      The name of a list file to load and append
    """"""
    with open(list_file) as f:
      for line in f:
        if line and line[0] != '#':
          splits = line.split()
          bounding_boxes = []
          for i in range(1, len(splits), 4):
            assert splits[i][0] == '[' and splits[i+3][-1] == ']'
            bounding_boxes.append(BoundingBox(topleft=(float(splits[i][1:]), float(splits[i+1])), size=(float(splits[i+2]), float(splits[i+3][:-1]))))
          self.image_paths.append(splits[0])
          self.bounding_boxes.append(bounding_boxes)"
778,"def iterate(self, max_number_of_files=None):
    """"""iterate([max_number_of_files]) -> image, bounding_boxes, image_file

    Yields the image and the bounding boxes stored in the training set as an iterator.

    This function loads the images and converts them to gray-scale.
    It yields the image, the list of bounding boxes and the original image file name.

    **Parameters:**

    ``max_number_of_files`` : int or ``None``
      If specified, limit the number of returned data by sub-selection using :py:func:`quasi_random_indices`

    **Yields:**

    ``image`` : array_like(2D)
      The image loaded from file and converted to gray scale

    ``bounding_boxes`` : [:py:class:`BoundingBox`]
      A list of bounding boxes, where faces are found in the image; might be empty (in case of pure background images)

    `` image_file`` : str
      The name of the original image that was read
    """"""
    indices = quasi_random_indices(len(self), max_number_of_files)
    for index in indices:
      image = bob.io.base.load(self.image_paths[index])
      if len(image.shape) == 3:
        image = bob.ip.color.rgb_to_gray(image)
      # return image and bounding box as iterator
      yield image, self.bounding_boxes[index], self.image_paths[index]"
779,"def _feature_file(self, parallel = None, index = None):
    """"""Returns the name of an intermediate file for storing features.""""""
    if index is None:
      index = 0 if parallel is None or ""SGE_TASK_ID"" not in os.environ else int(os.environ[""SGE_TASK_ID""])
    return os.path.join(self.feature_directory, ""Features_%02d.hdf5"" % index)"
780,"def extract(self, sampler, feature_extractor, number_of_examples_per_scale = (100, 100), similarity_thresholds = (0.5, 0.8), parallel = None, mirror = False, use_every_nth_negative_scale = 1):
    """"""Extracts features from **all** images in **all** scales and writes them to file.

    This function iterates over all images that are present in the internally stored list, and extracts features using the given ``feature_extractor`` for every image patch that the given ``sampler`` returns.
    The final features will be stored in the ``feature_directory`` that is set in the constructor.

    For each image, the ``sampler`` samples patch locations, which cover the whole image in different scales.
    For each patch locations is tested, how similar they are to the face bounding boxes that belong to that image, using the Jaccard :py:meth:`BoundingBox.similarity`.
    The similarity is compared to the ``similarity_thresholds``.
    If it is smaller than the first threshold, the patch is considered as background, when it is greater the the second threshold, it is considered as a face, otherwise it is rejected.
    Depending on the image resolution and the number of bounding boxes, this will usually result in some positive and thousands of negative patches per image.
    To limit the total amount of training data, for all scales, only up to a given number of positive and negative patches are kept.
    Also, to further limit the number of negative samples, only every ``use_every_nth_negative_scale`` scale is considered (for the positives, always all scales are processed).

    To increase the number (especially of positive) examples, features can also be extracted for horizontally mirrored images.
    Simply set the ``mirror`` parameter to ``True``.
    Furthermore, this function is designed to be run using several parallel processes, e.g., using the `GridTK <https://pypi.python.org/pypi/gridtk>`_.
    Each of the processes will run on a particular subset of the images, which is defined by the ``SGE_TASK_ID`` environment variable.
    The ``parallel`` parameter defines the total number of parallel processes that are used.

    **Parameters:**

    ``sampler`` : :py:class:`Sampler`
      The sampler to use to sample patches of the images. Please assure that the sampler is set up such that it samples patch locations which can overlap with the face locations.

    ``feature_extractor`` : :py:class:`FeatureExtractor`
      The feature extractor to be used to extract features from image patches

    ``number_of_examples_per_scale`` : (int, int)
      The maximum number of positive and negative examples to extract for each scale of the image

    ``similarity_thresholds`` : (float, float)
      The Jaccard similarity threshold, below which patch locations are considered to be negative, and above which patch locations are considered to be positive examples.

    ``parallel`` : int or ``None``
      If given, the total number of parallel processes, which are used to extract features (the current process index is read from the ``SGE_TASK_ID`` environment variable)

    ``mirror`` : bool
      Extract positive and negative samples also from horizontally mirrored images?

    ``use_every_nth_negative_scale`` : int
      Skip some negative scales to decrease the number of negative examples, i.e., only extract and store negative features, when ``scale_counter % use_every_nth_negative_scale == 0``

      .. note::
         The ``scale_counter`` is not reset between images, so that we might get features from different scales in subsequent images.
    """"""

    feature_file = self._feature_file(parallel)
    bob.io.base.create_directories_safe(self.feature_directory)

    if parallel is None or ""SGE_TASK_ID"" not in os.environ or os.environ[""SGE_TASK_ID""] == '1':
      extractor_file = os.path.join(self.feature_directory, ""Extractor.hdf5"")
      hdf5 = bob.io.base.HDF5File(extractor_file, ""w"")
      feature_extractor.save(hdf5)
      del hdf5

    total_positives, total_negatives = 0, 0

    indices = parallel_part(range(len(self)), parallel)
    if not indices:
      logger.warning(""The index range for the current parallel thread is empty."")
    else:
      logger.info(""Extracting features for images in range %d - %d of %d"", indices[0], indices[-1], len(self))

    hdf5 = bob.io.base.HDF5File(feature_file, ""w"")
    for index in indices:
      hdf5.create_group(""Image-%d"" % index)
      hdf5.cd(""Image-%d"" % index)

      logger.debug(""Processing file %d of %d: %s"", index+1, indices[-1]+1, self.image_paths[index])

      # load image
      image = bob.io.base.load(self.image_paths[index])
      if image.ndim == 3:
        image = bob.ip.color.rgb_to_gray(image)
      # get ground_truth bounding boxes
      ground_truth = self.bounding_boxes[index]

      # collect image and GT for originally and mirrored image
      images = [image] if not mirror else [image, bob.ip.base.flop(image)]
      ground_truths = [ground_truth] if not mirror else [ground_truth, [gt.mirror_x(image.shape[1]) for gt in ground_truth]]
      parts = ""om""

      # now, sample
      scale_counter = -1
      for image, ground_truth, part in zip(images, ground_truths, parts):
        for scale, scaled_image_shape in sampler.scales(image):
          scale_counter += 1
          scaled_gt = [gt.scale(scale) for gt in ground_truth]
          positives = []
          negatives = []
          # iterate over all possible positions in the image
          for bb in sampler.sample_scaled(scaled_image_shape):
            # check if the patch is a positive example
            positive = False
            negative = True
            for gt in scaled_gt:
              similarity = bb.similarity(gt)
              if similarity > similarity_thresholds[1]:
                positive = True
                break
              if similarity > similarity_thresholds[0]:
                negative = False
                break

            if positive:
              positives.append(bb)
            elif negative and scale_counter % use_every_nth_negative_scale == 0:
              negatives.append(bb)

          # per scale, limit the number of positive and negative samples
          positives = [positives[i] for i in quasi_random_indices(len(positives), number_of_examples_per_scale[0])]
          negatives = [negatives[i] for i in quasi_random_indices(len(negatives), number_of_examples_per_scale[1])]

          # extract features
          feature_extractor.prepare(image, scale)
          # .. negative features
          if negatives:
            negative_features = numpy.zeros((len(negatives), feature_extractor.number_of_features), numpy.uint16)
            for i, bb in enumerate(negatives):
              feature_extractor.extract_all(bb, negative_features, i)
            hdf5.set(""Negatives-%s-%.5f"" % (part,scale), negative_features)
            total_negatives += len(negatives)

          # positive features
          if positives:
            positive_features = numpy.zeros((len(positives), feature_extractor.number_of_features), numpy.uint16)
            for i, bb in enumerate(positives):
              feature_extractor.extract_all(bb, positive_features, i)
            hdf5.set(""Positives-%s-%.5f"" % (part,scale), positive_features)
            total_positives += len(positives)
      # cd backwards after each image
      hdf5.cd("".."")

    hdf5.set(""TotalPositives"", total_positives)
    hdf5.set(""TotalNegatives"", total_negatives)"
781,"def sample(self, model = None, maximum_number_of_positives = None, maximum_number_of_negatives = None, positive_indices = None, negative_indices = None):
    """"""sample([model], [maximum_number_of_positives], [maximum_number_of_negatives], [positive_indices], [negative_indices]) -> positives, negatives

    Returns positive and negative samples from the set of positives and negatives.

    This reads the previously extracted feature file (or all of them, in case features were extracted in parallel) and returns features.
    If the ``model`` is not specified, a random sub-selection of positive and negative features is returned.
    When the ``model`` is given, all patches are first classified with the given ``model``, and the ones that are mis-classified most are returned.
    The number of returned positives and negatives can be limited by specifying the ``maximum_number_of_positives`` and ``maximum_number_of_negatives``.

    This function keeps track of the positives and negatives that it once has returned, so it does not return the same positive or negative feature twice.
    However, when you have to restart training from a given point, you can set the ``positive_indices`` and ``negative_indices`` parameters, to retrieve the features for the given indices.
    In this case, no additional features are selected, but the given sets of indices are stored internally.

    .. note::
       The ``positive_indices`` and ``negative_indices`` only have an effect, when ``model`` is ``None``.

    **Parameters:**

    ``model`` : :py:class:`bob.learn.boosting.BoostedMachine` or ``None``
      If given, the ``model`` is used to predict the training features, and the highest mis-predicted features are returned

    ``maximum_number_of_positives, maximum_number_of_negatives`` : int
      The maximum number of positive and negative features to be returned

    ``positive_indices, negative_indices`` : set(int) or ``None``
      The set of positive and negative indices to extract features for, instead of randomly choosing indices; only considered when ``model = None``

    **Returns:**

    ``positives, negatives`` : array_like(2D, uint16)
      The new set of training features for the positive class (faces) and negative class (background).
    """"""

    # get all existing feature files
    feature_file = self._feature_file(index = 0)
    if os.path.exists(feature_file):
      feature_files = [feature_file]
    else:
      feature_files = []
      i = 1
      while True:
        feature_file = self._feature_file(index = i)
        if not os.path.exists(feature_file):
          break
        feature_files.append(feature_file)
        i += 1

    features = []
    labels = []

    # make a first iteration through the feature files and count the number of positives and negatives
    positive_count, negative_count = 0, 0
    logger.info(""Reading %d feature files"", len(feature_files))
    for feature_file in feature_files:
      logger.debug("".. Loading file %s"", feature_file)
      hdf5 = bob.io.base.HDF5File(feature_file)
      positive_count += hdf5.get(""TotalPositives"")
      negative_count += hdf5.get(""TotalNegatives"")
      del hdf5

    if model is None:
      # get a list of indices and store them, so that we don't re-use them next time
      if positive_indices is None:
        positive_indices = set(quasi_random_indices(positive_count, maximum_number_of_positives))
      if negative_indices is None:
        negative_indices = set(quasi_random_indices(negative_count, maximum_number_of_negatives))
      self.positive_indices |= positive_indices
      self.negative_indices |= negative_indices

      # now, iterate through the files again and sample
      positive_indices = collections.deque(sorted(positive_indices))
      negative_indices = collections.deque(sorted(negative_indices))

      logger.info(""Extracting %d of %d positive and %d of %d negative samples"" % (len(positive_indices), positive_count, len(negative_indices), negative_count))

      positive_count, negative_count = 0, 0
      for feature_file in feature_files:
        hdf5 = bob.io.base.HDF5File(feature_file)
        for image in sorted(hdf5.sub_groups(recursive=False, relative=True)):
          hdf5.cd(image)
          for scale in sorted(hdf5.keys(relative=True)):
            read = hdf5.get(scale)
            size = read.shape[0]
            if scale.startswith(""Positives""):
              # copy positive data
              while positive_indices and positive_count <= positive_indices[0] and positive_count + size > positive_indices[0]:
                assert positive_indices[0] >= positive_count
                features.append(read[positive_indices.popleft() - positive_count, :])
                labels.append(1)
              positive_count += size
            else:
              # copy negative data
              while negative_indices and negative_count <= negative_indices[0] and negative_count + size > negative_indices[0]:
                assert negative_indices[0] >= negative_count
                features.append(read[negative_indices.popleft() - negative_count, :])
                labels.append(-1)
              negative_count += size
          hdf5.cd("".."")
      # return features and labels
      return numpy.array(features), numpy.array(labels)

    else:
      positive_count -= len(self.positive_indices)
      negative_count -= len(self.negative_indices)
      logger.info(""Getting worst %d of %d positive and worst %d of %d negative examples"", min(maximum_number_of_positives, positive_count), positive_count, min(maximum_number_of_negatives, negative_count), negative_count)

      # compute the worst features based on the current model
      worst_positives, worst_negatives = [], []
      positive_count, negative_count = 0, 0

      for feature_file in feature_files:
        hdf5 = bob.io.base.HDF5File(feature_file)
        for image in sorted(hdf5.sub_groups(recursive=False, relative=True)):
          hdf5.cd(image)
          for scale in sorted(hdf5.keys(relative=True)):
            read = hdf5.get(scale)
            size = read.shape[0]
            prediction = bob.blitz.array((size,), numpy.float64)
            # forward features through the model
            result = model.forward(read, prediction)
            if scale.startswith(""Positives""):
              indices = [i for i in range(size) if positive_count + i not in self.positive_indices]
              worst_positives.extend([(prediction[i], positive_count + i, read[i]) for i in indices if prediction[i] <= 0])
              positive_count += size
            else:
              indices = [i for i in range(size) if negative_count + i not in self.negative_indices]
              worst_negatives.extend([(prediction[i], negative_count + i, read[i]) for i in indices if prediction[i] >= 0])
              negative_count += size
          hdf5.cd("".."")

        # cut off good results
        if maximum_number_of_positives is not None and len(worst_positives) > maximum_number_of_positives:
          # keep only the positives with the low predictions (i.e., the worst)
          worst_positives = sorted(worst_positives, key=lambda k: k[0])[:maximum_number_of_positives]
        if maximum_number_of_negatives is not None and len(worst_negatives) > maximum_number_of_negatives:
          # keep only the negatives with the high predictions (i.e., the worst)
          worst_negatives = sorted(worst_negatives, reverse=True, key=lambda k: k[0])[:maximum_number_of_negatives]

      # mark all indices to be used
      self.positive_indices |= set(k[1] for k in worst_positives)
      self.negative_indices |= set(k[1] for k in worst_negatives)

      # finally, collect features and labels
      return numpy.array([f[2] for f in worst_positives] + [f[2] for f in worst_negatives]), numpy.array([1]*len(worst_positives) + [-1]*len(worst_negatives))"
782,"def feature_extractor(self):
    """"""feature_extractor() -> extractor

    Returns the feature extractor used to extract the positive and negative features.

    This feature extractor is stored to file during the :py:meth:`extract` method ran, so this function reads that file (from the ``feature_directory`` set in the constructor) and returns its content.

    **Returns:**

    ``extractor`` : :py:class:`FeatureExtractor`
      The feature extractor used to extract the features stored in the ``feature_directory``
    """"""
    extractor_file = os.path.join(self.feature_directory, ""Extractor.hdf5"")
    if not os.path.exists(extractor_file):
      raise IOError(""Could not found extractor file %s. Did you already run the extraction process? Did you specify the correct `feature_directory` in the constructor?"" % extractor_file)
    hdf5 = bob.io.base.HDF5File(extractor_file)
    return FeatureExtractor(hdf5)"
783,"def get(self, param, default=EMPTY):
        """"""
        Returns the nparam value, and returns the default if it doesn't exist.
        If default is none, an exception will be raised instead.

        the returned parameter will have been specialized against the global context
        """"""
        if not self.has(param):
            if default is not EMPTY:
                return default
            raise ParamNotFoundException(""value for %s not found"" % param)
        context_dict = copy.deepcopy(self.manifest.get_context_dict())
        for k, v in self.raw_dict.items():
            context_dict[""%s:%s"" % (self.feature_name, k)] = v
        cur_value = self.raw_dict[param]
        prev_value = None
        max_depth = 5
        # apply the context until doing so does not change the value
        while cur_value != prev_value and max_depth > 0:
            prev_value = cur_value
            try:
                cur_value = str(prev_value) % context_dict
            except KeyError:
                e = sys.exc_info()[1]
                key = e.args[0]
                if key.startswith('config:'):
                    missing_key = key.split(':')[1]
                    if self.manifest.inputs.is_input(missing_key):
                        val = self.manifest.inputs.get_input(missing_key)
                        context_dict[key] = val
                else:
                    logger.warn(""Could not specialize %s! Error: %s"" % (self.raw_dict[param], e))
                    return self.raw_dict[param]
            except ValueError:
                # this is an esoteric error, and this implementation
                # forces a terrible solution. Sorry.
                # using the standard escaping syntax in python is a mistake.
                # if a value has a ""%"" inside (e.g. a password), a ValueError
                # is raised, causing an issue
                return cur_value
            max_depth -= 1
        return cur_value"
784,"def set(self, param, value):
        """""" sets the param to the value provided """"""
        self.raw_dict[param] = value
        self.manifest.set(self.feature_name, param, value)"
785,"def remove(self, param):
        """""" Remove a parameter from the manifest """"""
        if self.has(param):
            del(self.raw_dict[param])
            self.manifest.remove_option(self.feature_name, param)"
786,"def set_if_empty(self, param, default):
        """""" Set the parameter to the default if it doesn't exist """"""
        if not self.has(param):
            self.set(param, default)"
787,"def to_dict(self):
        """""" Returns the context, fully specialized, as a dictionary """"""
        return dict((k, str(self.get(k))) for k in self.raw_dict)"
788,"def write_to_manifest(self):
        """""" Overwrites the section of the manifest with the featureconfig's value """"""
        self.manifest.remove_section(self.feature_name)
        self.manifest.add_section(self.feature_name)
        for k, v in self.raw_dict.items():
            self.manifest.set(self.feature_name, k, v)"
789,"def mro_resolve(name, bases, dict):
  """"""
  Given a tuple of baseclasses and a dictionary that takes precedence
  over any value in the bases, finds a value with the specified *name*
  and returns it. Raises #KeyError if the value can not be found.
  """"""

  if name in dict:
    return dict[name]
  for base in bases:
    if hasattr(base, name):
      return getattr(base, name)
    try:
      return mro_resolve(name, base.__bases__, {})
    except KeyError:
      pass
  raise KeyError(name)"
790,"def round_to_05(n, exp=None, mode='s'):
    """"""
    Round to the next 0.5-value.

    This function applies the round function `func` to round `n` to the
    next 0.5-value with respect to its exponent with base 10 (i.e.
    1.3e-4 will be rounded to 1.5e-4) if `exp` is None or with respect
    to the given exponent in `exp`.

    Parameters
    ----------
    n: numpy.ndarray
        number to round
    exp: int or numpy.ndarray
        Exponent for rounding. If None, it will be computed from `n` to be the
        exponents for base 10.
    mode: {'s', 'l'}
        rounding mode. If 's', it will be rounded to value whose absolute
        value is below `n`, if 'l' it will rounded to the value whose absolute
        value is above `n`.

    Returns
    -------
    numpy.ndarray
        rounded `n`

    Examples
    --------
    The effects of the different parameters are show in the example below::

        >>> from psyplot.plotter.simple import round_to_05
        >>> a = [-100.3, 40.6, 8.7, -0.00023]
        >>>round_to_05(a, mode='s')
        array([ -1.00000000e+02,   4.00000000e+01,   8.50000000e+00,
                -2.00000000e-04])

        >>> round_to_05(a, mode='l')
        array([ -1.50000000e+02,   4.50000000e+01,   9.00000000e+00,
                -2.50000000e-04])""""""
    n = np.asarray(n)
    if exp is None:
        exp = np.floor(np.log10(np.abs(n)))  # exponent for base 10
    ntmp = np.abs(n)/10.**exp  # mantissa for base 10
    if mode == 's':
        n1 = ntmp
        s = 1.
        n2 = nret = np.floor(ntmp)
    else:
        n1 = nret = np.ceil(ntmp)
        s = -1.
        n2 = ntmp
    return np.where(n1 - n2 > 0.5, np.sign(n)*(nret + s*0.5)*10.**exp,
                    np.sign(n)*nret*10.**exp)"
791,"def convert_radian(coord, *variables):
    """"""Convert the given coordinate from radian to degree

    Parameters
    ----------
    coord: xr.Variable
        The variable to transform
    ``*variables``
        The variables that are on the same unit.

    Returns
    -------
    xr.Variable
        The transformed variable if one of the given `variables` has units in
        radian""""""
    if any(v.attrs.get('units') == 'radian' for v in variables):
        return coord * 180. / np.pi
    return coord"
792,"def format_coord_func(ax, ref):
    """"""Create a function that can replace the
    :func:`matplotlib.axes.Axes.format_coord`

    Parameters
    ----------
    ax: matplotlib.axes.Axes
        The axes instance
    ref: weakref.weakref
        The reference to the :class:`~psyplot.plotter.Formatoption` instance

    Returns
    -------
    function
        The function that can be used to replace `ax.format_coord`
    """"""
    orig_format_coord = ax.format_coord

    def func(x, y):
        orig_s = orig_format_coord(x, y)
        fmto = ref()
        if fmto is None:
            return orig_s
        try:
            orig_s += fmto.add2format_coord(x, y)
        except Exception:
            fmto.logger.debug(
                'Failed to get plot informations for status bar!', exc_info=1)
        return orig_s

    return func"
793,"def replace_coord(self, i):
        """"""Replace the coordinate for the data array at the given position

        Parameters
        ----------
        i: int
            The number of the data array in the raw data (if the raw data is
            not an interactive list, use 0)

        Returns
        xarray.DataArray
            The data array with the replaced coordinate""""""
        da = next(islice(self.data_iterator, i, i+1))
        name, coord = self.get_alternative_coord(da, i)
        other_coords = {key: da.coords[key]
                        for key in set(da.coords).difference(da.dims)}
        ret = da.rename({da.dims[-1]: name}).assign_coords(
            **{name: coord}).assign_coords(**other_coords)
        return ret"
794,"def value2pickle(self):
        """"""Return the current axis colors""""""
        return {key: s.get_edgecolor() for key, s in self.ax.spines.items()}"
795,"def set_default_formatters(self, which=None):
        """"""Sets the default formatters that is used for updating to None

        Parameters
        ----------
        which: {None, 'minor', 'major'}
            Specify which locator shall be set""""""
        if which is None or which == 'minor':
            self.default_formatters['minor'] = self.axis.get_minor_formatter()
        if which is None or which == 'major':
            self.default_formatters['major'] = self.axis.get_major_formatter()"
796,"def plotted_data(self):
        """"""The data that is shown to the user""""""
        return InteractiveList(
            [arr for arr, val in zip(self.iter_data,
                                     cycle(slist(self.value)))
             if val is not None])"
797,"def get_cmap(self, arr=None, cmap=None, N=None):
        """"""Get the :class:`matplotlib.colors.Colormap` for plotting

        Parameters
        ----------
        arr: np.ndarray
            The array to plot
        cmap: str or matplotlib.colors.Colormap
            The colormap to use. If None, the :attr:`value` of this
            formatoption is used
        N: int
            The number of colors in the colormap. If None, the norm of the
            :attr:`bounds` formatoption is used and, if necessary, the
            given array `arr`

        Returns
        -------
        matplotlib.colors.Colormap
            The colormap returned by :func:`psy_simple.colors.get_cmap`""""""
        N = N or None
        if cmap is None:
            cmap = self.value
        if N is None:
            try:
                N = self.bounds.norm.Ncmap
            except AttributeError:
                if arr is not None and self.bounds.norm is not None:
                    N = len(np.unique(self.bounds.norm(arr.ravel())))
        if N is not None:
            return get_cmap(cmap, N)
        return get_cmap(cmap)"
798,"def get_fmt_widget(self, parent, project):
        """"""Open a :class:`psy_simple.widget.CMapFmtWidget`""""""
        from psy_simple.widgets.colors import CMapFmtWidget
        return CMapFmtWidget(parent, self, project)"
799,"def xcoord(self):
        """"""The x coordinate :class:`xarray.Variable`""""""
        return self.decoder.get_x(self.data, coords=self.data.coords)"
800,"def ycoord(self):
        """"""The y coordinate :class:`xarray.Variable`""""""
        return self.decoder.get_y(self.data, coords=self.data.coords)"
801,"def cell_nodes_x(self):
        """"""The unstructured x-boundaries with shape (N, m) where m > 2""""""
        decoder = self.decoder
        xcoord = self.xcoord
        data = self.data
        xbounds = decoder.get_cell_node_coord(
            data, coords=data.coords, axis='x')
        if self.plotter.convert_radian:
            xbounds = convert_radian(xbounds, xcoord, xbounds)
        return xbounds.values"
802,"def cell_nodes_y(self):
        """"""The unstructured y-boundaries with shape (N, m) where m > 2""""""
        decoder = self.decoder
        ycoord = self.ycoord
        data = self.data
        ybounds = decoder.get_cell_node_coord(
            data, coords=data.coords, axis='y')
        if self.plotter.convert_radian:
            ybounds = convert_radian(ybounds, ycoord, ybounds)
        return ybounds.values"
803,"def axis(self):
        """"""axis of the colorbar with the ticks. Will be overwritten during
        update process.""""""
        return getattr(
            self.colorbar.ax, self.axis_locations[self.position] + 'axis')"
804,"def default_formatters(self):
        """"""Default locator of the axis of the colorbars""""""
        if self._default_formatters:
            return self._default_formatters
        else:
            self.set_default_formatters()
        return self._default_formatters"
805,"def xcoord(self):
        """"""The x coordinate :class:`xarray.Variable`""""""
        v = next(self.raw_data.psy.iter_base_variables)
        return self.decoder.get_x(v, coords=self.data.coords)"
806,"def ycoord(self):
        """"""The y coordinate :class:`xarray.Variable`""""""
        v = next(self.raw_data.psy.iter_base_variables)
        return self.decoder.get_y(v, coords=self.data.coords)"
807,"def add2format_coord(self, x, y):
        """"""Additional information for the :meth:`format_coord`""""""
        u, v = self.data
        uname, vname = self.data.coords['variable'].values
        xcoord = self.xcoord
        ycoord = self.ycoord
        if self.decoder.is_triangular(self.raw_data[0]):
            x, y, z1, z2 = self.get_xyz_tri(xcoord, x, ycoord, y, u, v)
        elif xcoord.ndim == 1:
            x, y, z1, z2 = self.get_xyz_1d(xcoord, x, ycoord, y, u, v)
        elif xcoord.ndim == 2:
            x, y, z1, z2 = self.get_xyz_2d(xcoord, x, ycoord, y, u, v)
        speed = (z1**2 + z2**2)**0.5
        xunit = xcoord.attrs.get('units', '')
        if xunit:
            xunit = ' ' + xunit
        yunit = ycoord.attrs.get('units', '')
        if yunit:
            yunit = ' ' + yunit
        zunit = u.attrs.get('units', '')
        if zunit:
            zunit = ' ' + zunit
        return (', vector data: %s: %.4g%s, %s: %.4g%s, %s: %.4g%s, '
                '%s: %.4g%s, absolute: %.4g%s') % (
                    xcoord.name, x, xunit, ycoord.name, y, yunit,
                    uname, z1, zunit, vname, z2, zunit,
                    speed, zunit)"
808,"def get_xyz_tri(self, xcoord, x, ycoord, y, u, v):
        """"""Get closest x, y and z for the given `x` and `y` in `data` for
        1d coords""""""
        return self.get_xyz_2d(xcoord, x, ycoord, y, u, v)"
809,"def get_xyz_1d(self, xcoord, x, ycoord, y, u, v):
        """"""Get closest x, y and z for the given `x` and `y` in `data` for
        1d coords""""""
        xclose = xcoord.indexes[xcoord.name].get_loc(x, method='nearest')
        yclose = ycoord.indexes[ycoord.name].get_loc(y, method='nearest')
        uval = u[yclose, xclose].values
        vval = v[yclose, xclose].values
        return xcoord[xclose].values, ycoord[yclose].values, uval, vval"
810,"def get_xyz_2d(self, xcoord, x, ycoord, y, u, v):
        """"""Get closest x, y and z for the given `x` and `y` in `data` for
        2d coords""""""
        xy = xcoord.values.ravel() + 1j * ycoord.values.ravel()
        dist = np.abs(xy - (x + 1j * y))
        imin = np.nanargmin(dist)
        xy_min = xy[imin]
        return (xy_min.real, xy_min.imag, u.values.ravel()[imin],
                v.values.ravel()[imin])"
811,"def hist2d(self, da, **kwargs):
        """"""Make the two dimensional histogram

        Parameters
        ----------
        da: xarray.DataArray
            The data source""""""
        if self.value is None or self.value == 'counts':
            normed = False
        else:
            normed = True
        y = da.values
        x = da.coords[da.dims[0]].values
        counts, xedges, yedges = np.histogram2d(
            x, y, normed=normed, **kwargs)
        if self.value == 'counts':
            counts = counts / counts.sum().astype(float)
        return counts, xedges, yedges"
812,"def _statsmodels_bivariate_kde(self, x, y, bws, xsize, ysize, xyranges):
        """"""Compute a bivariate kde using statsmodels.
        This function is mainly motivated through
        seaborn.distributions._statsmodels_bivariate_kde""""""
        import statsmodels.nonparametric.api as smnp
        for i, (coord, bw) in enumerate(zip([x, y], bws)):
            if isinstance(bw, six.string_types):
                bw_func = getattr(smnp.bandwidths, ""bw_"" + bw)
                bws[i] = bw_func(coord)
        kde = smnp.KDEMultivariate([x, y], ""cc"", bws)
        x_support = np.linspace(xyranges[0][0], xyranges[0][1], xsize)
        y_support = np.linspace(xyranges[1][0], xyranges[1][1], ysize)
        xx, yy = np.meshgrid(x_support, y_support)
        z = kde.pdf([xx.ravel(), yy.ravel()]).reshape(xx.shape)
        return x_support, y_support, z"
813,"def check_data(cls, name, dims, is_unstructured=None):
        """"""
        A validation method for the data shape

        Parameters
        ----------
        name: str or list of str
            The variable names (at maximum :attr:`allowed_vars` variables per
            array)
        dims: list with length 1 or list of lists with length 1
            The dimension of the arrays. Only 1D-Arrays are allowed
        is_unstructured: bool or list of bool, optional
            True if the corresponding array is unstructured. This keyword is
            ignored

        Returns
        -------
        %(Plotter.check_data.returns)s
        """"""
        if isinstance(name, six.string_types) or not is_iterable(name):
            name = [name]
            dims = [dims]
        N = len(name)
        if len(dims) != N:
            return [False] * N, [
                'Number of provided names (%i) and dimensions '
                '%(i) are not the same' % (N, len(dims))] * N
        checks = [True] * N
        messages = [''] * N
        for i, (n, d) in enumerate(zip(name, dims)):
            if n != 0 and not n:
                checks[i] = False
                messages[i] = 'At least one variable name is required!'
            elif ((not isstring(n) and is_iterable(n) and
                   len(n) > cls.allowed_vars) and
                  len(d) != (cls.allowed_dims - len(slist(n)))):
                checks[i] = False
                messages[i] = 'Only %i names are allowed per array!' % (
                    cls.allowed_vars)
            elif len(d) != cls.allowed_dims:
                checks[i] = False
                messages[i] = 'Only %i-dimensional arrays are allowed!' % (
                    cls.allowed_dims)
        return checks, messages"
814,"def check_data(cls, name, dims, is_unstructured):
        """"""
        A validation method for the data shape

        Parameters
        ----------
        name: str or list of str
            The variable names (one variable per array)
        dims: list with length 1 or list of lists with length 1
            The dimension of the arrays. Only 1D-Arrays are allowed
        is_unstructured: bool or list of bool
            True if the corresponding array is unstructured.

        Returns
        -------
        %(Plotter.check_data.returns)s
        """"""
        if isinstance(name, six.string_types) or not is_iterable(name):
            name = [name]
            dims = [dims]
            is_unstructured = [is_unstructured]
        N = len(name)
        if N != 1:
            return [False] * N, [
                'Number of provided names (%i) must equal 1!' % (N)] * N
        elif len(dims) != 1:
            return [False], [
                'Number of provided dimension lists (%i) must equal 1!' % (
                    len(dims))]
        elif len(is_unstructured) != 1:
            return [False], [
                ('Number of provided unstructured information (%i) must '
                 'equal 1!') % (len(is_unstructured))]
        if name[0] != 0 and not name[0]:
            return [False], ['At least one variable name must be provided!']
        # unstructured arrays have only 1 dimension
        dimlen = cls.allowed_dims
        if is_unstructured[0]:
            dimlen -= 1
        # Check that the array is two-dimensional
        #
        # if more than one array name is provided, the dimensions should be
        # one les than dimlen to have a 2D array
        if (not isstring(name[0]) and not is_iterable(name[0])
                and len(name[0]) != 1 and len(dims[0]) != dimlen - 1):
            return [False], ['Only one name is allowed per array!']
        # otherwise the number of dimensions must equal dimlen
        if len(dims[0]) != dimlen:
            return [False], [
                'An array with dimension %i is required, not %i' % (
                    dimlen, len(dims[0]))]
        return [True], ['']"
815,"def check_data(cls, name, dims, is_unstructured):
        """"""
        A validation method for the data shape

        Parameters
        ----------
        name: list of str with length 2
            The variable names (one for the first, two for the second array)
        dims: list with length 2 of lists with length 1
            The dimension of the arrays. Only 2D-Arrays are allowed (or 1-D if
            an array is unstructured)
        is_unstructured: bool or list of bool
            True if the corresponding array is unstructured.

        Returns
        -------
        %(Plotter.check_data.returns)s
        """"""
        if isinstance(name, six.string_types) or not is_iterable(name):
            name = [name]
            dims = [dims]
            is_unstructured = [is_unstructured]
        msg = ('Two arrays are required (one for the scalar and '
               'one for the vector field)')
        if len(name) < 2:
            return [None], [msg]
        elif len(name) > 2:
            return [False], [msg]
        valid1, msg1 = Simple2DBase.check_data(name[:1], dims[0:1],
                                               is_unstructured[:1])
        valid2, msg2 = BaseVectorPlotter.check_data(name[1:], dims[1:],
                                                    is_unstructured[1:])
        return valid1 + valid2, msg1 + msg2"
816,"def record_diff(old, new):
    """"""Return a JSON-compatible structure capable turn the `new` record back
    into the `old` record. The parameters must be structures compatible with
    json.dumps *or* strings compatible with json.loads. Note that by design,
    `old == record_patch(new, record_diff(old, new))`""""""
    old, new = _norm_json_params(old, new)
    return json_delta.diff(new, old, verbose=False)"
817,"def record_patch(rec, diff):
    """"""Return the JSON-compatible structure that results from applying the
    changes in `diff` to the record `rec`. The parameters must be structures
    compatible with json.dumps *or* strings compatible with json.loads. Note
    that by design, `old == record_patch(new, record_diff(old, new))`""""""
    rec, diff = _norm_json_params(rec, diff)
    return json_delta.patch(rec, diff, in_place=False)"
818,"def append_diff_hist(diff, diff_hist=list()):
    """"""Given a diff as generated by record_diff, append a diff record to the
    list of diff_hist records.""""""
    diff, diff_hist = _norm_json_params(diff, diff_hist)

    if not diff_hist:
        diff_hist = list()

    diff_hist.append({'diff': diff, 'diff_date': now_field()})
    return diff_hist"
819,"def parse_diff_hist(curr_obj, diff_hist):
    """"""Given a diff_hist as created, appended by append_diff_hist, yield the
    versions of the object start with curr_obj and working backwards in time.
    Each instance yielded is of the form (obj, date-string) where obj is the
    JSON version of the object created by applying a diff in the
    diff history and date-string is a string representing the date/time that
    the diff was taken""""""
    curr_obj, diff_hist = _norm_json_params(curr_obj, diff_hist)

    yield (json.dumps(curr_obj), None)

    last_obj = curr_obj
    for one in reversed(diff_hist):
        last_obj = record_patch(last_obj, one['diff'])
        yield json.dumps(last_obj), one['diff_date']"
820,"def to_dict(self):
        """"""
        Converts object into a dictionary.
        """"""
        data = {
            'id': self.id,
            'referenceId': self.reference_id,
            'type': self.type,
            'displayName': self.display_name,
            'remoteUrl': self.remote_url}
        for key in data.keys():
            if data[key] == None:
                data.pop(key)
        return data"
821,"def to_dict(self):
        """"""
        Converts object into a dictionary.
        """"""
        data = {
            'url': self.url,
            'encodingRate': self.encoding_rate,
            'frameHeight': self.frame_height,
            'frameWidth': self.frame_width,
            'size': self.size,
            'remoteUrl': self.remote_url,
            'remoteStream': self.remote_stream_name,
            'videoDuration': self.video_duration,
            'videoCodec': self.video_codec}
        [data.pop(key) for key in data.keys() if data[key] is None]
        return data"
822,"def to_dict(self):
        """"""
        Converts object into a dictionary.
        """"""
        data = {
            'name': self.name,
            'video_id': self.video_id,
            'time': self.time,
            'forceStop': self.force_stop,
            'type': self.type,
            'metadata': self.metadata}
        for key in data.keys():
            if data[key] == None:
                data.pop(key)
        return data"
823,"def _find_video(self):
        """"""
        Lookup and populate ``pybrightcove.video.Video`` object given a video
        id or reference_id.
        """"""
        data = None
        if self.id:
            data = self.connection.get_item(
                'find_video_by_id', video_id=self.id)
        elif self.reference_id:
            data = self.connection.get_item(
                'find_video_by_reference_id', reference_id=self.reference_id)

        if data:
            self._load(data)"
824,"def _to_dict(self):
        """"""
        Converts object into a dictionary.
        """"""
        for i, tag in enumerate(self.tags):
            if tag in ("""", None):
                self.tags.pop(i)

        data = {
            'name': self.name,
            'referenceId': self.reference_id,
            'shortDescription': self.short_description,
            'longDescription': self.long_description,
            'itemState': self.item_state,
            'linkURL': self.link_url,
            'linkText': self.link_text,
            'tags': self.tags,
            'economics': self.economics,
            'id': self.id,
            'end_date': _make_tstamp(self.end_date),
            'start_date': _make_tstamp(self.start_date)}
        if len(self.renditions) > 0:
            data['renditions'] = []
            for r in self.renditions:
                data['renditions'].append(r.to_dict())
        if len(self.metadata) > 0:
            data['customFields'] = {}
            for meta in self.metadata:
                data['customFields'][meta['key']] = meta['value']
        [data.pop(key) for key in data.keys() if data[key] == None]
        return data"
825,"def to_xml(self):
        # pylint: disable=R0912
        """"""
        Converts object into an XML string.
        """"""
        xml = ''
        for asset in self.assets:
            xml += '<asset filename=""%s"" ' % \
                os.path.basename(asset['filename'])
            xml += ' refid=""%(refid)s""' % asset
            xml += ' size=""%(size)s""' % asset
            xml += ' hash-code=""%s""' % asset['hash-code']
            xml += ' type=""%(type)s""' % asset
            if asset.get('encoding-rate', None):
                xml += ' encoding-rate=""%s""' % asset['encoding-rate']
            if asset.get('frame-width', None):
                xml += ' frame-width=""%s""' % asset['frame-width']
            if asset.get('frame-height', None):
                xml += ' frame-height=""%s""' % asset['frame-height']
            if asset.get('display-name', None):
                xml += ' display-name=""%s""' % asset['display-name']
            if asset.get('encode-to', None):
                xml += ' encode-to=""%s""' % asset['encode-to']
            if asset.get('encode-multiple', None):
                xml += ' encode-multiple=""%s""' % asset['encode-multiple']
            if asset.get('h264-preserve-as-rendition', None):
                xml += ' h264-preserve-as-rendition=""%s""' % \
                    asset['h264-preserve-as-rendition']
            if asset.get('h264-no-processing', None):
                xml += ' h264-no-processing=""%s""' % asset['h264-no-processing']
            xml += ' />\n'
        xml += '<title name=""%(name)s"" refid=""%(referenceId)s"" active=""TRUE"" '
        if self.start_date:
            xml += 'start-date=""%(start_date)s"" '
        if self.end_date:
            xml += 'end-date=""%(end_date)s"" '
        for asset in self.assets:
            if asset.get('encoding-rate', None) == None:
                choice = enums.AssetTypeEnum
                if asset.get('type', None) == choice.VIDEO_FULL:
                    xml += 'video-full-refid=""%s"" ' % asset.get('refid')
                if asset.get('type', None) == choice.THUMBNAIL:
                    xml += 'thumbnail-refid=""%s"" ' % asset.get('refid')
                if asset.get('type', None) == choice.VIDEO_STILL:
                    xml += 'video-still-refid=""%s"" ' % asset.get('refid')
                if asset.get('type', None) == choice.FLV_BUMPER:
                    xml += 'flash-prebumper-refid=""%s"" ' % asset.get('refid')
        xml += '>\n'
        if self.short_description:
            xml += '<short-description><![CDATA[%(shortDescription)s]]>'
            xml += '</short-description>\n'
        if self.long_description:
            xml += '<long-description><![CDATA[%(longDescription)s]]>'
            xml += '</long-description>\n'
        for tag in self.tags:
            xml += '<tag><![CDATA[%s]]></tag>\n' % tag
        for asset in self.assets:
            if asset.get('encoding-rate', None):
                xml += '<rendition-refid>%s</rendition-refid>\n' % \
                    asset['refid']
        for meta in self.metadata:
            xml += '<custom-%s-value name=""%s"">%s</custom-%s-value>' % \
                (meta['type'], meta['key'], meta['value'], meta['type'])
        xml += '</title>'
        xml = xml % self._to_dict()
        return xml"
826,"def _load(self, data):
        """"""
        Deserialize a dictionary of data into a ``pybrightcove.video.Video``
        object.
        """"""
        self.raw_data = data
        self.creation_date = _convert_tstamp(data['creationDate'])
        self.economics = data['economics']
        self.id = data['id']
        self.last_modified_date = _convert_tstamp(data['lastModifiedDate'])
        self.length = data['length']
        self.link_text = data['linkText']
        self.link_url = data['linkURL']
        self.long_description = data['longDescription']
        self.name = data['name']
        self.plays_total = data['playsTotal']
        self.plays_trailing_week = data['playsTrailingWeek']
        self.published_date = _convert_tstamp(data['publishedDate'])
        self.start_date = _convert_tstamp(data.get('startDate', None))
        self.end_date = _convert_tstamp(data.get('endDate', None))
        self.reference_id = data['referenceId']
        self.short_description = data['shortDescription']
        self.tags = []
        for tag in data['tags']:
            self.tags.append(tag)
        self.thumbnail_url = data['thumbnailURL']
        self.video_still_url = data['videoStillURL']"
827,"def get_custom_metadata(self):
        """"""
        Fetches custom metadta for an already exisiting Video.
        """"""
        if self.id is not None:
            data = self.connection.get_item(
                'find_video_by_id',
                video_id=self.id,
                video_fields=""customFields""
            )
            for key in data.get(""customFields"", {}).keys():
                val = data[""customFields""].get(key)
                if val is not None:
                    self.add_custom_metadata(key, val)"
828,"def add_custom_metadata(self, key, value, meta_type=None):
        """"""
        Add custom metadata to the Video.  meta_type is required for XML API.
        """"""
        self.metadata.append({'key': key, 'value': value, 'type': meta_type})"
829,"def add_asset(self, filename, asset_type, display_name,
        encoding_rate=None, frame_width=None, frame_height=None,
        encode_to=None, encode_multiple=False,
        h264_preserve_as_rendition=False, h264_no_processing=False):
        """"""
        Add an asset to the Video object.
        """"""
        m = hashlib.md5()
        fp = file(filename, 'rb')
        bits = fp.read(262144)  ## 256KB
        while bits:
            m.update(bits)
            bits = fp.read(262144)
        fp.close()

        hash_code = m.hexdigest()
        refid = ""%s-%s"" % (os.path.basename(filename), hash_code)

        asset = {
            'filename': filename,
            'type': asset_type,
            'size': os.path.getsize(filename),
            'refid': refid,
            'hash-code': hash_code}

        if encoding_rate:
            asset.update({'encoding-rate': encoding_rate})
        if frame_width:
            asset.update({'frame-width': frame_width})
        if frame_height:
            asset.update({'frame-height': frame_height})
        if display_name:
            asset.update({'display-name': display_name})
        if encode_to:
            asset.update({'encode-to': encode_to})
            asset.update({'encode-multiple': encode_multiple})
            if encode_multiple and h264_preserve_as_rendition:
                asset.update({
                    'h264-preserve-as-rendition': h264_preserve_as_rendition})
        else:
            if h264_no_processing:
                asset.update({'h264-no-processing': h264_no_processing})
        self.assets.append(asset)"
830,"def save(self, create_multiple_renditions=True,
        preserve_source_rendition=True,
        encode_to=enums.EncodeToEnum.FLV):
        """"""
        Creates or updates the video
        """"""
        if is_ftp_connection(self.connection) and len(self.assets) > 0:
            self.connection.post(xml=self.to_xml(), assets=self.assets)
        elif not self.id and self._filename:
            self.id = self.connection.post('create_video', self._filename,
                create_multiple_renditions=create_multiple_renditions,
                preserve_source_rendition=preserve_source_rendition,
                encode_to=encode_to,
                video=self._to_dict())
        elif not self.id and len(self.renditions) > 0:
            self.id = self.connection.post('create_video',
                video=self._to_dict())
        elif self.id:
            data = self.connection.post('update_video', video=self._to_dict())
            if data:
                self._load(data)"
831,"def delete(self, cascade=False, delete_shares=False):
        """"""
        Deletes the video.
        """"""
        if self.id:
            self.connection.post('delete_video', video_id=self.id,
                cascade=cascade, delete_shares=delete_shares)
            self.id = None"
832,"def get_upload_status(self):
        """"""
        Get the status of the video that has been uploaded.
        """"""
        if self.id:
            return self.connection.post('get_upload_status', video_id=self.id)"
833,"def share(self, accounts):
        """"""
        Create a share
        """"""
        if not isinstance(accounts, (list, tuple)):
            msg = ""Video.share expects an iterable argument""
            raise exceptions.PyBrightcoveError(msg)
        raise exceptions.PyBrightcoveError(""Not yet implemented"")"
834,"def set_image(self, image, filename=None, resize=False):
        """"""
        Set the poster or thumbnail of a this Vidoe.
        """"""
        if self.id:
            data = self.connection.post('add_image', filename,
                video_id=self.id, image=image.to_dict(), resize=resize)
            if data:
                self.image = Image(data=data)"
835,"def find_related(self, _connection=None, page_size=100, page_number=0):
        """"""
        List all videos that are related to this one.
        """"""
        if self.id:
            return connection.ItemResultSet('find_related_videos',
                Video, _connection, page_size, page_number, None, None,
                video_id=self.id)"
836,"def delete_video(video_id, cascade=False, delete_shares=False,
        _connection=None):
        """"""
        Delete the video represented by the ``video_id`` parameter.
        """"""
        c = _connection
        if not c:
            c = connection.APIConnection()
        c.post('delete_video', video_id=video_id, cascade=cascade,
            delete_shares=delete_shares)"
837,"def get_status(video_id, _connection=None):
        """"""
        Get the status of a video given the ``video_id`` parameter.
        """"""
        c = _connection
        if not c:
            c = connection.APIConnection()
        return c.post('get_upload_status', video_id=video_id)"
838,"def activate(video_id, _connection=None):
        """"""
        Mark a video as Active
        """"""
        c = _connection
        if not c:
            c = connection.APIConnection()
        data = c.post('update_video', video={
            'id': video_id,
            'itemState': enums.ItemStateEnum.ACTIVE})
        return Video(data=data, _connection=c)"
839,"def find_modified(since, filter_list=None, _connection=None, page_size=25,
        page_number=0, sort_by=enums.DEFAULT_SORT_BY,
        sort_order=enums.DEFAULT_SORT_ORDER):
        """"""
        List all videos modified since a certain date.
        """"""
        filters = []
        if filter_list is not None:
            filters = filter_list
        if not isinstance(since, datetime):
            msg = 'The parameter ""since"" must be a datetime object.'
            raise exceptions.PyBrightcoveError(msg)
        fdate = int(since.strftime(""%s"")) / 60  ## Minutes since UNIX time
        return connection.ItemResultSet('find_modified_videos',
            Video, _connection, page_size, page_number, sort_by, sort_order,
            from_date=fdate, filter=filters)"
840,"def find_all(_connection=None, page_size=100, page_number=0,
        sort_by=enums.DEFAULT_SORT_BY, sort_order=enums.DEFAULT_SORT_ORDER):
        """"""
        List all videos.
        """"""
        return connection.ItemResultSet('find_all_videos', Video,
            _connection, page_size, page_number, sort_by, sort_order)"
841,"def find_by_tags(and_tags=None, or_tags=None, _connection=None,
        page_size=100, page_number=0, sort_by=enums.DEFAULT_SORT_BY,
        sort_order=enums.DEFAULT_SORT_ORDER):
        """"""
        List videos given a certain set of tags.
        """"""
        err = None
        if not and_tags and not or_tags:
            err = ""You must supply at least one of either and_tags or or_tags.""
        if and_tags and not isinstance(and_tags, (tuple, list)):
            err = ""The and_tags argument for Video.find_by_tags must an ""
            err += ""iterable""
        if or_tags and not isinstance(or_tags, (tuple, list)):
            err = ""The or_tags argument for Video.find_by_tags must an ""
            err += ""iterable""
        if err:
            raise exceptions.PyBrightcoveError(err)
        atags = None
        otags = None
        if and_tags:
            atags = ','.join([str(t) for t in and_tags])
        if or_tags:
            otags = ','.join([str(t) for t in or_tags])
        return connection.ItemResultSet('find_videos_by_tags',
            Video, _connection, page_size, page_number, sort_by, sort_order,
            and_tags=atags, or_tags=otags)"
842,"def find_by_text(text, _connection=None, page_size=100, page_number=0,
        sort_by=enums.DEFAULT_SORT_BY, sort_order=enums.DEFAULT_SORT_ORDER):
        """"""
        List videos that match the ``text`` in title or description.
        """"""
        return connection.ItemResultSet('find_videos_by_text',
            Video, _connection, page_size, page_number, sort_by, sort_order,
            text=text)"
843,"def find_by_campaign(campaign_id, _connection=None, page_size=100,
        page_number=0, sort_by=enums.DEFAULT_SORT_BY,
        sort_order=enums.DEFAULT_SORT_ORDER):
        """"""
        List all videos for a given campaign.
        """"""
        return connection.ItemResultSet(
            'find_videos_by_campaign_id', Video, _connection, page_size,
            page_number, sort_by, sort_order, campaign_id=campaign_id)"
844,"def find_by_user(user_id, _connection=None, page_size=100, page_number=0,
        sort_by=enums.DEFAULT_SORT_BY, sort_order=enums.DEFAULT_SORT_ORDER):
        """"""
        List all videos uploaded by a certain user.
        """"""
        return connection.ItemResultSet('find_videos_by_user_id',
            Video, _connection, page_size, page_number, sort_by, sort_order,
            user_id=user_id)"
845,"def find_by_reference_ids(reference_ids, _connection=None, page_size=100,
        page_number=0, sort_by=enums.DEFAULT_SORT_BY,
        sort_order=enums.DEFAULT_SORT_ORDER):
        """"""
        List all videos identified by a list of reference ids
        """"""
        if not isinstance(reference_ids, (list, tuple)):
            err = ""Video.find_by_reference_ids expects an iterable argument""
            raise exceptions.PyBrightcoveError(err)
        ids = ','.join(reference_ids)
        return connection.ItemResultSet(
            'find_videos_by_reference_ids', Video, _connection, page_size,
            page_number, sort_by, sort_order, reference_ids=ids)"
846,"def find_by_ids(ids, _connection=None, page_size=100, page_number=0,
        sort_by=enums.DEFAULT_SORT_BY, sort_order=enums.DEFAULT_SORT_ORDER):
        """"""
        List all videos identified by a list of Brightcove video ids
        """"""
        if not isinstance(ids, (list, tuple)):
            err = ""Video.find_by_ids expects an iterable argument""
            raise exceptions.PyBrightcoveError(err)
        ids = ','.join([str(i) for i in ids])
        return connection.ItemResultSet('find_videos_by_ids',
            Video, _connection, page_size, page_number, sort_by, sort_order,
            video_ids=ids)"
847,"def read_gpx(xml, gpxns=None):
    """"""Parse a GPX file into a GpxModel.

    Args:
        xml: A file-like-object opened in binary mode - that is containing
             bytes rather than characters. The root element of the XML should
             be a <gpx> element containing a version attribute. GPX versions
             1.1 is supported.

        gpxns: The XML namespace for GPX in Clarke notation (i.e. delimited
             by curly braces). If None, (the default) the namespace used in
             the document will be determined automatically.
    """"""
    tree = etree.parse(xml)
    gpx_element = tree.getroot()
    return parse_gpx(gpx_element, gpxns=gpxns)"
848,"def parse_gpx(gpx_element, gpxns=None):
    """"""Parse a GPX file into a GpxModel.

    Args:
        xml: A file-like-object opened in binary mode - that is containing
             bytes rather than characters. The root element of the XML should
             be a <gpx> element containing a version attribute. GPX versions
             1.0 is supported.

    Returns:
        A GpxModel representing the data from the supplies xml.

    Raises:
        ValueError: The supplied XML could not be parsed as GPX.
    """"""
    gpxns = gpxns if gpxns is not None else determine_gpx_namespace(gpx_element)

    if gpx_element.tag != gpxns+'gpx':
        raise ValueError(""No gpx root element"")

    get_text = lambda tag: optional_text(gpx_element, gpxns+tag)

    version = gpx_element.attrib['version']

    if not version.startswith('1.0'):
        raise ValueError(""Not a GPX 1.0 file"")

    creator = gpx_element.attrib['creator']

    name = get_text('name')
    description = get_text('desc')

    author_name = get_text('author')
    email = get_text('email')
    author = Person(author_name, email)

    url = get_text('url')
    urlname = get_text('urlname')
    links = make_links(url, urlname)

    time = get_text('time')
    keywords = get_text('keywords')

    bounds_element = gpx_element.find(gpxns+'bounds')
    bounds = nullable(parse_bounds)(bounds_element)

    metadata = Metadata(name=name, description=description, author=author,
               links=links, time=time, keywords=keywords, bounds=bounds)

    waypoint_elements = gpx_element.findall(gpxns+'wpt')
    waypoints = [parse_waypoint(waypoint_element, gpxns) for waypoint_element in waypoint_elements]

    route_elements = gpx_element.findall(gpxns+'rte')
    routes = [parse_route(route_element, gpxns) for route_element in route_elements]

    track_elements = gpx_element.findall(gpxns+'trk')
    tracks = [parse_track(track_element, gpxns) for track_element in track_elements]

    # TODO : Private elements

    gpx_model  = GpxModel(creator, metadata, waypoints, routes, tracks)

    return gpx_model"
849,"def add_log_handler(log, handler=None, debug=None, fmt=None):
    """"""为一个 :class:`logging.Logger` 的实例增加 handler。

    :param Logger log: 需要处理的 :class:`logging.Logger` 的实例。
    :param Handler handler: 一个 :class:`logging.Handler` 的实例。
    :param int debug: Debug 级别。
    :param str fmt: Handler 的 Formatter。

    """"""
    if debug:
        log.setLevel(debug)
    if handler:
        # if not fmt:
        #     fmt = __LOG_FMT
        if fmt:
            handler.setFormatter(fmt)
        log.addHandler(handler)"
850,"def __wrap(self, func):
        '''This decorator overrides the default arguments of a function.

        For each keyword argument in the function, the decorator first checks
        if the argument has been overridden by the caller, and uses that value instead if so.

        If not, the decorator consults the Preset object for an override value.

        If both of the above cases fail, the decorator reverts to the function's native
        default parameter value.
        '''

        def deffunc(*args, **kwargs):
            '''The decorated function'''
            # Get the list of function arguments
            if hasattr(inspect, 'signature'):
                # Python 3.5
                function_args = inspect.signature(func).parameters

            else:
                function_args = inspect.getargspec(func).args

            # Construct a dict of those kwargs which appear in the function
            filtered_kwargs = kwargs.copy()

            # look at all relevant keyword arguments for this function
            for param in function_args:

                if param in kwargs:
                    # Did the user override the default?
                    filtered_kwargs[param] = kwargs[param]

                elif param in self._defaults:
                    # Do we have a clobbering value in the default dict?
                    filtered_kwargs[param] = self._defaults[param]

            # Call the function with the supplied args and the filtered kwarg dict
            return func(*args, **filtered_kwargs)  # pylint: disable=W0142

        wrapped = functools.update_wrapper(deffunc, func)

        # force-mangle the docstring here
        wrapped.__doc__ = ('WARNING: this function has been modified by the Presets '
                           'package.\nDefault parameter values described in the '
                           'documentation below may be inaccurate.\n\n{}'.format(wrapped.__doc__))
        return wrapped"
851,"def _sumDiceRolls(self, rollList):
        """"""convert from dice roll structure to a single integer result""""""
        if isinstance(rollList, RollList):
            self.rolls.append(rollList)
            return rollList.sum()
        else:
            return rollList"
852,"def _re_flatten(p):
    ''' Turn all capturing groups in a regular expression pattern into
        non-capturing groups. '''
    if '(' not in p: return p
    return re.sub(r'(\\*)(\(\?P<[^>]*>|\((?!\?))',
        lambda m: m.group(0) if len(m.group(1)) % 2 else m.group(1) + '(?:', p)"
853,"def cookies(self):
        """""" Cookies parsed into a :class:`FormsDict`. Signed cookies are NOT
            decoded. Use :meth:`get_cookie` if you expect signed cookies. """"""
        cookies = SimpleCookie(self.environ.get('HTTP_COOKIE','')).values()
        if len(cookies) > self.MAX_PARAMS:
            raise HTTPError(413, 'Too many cookies')
        return FormsDict((c.key, c.value) for c in cookies)"
854,"def query(self):
        ''' The :attr:`query_string` parsed into a :class:`FormsDict`. These
            values are sometimes called ""URL arguments"" or ""GET parameters"", but
            not to be confused with ""URL wildcards"" as they are provided by the
            :class:`Router`. '''
        get = self.environ['bottle.get'] = FormsDict()
        pairs = _parse_qsl(self.environ.get('QUERY_STRING', ''))
        if len(pairs) > self.MAX_PARAMS:
            raise HTTPError(413, 'Too many parameters')
        for key, value in pairs:
            get[key] = value
        return get"
855,"def copy(self):
        ''' Returns a copy of self. '''
        # TODO
        copy = Response()
        copy.status = self.status
        copy._headers = dict((k, v[:]) for (k, v) in self._headers.items())
        return copy"
856,"def annotated_references(obj):
    """"""
    Return known information about references held by the given object.

    Returns a mapping from referents to lists of descriptions.  Note that there
    may be more than one edge leading to any particular referent; hence the
    need for a list.  Descriptions are currently strings.

    """"""
    references = KeyTransformDict(transform=id, default_factory=list)
    for type_ in type(obj).__mro__:
        if type_ in type_based_references:
            type_based_references[type_](obj, references)

    add_attr(obj, ""__dict__"", references)
    add_attr(obj, ""__class__"", references)
    if isinstance(obj, type):
        add_attr(obj, ""__mro__"", references)

    return references"
857,"def object_annotation(obj):
    """"""
    Return a string to be used for Graphviz nodes.  The string
    should be short but as informative as possible.

    """"""
    # For basic types, use the repr.
    if isinstance(obj, BASE_TYPES):
        return repr(obj)
    if type(obj).__name__ == 'function':
        return ""function\\n{}"".format(obj.__name__)
    elif isinstance(obj, types.MethodType):
        if six.PY2:
            im_class = obj.im_class
            if im_class is None:
                im_class_name = ""<None>""
            else:
                im_class_name = im_class.__name__

            try:
                func_name = obj.__func__.__name__
            except AttributeError:
                func_name = ""<anonymous>""
            return ""instancemethod\\n{}.{}"".format(
                im_class_name,
                func_name,
            )
        else:
            try:
                func_name = obj.__func__.__qualname__
            except AttributeError:
                func_name = ""<anonymous>""
            return ""instancemethod\\n{}"".format(func_name)
    elif isinstance(obj, list):
        return ""list[{}]"".format(len(obj))
    elif isinstance(obj, tuple):
        return ""tuple[{}]"".format(len(obj))
    elif isinstance(obj, dict):
        return ""dict[{}]"".format(len(obj))
    elif isinstance(obj, types.ModuleType):
        return ""module\\n{}"".format(obj.__name__)
    elif isinstance(obj, type):
        return ""type\\n{}"".format(obj.__name__)
    elif six.PY2 and isinstance(obj, types.InstanceType):
        return ""instance\\n{}"".format(obj.__class__.__name__)
    elif isinstance(obj, weakref.ref):
        referent = obj()
        if referent is None:
            return ""weakref (dead referent)""
        else:
            return ""weakref to id 0x{:x}"".format(id(referent))
    elif isinstance(obj, types.FrameType):
        filename = obj.f_code.co_filename
        if len(filename) > FRAME_FILENAME_LIMIT:
            filename = ""..."" + filename[-(FRAME_FILENAME_LIMIT-3):]
        return ""frame\\n{}:{}"".format(
            filename,
            obj.f_lineno,
        )
    else:
        return ""object\\n{}.{}"".format(
            type(obj).__module__,
            type(obj).__name__,
        )"
858,"def disttar(target, source, env):
        """"""tar archive builder""""""

        import tarfile

        env_dict = env.Dictionary()

        if env_dict.get(""DISTTAR_FORMAT"") in [""gz"", ""bz2""]:
                tar_format = env_dict[""DISTTAR_FORMAT""]
        else:
                tar_format = """"

        # split the target directory, filename, and stuffix
        base_name = str(target[0]).split('.tar')[0]
        (target_dir, dir_name) = os.path.split(base_name)

        # create the target directory if it does not exist
        if target_dir and not os.path.exists(target_dir):
                os.makedirs(target_dir)

        # open our tar file for writing
        print >> sys.stderr, 'DistTar: Writing %s' % str(target[0])
        print >> sys.stderr, '  with contents: %s' % [str(s) for s in source]
        tar = tarfile.open(str(target[0]), ""w:%s"" % tar_format)

        # write sources to our tar file
        for item in source:
                item = str(item)
                sys.stderr.write(""."")
                #print ""Adding to TAR file: %s/%s"" % (dir_name,item)
                tar.add(item,'%s/%s' % (dir_name,item))

        # all done
        sys.stderr.write(""\n"") #print ""Closing TAR file""
        tar.close()"
859,"def disttar_suffix(env, sources):
        """"""tar archive suffix generator""""""

        env_dict = env.Dictionary()
        if env_dict.has_key(""DISTTAR_FORMAT"") and env_dict[""DISTTAR_FORMAT""] in [""gz"", ""bz2""]:
                return "".tar."" + env_dict[""DISTTAR_FORMAT""]
        else:
                return "".tar"""
860,"def generate(env):
    """"""
    Add builders and construction variables for the DistTar builder.
    """"""

    disttar_action=SCons.Action.Action(disttar, disttar_string)
    env['BUILDERS']['DistTar'] =  Builder(
            action=disttar_action
            , emitter=disttar_emitter
            , suffix = disttar_suffix
            , target_factory = env.fs.Entry
    )

    env.AppendUnique(
        DISTTAR_FORMAT = 'gz'
    )"
861,"def ensure_table(self, cls):
        """"""Ensure table's existence - as per the gludb spec.""""""
        id_len = len(uuid())
        index_names = cls.index_names() or []
        cols = [
            'id char(%d) primary key' % (id_len,),
            'value jsonb'
        ] + [
            name + ' text' for name in index_names
        ]

        table_name = cls.get_table_name()

        with self._conn() as conn:
            with conn.cursor() as cur:
                cur.execute('create table if not exists %s (%s);' % (
                    table_name,
                    ','.join(cols)
                ))
                for name in index_names:
                    cur.execute('create index if not exists %s on %s(%s);' % (
                        table_name + '_' + name + '_idx',
                        table_name,
                        name
                    ))"
862,"def find_one(self, cls, id):
        """"""Find single keyed row - as per the gludb spec.""""""
        found = self.find_by_index(cls, 'id', id)
        return found[0] if found else None"
863,"def find_by_index(self, cls, index_name, value):
        """"""Find all rows matching index query - as per the gludb spec.""""""
        cur = self._conn().cursor()

        # psycopg2 supports using Python formatters for queries
        # we also request our JSON as a string for the from_data calls
        query = 'select id, value::text from {0} where {1} = %s;'.format(
            cls.get_table_name(),
            index_name
        )

        found = []
        with self._conn() as conn:
            with conn.cursor() as cur:
                cur.execute(query, (value,))
                for row in cur:
                    id, data = str(row[0]).strip(), row[1]
                    obj = cls.from_data(data)
                    assert id == obj.id
                    found.append(obj)

        return found"
864,"def save(self, obj):
        """"""Save current instance - as per the gludb spec.""""""
        cur = self._conn().cursor()

        tabname = obj.__class__.get_table_name()

        index_names = obj.__class__.index_names() or []

        col_names = ['id', 'value'] + index_names
        value_holders = ['%s'] * len(col_names)
        updates = ['%s = EXCLUDED.%s' % (cn, cn) for cn in col_names[1:]]

        if not obj.id:
            id = uuid()
            obj.id = id

        query = 'insert into {0} ({1}) values ({2}) on conflict(id) do update set {3};'.format(
            tabname,
            ','.join(col_names),
            ','.join(value_holders),
            ','.join(updates),
        )

        values = [obj.id, obj.to_data()]

        index_vals = obj.indexes() or {}
        values += [index_vals.get(name, 'NULL') for name in index_names]

        with self._conn() as conn:
            with conn.cursor() as cur:
                cur.execute(query, tuple(values))"
865,"def delete(self, obj):
        """"""Required functionality.""""""
        del_id = obj.get_id()
        if not del_id:
            return

        cur = self._conn().cursor()

        tabname = obj.__class__.get_table_name()
        query = 'delete from {0} where id = %s;'.format(tabname)

        with self._conn() as conn:
            with conn.cursor() as cur:
                cur.execute(query, (del_id,))"
866,"def authenticated_get(username, password, url, verify=True):
    """"""
    Perform an authorized query to the url, and return the result
    """"""
    try:
        response = requests.get(url, auth=(username, password), verify=verify)
        if response.status_code == 401:
            raise BadCredentialsException(
                ""Unable to authenticate user %s to %s with password provided!""
                % (username, url))
    except requests.exceptions.SSLError:
        raise CertificateException(""Unable to verify certificate at %s!"" % url)
    return response.content"
867,"def cleaned_request(request_type, *args, **kwargs):
    """""" Perform a cleaned requests request """"""
    s = requests.Session()
    # this removes netrc checking
    s.trust_env = False
    return s.request(request_type, *args, **kwargs)"
868,"def download_to_bytesio(url):
    """""" Return a bytesio object with a download bar """"""
    logger.info(""Downloading url: {0}"".format(url))
    r = cleaned_request('get', url, stream=True)
    stream = io.BytesIO()
    total_length = int(r.headers.get('content-length'))
    for chunk in progress.bar(r.iter_content(chunk_size=1024), expected_size=(total_length/1024) + 1):
        if chunk:
            stream.write(chunk)
    stream.seek(0)
    return stream"
869,"def add(one, two=4, three=False):
    ''' This function adds two number.

    :param one: first number to add
    :param two: second number to add
    :rtype: int
    '''
    s = str(int(one) + int(two))

    logging.debug('logging sum from hello.py:' + s)
    print 'printing sum from hello.py:', s

    return s"
870,"def queue(self):
        """"""Message queue queue.""""""
        with self.connection_pool.acquire(block=True) as conn:
            return Q(
                self.routing_key,
                exchange=self.exchange,
                routing_key=self.routing_key
            )(conn)"
871,"def exists(self):
        """"""Test if this queue exists in the AMQP store.

        Note: This doesn't work with redis as declaring queues has not effect
        except creating the exchange.

        :returns: True if the queue exists, else False.
        :rtype: bool
        """"""
        try:
            queue = self.queue
            queue.queue_declare(passive=True)
        except NotFound:
            return False
        except ChannelError as e:
            if e.reply_code == '404':
                return False
            raise e
        return True"
872,"def producer(self, conn):
        """"""Get a consumer for a connection.""""""
        return Producer(
            conn,
            exchange=self.exchange,
            routing_key=self.routing_key,
            auto_declare=True,
        )"
873,"def consumer(self, conn):
        """"""Get a consumer for a connection.""""""
        return Consumer(
            connection=conn,
            queue=self.queue.name,
            exchange=self.exchange.name,
            exchange_type=self.exchange.type,
            durable=self.exchange.durable,
            auto_delete=self.exchange.auto_delete,
            routing_key=self.routing_key,
            no_ack=self.no_ack,
        )"
874,"def create_producer(self):
        """"""Context manager that yields an instance of ``Producer``.""""""
        with self.connection_pool.acquire(block=True) as conn:
            yield self.producer(conn)"
875,"def create_consumer(self):
        """"""Context manager that yields an instance of ``Consumer``.""""""
        with self.connection_pool.acquire(block=True) as conn:
            yield self.consumer(conn)"
876,"def publish(self, events):
        """"""Publish events.""""""
        assert len(events) > 0
        with self.create_producer() as producer:
            for event in events:
                producer.publish(event)"
877,"def consume(self, payload=True):
        """"""Consume events.""""""
        with self.create_consumer() as consumer:
            for msg in consumer.iterqueue():
                yield msg.payload if payload else msg"
878,"def get_initial(self, *args, **kwargs):
        """"""
        Gathers initial form values from user and profile objects
        suitable for using as form's initial data.
        """"""
        initial = {}
        for field in self.fields:
            value = None
            if hasattr(self.user, field):
                value = getattr(self.user, field)
            if hasattr(self.profile, field):
                value = getattr(self.profile, field)
            if value:
                initial.update({
                    field: value
                })

        if hasattr(self.profile, 'dob'):
            dob = self.profile.dob
            if dob:
                if 'dob_day' in self.fields:
                    initial.update({
                        'dob_day': dob.day
                    })
                if 'dob_month' in self.fields:
                    initial.update({
                        'dob_month': dob.month
                    })
                if 'dob_year' in self.fields:
                    initial.update({
                        'dob_year': dob.year
                    })

        return initial"
879,"def save(self, *args, **kwargs):
        """"""
        This method should be called when is_valid is true to save
        relevant fields to user and profile models.
        """"""
        for key, value in self.cleaned_data.items():
            if value != None:
                if hasattr(self.user, key):
                    setattr(self.user, key, value)
                if hasattr(self.profile, key):
                    setattr(self.profile, key, value)

        # set password
        if 'password1' in self.cleaned_data:
            if self.cleaned_data['password1']:
                self.user.set_password(self.cleaned_data['password1'])

        # set dob
        if 'dob_day' in self.cleaned_data and 'dob_month' in self.\
                cleaned_data and 'dob_year' in self.cleaned_data:
            self.profile.dob = self._gen_dob()

        self.user.save()
        self.profile.save()"
880,"def clean_username(self):
        """"""
        Validate that the username is alphanumeric and is not already
        in use. Don't fail if users username is provided.
        """"""
        user = None
        try:
            user = User.objects.get(username__iexact=self.\
                    cleaned_data['username'])
        except User.DoesNotExist:
            return self.cleaned_data['username']

        if user:
            if user.username == self.user.username:
                return self.cleaned_data['username']

        raise forms.ValidationError(_(\
                ""A user with that username already exists.""))"
881,"def clean(self):
        """"""
        Verifiy that the values entered into the two password fields
        match. Note that an error here will end up in
        ``non_field_errors()`` because it doesn't apply to a single
        field.
        """"""
        if 'dob_day' in self.cleaned_data and 'dob_month' in \
                self.cleaned_data and 'dob_year' in self.cleaned_data:
                try:
                    self._gen_dob()
                except ValueError:
                    self._errors['dob_day'] = (_(\
                            ""You provided an invalid date.""),)

        if 'password1' in self.cleaned_data and 'password2' in \
                self.cleaned_data:
            if self.cleaned_data['password1'] != \
                    self.cleaned_data['password2']:
                raise forms.ValidationError(_(\
                        ""The two password fields didn't match.""))

        return self.cleaned_data"
882,"def request(self,message,message_type):
        """"""
        Send a request message of the given type
        
        Args:
            - message: the message to publish
            - message_type: the type of message being sent
        """"""
        if message_type == MULTIPART:
            raise Exception(""Unsupported request type"")
            
        super(Requestor,self).send(message,message_type)"
883,"def run_as_admin(command, cwd=None, environ=None):
  """"""
  Runs a command as an admin in the specified *cwd* and *environ*.
  On Windows, this creates a temporary directory where this information
  is stored temporarily so that the new process can launch the proper
  subprocess.
  """"""

  if isinstance(command, str):
    command = shlex.split(command)

  if os.name == 'nt':
    return _run_as_admin_windows(command, cwd, environ)

  elif os.name == 'posix':
    command = ['sudo', '-E'] + list(command)
    sys.exit(subprocess.call(command))

  else:
    raise RuntimeError('Unsupported os: {!r}'.format(os.name))"
884,"def add_body_part(self, key, data, mime_type, size=None):
    """"""Adds data to the HTTP request body.
   
    If more than one part is added, this is assumed to be a mime-multipart
    request. This method is designed to create MIME 1.0 requests as specified
    in RFC 1341.

    Args:
      data: str or a file-like object containing a part of the request body.
      mime_type: str The MIME type describing the data
      size: int Required if the data is a file like object. If the data is a
            string, the size is calculated so this parameter is ignored.
    """"""
    if isinstance(data, str):
      size = len(data)
    if hasattr(data, ""fileno""):
      size = os.fstat(data.fileno())[stat.ST_SIZE]
    if size is None:
      # TODO: support chunked transfer if some of the body is of unknown size.
      raise UnknownSize('Each part of the body must have a known size.')
    if 'Content-Length' in self.headers:
      content_length = int(self.headers['Content-Length'])
    else:
      content_length = 0
    # If this is the first part added to the body, then this is not a multipart
    # request.
    boundary_string = '\r\n--%s\r\n' % (MIME_BOUNDARY,)
    self._body_parts.append(boundary_string)
    content_length += len(boundary_string) + size
    # Include the mime type of this part.
    cd = 'Content-Disposition: form-data; name=""%s""' % key
    mt = mime_type
    if hasattr(data, ""fileno""):
        cd += '; filename=""%s""' % data.name.split('/')[-1]
        mt = mimetypes.guess_type(data.name)[0] or 'application/octet-stream'
    cd += '\r\n'
    type_string = 'Content-Type: %s\r\n\r\n' % (mt)
    self._body_parts.append(cd)
    self._body_parts.append(type_string)
    content_length += len(type_string) + len(cd)
    self._body_parts.append(data)
    self.headers['Content-Length'] = str(content_length)"
885,"def _copy(self):
    """"""Creates a deep copy of this request.""""""
    copied_uri = Uri(self.uri.scheme, self.uri.host, self.uri.port,
                     self.uri.path, self.uri.query.copy())
    new_request = HttpRequest(uri=copied_uri, method=self.method,
                              headers=self.headers.copy())
    new_request._body_parts = self._body_parts[:]
    return new_request"
886,"def _get_relative_path(self):
    """"""Returns the path with the query parameters escaped and appended.""""""
    param_string = self._get_query_string()
    if self.path is None:
      path = '/'
    else:
      path = self.path
    if param_string:
      return '?'.join([path, param_string])
    else:
      return path"
887,"def modify_request(self, http_request=None):
    """"""Sets HTTP request components based on the URI.""""""
    if http_request is None:
      http_request = HttpRequest()
    if http_request.uri is None:
      http_request.uri = Uri()
    # Determine the correct scheme.
    if self.scheme:
      http_request.uri.scheme = self.scheme
    if self.port:
      http_request.uri.port = self.port
    if self.host:
      http_request.uri.host = self.host
    # Set the relative uri path
    if self.path:
      http_request.uri.path = self.path
    if self.query:
      http_request.uri.query = self.query.copy()
    return http_request"
888,"def parse_uri(uri_string):
    """"""Creates a Uri object which corresponds to the URI string.
 
    This method can accept partial URIs, but it will leave missing
    members of the Uri unset.
    """"""
    parts = urlparse.urlparse(uri_string)
    uri = Uri()
    if parts[0]:
      uri.scheme = parts[0]
    if parts[1]:
      host_parts = parts[1].split(':')
      if host_parts[0]:
        uri.host = host_parts[0]
      if len(host_parts) > 1:
        uri.port = int(host_parts[1])
    if parts[2]:
      uri.path = parts[2]
    if parts[4]:
      param_pairs = parts[4].split('&')
      for pair in param_pairs:
        pair_parts = pair.split('=')
        if len(pair_parts) > 1:
          uri.query[urllib.unquote_plus(pair_parts[0])] = (
              urllib.unquote_plus(pair_parts[1]))
        elif len(pair_parts) == 1:
          uri.query[urllib.unquote_plus(pair_parts[0])] = None
    return uri"
889,"def _get_connection(self, uri, headers=None):
    """"""Opens a socket connection to the server to set up an HTTP request.
    
    Args:
      uri: The full URL for the request as a Uri object.
      headers: A dict of string pairs containing the HTTP headers for the
          request.
    """"""
    connection = None
    if uri.scheme == 'https':
      if not uri.port:
        connection = httplib.HTTPSConnection(uri.host)
      else:
        connection = httplib.HTTPSConnection(uri.host, int(uri.port))
    else:
      if not uri.port:
        connection = httplib.HTTPConnection(uri.host)
      else:
        connection = httplib.HTTPConnection(uri.host, int(uri.port))
    return connection"
890,"def _http_request(self, method, uri, headers=None, body_parts=None):
    """"""Makes an HTTP request using httplib.
   
    Args:
      method: str example: 'GET', 'POST', 'PUT', 'DELETE', etc.
      uri: str or atom.http_core.Uri
      headers: dict of strings mapping to strings which will be sent as HTTP 
               headers in the request.
      body_parts: list of strings, objects with a read method, or objects
                  which can be converted to strings using str. Each of these
                  will be sent in order as the body of the HTTP request.
    """"""
    if isinstance(uri, (str, unicode)):
      uri = Uri.parse_uri(uri)
    connection = self._get_connection(uri, headers=headers)
    if self.debug:
      connection.debuglevel = 1

    if connection.host != uri.host:
      connection.putrequest(method, str(uri))
    else:
      connection.putrequest(method, uri._get_relative_path())

    # Overcome a bug in Python 2.4 and 2.5
    # httplib.HTTPConnection.putrequest adding
    # HTTP request header 'Host: www.google.com:443' instead of
    # 'Host: www.google.com', and thus resulting the error message
    # 'Token invalid - AuthSub token has wrong scope' in the HTTP response.
    if (uri.scheme == 'https' and int(uri.port or 443) == 443 and
        hasattr(connection, '_buffer') and
        isinstance(connection._buffer, list)):
      header_line = 'Host: %s:443' % uri.host
      replacement_header_line = 'Host: %s' % uri.host
      try:
        connection._buffer[connection._buffer.index(header_line)] = (
            replacement_header_line)
      except ValueError:  # header_line missing from connection._buffer
        pass

    # Send the HTTP headers.
    for header_name, value in headers.iteritems():
      connection.putheader(header_name, value)
    connection.endheaders()

    # If there is data, send it in the request.
    if body_parts:
      for part in body_parts:
        _send_data_part(part, connection)

    # Return the HTTP Response from the server.
    return connection.getresponse()"
891,"def seek(self, offset, mode='set', renew=False):
    """"""
    Moves the cursor of the Scanner to or by *offset* depending on the *mode*.
    Is is similar to a file's `seek()` function, however the *mode* parameter
    also accepts the string-mode values `'set'`, `'cur'` and `'end'`.

    Note that even for the `'end'` mode, the *offset* must be negative to
    actually reach back up from the end of the file.

    If *renew* is set to True, the line and column counting will always begin
    from the start of the file. Keep in mind that this could can be very slow
    because it has to go through each and every character until the desired
    position is reached.

    Otherwise, if *renew* is set to False, it will be decided if counting from
    the start is shorter than counting from the current cursor position.
    """"""

    mapping = {os.SEEK_SET: 'set', os.SEEK_CUR: 'cur', os.SEEK_END: 'end'}
    mode = mapping.get(mode, mode)
    if mode not in ('set', 'cur', 'end'):
      raise ValueError('invalid mode: ""{}""'.format(mode))

    # Translate the other modes into the 'set' mode.
    if mode == 'end':
      offset = len(self.text) + offset
      mode = 'set'
    elif mode == 'cur':
      offset = self.index + offset
      mode = 'set'

    assert mode == 'set'
    if offset < 0:
      offset = 0
    elif offset > len(self.text):
      offset = len(self.text) + 1

    if self.index == offset:
      return

    # Figure which path is shorter:
    # 1) Start counting from the beginning of the file,
    if offset <= abs(self.index - offset):
      text, index, lineno, colno = self.text, 0, 1, 0
      while index != offset:
        # Find the next newline in the string.
        nli = text.find('\n', index)
        if nli >= offset or nli < 0:
          colno = offset - index
          index = offset
          break
        else:
          colno = 0
          lineno += 1
          index = nli + 1

    # 2) or step from the current position of the cursor.
    else:
      text, index, lineno, colno = self.text, self.index, self.lineno, self.colno

      if offset < index:  # backwards
        while index != offset:
          nli = text.rfind('\n', 0, index)
          if nli < 0 or nli <= offset:
            if text[offset] == '\n':
              assert (offset - nli) == 0, (offset, nli)
              nli = text.rfind('\n', 0, index-1)
              lineno -= 1
            colno = offset - nli - 1
            index = offset
            break
          else:
            lineno -= 1
            index = nli - 1
      else:  # forwards
        while index != offset:
          nli = text.find('\n', index)
          if nli < 0 or nli >= offset:
            colno = offset - index
            index = offset
          else:
            lineno += 1
            index = nli + 1

    assert lineno >= 1
    assert colno >= 0
    assert index == offset
    self.index, self.lineno, self.colno = index, lineno, colno"
892,"def next(self):
    "" Move on to the next character in the text. ""

    char = self.char
    if char == '\n':
      self.lineno += 1
      self.colno = 0
    else:
      self.colno += 1
    self.index += 1
    return self.char"
893,"def readline(self):
    "" Reads a full line from the scanner and returns it. ""

    start = end = self.index
    while end < len(self.text):
      if self.text[end] == '\n':
        end += 1
        break
      end += 1
    result = self.text[start:end]
    self.index = end
    if result.endswith('\n'):
      self.colno = 0
      self.lineno += 1
    else:
      self.colno += end - start
    return result"
894,"def match(self, regex, flags=0):
    """"""
    Matches the specified *regex* from the current character of the *scanner*
    and returns the result. The Scanners column and line numbers are updated
    respectively.

    # Arguments
    regex (str, Pattern): The regex to match.
    flags (int): The flags to use when compiling the pattern.
    """"""

    if isinstance(regex, str):
      regex = re.compile(regex, flags)
    match = regex.match(self.text, self.index)
    if not match:
      return None
    start, end = match.start(), match.end()
    lines = self.text.count('\n', start, end)
    self.index = end
    if lines:
      self.colno = end - self.text.rfind('\n', start, end) - 1
      self.lineno += lines
    else:
      self.colno += end - start
    return match"
895,"def getmatch(self, regex, group=0, flags=0):
    """"""
    The same as #Scanner.match(), but returns the captured group rather than
    the regex match object, or None if the pattern didn't match.
    """"""

    match = self.match(regex, flags)
    if match:
      return match.group(group)
    return None"
896,"def restore(self, cursor):
    "" Moves the scanner back (or forward) to the specified cursor location. ""

    if not isinstance(cursor, Cursor):
      raise TypeError('expected Cursor object', type(cursor))
    self.index, self.lineno, self.colno = cursor"
897,"def update(self):
    """"""
    Updates the #rules_map dictionary and #skippable_rules list based on the
    #rules list. Must be called after #rules or any of its items have been
    modified. The same rule name may appear multiple times.

    # Raises
    TypeError: if an item in the `rules` list is not a rule.
    """"""

    self.rules_map = {}
    self.skippable_rules = []
    for rule in self.rules:
      if not isinstance(rule, Rule):
        raise TypeError('item must be Rule instance', type(rule))
      self.rules_map.setdefault(rule.name, []).append(rule)
      if rule.skip:
        self.skippable_rules.append(rule)"
898,"def expect(self, *names):
    """"""
    Checks if the current #token#s type name matches with any of the specified
    *names*. This is useful for asserting multiple valid token types at a
    specific point in the parsing process.

    # Arguments
    names (str): One or more token type names. If zero are passed,
      nothing happens.

    # Raises
    UnexpectedTokenError: If the current #token#s type name does not match
      with any of the specified *names*.
    """"""

    if not names:
      return
    if not self.token or self.token.type not in names:
      raise UnexpectedTokenError(names, self.token)"
899,"def accept(self, *names, **kwargs):
    """"""
    Extracts a token of one of the specified rule names and doesn't error if
    unsuccessful. Skippable tokens might still be skipped by this method.

    # Arguments
    names (str): One or more token names that are accepted.
    kwargs: Additional keyword arguments for #next().

    # Raises
    ValueError: if a rule with the specified name doesn't exist.
    """"""

    return self.next(*names, as_accept=True, **kwargs)"
900,"def next(self, *expectation, **kwargs):
    """"""
    Parses the next token from the input and returns it. The new token can be
    accessed from the #token attribute after the method was called.

    If one or more arguments are specified, they must be rule names that are to
    be expected at the current position. They will be attempted to be matched
    first (in the specicied order). If the expectation could not be met, an
    #UnexpectedTokenError is raised.

    An expected Token will not be skipped, even if its rule defines it so.

    # Arguments
    expectation (str): The name of one or more rules that are expected from the
      current position of the parser. If empty, the first matching token of ALL
      rules will be returned. In this case, skippable tokens will be skipped.
    as_accept (bool): If passed True, this method behaves the same as the
      #accept() method. The default value is #False.
    weighted (bool): If passed True, the tokens specified with *expectations*
      are checked first, effectively giving them a higher priority than other
      they would have from the order in the #rules list. The default value is
      #False.

    # Raises
    ValueError: if an expectation doesn't match with a rule name.
    UnexpectedTokenError: Ff an expectation is given and the expectation
      wasn't fulfilled. Only when *as_accept* is set to #False.
    TokenizationError: if a token could not be generated from the current
      position of the Scanner.
    """"""

    as_accept = kwargs.pop('as_accept', False)
    weighted = kwargs.pop('weighted', False)
    for key in kwargs:
      raise TypeError('unexpected keyword argument {0!r}'.format(key))

    if self.token and self.token.type == eof:
      if not as_accept and expectation and eof not in expectation:
        raise UnexpectedTokenError(expectation, self.token)
      elif as_accept and eof in expectation:
        return self.token
      elif as_accept:
        return None
      return self.token

    token = None
    while token is None:
      # Stop if we reached the end of the input.
      cursor = self.scanner.cursor
      if not self.scanner:
        token = Token(eof, cursor, None, None)
        break

      value = None

      # Try to match the expected tokens.
      if weighted:
        for rule_name in expectation:
          if rule_name == eof:
            continue
          rules = self.rules_map.get(rule_name)
          if rules is None:
            raise ValueError('unknown rule', rule_name)
          for rule in rules:
            value = rule.tokenize(self.scanner)
            if value:
              break
          if value:
            break
          self.scanner.restore(cursor)

      # Match the rest of the rules, but only if we're not acting
      # like the accept() method that doesn't need the next token
      # for raising an UnexpectedTokenError.
      if not value:
        if as_accept and weighted:
          # Check only skippable rules if we're only trying to accept
          # a certain token type and may consume any skippable tokens
          # until then.
          check_rules = self.skippable_rules
        else:
          check_rules = self.rules
        for rule in check_rules:
          if weighted and expectation and rule.name in expectation:
            # Skip rules that we already tried.
            continue
          value = rule.tokenize(self.scanner)
          if value:
            break
          self.scanner.restore(cursor)

      if not value:
        if as_accept:
          return None
        token = Token(None, cursor, self.scanner.char, None)
      else:
        assert rule, ""we should have a rule by now""
        if type(value) is not Token:
          if isinstance(value, tuple):
            value, string_repr = value
          else:
            string_repr = None
          value = Token(rule.name, cursor, value, string_repr)
        token = value

        expected = rule.name in expectation
        if not expected and rule.skip:
          # If we didn't expect this rule to match, and if its skippable,
          # just skip it. :-)
          token = None
        elif not expected and as_accept:
          # If we didn't expect this rule to match but are just accepting
          # instead of expecting, restore to the original location and stop.
          self.scanner.restore(cursor)
          return None

    self.token = token
    if as_accept and token and token.type == eof:
      if eof in expectation:
        return token
      return None

    if token.type is None:
      raise TokenizationError(token)
    if not as_accept and expectation and token.type not in expectation:
      raise UnexpectedTokenError(expectation, token)
    assert not as_accept or (token and token.type in expectation)
    return token"
901,"def append(self, event, help=""""):
        """"""Creates a new event. `event` may be iterable or string

        Args:
            event (str): Name of event to declare

        Kwrgs:
            help (str): Help string for the event

        Raises:
            TypeError

        **Please** describe the event and its calling arguments in the help
        string.
        """"""
        if isinstance(event, str):
            self._events[event] = HookList(is_waterfall=self.is_waterfall)
            self._help[event] = (help, getframeinfo(stack()[1][0]))

            if not help:
                logger.warning(""Great, don't say anything about your hooks and \
                wait for plugin creators to figure it out."")
        elif isinstance(event, Iterable):
            # Depricated. It does not give the ability to give help string
            # TODO: Remove this
            for name in event:
                self.append(name)
        else:
            raise TypeError(""Invalid event name!"")"
902,"def hook(self, function, event, dependencies):
        """"""Tries to load the hook to the event

        Args:
            function (func): Function that will be called when the event is called

        Kwargs:
            dependencies (str): String or Iterable with modules whose hooks should be called before this one

        Raises:
            NameError

        Note that the dependencies are module-wide, that means that if
        `parent.foo` and `parent.bar` are both subscribed to `example` event
        and `child` enumerates `parent` as dependcy, **both** `foo` and `bar`
        must be called in order for the dependcy to get resolved.
        """"""
        # Hooks all events (recursively)
        if event is None:
            for e in self._events.keys():
                self.hook(function, e, dependencies)
            return

        # Hook multiple, but specific events (recursively)
        if not isinstance(event, str) and isinstance(event, Iterable):
            for e in event:
                self.hook(function, e, dependencies)
            return

        # Hook a simple event
        event_list = self._events.get(event, None)
        if event_list is None:
            raise NameError(
                ""Invalid key provided '%s'. Valid options: %s""
                % (event, "", "".join(self._events.keys()))
            )
            return

        return event_list.hook(function, dependencies)"
903,"def call(path, *args, encoding=""utf-8"", show_command=False):
    """"""使用 subprocess.check_output 调用 git 命令。

    :param str path: git 仓库文件夹路径。
    :param \*args: git 的附加参数。
    :returns: 错误代码和调用结果。
    :rtype: int
    :rtype: string git 返回的信息，若执行出错则为错误信息。

    """"""
    returncode = 0
    output = None
    try:
        # 2015-10-10 zrong
        # 在 windows 上使用 universal_newlines=True
        # 会导致输出信息为中文时出现编码错误
        # 原因是 check_out 中读入 stdout 内容的 read 方法没有传递编码参数
        # 因此不再使用 universal_newlines=True 这个参数
        # 而改用直接返回 bytes，然后对其解码
        arg_list = get_args(path, *args)
        if show_command:
            print('git call args:', arg_list)
        output = subprocess.check_output(arg_list, 
                stderr=subprocess.STDOUT)
        output = output.decode(encoding=encoding)
    except subprocess.CalledProcessError as err:
        returncode = err.returncode
        output = err.output.decode(encoding=encoding)
    return returncode, output"
904,"def get_args(path, *args, work_tree=True, bare=False):
    """"""获取可被 subprogress 执行的 git 参数 list。

    :param str path: git 仓库文件夹路径。
    :param \*args: git 的附加参数。
    :param bare: 是否视为 bare 库

    """"""
    base = [ 'git' ]
    if path:
        base.append('-C')
        base.append(path)
        if bare:
            base.append('--bare')
            base.append(""--git-dir=""+path)
        else:
            base.append(""--git-dir=""+os.path.join(path, "".git""))
        if work_tree:
            base.append(""--work-tree=""+path)
    for arg in args:
        base.append(arg)
    return base"
905,"def get_branches(path):
    """"""获取当前所有分支名称的列表。

    :param str path: git 仓库文件夹路径。
    :return: 分支名称列表。当前分支位于列表第一项。
    :rtype: list

    """"""
    code, output = call(path, 'branch', '--list')
    if code > 0:
        return None
    branches = output.split('\n')
    newbr = [None]
    for br in branches:
        if br:
            if br[0] == '*':
                newbr[0] = br[2:]
            else:
                newbr.append(br[2:])
    return newbr"
906,"def clone(giturl, gitpath):
    """"""clone 一个 git 库。

    :param str giturl: git 仓库的 url 地址。
    :param str gitpath: git 仓库保存路径。

    """"""
    gitArgs = ['git', 'clone', giturl, gitpath]
    slog.info(' '.join(gitArgs))
    return subprocess.call(gitArgs)"
907,"def get_hash(path, cut=0):
    """"""获取可被 git 的 HEAD 的 sha1 值。

    :param str path: git 仓库文件夹路径。
    :param int cut: 包含的 sha1 值的长度。0代表不剪切。
    :returns: 剪切过的 sha1 的值。
    :rtype: str

    """"""
    code, output = call(path, 'rev-parse', 'HEAD')
    if code > 0:
        return None
    # maybe the string is with a linebreak.
    sha1 = output.strip()
    if cut > 0:
        sha1 = sha1[:7]
    return sha1"
908,"def update_submodules(path, init=True, update=True):
    """"""更新子模块。

    :param str path: git 仓库文件夹路径。
    :param bool init: 是否初始化子模块。
    :param bool update: 是否更新子模块。

    """"""
    succ = None
    if init:
        arg = get_args(path, 'submodule', 'init', work_tree=False)
        slog.info(' '.join(arg))
        succ = subprocess.call(arg)
        if succ>0:
            slog.error('git execute error!')
            return succ
    if update:
        arg = get_args(path, ""submodule"", ""update"", work_tree=False)
        slog.info(' '.join(arg))
        succ = subprocess.call(arg)
        if succ>0:
            slog.error('git execute error!')
            return succ
    return succ"
909,"def print_message(self, message, verbosity_needed=1):
        """""" Prints the message, if verbosity is high enough. """"""
        if self.args.verbosity >= verbosity_needed:
            print(message)"
910,"def error(self, message, code=1):
        """""" Prints the error, and exits with the given code. """"""
        sys.stderr.write(message)
        sys.exit(code)"
911,"def parse_db_settings(self, settings):
        """""" Parse out database settings from filename or DJANGO_SETTINGS_MODULE. """"""
        if settings == 'DJANGO_SETTINGS_MODULE':
            django_settings = os.environ.get('DJANGO_SETTINGS_MODULE')
            self.print_message(""Getting settings file from DJANGO_SETTINGS_MODULE=%s""
                               % django_settings)
            path_pieces = django_settings.split('.')
            path_pieces[-1] = '%s.py' % path_pieces[-1]
            settings = os.path.join(*path_pieces)

        self.print_message(""Parsing settings from settings file '%s'"" % settings)
        parser = DatabaseSettingsParser()
        with open(settings) as settings_file:
            settings_ast = ast.parse(settings_file.read())
            parser.visit(settings_ast)

        try:
            return parser.database_settings['default']
        except KeyError as e:
            self.error(""Missing key or value for: %s\nSettings must be of the form: %s""
                       % (e, self.settings_format))"
912,"def initialize_db_args(self, settings, db_key):
        """""" Initialize connection arguments for postgres commands. """"""
        self.print_message(""Initializing database settings for %s"" % db_key, verbosity_needed=2)

        db_member = self.databases[db_key]

        db_name = settings.get('NAME')
        if db_name and not db_member['name']:
            db_member['name'] = db_name

        db_member['password'] = settings.get('PASSWORD')

        args = []
        for key in ['USER', 'HOST', 'PORT']:
            value = settings.get(key)
            if value:
                self.print_message(""Adding parameter %s"" % key.lower, verbosity_needed=2)
                args.append('--%s=%s' % (key.lower(), value))

        db_member['args'] = args"
913,"def download_file(self, url, filename):
        """""" Download file from url to filename. """"""
        self.print_message(""Downloading to file '%s' from URL '%s'"" % (filename, url))
        try:
            db_file = urllib2.urlopen(url)
            with open(filename, 'wb') as output:
                output.write(db_file.read())
            db_file.close()
        except Exception as e:
            self.error(str(e))
        self.print_message(""File downloaded"")"
914,"def unzip_file_if_necessary(self, source_file):
        """""" Unzip file if zipped. """"""
        if source_file.endswith("".gz""):
            self.print_message(""Decompressing '%s'"" % source_file)
            subprocess.check_call([""gunzip"", ""--force"", source_file])
            source_file = source_file[:-len("".gz"")]
        return source_file"
915,"def download_file_from_url(self, source_app, url):
        """""" Download file from source app or url, and return local filename. """"""
        if source_app:
            source_name = source_app
        else:
            source_name = urlparse.urlparse(url).netloc.replace('.', '_')

        filename = self.create_file_name(source_name)
        self.download_file(url, filename)
        return filename"
916,"def dump_database(self):
        """""" Create dumpfile from postgres database, and return filename. """"""
        db_file = self.create_file_name(self.databases['source']['name'])
        self.print_message(""Dumping postgres database '%s' to file '%s'""
                           % (self.databases['source']['name'], db_file))
        self.export_pgpassword('source')
        args = [
            ""pg_dump"",
            ""-Fc"",
            ""--no-acl"",
            ""--no-owner"",
            ""--dbname=%s"" % self.databases['source']['name'],
            ""--file=%s"" % db_file,
        ]
        args.extend(self.databases['source']['args'])
        subprocess.check_call(args)
        return db_file"
917,"def drop_database(self):
        """""" Drop postgres database. """"""
        self.print_message(""Dropping database '%s'"" % self.databases['destination']['name'])
        self.export_pgpassword('destination')
        args = [
            ""dropdb"",
            ""--if-exists"",
            self.databases['destination']['name'],
        ]
        args.extend(self.databases['destination']['args'])
        subprocess.check_call(args)"
918,"def create_database(self):
        """""" Create postgres database. """"""
        self.print_message(""Creating database '%s'"" % self.databases['destination']['name'])
        self.export_pgpassword('destination')
        args = [
            ""createdb"",
            self.databases['destination']['name'],
        ]
        args.extend(self.databases['destination']['args'])
        for arg in self.databases['destination']['args']:
            if arg[:7] == '--user=':
                args.append('--owner=%s' % arg[7:])
        subprocess.check_call(args)"
919,"def replace_postgres_db(self, file_url):
        """""" Replace postgres database with database from specified source. """"""
        self.print_message(""Replacing postgres database"")

        if file_url:
            self.print_message(""Sourcing data from online backup file '%s'"" % file_url)
            source_file = self.download_file_from_url(self.args.source_app, file_url)
        elif self.databases['source']['name']:
            self.print_message(""Sourcing data from database '%s'""
                               % self.databases['source']['name'])
            source_file = self.dump_database()
        else:
            self.print_message(""Sourcing data from local backup file %s"" % self.args.file)
            source_file = self.args.file

        self.drop_database()
        self.create_database()

        source_file = self.unzip_file_if_necessary(source_file)

        self.print_message(""Importing '%s' into database '%s'""
                           % (source_file, self.databases['destination']['name']))
        args = [
            ""pg_restore"",
            ""--no-acl"",
            ""--no-owner"",
            ""--dbname=%s"" % self.databases['destination']['name'],
            source_file,
        ]
        args.extend(self.databases['destination']['args'])
        subprocess.check_call(args)"
920,"def get_file_url_for_heroku_app(self, source_app):
        """""" Get latest backup URL from heroku pg:backups (or pgbackups). """"""
        self.print_message(""Getting backup url for Heroku app '%s'"" % source_app)
        args = [
            ""heroku"",
            ""pg:backups:url"",
            ""--app=%s"" % source_app,
        ]
        if self.args.use_pgbackups:
            args = [
                ""heroku"",
                ""pgbackups:url"",
                ""--app=%s"" % source_app,
            ]
        return subprocess.check_output(args).strip().decode('ascii')"
921,"def capture_heroku_database(self):
        """""" Capture Heroku database backup. """"""
        self.print_message(""Capturing database backup for app '%s'"" % self.args.source_app)
        args = [
            ""heroku"",
            ""pg:backups:capture"",
            ""--app=%s"" % self.args.source_app,
        ]
        if self.args.use_pgbackups:
            args = [
                ""heroku"",
                ""pgbackups:capture"",
                ""--app=%s"" % self.args.source_app,
                ""--expire"",
            ]
        subprocess.check_call(args)"
922,"def reset_heroku_database(self):
        """""" Reset Heroku database. """"""
        self.print_message(""Resetting database for app '%s'"" % self.args.destination_app)
        args = [
            ""heroku"",
            ""pg:reset"",
            ""--app=%s"" % self.args.destination_app,
            ""DATABASE_URL"",
        ]
        subprocess.check_call(args)"
923,"def replace_heroku_db(self, file_url):
        """""" Replace Heroku database with database from specified source. """"""
        self.print_message(""Replacing database for Heroku app '%s'"" % self.args.destination_app)

        self.reset_heroku_database()

        if file_url:
            self.print_message(""Restoring from URL '%s'"" % file_url)
            args = [
                ""heroku"",
                ""pg:backups:restore"",
                file_url,
                ""--app=%s"" % self.args.destination_app,
                ""DATABASE"",
                ""--confirm"",
                self.args.destination_app,
            ]
            if self.args.use_pgbackups:
                args = [
                    ""heroku"",
                    ""pgbackups:restore"",
                    ""--app=%s"" % self.args.destination_app,
                    ""DATABASE_URL"",
                    ""--confirm"",
                    self.args.destination_app,
                    file_url,
                ]
            subprocess.check_call(args)
        else:
            # TODO perhaps add support for file -> heroku by piping to pg:psql
            self.print_message(""Pushing data from database '%s'"" % self.databases['source']['name'])
            self.print_message(""NOTE: Any postgres authentication settings you passed to paragres ""
                               ""will be ignored.\nIf desired, you can export PG* variables.\n""
                               ""You will be prompted for your psql password."")
            args = [
                ""heroku"",
                ""pg:push"",
                self.databases['source']['name'],
                ""DATABASE_URL"",
                ""--app=%s"" % self.args.destination_app,
            ]
            subprocess.check_call(args)"
924,"def run(self):
        """""" Replace a database with the data from the specified source. """"""
        self.print_message(""\nBeginning database replacement process.\n"")

        if self.args.source_settings:
            settings = self.parse_db_settings(self.args.source_settings)
            self.initialize_db_args(settings, 'source')

        if self.args.settings:
            settings = self.parse_db_settings(self.args.settings)
            self.initialize_db_args(settings, 'destination')

        if self.args.capture:
            self.capture_heroku_database()

        file_url = self.args.url
        if self.args.source_app:
            self.print_message(""Sourcing data from backup for Heroku app '%s'""
                               % self.args.source_app)
            file_url = self.get_file_url_for_heroku_app(self.args.source_app)

        if self.args.destination_app:
            self.replace_heroku_db(file_url)
        elif self.databases['destination']['name']:
            self.replace_postgres_db(file_url)

        self.print_message(""\nDone.\n\nDon't forget to update the Django Site entry if necessary!"")"
925,"def import_task_modules():
    """"""
    Import all installed apps and add modules to registry
    """"""
    top_level_modules = settings.INSTALLED_APPS
    module_names = []
    for module in top_level_modules:
        #Import package
        mod = import_module(module)
        #Find all modules in package path
        for loader, module_name, is_pkg in  pkgutil.walk_packages(mod.__path__):
            if not module_name.startswith(""__""):
                #If the module is not __init__, add it to the registry
                submod_name = ""{0}.{1}"".format(module,module_name)
                module_names.append(submod_name)
    #Once everything is imported, the metaclass will register them automatically
    modules = map(import_module, module_names)
    return modules"
926,"def find_in_registry(category = None, namespace = None, name = None):
    """"""
    Find a given category/namespace/name combination in the registry
    category - string, see utils.inputs.registrycategories
    namespace - module namespace, see settings.NAMESPACE
    name - lowercase name of module
    """"""
    selected_registry = registry
    if category is not None:
        selected_registry = [re for re in selected_registry if re.category==category]
    if namespace is not None:
        selected_registry = [re for re in selected_registry if re.namespace==namespace]
    if name is not None:
        selected_registry = [re for re in selected_registry if re.name==name]
    if len(selected_registry)>0:
        return [sr.cls for sr in selected_registry]

    return None"
927,"def list(self, service_rec=None, host_rec=None, hostfilter=None):
        """"""
        List a specific service or all services

        :param service_rec: t_services.id
        :param host_rec: t_hosts.id
        :param hostfilter: Valid hostfilter or None
        :return: [(svc.t_services.id, svc.t_services.f_hosts_id, svc.t_hosts.f_ipaddr,
             svc.t_hosts.f_hostname, svc.t_services.f_proto,
             svc.t_services.f_number, svc.t_services.f_status, svc.t_services.f_name,
             svc.t_services.f_banner), ...]
        """"""
        return self.send.service_list(service_rec, host_rec, hostfilter)"
928,"def info(self, svc_rec=None, ipaddr=None, proto=None, port=None):
        """"""
        Information about a service.

        :param svc_rec: t_services.id
        :param ipaddr: IP Address
        :param proto: Protocol (tcp, udp, info)
        :param port: Port (0-65535)
        :return: [ service_id, host_id, ipv4, ipv6, hostname, proto, number, status, name, banner ]
        """"""
        return self.send.service_info(svc_rec, ipaddr, proto, port)"
929,"def add(self, ipaddr=None, proto=None, port=None, fields=None):
        """"""
        Add a service record

        :param ipaddr: IP Address
        :param proto: Protocol (tcp, udp, info)
        :param port: Port (0-65535)
        :param fields: Extra fields
        :return: (True/False, t_services.id or response message)
        """"""
        return self.send.service_add(ipaddr, proto, port, fields)"
930,"def delete(self, svc_rec=None, ipaddr=None, proto=None, port=None):
        """"""
        Delete a t_services record

        :param svc_rec: t_services.id
        :param ipaddr: IP Address or t_hosts.id
        :param proto: Protocol (tcp, udp, info)
        :param port: Port (0-65535)
        :return: [True, Response Message]
        """"""
        return self.send.service_del(svc_rec, ipaddr, proto, port)"
931,"def report_list(self, service_id=None, service_port=None, hostfilter=None):
        """"""
        Returns a list of ports with IPs, banners and vulnerabilities (warning, slow!)

        :param service_id: t_services.id
        :param service_port: Port (tcp/#, udp/#, info/#)
        :param hostfilter: Valid hostfilter or None
        :return: { 'port': [t_hosts.f_ipaddr, t_services.f_banner,
            (t_vulndata.f_vulnid, t_vulndata.f_title, t_vulndata.f_severity, t_vulndata.f_cvss_score), ...}
        """"""
        return self.send.service_report_list(service_id, service_port, hostfilter)"
932,"def vulns_list(self, service_id=None, service_port=None, hostfilter=None):
        """"""
        List of vulnerabilities for a service

        :param service_id: t_services.id
        :param service_port: tcp/#, udp/# or info/#
        :param hostfilter: Valid hostfilter or None
        :return: t_services.rows.as_list()
        """"""
        return self.send.service_vulns_list(service_id, service_port, hostfilter)"
933,"def connect(nodes):
    '''
    Connect a list of nodes.

    Connected nodes have an ``output`` member which is the following node in
    the line. The last node's ``output`` is a :class:`Queue` for
    easy plumbing.
    '''
    for a, b in zip(nodes[:-1], nodes[1:]):
        a.output = b
    b.output = queues.Queue()"
934,"def render_layout(layout_name, content, **context):
    """"""Uses a jinja template to wrap the content inside a layout.
    Wraps the content inside a block and adds the extend statement before rendering it
    with jinja. The block name can be specified in the layout_name after the filename separated
    by a colon. The default block name is ""content"".
    """"""
    layout_block = ""content""
    if "":"" in layout_name:
        layout_name, layout_block = layout_name.split("":"")
    tpl = '{%% extends ""%s"" %%}{%% block %s %%}%s{%% endblock %%}' % (layout_name, layout_block, content)
    return render_template_string(tpl, **context)"
935,"def parse_template(app, filename):
    """"""Parses the given template using the jinja environment of the given app
    and returns the AST. ASTs are cached in parse_template.cache
    """"""
    if not hasattr(parse_template, ""cache""):
        parse_template.cache = {}
    if filename not in parse_template.cache:
        source = get_template_source(app, filename)
        parse_template.cache[filename] = app.jinja_env.parse(source, filename=filename)
    return parse_template.cache[filename]"
936,"def jinja_node_to_python(node):
    """"""Converts a Jinja2 node to its python equivalent
    """"""
    if isinstance(node, nodes.Const):
        return node.value
    if isinstance(node, nodes.Neg):
        return -jinja_node_to_python(node.node)
    if isinstance(node, nodes.Name):
        return node.name
    if isinstance(node, (nodes.List, nodes.Tuple)):
        value = []
        for i in node.items:
            value.append(jinja_node_to_python(i))
        return value
    if isinstance(node, nodes.Dict):
        value = {}
        for pair in node.items:
            value[pair.key.value] = jinja_node_to_python(pair.value)
        return value
    if isinstance(node, nodes.Call):
        if not isinstance(node.node, nodes.Name) or node.node.name not in (""_"", ""translate"", ""gettext""):
            raise FormDefinitionError(""Cannot convert function calls from jinja to python other than translation calls"")
        return lazy_translate(jinja_node_to_python(node.args[0]))
    raise Exception(""Cannot convert jinja nodes to python"")"
937,"def groups(self):
        """"""Get the list of Groups (by dn) that the bound CSH LDAP member object
        is in.
        """"""
        group_list = []
        all_groups = self.get('memberof')
        for group_dn in all_groups:
            if self.__ldap_group_ou__ in group_dn:
                group_list.append(group_dn)

        return group_list"
938,"def in_group(self, group, dn=False):
        """"""Get whether or not the bound CSH LDAP member object is part of a
        group.

        Arguments:
        group -- the CSHGroup object (or distinguished name) of the group to
                 check membership for
        """"""
        if dn:
            return group in self.groups()
        return group.check_member(self)"
939,"def savgol_filter(x, window_length, polyorder, deriv=0, delta=1.0, axis=-1, mode='interp', cval=0.0):
    '''
    Wrapper for the scipy.signal.savgol_filter function that handles Nan values.

    See: https://github.com/wheeler-microfluidics/dmf-control-board-firmware/issues/3

    Returns
    -------
    y : ndarray, same shape as `x`
        The filtered data.
    '''
    # linearly interpolate missing values before filtering
    x = np.ma.masked_invalid(pd.Series(x).interpolate())

    try:
        # start filtering from the first non-zero value since these won't be addressed by
        # the interpolation above
        ind = np.isfinite(x).nonzero()[0][0]
        x[ind:] = signal.savgol_filter(x[ind:], window_length, polyorder, deriv,
                                       delta, axis, mode, cval)
    except IndexError:
        pass
    return np.ma.masked_invalid(x)"
940,"def feedback_results_to_measurements_frame(feedback_result):
    '''
    Extract measured data from `FeedbackResults` instance into
    `pandas.DataFrame`.
    '''
    index = pd.Index(feedback_result.time * 1e-3, name='seconds')
    df_feedback = pd.DataFrame(np.column_stack([feedback_result.V_fb,
                                                feedback_result.V_hv,
                                                feedback_result.fb_resistor,
                                                feedback_result.hv_resistor]),
                               columns=['V_fb', 'V_hv', 'fb_resistor',
                                        'hv_resistor'],
                               index=index)
    df_feedback.insert(0, 'frequency', feedback_result.frequency)
    return df_feedback"
941,"def feedback_results_to_impedance_frame(feedback_result):
    '''
    Extract computed impedance data from `FeedbackResults` instance into
    `pandas.DataFrame`.
    '''
    index = pd.Index(feedback_result.time * 1e-3, name='seconds')
    df_feedback = pd.DataFrame(np.column_stack([feedback_result.V_actuation()
                                                .filled(np.NaN),
                                                feedback_result.capacitance()
                                                .filled(np.NaN),
                                                feedback_result.Z_device()
                                                .filled(np.NaN)]),
                               columns=['V_actuation', 'capacitance',
                                        'impedance'],
                               index=index)
    df_feedback.insert(0, 'frequency', feedback_result.frequency)
    df_feedback.insert(1, 'voltage', feedback_result.voltage)
    return df_feedback"
942,"def get_firmwares():
    '''
    Return `dmf_control_board` compiled Arduino hex file paths.

    This function may be used to locate firmware binaries that are available
    for flashing to [Arduino Mega2560][1] boards.

    [1]: http://arduino.cc/en/Main/arduinoBoardMega2560
    '''
    return OrderedDict([(board_dir.name, [f.abspath() for f in
                                          board_dir.walkfiles('*.hex')])
                        for board_dir in
                        package_path().joinpath('firmware').dirs()])"
943,"def safe_series_resistor_index_read(f, self, channel, resistor_index=None):
    '''
    This decorator checks the resistor-index from the current context _(i.e.,
    the result of `self.series_resistor_index`)_.  If the resistor-index
    specified by the `resistor_index` keyword argument is different than the
    current context value, the series-resistor-index is temporarily set to the
    value of `resistor_index` to execute the wrapped function before restoring
    back to the original value.
    '''
    if resistor_index is not None:
        original_resistor_index = self.series_resistor_index(channel)
        # Save state of resistor-index
        if resistor_index != original_resistor_index:
            self.set_series_resistor_index(channel, resistor_index)

    value = f(self, channel)

    if (resistor_index is not None and
            resistor_index != original_resistor_index):
        # Restore state of resistor-index
        self.set_series_resistor_index(channel, original_resistor_index)
    return value"
944,"def remote_command(function, self, *args, **kwargs):
    '''
    Catch `RuntimeError` exceptions raised by remote control board firmware
    commands and re-raise as more specific `FirmwareError` exception type,
    which includes command code and return code.
    '''
    try:
        return function(self, *args, **kwargs)
    except RuntimeError, exception:
        error_message = str(exception)
        match = CRE_REMOTE_ERROR.match(error_message)
        if match:
            # Exception message matches format of remote firmware error.
            command_code = int(match.group('command_int'))
            return_code = int(match.group('return_code_int'))
            raise FirmwareError(command_code, return_code)

        match = CRE_REMOTE_COMMAND_ERROR.match(error_message)
        if match:
            # Exception message matches format of remote firmware error.
            command_code = int(match.group('command_int'))
            command_name = NAMES_BY_COMMAND_CODE[command_code]
            raise RuntimeError(CRE_REMOTE_COMMAND_ERROR.sub(command_name,
                                                            error_message))

        # Not a remote firmware error, so raise original exception.
        raise"
945,"def _upgrade(self):
        """"""
        Upgrade the serialized object if necessary.

        Raises:
            FutureVersionError: file was written by a future version of the
                software.
        """"""
        logging.debug('[FeedbackResults]._upgrade()')
        if hasattr(self, 'version'):
            version = Version.fromstring(self.version)
        else:
            version = Version(0)
        logging.debug('[FeedbackResults] version=%s, class_version=%s' %
                      (str(version), self.class_version))
        if version > Version.fromstring(self.class_version):
            logging.debug('[FeedbackResults] version>class_version')
            raise FutureVersionError(Version.fromstring(self.class_version),
                                     version)
        elif version < Version.fromstring(self.class_version):
            if version < Version(0, 1):
                self.calibration = FeedbackCalibration()
            if version < Version(0, 2):
                # flag invalid data points
                self.version = str(Version(0, 2))
                self.fb_resistor[self.V_fb > 5] = -1
                self.hv_resistor[self.V_hv > 5] = -1
            if version < Version(0, 3):
                self.attempt = 0
            if version < Version(0, 4):
                del self.sampling_time_ms
                del self.delay_between_samples_ms
                self.voltage = self.options.voltage
                del self.options
                del self.attempt
            if version < Version(0, 5):
                self.area = 0
                self.version = str(Version(0, 5))
            if version < Version(0, 6):
                self.amplifier_gain = None
                self.vgnd_hv = None
                self.vgnd_fb = None
                self.version = str(Version(0, 6))
                logging.info('[FeedbackResults] upgrade to version %s' %
                             self.version)
        else:
            # Else the versions are equal and don't need to be upgraded.
            pass"
946,"def V_total(self):
        '''
        Compute the input voltage (i.e., ``V1``) based on the measured
        high-voltage feedback values for ``V2``, using the high-voltage
        transfer function.

        See also
        --------
        :meth:`V_actuation` for diagram with ``V1`` and ``V2`` labelled.
        '''
        ind = mlab.find(self.hv_resistor >= 0)
        V1 = np.empty(self.hv_resistor.shape)
        V1.fill(np.nan)
        V1[ind] = compute_from_transfer_function(self.calibration.hw_version
                                                 .major, 'V1',
                                                 V2=self.V_hv[ind], R1=10e6,
                                                 R2=self.calibration.R_hv
                                                 [self.hv_resistor[ind]],
                                                 C2=self.calibration.C_hv
                                                 [self.hv_resistor[ind]],
                                                 f=self.frequency)
        # convert to masked array
        V1 = np.ma.masked_invalid(pd.Series(V1, pd.to_datetime(self.time, unit='s')
            ).interpolate(method='time').values)
        V1.fill_value = np.nan
        V1.data[V1.mask] = V1.fill_value
        return V1"
947,"def V_actuation(self):
        '''
        Return the voltage drop across the device (i.e., the ``Z1`` load) for
        each feedback measurement.

        Consider the feedback circuit diagrams below for the feedback
        measurement circuits of the two the control board hardware versions.

        .. code-block:: none

                         # Hardware V1 #          # Hardware V2 #

                         V_1 @ frequency          V_1 @ frequency
                        ┬    ┯                        ┯
                        │  ┌─┴─┐                    ┌─┴─┐    ┌───┐
            V_actuation │  │Z_1│                    │Z_1│  ┌─┤Z_2├─┐
                        │  └─┬─┘                    └─┬─┘  │ └───┘ │
                        ┴    ├───O V_2                │    │  │\   ├───O V_2
                           ┌─┴─┐                      └────┴──│-\__│
                           │Z_2│                           ┌──│+/
                           └─┬─┘                           │  │/
                            ═╧═                            │
                             ¯                            ═╧═
                                                           ¯

        Note that in the case of **hardware version 1**, the input voltage
        ``V1`` is divided across ``Z1`` *and* the feedback measurement load
        ``Z2``. Therefore, the effective *actuation* voltage across the DMF
        device is less than ``V1``.  Specifically, the effective *actuation*
        voltage is ``V1 - V2``.

        In **hardware version 2**, since the positive terminal of the op-amp is
        attached to *(virtual)* ground, the negative op-amp terminal is also at
        ground potential.  It follows that the actuation voltage is equal to
        ``V1`` on **hardware version 2**.
        '''
        if self.calibration.hw_version.major == 1:
            return self.V_total() - np.array(self.V_fb)
        else:
            return self.V_total()"
948,"def Z_device(self, filter_order=None, window_size=None, tol=0.05):
        '''
        Compute the impedance *(including resistive and capacitive load)* of
        the DMF device *(i.e., dielectric and droplet)*.

        See :func:`calibrate.compute_from_transfer_function`
        for details.
        '''
        ind = mlab.find(self.fb_resistor >= 0)
        Z1 = np.empty(self.fb_resistor.shape)
        Z1.fill(np.nan)
        # convert to masked array
        Z1 = np.ma.masked_invalid(Z1)

        R2 = self.calibration.R_fb[self.fb_resistor[ind]]
        C2 = self.calibration.C_fb[self.fb_resistor[ind]]
        Z1[ind] = compute_from_transfer_function(self.calibration.hw_version
                                                 .major, 'Z1',
                                                 V1=self.V_total()[ind],
                                                 V2=self.V_fb[ind], R2=R2,
                                                 C2=C2, f=self.frequency)

        Z1 = np.ma.masked_invalid(pd.Series(Z1, pd.to_datetime(self.time, unit='s')
            ).interpolate(method='time').values)
        Z1.fill_value = np.nan
        Z1.data[Z1.mask] = Z1.fill_value

        # if we're filtering and we don't have a window size specified,
        # automatically determine one
        if filter_order and window_size is None:
            window_size = self._get_window_size(tol)

        # if the filter_order or window size is None or if the window size is
        # smaller than filter_order + 2, don't filter
        if (filter_order is None or window_size is None or window_size < filter_order + 2):
            pass
        else:
            # if the window size is less than half the sample length
            if window_size and window_size < len(Z1) / 2:
                # suppress polyfit warnings
                with warnings.catch_warnings():
                    warnings.simplefilter(""ignore"")
                    Z1 = savgol_filter(Z1, window_size, filter_order)
            else: # fit a line
                result = self.mean_velocity(tol=tol)
                if result['dt'] and \
                    result['dt'] > 0.1 * self.time[-1] and result['p'][0] > 0:
                    if self.calibration._c_drop:
                        c_drop = self.calibration.c_drop(self.frequency)
                    else:
                        c_drop = self.capacitance()[-1] / self.area
                    if self.calibration._c_filler:
                        c_filler = self.calibration.c_filler(self.frequency)
                    else:
                        c_filler = 0
                    x = result['p'][0]*self.time + result['p'][1]
                    C = self.area * (x * (c_drop - c_filler) / \
                                     np.sqrt(self.area) + c_filler)
                    Z1 = 1.0 / (2.0 * math.pi * self.frequency * C)
                    Z1[mlab.find(self.time==result['t_end'])[0]+1:] = \
                        Z1[mlab.find(self.time==result['t_end'])[0]]
                else:
                    Z1 = np.mean(Z1)*np.ones(Z1.shape)
        return Z1"
949,"def force(self, Ly=None):
        '''
        Estimate the applied force (in Newtons) on a drop according to the
        electromechanical model [1].

            Ly is the length of the actuated electrode along the y-axis
                (perpendicular to the direction of motion) in milimeters. By
                default, use the square root of the actuated electrode area,
                i.e.,
                    Ly=Lx=sqrt(Area)
                To get the force normalized by electrode width (i.e., in units
                of N/mm), set Ly=1.0.

        1. Chatterjee et al., ""Electromechanical model for actuating liquids in
           a two-plate droplet microfluidic device,"" Lab on a Chip, no. 9
           (2009): 1219-1229.
        '''
        if self.calibration._c_drop:
            c_drop = self.calibration.c_drop(self.frequency)
        else:
            c_drop = self.capacitance()[-1] / self.area
        if self.calibration._c_filler:
            c_filler = self.calibration.c_filler(self.frequency)
        else:
            c_filler = 0
        if Ly is None:
            Ly = np.sqrt(self.area)
        return 1e3 * Ly * 0.5 * (c_drop - c_filler) * self.V_actuation()**2"
950,"def capacitance(self, filter_order=None, window_size=None, tol=0.05):
        '''
        Compute the capacitance of the DMF device _(i.e., dielectric and
        droplet)_ based on the computed impedance value.

        Note: this assumes impedance is purely capacitive load.
        TODO: Is this assumption ok?
        '''
        C = np.ma.masked_invalid(1.0 / (2.0 * math.pi * self.frequency *
                   self.Z_device(filter_order=filter_order,
                                 window_size=window_size, tol=tol)))
        C.fill_value = np.nan
        C.data[C.mask] = C.fill_value
        return C"
951,"def x_position(self, filter_order=None, window_size=None, tol=0.05,
                   Lx=None):
        '''
        Calculate $x$-position according to:

               __ | C       |
                           ╲╱ a   ⋅ | - - c_f |
                  | a       |
        x = ──────────────
              c_d - c_f

        where:

         - $C$ is the measured capacitance.
         - $c_f$ is the capacitance of the filler medium per unit area
           _(e.g., air)_.
         - $c_d$ is the capacitance of an electrode completely covered in
           liquid per unit area.
         - $a$ is the area of the actuated electrode(s).

        Note that this equation for $x$ assumes a single drop moving across an
        electrode with a length along the x-axis of Lx. If no value is provided
        for Lx, the electrode is assumed to be square, i.e.,
            Lx=Ly=sqrt(area)
        '''
        if self.calibration._c_drop:
            c_drop = self.calibration.c_drop(self.frequency)
        else:
            c_drop = self.capacitance()[-1] / self.area
        if self.calibration._c_filler:
            c_filler = self.calibration.c_filler(self.frequency)
        else:
            c_filler = 0
        if Lx is None:
            Lx = np.sqrt(self.area)
        return (self.capacitance(filter_order=filter_order,
                                 window_size=window_size, tol=tol) / self.area \
                - c_filler) / (c_drop - c_filler) * Lx"
952,"def mean_velocity(self, tol=0.05, Lx=None):
        '''
        Calculate the mean velocity for a step (mm/ms which is equivalent to
        m/s). Fit a line to the capacitance data and get the slope.
        '''
        dx = None
        dt = None
        p = None
        ind = None
        t_end = None

        if self.area == 0:
            return dict(dx=dx, dt=dt, p=p, ind=ind, t_end=t_end)

        x = self.x_position(Lx=Lx)

        # find the first and last valid indices
        ind_start = mlab.find(x.mask==False)[0]
        ind_last = mlab.find(x.mask==False)[-1]

        # if the original x value is within tol % of the final x value, include
        # all samples
        if x[ind_start] > (1 - tol) * x[ind_last] or x[ind_last] < 0:
            ind_stop = ind_last
        else: # otherwise, stop when x reaches (1 - tol) % of it's final value
            ind_stop = mlab.find(x > (1 - tol) * x[ind_last])[0]

        ind = [ind_start, ind_stop]

        # if we have at least 2 valid samples
        if len(ind) >=2:
            dx = np.diff(x[ind])[0]
            dt = np.diff(self.time[ind])[0] # ms

            # suppress polyfit warnings
            with warnings.catch_warnings():
                warnings.simplefilter(""ignore"")
                # fit a line to the data
                p = np.polyfit(self.time[ind[0]:ind[1]], x[ind[0]:ind[1]], 1)

            # find time when the the line intercepts x[ind_last]
            ind_stop = mlab.find(self.time > \
                                 (x[ind_last] - p[1]) / p[0])
            if len(ind_stop):
                t_end = self.time[ind_stop[0]]
            else:
                t_end = self.time[-1]
        return dict(dx=dx, dt=dt, p=p, ind=ind, t_end=t_end)"
953,"def to_frame(self, filter_order=3):
        """"""
        Convert data to a `pandas.DataFrame`.

        Parameters
        ----------
        filter_order : int
            Filter order to use when filtering Z_device, capacitance, x_position, and dxdt.
            Data is filtered using a Savitzky-Golay filter with a window size that is adjusted
            based on the mean velocity of the drop (see _get_window_size).

        Returns
        -------
        pandas.DataFrame
            This DataFrame is indexed by a utc_timestamp and contains the following columns:
                frequency: actuation frequency (Hz)
                target_voltage: target voltage (V)
                voltage: measured voltage (V)
                force: actuation force (uN/mm)
                area: actuated area (mm^2)
                Z_device_filtered: filtered device impedance for actuated area (Ohms)
                capacitance_filtered: filtered device capacitance for actuated area (F)
                x_position_filtered: filtered x-position of the drop (mm)
                dxdt_filtered: filtered instantaneous velocity of the drop (mm/s)
                Z_device: device impedance for actuated area (Ohms)
                capacitance: device capacitance for actuated area (F)
                x_position: x-position of the drop (mm)
                dxdt: instantaneous velocity of the drop (mm/s)
                dx: difference in the drop's x-position over the course of the step (mm)
                dt: time the drop is considered to have been ""moving"" (s)
                mean_velocity: mean drop velocity (mm/s)
                peak_velocity: peak drop velocity calculated from filtered instantaneous
                    velocity (mm/s)
                window_size: windows size used for Savitzky-Golay filter (# bins)
                filter_order: order used for Savitzky-Golay filter (integer)
        """"""

        window_size = self._get_window_size()
        L = np.sqrt(self.area)
        velocity_results = self.mean_velocity(Lx=L)
        mean_velocity = None
        peak_velocity = None
        dx = 0
        dt = 0
        dxdt = np.zeros(len(self.time))
        dxdt_filtered = np.zeros(len(self.time))

        # if the window size is too small for filtering, set filter_order to None
        if filter_order and window_size and window_size < filter_order + 2:
            filter_order = None

        if velocity_results and velocity_results['dx']:
            mean_velocity = velocity_results['p'][0] * 1e3

            dx = velocity_results['dx']
            dt = velocity_results['dt'] * 1e-3 # convert to seconds

            t, dxdt = self.dxdt(Lx=L)
            # interpolate dxdt to use the same time points as the impedance values.
            dxdt = np.interp(self.time,
                             t, dxdt) * 1e3 # multiply by 1000 to convert to mm/s
            dxdt = np.ma.masked_invalid(dxdt)

            t, dxdt_filtered = self.dxdt(filter_order=filter_order, Lx=L)
            # interpolate dxdt_filtered to use the same time points as the impedance values.
            dxdt_filtered = np.interp(self.time,
                                      t, dxdt_filtered) * 1e3 # multiply by 1000 to convert to mm/s
            dxdt_filtered = np.ma.masked_invalid(dxdt_filtered)

            # calculate peak velocity from filtered data
            peak_velocity = np.max(dxdt_filtered)

        index = pd.Index(self.time * 1e-3, name='step_time')
        df = pd.DataFrame({'target_voltage': self.voltage, # V
                           'voltage': self.V_actuation(), # V
                           'force': self.force(Ly=1.0) * 1e6, # uN/mm
                           'Z_device_filtered': self.Z_device(filter_order=filter_order), # Ohms
                           'capacitance_filtered': self.capacitance(filter_order=filter_order), # F
                           'x_position_filtered': self.x_position(filter_order=filter_order), # mm
                           'dxdt_filtered': dxdt_filtered, # mm/s
                           'Z_device': self.Z_device(), # Ohms
                           'capacitance': self.capacitance(), # F
                           'x_position': self.x_position(), # mm
                           'dxdt': dxdt, # mm/s
                          }, index=index)

        df['frequency'] = self.frequency
        df['area'] = self.area # mm^2
        df['dx'] = dx # mm
        df['dt'] = dt # s
        df['mean_velocity'] = mean_velocity # mm/s
        df['peak_velocity'] = peak_velocity # mm/s
        df['window_size'] = window_size
        df['filter_order'] = filter_order

        # re-order columns
        return df[[u'frequency', u'target_voltage', u'voltage', u'force', u'area',
                   u'Z_device_filtered', u'capacitance_filtered', u'x_position_filtered',
                   u'dxdt_filtered', u'Z_device', u'capacitance', u'x_position', u'dxdt',
                   u'dx', u'dt', u'mean_velocity', u'peak_velocity',
                   u'window_size', u'filter_order']]"
954,"def _upgrade(self):
        """"""
        Upgrade the serialized object if necessary.

        Raises:
            FutureVersionError: file was written by a future version of the
                software.
        """"""
        logging.debug(""[FeedbackResultsSeries]._upgrade()"")
        version = Version.fromstring(self.version)
        logging.debug('[FeedbackResultsSeries] version=%s, class_version=%s',
                      str(version), self.class_version)
        if version > Version.fromstring(self.class_version):
            logging.debug('[FeedbackResultsSeries] version>class_version')
            raise FutureVersionError(Version.fromstring(self.class_version),
                                     version)
        elif version < Version.fromstring(self.class_version):
            if version < Version(0, 1):
                self.time = [None]*len(self.data)
                self.version = str(Version(0, 1))"
955,"def c_drop(self, frequency):
        '''
        Capacitance of an electrode covered in liquid, normalized per unit
        area (i.e., units are F/mm^2).
        '''
        try:
            return np.interp(frequency,
                             self._c_drop['frequency'],
                             self._c_drop['capacitance']
            )
        except:
            pass
        return self._c_drop"
956,"def c_filler(self, frequency):
        '''
        Capacitance of an electrode covered in filler media (e.g., air or oil),
        normalized per unit area (i.e., units are F/mm^2).
        '''
        try:
            return np.interp(frequency,
                             self._c_filler['frequency'],
                             self._c_filler['capacitance']
            )
        except:
            pass
        return self._c_filler"
957,"def _upgrade(self):
        """"""
        Upgrade the serialized object if necessary.

        Raises:
            FutureVersionError: file was written by a future version of the
                software.
        """"""
        logging.debug(""[FeedbackCalibration]._upgrade()"")
        version = Version.fromstring(self.version)
        logging.debug('[FeedbackCalibration] version=%s, class_version=%s',
                      str(version), self.class_version)
        if version > Version.fromstring(self.class_version):
            logging.debug('[FeedbackCalibration] version>class_version')
            raise FutureVersionError(Version.fromstring(self.class_version),
                                     version)
        elif version < Version.fromstring(self.class_version):
            if version < Version(0, 1):
                self._c_filler = None
                self._c_drop = None
                self.version = str(Version(0, 1))
            if version < Version(0, 2):
                self.hw_version = Version(1)
                self.version = str(Version(0, 2))
                logging.info('[FeedbackCalibration] upgrade to version %s',
                             self.version)
            if version < Version(0, 2):
                self.hw_version = Version(1)
                self.version = str(Version(0, 2))
                logging.info('[FeedbackCalibration] upgrade to version %s',
                             self.version)
            if version < Version(0, 3):
                self.version = str(Version(0, 3))
                logging.info('[FeedbackCalibration] upgrade to version %s',
                             self.version)"
958,"def force_to_voltage(self, force, frequency):
        '''
        Convert a force in uN/mm to voltage.

        Parameters
        ----------
        force : float
            Force in **uN/mm**.
        frequency : float
            Actuation frequency.

        Returns
        -------
        float
            Actuation voltage to apply :data:`force` at an actuation frequency
            of :data:`frequency`.
        '''
        c_drop = self.calibration.c_drop(frequency)

        # if c_filler hasn't been set, assume c_filler = 0
        if self.calibration._c_filler:
            c_filler = self.calibration.c_filler(frequency)
        else:
            c_filler = 0

        return np.sqrt(force * 1e-9/ (0.5 * (c_drop - c_filler)))"
959,"def series_capacitance(self, channel, resistor_index=None):
        '''
        Parameters
        ----------
        channel : int
            Analog channel index.
        resistor_index : int, optional
            Series resistor channel index.

            If :data:`resistor_index` is not specified, the resistor-index from
            the current context _(i.e., the result of
            :attr:`series_resistor_index`)_ is used.

            Otherwise, the series-resistor is temporarily set to the value of
            :data:`resistor_index` to read the capacitance before restoring
            back to the original value.

            See definition of :meth:`safe_series_resistor_index_read`
            decorator.

        Returns
        -------
        float
            Return the current series capacitance value for the specified
            channel.
        '''
        if resistor_index is None:
            resistor_index = self.series_resistor_index(channel)
        value = self._series_capacitance(channel)
        try:
            if channel == 0:
                self.calibration.C_hv[resistor_index] = value
            else:
                self.calibration.C_fb[resistor_index] = value
        except:
            pass
        return value"
960,"def series_resistance(self, channel, resistor_index=None):
        '''
        Parameters
        ----------
        channel : int
            Analog channel index.
        resistor_index : int, optional
            Series resistor channel index.

            If :data:`resistor_index` is not specified, the resistor-index from
            the current context _(i.e., the result of
            :attr:`series_resistor_index`)_ is used.

            Otherwise, the series-resistor is temporarily set to the value of
            :data:`resistor_index` to set the capacitance before restoring back
            to the original value.

            See definition of :meth:`safe_series_resistor_index_read`
            decorator.

        Returns
        -------
        float
            Return the current series resistance value for the specified
            channel.
        '''
        if resistor_index is None:
            resistor_index = self.series_resistor_index(channel)
        value = self._series_resistance(channel)
        try:
            if channel == 0:
                self.calibration.R_hv[resistor_index] = value
            else:
                self.calibration.R_fb[resistor_index] = value
        except:
            pass
        return value"
961,"def set_series_capacitance(self, channel, value, resistor_index=None):
        '''
        Set the current series capacitance value for the specified channel.

        Parameters
        ----------
        channel : int
            Analog channel index.
        value : float
            Series capacitance value.
        resistor_index : int, optional
            Series resistor channel index.

            If :data:`resistor_index` is not specified, the resistor-index from
            the current context _(i.e., the result of
            :attr:`series_resistor_index`)_ is used.

            Otherwise, the series-resistor is temporarily set to the value of
            :data:`resistor_index` to read the resistance before restoring
            back to the original value.

        Returns
        -------
        int
            Return code from embedded call.
        '''
        if resistor_index is None:
            resistor_index = self.series_resistor_index(channel)
        try:
            if channel == 0:
                self.calibration.C_hv[resistor_index] = value
            else:
                self.calibration.C_fb[resistor_index] = value
        except:
            pass
        return self._set_series_capacitance(channel, value)"
962,"def set_series_resistance(self, channel, value, resistor_index=None):
        '''
        Set the current series resistance value for the specified channel.

        Parameters
        ----------
        channel : int
            Analog channel index.
        value : float
            Series resistance value.
        resistor_index : int, optional
            Series resistor channel index.

            If :data:`resistor_index` is not specified, the resistor-index from
            the current context _(i.e., the result of
            :attr:`series_resistor_index`)_ is used.

            Otherwise, the series-resistor is temporarily set to the value of
            :data:`resistor_index` to set the resistance before restoring back
            to the original value.

            See definition of :meth:`safe_series_resistor_index_read`
            decorator.

        Returns
        -------
        int
            Return code from embedded call.
        '''
        if resistor_index is None:
            resistor_index = self.series_resistor_index(channel)
        try:
            if channel == 0:
                self.calibration.R_hv[resistor_index] = value
            else:
                self.calibration.R_fb[resistor_index] = value
        except:
            pass
        return self._set_series_resistance(channel, value)"
963,"def connect(self, port=None, baud_rate=115200):
        '''
        Parameters
        ----------
        port : str or list-like, optional
            Port (or list of ports) to try to connect to as a DMF Control
            Board.
        baud_rate : int, optional

        Returns
        -------
        str
            Port DMF control board was connected on.

        Raises
        ------
        RuntimeError
            If connection could not be established.
        IOError
            If no ports were specified and Arduino Mega2560 not found on any
            port.
        '''
        if isinstance(port, types.StringTypes):
            ports = [port]
        else:
            ports = port

        if not ports:
            # No port was specified.
            #
            # Try ports matching Mega2560 USB vendor/product ID.
            ports = serial_ports().index.tolist()
            if not ports:
                raise IOError(""Arduino Mega2560 not found on any port."")

        for comport_i in ports:
            if self.connected():
                self.disconnect()
                self.port = None
                self._i2c_devices = {}

            # Try to connect to control board on available ports.
            try:
                logger.debug('Try to connect to: %s', comport_i)
                # Explicitly cast `comport_i` to string since `Base.connect`
                # Boost Python binding does not support unicode strings.
                #
                # Fixes [issue 8][issue-8].
                #
                # [issue-8]: https://github.com/wheeler-microfluidics/dmf-control-board-firmware/issues/8
                Base.connect(self, str(comport_i), baud_rate)
                self.port = comport_i
                break
            except BadVGND, exception:
                logger.warning(exception)
                break
            except RuntimeError, exception:
                continue
        else:
            raise RuntimeError('Could not connect to control board on any of '
                               'the following ports: %s' % ports)

        name = self.name()
        version = self.hardware_version()
        firmware = self.software_version()
        serial_number_string = """"
        try:
            serial_number_string = "", S/N %03d"" % self.serial_number
        except:
            # Firmware does not support `serial_number` attribute.
            pass
        logger.info(""Connected to %s v%s (Firmware: %s%s)"" %
                    (name, version, firmware, serial_number_string))

        logger.info(""Poll control board for series resistors and ""
                    ""capacitance values."")

        self._read_calibration_data()

        try:
            self.__aref__ = self._aref()
            logger.info(""Analog reference = %.2f V"" % self.__aref__)
        except:
            # Firmware does not support `__aref__` attribute.
            pass

        # Check VGND for both analog channels
        expected = 2 ** 10/2
        v = {}
        channels = [0, 1]
        damaged = []
        for channel in channels:
            try:
                v[channel] = np.mean(self.analog_reads(channel, 10))
                logger.info(""A%d VGND = %.2f V (%.2f%% of Aref)"", channel,
                            self.__aref__ * v[channel] / (2 ** 10), 100.0 *
                            v[channel] / (2 ** 10))
                # Make sure that the VGND is close to the expected value;
                # otherwise, the op-amp may be damaged (expected error
                # is <= 10%).
                if np.abs(v[channel] - expected) / expected > .1:
                    damaged.append(channel)
            except:
                # Firmware does not support `__aref__` attribute.
                break

        # Scan I2C bus to generate list of connected devices.
        self._i2c_scan()

        if damaged:
            # At least one of the analog input channels appears to be damaged.
            if len(damaged) == 1:
                msg = ""Analog channel %d appears"" % damaged[0]
            else:
                msg = ""Analog channels %s appear"" % damaged
            raise BadVGND(msg + "" to be damaged. You may need to replace the ""
                          ""op-amp on the control board."")

        return self.RETURN_OK"
964,"def persistent_write(self, address, byte, refresh_config=False):
        '''
        Write a single byte to an address in persistent memory.

        Parameters
        ----------
        address : int
            Address in persistent memory (e.g., EEPROM).
        byte : int
            Value to write to address.
        refresh_config : bool, optional
            Is ``True``, :meth:`load_config()` is called afterward to refresh
            the configuration settings.
        '''
        self._persistent_write(address, byte)
        if refresh_config:
            self.load_config(False)"
965,"def persistent_read_multibyte(self, address, count=None, dtype=np.uint8):
        '''
        Read a chunk of data from persistent memory.

        Parameters
        ----------
        address : int
            Address in persistent memory (e.g., EEPROM).
        count : int, optional
            Number of values to read.

            If not set, read a single value of the specified :data:`dtype`.
        dtype : numpy.dtype, optional
            The type of the value(s) to read.

        Returns
        -------
        dtype or numpy.array(dtype=dtype)
            If :data:`count` is ``None``, return single value.

            Otherwise, return array of values.
        '''
        nbytes = np.dtype(dtype).itemsize
        if count is not None:
            nbytes *= count

        # Read enough bytes starting at specified address to match the
        # requested number of the specified data type.
        data_bytes = np.array([self.persistent_read(address + i)
                               for i in xrange(nbytes)], dtype=np.uint8)

        # Cast byte array as array of specified data type.
        result = data_bytes.view(dtype)

        # If no count was specified, we return a scalar value rather than the
        # resultant array.
        if count is None:
            return result[0]
        return result"
966,"def persistent_write_multibyte(self, address, data, refresh_config=False):
        '''
        Write multiple bytes to an address in persistent memory.

        Parameters
        ----------
        address : int
            Address in persistent memory (e.g., EEPROM).
        data : numpy.array
            Data to write.
        refresh_config : bool, optional
            Is ``True``, :meth:`load_config()` is called afterward to refresh
            the configuration settings.
        '''
        for i, byte in enumerate(data.view(np.uint8)):
            self.persistent_write(address + i, int(byte))
        if refresh_config:
            self.load_config(False)"
967,"def measure_impedance(self, sampling_window_ms, n_sampling_windows,
                          delay_between_windows_ms, interleave_samples, rms,
                          state):
        '''
        Measure voltage across load of each of the following control board
        feedback circuits:

         - Reference _(i.e., attenuated high-voltage amplifier output)_.
         - Load _(i.e., voltage across DMF device)_.

        The measured voltage _(i.e., ``V2``)_ can be used to compute the
        impedance of the measured load, the input voltage _(i.e., ``V1``)_,
        etc.

        Parameters
        ----------
        sampling_window_ms : float
            Length of sampling window (in milleseconds) for each
            RMS/peak-to-peak voltage measurement.
        n_sampling_windows : int
            Number of RMS/peak-to-peak voltage measurements to take.
        delay_between_windows_ms : float
            Delay (in milleseconds) between RMS/peak-to-peak voltage
            measurements.
        interleave_samples : bool
            If ``True``, interleave RMS/peak-to-peak measurements for analog
            channels.

            For example, ``[<i_0>, <j_0>, <i_1>, <j_1>, ..., <i_n>, <j_n>]``
            where ``i`` and ``j`` correspond to two different analog channels.

            If ``False``, all measurements for each analog channel are taken
            together.  For example, ``[<i_0>, ..., <i_n>, <j_0>, ..., <j_n>]``
            where ``i`` and ``j`` correspond to two different analog channels.
        rms : bool
            If ``True``, a RMS voltage measurement is collected for each
            sampling window.

            Otherwise, peak-to-peak measurements are collected.
        state : list
            State of device channels.  Length should be equal to the number of
            device channels.

        Returns
        -------
        :class:`FeedbackResults`
        '''
        state_ = uint8_tVector()
        for i in range(0, len(state)):
            state_.append(int(state[i]))

        buffer = np.array(Base.measure_impedance(self,
                                                 sampling_window_ms,
                                                 n_sampling_windows,
                                                 delay_between_windows_ms,
                                                 interleave_samples,
                                                 rms,
                                                 state_))
        return self.measure_impedance_buffer_to_feedback_result(buffer)"
968,"def sweep_channels(self,
                       sampling_window_ms,
                       n_sampling_windows_per_channel,
                       delay_between_windows_ms,
                       interleave_samples,
                       rms,
                       channel_mask):
        '''
        Measure voltage across load of each of the following control board
        feedback circuits:

         - Reference _(i.e., attenuated high-voltage amplifier output)_.
         - Load _(i.e., voltage across DMF device)_.

        For each channel in the channel mask. The measured voltage _(i.e.,
        ``V2``)_ can be used to compute the impedance of the measured load, the
        input voltage _(i.e., ``V1``)_, etc.

        Parameters
        ----------
        sampling_window_ms : float
            Length of sampling window (in milleseconds) for each
            RMS/peak-to-peak voltage measurement.
        n_sampling_windows_per_channel : int
            Number of RMS/peak-to-peak voltage measurements to take.
        delay_between_windows_ms : float
            Delay (in milleseconds) between RMS/peak-to-peak voltage
            measurements.
        interleave_samples : bool
            If ``True``, interleave RMS/peak-to-peak measurements for analog
            channels.

            For example, ``[<i_0>, <j_0>, <i_1>, <j_1>, ..., <i_n>, <j_n>]``
            where ``i`` and ``j`` correspond to two different analog channels.

            If ``False``, all measurements for each analog channel are taken
            together.  For example, ``[<i_0>, ..., <i_n>, <j_0>, ..., <j_n>]``
            where ``i`` and ``j`` correspond to two different analog channels.
        rms : bool
            If ``True``, a RMS voltage measurement is collected for each
            sampling window.

            Otherwise, peak-to-peak measurements are collected.
        channel_mask : array-like
            State of device channels.  Length should be equal to the number of
            device channels.

        Returns
        -------
        pandas.DataFrame
            Table containing one actuation RMS measurement and one device load
            impedance measurement per row and the columns ``frequency``,
            ``voltage``, ``channel_i``, ``V_actuation``, ``capacitance``, and
            ``impedance``.

            Rows are indexed by time since first measurement in frame.
        '''

        channel_cumsum = np.cumsum(channel_mask)

        # figure out how many channels are in the mask, and how many we can scan
        # per request
        n_channels_in_mask = channel_cumsum[-1]
        max_channels_per_call = (self.MAX_PAYLOAD_LENGTH - 4*4) / \
                                 (3*2) / n_sampling_windows_per_channel

        # cache the channel mask
        self._channel_mask_cache = np.array(channel_mask)

        buffer = np.zeros(4)
        for i in range(int(math.ceil(n_channels_in_mask / max_channels_per_call))):
            # figure out which channels to include in this call
            ind = np.logical_and(channel_cumsum >= i * max_channels_per_call,
                                 channel_cumsum < (i + 1) * max_channels_per_call)

            # copy those channels from the cached mask
            channel_mask_ = np.zeros(len(self._channel_mask_cache), dtype=int)
            channel_mask_[ind] = self._channel_mask_cache[ind]

            # convert it to a uint8_tVector
            channel_mask_uint8 = uint8_tVector()
            channel_mask_uint8.extend(channel_mask_)

            buffer = buffer[:-4]
            buffer = np.concatenate((buffer, np.array(Base.sweep_channels(self,
                                                     sampling_window_ms,
                                                     n_sampling_windows_per_channel,
                                                     delay_between_windows_ms,
                                                     interleave_samples,
                                                     rms,
                                                     channel_mask_uint8))))
        return self.sweep_channels_buffer_to_feedback_result(buffer)"
969,"def sweep_channels_slow(self, sampling_window_ms, n_sampling_windows,
                            delay_between_windows_ms, interleave_samples,
                            use_rms, channel_mask):
        '''
        Measure voltage across load of each of the following control board
        feedback circuits:

         - Reference _(i.e., attenuated high-voltage amplifier output)_.
         - Load _(i.e., voltage across DMF device)_.

        For each channel in the channel mask. The measured voltage _(i.e.,
        ``V2``)_ can be used to compute the impedance of the measured load, the
        input voltage _(i.e., ``V1``)_, etc.

        **N.B.,** Use one firmware call per channel, as opposed to scanning all
        channels with a single firmware call as in :meth:`sweep_channels`
        method.

        Returns
        -------
        pandas.DataFrame
            Table containing one actuation RMS measurement and one device load
            impedance measurement per row and the columns ``frequency``,
            ``voltage``, ``channel_i``, ``V_actuation``, ``capacitance``, and
            ``impedance``.

            Rows are indexed by time since first measurement in frame.
        '''
        channel_count = len(channel_mask)
        scan_count = sum(channel_mask)

        frames = []

        print ''
        scan_count_i = 0
        # Iterate through channel mask, measuring impedance for each selected
        # channel in the mask.
        for channel_i, state_i in enumerate(channel_mask):
            if state_i:
                scan_count_i += 1
                print '\rMeasure impedance: {} ({}/{})'.format(channel_i,
                                                               scan_count_i,
                                                               scan_count),
                channel_states_i = [0] * channel_count
                channel_states_i[channel_i] = 1
                start_time_i = datetime.utcnow()
                feedback_results_i = \
                    self.measure_impedance(sampling_window_ms,
                                           n_sampling_windows,
                                           delay_between_windows_ms,
                                           interleave_samples, use_rms,
                                           channel_states_i)
                # Convert custom feedback results object into a
                # `pandas.DataFrame`.
                df_result_i =\
                    feedback_results_to_impedance_frame(feedback_results_i)
                df_result_i.insert(2, 'channel_i', channel_i)
                df_result_i.insert(0, 'utc_start', start_time_i)
                frames.append(df_result_i)
        print ''

        if not frames:
            df_result = pd.DataFrame(None, columns=['utc_start', 'seconds',
                                                    'channel_i', 'frequency',
                                                    'V_actuation',
                                                    'capacitance',
                                                    'impedance'])
        else:
            df_result = pd.concat(frames)
        return df_result"
970,"def i2c_write(self, address, data):
        '''
        Parameters
        ----------
        address : int
            Address of I2C device.
        data : array-like
            Array of bytes to send to device.
        '''
        data_ = uint8_tVector()
        for i in range(0, len(data)):
            data_.append(int(data[i]))
        Base.i2c_write(self, address, data_)"
971,"def read_all_series_channel_values(self, f, channel):
        '''
        Return all values for the specified channel of the type corresponding
        to the function `f`, where `f` is either `self.series_resistance` or
        `self.series_capacitance`.
        '''
        values = []
        channel_max_param_count = [3, 5]
        for i in range(channel_max_param_count[channel]):
            try:
                values.append(f(channel, i))
            except RuntimeError:
                break
        return values"
972,"def write_all_series_channel_values(self, read_f, write_f, channel,
                                        values):
        '''
        Return all values for the specified channel of the type corresponding
        to the function `f`, where `f` is either `self.series_resistance` or
        `self.series_capacitance`.
        '''

        # Create a copy of the new values we intend to write. Otherwise, if
        # `values` is a reference to the calibration object owned by the
        # control board, it can be overwritten in the following step which will
        # prevent the update.
        #
        # See http://microfluidics.utoronto.ca/trac/dropbot/ticket/81
        values = copy.deepcopy(values)

        # Read the current values, and only update the values that are
        # different.
        original_values = self.read_all_series_channel_values(read_f, channel)

        # Make sure that the number of supplied values matches the number of
        # corresponding values read from the channel.
        assert(len(values) == len(original_values))

        for i in range(len(original_values)):
            if values[i] != original_values[i]:
                write_f(channel, values[i], i)"
973,"def _get_files_modified():
    """"""Get the list of modified files that are Python or Jinja2.""""""
    cmd = ""git diff-index --cached --name-only --diff-filter=ACMRTUXB HEAD""
    _, files_modified, _ = run(cmd)

    extensions = [re.escape(ext) for ext in list(SUPPORTED_FILES) + ["".rst""]]
    test = ""(?:{0})$"".format(""|"".join(extensions))
    return list(filter(lambda f: re.search(test, f), files_modified))"
974,"def _get_git_author():
    """"""Return the git author from the git variables.""""""
    _, stdout, _ = run(""git var GIT_AUTHOR_IDENT"")

    git_author = stdout[0]
    return git_author[:git_author.find("">"") + 1]"
975,"def _get_component(filename, default=""global""):
    """"""Get component name from filename.""""""
    if hasattr(filename, ""decode""):
        filename = filename.decode()
    parts = filename.split(os.path.sep)

    if len(parts) >= 3:
        if parts[1] in ""modules legacy ext"".split():
            return parts[2]
    if len(parts) >= 2:
        if parts[1] in ""base celery utils"".split():
            return parts[1]
    if len(parts) >= 1:
        if parts[0] in ""grunt docs"".split():
            return parts[0]
    return default"
976,"def _prepare_commit_msg(tmp_file, author, files_modified=None, template=None):
    """"""Prepare the commit message in tmp_file.

    It will build the commit message prefilling the component line, as well
    as the signature using the git author and the modified files.

    The file remains untouched if it is not empty.
    """"""
    files_modified = files_modified or []
    template = template or ""{component}:\n\nSigned-off-by: {author}\n{extra}""
    if hasattr(template, ""decode""):
        template = template.decode()

    with open(tmp_file, ""r"", ""utf-8"") as fh:
        contents = fh.readlines()
        msg = filter(lambda x: not (x.startswith(""#"") or x.isspace()),
                     contents)
        if len(list(msg)):
            return

    component = ""unknown""
    components = _get_components(files_modified)

    if len(components) == 1:
        component = components[0]
    elif len(components) > 1:
        component = ""/"".join(components)
        contents.append(
            ""# WARNING: Multiple components detected - consider splitting ""
            ""commit.\r\n""
        )

    with open(tmp_file, ""w"", ""utf-8"") as fh:
        fh.write(template.format(component=component,
                                 author=author,
                                 extra="""".join(contents)))"
977,"def _check_message(message, options):
    """"""Checking the message and printing the errors.""""""
    options = options or dict()
    options.update(get_options())
    options.update(_read_local_kwalitee_configuration())

    errors = check_message(message, **options)

    if errors:
        for error in errors:
            print(error, file=sys.stderr)

        return False
    return True"
978,"def prepare_commit_msg_hook(argv):
    """"""Hook: prepare a commit message.""""""
    options = get_options()
    # Check if the repo has a configuration repo
    options.update(_read_local_kwalitee_configuration())

    _prepare_commit_msg(argv[1],
                        _get_git_author(),
                        _get_files_modified(),
                        options.get('template'))
    return 0"
979,"def commit_msg_hook(argv):
    """"""Hook: for checking commit message (prevent commit).""""""
    with open(argv[1], ""r"", ""utf-8"") as fh:
        message = ""\n"".join(filter(lambda x: not x.startswith(""#""),
                                   fh.readlines()))
    options = {""allow_empty"": True}

    if not _check_message(message, options):
        click.echo(
            ""Aborting commit due to commit message errors (override with ""
            ""'git commit --no-verify')."", file=sys.stderr)
        raise click.Abort
    return 0"
980,"def post_commit_hook(argv):
    """"""Hook: for checking commit message.""""""
    _, stdout, _ = run(""git log -1 --format=%B HEAD"")
    message = ""\n"".join(stdout)
    options = {""allow_empty"": True}

    if not _check_message(message, options):
        click.echo(
            ""Commit message errors (fix with 'git commit --amend')."",
            file=sys.stderr)
        return 1  # it should not fail with exit
    return 0"
981,"def _read_local_kwalitee_configuration(directory="".""):
    """"""Check if the repo has a ``.kwalitee.yaml`` file.""""""
    filepath = os.path.abspath(os.path.join(directory, '.kwalitee.yml'))
    data = {}
    if os.path.exists(filepath):
        with open(filepath, 'r') as file_read:
            data = yaml.load(file_read.read())
    return data"
982,"def _pre_commit(files, options):
    """"""Run the check on files of the added version.

    They might be different than the one on disk. Equivalent than doing a git
    stash, check, and git stash pop.
    """"""
    errors = []
    tmpdir = mkdtemp()
    files_to_check = []
    try:
        for (file_, content) in files:
            # write staged version of file to temporary directory
            dirname, filename = os.path.split(os.path.abspath(file_))
            prefix = os.path.commonprefix([dirname, tmpdir])
            dirname = os.path.relpath(dirname, start=prefix)
            dirname = os.path.join(tmpdir, dirname)
            if not os.path.isdir(dirname):
                os.makedirs(dirname)
            filename = os.path.join(dirname, filename)
            with open(filename, ""wb"") as fh:
                fh.write(content)
            files_to_check.append((file_, filename))

        for (file_, filename) in files_to_check:
            errors += list(map(lambda x: ""{0}: {1}"".format(file_, x),
                               check_file(filename, **options) or []))
    finally:
        shutil.rmtree(tmpdir, ignore_errors=True)

    return errors"
983,"def pre_commit_hook(argv):
    """"""Hook: checking the staged files.""""""
    options = get_options()
    # Check if the repo has a configuration repo
    options.update(_read_local_kwalitee_configuration())

    files = []
    for filename in _get_files_modified():
        # get the staged version of the file and
        # write the staged version to temp dir with its full path to
        # avoid overwriting files with the same name
        _, stdout, _ = run(""git show :{0}"".format(filename), raw_output=True)
        files.append((filename, stdout))

    errors = _pre_commit(files, options)

    for error in errors:
        if hasattr(error, ""decode""):
            error = error.decode()
        click.echo(error, file=sys.stderr)

    if errors:
        click.echo(
            ""Aborting commit due to kwalitee errors (override with ""
            ""'git commit --no-verify')."",
            file=sys.stderr)
        raise click.Abort
    return 0"
984,"def run(command, raw_output=False):
    """"""Run a command using subprocess.

    :param command: command line to be run
    :type command: str
    :param raw_output: does not attempt to convert the output as unicode
    :type raw_output: bool
    :return: error code, output (``stdout``) and error (``stderr``)
    :rtype: tuple

    """"""
    p = Popen(command.split(), stdout=PIPE, stderr=PIPE)
    (stdout, stderr) = p.communicate()
    # On python 3, subprocess.Popen returns bytes objects.
    if not raw_output:
        return (
            p.returncode,
            [line.rstrip() for line in stdout.decode(""utf-8"").splitlines()],
            [line.rstrip() for line in stderr.decode(""utf-8"").splitlines()]
        )
    else:
        return (p.returncode, stdout, stderr)"
985,"def mpl_weight2qt(weight):
    """"""Convert a weight from matplotlib definition to a Qt weight

    Parameters
    ----------
    weight: int or string
        Either an integer between 1 and 1000 or a string out of
        :attr:`weights_mpl2qt`

    Returns
    -------
    int
        One type of the PyQt5.QtGui.QFont.Weight""""""
    try:
        weight = weights_mpl2qt[weight]
    except KeyError:
        try:
            weight = float(weight) / 10
        except (ValueError, TypeError):
            weight = QtGui.QFont.Normal
        else:
            try:
                weight = min(filter(lambda w: w >= weight, weights_qt2mpl),
                             key=lambda w: abs(w - weight))
            except ValueError:
                weight = QtGui.QFont.Normal
    return weight"
986,"def artist_to_qfont(artist):
        """"""Convert a :class:`matplotlib.text.Text` artist to a QFont object

        Parameters
        ----------
        artist: matplotlib.text.Text
            The text artist, e.g. an axes title

        Returns
        -------
        PyQt5.QtGui.QFont
            The QFont object""""""
        size = int(artist.get_size())
        weight = mpl_weight2qt(artist.get_weight())
        italic = artist.get_style() == 'italic'
        for family in artist.get_family():
            if family in ['sans-serif', 'cursive', 'monospace', 'serif']:
                for name in mpl.rcParams['font.' + family]:
                    font = QtGui.QFont(name, size, weight, italic)
                    if font.exactMatch():
                        break
            else:
                font = QtGui.QFont(family, size, weight, italic)
        return font"
987,"def choose_font(self, font=None):
        """"""Choose a font for the label through a dialog""""""
        fmt_widget = self.parent()
        if font is None:
            if self.current_font:
                font, ok = QFontDialog.getFont(
                    self.current_font, fmt_widget,
                    'Select %s font' % self.fmto_name,
                    QFontDialog.DontUseNativeDialog)
            else:
                font, ok = QFontDialog.getFont(fmt_widget)
            if not ok:
                return
        self.current_font = font
        properties = self.load_properties()
        properties.update(self.qfont_to_artist_props(font))
        fmt_widget.set_obj(properties)
        self.refresh()"
988,"def refresh(self):
        """"""Refresh the widgets from the current font""""""
        font = self.current_font

        # refresh btn_bold
        self.btn_bold.blockSignals(True)
        self.btn_bold.setChecked(font.weight() > 50)
        self.btn_bold.blockSignals(False)

        # refresh btn_italic
        self.btn_italic.blockSignals(True)
        self.btn_italic.setChecked(font.italic())
        self.btn_italic.blockSignals(False)

        # refresh font size
        self.spin_box.blockSignals(True)
        self.spin_box.setValue(font.pointSize())
        self.spin_box.blockSignals(False)"
989,"def init_app(self, app):
        """"""
        Initializes a Flask object `app`: binds the HTML prettifying with
        app.after_request.

        :param app: The Flask application object.
        """"""
        app.config.setdefault('PRETTIFY', False)

        if app.config['PRETTIFY']:
            app.after_request(self._prettify_response)"
990,"def _prettify_response(self, response):
        """"""
        Prettify the HTML response.

        :param response: A Flask Response object.
        """"""
        if response.content_type == 'text/html; charset=utf-8':
            ugly = response.get_data(as_text=True)
            soup = BeautifulSoup(ugly, 'html.parser')
            pretty = soup.prettify(formatter='html')
            response.direct_passthrough = False
            response.set_data(pretty)

        return response"
991,"async def _call(self, params):
        """"""Call the SABnzbd API""""""
        if self._session.closed:
            raise SabnzbdApiException('Session already closed')

        p = {**self._default_params, **params}
        try:
            async with timeout(self._timeout, loop=self._session.loop):
                async with self._session.get(self._api_url, params=p) as resp:
                    data = await resp.json()
                    if data.get('status', True) is False:
                        self._handle_error(data, params)
                    else:
                        return data
        except aiohttp.ClientError:
            raise SabnzbdApiException('Unable to communicate with Sabnzbd API')
        except asyncio.TimeoutError:
            raise SabnzbdApiException('SABnzbd API request timed out')"
992,"async def refresh_data(self):
        """"""Refresh the cached SABnzbd queue data""""""
        queue = await self.get_queue()
        history = await self.get_history()
        totals = {}
        for k in history:
            if k[-4:] == 'size':
                totals[k] = self._convert_size(history.get(k))
        self.queue = {**totals, **queue}"
993,"def _convert_size(self, size_str):
        """"""Convert units to GB""""""
        suffix = size_str[-1]
        if suffix == 'K':
            multiplier = 1.0 / (1024.0 * 1024.0)
        elif suffix == 'M':
            multiplier = 1.0 / 1024.0
        elif suffix == 'T':
            multiplier = 1024.0
        else:
            multiplier = 1

        try:
            val = float(size_str.split(' ')[0])
            return val * multiplier
        except ValueError:
            return 0.0"
994,"def _handle_error(self, data, params):
        """"""Handle an error response from the SABnzbd API""""""
        error = data.get('error', 'API call failed')
        mode = params.get('mode')
        raise SabnzbdApiException(error, mode=mode)"
995,"def __generate_key(self, config):
        """"""
        Generate the ssh key, and return the ssh config location
        """"""
        cwd = config.get('ssh_path', self._install_directory())
        if config.is_affirmative('create', default=""yes""):
            if not os.path.exists(cwd):
                os.makedirs(cwd)
            if not os.path.exists(os.path.join(cwd, config.get('keyname'))):
                command = ""ssh-keygen -t %(type)s -f %(keyname)s -N  "" % config.to_dict()
                lib.call(command, cwd=cwd, output_log_level=logging.DEBUG)
        if not config.has('ssh_path'):
            config.set('ssh_path', cwd)
        config.set('ssh_key_path', os.path.join(config.get('ssh_path'), config.get('keyname')))"
996,"def __install_ssh_config(self, config):
        """"""
        Install the ssh configuration
        """"""
        if not config.is_affirmative('use_global_ssh', default=""no""):
            ssh_config_injection = self._build_ssh_config(config)

            if not os.path.exists(ssh_config_path):

                if self.injections.in_noninjected_file(ssh_config_path, ""Host %s"" % config.get('host')):
                    if config.is_affirmative('override'):
                        self.injections.inject(ssh_config_path, ssh_config_injection)
                else:
                    self.injections.inject(ssh_config_path, ssh_config_injection)

            else:
                self.injections.inject(ssh_config_path, ssh_config_injection)

            self.injections.commit()"
997,"def _build_ssh_config(self, config):
        """""" build the ssh injection configuration """"""
        ssh_config_injection = ssh_config_template % {
            'host': config.get('host'),
            'hostname': config.get('hostname'),
            'ssh_key_path': config.get('ssh_key_path'),
            'user': config.get('user')
        }
        if config.has('port'):
            ssh_config_injection += ""  Port {0}\n"".format(config.get('port'))
        return ssh_config_injection"
998,"def extract_followups(task):
    """"""
    Retrieve callbacks and errbacks from provided task instance, disables
    tasks callbacks.
    """"""
    callbacks = task.request.callbacks
    errbacks = task.request.errbacks
    task.request.callbacks = None
    return {'link': callbacks, 'link_error': errbacks}"
999,"def gen_procfile(ctx, wsgi, dev):
    """"""Generates Procfiles which can be used with honcho or foreman.
    """"""
    if wsgi is None:
        if os.path.exists(""wsgi.py""):
            wsgi = ""wsgi.py""
        elif os.path.exists(""app.py""):
            wsgi = ""app.py""
        else:
            wsgi = ""app.py""
            ctx.invoke(gen_apppy)

    def write_procfile(filename, server_process, debug):
        processes = [server_process] + current_app.processes
        procfile = []
        for name, cmd in procfile_processes(processes, debug).iteritems():
            procfile.append(""%s: %s"" % (name, cmd))
        with open(filename, ""w"") as f:
            f.write(""\n"".join(procfile))

    write_procfile(""Procfile"", (""web"", [""gunicorn"", wsgi]), False)
    if dev:
        write_procfile(""Procfile.dev"", (""web"", [""frasco"", ""serve""]), True)"
1000,"def add(self, host, filename, data, f_type, f_other_type=None, f_text=''):
        """"""
        Add evidence

        :param host: db.t_hosts.id
        :param filename: Filename
        :param data: Content of file
        :param f_type: Evidence type
        :param f_other_type: If f_type is 'Other' what type it is
        :param f_text: Text information about the evidence
        :return: (True/False, response message)
        """"""
        return self.send.evidence_add(host, filename, data, f_type, f_other_type, f_text)"
1001,"def utc_mktime(utc_tuple):
  """"""Returns number of seconds elapsed since epoch
  Note that no timezone are taken into consideration.
  utc tuple must be: (year, month, day, hour, minute, second)
  """"""
  if len(utc_tuple) == 6:
      utc_tuple += (0, 0, 0)
  return time.mktime(utc_tuple) - time.mktime((1970, 1, 1, 0, 0, 0, 0, 0, 0))"
1002,"def f(self):
        """"""
        Time, in 12-hour hours and minutes, with minutes left off if they're
        zero.
        Examples: '1', '1:30', '2:05', '2'
        Proprietary extension.
        """"""
        if self.data.minute == 0:
            return self.g()
        return u'%s:%s' % (self.g(), self.i())"
1003,"def g(self):
        ""Hour, 12-hour format without leading zeros; i.e. '1' to '12'""
        if self.data.hour == 0:
            return 12
        if self.data.hour > 12:
            return self.data.hour - 12
        return self.data.hour"
1004,"def P(self):
        """"""
        Time, in 12-hour hours, minutes and 'a.m.'/'p.m.', with minutes left off
        if they're zero and the strings 'midnight' and 'noon' if appropriate.
        Examples: '1 a.m.', '1:30 p.m.', 'midnight', 'noon', '12:30 p.m.'
        Proprietary extension.
        """"""
        if self.data.minute == 0 and self.data.hour == 0:
            return _('midnight')
        if self.data.minute == 0 and self.data.hour == 12:
            return _('noon')
        return u'%s %s' % (self.f(), self.a())"
1005,"def I(self):
    ""'1' if Daylight Savings Time, '0' otherwise.""
    if self.timezone and self.timezone.dst(self.data):
      return u'1'
    else:
      return u'0'"
1006,"def S(self):
    ""English ordinal suffix for the day of the month, 2 characters; i.e. 'st', 'nd', 'rd' or 'th'""
    if self.data.day in (11, 12, 13): # Special case
      return u'th'
    last = self.data.day % 10
    if last == 1:
      return u'st'
    if last == 2:
      return u'nd'
    if last == 3:
      return u'rd'
    return u'th'"
1007,"def t(self):
    ""Number of days in the given month; i.e. '28' to '31'""
    return u'%02d' % calendar.monthrange(self.data.year, self.data.month)[1]"
1008,"def T(self):
    ""Time zone of this machine; e.g. 'EST' or 'MDT'""
    name = self.timezone and self.timezone.tzname(self.data) or None
    if name is None:
      name = self.format('O')
    return unicode(name)"
1009,"def U(self):
    ""Seconds since the Unix epoch (January 1 1970 00:00:00 GMT)""
    if getattr(self.data, 'tzinfo', None):
      return int(calendar.timegm(self.data.utctimetuple()))
    else:
      return int(time.mktime(self.data.timetuple()))"
1010,"def W(self):
    ""ISO-8601 week number of year, weeks starting on Monday""
    # Algorithm from http://www.personal.ecu.edu/mccartyr/ISOwdALG.txt
    week_number = None
    jan1_weekday = self.data.replace(month=1, day=1).weekday() + 1
    weekday = self.data.weekday() + 1
    day_of_year = self.z()
    if day_of_year <= (8 - jan1_weekday) and jan1_weekday > 4:
      if jan1_weekday == 5 or (jan1_weekday == 6 and calendar.isleap(self.data.year-1)):
        week_number = 53
      else:
        week_number = 52
    else:
      if calendar.isleap(self.data.year):
        i = 366
      else:
        i = 365
      if (i - day_of_year) < (4 - weekday):
        week_number = 1
      else:
        j = day_of_year + (7 - weekday) + (jan1_weekday - 1)
        week_number = j // 7
        if jan1_weekday > 4:
          week_number -= 1
    return week_number"
1011,"def z(self):
    ""Day of the year; i.e. '0' to '365'""
    doy = self.year_days[self.data.month] + self.data.day
    if self.L() and self.data.month > 2:
      doy += 1
    return doy"
1012,"def Z(self):
    """"""
    Time zone offset in seconds (i.e. '-43200' to '43200'). The offset for
    timezones west of UTC is always negative, and for those east of UTC is
    always positive.
    """"""
    if not self.timezone:
      return 0
    offset = self.timezone.utcoffset(self.data)
    # Only days can be negative, so negative offsets have days=-1 and
    # seconds positive. Positive offsets have days=0
    return offset.days * 86400 + offset.seconds"
1013,"def print_metric(name, count, elapsed):
    """"""A metric function that prints to standard output

    :arg str name: name of the metric
    :arg int count: number of items
    :arg float elapsed: time in seconds
    """"""
    _do_print(name, count, elapsed, file=sys.stdout)"
1014,"def stderr_metric(name, count, elapsed):
    """"""A metric function that prints to standard error

    :arg str name: name of the metric
    :arg int count: number of items
    :arg float elapsed: time in seconds
    """"""
    _do_print(name, count, elapsed, file=sys.stderr)"
1015,"def make_multi_metric(*metrics):
    """"""Make a new metric function that calls the supplied metrics

    :arg functions metrics: metric functions
    :rtype: function
    """"""
    def multi_metric(name, count, elapsed):
        """"""Calls multiple metrics (closure)""""""
        for m in metrics:
            m(name, count, elapsed)
    return multi_metric"
1016,"def _is_orphan(scc, graph):
    """"""
    Return False iff the given scc is reachable from elsewhere.

    """"""
    return all(p in scc for v in scc for p in graph.parents(v))"
1017,"def key_cycles():
    """"""
    Collect cyclic garbage, and return the strongly connected
    components that were keeping the garbage alive.

    """"""
    graph = garbage()
    sccs = graph.strongly_connected_components()
    return [scc for scc in sccs if _is_orphan(scc, graph)]"
1018,"def _run_command(self, command, **kwargs):
        """"""Wrapper to pass command to plowshare.

        :param command: The command to pass to plowshare.
        :type command: str
        :param **kwargs: Additional keywords passed into
        :type **kwargs: dict
        :returns: Object containing either output of plowshare command or an
                  error message.
        :rtype: dict
        :raises: Exception
        """"""
        try:
            return {'output': subprocess.check_output(command, **kwargs)}
        except Exception as e:
            return {'error': str(e)}"
1019,"def _hosts_by_success(self, hosts=[]):
        """"""Order hosts by most successful (least amount of errors) first.

        :param hosts: List of hosts.
        :type hosts: list
        :returns: List of hosts sorted by successful connections.
        :rtype: list
        """"""
        hosts = hosts if hosts else self.hosts
        return sorted(hosts, key=lambda h: self._host_errors[h])"
1020,"def _filter_sources(self, sources):
        """"""Remove sources with errors and return ordered by host success.

        :param sources: List of potential sources to connect to.
        :type sources: list
        :returns: Sorted list of potential sources without errors.
        :rtype: list
        """"""
        filtered, hosts = [], []
        for source in sources:
            if 'error' in source:
                continue
            filtered.append(source)
            hosts.append(source['host_name'])

        return sorted(filtered, key=lambda s:
                      self._hosts_by_success(hosts).index(s['host_name']))"
1021,"def upload(self, filename, number_of_hosts):
        """"""Upload the given file to the specified number of hosts.

        :param filename: The filename of the file to upload.
        :type filename: str
        :param number_of_hosts: The number of hosts to connect to.
        :type number_of_hosts: int
        :returns:  A list of dicts with 'host_name' and 'url' keys for all
                   successful uploads or an empty list if all uploads failed.
        :rtype: list
        """"""
        return self.multiupload(filename, self.random_hosts(number_of_hosts))"
1022,"def download(self, sources, output_directory, filename):
        """"""Download a file from one of the provided sources

        The sources will be ordered by least amount of errors, so most
        successful hosts will be tried first. In case of failure, the next
        source will be attempted, until the first successful download is
        completed or all sources have been depleted.

        :param sources: A list of dicts with 'host_name' and 'url' keys.
        :type sources: list
        :param output_directory: Directory to save the downloaded file in.
        :type output_directory: str
        :param filename: Filename assigned to the downloaded file.
        :type filename: str
        :returns: A dict with 'host_name' and 'filename' keys if the download
                  is successful, or an empty dict otherwise.
        :rtype: dict
        """"""
        valid_sources = self._filter_sources(sources)
        if not valid_sources:
            return {'error': 'no valid sources'}

        manager = Manager()
        successful_downloads = manager.list([])

        def f(source):
            if not successful_downloads:
                result = self.download_from_host(
                    source, output_directory, filename)
                if 'error' in result:
                    self._host_errors[source['host_name']] += 1
                else:
                    successful_downloads.append(result)

        multiprocessing.dummy.Pool(len(valid_sources)).map(f, valid_sources)

        return successful_downloads[0] if successful_downloads else {}"
1023,"def download_from_host(self, source, output_directory, filename):
        """"""Download a file from a given host.

        This method renames the file to the given string.

        :param source: Dictionary containing information about host.
        :type source: dict
        :param output_directory: Directory to place output in.
        :type output_directory: str
        :param filename: The filename to rename to.
        :type filename: str
        :returns: Dictionary with information about downloaded file.
        :rtype: dict
        """"""
        result = self._run_command(
            [""plowdown"", source[""url""], ""-o"",
                output_directory, ""--temp-rename""],
            stderr=open(""/dev/null"", ""w"")
        )

        result['host_name'] = source['host_name']

        if 'error' in result:
            return result

        temporary_filename = self.parse_output(
            result['host_name'], result['output'])
        result['filename'] = os.path.join(output_directory, filename)
        result.pop('output')

        os.rename(temporary_filename, result['filename'])

        return result"
1024,"def multiupload(self, filename, hosts):
        """"""Upload file to multiple hosts simultaneously

        The upload will be attempted for each host until the optimal file
        redundancy is achieved (a percentage of successful uploads) or the host
        list is depleted.

        :param filename: The filename of the file to upload.
        :type filename: str
        :param hosts: A list of hosts as defined in the master host list.
        :type hosts: list
        :returns:  A list of dicts with 'host_name' and 'url' keys for all
                   successful uploads or an empty list if all uploads failed.
        :rtype: list
        """"""
        manager = Manager()
        successful_uploads = manager.list([])

        def f(host):
            if len(successful_uploads) / float(len(hosts)) < \
                    settings.MIN_FILE_REDUNDANCY:
                # Optimal redundancy not achieved, keep going
                result = self.upload_to_host(filename, host)
                if 'error' in result:
                    self._host_errors[host] += 1
                else:
                    successful_uploads.append(result)

        multiprocessing.dummy.Pool(len(hosts)).map(
            f, self._hosts_by_success(hosts))

        return list(successful_uploads)"
1025,"def upload_to_host(self, filename, hostname):
        """"""Upload a file to the given host.

        This method relies on 'plowup' being installed on the system.
        If it succeeds, this method returns a dictionary with the host name,
        and the final URL. Otherwise, it returns a dictionary with the
        host name and an error flag.

        :param filename: The filename of the file to upload.
        :type filename: str
        :param hostname: The host you are uploading the file to.
        :type hostname: str
        :returns: Dictionary containing information about upload to host.
        :rtype: dict
        """"""
        result = self._run_command(
            [""plowup"", hostname, filename],
            stderr=open(""/dev/null"", ""w"")
        )

        result['host_name'] = hostname
        if 'error' not in result:
            result['url'] = self.parse_output(hostname, result.pop('output'))

        return result"
1026,"def parse_output(self, hostname, output):
        """"""Parse plowup's output.

        For now, we just return the last line.

        :param hostname: Name of host you are working with.
        :type hostname: str
        :param output: Dictionary containing information about a plowshare
                       action.
        :type output: dict
        :returns: Parsed and decoded output list.
        :rtype: list
        """"""
        if isinstance(output, bytes):
            output = output.decode('utf-8')
        return output.split()[-1]"
1027,"def set(self, keyword, default, from_env=True):
        """"""
        Set value on self if not already set. If unset, attempt to
        retrieve from environment variable of same name (unless disabled
        via 'from_env'). If 'default' value is not a string, evaluate
        environment variable as a Python type. If no env variables are
        found, fallback to 'default' value.
        """"""
        env_key = '{}{}'.format(self.ENV_PREFIX, keyword.upper())
        if hasattr(self, keyword):
            return getattr(self, keyword)
        value = default
        if from_env and (env_key in env):
            env_val = env.get(env_key)
            should_eval = not isinstance(default, str)
            try:
                value = literal_eval(env_val) if should_eval else env_val
            except (ValueError, SyntaxError):
                raise ValueError(""Unable to cast %r to %r"" % (
                    env_val, type.__name__))
        setattr(self, keyword, value)
        return getattr(self, keyword)"
1028,"def _generate_queues(queues, exchange, platform_queue):
        """""" Queues known by this worker """"""
        return set([
            Queue('celery', exchange, routing_key='celery'),
            Queue(platform_queue, exchange, routing_key='#'),
        ] + [
            Queue(q_name, exchange, routing_key=q_name)
            for q_name in queues
        ])"
1029,"def _erf(x):
    """"""
    Port of cephes ``ndtr.c`` ``erf`` function.

    See https://github.com/jeremybarnes/cephes/blob/master/cprob/ndtr.c
    """"""
    T = [
        9.60497373987051638749E0,
        9.00260197203842689217E1,
        2.23200534594684319226E3,
        7.00332514112805075473E3,
        5.55923013010394962768E4,
    ]

    U = [
        3.35617141647503099647E1,
        5.21357949780152679795E2,
        4.59432382970980127987E3,
        2.26290000613890934246E4,
        4.92673942608635921086E4,
    ]

    # Shorcut special cases
    if x == 0:
        return 0
    if x >= MAXVAL:
        return 1
    if x <= -MAXVAL:
        return -1

    if abs(x) > 1:
        return 1 - erfc(x)

    z = x * x
    return x * _polevl(z, T, 4) / _p1evl(z, U, 5)"
1030,"def _erfc(a):
    """"""
    Port of cephes ``ndtr.c`` ``erfc`` function.

    See https://github.com/jeremybarnes/cephes/blob/master/cprob/ndtr.c
    """"""
    # approximation for abs(a) < 8 and abs(a) >= 1
    P = [
        2.46196981473530512524E-10,
        5.64189564831068821977E-1,
        7.46321056442269912687E0,
        4.86371970985681366614E1,
        1.96520832956077098242E2,
        5.26445194995477358631E2,
        9.34528527171957607540E2,
        1.02755188689515710272E3,
        5.57535335369399327526E2,
    ]

    Q = [
        1.32281951154744992508E1,
        8.67072140885989742329E1,
        3.54937778887819891062E2,
        9.75708501743205489753E2,
        1.82390916687909736289E3,
        2.24633760818710981792E3,
        1.65666309194161350182E3,
        5.57535340817727675546E2,
    ]

    # approximation for abs(a) >= 8
    R = [
        5.64189583547755073984E-1,
        1.27536670759978104416E0,
        5.01905042251180477414E0,
        6.16021097993053585195E0,
        7.40974269950448939160E0,
        2.97886665372100240670E0,
    ]

    S = [
        2.26052863220117276590E0,
        9.39603524938001434673E0,
        1.20489539808096656605E1,
        1.70814450747565897222E1,
        9.60896809063285878198E0,
        3.36907645100081516050E0,
    ]

    # Shortcut special cases
    if a == 0:
        return 1
    if a >= MAXVAL:
        return 0
    if a <= -MAXVAL:
        return 2

    x = a
    if a < 0:
        x = -a

    # computationally cheaper to calculate erf for small values, I guess.
    if x < 1:
        return 1 - erf(a)

    z = -a * a

    z = math.exp(z)

    if x < 8:
        p = _polevl(x, P, 8)
        q = _p1evl(x, Q, 8)
    else:
        p = _polevl(x, R, 5)
        q = _p1evl(x, S, 6)

    y = (z * p) / q

    if a < 0:
        y = 2 - y

    return y"
1031,"def _polevl(x, coefs, N):
    """"""
    Port of cephes ``polevl.c``: evaluate polynomial

    See https://github.com/jeremybarnes/cephes/blob/master/cprob/polevl.c
    """"""
    ans = 0
    power = len(coefs) - 1
    for coef in coefs:
        try:
            ans += coef * x**power
        except OverflowError:
            pass
        power -= 1
    return ans"
1032,"def _ndtri(y):
    """"""
    Port of cephes ``ndtri.c``: inverse normal distribution function.

    See https://github.com/jeremybarnes/cephes/blob/master/cprob/ndtri.c
    """"""
    # approximation for 0 <= abs(z - 0.5) <= 3/8
    P0 = [
        -5.99633501014107895267E1,
        9.80010754185999661536E1,
        -5.66762857469070293439E1,
        1.39312609387279679503E1,
        -1.23916583867381258016E0,
    ]

    Q0 = [
        1.95448858338141759834E0,
        4.67627912898881538453E0,
        8.63602421390890590575E1,
        -2.25462687854119370527E2,
        2.00260212380060660359E2,
        -8.20372256168333339912E1,
        1.59056225126211695515E1,
        -1.18331621121330003142E0,
    ]

    # Approximation for interval z = sqrt(-2 log y ) between 2 and 8
    # i.e., y between exp(-2) = .135 and exp(-32) = 1.27e-14.
    P1 = [
        4.05544892305962419923E0,
        3.15251094599893866154E1,
        5.71628192246421288162E1,
        4.40805073893200834700E1,
        1.46849561928858024014E1,
        2.18663306850790267539E0,
        -1.40256079171354495875E-1,
        -3.50424626827848203418E-2,
        -8.57456785154685413611E-4,
    ]

    Q1 = [
        1.57799883256466749731E1,
        4.53907635128879210584E1,
        4.13172038254672030440E1,
        1.50425385692907503408E1,
        2.50464946208309415979E0,
        -1.42182922854787788574E-1,
        -3.80806407691578277194E-2,
        -9.33259480895457427372E-4,
    ]

    # Approximation for interval z = sqrt(-2 log y ) between 8 and 64
    # i.e., y between exp(-32) = 1.27e-14 and exp(-2048) = 3.67e-890.
    P2 = [
        3.23774891776946035970E0,
        6.91522889068984211695E0,
        3.93881025292474443415E0,
        1.33303460815807542389E0,
        2.01485389549179081538E-1,
        1.23716634817820021358E-2,
        3.01581553508235416007E-4,
        2.65806974686737550832E-6,
        6.23974539184983293730E-9,
    ]

    Q2 = [
        6.02427039364742014255E0,
        3.67983563856160859403E0,
        1.37702099489081330271E0,
        2.16236993594496635890E-1,
        1.34204006088543189037E-2,
        3.28014464682127739104E-4,
        2.89247864745380683936E-6,
        6.79019408009981274425E-9,
    ]

    sign_flag = 1

    if y > (1 - EXP_NEG2):
        y = 1 - y
        sign_flag = 0

    # Shortcut case where we don't need high precision
    # between -0.135 and 0.135
    if y > EXP_NEG2:
        y -= 0.5
        y2 = y ** 2
        x = y + y * (y2 * _polevl(y2, P0, 4) / _p1evl(y2, Q0, 8))
        x = x * ROOT_2PI
        return x

    x = math.sqrt(-2.0 * math.log(y))
    x0 = x - math.log(x) / x

    z = 1.0 / x
    if x < 8.0:                 # y > exp(-32) = 1.2664165549e-14
        x1 = z * _polevl(z, P1, 8) / _p1evl(z, Q1, 8)
    else:
        x1 = z * _polevl(z, P2, 8) / _p1evl(z, Q2, 8)

    x = x0 - x1
    if sign_flag != 0:
        x = -x

    return x"
1033,"def erfinv(z):
    """"""
    Calculate the inverse error function at point ``z``.

    This is a direct port of the SciPy ``erfinv`` function, originally
    written in C.

    Parameters
    ----------
    z : numeric

    Returns
    -------
    float

    References
    ----------
    + https://en.wikipedia.org/wiki/Error_function#Inverse_functions
    + http://functions.wolfram.com/GammaBetaErf/InverseErf/

    Examples
    --------
    >>> round(erfinv(0.1), 12)
    0.088855990494
    >>> round(erfinv(0.5), 12)
    0.476936276204
    >>> round(erfinv(-0.5), 12)
    -0.476936276204
    >>> round(erfinv(0.95), 12)
    1.38590382435
    >>> round(erf(erfinv(0.3)), 3)
    0.3
    >>> round(erfinv(erf(0.5)), 3)
    0.5
    >>> erfinv(0)
    0
    >>> erfinv(1)
    inf
    >>> erfinv(-1)
    -inf
    """"""
    if abs(z) > 1:
        raise ValueError(""`z` must be between -1 and 1 inclusive"")

    # Shortcut special cases
    if z == 0:
        return 0
    if z == 1:
        return inf
    if z == -1:
        return -inf

    # otherwise calculate things.
    return _ndtri((z + 1) / 2.0) / math.sqrt(2)"
1034,"def get_cmap(name, lut=None):
    """"""
    Returns the specified colormap.

    Parameters
    ----------
    name: str or :class:`matplotlib.colors.Colormap`
        If a colormap, it returned unchanged.
        %(cmap_note)s
    lut: int
        An integer giving the number of entries desired in the lookup table

    Returns
    -------
    matplotlib.colors.Colormap
        The colormap specified by `name`

    See Also
    --------
    show_colormaps: A function to display all available colormaps

    Notes
    -----
    Different from the :func::`matpltolib.pyplot.get_cmap` function, this
    function changes the number of colors if `name` is a
    :class:`matplotlib.colors.Colormap` instance to match the given `lut`.""""""
    if name in rcParams['colors.cmaps']:
        colors = rcParams['colors.cmaps'][name]
        lut = lut or len(colors)
        return FixedColorMap.from_list(name=name, colors=colors, N=lut)
    elif name in _cmapnames:
        colors = _cmapnames[name]
        lut = lut or len(colors)
        return FixedColorMap.from_list(name=name, colors=colors, N=lut)
    else:
        cmap = mpl_get_cmap(name)
        # Note: we could include the `lut` in the call of mpl_get_cmap, but
        # this raises a ValueError for colormaps like 'viridis' in mpl version
        # 1.5. Besides the mpl_get_cmap function does not modify the lut if
        # it does not match
        if lut is not None and cmap.N != lut:
            cmap = FixedColorMap.from_list(
                name=cmap.name, colors=cmap(np.linspace(0, 1, lut)), N=lut)
        return cmap"
1035,"def _get_cmaps(names):
    """"""Filter the given `names` for colormaps""""""
    import matplotlib.pyplot as plt
    available_cmaps = list(
        chain(plt.cm.cmap_d, _cmapnames, rcParams['colors.cmaps']))
    names = list(names)
    wrongs = []
    for arg in (arg for arg in names if (not isinstance(arg, Colormap) and
                                         arg not in available_cmaps)):
        if isinstance(arg, str):
            similarkeys = get_close_matches(arg, available_cmaps)
        if similarkeys != []:
            warn(""Colormap %s not found in standard colormaps.\n""
                 ""Similar colormaps are %s."" % (arg, ', '.join(similarkeys)))
        else:
            warn(""Colormap %s not found in standard colormaps.\n""
                 ""Run function without arguments to see all colormaps"" % arg)
        names.remove(arg)
        wrongs.append(arg)
    if not names and not wrongs:
        names = sorted(m for m in available_cmaps if not m.endswith(""_r""))
    return names"
1036,"def show_colormaps(names=[], N=10, show=True, use_qt=None):
    """"""Function to show standard colormaps from pyplot

    Parameters
    ----------
    ``*args``: str or :class:`matplotlib.colors.Colormap`
        If a colormap, it returned unchanged.
        %(cmap_note)s
    N: int, optional
        Default: 11. The number of increments in the colormap.
    show: bool, optional
        Default: True. If True, show the created figure at the end with
        pyplot.show(block=False)
    use_qt: bool
        If True, use the
        :class:`psy_simple.widgets.color.ColormapDialog.show_colormaps`, if
        False use a matplotlib implementation based on [1]_. If None, use
        the Qt implementation if it is running in the psyplot GUI.

    Returns
    -------
    psy_simple.widgets.color.ColormapDialog or matplitlib.figure.Figure
        Depending on `use_qt`, either an instance of the
        :class:`psy_simple.widgets.color.ColormapDialog` or the
        :class:`matplotlib.figure.Figure`

    References
    ----------
    .. [1] http://matplotlib.org/1.2.1/examples/pylab_examples/show_colormaps.html
    """"""
    names = safe_list(names)
    if use_qt or (use_qt is None and psyplot.with_gui):
        from psy_simple.widgets.colors import ColormapDialog
        from psyplot_gui.main import mainwindow
        return ColormapDialog.show_colormap(names, N, show, parent=mainwindow)
    import matplotlib.pyplot as plt
    # This example comes from the Cookbook on www.scipy.org.  According to the
    # history, Andrew Straw did the conversion from an old page, but it is
    # unclear who the original author is.
    a = np.vstack((np.linspace(0, 1, 256).reshape(1, -1)))
    # Get a list of the colormaps in matplotlib.  Ignore the ones that end with
    # '_r' because these are simply reversed versions of ones that don't end
    # with '_r'
    cmaps = _get_cmaps(names)
    nargs = len(cmaps) + 1
    fig = plt.figure(figsize=(5, 10))
    fig.subplots_adjust(top=0.99, bottom=0.01, left=0.2, right=0.99)
    for i, m in enumerate(cmaps):
        ax = plt.subplot(nargs, 1, i+1)
        plt.axis(""off"")
        plt.pcolormesh(a, cmap=get_cmap(m, N + 1))
        pos = list(ax.get_position().bounds)
        fig.text(pos[0] - 0.01, pos[1], m, fontsize=10,
                 horizontalalignment='right')
    fig.canvas.set_window_title(""Figure %i: Predefined colormaps"" % fig.number)
    if show:
        plt.show(block=False)
    return fig"
1037,"def _create_stdout_logger(logging_level):
    """"""
    create a logger to stdout. This creates logger for a series
    of module we would like to log information on.
    """"""
    out_hdlr = logging.StreamHandler(sys.stdout)
    out_hdlr.setFormatter(logging.Formatter(
        '[%(asctime)s] %(message)s', ""%H:%M:%S""
    ))
    out_hdlr.setLevel(logging_level)
    for name in LOGGING_NAMES:
        log = logging.getLogger(name)
        log.addHandler(out_hdlr)
        log.setLevel(logging_level)"
1038,"def main():
    """"""Generate a PDF using the async method.""""""
    docraptor = DocRaptor()

    print(""Create PDF"")
    resp = docraptor.create(
        {
            ""document_content"": ""<h1>python-docraptor</h1><p>Async Test</p>"",
            ""test"": True,
            ""async"": True,
        }
    )
    print(""Status ID: {status_id}"".format(status_id=resp[""status_id""]))

    status_id = resp[""status_id""]
    resp = docraptor.status(status_id)

    print(""    {status}"".format(status=resp[""status""]))
    while resp[""status""] != ""completed"":
        time.sleep(3)
        resp = docraptor.status(status_id)
        print(""    {status}"".format(status=resp[""status""]))

    print(""Download to test_async.pdf"")
    with open(""test_async.pdf"", ""wb"") as pdf_file:
        pdf_file.write(docraptor.download(resp[""download_key""]).content)
    print(""[DONE]"")"
1039,"def get_alternate_types_resolving_forwardref_union_and_typevar(typ, _memo: List[Any] = None) \
        -> Tuple[Any, ...]:
    """"""
    Returns a tuple of all alternate types allowed by the `typ` type annotation.

    If typ is a TypeVar,
     * if the typevar is bound, return get_alternate_types_resolving_forwardref_union_and_typevar(bound)
     * if the typevar has constraints, return a tuple containing all the types listed in the constraints (with
     appropriate recursive call to get_alternate_types_resolving_forwardref_union_and_typevar for each of them)
     * otherwise return (object, )

    If typ is a Union, return a tuple containing all the types listed in the union (with
     appropriate recursive call to get_alternate_types_resolving_forwardref_union_and_typevar for each of them)

    If typ is a forward reference, it is evaluated and this method is applied to the results.

    Otherwise (typ, ) is returned

    Note that this function automatically prevent infinite recursion through forward references such as in
    `A = Union[str, 'A']`, by keeping a _memo of already met symbols.

    :param typ: 
    :return: 
    """"""
    # avoid infinite recursion by using a _memo
    _memo = _memo or []
    if typ in _memo:
        return tuple()

    # remember that this was already explored
    _memo.append(typ)
    if is_typevar(typ):
        if hasattr(typ, '__bound__') and typ.__bound__ is not None:
            # TypeVar is 'bound' to a class
            if hasattr(typ, '__contravariant__') and typ.__contravariant__:
                # Contravariant means that only super classes of this type are supported!
                raise Exception('Contravariant TypeVars are not supported')
            else:
                # only subclasses of this are allowed (even if not covariant, because as of today we cant do otherwise)
                return get_alternate_types_resolving_forwardref_union_and_typevar(typ.__bound__, _memo=_memo)

        elif hasattr(typ, '__constraints__') and typ.__constraints__ is not None:
            if hasattr(typ, '__contravariant__') and typ.__contravariant__:
                # Contravariant means that only super classes of this type are supported!
                raise Exception('Contravariant TypeVars are not supported')
            else:
                # TypeVar is 'constrained' to several alternate classes, meaning that subclasses of any of them are
                # allowed (even if not covariant, because as of today we cant do otherwise)
                return tuple(typpp for c in typ.__constraints__
                             for typpp in get_alternate_types_resolving_forwardref_union_and_typevar(c, _memo=_memo))

        else:
            # A non-parametrized TypeVar means 'any'
            return object,

    elif is_union_type(typ):
        # do not use typ.__args__, it may be wrong
        # the solution below works even in typevar+config cases such as u = Union[T, str][Optional[int]]
        return tuple(t for typpp in get_args(typ, evaluate=True)
                     for t in get_alternate_types_resolving_forwardref_union_and_typevar(typpp, _memo=_memo))

    elif is_forward_ref(typ):
        return get_alternate_types_resolving_forwardref_union_and_typevar(resolve_forward_ref(typ), _memo=_memo)

    else:
        return typ,"
1040,"def robust_isinstance(inst, typ) -> bool:
    """"""
    Similar to isinstance, but if 'typ' is a parametrized generic Type, it is first transformed into its base generic
    class so that the instance check works. It is also robust to Union and Any.

    :param inst:
    :param typ:
    :return:
    """"""
    if typ is Any:
        return True
    if is_typevar(typ):
        if hasattr(typ, '__constraints__') and typ.__constraints__ is not None:
            typs = get_args(typ, evaluate=True)
            return any(robust_isinstance(inst, t) for t in typs)
        elif hasattr(typ, '__bound__') and typ.__bound__ is not None:
            return robust_isinstance(inst, typ.__bound__)
        else:
            # a raw TypeVar means 'anything'
            return True
    else:
        if is_union_type(typ):
            typs = get_args(typ, evaluate=True)
            return any(robust_isinstance(inst, t) for t in typs)
        else:
            return isinstance(inst, get_base_generic_type(typ))"
1041,"def get_pretty_type_str(object_type) -> str:
    """"""
    Utility method to check if a type is a subclass of typing.{List,Dict,Set,Tuple}. In that case returns a
    user-friendly character string with the inner item types, such as Dict[str, int].

    :param object_type:
    :return: type.__name__ if type is not a subclass of typing.{List,Dict,Set,Tuple}, otherwise
    type__name__[list of inner_types.__name__]
    """"""

    try:
        # DO NOT resolve forward references otherwise this can lead to infinite recursion
        contents_item_type, contents_key_type = _extract_collection_base_type(object_type, resolve_fwd_refs=False)
        if isinstance(contents_item_type, tuple):
            return object_type.__name__ + '[' \
                   + ', '.join([get_pretty_type_str(item_type) for item_type in contents_item_type]) + ']'
        else:
            if contents_key_type is not None:
                return object_type.__name__ + '[' + get_pretty_type_str(contents_key_type) + ', ' \
                       + get_pretty_type_str(contents_item_type) + ']'
            elif contents_item_type is not None:
                return object_type.__name__ + '[' + get_pretty_type_str(contents_item_type) + ']'
    except Exception as e:
        pass

    if is_union_type(object_type):
        return 'Union[' + ', '.join([get_pretty_type_str(item_type) 
                                     for item_type in get_args(object_type, evaluate=True)]) + ']'
    elif is_typevar(object_type):
        # typevars usually do not display their namespace so str() is compact. And it displays the cov/contrav symbol
        return str(object_type)
    else:
        try:
            return object_type.__name__
        except:
            return str(object_type)"
1042,"def is_collection(object_type, strict: bool = False) -> bool:
    """"""
    Utility method to check if a type is a subclass of typing.{List,Dict,Set,Tuple}
    or of list, dict, set, tuple.

    If strict is set to True, the method will return True only if the class IS directly one of the base collection
    classes

    :param object_type:
    :param strict: if set to True, this method will look for a strict match.
    :return:
    """"""
    if object_type is None or object_type is Any or is_union_type(object_type) or is_typevar(object_type):
        return False
    elif strict:
        return object_type == dict \
               or object_type == list \
               or object_type == tuple \
               or object_type == set \
               or get_base_generic_type(object_type) == Dict \
               or get_base_generic_type(object_type) == List \
               or get_base_generic_type(object_type) == Set \
               or get_base_generic_type(object_type) == Tuple
    else:
        return issubclass(object_type, Dict) \
               or issubclass(object_type, List) \
               or issubclass(object_type, Set) \
               or issubclass(object_type, Tuple) \
               or issubclass(object_type, dict) \
               or issubclass(object_type, list) \
               or issubclass(object_type, tuple) \
               or issubclass(object_type, set)"
1043,"def get_all_subclasses(typ, recursive: bool = True, _memo = None) -> Sequence[Type[Any]]:
    """"""
    Returns all subclasses, and supports generic types. It is recursive by default
    See discussion at https://github.com/Stewori/pytypes/issues/31

    :param typ:
    :param recursive: a boolean indicating whether recursion is needed
    :param _memo: internal variable used in recursion to avoid exploring subclasses that were already explored
    :return:
    """"""
    _memo = _memo or set()

    # if we have collected the subclasses for this already, return
    if typ in _memo:
        return []

    # else remember that we have collected them, and collect them
    _memo.add(typ)
    if is_generic_type(typ):
        # We now use get_origin() to also find all the concrete subclasses in case the desired type is a generic
        sub_list = get_origin(typ).__subclasses__()
    else:
        sub_list = typ.__subclasses__()

    # recurse
    result = []
    for t in sub_list:
        # only keep the origins in the list
        to = get_origin(t) or t
        try:
            if to is not typ and to not in result and is_subtype(to, typ, bound_typevars={}):
                result.append(to)
        except:
            # catching an error with is_subtype(Dict, Dict[str, int], bound_typevars={})
            pass

    # recurse
    if recursive:
        for typpp in sub_list:
            for t in get_all_subclasses(typpp, recursive=True, _memo=_memo):
                # unfortunately we have to check 't not in sub_list' because with generics strange things happen
                # also is_subtype returns false when the parent is a generic
                if t not in sub_list and is_subtype(t, typ, bound_typevars={}):
                    result.append(t)

    return result"
1044,"def eval_forward_ref(typ: _ForwardRef):
    """"""
    Climbs the current stack until the given Forward reference has been resolved, or raises an InvalidForwardRefError

    :param typ: the forward reference to resolve
    :return:
    """"""
    for frame in stack():
        m = getmodule(frame[0])
        m_name = m.__name__ if m is not None else '<unknown>'
        if m_name.startswith('parsyfiles.tests') or not m_name.startswith('parsyfiles'):
            try:
                # print(""File {}:{}"".format(frame.filename, frame.lineno))
                return typ._eval_type(frame[0].f_globals, frame[0].f_locals)
            except NameError:
                pass

    raise InvalidForwardRefError(typ)"
1045,"def is_valid_pep484_type_hint(typ_hint, allow_forward_refs: bool = False):
    """"""
    Returns True if the provided type is a valid PEP484 type hint, False otherwise.

    Note: string type hints (forward references) are not supported by default, since callers of this function in
    parsyfiles lib actually require them to be resolved already.

    :param typ_hint:
    :param allow_forward_refs:
    :return:
    """"""
    # most common case first, to be faster
    try:
        if isinstance(typ_hint, type):
            return True
    except:
        pass

    # optionally, check forward reference
    try:
        if allow_forward_refs and is_forward_ref(typ_hint):
            return True
    except:
        pass

    # finally check unions and typevars
    try:
        return is_union_type(typ_hint) or is_typevar(typ_hint)
    except:
        return False"
1046,"def is_pep484_nonable(typ):
    """"""
    Checks if a given type is nonable, meaning that it explicitly or implicitly declares a Union with NoneType.
    Nested TypeVars and Unions are supported.

    :param typ:
    :return:
    """"""
    # TODO rely on typing_inspect if there is an answer to https://github.com/ilevkivskyi/typing_inspect/issues/14
    if typ is type(None):
        return True
    elif is_typevar(typ) or is_union_type(typ):
        return any(is_pep484_nonable(tt) for tt in get_alternate_types_resolving_forwardref_union_and_typevar(typ))
    else:
        return False"
1047,"def _extract_collection_base_type(collection_object_type, exception_if_none: bool = True,
                                  resolve_fwd_refs: bool = True) -> Tuple[Type, Optional[Type]]:
    """"""
    Utility method to extract the base item type from a collection/iterable item type.
    Throws
    * a TypeError if the collection_object_type a Dict with non-string keys.
    * an AttributeError if the collection_object_type is actually not a collection
    * a TypeInformationRequiredError if somehow the inner type can't be found from the collection type (either if dict,
    list, set, tuple were used instead of their typing module equivalents (Dict, List, Set, Tuple), or if the latter
    were specified without inner content types (as in Dict instead of Dict[str, Foo])

    :param collection_object_type:
    :return: a tuple containing the collection's content type (which may itself be a Tuple in case of a Tuple) and the
    collection's content key type for dicts (or None)
    """"""
    contents_item_type = None
    contents_key_type = None

    check_var(collection_object_type, var_types=type, var_name='collection_object_type')

    is_tuple = False
    if is_tuple_type(collection_object_type):  # Tuple is a special construct, is_generic_type does not work
        is_tuple = True
        # --old: hack into typing module
        # if hasattr(collection_object_type, '__args__') and collection_object_type.__args__ is not None:
        # contents_item_type = collection_object_type.__args__

        # --new : using typing_inspect
        # __args = get_last_args(collection_object_type)
        # this one works even in typevar+config cases such as t = Tuple[int, Tuple[T, T]][Optional[int]]
        __args = get_args(collection_object_type, evaluate=True)
        if len(__args) > 0:
            contents_item_type = __args

    elif issubclass(collection_object_type, Mapping):  # Dictionary-like
        if is_generic_type(collection_object_type):
            # --old: hack into typing module
            # if hasattr(collection_object_type, '__args__') and collection_object_type.__args__ is not None:
            # contents_key_type, contents_item_type = collection_object_type.__args__

            # --new : using typing_inspect
            # __args = get_last_args(collection_object_type)
            # this one works even in typevar+config cases such as d = Dict[int, Tuple[T, T]][Optional[int]]
            __args = get_args(collection_object_type, evaluate=True)
            if len(__args) > 0:
                contents_key_type, contents_item_type = __args
                if not issubclass(contents_key_type, str):
                    raise TypeError('Collection object has type Dict, but its PEP484 type hints declare '
                                    'keys as being of type ' + str(contents_key_type) + ' which is not supported. Only '
                                    'str keys are supported at the moment, since we use them as item names')

    elif issubclass(collection_object_type, Iterable):  # List or Set. Should we rather use Container here ?
        if is_generic_type(collection_object_type):
            # --old: hack into typing module
            # if hasattr(collection_object_type, '__args__') and collection_object_type.__args__ is not None:
            # contents_item_type = collection_object_type.__args__[0]

            # --new : using typing_inspect
            # __args = get_last_args(collection_object_type)
            # this one works even in typevar+config cases such as i = Iterable[Tuple[T, T]][Optional[int]]
            __args = get_args(collection_object_type, evaluate=True)
            if len(__args) > 0:
                contents_item_type, = __args

    elif issubclass(collection_object_type, dict) or issubclass(collection_object_type, list)\
            or issubclass(collection_object_type, tuple) or issubclass(collection_object_type, set):
        # the error is now handled below with the other under-specified types situations
        pass

    else:
        # Not a collection
        raise AttributeError('Cannot extract collection base type, object type ' + str(collection_object_type)
                             + ' is not a collection')

    # Finally return if something was found, otherwise tell it
    try:
        if contents_item_type is None or contents_item_type is Parameter.empty:
            # Empty type hints
            raise TypeInformationRequiredError.create_for_collection_items(collection_object_type, contents_item_type)
        
        elif is_tuple:
            # --- tuple: Iterate on all sub-types
            resolved = []
            for t in contents_item_type:
                # Check for empty type hints
                if contents_item_type is None or contents_item_type is Parameter.empty:
                    raise TypeInformationRequiredError.create_for_collection_items(collection_object_type, t)

                # Resolve any forward references if needed
                if resolve_fwd_refs:
                    t = resolve_forward_ref(t)
                resolved.append(t)

                # Final type hint compliance
                if not is_valid_pep484_type_hint(t):
                    raise InvalidPEP484TypeHint.create_for_collection_items(collection_object_type, t)

            if resolve_fwd_refs:
                contents_item_type = tuple(resolved)
        
        else:
            # --- Not a tuple
            # resolve any forward references first
            if resolve_fwd_refs:
                contents_item_type = resolve_forward_ref(contents_item_type)

            # check validity then
            if not is_valid_pep484_type_hint(contents_item_type):
                # Invalid type hints
                raise InvalidPEP484TypeHint.create_for_collection_items(collection_object_type, contents_item_type)

    except TypeInformationRequiredError as e:
        # only raise it if the flag says it
        if exception_if_none:
            raise e.with_traceback(e.__traceback__)

    return contents_item_type, contents_key_type"
1048,"def get_validated_attribute_type_info(typ, item_type, attr_name):
    """"""
    Routine to validate that typ is a valid non-empty PEP484 type hint. If it is a forward reference, it will be 
    resolved 
    
    :param typ: 
    :param item_type: 
    :param attr_name: 
    :return: 
    """"""
    if (typ is None) or (typ is Parameter.empty):
        raise TypeInformationRequiredError.create_for_object_attributes(item_type, attr_name, typ)

    # resolve forward references
    typ = resolve_forward_ref(typ)

    if not is_valid_pep484_type_hint(typ):
        raise InvalidPEP484TypeHint.create_for_object_attributes(item_type, attr_name, typ)

    return typ"
1049,"def get_constructor_attributes_types(item_type) -> Dict[str, Tuple[Type[Any], bool]]:
    """"""
    Utility method to return a dictionary of attribute name > attribute type from the constructor of a given type
    It supports PEP484 and 'attrs' declaration, see https://github.com/python-attrs/attrs.

    :param item_type:
    :return: a dictionary containing for each attr name, a tuple (type, is_mandatory)
    """"""
    res = dict()
    try:
        # -- Try to read an 'attr' declaration and to extract types and optionality
        from parsyfiles.plugins_optional.support_for_attrs import get_attrs_declarations
        decls = get_attrs_declarations(item_type)

        # check that types are correct
        for attr_name, v in decls.items():
            typ, is_optional = v

            # -- Get and check that the attribute type is PEP484 compliant
            typ = get_validated_attribute_type_info(typ, item_type, attr_name)

            # -- optional = attrs'Optional validator was used, or a default value was set, or type is pep484 Optional
            is_optional = is_optional or is_pep484_nonable(typ)

            # -- store both info in result dict
            res[attr_name] = (typ, not is_optional)

        return res

    except:  # ImportError or NotAnAttrsClassError but we obviously cant import the latter.
        pass  # do not specify a type and use 'pass' so as to reset the exception context

    # -- Fallback to PEP484

    # first get the signature of the class constructor
    s = _get_constructor_signature(item_type)

    # then extract the type and optionality of each attribute and raise errors if needed
    for attr_name in s.parameters.keys():
        # skip the 'self' attribute
        if attr_name != 'self':

            # -- Get and check that the attribute type is PEP484 compliant
            typ = get_validated_attribute_type_info(s.parameters[attr_name].annotation, item_type, attr_name)

            # -- is the attribute mandatory ?
            is_mandatory = (s.parameters[attr_name].default is Parameter.empty) and not is_pep484_nonable(typ)

            # -- store both info in result dict
            res[attr_name] = (typ, is_mandatory)

    return res"
1050,"def create_for_collection_items(item_type, hint):
        """"""
        Helper method for collection items

        :param item_type:
        :return:
        """"""
        # this leads to infinite loops
        # try:
        #     prt_type = get_pretty_type_str(item_type)
        # except:
        #     prt_type = str(item_type)
        return TypeInformationRequiredError(""Cannot parse object of type {t} as a collection: this type has no valid ""
                                            ""PEP484 type hint about its contents: found {h}. Please use a standard ""
                                            ""PEP484 declaration such as Dict[str, Foo] or List[Foo]""
                                            """".format(t=str(item_type), h=hint))"
1051,"def create_for_object_attributes(item_type, faulty_attribute_name: str, hint):
        """"""
        Helper method for constructor attributes

        :param item_type:
        :return:
        """"""
        # this leads to infinite loops
        # try:
        #     prt_type = get_pretty_type_str(item_type)
        # except:
        #     prt_type = str(item_type)
        return TypeInformationRequiredError(""Cannot create instances of type {t}: constructor attribute '{a}' has an""
                                            "" invalid PEP484 type hint: {h}."".format(t=str(item_type),
                                                                                     a=faulty_attribute_name, h=hint))"
1052,"def bounding_box_from_annotation(source=None, padding=None, **kwargs):
  """"""bounding_box_from_annotation(source, padding, **kwargs) -> bounding_box

  Creates a bounding box from the given parameters, which are, in general, annotations read using :py:func:`bob.ip.facedetect.read_annotation_file`.
  Different kinds of annotations are supported, given by the ``source`` keyword:

  * ``direct`` : bounding boxes are directly specified by keyword arguments ``topleft`` and ``bottomright``
  * ``eyes`` : the left and right eyes are specified by keyword arguments ``leye`` and ``reye``
  * ``left-profile`` : the left eye and the mouth are specified by keyword arguments ``eye`` and ``mouth``
  * ``right-profile`` : the right eye and the mouth are specified by keyword arguments ``eye`` and ``mouth``
  * ``ellipse`` : the face ellipse as well as face angle and axis radius is provided by keyword arguments ``center``, ``angle`` and ``axis_radius``

  If a ``source`` is specified, the according keywords must be given as well.
  Otherwise, the source is estimated from the given keyword parameters if possible.

  If 'topleft' and 'bottomright' are given (i.e., the 'direct' source), they are taken as is.
  Note that the 'bottomright' is NOT included in the bounding box.
  Please assure that the aspect ratio of the bounding box is 6:5 (height : width).

  For source 'ellipse', the bounding box is computed to capture the whole ellipse, even if it is rotated.

  For other sources (i.e., 'eyes'), the center of the two given positions is computed, and the ``padding`` is applied, which is relative to the distance between the two given points.
  If ``padding`` is ``None`` (the default) the default_paddings of this source are used instead.
  These padding is required to keep an aspect ratio of 6:5.

  **Parameters:**

  ``source`` : str or ``None``
    The type of annotations present in the list of keyword arguments, see above.

  ``padding`` : {'top':float, 'bottom':float, 'left':float, 'right':float}
    This padding is added to the center between the given points, to define the top left and bottom right positions in the bounding box; values are relative to the distance between the two given points; ignored for some of the ``source``\s

  ``kwargs`` : key=value
    Further keyword arguments specifying the annotations.

  **Returns:**

  bounding_box : :py:class:`BoundingBox`
    The bounding box that was estimated from the given annotations.
  """"""

  if source is None:
    # try to estimate the source
    for s,k in available_sources.items():
      # check if the according keyword arguments are given
      if k[0] in kwargs and k[1] in kwargs:
        # check if we already assigned a source before
        if source is not None:
          raise ValueError(""The given list of keywords (%s) is ambiguous. Please specify a source"" % kwargs)
        # assign source
        source = s

    # check if a source could be estimated from the keywords
    if source is None:
      raise ValueError(""The given list of keywords (%s) could not be interpreted"" % kwargs)

  assert source in available_sources

  # use default padding if not specified
  if padding is None:
    padding = default_paddings[source]

  keys = available_sources[source]
  if source == 'ellipse':
    # compute the tight bounding box for the ellipse
    angle = kwargs['angle']
    axis = kwargs['axis_radius']
    center = kwargs['center']
    dx = abs(math.cos(angle) * axis[0]) + abs(math.sin(angle) * axis[1])
    dy = abs(math.sin(angle) * axis[0]) + abs(math.cos(angle) * axis[1])
    top = center[0] - dy
    bottom = center[0] + dy
    left = center[1] - dx
    right = center[1] + dx
  elif padding is None:
    # There is no padding to be applied -> take nodes as they are
    top    = kwargs[keys[0]][0]
    bottom = kwargs[keys[1]][0]
    left   = kwargs[keys[0]][1]
    right  = kwargs[keys[1]][1]
  else:
    # apply padding
    pos_0 = kwargs[keys[0]]
    pos_1 = kwargs[keys[1]]
    tb_center = float(pos_0[0] + pos_1[0]) / 2.
    lr_center = float(pos_0[1] + pos_1[1]) / 2.
    distance = math.sqrt((pos_0[0] - pos_1[0])**2 + (pos_0[1] - pos_1[1])**2)

    top    = tb_center + padding['top'] * distance
    bottom = tb_center + padding['bottom'] * distance
    left   = lr_center + padding['left'] * distance
    right  = lr_center + padding['right'] * distance

  return BoundingBox((top, left), (bottom - top, right - left))"
1053,"def expected_eye_positions(bounding_box, padding = None):
  """"""expected_eye_positions(bounding_box, padding) -> eyes

  Computes the expected eye positions based on the relative coordinates of the bounding box.

  This function can be used to translate between bounding-box-based image cropping and eye-location-based alignment.
  The returned eye locations return the **average** eye locations, no landmark detection is performed.

  **Parameters:**

  ``bounding_box`` : :py:class:`BoundingBox`
    The face bounding box as detected by one of the functions in ``bob.ip.facedetect``.

  ``padding`` : {'top':float, 'bottom':float, 'left':float, 'right':float}
    The padding that was used for the ``eyes`` source in :py:func:`bounding_box_from_annotation`, has a proper default.

  **Returns:**

  ``eyes`` : {'reye' : (rey, rex), 'leye' : (ley, lex)}
    A dictionary containing the average left and right eye annotation.
  """"""
  if padding is None:
    padding = default_paddings['eyes']
  top, left, right = padding['top'], padding['left'], padding['right']
  inter_eye_distance = (bounding_box.size[1]) / (right - left)
  return {
    'reye':(bounding_box.top_f - top*inter_eye_distance, bounding_box.left_f - left/2.*inter_eye_distance),
    'leye':(bounding_box.top_f - top*inter_eye_distance, bounding_box.right_f - right/2.*inter_eye_distance)
  }"
1054,"def parallel_part(data, parallel):
  """"""parallel_part(data, parallel) -> part

  Splits off samples from the the given data list and the given number of parallel jobs based on the ``SGE_TASK_ID`` environment variable.

  **Parameters:**

  ``data`` : [object]
    A list of data that should be split up into ``parallel`` parts

  ``parallel`` : int or ``None``
    The total number of parts, in which the data should be split into

  **Returns:**

  ``part`` : [object]
    The desired partition of the ``data``
  """"""
  if parallel is None or ""SGE_TASK_ID"" not in os.environ:
    return data

  data_per_job = int(math.ceil(float(len(data)) / float(parallel)))
  task_id = int(os.environ['SGE_TASK_ID'])
  first = (task_id-1) * data_per_job
  last = min(len(data), task_id * data_per_job)
  return data[first:last]"
1055,"def quasi_random_indices(number_of_total_items, number_of_desired_items = None):
  """"""quasi_random_indices(number_of_total_items, [number_of_desired_items]) -> index

  Yields an iterator to a quasi-random list of indices that will contain exactly the number of desired indices (or the number of total items in the list, if this is smaller).

  This function can be used to retrieve a consistent and reproducible list of indices of the data, in case the ``number_of_total_items`` is lower that the given ``number_of_desired_items``.

  **Parameters:**

  ``number_of_total_items`` : int
    The total number of elements in the collection, which should be sub-sampled

  ``number_of_desired_items`` : int or ``None``
    The number of items that should be used; if ``None`` or greater than ``number_of_total_items``, all indices are yielded

  **Yields:**

  ``index`` : int
    An iterator to indices, which will span ``number_of_total_items`` evenly.
  """"""
  # check if we need to compute a sublist at all
  if number_of_desired_items is None or number_of_desired_items >= number_of_total_items or number_of_desired_items < 0:
    for i in range(number_of_total_items):
      yield i
  else:
    increase = float(number_of_total_items)/float(number_of_desired_items)
    # generate a regular quasi-random index list
    for i in range(number_of_desired_items):
      yield int((i +.5)*increase)"
1056,"def exception_class(self, exception):
		""""""Return a name representing the class of an exception.""""""

		cls = type(exception)
		if cls.__module__ == 'exceptions':  # Built-in exception.
			return cls.__name__
		return ""%s.%s"" % (cls.__module__, cls.__name__)"
1057,"def request_info(self, request):

		""""""
		Return a dictionary of information for a given request.

		This will be run once for every request.
		""""""

		# We have to re-resolve the request path here, because the information
		# is not stored on the request.
		view, args, kwargs = resolve(request.path)
		for i, arg in enumerate(args):
			kwargs[i] = arg

		parameters = {}
		parameters.update(kwargs)
		parameters.update(request.POST.items())

		environ = request.META

		return {
				""session"": dict(request.session),
				'cookies': dict(request.COOKIES),
				'headers': dict(get_headers(environ)),
                'env': dict(get_environ(environ)),
				""remote_ip"": request.META[""REMOTE_ADDR""],
				""parameters"": parameters,
				""action"": view.__name__,
				""application"": view.__module__,
				""method"": request.method,
				""url"": request.build_absolute_uri()
		}"
1058,"def run(self, training_set, trainer, filename = ""bootstrapped_model.hdf5"", force = False):
    """"""run(training_set, trainer, [filename], [force]) -> model

    Runs the bootstrapped training of a strong classifier using the given training data and a strong classifier trainer.
    The training set need to contain extracted features already, as this function will need the features several times.

    **Parameters:**

    ``training_set`` : :py:class:`TrainingSet`
      The training set containing pre-extracted feature files

    ``trainer`` : :py:class:`bob.learn.boosting.Boosting`
      A strong boosting trainer to use for selecting the weak classifiers and their weights for each round.

    ``filename`` : str
      A filename, where to write the resulting strong classifier to.
      This filename is also used as a base to compute filenames of intermediate files, which store results of each of the bootstrapping steps.

    ``force`` : bool
      If set to ``False`` (the default), the bootstrapping will continue the round, where it has been stopped during the last run (reading the current stage from respective files).
      If set to ``True``, the training will start from the beginning.

    **Returns:**

    ``model`` : :py:class:`bob.learn.boosting.BoostedMachine`
      The resulting strong classifier, a weighted combination of weak classifiers.
    """"""

    feature_extractor = training_set.feature_extractor()

    training_data = None
    training_labels = None
    model = None

    positive_indices, negative_indices = set(), set()

    for b in range(self.m_number_of_rounds):
      # check if old results are present
      temp_file = ""%s_round_%d.hdf5"" % (os.path.splitext(filename)[0], b+1)
      if os.path.exists(temp_file) and not force:
        logger.info(""Loading already computed stage %d from %s."", b+1, temp_file)
        model, positives, negatives = self._load(bob.io.base.HDF5File(temp_file))
        positive_indices |= positives
        negative_indices |= negatives

      else:
        if positive_indices or negative_indices:
          # load data from previous rounds
          logger.info(""Getting training data of previous rounds"")
          training_data, training_labels = training_set.sample(positive_indices = positive_indices, negative_indices = negative_indices)
          positive_indices, negative_indices = set(), set()

        # get data for current round
        logger.info(""Getting new data for bootstrapping round %d"", b+1)
        new_data, new_labels = training_set.sample(model, self.m_number_of_positive_examples_per_round, self.m_number_of_negative_examples_per_round)
        if training_data is None:
          training_data = new_data
        else:
          training_data = numpy.append(training_data, new_data, axis=0)
        if training_labels is None:
          training_labels = new_labels
        else:
          training_labels = numpy.append(training_labels, new_labels, axis=0)

        logger.info(""Starting training with %d examples"", training_data.shape[0])
        model = trainer.train(training_data, training_labels, self.m_number_of_weak_learners_per_round[b], model)

        # write model and extractor to temporary file to be able to catch up later
        logger.info(""Saving results for stage %d to file %s"", b+1, temp_file)
        self._save(bob.io.base.HDF5File(temp_file, 'w'), model, training_set.positive_indices, training_set.negative_indices)

      feature_extractor.model_indices = model.indices

    # finally, return the trained model
    return model"
1059,"def _save(self, hdf5, model, positives, negatives):
    """"""Saves the given intermediate state of the bootstrapping to file.""""""
    # write the model and the training set indices to the given HDF5 file
    hdf5.set(""PositiveIndices"", sorted(list(positives)))
    hdf5.set(""NegativeIndices"", sorted(list(negatives)))
    hdf5.create_group(""Model"")
    hdf5.cd(""Model"")
    model.save(hdf5)
    del hdf5"
1060,"def _load(self, hdf5):
    """"""Loads the intermediate state of the bootstrapping from file.""""""
    positives = set(hdf5.get(""PositiveIndices""))
    negatives = set(hdf5.get(""NegativeIndices""))
    hdf5.cd(""Model"")
    model = bob.learn.boosting.BoostedMachine(hdf5)
    return model, positives, negatives"
1061,"def _optimize_switches(self, minimumLength=2):
      '''
      converts sequences of compare/cjmp to switch instructions
      this must happen BEFORE linking
      minimumLength describes the minum amount of sequential compare/cjmp combinations
      needed to switch to a switch

      AUTOMATICALLY called by compile
      '''
      # locate all the targets of switch statements
      q = util.OneTimeQueue()
      targets = {}
      for i in range(len(self)):
        if isinstance(self[i], Compare) and isinstance(self[i+1], CondJmp):
          q.append(i)

      while q:
        front = q.popleft()
        i = front
        targets[i] = {}
        targets[i][self[i].arg1] = self[i+1].arg1
        while isinstance(self[i+2], Compare) and isinstance(self[i+3], CondJmp):
          i += 2
          targets[front][self[i].arg1] = self[i+1].arg1
          q.remove(i)
        if len(targets[front]) < minimumLength:
          # don't convert single cjmps to switches
          del targets[front]

      # now replace sequences with their switch statements
      # in order for our instruction numbers to be valid, do this
      # in reverse order
      _keys = targets.keys()
      _keys.sort()
      _keys.reverse()
      for i in _keys:
        del self[i:i+(len(targets[i])*2)]
        self.insert(i, Switch(targets[i]))"
1062,"def undelay(self):
        '''resolves all delayed arguments'''
        i = 0
        while i < len(self):
            op = self[i]
            i += 1
            if hasattr(op, 'arg1'):
                if isinstance(op.arg1,DelayedArg):
                    op.arg1 = op.arg1.resolve()
                if isinstance(op.arg1,CodeBlock):
                    op.arg1.undelay()"
1063,"def setup_logging(log_level=logging.INFO):
    """"""Set up the logging.""""""
    logging.basicConfig(level=log_level)
    fmt = (""%(asctime)s %(levelname)s (%(threadName)s) ""
           ""[%(name)s] %(message)s"")
    colorfmt = ""%(log_color)s{}%(reset)s"".format(fmt)
    datefmt = '%Y-%m-%d %H:%M:%S'

    # Suppress overly verbose logs from libraries that aren't helpful
    logging.getLogger('requests').setLevel(logging.WARNING)

    try:
        from colorlog import ColoredFormatter
        logging.getLogger().handlers[0].setFormatter(ColoredFormatter(
            colorfmt,
            datefmt=datefmt,
            reset=True,
            log_colors={
                'DEBUG': 'cyan',
                'INFO': 'green',
                'WARNING': 'yellow',
                'ERROR': 'red',
                'CRITICAL': 'red',
            }
        ))
    except ImportError:
        pass

    logger = logging.getLogger('')
    logger.setLevel(log_level)"
1064,"def get_arguments():
    """"""Get parsed arguments.""""""
    parser = argparse.ArgumentParser(""Lupupy: Command Line Utility"")

    parser.add_argument(
        '-u', '--username',
        help='Username',
        required=False)

    parser.add_argument(
        '-p', '--password',
        help='Password',
        required=False)

    parser.add_argument(
        '--arm',
        help='Arm alarm to mode',
        required=False, default=False, action=""store_true"")

    parser.add_argument(
        '-i', '--ip_address',
        help='IP of the Lupus panel',
        required=False)    

    parser.add_argument(
        '--disarm',
        help='Disarm the alarm',
        required=False, default=False, action=""store_true"")

    parser.add_argument(
        '--home',
        help='Set to home mode',
        required=False, default=False, action=""store_true"")
    
    parser.add_argument(
        '--devices',
        help='Output all devices',
        required=False, default=False, action=""store_true"")

    parser.add_argument(
        '--history',
        help='Get the history',
        required=False, default=False, action=""store_true"")
    
    parser.add_argument(
        '--status',
        help='Get the status of the panel',
        required=False, default=False, action=""store_true"")

    parser.add_argument(
        '--debug',
        help='Enable debug logging',
        required=False, default=False, action=""store_true"")

    parser.add_argument(
        '--quiet',
        help='Output only warnings and errors',
        required=False, default=False, action=""store_true"")

    return parser.parse_args()"
1065,"def call():
    """"""Execute command line helper.""""""
    args = get_arguments()

    if args.debug:
        log_level = logging.DEBUG
    elif args.quiet:
        log_level = logging.WARN
    else:
        log_level = logging.INFO

    setup_logging(log_level)

    lupusec = None

    if not args.username or not args.password or not args.ip_address:
            raise Exception(""Please supply a username, password and ip."")

    def _devicePrint(dev, append=''):
        _LOGGER.info(""%s%s"", dev.desc, append)

    try:
        if args.username and args.password and args.ip_address:
            lupusec = lupupy.Lupusec(ip_address=args.ip_address,
                                     username=args.username,
                                     password=args.password)
        
        if args.arm:
            if lupusec.get_alarm().set_away():
                _LOGGER.info('Alarm mode changed to armed')
            else:
                _LOGGER.warning('Failed to change alarm mode to armed')
        
        if args.disarm:
            if lupusec.get_alarm().set_standby():
                _LOGGER.info('Alarm mode changed to disarmed')
            else:
                _LOGGER.warning('Failed to change alarm mode to disarmed')

        if args.home:
            if lupusec.get_alarm().set_home():
                _LOGGER.info('Alarm mode changed to home')
            else:
                _LOGGER.warning('Failed to change alarm mode to home')
            
        if args.history:
            _LOGGER.info(json.dumps(lupusec.get_history()['hisrows'], indent=4, sort_keys=True))

        if args.status:
            _LOGGER.info('Mode of panel: %s', lupusec.get_alarm().mode)
        
        if args.devices:
            for device in lupusec.get_devices():
                _devicePrint(device)
                
    except lupupy.LupusecException as exc:
        _LOGGER.error(exc)
    finally:
        _LOGGER.info('--Finished running--')"
1066,"def get_member_ibutton(self, val):
        """"""Get a CSHMember object.

        Arguments:
        val -- the iButton ID of the member

        Returns:
        None if the iButton supplied does not correspond to a CSH Member
        """"""
        members = self.__con__.search_s(
            CSHMember.__ldap_user_ou__,
            ldap.SCOPE_SUBTREE,
            ""(ibutton=%s)"" % val,
            ['ipaUniqueID'])
        if members:
            return CSHMember(
                    self,
                    members[0][1]['ipaUniqueID'][0].decode('utf-8'),
                    False)
        return None"
1067,"def get_member_slackuid(self, slack):
        """"""Get a CSHMember object.

        Arguments:
        slack -- the Slack UID of the member

        Returns:
        None if the Slack UID provided does not correspond to a CSH Member
        """"""
        members = self.__con__.search_s(
            CSHMember.__ldap_user_ou__,
            ldap.SCOPE_SUBTREE,
            ""(slackuid=%s)"" % slack,
            ['ipaUniqueID'])
        if members:
            return CSHMember(
                    self,
                    members[0][1]['ipaUniqueID'][0].decode('utf-8'),
                    False)
        return None"
1068,"def get_directorship_heads(self, val):
        """"""Get the head of a directorship

        Arguments:
        val -- the cn of the directorship
        """"""

        __ldap_group_ou__ = ""cn=groups,cn=accounts,dc=csh,dc=rit,dc=edu""

        res = self.__con__.search_s(
                __ldap_group_ou__,
                ldap.SCOPE_SUBTREE,
                ""(cn=eboard-%s)"" % val,
                ['member'])

        ret = []
        for member in res[0][1]['member']:
            try:
                ret.append(member.decode('utf-8'))
            except UnicodeDecodeError:
                ret.append(member)
            except KeyError:
                continue

        return [CSHMember(self,
                dn.split('=')[1].split(',')[0],
                True)
                for dn in ret]"
1069,"def enqueue_mod(self, dn, mod):
        """"""Enqueue a LDAP modification.

        Arguments:
        dn -- the distinguished name of the object to modify
        mod -- an ldap modfication entry to enqueue
        """"""
        # mark for update
        if dn not in self.__pending_mod_dn__:
            self.__pending_mod_dn__.append(dn)
            self.__mod_queue__[dn] = []

        self.__mod_queue__[dn].append(mod)"
1070,"def flush_mod(self):
        """"""Flush all pending LDAP modifications.""""""
        for dn in self.__pending_mod_dn__:
            try:
                if self.__ro__:
                    for mod in self.__mod_queue__[dn]:
                        if mod[0] == ldap.MOD_DELETE:
                            mod_str = ""DELETE""
                        elif mod[0] == ldap.MOD_ADD:
                            mod_str = ""ADD""
                        else:
                            mod_str = ""REPLACE""
                        print(""{} VALUE {} = {} FOR {}"".format(mod_str,
                                                               mod[1],
                                                               mod[2],
                                                               dn))
                else:
                    self.__con__.modify_s(dn, self.__mod_queue__[dn])
            except ldap.TYPE_OR_VALUE_EXISTS:
                print(""Error! Conflicting Batch Modification: %s""
                      % str(self.__mod_queue__[dn]))
                continue
            except ldap.NO_SUCH_ATTRIBUTE:
                print(""Error! Conflicting Batch Modification: %s""
                      % str(self.__mod_queue__[dn]))
                continue
            self.__mod_queue__[dn] = None
        self.__pending_mod_dn__ = []"
1071,"def detect_encoding(value):
    """"""Returns the character encoding for a JSON string.""""""
    # https://tools.ietf.org/html/rfc4627#section-3
    if six.PY2:
        null_pattern = tuple(bool(ord(char)) for char in value[:4])
    else:
        null_pattern = tuple(bool(char) for char in value[:4])

    encodings = {
        # Zero is a null-byte, 1 is anything else.
        (0, 0, 0, 1): 'utf-32-be',
        (0, 1, 0, 1): 'utf-16-be',
        (1, 0, 0, 0): 'utf-32-le',
        (1, 0, 1, 0): 'utf-16-le',
    }

    return encodings.get(null_pattern, 'utf-8')"
1072,"def _merge_params(url, params):
    """"""Merge and encode query parameters with an URL.""""""
    if isinstance(params, dict):
        params = list(params.items())

    scheme, netloc, path, query, fragment = urllib.parse.urlsplit(url)
    url_params = urllib.parse.parse_qsl(query, keep_blank_values=True)
    url_params.extend(params)

    query = _encode_data(url_params)

    return urllib.parse.urlunsplit((scheme, netloc, path, query, fragment))"
1073,"def json(self, **kwargs):
        """"""Decodes response as JSON.""""""
        encoding = detect_encoding(self.content[:4])
        value = self.content.decode(encoding)

        return simplejson.loads(value, **kwargs)"
1074,"def links(self):
        """"""A dict of dicts parsed from the response 'Link' header (if set).""""""
        # <https://example.com/?page=2>; rel=""next"", <https://example.com/?page=34>; rel=""last""'
        # becomes
        # {
        #     'last': {'rel': 'last', 'url': 'https://example.com/?page=34'},
        #     'next': {'rel': 'next', 'url': 'https://example.com/?page=2'},
        # },
        result = {}
        if 'Link' in self.headers:
            value = self.headers['Link']

            for part in re.split(r', *<', value):
                link = {}
                vs = part.split(';')

                # First section is always an url.
                link['url'] = vs.pop(0).strip('\'"" <>')

                for v in vs:
                    if '=' in v:
                        key, v = v.split('=')
                        link[key.strip('\'"" ')] = v.strip('\'"" ')

                rkey = link.get('rel') or link['url']
                result[rkey] = link

        return result"
1075,"def raise_for_status(self):
        """"""Raises HTTPError if the request got an error.""""""
        if 400 <= self.status_code < 600:
            message = 'Error %s for %s' % (self.status_code, self.url)
            raise HTTPError(message)"
1076,"def unpack_text_io_wrapper(fp, encoding):
  """"""
  If *fp* is a #io.TextIOWrapper object, this function returns the underlying
  binary stream and the encoding of the IO-wrapper object. If *encoding* is not
  None and does not match with the encoding specified in the IO-wrapper, a
  #RuntimeError is raised.
  """"""

  if isinstance(fp, io.TextIOWrapper):
    if fp.writable() and encoding is not None and fp.encoding != encoding:
      msg = 'TextIOWrapper.encoding({0!r}) != {1!r}'
      raise RuntimeError(msg.format(fp.encoding, encoding))
    if encoding is None:
      encoding = fp.encoding
    fp = fp.buffer

  return fp, encoding"
1077,"def metric(cls, name, count, elapsed):
        """"""A metric function that buffers through numpy

        :arg str name: name of the metric
        :arg int count: number of items
        :arg float elapsed: time in seconds
        """"""

        if name is None:
            warnings.warn(""Ignoring unnamed metric"", stacklevel=3)
            return

        with cls.lock:
            # register with atexit on first call
            if cls.dump_atexit and not cls.instances:
                atexit.register(cls.dump)

            try:
                self = cls.instances[name]
            except KeyError:
                self = cls.instances[name] = cls(name)

            self.temp.write(self.struct.pack(count, elapsed))"
1078,"def dump(cls):
        """"""Output all recorded metrics""""""
        with cls.lock:
            if not cls.instances: return
            atexit.unregister(cls.dump)

            cls._pre_dump()

            for self in cls.instances.values():
                self._dump()

            cls._post_dump()"
1079,"def _dump(self):
        """"""dump data for an individual metric. For internal use only.""""""

        try:
            self.temp.seek(0) # seek to beginning
            arr = np.fromfile(self.temp, self.dtype)
            self.count_arr = arr['count']
            self.elapsed_arr = arr['elapsed']

            if self.calc_stats:
                # calculate mean & standard deviation
                self.count_mean = np.mean(self.count_arr)
                self.count_std = np.std(self.count_arr)
                self.elapsed_mean = np.mean(self.elapsed_arr)
                self.elapsed_std = np.std(self.elapsed_arr)

            self._output()
        finally:
            self.temp.close()
            self._cleanup()"
1080,"def list(self, host_rec=None, service_rec=None, hostfilter=None):
        """"""
        Returns a list of vulnerabilities based on t_hosts.id or t_services.id.
        If neither are set then statistical results are added

        :param host_rec: db.t_hosts.id
        :param service_rec: db.t_services.id
        :param hostfilter: Valid hostfilter or None
        :return: [(vulndata) ...] if host_rec or service_rec set
        :return: [(vulndata, vuln_cnt, [vuln_ip, ...], [services ...]) ...] if nothing sent
        """"""
        return self.send.vuln_list(host_rec, service_rec, hostfilter)"
1081,"def ip_info(self, vuln_name=None, vuln_id=None, ip_list_only=True, hostfilter=None):
        """"""
        List of all IP Addresses with a vulnerability

        :param vuln_name: t_vulndata.f_vulnid
        :param vuln_id: t_vulndata.id
        :param ip_list_only: IP List only (default) or rest of t_hosts fields
        :param hostfilter: Valid hostfilter or none
        :return: [(ip, hostname) ...] or [(ip, hostname, t_service_vulns.f_proof, t_service_vulns.f_status), ...]
        """"""
        return self.send.vuln_ip_info(vuln_name, vuln_id, ip_list_only, hostfilter)"
1082,"def service_list(self, vuln_name=None, vuln_id=None, hostfilter=None):
        """"""
        Returns a dictionary of vulns with services and IP Addresses

        :param vuln_name: t_vulndata.f_vulnid
        :param vuln_id: t_vulndata.id
        :param hostfilter: Valid hostfilter or none
        :return: {'vuln-id': {'port': [ ip, hostname ]} ...} ...
        """"""
        return self.send.vuln_service_list(vuln_name, vuln_id, hostfilter)"
1083,"def import_code(mod_code, mod_name):
    """"""Create a module object by code.
    @param mod_code: the code that the module contains.

    @param mod_name: module name.
    """"""
    mod_obj = imp.new_module(mod_name)

    mod_obj.__file__ = None

    exec_(mod_code, mod_obj.__dict__, mod_obj.__dict__)

    add_to_sys_modules(mod_name=mod_name, mod_obj=mod_obj)

    return mod_obj"
1084,"def import_name(mod_name):
    """"""Import a module by module name.

    @param mod_name: module name.
    """"""
    try:
        mod_obj_old = sys.modules[mod_name]
    except KeyError:
        mod_obj_old = None

    if mod_obj_old is not None:
        return mod_obj_old

    __import__(mod_name)

    mod_obj = sys.modules[mod_name]

    return mod_obj"
1085,"def import_path(mod_path, mod_name):
    """"""Import a module by module file path.

    @param mod_path: module file path.

    @param mod_name: module name.
    """"""
    mod_code = open(mod_path).read()

    mod_obj = import_code(
        mod_code=mod_code,
        mod_name=mod_name,
    )

    if not hasattr(mod_obj, '__file__'):
        mod_obj.__file__ = mod_path

    return mod_obj"
1086,"def import_obj(
    uri,
    mod_name=None,
    mod_attr_sep='::',
    attr_chain_sep='.',
    retn_mod=False,
):
    """"""Load an object from a module.

    @param uri: an uri specifying which object to load.
    An `uri` consists of two parts: module URI and attribute chain,
     e.g. `a/b/c.py::x.y.z` or `a.b.c::x.y.z`

    # Module URI
    E.g.  `a/b/c.py` or `a.b.c`.
    Can be either a module name or a file path.
    Whether it is a file path is determined by whether it ends with `.py`.

    # Attribute chain
    E.g. `x.y.z`.

    @param mod_name: module name.
    Must be given when `uri` specifies a module file path, not a module name.

    @param mod_attr_sep: the separator between module name and attribute name.

    @param attr_chain_sep: the separator between parts of attribute name.

    @retn_mod: whether return module object.
    """"""
    if mod_attr_sep is None:
        mod_attr_sep = '::'

    uri_parts = split_uri(uri=uri, mod_attr_sep=mod_attr_sep)

    protocol, mod_uri, attr_chain = uri_parts

    if protocol == 'py':
        mod_obj = import_name(mod_uri)

    else:
        if not mod_name:
            msg = (
                'Argument `mod_name` must be given when loading by file path.'
            )

            raise ValueError(msg)

        mod_obj = import_path(mod_uri, mod_name=mod_name)

    if not attr_chain:
        if retn_mod:
            return mod_obj, None
        else:
            return mod_obj

    if attr_chain_sep is None:
        attr_chain_sep = '.'

    attr_obj = get_attr_chain(
        obj=mod_obj,
        attr_chain=attr_chain,
        sep=attr_chain_sep,
    )

    if retn_mod:
        return mod_obj, attr_obj
    else:
        return attr_obj"
1087,"def add_to_sys_modules(mod_name, mod_obj=None):
    """"""Add a module object to `sys.modules`.

    @param mod_name: module name, used as key to `sys.modules`.
    If `mod_name` is `a.b.c` while modules `a` and `a.b` are not existing,
    empty modules will be created for `a` and `a.b` as well.

    @param mod_obj: a module object.
    If None, an empty module object will be created.
    """"""
    mod_snames = mod_name.split('.')

    parent_mod_name = ''

    parent_mod_obj = None

    for mod_sname in mod_snames:
        if parent_mod_name == '':
            current_mod_name = mod_sname
        else:
            current_mod_name = parent_mod_name + '.' + mod_sname

        if current_mod_name == mod_name:
            current_mod_obj = mod_obj
        else:
            current_mod_obj = sys.modules.get(current_mod_name, None)

        if current_mod_obj is None:
            current_mod_obj = imp.new_module(current_mod_name)

        sys.modules[current_mod_name] = current_mod_obj

        if parent_mod_obj is not None:
            setattr(parent_mod_obj, mod_sname, current_mod_obj)

        parent_mod_name = current_mod_name

        parent_mod_obj = current_mod_obj"
1088,"def split_uri(uri, mod_attr_sep='::'):
    """"""Split given URI into a tuple of (protocol, module URI, attribute chain).

    @param mod_attr_sep: the separator between module name and attribute name.
    """"""
    uri_parts = uri.split(mod_attr_sep, 1)

    if len(uri_parts) == 2:
        mod_uri, attr_chain = uri_parts
    else:
        mod_uri = uri_parts[0]

        attr_chain = None

    if mod_uri.startswith('py://'):
        protocol = 'py'

        mod_uri = mod_uri[5:]

    elif mod_uri.startswith('file://'):
        protocol = 'file'

        mod_uri = mod_uri[7:]

    # If no protocol prefix is present, and the uri ends with `.py`, then
    # consider the uri as module file path instead of module name.
    elif mod_uri.endswith('.py'):
        protocol = 'file'

    else:
        protocol = 'py'

    info = (protocol, mod_uri, attr_chain)

    return info"
1089,"def get_attr_chain(obj, attr_chain, sep='.'):
    """"""Get the last attribute of given attribute chain.
    E.g. `get_attr_chain(x, 'a.b.c')` is equivalent to `x.a.b.c`.

    @param obj: an object

    @param attr_chain: a chain of attribute names

    @param sep: separator for the chain of attribute names
    """"""
    if sep is None:
        sep = '.'

    attr_names = attr_chain.split(sep)

    new_obj = obj

    for attr_name in attr_names:
        new_obj = getattr(new_obj, attr_name)

    return new_obj"
1090,"def is_closed(self):
        """"""
        _check if the observation table is closed.
        Args:
            None
        Returns:
            tuple (bool, str): True if the observation table is
            closed and false otherwise. If the table is not closed
            the escaping string is returned.
        """"""
        for t in self.smi_vector:
            found = False
            for s in self.sm_vector:
                if self.observation_table[s] == self.observation_table[t]:
                    self.equiv_classes[t] = s
                    found = True
                    break
            if not found:
                return False, t
        return True, None"
1091,"def _fill_table_entry(self, row, col):
        """"""""""
        Fill an entry of the observation table.
        Args:
            row (str): The row of the observation table
            col (str): The column of the observation table
        Returns:
            None
        """"""
        prefix = self._membership_query(row)
        full_output = self._membership_query(row + col)
        length = len(commonprefix([prefix, full_output]))
        self.observation_table[row, col] = full_output[length:]"
1092,"def _run_in_hypothesis(self, mma, w_string, index):
        """"""""""
        Run the string in the hypothesis automaton for index steps and then
        return the access string for the state reached concatanated with the
        rest of the string w.
        Args:
            mma (DFA): The hypothesis automaton
            w_string (str): The examined string to be consumed
            index (int): The index value for selecting the prefix of w
        Return:
            str: The access string
        """"""
        state = mma[0]
        for i in range(index):
            for arc in state:
                if mma.isyms.find(arc.ilabel) == w_string[i]:
                    state = mma[arc.nextstate]
                    s_index = arc.nextstate

        # The id of the state is its index inside the Sm list
        access_string = self.observation_table.sm_vector[s_index]
        logging.debug(
            'Access string for %d: %s - %d ',
            index,
            access_string,
            s_index)

        return access_string"
1093,"def _check_suffix(self, w_string, access_string, index):
        """"""
        Checks if access string suffix matches with the examined string suffix
        Args:
            w_string (str): The examined string to be consumed
            access_string (str): The access string for the state
            index (int): The index value for selecting the prefix of w
        Returns:
            bool: A boolean valuei indicating if matching was successful
        """"""
        prefix_as = self._membership_query(access_string)
        full_as = self._membership_query(access_string + w_string[index:])

        prefix_w = self._membership_query(w_string[:index])
        full_w = self._membership_query(w_string)

        length = len(commonprefix([prefix_as, full_as]))
        as_suffix = full_as[length:]

        length = len(commonprefix([prefix_w, full_w]))
        w_suffix = full_w[length:]

        if as_suffix != w_suffix:
            logging.debug('Access string state incorrect')
            return True
        logging.debug('Access string state correct.')
        return False"
1094,"def _find_bad_transition(self, mma, w_string):
        """"""
        Checks for bad DFA transitions using the examined string
        Args:
            mma (DFA): The hypothesis automaton
            w_string (str): The examined string to be consumed
        Returns:
            str: The prefix of the examined string that matches
        """"""
        conj_out = mma.consume_input(w_string)
        targ_out = self._membership_query(w_string)
        # TODO: handle different length outputs from conjecture and target
        # hypothesis.
        length = min(len(conj_out), len(targ_out))
        diff = [i for i in range(length)
                if conj_out[i] != targ_out[i]]
        if len(diff) == 0:
            diff_index = len(targ_out)
        else:
            diff_index = diff[0]

        low = 0
        high = len(w_string)
        while True:
            i = (low + high) / 2
            length = len(self._membership_query(w_string[:i]))
            if length == diff_index + 1:
                return w_string[:i]
            elif length < diff_index + 1:
                low = i + 1
            else:
                high = i - 1"
1095,"def _process_counter_example(self, mma, w_string):
        """"""""
       Process a counterexample in the Rivest-Schapire way.
       Args:
           mma (DFA): The hypothesis automaton
           w_string (str): The examined string to be consumed
       Returns:
           None
        """"""
        w_string = self._find_bad_transition(mma, w_string)

        diff = len(w_string)
        same = 0
        while True:
            i = (same + diff) / 2
            access_string = self._run_in_hypothesis(mma, w_string, i)
            is_diff = self._check_suffix(w_string, access_string, i)
            if is_diff:
                diff = i
            else:
                same = i
            if diff - same == 1:
                break
        exp = w_string[diff:]

        self.observation_table.em_vector.append(exp)
        for row in self.observation_table.sm_vector + self.observation_table.smi_vector:
            self._fill_table_entry(row, exp)"
1096,"def _ot_make_closed(self, access_string):
        """"""
        Given a state input_string in Smi that is not equivalent with any state in Sm
        this method will move that state in Sm create a corresponding Smi
        state and fill the corresponding entries in the table.
        Args:
            access_string (str): State access string
        Returns:
            None
        """"""
        self.observation_table.sm_vector.append(access_string)
        for i in self.alphabet:
            self.observation_table.smi_vector.append(access_string + i)
            for e in self.observation_table.em_vector:
                self._fill_table_entry(access_string + i, e)"
1097,"def get_mealy_conjecture(self):
        """"""
        Utilize the observation table to construct a Mealy Machine.
        The library used for representing the Mealy Machine is the python
        bindings of the openFST library (pyFST).
        Args:
            None
        Returns:
            MealyMachine: A mealy machine build based on a closed and consistent
        observation table.
        """"""
        mma = MealyMachine()
        for s in self.observation_table.sm_vector:
            for i in self.alphabet:
                dst = self.observation_table.equiv_classes[s + i]
                # If dst == None then the table is not closed.
                if dst is None:
                    logging.debug('Conjecture attempt on non closed table.')
                    return None
                o = self.observation_table[s, i]
                src_id = self.observation_table.sm_vector.index(s)
                dst_id = self.observation_table.sm_vector.index(dst)
                mma.add_arc(src_id, dst_id, i, o)

        # This works only for Mealy machines
        for s in mma.states:
            s.final = True
        return mma"
1098,"def _init_table(self):
        """"""
        Initialize the observation table.
        """"""
        self.observation_table.sm_vector.append('')
        self.observation_table.smi_vector = list(self.alphabet)
        self.observation_table.em_vector = list(self.alphabet)

        for i in self.observation_table.em_vector:
            self._fill_table_entry('', i)

        for s, e in product(self.observation_table.smi_vector, self.observation_table.em_vector):
            self._fill_table_entry(s, e)"
1099,"def learn_mealy_machine(self):
        """"""
        Implements the high level loop of the algorithm for learning a
        Mealy machine.
        Args:
            None
        Returns:
            MealyMachine: The learned mealy machine
        """"""
        logging.info('Initializing learning procedure.')
        self._init_table()

        logging.info('Generating a closed and consistent observation table.')
        while True:

            closed = False
            # Make sure that the table is closed and consistent
            while not closed:

                logging.debug('Checking if table is closed.')
                closed, string = self.observation_table.is_closed()
                if not closed:
                    logging.debug('Closing table.')
                    self._ot_make_closed(string)
                else:
                    logging.debug('Table closed.')

            # Create conjecture
            mma = self.get_mealy_conjecture()

            logging.info('Generated conjecture machine with %d states.',
                         len(list(mma.states)))

            # _check correctness
            logging.debug('Running equivalence query.')
            found, counter_example = self._equivalence_query(mma)

            # Are we done?
            if found:
                logging.info('No counterexample found. Hypothesis is correct!')
                break

            # Add the new experiments into the table to reiterate the
            # learning loop
            logging.info(
                'Processing counterexample %input_string with length %d.',
                counter_example,
                len(counter_example))
            self._process_counter_example(mma, counter_example)

        logging.info('Learning complete.')
        return mma"
1100,"def get_headers(environ):
    """"""
    Returns only proper HTTP headers.
    """"""
    for key, value in environ.iteritems():
        key = str(key)
        if key.startswith('HTTP_') and key not in \
           ('HTTP_CONTENT_TYPE', 'HTTP_CONTENT_LENGTH'):
            yield key[5:].replace('_', '-').title(), value
        elif key in ('CONTENT_TYPE', 'CONTENT_LENGTH'):
            yield key.replace('_', '-').title(), value"
1101,"def get_host(environ):
    """"""Return the real host for the given WSGI environment.  This takes care
    of the `X-Forwarded-Host` header.

    :param environ: the WSGI environment to get the host of.
    """"""
    scheme = environ.get('wsgi.url_scheme')
    if 'HTTP_X_FORWARDED_HOST' in environ:
        result = environ['HTTP_X_FORWARDED_HOST']
    elif 'HTTP_HOST' in environ:
        result = environ['HTTP_HOST']
    else:
        result = environ['SERVER_NAME']
        if (scheme, str(environ['SERVER_PORT'])) not \
           in (('https', '443'), ('http', '80')):
            result += ':' + environ['SERVER_PORT']
    if result.endswith(':80') and scheme == 'http':
        result = result[:-3]
    elif result.endswith(':443') and scheme == 'https':
        result = result[:-4]
    return result"
1102,"def parse_library(lib_files):
    """"""
    Analizuje pliki podane w liście lib_files
    Zwraca instancję MusicLibrary
    """"""
    tracks, playlists = lib_files
    lib = MusicLibrary()
    lib_length = len(tracks)
    i = 0

    writer = lib.ix.writer()
    previous_procent_done_str = """"
    for f in tracks:
        track_info = TrackInfo(f)
        lib.add_track_internal(track_info, writer)
        current_percent_done_str = ""%d%%"" % (i / lib_length * 100)
        if current_percent_done_str != previous_procent_done_str:
            logs.print_info(""Analizowanie biblioteki muzycznej... "" + current_percent_done_str)
            previous_procent_done_str = current_percent_done_str
        i += 1.0
    logs.print_info(""Analizowanie playlist..."")
    for f in playlists:
        with open(f, 'r') as fo:
            playlist_dict = loads(fo.read())
            playlist = Playlist(lib, f, playlist_dict['title'], playlist_dict['tracks'])
            lib.add_playlist(playlist)
    writer.commit()
    logs.print_info(""Optymalizacja index-u..."")
    lib.ix.optimize()
    return lib"
1103,"def full_subgraph(self, objects):
        """"""
        Return the subgraph of this graph whose vertices
        are the given ones and whose edges are the edges
        of the original graph between those vertices.

        """"""
        vertices = ElementTransformSet(transform=id)
        out_edges = KeyTransformDict(transform=id)
        in_edges = KeyTransformDict(transform=id)
        for obj in objects:
            vertices.add(obj)
            out_edges[obj] = []
            in_edges[obj] = []

        edges = set()
        head = {}
        tail = {}

        for referrer in vertices:
            for edge in self._out_edges[referrer]:
                referent = self._head[edge]
                if referent not in vertices:
                    continue
                edges.add(edge)
                tail[edge] = referrer
                head[edge] = referent
                out_edges[referrer].append(edge)
                in_edges[referent].append(edge)

        return ObjectGraph._raw(
            vertices=vertices,
            edges=edges,
            out_edges=out_edges,
            in_edges=in_edges,
            head=head,
            tail=tail,
        )"
1104,"def _raw(cls, vertices, edges, out_edges, in_edges, head, tail):
        """"""
        Private constructor for direct construction
        of an ObjectGraph from its attributes.

        vertices is the collection of vertices
        out_edges and in_edges map vertices to lists of edges
        head and tail map edges to objects.

        """"""
        self = object.__new__(cls)
        self._out_edges = out_edges
        self._in_edges = in_edges
        self._head = head
        self._tail = tail
        self._vertices = vertices
        self._edges = edges
        return self"
1105,"def _from_objects(cls, objects):
        """"""
        Private constructor: create graph from the given Python objects.

        The constructor examines the referents of each given object to build up
        a graph showing the objects and their links.

        """"""
        vertices = ElementTransformSet(transform=id)
        out_edges = KeyTransformDict(transform=id)
        in_edges = KeyTransformDict(transform=id)
        for obj in objects:
            vertices.add(obj)
            out_edges[obj] = []
            in_edges[obj] = []

        # Edges are identified by simple integers, so
        # we can use plain dictionaries for mapping
        # edges to their heads and tails.
        edge_label = itertools.count()
        edges = set()
        head = {}
        tail = {}

        for referrer in vertices:
            for referent in gc.get_referents(referrer):
                if referent not in vertices:
                    continue
                edge = next(edge_label)
                edges.add(edge)
                tail[edge] = referrer
                head[edge] = referent
                out_edges[referrer].append(edge)
                in_edges[referent].append(edge)

        return cls._raw(
            vertices=vertices,
            edges=edges,
            out_edges=out_edges,
            in_edges=in_edges,
            head=head,
            tail=tail,
        )"
1106,"def annotated(self):
        """"""
        Annotate this graph, returning an AnnotatedGraph object
        with the same structure.

        """"""
        # Build up dictionary of edge annotations.
        edge_annotations = {}
        for edge in self.edges:
            if edge not in edge_annotations:
                # We annotate all edges from a given object at once.
                referrer = self._tail[edge]
                known_refs = annotated_references(referrer)
                for out_edge in self._out_edges[referrer]:
                    referent = self._head[out_edge]
                    if known_refs[referent]:
                        annotation = known_refs[referent].pop()
                    else:
                        annotation = None
                    edge_annotations[out_edge] = annotation

        annotated_vertices = [
            AnnotatedVertex(
                id=id(vertex),
                annotation=object_annotation(vertex),
            )
            for vertex in self.vertices
        ]

        annotated_edges = [
            AnnotatedEdge(
                id=edge,
                annotation=edge_annotations[edge],
                head=id(self._head[edge]),
                tail=id(self._tail[edge]),
            )
            for edge in self.edges
        ]

        return AnnotatedGraph(
            vertices=annotated_vertices,
            edges=annotated_edges,
        )"
1107,"def export_image(self, filename='refcycle.png', format=None,
                     dot_executable='dot'):
        """"""
        Export graph as an image.

        This requires that Graphviz is installed and that the ``dot``
        executable is in your path.

        The *filename* argument specifies the output filename.

        The *format* argument lets you specify the output format.  It may be
        any format that ``dot`` understands, including extended format
        specifications like ``png:cairo``.  If omitted, the filename extension
        will be used; if no filename extension is present, ``png`` will be
        used.

        The *dot_executable* argument lets you provide a full path to the
        ``dot`` executable if necessary.

        """"""
        return self.annotated().export_image(
            filename=filename,
            format=format,
            dot_executable=dot_executable,
        )"
1108,"def owned_objects(self):
        """"""
        List of gc-tracked objects owned by this ObjectGraph instance.

        """"""
        return (
            [
                self,
                self.__dict__,
                self._head,
                self._tail,
                self._out_edges,
                self._out_edges._keys,
                self._out_edges._values,
                self._in_edges,
                self._in_edges._keys,
                self._in_edges._values,
                self._vertices,
                self._vertices._elements,
                self._edges,
            ] +
            list(six.itervalues(self._out_edges)) +
            list(six.itervalues(self._in_edges))
        )"
1109,"def find_by_typename(self, typename):
        """"""
        List of all objects whose type has the given name.
        """"""
        return self.find_by(lambda obj: type(obj).__name__ == typename)"
1110,"def set_input(self, key, value):
        """""" Sets the <key> to <value> """"""
        if key not in self._inputs:
            raise InputException(""Key {0} is not a valid input!"".format(key))
        self._inputs[key].value = value"
1111,"def get_input(self, key, force=False):
        """""" Get the value of <key> if it already exists, or prompt for it if not """"""
        if key not in self._inputs:
            raise InputException(""Key {0} is not a valid input!"".format(key))

        if self._inputs[key].prompt:
            prompt = self._inputs[key].prompt
        elif self._inputs[key].is_bool():
            prompt = ""{0}?"".format(key)
        else:
            prompt = ""please enter your {0}"".format(key)
        help_text = self._inputs[key].help if hasattr(self._inputs[key], 'help') else None

        if self._inputs[key].value is EMPTY or force:

            default_value = None
            if self._inputs[key].default is not EMPTY:
                default_value = self._inputs[key].default
            if self._inputs[key].value is not EMPTY:
                default_value = self._inputs[key].value

            input_value = EMPTY
            while input_value is EMPTY or input_value == '?':
                if input_value == '?' and help_text:
                    print(help_text)
                input_value = lib.prompt(
                    prompt,
                    default=default_value,
                    bool_type=self._inputs[key].in_type,
                    secret=self._inputs[key].is_secret)
            self._inputs[key].value = input_value

        return self._inputs[key].value"
1112,"def get_unset_inputs(self):
        """""" Return a set of unset inputs """"""
        return set([k for k, v in self._inputs.items() if v.is_empty(False)])"
1113,"def prompt_unset_inputs(self, force=False):
        """""" Prompt for unset input values """"""
        for k, v in self._inputs.items():
            if force or v.is_empty(False):
                self.get_input(k, force=force)"
1114,"def values(self, with_defaults=True):
        """""" Return the values dictionary, defaulting to default values """"""
        return dict(((k, str(v)) for k, v in self._inputs.items() if not v.is_empty(with_defaults)))"
1115,"def write_values(self):
        """""" Return the dictionary with which to write values """"""
        return dict(((k, v.value) for k, v in self._inputs.items() if not v.is_secret and not v.is_empty(False)))"
1116,"def add_inputs_from_inputstring(self, input_string):
        """"""
        Add inputs using the input string format:

        gitroot==~/workspace
        username
        password?
        main_branch==comp_main
        """"""
        raw_params = input_string.split('\n')
        param_attributes = (self._parse_param_line(rp) for rp in raw_params if len(rp.strip(' \t')) > 0)
        for param, attributes in param_attributes:
            self.add_input(param, attributes)"
1117,"def _parse_param_line(self, line):
        """""" Parse a single param line. """"""
        value = line.strip('\n \t')
        if len(value) > 0:
            i = Input()
            if value.find('#') != -1:
                value, extra_attributes = value.split('#')
                try:
                    extra_attributes = eval(extra_attributes)
                except SyntaxError:
                    raise InputException(""Incorrectly formatted input for {0}!"".format(value))
                if not isinstance(extra_attributes, dict):
                    raise InputException(""Incorrectly formatted input for {0}!"".format(value))
                if 'prompt' in extra_attributes:
                    i.prompt = extra_attributes['prompt']
                if 'help' in extra_attributes:
                    i.help = extra_attributes['help']
                if 'type' in extra_attributes:
                    i.in_type = extra_attributes['type']
                    if i.in_type.find('/') != -1:
                        i.in_type, i.out_type = i.in_type.split('/')
                if 'cast' in extra_attributes:
                    i.out_type = extra_attributes['cast']
            if value.find('==') != -1:
                value, default = value.split('==')
                i.default = default
            if value.endswith('?'):
                value = value[:-1]
                i.is_secret = True
            return (value, i)
        return None"
1118,"def extract_csv(zip_path, destination):
    """"""
    Extract the first CSV file found in the given ``zip_path`` ZIP file to the
    ``destination`` file. Raises :class:`LookupError` if no CSV file can be
    found in the ZIP.
    """"""
    with zipfile.ZipFile(zip_path) as zf:
        member_to_unzip = None
        for member in zf.namelist():
            if member.endswith('.csv'):
                member_to_unzip = member
                break

        if not member_to_unzip:
            raise LookupError(
                ""Couldn't find any CSV file in the archive""
            )

        with zf.open(member_to_unzip) as zfp, \
                open(destination, 'wb') as dfp:
            dfp.write(zfp.read())"
1119,"def download(self, overwrite=True):
        """"""
        Download the zipcodes CSV file. If ``overwrite`` is set to False, the
        file won't be downloaded if it already exists.
        """"""
        if overwrite or not os.path.exists(self.file_path):
            _, f = tempfile.mkstemp()
            try:
                urlretrieve(self.DOWNLOAD_URL, f)
                extract_csv(f, self.file_path)
            finally:
                os.remove(f)"
1120,"def get_locations(self):
        """"""
        Return the zipcodes mapping as a list of ``{zipcode: location}`` dicts.
        The zipcodes file will be downloaded if necessary.
        """"""
        if not self.zipcode_mapping:
            self.download(overwrite=False)

            zipcode_mapping = {}
            with UnicodeReader(self.file_path, delimiter=';', encoding='latin1') as csv_reader:
                # Skip header
                next(csv_reader)
                for line in csv_reader:
                    zipcode_mapping[int(line[1])] = Location(
                        official_name=line[0],
                        canton=line[5],
                        municipality=line[3]
                    )
            self.zipcode_mapping = zipcode_mapping

        return self.zipcode_mapping"
1121,"def get_zipcodes_for_canton(self, canton):
        """"""
        Return the list of zipcodes for the given canton code.
        """"""
        zipcodes = [
            zipcode for zipcode, location in self.get_locations().items()
            if location.canton == canton
        ]

        return zipcodes"
1122,"def get_cantons(self):
        """"""
        Return the list of unique cantons, sorted by name.
        """"""
        return sorted(list(set([
            location.canton for location in self.get_locations().values()
        ])))"
1123,"def get_municipalities(self):
        """"""
        Return the list of unique municipalities, sorted by name.
        """"""
        return sorted(list(set([
            location.municipality for location in self.get_locations().values()
        ])))"
1124,"def term_vector(self, params):
        '''
        params are either True/False, 'with_offsets', 'with_positions', 'with_positions_offsets'
        '''
        if params == True:
            self[self.field]['term_vector'] = 'yes'
        elif params == False:
            self[self.field]['term_vector'] = 'no'
        else:
            self[self.field]['term_vector'] = params
        return self"
1125,"def _get_formula_class(self, formula):
        """"""
        get a formula class object if it exists, else
        create one, add it to the dict, and pass return it.
        """"""
        # recursive import otherwise
        from sprinter.formula.base import FormulaBase
        if formula in LEGACY_MAPPINGS:
            formula = LEGACY_MAPPINGS[formula]
        formula_class, formula_url = formula, None
        if ':' in formula:
            formula_class, formula_url = formula.split("":"", 1)
        if formula_class not in self._formula_dict:
            try:
                self._formula_dict[formula_class] = lib.get_subclass_from_module(formula_class, FormulaBase)
            except (SprinterException, ImportError):
                logger.info(""Downloading %s..."" % formula_class)
                try:
                    self._pip.install_egg(formula_url or formula_class)
                    try:
                        self._formula_dict[formula_class] = lib.get_subclass_from_module(formula_class, FormulaBase)
                    except ImportError:
                        logger.debug(""FeatureDict import Error"", exc_info=sys.exc_info())
                        raise SprinterException(""Error: Unable to retrieve formula %s!"" % formula_class)
                except PipException:
                    logger.error(""ERROR: Unable to download %s!"" % formula_class)
        return self._formula_dict[formula_class]"
1126,"def is_backup_class(cls):
    """"""Return true if given class supports back up. Currently this means a
    gludb.data.Storable-derived class that has a mapping as defined in
    gludb.config""""""
    return True if (
        isclass(cls) and
        issubclass(cls, Storable) and
        get_mapping(cls, no_mapping_ok=True)
    ) else False"
1127,"def add_package(
        self,
        pkg_name,
        recurse=True,
        include_bases=True,
        parent_pkg=None
    ):
        """"""Add all classes to the backup in the specified package (including
        all modules and all sub-packages) for which is_backup_class returns
        True. Note that self.add_class is used, so base classes will added as
        well.

        Parameters:
        * pkg_name - a string representing the package name. It may be
          relative _if_ parent_pkg is supplied as well
        * recurse - (default value of True) if False, sub-packages will _not_
          be examined
        * include_bases - (default value of True) is passed directly to
          add_class for every class added
        * parent_pkg - a string representing the parent package of the relative
          package specified in pkg_name. Note that you should specify
          parent_pkg _only_ if pkg_name should be interpreted as relative

        An an example of both relative and absolute package imports, these
        are equivalent:

        ````
        backup.add_package('toppackage.subpackage')
        backup.add_package('subpackage', parent_pkg='toppackage')
        ````
        """"""
        if parent_pkg:
            pkg = import_module('.' + pkg_name, parent_pkg)
        else:
            pkg = import_module(pkg_name)

        for module_loader, name, ispkg in pkgutil.walk_packages(pkg.__path__):
            if not ispkg:
                # Module
                mod = import_module('.' + name, pkg_name)
                for name, member in getmembers(mod):
                    if is_backup_class(member):
                        self.add_class(member, include_bases=include_bases)
            elif recurse:
                # Package and we're supposed to recurse
                self.add_package(
                    pkg_name + '.' + name,
                    recurse=True,
                    include_bases=include_bases,
                    parent_pkg=parent_pkg
                )"
1128,"def add_class(self, cls, include_bases=True):
        """"""Add the specified class (which should be a class object, _not_ a
        string). By default all base classes for which is_backup_class returns
        True will also be added. `include_bases=False` may be spcified to
        suppress this behavior. The total number of classes added is returned.
        Note that if is_backup_class does not return True for the class object
        passed in, 0 will be returned. If you specify include_bases=False, then
        the maximum value that can be returned is 1.""""""
        if not is_backup_class(cls):
            return 0

        added = 0

        cls_name = backup_name(cls)
        if cls_name not in self.classes:
            self.classes[cls_name] = cls
            self.log(""Added class for backup: %s"", cls_name)
            added = 1

        if include_bases:
            for candidate_cls in getmro(cls):
                if is_backup_class(cls):
                    # Note that we don't keep recursing on base classes
                    added += self.add_class(candidate_cls, include_bases=False)

        return added"
1129,"def log(self, entry, *args):
        """"""Append the string supplied to the log (a list of strings). If
        additional arguments are supplied, then first string is assumed to be
        a format string and the other args are used for string interpolation.
        For instance `backup.log(""%d + %d == %d"", 1, 1, 2)` would result in the
        string `'1 + 1 == 2'` being logged""""""
        if args:
            entry = entry % args
        self.backup_log.append(entry)"
1130,"def run_backup(self):
        """"""The actual backup is performed. The data for all added classes is
        extracted and written to a file per class where each line (terminated
        by a line feed character) is the JSON representing a single object.
        Those files are all archived in a single gzip'ed tarball which is
        stored in the AWS S3 bucket specified when the current instance of
        Backup was created""""""
        self.log(""Starting backup at %s"", now_field())
        self.log(""Backup config object created at %s"", self.timestamp)

        # Make sure we're good to go
        for fld in ['aws_access_key', 'aws_secret_key', 'bucketname']:
            val = getattr(self, fld, None)
            if not val:
                self.log(""Backup cannot start: %s is a required field"", fld)
                raise ValueError(self.backup_log[-1])

        # Start the compressed tarball our data is stored in
        backup_file = NamedTemporaryFile(suffix="".tar.gz"")
        backup_tarfile = tarfile.open(fileobj=backup_file, mode='w:gz')

        for cls_name, cls in self.classes.items():
            self.log(""Backing up %s"", cls_name)

            rec_count = 0

            with NamedTemporaryFile() as record_file:
                for rec in cls.find_all():
                    write_line(record_file, rec.to_data())
                    rec_count += 1

                record_file.flush()
                backup_tarfile.add(record_file.name, arcname=cls_name+'.json')

            self.log(""%s => %d records backed up"", cls_name, rec_count)

        # Finalize archive
        backup_tarfile.close()
        backup_file.flush()
        backup_size = os.stat(backup_file.name)[6]

        # Figure out key name for archived file
        key_name = ('Backup_' + now_field() + '.tar.gz').replace(':', '_')

        # upload archive to s3
        if os.environ.get('DEBUG', False) or os.environ.get('travis', False):
            # Local or CI - connect to our mock s3 service
            conn = S3Connection(
                '', '',
                is_secure=False, port=8888, host='localhost',
                calling_format=OrdinaryCallingFormat()
            )
        else:
            conn = S3Connection(self.aws_access_key, self.aws_secret_key)

        bucket = conn.get_bucket(self.bucketname)
        key = Key(bucket)
        key.key = key_name

        self.log(
            ""Sending %s [size=%d bytes] with key name %s"",
            backup_file.name,
            backup_size,
            key_name
        )

        # TODO: should probably look into a multi-part upload for larger backup
        key.set_contents_from_filename(backup_file.name)
        self.log(""Sent %s"", backup_file.name)

        # All done
        backup_file.close()
        self.log(""Backup completed"")

        # return the bucket name and key name for the completed backup
        return self.bucketname, key_name"
1131,"def list_dir(sourceDir, include_source=None, include_file=True):
    """"""与 :func:`os.listdir()` 类似，但提供一些筛选功能，且返回生成器对象。

    :param str sourceDir: 待处理的文件夹。
    :param bool include_source: 遍历结果中是否包含源文件夹的路径。
    :param bool include_file:    是否包含文件。True 表示返回的内容中既包含文件，又
                                包含文件夹；Flase 代表仅包含文件夹。
    :return: 一个生成器对象。

    """"""
    for cur_file in os.listdir(sourceDir):
        if cur_file.lower() == "".ds_store"":
            continue
        pathWithSource = os.path.join(sourceDir, cur_file)
        if include_file or os.path.isdir(pathWithSource):
            if include_source:
                yield pathWithSource
            else:
                yield cur_file"
1132,"def copy_dir(sou_dir, dst_dir, del_dst=False, del_subdst=False):
    """""":func:`shutil.copytree()` 也能实现类似功能，
    但前者要求目标文件夹必须不存在。
    而 copy_dir 没有这个要求，它可以将 sou_dir 中的文件合并到 dst_dir 中。

    :param str sou_dir: 待复制的文件夹；
    :param str dst_dir: 目标文件夹；
    :param bool del_dst: 是否删除目标文件夹。
    :param bool del_subdst: 是否删除目标子文件夹。

    """"""
    if del_dst and os.path.isdir(del_dst):
        shutil.rmtree(dst_dir)
    os.makedirs(dst_dir, exist_ok=True)
    for cur_file in list_dir(sou_dir):
        dst_file = os.path.join(dst_dir, cur_file)
        cur_file = os.path.join(sou_dir, cur_file)
        if os.path.isdir(cur_file):
            if del_subdst and os.path.isdir(dst_file):
                shutil.rmtree(dst_file)
            os.makedirs(dst_file, exist_ok=True)
            copy_dir(cur_file, dst_file)
        else:
            shutil.copyfile(cur_file, dst_file)"
1133,"def get_files(path, ext=[], include=True):
    """"""遍历提供的文件夹的所有子文件夹，饭后生成器对象。

    :param str path: 待处理的文件夹。
    :param list ext: 扩展名列表。
    :param bool include:    若值为 True，代表 ext 提供的是包含列表；
                            否则是排除列表。
    :returns: 一个生成器对象。 

    """"""
    has_ext = len(ext)>0
    for p, d, fs in os.walk(path):
        for f in fs:
            if has_ext:
                in_ext = False
                for name in ext:
                    if f.endswith(name):
                        in_ext = True
                        break
                if (include and in_ext) or \
                (not include and not in_ext):
                    yield os.path.join(p,f)
            else:
                yield os.path.join(p, f)"
1134,"def read_file(file_path, **kws):
    """"""读取文本文件的内容。

    :param str file_path: 文件路径。
    :returns: 文件内容。
    :rtype: str

    """"""
    kw = {""mode"":""r"", ""encoding"":""utf-8""}
    if kws:
        for k,v in kws.items():
            kw[k] = v
    with open(file_path, **kw) as afile:
        txt = afile.read()
    return txt"
1135,"def write_file(file_path, txt, **kws):
    """"""将文本内容写入文件。

    :param str file_path: 文件路径。
    :param str txt: 待写入的文件内容。

    """"""
    if not os.path.exists(file_path):
        upDir = os.path.dirname(file_path)
        if not os.path.isdir(upDir):
            os.makedirs(upDir)

    kw = {""mode"":""w"", ""encoding"":""utf-8""}
    if kws:
        for k,v in kws.items():
            kw[k] = v
    with open(file_path, **kw) as afile:
        afile.write(txt)"
1136,"def write_by_templ(templ, target, sub_value, safe=False):
    """"""根据模版写入文件。

    :param str templ: 模版文件所在路径。
    :param str target: 要写入的文件所在路径。
    :param dict sub_value: 被替换的内容。

    """"""
    templ_txt = read_file(templ)
    txt = None
    if safe:
        txt = Template(templ_txt).safe_substitute(sub_value)
    else:
        txt = Template(templ_txt).substitute(sub_value)
    write_file(target, txt)"
1137,"def get_md5(path):
    """"""获取文件的 MD5 值。

    :param str path: 文件路径。
    :returns: MD5 值。
    :rtype: str

    """"""
    with open(path,'rb') as f:
        md5obj = hashlib.md5()
        md5obj.update(f.read())
        return md5obj.hexdigest()
    raise FileNotFoundError(""Error when get md5 for %s!""%path)"
1138,"def create_zip(files, trim_arcname=None, target_file=None, **zipfile_args):
    """"""创建一个 zip 文件。

    :param list files: 要创建zip 的文件列表。
    :param int trim_arcname: 若提供这个值，则使用 ZipFile.write(filename, filename[trim_arcname:]) 进行调用。
    :returns: zip 文件的路径。
    :rtype: str

    """"""
    zipname = None
    azip = None
    if not target_file:
        azip = tempfile.NamedTemporaryFile(mode='wb', delete=False)
        zipname = azip.name
    else:
        azip = target_file
        zipname = target_file.name if hasattr(azip, 'read') else azip
    slog.info('Package %d files to ""%s""'%(len(files), azip.name))
    fileNum = len(files)
    curFile = 0
    zipfile_args['mode'] = 'w'
    if not zipfile_args.get('compression'):
        zipfile_args['compression'] = zipfile.ZIP_DEFLATED
    with zipfile.ZipFile(azip, **zipfile_args) as zipf:
       for f in files:
           percent = round(curFile/fileNum*100)
           sys.stdout.write('\r%d%%'%(percent))
           sys.stdout.flush()
           zipf.write(f, f[trim_arcname:] if trim_arcname else None )
           curFile = curFile+1

       sys.stdout.write('\r100%\n')
       sys.stdout.flush()

    if hasattr(azip, 'close'):
        azip.close()
    return zipname"
1139,"def get_max_ver(fmt, filelist):
    """"""有一堆字符串，文件名均包含 %d.%d.%d 形式版本号，返回其中版本号最大的那个。
    我一般用它来检测一堆发行版中版本号最大的那个文件。

    :param str fmt: 要检测测字符串形式，例如 rookout-%s.tar.gz ，其中 %s 会被正则替换。
    :param list files: 字符串列表。
    :returns: 版本号最大的字符串。
    :rtype: str

    """"""
    x, y, z = 0,0,0
    verpat = fmt%'(\d+).(\d+).(\d+)'
    verre = re.compile(r''+verpat+'', re.M) 
    for f in filelist:
        match = verre.search(f)
        if match:
            x1 = int(match.group(1))
            y1 = int(match.group(2))
            z1 = int(match.group(3))
            if x1 >= x and y1 >= y:
                x = x1
                y = y1
                z = z1
    verfmt = fmt%('%d.%d.%d')
    name = verfmt%(x, y, z)
    if x == 0 and y == 0 and z == 0:
        slog.info('Can not find the string ""%s"" !'%name)
        return None
    return name"
1140,"def merge_dicts(d1, d2):
    """"""合并两个无限深度的 dict
    会自动合并 list 格式

    :param dict d1: 被合并的 dict
    :param dict d2: 待合并的 dict
    :returns: 一个新的生成器对象
    :rtype: generator

    """"""
    for k in set(d1.keys()).union(d2.keys()):
        if k in d1 and k in d2:
            if isinstance(d1[k], dict) and isinstance(d2[k], dict):
                yield (k, dict(merge_dicts(d1[k], d2[k])))
            elif isinstance(d1[k], list):
                if isinstance(d2[k], list):
                    d1[k].extend(d2[k])
                else:
                    d1[k].append(d2[k])
                yield(k, d1)
            else:
                # If one of the values is not a dict, you can't continue merging it.
                # Value from second dict overrides one in first and we move on.
                yield (k, d2[k])
                # Alternatively, replace this with exception raiser to alert you of value conflicts
        elif k in d1:
            yield (k, d1[k])
        else:
            yield (k, d2[k])"
1141,"def process(
    hw_num: int,
    problems_to_do: Optional[Iterable[int]] = None,
    prefix: Optional[Path] = None,
    by_hand: Optional[Iterable[int]] = None,
) -> None:
    """"""Process the homework problems in ``prefix`` folder.

    Arguments
    ---------
    hw_num
        The number of this homework
    problems_to_do, optional
        A list of the problems to be processed
    prefix, optional
        A `~pathlib.Path` to this homework assignment folder
    by_hand, optional
        A list of the problems that should be labeled to be completed
        by hand and have an image with the solution included.

    """"""
    if prefix is None:
        prefix = Path(""."")

    problems: Iterable[Path]

    if problems_to_do is None:
        # The glob syntax here means a the filename must start with
        # homework-, be followed the homework number, followed by a
        # dash, then a digit representing the problem number for this
        # homework number, then any number of characters (in practice
        # either nothing or, rarely, another digit), then the ipynb
        # extension. Examples:
        # homework-1-1.ipynb, homework-10-1.ipynb, homework-3-10.ipynb
        problems = list(prefix.glob(f""homework-{hw_num}-[0-9]*.ipynb""))
    else:
        problems = [prefix / f""homework-{hw_num}-{i}.ipynb"" for i in problems_to_do]

    problems = sorted(problems, key=lambda k: k.stem[-1])

    output_directory: Path = (prefix / ""output"").resolve()
    fw = FilesWriter(build_directory=str(output_directory))

    assignment_zip_name = output_directory / f""homework-{hw_num}.zip""
    solution_zip_name = output_directory / f""homework-{hw_num}-soln.zip""

    assignment_pdfs: List[BytesIO] = []
    solution_pdfs: List[BytesIO] = []

    assignment_pdf: bytes
    solution_pdf: bytes
    assignment_nb: str
    solution_nb: str

    res: Dict[str, Union[str, bool]] = {
        ""delete_pymarkdown"": True,
        ""global_content_filter"": {""include_raw"": False},
    }

    for problem in problems:
        print(""Working on:"", problem)
        res[""unique_key""] = problem.stem
        problem_number = int(problem.stem.split(""-"")[-1])
        if by_hand is not None and problem_number in by_hand:
            res[""by_hand""] = True
        else:
            res[""by_hand""] = False
        problem_fname = str(problem.resolve())

        # Process assignments
        res[""remove_solution""] = True
        assignment_pdf, _ = pdf_exp.from_filename(problem_fname, resources=res)
        assignment_pdfs.append(BytesIO(assignment_pdf))

        assignment_nb, _ = nb_exp.from_filename(problem_fname, resources=res)
        with ZipFile(assignment_zip_name, mode=""a"") as zip_file:
            zip_file.writestr(problem.name, assignment_nb)

        # Process solutions
        res[""remove_solution""] = False
        solution_pdf, _ = pdf_exp.from_filename(problem_fname, resources=res)
        solution_pdfs.append(BytesIO(solution_pdf))

        solution_nb, _ = nb_exp.from_filename(problem_fname, resources=res)
        with ZipFile(solution_zip_name, mode=""a"") as zip_file:
            zip_file.writestr(problem.stem + ""-soln"" + problem.suffix, solution_nb)

    resources: Dict[str, Any] = {
        ""metadata"": {
            ""name"": f""homework-{hw_num}"",
            ""path"": str(prefix),
            ""modified_date"": date.today().strftime(""%B %d, %Y""),
        },
        ""output_extension"": "".pdf"",
    }
    fw.write(combine_pdf_as_bytes(assignment_pdfs), resources, f""homework-{hw_num}"")

    resources[""metadata""][""name""] = f""homework-{hw_num}-soln""
    fw.write(combine_pdf_as_bytes(solution_pdfs), resources, f""homework-{hw_num}-soln"")"
1142,"def main(argv: Optional[Sequence[str]] = None) -> None:
    """"""Parse arguments and process the homework assignment.""""""
    parser = ArgumentParser(description=""Convert Jupyter Notebook assignments to PDFs"")
    parser.add_argument(
        ""--hw"",
        type=int,
        required=True,
        help=""Homework number to convert"",
        dest=""hw_num"",
    )
    parser.add_argument(
        ""-p"",
        ""--problems"",
        type=int,
        help=""Problem numbers to convert"",
        dest=""problems"",
        nargs=""*"",
    )
    parser.add_argument(
        ""--by-hand"",
        type=int,
        help=""Problem numbers to be completed by hand"",
        dest=""by_hand"",
        nargs=""*"",
    )
    args = parser.parse_args(argv)
    prefix = Path(f""homework/homework-{args.hw_num}"")
    process(args.hw_num, args.problems, prefix=prefix, by_hand=args.by_hand)"
1143,"def get_object_by_name(content, object_type, name, regex=False):
    '''
    Get the vsphere object associated with a given text name
    Source: https://github.com/rreubenur/vmware-pyvmomi-examples/blob/master/create_template.py
    '''
    container = content.viewManager.CreateContainerView(
        content.rootFolder, [object_type], True
    )
    for c in container.view:
        if regex:
            if re.match(name, c.name):
                return c
        elif c.name == name:
            return c"
1144,"def get_vm_by_name(content, name, regex=False):
    '''
    Get a VM by its name
    '''
    return get_object_by_name(content, vim.VirtualMachine, name, regex)"
1145,"def get_all(content, container, object_type):
    '''
    Get all items of a certain type
    Example: get_all(content, vim.Datastore) return all datastore objects
    '''
    obj_list = list()
    view_manager = content.viewManager
    object_view = view_manager.CreateContainerView(
        container, [object_type], True
    )
    for obj in object_view.view:
        if isinstance(obj, object_type):
            obj_list.append(obj)
    object_view.Destroy()
    return obj_list"
1146,"def get_datacenter(content, obj):
    '''
    Get the datacenter to whom an object belongs
    '''
    datacenters = content.rootFolder.childEntity
    for d in datacenters:
        dch = get_all(content, d, type(obj))
        if dch is not None and obj in dch:
            return d"
1147,"def get_all_vswitches(content):
    '''
    Get all the virtual switches
    '''
    vswitches = []
    hosts = get_all_hosts(content)
    for h in hosts:
        for s in h.config.network.vswitch:
            vswitches.append(s)
    return vswitches"
1148,"def print_vm_info(vm):
    '''
    Print information for a particular virtual machine
    '''
    summary = vm.summary
    print('Name  : ', summary.config.name)
    print('Path  : ', summary.config.vmPathName)
    print('Guest : ', summary.config.guestFullName)
    annotation = summary.config.annotation
    if annotation is not None and annotation != '':
        print('Annotation : ', annotation)
    print('State : ', summary.runtime.powerState)
    if summary.guest is not None:
        ip = summary.guest.ipAddress
        if ip is not None and ip != '':
            print('IP    : ', ip)
    if summary.runtime.question is not None:
        print('Question : ', summary.runtime.question.text)
    print('')"
1149,"def module_import(module_path):
    """"""Imports the module indicated in name

    Args:
        module_path: string representing a module path such as
        'app.config' or 'app.extras.my_module'
    Returns:
        the module matching name of the last component, ie: for
        'app.extras.my_module' it returns a
        reference to my_module
    Raises:
        BadModulePathError if the module is not found
    """"""
    try:
        # Import whole module path.
        module = __import__(module_path)

        # Split into components: ['contour',
        # 'extras','appengine','ndb_persistence'].
        components = module_path.split('.')

        # Starting at the second component, set module to a
        # a reference to that component. at the end
        # module with be the last component. In this case:
        # ndb_persistence
        for component in components[1:]:
            module = getattr(module, component)

        return module

    except ImportError:
        raise BadModulePathError(
            'Unable to find module ""%s"".' % (module_path,))"
1150,"def find_contour_yaml(config_file=__file__, names=None):
    """"""
    Traverse directory trees to find a contour.yaml file

    Begins with the location of this file then checks the
    working directory if not found

    Args:
        config_file: location of this file, override for
        testing
    Returns:
        the path of contour.yaml or None if not found
    """"""
    checked = set()
    contour_yaml = _find_countour_yaml(os.path.dirname(config_file), checked,
                                       names=names)

    if not contour_yaml:
        contour_yaml = _find_countour_yaml(os.getcwd(), checked, names=names)

    return contour_yaml"
1151,"def _find_countour_yaml(start, checked, names=None):
    """"""Traverse the directory tree identified by start
    until a directory already in checked is encountered or the path
    of countour.yaml is found.

    Checked is present both to make the loop termination easy
    to reason about and so the same directories do not get
    rechecked

    Args:
        start: the path to start looking in and work upward from
        checked: the set of already checked directories

    Returns:
        the path of the countour.yaml file or None if it is not found
    """"""
    extensions = []

    if names:
        for name in names:
            if not os.path.splitext(name)[1]:
                extensions.append(name + "".yaml"")
                extensions.append(name + "".yml"")

    yaml_names = (names or []) + CONTOUR_YAML_NAMES + extensions
    directory = start

    while directory not in checked:
        checked.add(directory)

        for fs_yaml_name in yaml_names:
            yaml_path = os.path.join(directory, fs_yaml_name)

            if os.path.exists(yaml_path):
                return yaml_path

        directory = os.path.dirname(directory)

    return"
1152,"def _load_yaml_config(path=None):
    """"""Open and return the yaml contents.""""""
    countour_yaml_path = path or find_contour_yaml()

    if countour_yaml_path is None:
        logging.debug(""countour.yaml not found."")
        return None

    with open(countour_yaml_path) as yaml_file:
        return yaml_file.read()"
1153,"def build_parser():
    """"""
    _build_parser_

    Set up CLI parser options, parse the
    CLI options an return the parsed results

    """"""
    parser = argparse.ArgumentParser(
        description='dockerstache templating util'
    )
    parser.add_argument(
        '--output', '-o',
        help='Working directory to render dockerfile and templates',
        dest='output',
        default=None
        )
    parser.add_argument(
        '--input', '-i',
        help='Working directory containing dockerfile and script mustache templates',
        dest='input',
        default=os.getcwd()
        )
    parser.add_argument(
        '--context', '-c',
        help='JSON file containing context dictionary to render templates',
        dest='context',
        default=None
    )
    parser.add_argument(
        '--defaults', '-d',
        help='JSON file containing default context dictionary to render templates',
        dest='defaults',
        default=None
    )
    parser.add_argument(
        '--inclusive',
        help='include non .mustache files from template',
        default=False,
        action='store_true'
    )
    parser.add_argument(
        '--exclude', '-e',
        help='exclude files from template in this list',
        default=[],
        nargs='+'
    )
    opts = parser.parse_args()
    return vars(opts)"
1154,"def main():
    """"""
    _main_

    Create a CLI parser and use that to run
    the template rendering process

    """"""
    options = build_parser()
    try:
        run(**options)
    except RuntimeError as ex:
        msg = (
            ""An error occurred running dockerstache: {} ""
            ""please see logging info above for details""

        ).format(ex)
        LOGGER.error(msg)
        sys.exit(1)"
1155,"def _guess_type_from_validator(validator):
    """"""
    Utility method to return the declared type of an attribute or None. It handles _OptionalValidator and _AndValidator
    in order to unpack the validators.

    :param validator:
    :return: the type of attribute declared in an inner 'instance_of' validator (if any is found, the first one is used)
    or None if no inner 'instance_of' validator is found
    """"""
    if isinstance(validator, _OptionalValidator):
        # Optional : look inside
        return _guess_type_from_validator(validator.validator)

    elif isinstance(validator, _AndValidator):
        # Sequence : try each of them
        for v in validator.validators:
            typ = _guess_type_from_validator(v)
            if typ is not None:
                return typ
        return None

    elif isinstance(validator, _InstanceOfValidator):
        # InstanceOf validator : found it !
        return validator.type

    else:
        # we could not find the type
        return None"
1156,"def is_optional(attr):
    """"""
    Helper method to find if an attribute is mandatory

    :param attr:
    :return:
    """"""
    return isinstance(attr.validator, _OptionalValidator) or (attr.default is not None and attr.default is not NOTHING)"
1157,"def get_attrs_declarations(item_type):
    """"""
    Helper method to return a dictionary of tuples. Each key is attr_name, and value is (attr_type, attr_is_optional)

    :param item_type:
    :return:
    """"""

    # this will raise an error if the type is not an attr-created type
    attribs = fields(item_type)

    res = dict()
    for attr in attribs:
        attr_name = attr.name

        # -- is the attribute mandatory ?
        optional = is_optional(attr)

        # -- get and check the attribute type
        typ = guess_type_from_validators(attr)

        # -- store both info in result dict
        res[attr_name] = (typ, optional)

    return res"
1158,"def preprocess(
        self, nb: ""NotebookNode"", resources: dict
    ) -> Tuple[""NotebookNode"", dict]:
        """"""Remove any raw cells from the Notebook.

        By default, exclude raw cells from the output. Change this by including
        global_content_filter->include_raw = True in the resources dictionary.
        This preprocessor is necessary because the NotebookExporter doesn't
        include the exclude_raw config.""""""
        if not resources.get(""global_content_filter"", {}).get(""include_raw"", False):
            keep_cells = []
            for cell in nb.cells:
                if cell.cell_type != ""raw"":
                    keep_cells.append(cell)

            nb.cells = keep_cells

        return nb, resources"
1159,"def preprocess(
        self, nb: ""NotebookNode"", resources: dict
    ) -> Tuple[""NotebookNode"", dict]:
        """"""Preprocess the entire notebook.""""""
        if ""remove_solution"" not in resources:
            raise KeyError(""The resources dictionary must have a remove_solution key."")
        if resources[""remove_solution""]:
            keep_cells_idx = []
            for index, cell in enumerate(nb.cells):
                if ""## solution"" in cell.source.lower():
                    keep_cells_idx.append(index)
                # The space at the end of the test string here is important
                elif len(keep_cells_idx) > 0 and cell.source.startswith(""### ""):
                    keep_cells_idx.append(index)

            keep_cells = nb.cells[: keep_cells_idx[0] + 1]
            for i in keep_cells_idx[1:]:
                keep_cells.append(nb.cells[i])
                if resources[""by_hand""]:
                    keep_cells.append(by_hand_cell)
                else:
                    if ""sketch"" in nb.cells[i].source.lower():
                        keep_cells.append(sketch_cell)
                    else:
                        keep_cells.append(md_expl_cell)
                        keep_cells.append(code_ans_cell)
                        keep_cells.append(md_ans_cell)
            nb.cells = keep_cells

        return nb, resources"
1160,"def preprocess(
        self, nb: ""NotebookNode"", resources: dict
    ) -> Tuple[""NotebookNode"", dict]:
        """"""Preprocess the entire Notebook.""""""
        for index, cell in enumerate(nb.cells):
            if ""## Solution"" in cell.source:
                nb.cells[index + 1].source = """"

        return nb, resources"
1161,"def preprocess(
        self, nb: ""NotebookNode"", resources: dict
    ) -> Tuple[""NotebookNode"", dict]:
        """"""Preprocess the entire Notebook.""""""

        exam_num = resources[""exam_num""]
        time = resources[""time""]
        date = resources[""date""]

        nb.cells.insert(0, new_markdown_cell(source=""---""))
        nb.cells.insert(0, new_markdown_cell(source=""""))
        nb.cells.insert(0, exam_instructions_cell)
        first_cell_source = (
            ""# ME 2233: Thermodynamic Principles\n\n""
            f""# Exam {exam_num} - {time}\n\n# {date}""
        )
        nb.cells.insert(0, new_markdown_cell(source=first_cell_source))

        return nb, resources"
1162,"def parse_from_dict(json_dict):
    """"""
    Given a Unified Uploader message, parse the contents and return a
    MarketOrderList.

    :param dict json_dict: A Unified Uploader message as a JSON dict.
    :rtype: MarketOrderList
    :returns: An instance of MarketOrderList, containing the orders
        within.
    """"""
    order_columns = json_dict['columns']

    order_list = MarketOrderList(
        upload_keys=json_dict['uploadKeys'],
        order_generator=json_dict['generator'],
    )

    for rowset in json_dict['rowsets']:
        generated_at = parse_datetime(rowset['generatedAt'])
        region_id = rowset['regionID']
        type_id = rowset['typeID']
        order_list.set_empty_region(region_id, type_id, generated_at)

        for row in rowset['rows']:
            order_kwargs = _columns_to_kwargs(
                SPEC_TO_KWARG_CONVERSION, order_columns, row)
            order_kwargs.update({
                'region_id': region_id,
                'type_id': type_id,
                'generated_at': generated_at,
            })

            order_kwargs['order_issue_date'] = parse_datetime(order_kwargs['order_issue_date'])

            order_list.add_order(MarketOrder(**order_kwargs))

    return order_list"
1163,"def encode_to_json(order_list):
    """"""
    Encodes this list of MarketOrder instances to a JSON string.

    :param MarketOrderList order_list: The order list to serialize.
    :rtype: str
    """"""
    rowsets = []
    for items_in_region_list in order_list._orders.values():
        region_id = items_in_region_list.region_id
        type_id = items_in_region_list.type_id
        generated_at = gen_iso_datetime_str(items_in_region_list.generated_at)

        rows = []
        for order in items_in_region_list.orders:
            issue_date = gen_iso_datetime_str(order.order_issue_date)

            # The order in which these values are added is crucial. It must
            # match STANDARD_ENCODED_COLUMNS.
            rows.append([
                order.price,
                order.volume_remaining,
                order.order_range,
                order.order_id,
                order.volume_entered,
                order.minimum_volume,
                order.is_bid,
                issue_date,
                order.order_duration,
                order.station_id,
                order.solar_system_id,
            ])

        rowsets.append(dict(
            generatedAt = generated_at,
            regionID = region_id,
            typeID = type_id,
            rows = rows,
        ))

    json_dict = {
        'resultType': 'orders',
        'version': '0.1',
        'uploadKeys': order_list.upload_keys,
        'generator': order_list.order_generator,
        'currentTime': gen_iso_datetime_str(now_dtime_in_utc()),
        # This must match the order of the values in the row assembling portion
        # above this.
        'columns': STANDARD_ENCODED_COLUMNS,
        'rowsets': rowsets,
    }

    return json.dumps(json_dict)"
1164,"def weather(query):
	""""""weather(query) -- use Name Entity Recogniser (nltk-stanford-ner), to 
	determine location entity in query and fetch weather info for that location
	(using yahoo apis).
	""""""

	print 'Identifying the location . . .'
	try:
		response = unirest.post(""https://textanalysis.p.mashape.com/nltk-stanford-ner"",
	  		headers={
	    	""X-Mashape-Key"": ""E7WffsNDbNmshj4aVC4NUwj9dT9ep1S2cc3jsnFp5wSCzNBiaP"",
	    	""Content-Type"": ""application/x-www-form-urlencoded""
	  			},
	  		params={
	    	""text"": query
	  		}
		)
	except:
		print 'Unable to connect to internet'
		return
	location = ''
	for entity in response.body['result'].split():
		word,tag = entity.split('/')
		if(tag == 'LOCATION'):
			location += ' '+word
	if(location != ''):
		print 'Gathering weather information for'+location
		import urllib2, urllib, json
		baseurl = ""https://query.yahooapis.com/v1/public/yql?""
		yql_query = ""select * from weather.forecast where woeid in \
		(select woeid from geo.places(1) where text=\""""+location+""\"")""
		yql_url = baseurl + urllib.urlencode({'q':yql_query}) + ""&format=json""
		try:
			result = urllib2.urlopen(yql_url).read()
			data = json.loads(result)
			result = data['query']['results']['channel']
			print result['location']['city']+' '+result['location']['country']+' '+result['location']['region']
			print result['item']['condition']['date']
			print result['item']['condition']['text']
			print result['item']['condition']['temp']+' '+result['units']['temperature'] 
		except:
			print 'Unable to connect to internet'
	else:
		print 'Unable to get the location.'"
1165,"def generic(query):
	"""""" generic(query) -- process a generic user query using the Stanford 
	NLTK NER and duckduckgo api.
	""""""
	
	try:
		response = unirest.post(""https://textanalysis.p.mashape.com/nltk-stanford-ner"",
	  		headers={
	    	""X-Mashape-Key"": ""E7WffsNDbNmshj4aVC4NUwj9dT9ep1S2cc3jsnFp5wSCzNBiaP"",
	    	""Content-Type"": ""application/x-www-form-urlencoded""
	  			},
	  		params={
	    	""text"": query
	  		}
		)
	except:
		print 'Unable to connect to internet'
		return
	web_query = ''
	for entity in response.body['result'].split():
		word,tag = entity.split('/')
		if(tag != 'O'):
			web_query += ' '+word
	if(web_query != ''):
		web_query = web_query.strip().split()
		duckduckgo.query(web_query)
	else:
		print 'I do not know how to process this query at this moment.'"
1166,"def _can_construct_from_str(strict_mode: bool, from_type: Type, to_type: Type) -> bool:
    """"""
    Returns true if the provided types are valid for constructor_with_str_arg conversion
    Explicitly declare that we are not able to convert primitive types (they already have their own converters)

    :param strict_mode:
    :param from_type:
    :param to_type:
    :return:
    """"""
    return to_type not in {int, float, bool}"
1167,"def are_flags_valid(packet_type, flags):
    """"""True when flags comply with [MQTT-2.2.2-1] requirements based on
    packet_type; False otherwise.

    Parameters
    ----------
    packet_type: MqttControlPacketType
    flags: int
        Integer representation of 4-bit MQTT header flags field.
        Values outside of the range [0, 15] will certainly cause the
        function to return False.

    Returns
    -------
    bool
    """"""
    if packet_type == MqttControlPacketType.publish:
        rv = 0 <= flags <= 15
    elif packet_type in (MqttControlPacketType.pubrel,
                         MqttControlPacketType.subscribe,
                         MqttControlPacketType.unsubscribe):
        rv = flags == 2
    elif packet_type in (MqttControlPacketType.connect,
                         MqttControlPacketType.connack,
                         MqttControlPacketType.puback,
                         MqttControlPacketType.pubrec,
                         MqttControlPacketType.pubcomp,
                         MqttControlPacketType.suback,
                         MqttControlPacketType.unsuback,
                         MqttControlPacketType.pingreq,
                         MqttControlPacketType.pingresp,
                         MqttControlPacketType.disconnect):
        rv = flags == 0
    else:
        raise NotImplementedError(packet_type)

    return rv"
1168,"def decode(f):
        """"""Extract a `MqttFixedHeader` from ``f``.

        Parameters
        ----------
        f: file
            Object with read method.

        Raises
        -------
        DecodeError
            When bytes decoded have values incompatible with a
            `MqttFixedHeader` object.
        UnderflowDecodeError
            When end-of-stream is encountered before the end of the
            fixed header.

        Returns
        -------
        int
            Number of bytes consumed from ``f``.
        MqttFixedHeader
            Header object extracted from ``f``.
        """"""
        decoder = mqtt_io.FileDecoder(f)
        (byte_0,) = decoder.unpack(mqtt_io.FIELD_U8)

        packet_type_u4 = (byte_0 >> 4)
        flags = byte_0 & 0x0f

        try:
            packet_type = MqttControlPacketType(packet_type_u4)
        except ValueError:
            raise DecodeError('Unknown packet type 0x{:02x}.'.format(packet_type_u4))

        if not are_flags_valid(packet_type, flags):
            raise DecodeError('Invalid flags for packet type.')

        num_bytes, num_remaining_bytes = decoder.unpack_varint(4)

        return decoder.num_bytes_consumed, MqttFixedHeader(packet_type, flags, num_remaining_bytes)"
1169,"def encode_body(self, f):
        """"""
        Parameters
        ----------
        f: file
            File-like object with a write method.

        Returns
        -------
        int
            Number of bytes written to ``f``.
        """"""
        num_bytes_written = 0
        num_bytes_written += self.__encode_name(f)
        num_bytes_written += self.__encode_protocol_level(f)
        num_bytes_written += self.__encode_connect_flags(f)
        num_bytes_written += self.__encode_keep_alive(f)

        num_bytes_written += mqtt_io.encode_utf8(self.client_id, f)

        if self.will is not None:
            num_bytes_written += mqtt_io.encode_utf8(self.will.topic, f)
            num_bytes_written += mqtt_io.encode_bytes(self.will.message, f)

        if self.username is not None:
            num_bytes_written += mqtt_io.encode_utf8(self.username, f)

        if self.password is not None:
            num_bytes_written += mqtt_io.encode_utf8(self.password, f)

        return num_bytes_written"
1170,"def decode_body(cls, header, f):
        """"""Generates a `MqttSubscribe` packet given a
        `MqttFixedHeader`.  This method asserts that header.packet_type
        is `subscribe`.

        Parameters
        ----------
        header: MqttFixedHeader
        f: file
            Object with a read method.

        Raises
        ------
        DecodeError
            When there are extra bytes at the end of the packet.

        Returns
        -------
        int
            Number of bytes consumed from ``f``.
        MqttSubscribe
            Object extracted from ``f``.
        """"""
        assert header.packet_type == MqttControlPacketType.subscribe

        decoder = mqtt_io.FileDecoder(mqtt_io.LimitReader(f, header.remaining_len))
        packet_id, = decoder.unpack(mqtt_io.FIELD_PACKET_ID)

        topics = []
        while header.remaining_len > decoder.num_bytes_consumed:
            num_str_bytes, name = decoder.unpack_utf8()
            max_qos, = decoder.unpack(mqtt_io.FIELD_U8)
            try:
                sub_topic = MqttTopic(name, max_qos)
            except ValueError:
                raise DecodeError('Invalid QOS {}'.format(max_qos))
            topics.append(sub_topic)

        assert header.remaining_len == decoder.num_bytes_consumed

        return decoder.num_bytes_consumed, MqttSubscribe(packet_id, topics)"
1171,"def decode_body(cls, header, f):
        """"""Generates a `MqttSuback` packet given a
        `MqttFixedHeader`.  This method asserts that header.packet_type
        is `suback`.

        Parameters
        ----------
        header: MqttFixedHeader
        f: file
            Object with a read method.

        Raises
        ------
        DecodeError
            When there are extra bytes at the end of the packet.

        Returns
        -------
        int
            Number of bytes consumed from ``f``.
        MqttSuback
            Object extracted from ``f``.
        """"""
        assert header.packet_type == MqttControlPacketType.suback

        decoder = mqtt_io.FileDecoder(mqtt_io.LimitReader(f, header.remaining_len))
        packet_id, = decoder.unpack(mqtt_io.FIELD_PACKET_ID)

        results = []
        while header.remaining_len > decoder.num_bytes_consumed:
            result, = decoder.unpack(mqtt_io.FIELD_U8)
            try:
                results.append(SubscribeResult(result))
            except ValueError:
                raise DecodeError('Unsupported result {:02x}.'.format(result))

        assert header.remaining_len == decoder.num_bytes_consumed

        return decoder.num_bytes_consumed, MqttSuback(packet_id, results)"
1172,"def decode_body(cls, header, f):
        """"""Generates a `MqttPublish` packet given a
        `MqttFixedHeader`.  This method asserts that header.packet_type
        is `publish`.

        Parameters
        ----------
        header: MqttFixedHeader
        f: file
            Object with a read method.

        Raises
        ------
        DecodeError
            When there are extra bytes at the end of the packet.

        Returns
        -------
        int
            Number of bytes consumed from ``f``.
        MqttPublish
            Object extracted from ``f``.
        """"""
        assert header.packet_type == MqttControlPacketType.publish

        dupe = bool(header.flags & 0x08)
        retain = bool(header.flags & 0x01)
        qos = ((header.flags & 0x06) >> 1)

        if qos == 0 and dupe:
            # The DUP flag MUST be set to 0 for all QoS 0 messages
            # [MQTT-3.3.1-2]
            raise DecodeError(""Unexpected dupe=True for qos==0 message [MQTT-3.3.1-2]."")

        decoder = mqtt_io.FileDecoder(mqtt_io.LimitReader(f, header.remaining_len))
        num_bytes_consumed, topic_name = decoder.unpack_utf8()

        if qos != 0:
            # See MQTT 3.1.1 section 3.3.2.2
            # See https://github.com/kcallin/mqtt-codec/issues/5
            packet_id, = decoder.unpack(mqtt_io.FIELD_PACKET_ID)
        else:
            packet_id = 0

        payload_len = header.remaining_len - decoder.num_bytes_consumed
        payload = decoder.read(payload_len)

        return decoder.num_bytes_consumed, MqttPublish(packet_id, topic_name, payload, dupe, qos, retain)"
1173,"def decode_body(cls, header, f):
        """"""Generates a `MqttPubrel` packet given a
        `MqttFixedHeader`.  This method asserts that header.packet_type
        is `pubrel`.

        Parameters
        ----------
        header: MqttFixedHeader
        f: file
            Object with a read method.

        Raises
        ------
        DecodeError
            When there are extra bytes at the end of the packet.

        Returns
        -------
        int
            Number of bytes consumed from ``f``.
        MqttPubrel
            Object extracted from ``f``.
        """"""
        assert header.packet_type == MqttControlPacketType.pubrel

        decoder = mqtt_io.FileDecoder(mqtt_io.LimitReader(f, header.remaining_len))
        packet_id, = decoder.unpack(mqtt_io.FIELD_U16)

        if header.remaining_len != decoder.num_bytes_consumed:
            raise DecodeError('Extra bytes at end of packet.')

        return decoder.num_bytes_consumed, MqttPubrel(packet_id)"
1174,"def decode_body(cls, header, f):
        """"""Generates a `MqttUnsubscribe` packet given a
        `MqttFixedHeader`.  This method asserts that header.packet_type
        is `unsubscribe`.

        Parameters
        ----------
        header: MqttFixedHeader
        f: file
            Object with a read method.

        Raises
        ------
        DecodeError
            When there are extra bytes at the end of the packet.

        Returns
        -------
        int
            Number of bytes consumed from ``f``.
        MqttUnsubscribe
            Object extracted from ``f``.
        """"""
        assert header.packet_type == MqttControlPacketType.unsubscribe

        decoder = mqtt_io.FileDecoder(mqtt_io.LimitReader(f, header.remaining_len))
        packet_id, = decoder.unpack(mqtt_io.FIELD_PACKET_ID)

        topics = []
        while header.remaining_len > decoder.num_bytes_consumed:
            num_str_bytes, topic = decoder.unpack_utf8()
            topics.append(topic)

        assert header.remaining_len - decoder.num_bytes_consumed == 0

        return decoder.num_bytes_consumed, MqttUnsubscribe(packet_id, topics)"
1175,"def decode_body(cls, header, f):
        """"""Generates a `MqttUnsuback` packet given a
        `MqttFixedHeader`.  This method asserts that header.packet_type
        is `unsuback`.

        Parameters
        ----------
        header: MqttFixedHeader
        f: file
            Object with a read method.

        Raises
        ------
        DecodeError
            When there are extra bytes at the end of the packet.

        Returns
        -------
        int
            Number of bytes consumed from ``f``.
        MqttUnsuback
            Object extracted from ``f``.
        """"""
        assert header.packet_type == MqttControlPacketType.unsuback

        decoder = mqtt_io.FileDecoder(mqtt_io.LimitReader(f, header.remaining_len))
        packet_id, = decoder.unpack(mqtt_io.FIELD_PACKET_ID)

        if header.remaining_len != decoder.num_bytes_consumed:
            raise DecodeError('Extra bytes at end of packet.')

        return decoder.num_bytes_consumed, MqttUnsuback(packet_id)"
1176,"def decode_body(cls, header, f):
        """"""Generates a `MqttPingreq` packet given a
        `MqttFixedHeader`.  This method asserts that header.packet_type
        is `pingreq`.

        Parameters
        ----------
        header: MqttFixedHeader
        f: file
            Object with a read method.

        Raises
        ------
        DecodeError
            When there are extra bytes at the end of the packet.

        Returns
        -------
        int
            Number of bytes consumed from ``f``.
        MqttPingreq
            Object extracted from ``f``.
        """"""
        assert header.packet_type == MqttControlPacketType.pingreq

        if header.remaining_len != 0:
            raise DecodeError('Extra bytes at end of packet.')

        return 0, MqttPingreq()"
1177,"def decode_body(cls, header, f):
        """"""Generates a `MqttPingresp` packet given a
        `MqttFixedHeader`.  This method asserts that header.packet_type
        is `pingresp`.

        Parameters
        ----------
        header: MqttFixedHeader
        f: file
            Object with a read method.

        Raises
        ------
        DecodeError
            When there are extra bytes at the end of the packet.

        Returns
        -------
        int
            Number of bytes consumed from ``f``.
        MqttPingresp
            Object extracted from ``f``.
        """"""
        assert header.packet_type == MqttControlPacketType.pingresp

        if header.remaining_len != 0:
            raise DecodeError('Extra bytes at end of packet.')

        return 0, MqttPingresp()"
1178,"def decode_body(cls, header, f):
        """"""Generates a :class:`MqttDisconnect` packet given a
        :class:`MqttFixedHeader`.  This method asserts that
        header.packet_type is :const:`MqttControlPacketType.disconnect`.

        Parameters
        ----------
        header: MqttFixedHeader
        f: file
            Object with a read method.

        Raises
        ------
        DecodeError
            When there are extra bytes at the end of the packet.

        Returns
        -------
        int
            Number of bytes consumed from ``f``.
        MqttDisconnect
            Object extracted from ``f``.
        """"""
        assert header.packet_type == MqttControlPacketType.disconnect

        if header.remaining_len != 0:
            raise DecodeError('Extra bytes at end of packet.')

        return 0, MqttDisconnect()"
1179,"def getter(name, key=None):
  """"""
  Creates a read-only property for the attribute name *name*. If a *key*
  function is provided, it can be used to post-process the value of the
  attribute.
  """"""

  if not key:
    key = lambda x: x

  def wrapper(self):
    return key(getattr(self, name))
  wrapper.__name__ = wrapper.__qualname__ = name
  return property(wrapper)"
1180,"def connect(self):
        """"""
        Sets up your Phabricator session, it's not necessary to call
        this directly
        """"""
        if self.token:
            self.phab_session = {'token': self.token}
            return

        req = self.req_session.post('%s/api/conduit.connect' % self.host, data={
            'params': json.dumps(self.connect_params),
            'output': 'json',
            '__conduit__': True,
        })

        # Parse out the response (error handling ommitted)
        result = req.json()['result']
        self.phab_session = {
            'sessionKey': result['sessionKey'],
            'connectionID': result['connectionID'],
        }"
1181,"def request(self, method, params=None):
        """"""
        Make a request to a method in the phabricator API
        :param method: Name of the API method to call
        :type method: basestring
        :param params: Optional dict of params to pass
        :type params: dict
        """"""
        if params is None:
            params = {}
        if not self.phab_session:
            self.connect()
        url = '%s/api/%s' % (self.host, method)
        params['__conduit__'] = self.phab_session
        req = self.req_session.post(url, data={
            'params': json.dumps(params),
            'output': 'json',
        })
        return json.loads(
            req.content.decode(),
            object_pairs_hook=collections.OrderedDict
        )['result']"
1182,"def get_musiclibrary():
    lib_files = music_library.get_file_list(config.library_path)
    global lib
    lib = music_library.parse_library(lib_files)
    """""":type :musiclibrary.MusicLibrary""""""
    return lib"
1183,"def install(force=False):
    """"""Install git hooks.""""""
    ret, git_dir, _ = run(""git rev-parse --show-toplevel"")
    if ret != 0:
        click.echo(
            ""ERROR: Please run from within a GIT repository."",
            file=sys.stderr)
        raise click.Abort
    git_dir = git_dir[0]

    hooks_dir = os.path.join(git_dir, HOOK_PATH)

    for hook in HOOKS:
        hook_path = os.path.join(hooks_dir, hook)
        if os.path.exists(hook_path):
            if not force:
                click.echo(
                    ""Hook already exists. Skipping {0}"".format(hook_path),
                    file=sys.stderr)
                continue
            else:
                os.unlink(hook_path)

        source = os.path.join(sys.prefix, ""bin"", ""kwalitee-"" + hook)
        os.symlink(os.path.normpath(source), hook_path)
    return True"
1184,"def uninstall():
    """"""Uninstall git hooks.""""""
    ret, git_dir, _ = run(""git rev-parse --show-toplevel"")
    if ret != 0:
        click.echo(
            ""ERROR: Please run from within a GIT repository."",
            file=sys.stderr)
        raise click.Abort
    git_dir = git_dir[0]

    hooks_dir = os.path.join(git_dir, HOOK_PATH)

    for hook in HOOKS:
        hook_path = os.path.join(hooks_dir, hook)
        if os.path.exists(hook_path):
            os.remove(hook_path)
    return True"
1185,"def find_promulgation_date(line):
    """"""
    >>> find_promulgation_date(""Loi  nº 2010-383 du 16 avril 2010 autorisant l'approbation de l'accord entre..."")
    '2010-04-16'
    """"""
    line = line.split(' du ')[1]
    return format_date(re.search(r""(\d\d? \w\w\w+ \d\d\d\d)"", line).group(1))"
1186,"def historic_doslegs_parse(html, url_an=None, logfile=sys.stderr, nth_dos_in_page=0, parse_previous_works=True, parse_next_works=True):
    """"""
    Parse an AN dosleg like http://www.assemblee-nationale.fr/13/dossiers/accord_Montenegro_mobilite_jeunes.asp

    nth_dos_in_page, parse_previous_works and parse_next_works are for internal logic
    """"""

    data = {
        'url_dossier_assemblee': clean_url(url_an),
        'urgence': False,
    }

    def log_error(*error):
        print('## ERROR ###', *error, file=logfile)

    def log_warning(*error):
        print('## WARNING ###', *error, file=logfile)

    soup = BeautifulSoup(html, 'lxml')

    legislature, slug = parse_national_assembly_url(data['url_dossier_assemblee'])
    data['assemblee_slug'] = slug
    if legislature:
        data['assemblee_legislature'] = legislature
    else:  # strange link (old dosleg)
        log_error('NO LEGISLATURE IN AN LINK: ' + data['url_dossier_assemblee'])
    data['assemblee_id'] = '%s-%s' % (data.get('assemblee_legislature', ''), data['assemblee_slug'])

    data['steps'] = []
    curr_institution = 'assemblee'
    curr_stage = '1ère lecture'
    last_section = None  # Travaux des commissions/Discussion en séance publique
    last_step_index = 0
    travaux_prep_already = False
    another_dosleg_inside = None
    predicted_next_step = None  # For unfinished projects, we try to catch the next step
    previous_works = None
    url_jo = None

    html_lines = html.split('\n')
    for i, line in enumerate(html_lines):
        def parse_line():
            return BeautifulSoup(line, 'lxml')

        def line_text():
            return parse_line().text.strip()

        def get_last_step():
            if len(data['steps']) > 0:
                return data['steps'][-1]
            return {}

        if '<COMMENTAIRE>' in line or '<table border=""1""' in line:
            continue

        if '<font face=""ARIAL"" size=""3"" color=""#000080"">' in line:
            data['long_title'] = line_text()
        if '<br><b><font color=""#000099"">Travaux des commissions</font></b><br>' in line:
            last_section = line_text()
        if '<p align=""center""><b><font color=""#000080"">Travaux préparatoires</font></b><br>' in line:
            if travaux_prep_already:
                if parse_next_works and not nth_dos_in_page:
                    log_warning('FOUND ANOTHER DOSLEG INSIDE THE DOSLEG')
                    another_dosleg_inside = '\n'.join(html.split('\n')[last_step_index + 1:])
                if not nth_dos_in_page:
                    break
                travaux_prep_already = False
            else:
                travaux_prep_already = True
        if not parse_next_works and travaux_prep_already and nth_dos_in_page:
            continue

        # Senat 1ère lecture, CMP, ...
        if '<font color=""#000099"" size=""2"" face=""Arial"">' in line:
            text = line_text()
            last_section = None
            if 'Dossier en ligne sur le site du Sénat' in text:
                data['url_dossier_senat'] = clean_url(parse_line().select(
                    'a')[-1].attrs['href'])
                text = text.replace(
                    '(Dossier en ligne sur le site du Sénat)', '')
            if 'Sénat' in text:
                curr_institution = 'senat'
            elif 'Assemblée nationale' in text:
                curr_institution = 'assemblee'
            elif 'Commission Mixte Paritaire' in text or 'Lecture texte CMP' in text:
                curr_institution = 'CMP'
                curr_stage = 'CMP'
            elif 'Conseil Constitutionnel' in text:
                curr_institution = 'conseil constitutionnel'
                curr_stage = 'constitutionnalité'
            elif 'Congrès du Parlement' in text:
                curr_institution = 'congrès'
                curr_stage = 'congrès'

            if '1ère lecture' in text:
                curr_stage = '1ère lecture'
            elif '2e lecture' in text:
                curr_stage = '2ème lecture'
            elif 'Nouvelle lecture' in text:
                curr_stage = 'nouv. lect.'
            elif 'Lecture définitive' in text:
                curr_stage = 'l. définitive'
            if not curr_stage:
                curr_stage = text.split('-')[-1].strip().lower()

            if curr_stage == ""création de la commission d'enquête"":
                log_warning('COMMISSION D\'ENQUETE')
                return None

        if '>Proposition de résolution européenne<' in line:
            log_warning('PROPOSITION DE RESOLUTION EUROPEENE')
            return None

        if '>Accès aux Travaux préparatoires' in line and not previous_works:
            previous_works = clean_url(urljoin(url_an, parse_line().find('a').attrs['href']))

        curr_step = None
        # conseil. consti. has no step but we should get the link
        no_step_but_good_link = False
        if 'Rapport portant également sur les propositions' in line:
            continue
        elif re.search(r'<a[^>]* href=[^>]*>(projet de loi|proposition de loi|proposition de résolution)', line, re.I):
            curr_step = 'depot'
            if curr_stage == 'CMP':
                continue
        elif "">Texte de la commission"" in line or '/ta-commission/' in line:
            curr_step = 'commission'

        elif '/ta/' in line or '/leg/tas' in line:
            if get_last_step().get('stage') != curr_stage:
                curr_step = 'depot'
                if curr_stage == 'CMP':
                    curr_step = 'commission'
            else:
                curr_step = 'hemicycle'
        elif ('/rapports/' in line or '/rap/' in line) and last_section and 'commissions' in last_section:
            if get_last_step().get('step') == 'commission':
                # log_warning('DOUBLE COMMISSION LINE: %s' % line)
                continue
            curr_step = 'commission'

        elif 'www.conseil-constitutionnel.fr/decision/' in line:
            no_step_but_good_link = True

        # no commissions for l. définitive
        if curr_stage == 'l. définitive' and curr_step == 'commission':
            continue

        if curr_step or no_step_but_good_link:
            # if same step previously, replace or not the url
            if get_last_step().get('step') == curr_step:
                # log_warning('DOUBLE STEP: %s' % line)
                # remove last step since we prefer text links instead of reports links
                # TODO: add report link as bonus_url
                last_url = get_last_step().get('source_url')
                if not last_url or ('/rapports/' in last_url or '/rap/' in last_url):
                    data['steps'] = data['steps'][:-1]
                # looks like the last url was already a text, let's assume it's a multi-depot
                else:
                    # multi-depot if not CMP
                    # TODO: re-order multi depot
                    if curr_institution == 'senat' and curr_stage != 'CMP':
                        curr_step = 'depot'

            links = [a.attrs.get('href') for a in parse_line().select('a')]
            links = [
                href for href in links if href and 'fiches_id' not in href and '/senateur/' not in href and 'javascript:' not in href]
            if not links:
                log_error('NO LINK IN LINE: %s' % (line,))
                continue
            urls_raps = []
            urls_others = []
            for href in links:
                if '/rap/' in href or '/rapports/' in href:
                    urls_raps.append(href)
                else:
                    urls_others.append(href)

            cmp_commission_other_url = None
            if len(urls_others) > 0:
                url = urls_others[0]
                # CMP commission should produce two texts, one for each institution
                if curr_step == 'commission' and curr_stage == 'CMP' and len(urls_others) > 1:
                    cmp_commission_other_url = clean_url(urljoin(url_an, urls_others[1]))
            else:
                url = urls_raps[0]

            url = clean_url(urljoin(url_an, url))

            real_institution = curr_institution
            if curr_stage == 'CMP' and curr_step == 'hemicycle':
                if 'assemblee-nationale.fr' in url:
                    real_institution = 'assemblee'
                elif 'senat.fr' in url:
                    real_institution = 'senat'

            step = {
                'institution': real_institution,
                'stage': curr_stage,
                'source_url': url,
            }

            if curr_step:
                step['step'] = curr_step

            if cmp_commission_other_url:
                step['cmp_commission_other_url'] = cmp_commission_other_url

            # try to detect a date
            for test_line in (line, html_lines[i-1]):
                test_line = test_line.replace('1<sup>er</sup>', '1')
                date_match = re.search(r'(déposée? le|adoptée? .*? le|modifiée? .*?|rejetée? .*?)\s*(\d\d? \w\w\w+ \d\d\d\d)', test_line, re.I)
                if date_match:
                    step['date'] = format_date(date_match.group(2))
                else:
                    date_match = re.search(r'(mis en ligne le)\s*(\d\d? \w\w\w+ \d\d\d\d)', test_line, re.I)
                    if date_match:
                        step['date'] = format_date(date_match.group(2))
                if 'date' in step and 'beginning' not in data:
                    data['beginning'] = step['date']
            data['steps'].append(step)
            predicted_next_step = None
            last_step_index = i

        if 'publiée au Journal Officiel' in line and not url_jo:
            links = [clean_url(a.attrs['href']) for a in parse_line().select('a') if 'legifrance' in a.attrs.get('href', '')]
            if not links:
                log_error('NO GOOD LINK IN LINE: %s' % (line,))
                continue
            url_jo = links[-1]

        if 'Le Gouvernement a engagé la procédure accélérée' in line or 'engagement de la procédure accélérée' in line:
            data['urgence'] = True

        # Next step prediction via small clues
        # TODO: this could be done via last_section (we parse two times the same thing)
        # TODO: this fails for CMP hemicycle senat
        if curr_stage != 'CMP':
            if '>Discussion en séance publique<' in line:
                predicted_next_step = {
                    'institution': curr_institution,
                    'stage': curr_stage,
                    'step': 'hemicycle',
                }
            elif '>Travaux des commissions<' in line:
                predicted_next_step = {
                    'institution': curr_institution,
                    'stage': curr_stage,
                    'step': 'commission',
                }

    metas = {}
    for meta in soup.select('meta'):
        if 'name' in meta.attrs:
            metas[meta.attrs['name']] = meta.attrs['content']

    if not url_jo:
        url_jo = metas.get('LIEN_LOI_PROMULGUEE')

    if url_jo:
        data['url_jo'] = clean_url(url_jo)
        promulgation_step = {
            'institution': 'gouvernement',
            'stage': 'promulgation',
            'source_url': data['url_jo'],
        }
        if metas.get('LOI_PROMULGUEE'):
            data['end'] = find_promulgation_date(metas.get('LOI_PROMULGUEE'))
            promulgation_step['date'] = data['end']
        data['steps'].append(promulgation_step)
    # add predicted next step for unfinished projects
    elif predicted_next_step:
        data['steps'].append(predicted_next_step)

    if 'url_dossier_senat' not in data or 'dossier-legislatif' not in data['url_dossier_senat']:
        senat_url = find_senat_url(data)
        if senat_url:
            data['url_dossier_senat'] = senat_url

    # append previous works if there are some
    if previous_works and parse_previous_works:
        log_warning('MERGING %s WITH PREVIOUS WORKS %s' % (url_an, previous_works))
        resp = download_historic_dosleg(previous_works)
        prev_data = historic_doslegs_parse(
            resp.text, previous_works,
            logfile=logfile,
            nth_dos_in_page=nth_dos_in_page, parse_next_works=False)
        if prev_data:
            prev_data = prev_data[nth_dos_in_page] if len(prev_data) > 1 else prev_data[0]
            data = merge_previous_works_an(prev_data, data)
        else:
            log_warning('INVALID PREVIOUS WORKS', previous_works)

    # is this part of a dosleg previous works ?
    next_legislature = data['assemblee_legislature'] + 1 if 'assemblee_legislature' in data else 9999
    if parse_next_works and next_legislature < 15:
        #  TODO: parse 15th legislature from open data if it exists
        resp = download_historic_dosleg(url_an.replace('/%d/' % data['assemblee_legislature'], '/%d/' % (data['assemblee_legislature'] + 1)))
        if resp.status_code == 200:
            recent_data = historic_doslegs_parse(
                resp.text, resp.url,
                logfile=logfile,
                nth_dos_in_page=nth_dos_in_page, parse_previous_works=False)
            if recent_data:
                log_warning('FOUND MORE RECENT WORKS', resp.url)
                recent_data = recent_data[nth_dos_in_page] if len(recent_data) > 1 else recent_data[0]
                data = merge_previous_works_an(data, recent_data)

    if another_dosleg_inside:
        others = historic_doslegs_parse(another_dosleg_inside, url_an, logfile=logfile, nth_dos_in_page=nth_dos_in_page+1)
        if others:
            return [data] + others
    return [data]"
1187,"def auto_need(form):
    """"""Automatically ``need()`` the relevant Fanstatic resources for a form.

    This function automatically utilises libraries in the ``js.*`` namespace
    (such as ``js.jquery``, ``js.tinymce`` and so forth) to allow Fanstatic
    to better manage these resources (caching, minifications) and avoid
    duplication across the rest of your application.
    """"""

    requirements = form.get_widget_requirements()

    for library, version in requirements:
        resources = resource_mapping[library]
        if not isinstance(resources, list):  # pragma: no cover (bw compat only)
            resources = [resources]
        for resource in resources:
            resource.need()"
1188,"def setup_logger():
    """"""
    setup basic logger
    """"""
    logger = logging.getLogger('dockerstache')
    logger.setLevel(logging.INFO)
    handler = logging.StreamHandler(stream=sys.stdout)
    handler.setLevel(logging.INFO)
    logger.addHandler(handler)
    return logger"
1189,"def named_any(name):
    """"""
    Retrieve a Python object by its fully qualified name from the global Python
    module namespace.  The first part of the name, that describes a module,
    will be discovered and imported.  Each subsequent part of the name is
    treated as the name of an attribute of the object specified by all of the
    name which came before it.
    @param name: The name of the object to return.
    @return: the Python object identified by 'name'.
    """"""
    assert name, 'Empty module name'
    names = name.split('.')

    topLevelPackage = None
    moduleNames = names[:]
    while not topLevelPackage:
        if moduleNames:
            trialname = '.'.join(moduleNames)
            try:
                topLevelPackage = __import__(trialname)
            except Exception, ex:
                moduleNames.pop()
        else:
            if len(names) == 1:
                raise Exception(""No module named %r"" % (name,))
            else:
                raise Exception('%r does not name an object' % (name,))

    obj = topLevelPackage
    for n in names[1:]:
        obj = getattr(obj, n)

    return obj"
1190,"def for_name(modpath, classname):
    '''
    Returns a class of ""classname"" from module ""modname"".
    '''
    module = __import__(modpath, fromlist=[classname])
    classobj = getattr(module, classname)
    return classobj()"
1191,"def _convert(self, val):
        """""" Convert the type if necessary and return if a conversion happened. """"""
        if isinstance(val, dict) and not isinstance(val, DotDict):
            return DotDict(val), True
        elif isinstance(val, list) and not isinstance(val, DotList):
            return DotList(val), True

        return val, False"
1192,"def full_subgraph(self, vertices):
        """"""
        Return the subgraph of this graph whose vertices
        are the given ones and whose edges are the edges
        of the original graph between those vertices.

        """"""
        obj_map = {vertex.id: vertex for vertex in vertices}
        edges = [
            edge for vertex_id in obj_map
            for edge in self._out_edges[vertex_id]
            if edge.head in obj_map
        ]

        return AnnotatedGraph(
            vertices=obj_map.values(),
            edges=edges,
        )"
1193,"def to_json(self):
        """"""
        Convert to a JSON string.

        """"""
        obj = {
            ""vertices"": [
                {
                    ""id"": vertex.id,
                    ""annotation"": vertex.annotation,
                }
                for vertex in self.vertices
            ],
            ""edges"": [
                {
                    ""id"": edge.id,
                    ""annotation"": edge.annotation,
                    ""head"": edge.head,
                    ""tail"": edge.tail,
                }
                for edge in self._edges
            ],
        }
        # Ensure that we always return unicode output on Python 2.
        return six.text_type(json.dumps(obj, ensure_ascii=False))"
1194,"def from_json(cls, json_graph):
        """"""
        Reconstruct the graph from a graph exported to JSON.

        """"""
        obj = json.loads(json_graph)

        vertices = [
            AnnotatedVertex(
                id=vertex[""id""],
                annotation=vertex[""annotation""],
            )
            for vertex in obj[""vertices""]
        ]

        edges = [
            AnnotatedEdge(
                id=edge[""id""],
                annotation=edge[""annotation""],
                head=edge[""head""],
                tail=edge[""tail""],
            )
            for edge in obj[""edges""]
        ]

        return cls(vertices=vertices, edges=edges)"
1195,"def export_json(self, filename):
        """"""
        Export graph in JSON form to the given file.

        """"""
        json_graph = self.to_json()
        with open(filename, 'wb') as f:
            f.write(json_graph.encode('utf-8'))"
1196,"def import_json(cls, filename):
        """"""
        Import graph from the given file.  The file is expected
        to contain UTF-8 encoded JSON data.

        """"""
        with open(filename, 'rb') as f:
            json_graph = f.read().decode('utf-8')
        return cls.from_json(json_graph)"
1197,"def to_dot(self):
        """"""
        Produce a graph in DOT format.

        """"""
        edge_labels = {
            edge.id: edge.annotation
            for edge in self._edges
        }

        edges = [self._format_edge(edge_labels, edge) for edge in self._edges]

        vertices = [
            DOT_VERTEX_TEMPLATE.format(
                vertex=vertex.id,
                label=dot_quote(vertex.annotation),
            )
            for vertex in self.vertices
        ]

        return DOT_DIGRAPH_TEMPLATE.format(
            edges="""".join(edges),
            vertices="""".join(vertices),
        )"
1198,"def export_image(self, filename='refcycle.png', format=None,
                     dot_executable='dot'):
        """"""
        Export graph as an image.

        This requires that Graphviz is installed and that the ``dot``
        executable is in your path.

        The *filename* argument specifies the output filename.

        The *format* argument lets you specify the output format.  It may be
        any format that ``dot`` understands, including extended format
        specifications like ``png:cairo``.  If omitted, the filename extension
        will be used; if no filename extension is present, ``png`` will be
        used.

        The *dot_executable* argument lets you provide a full path to the
        ``dot`` executable if necessary.

        """"""
        # Figure out what output format to use.
        if format is None:
            _, extension = os.path.splitext(filename)
            if extension.startswith('.') and len(extension) > 1:
                format = extension[1:]
            else:
                format = 'png'

        # Convert to 'dot' format.
        dot_graph = self.to_dot()

        # We'll send the graph directly to the process stdin.
        cmd = [
            dot_executable,
            '-T{}'.format(format),
            '-o{}'.format(filename),
        ]
        dot = subprocess.Popen(cmd, stdin=subprocess.PIPE)
        dot.communicate(dot_graph.encode('utf-8'))"
1199,"def serve_command(info, host, port, reload, debugger, eager_loading,
                with_threads):
    """"""Runs a local development server for the Flask application.
    This local server is recommended for development purposes only but it
    can also be used for simple intranet deployments.  By default it will
    not support any sort of concurrency at all to simplify debugging.  This
    can be changed with the --with-threads option which will enable basic
    multithreading.
    The reloader and debugger are by default enabled if the debug flag of
    Flask is enabled and disabled otherwise.
    """"""
    from werkzeug.serving import run_simple

    debug = get_debug_flag()
    if reload is None:
        reload = bool(debug)
    if debugger is None:
        debugger = bool(debug)
    if eager_loading is None:
        eager_loading = not reload

    app = DispatchingApp(info.load_app, use_eager_loading=eager_loading)

    # Extra startup messages.  This depends a but on Werkzeug internals to
    # not double execute when the reloader kicks in.
    if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
        # If we have an import path we can print it out now which can help
        # people understand what's being served.  If we do not have an
        # import path because the app was loaded through a callback then
        # we won't print anything.
        if info.app_import_path is not None:
            print(' * Serving Flask app ""%s""' % info.app_import_path)
        if debug is not None:
            print(' * Forcing debug mode %s' % (debug and 'on' or 'off'))

    reloader_path = '.'
    if info.app_import_path:
        if os.path.isdir(info.app_import_path):
            reloader_path = info.app_import_path
        elif os.path.isfile(info.app_import_path):
            reloader_path = os.path.dirname(info.app_import_path)
    extra_files = get_reloader_extra_files(reloader_path)

    run_simple(host, port, app, use_reloader=reload, extra_files=extra_files,
               use_debugger=debugger, threaded=with_threads)"
1200,"def load_calls(self, call_type='jsonrpc'):
        """"""Loads the KvasirAPI calls into API.call based on the call_type variable. Utilizes the `Calls` class to
        establish an attribute-based access method. For instance a configuration with an instance called 'internal'
        will create an API.call that can be used like this:

            API.call.internal.hosts.list()  # return all hosts from Kvasir instance 'internal'

        :param call_type: string of 'jsonrpc' or 'restapi'
        :return: self.call dictionary
        """"""
        valid = False
        if call_type == 'jsonrpc':
            #from jsonrpc import Hosts, Services, Accounts, Vulns, OS, NetBIOS, Evidence
            import jsonrpc as api_calls
            self.api_calls = api_calls
            valid = True
        #if call_type == 'rest'
            # TODO: Implement restful API functions
            #from restapi import hosts, services, accounts, vulns, os, netbios, evidence

        if valid:
            # if kvasir configuration is valid, go through the instances and build the self.call dict
            for instance, values in self.configuration.instances_dict.items():
                self.call[instance] = Calls()
                self.call[instance].call_type = call_type
                self.call[instance].hosts = self.api_calls.Hosts(values, self.configuration.web2py_dir)
                self.call[instance].services = self.api_calls.Services(values, self.configuration.web2py_dir)
                self.call[instance].accounts = self.api_calls.Accounts(values, self.configuration.web2py_dir)
                self.call[instance].vulns = self.api_calls.Vulns(values, self.configuration.web2py_dir)
                self.call[instance].os = self.api_calls.OpSys(values, self.configuration.web2py_dir)
                self.call[instance].snmp = self.api_calls.SNMP(values, self.configuration.web2py_dir)
                self.call[instance].netbios = self.api_calls.NetBIOS(values, self.configuration.web2py_dir)
                self.call[instance].evidence = self.api_calls.Evidence(values, self.configuration.web2py_dir)
                self.call[instance].stats = self.api_calls.Stats(values, self.configuration.web2py_dir)"
1201,"def install_brew(target_path):
    """""" Install brew to the target path """"""
    if not os.path.exists(target_path):
        try:
            os.makedirs(target_path)
        except OSError:
            logger.warn(""Unable to create directory %s for brew."" % target_path)
            logger.warn(""Skipping..."")
            return
    extract_targz(HOMEBREW_URL, target_path, remove_common_prefix=True)"
1202,"def scales(self, image):
    """"""scales(image) -> scale, shape

    Computes the all possible scales for the given image and yields a tuple of the scale and the scaled image shape as an iterator.

    **Parameters::**

    ``image`` : array_like(2D or 3D)
      The image, for which the scales should be computed

    **Yields:**

    ``scale`` : float
      The next scale of the image to be considered

    ``shape`` : (int, int) or (int, int, int)
      The shape of the image, when scaled with the current ``scale``
    """"""
    # compute the minimum scale so that the patch size still fits into the given image
    minimum_scale = max(self.m_patch_box.size_f[0] / image.shape[-2], self.m_patch_box.size_f[1] / image.shape[-1])
    if self.m_lowest_scale:
      maximum_scale = min(minimum_scale / self.m_lowest_scale, 1.)
    else:
      maximum_scale = 1.
    current_scale_power = 0.

    # iterate over all possible scales
    while True:
      # scale the image
      scale = minimum_scale * math.pow(self.m_scale_factor, current_scale_power)
      if scale > maximum_scale:
        # image is smaller than the requested minimum size
        break
      current_scale_power -= 1.
      scaled_image_shape = bob.ip.base.scaled_output_shape(image, scale)

      # return both the scale and the scaled image size
      yield scale, scaled_image_shape"
1203,"def sample_scaled(self, shape):
    """"""sample_scaled(shape) -> bounding_box

    Yields an iterator that iterates over all sampled bounding boxes in the given (scaled) image shape.

    **Parameters:**

    ``shape`` : (int, int) or (int, int, int)
      The (current) shape of the (scaled) image

    **Yields:**

    ``bounding_box`` : :py:class:`BoundingBox`
      An iterator iterating over all bounding boxes that are valid for the given shape
    """"""
    for y in range(0, shape[-2]-self.m_patch_box.bottomright[0], self.m_distance):
      for x in range(0, shape[-1]-self.m_patch_box.bottomright[1], self.m_distance):
        # create bounding box for the current shift
        yield self.m_patch_box.shift((y,x))"
1204,"def sample(self, image):
    """"""sample(image) -> bounding_box

    Yields an iterator over all bounding boxes in different scales that are sampled for the given image.

    **Parameters:**

    ``image`` : array_like(2D or 3D)
      The image, for which the bounding boxes should be generated

    **Yields:**

    ``bounding_box`` : :py:class:`BoundingBox`
      An iterator iterating over all bounding boxes for the given ``image``
    """"""
    for scale, scaled_image_shape in self.scales(image):
      # prepare the feature extractor to extract features from the given image
      for bb in self.sample_scaled(scaled_image_shape):
        # extract features for
        yield bb.scale(1./scale)"
1205,"def iterate(self, image, feature_extractor, feature_vector):
    """"""iterate(image, feature_extractor, feature_vector) -> bounding_box

    Scales the given image, and extracts features from all possible bounding boxes.

    For each of the sampled bounding boxes, this function fills the given pre-allocated feature vector and yields the current bounding box.

    **Parameters:**

    ``image`` : array_like(2D)
      The given image to extract features for

    ``feature_extractor`` : :py:class:`FeatureExtractor`
      The feature extractor to use to extract the features for the sampled patches

    ``feature_vector`` : :py:class:`numpy.ndarray` (1D, uint16)
      The pre-allocated feature vector that will be filled inside this function; needs to be of size :py:attr:`FeatureExtractor.number_of_features`

    **Yields:**

    ``bounding_box`` : :py:class:`BoundingBox`
      The bounding box for which the current features are extracted for
    """"""
    for scale, scaled_image_shape in self.scales(image):
      # prepare the feature extractor to extract features from the given image
      feature_extractor.prepare(image, scale)
      for bb in self.sample_scaled(scaled_image_shape):
        # extract features for
        feature_extractor.extract_indexed(bb, feature_vector)
        yield bb.scale(1./scale)"
1206,"def iterate_cascade(self, cascade, image, threshold = None):
    """"""iterate_cascade(self, cascade, image, [threshold]) -> prediction, bounding_box

    Iterates over the given image and computes the cascade of classifiers.
    This function will compute the cascaded classification result for the given ``image`` using the given ``cascade``.
    It yields a tuple of prediction value and the according bounding box.
    If a ``threshold`` is specified, only those ``prediction``\s are returned, which exceed the given ``threshold``.

    .. note::
       The ``threshold`` does not overwrite the cascade thresholds `:py:attr:`Cascade.thresholds`, but only threshold the final prediction.
       Specifying the ``threshold`` here is just slightly faster than thresholding the yielded prediction.

    **Parameters:**

    ``cascade`` : :py:class:`Cascade`
      The cascade that performs the predictions

    ``image`` : array_like(2D)
      The image for which the predictions should be computed

    ``threshold`` : float
      The threshold, which limits the number of predictions

    **Yields:**

    ``prediction`` : float
      The prediction value for the current bounding box

    ``bounding_box`` : :py:class:`BoundingBox`
      An iterator over all possible sampled bounding boxes (which exceed the prediction ``threshold``, if given)
    """"""

    for scale, scaled_image_shape in self.scales(image):
      # prepare the feature extractor to extract features from the given image
      cascade.prepare(image, scale)
      for bb in self.sample_scaled(scaled_image_shape):
        # return the prediction and the bounding box, if the prediction is over threshold
        prediction = cascade(bb)
        if threshold is None or prediction > threshold:
          yield prediction, bb.scale(1./scale)"
1207,"def pass_service(*names):
    """"""Injects a service instance into the kwargs
    """"""
    def decorator(f):
        @functools.wraps(f)
        def wrapper(*args, **kwargs):
            for name in names:
                kwargs[name] = service_proxy(name)
            return f(*args, **kwargs)
        return wrapper
    return decorator"
1208,"def get_conn():
    """"""Return a connection to DynamoDB.""""""
    if os.environ.get('DEBUG', False) or os.environ.get('travis', False):
        # In DEBUG mode - use the local DynamoDB
        # This also works for travis since we'll be running dynalite
        conn = DynamoDBConnection(
            host='localhost',
            port=8000,
            aws_access_key_id='TEST',
            aws_secret_access_key='TEST',
            is_secure=False
        )
    else:
        # Regular old production
        conn = DynamoDBConnection()

    return conn"
1209,"def map_index_val(index_val):
        """"""Xform index_val so that it can be stored/queried.""""""
        if index_val is None:
            return DynamoMappings.NONE_VAL

        index_val = str(index_val)
        if not index_val:
            return DynamoMappings.EMPTY_STR_VAL

        return index_val"
1210,"def table_schema_call(self, target, cls):
        """"""Perform a table schema call.

        We call the callable target with the args and keywords needed for the
        table defined by cls. This is how we centralize the Table.create and
        Table ctor calls.
        """"""
        index_defs = []
        for name in cls.index_names() or []:
            index_defs.append(GlobalIncludeIndex(
                gsi_name(name),
                parts=[HashKey(name)],
                includes=['value']
            ))

        return target(
            cls.get_table_name(),
            connection=get_conn(),
            schema=[HashKey('id')],
            global_indexes=index_defs or None
        )"
1211,"def ensure_table(self, cls):
        """"""Required functionality.""""""
        exists = True
        conn = get_conn()

        try:
            descrip = conn.describe_table(cls.get_table_name())
            assert descrip is not None
        except ResourceNotFoundException:
            # Expected - this is what we get if there is no table
            exists = False
        except JSONResponseError:
            # Also assuming no table
            exists = False

        if not exists:
            table = self.table_schema_call(Table.create, cls)
            assert table is not None"
1212,"def find_one(self, cls, id):
        """"""Required functionality.""""""
        try:
            db_result = self.get_class_table(cls).lookup(id)
        except ItemNotFound:
            # according to docs, this shouldn't be required, but it IS
            db_result = None

        if not db_result:
            return None

        obj = cls.from_data(db_result['value'])
        return obj"
1213,"def find_all(self, cls):
        """"""Required functionality.""""""
        final_results = []
        table = self.get_class_table(cls)
        for db_result in table.scan():
            obj = cls.from_data(db_result['value'])
            final_results.append(obj)

        return final_results"
1214,"def find_by_index(self, cls, index_name, value):
        """"""Required functionality.""""""
        query_args = {
            index_name + '__eq': DynamoMappings.map_index_val(value),
            'index': gsi_name(index_name)
        }

        final_results = []
        for db_result in self.get_class_table(cls).query_2(**query_args):
            obj = cls.from_data(db_result['value'])
            final_results.append(obj)

        return final_results"
1215,"def save(self, obj):
        """"""Required functionality.""""""
        if not obj.id:
            obj.id = uuid()

        stored_data = {
            'id': obj.id,
            'value': obj.to_data()
        }

        index_vals = obj.indexes() or {}
        for key in obj.__class__.index_names() or []:
            val = index_vals.get(key, '')
            stored_data[key] = DynamoMappings.map_index_val(val)

        table = self.get_class_table(obj.__class__)
        item = Item(table, data=stored_data)

        item.save(overwrite=True)"
1216,"def process_event(self, name, subject, data):
        """"""
        Process a single event.
        :param name:
        :param subject:
        :param data:
        """"""
        method_mapping = Registry.get_event(name)
        if not method_mapping:
            log.info('@{}.process_event no subscriber for event `{}`'
                     .format(self.__class__.__name__, name))
            return
        for event, methods in method_mapping.items():
            event_instance = event(subject, data)
            log.info('@{}.process_event `{}` for subject `{}`'.format(
                self.__class__.__name__,
                event_instance.__class__.__name__,
                subject
            ))
            for method in methods:
                with self._context_manager:
                    log.info('>> Calling subscriber `{}`'
                             .format(method.__name__))
                    method(event_instance)"
1217,"def thread(self):
        """"""
        Start a thread for this consumer.
        """"""
        log.info('@{}.thread starting'.format(self.__class__.__name__))
        thread = threading.Thread(target=thread_wrapper(self.consume), args=())
        thread.daemon = True
        thread.start()"
1218,"def create(parser: Parser, obj: PersistedObject = None):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param parser:
        :param obj:
        :return:
        """"""
        if obj is not None:
            return _InvalidParserException('Error ' + str(obj) + ' cannot be parsed using ' + str(parser) + ' since '
                                           + ' this parser does not support ' + obj.get_pretty_file_mode())
        else:
            return _InvalidParserException('Error this parser is neither SingleFile nor MultiFile !')"
1219,"def _parse_multifile(self, desired_type: Type[T], obj: PersistedObject,
                         parsing_plan_for_children: Dict[str, ParsingPlan], logger: Logger,
                         options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        First parse all children from the parsing plan, then calls _build_object_from_parsed_children

        :param desired_type:
        :param obj:
        :param parsing_plan_for_children:
        :param logger:
        :param options:
        :return:
        """"""
        pass"
1220,"def execute(self, logger: Logger, options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        Overrides the parent method to add log messages.

        :param logger: the logger to use during parsing (optional: None is supported)
        :param options:
        :return:
        """"""
        in_root_call = False
        if logger is not None:
            # log only for the root object, not for the children that will be created by the code below
            if not hasattr(_BaseParsingPlan.thrd_locals, 'flag_exec') \
                    or _BaseParsingPlan.thrd_locals.flag_exec == 0:
                # print('Executing Parsing Plan for ' + str(self))
                logger.debug('Executing Parsing Plan for [{location}]'
                             ''.format(location=self.obj_on_fs_to_parse.get_pretty_location(append_file_ext=False)))
                _BaseParsingPlan.thrd_locals.flag_exec = 1
                in_root_call = True

        # Common log message
        logger.debug('(P) ' + get_parsing_plan_log_str(self.obj_on_fs_to_parse, self.obj_type,
                                                       log_only_last=not in_root_call, parser=self.parser))

        try:
            res = super(_BaseParsingPlan, self).execute(logger, options)
            if logger.isEnabledFor(DEBUG):
                logger.info('(P) {loc} -> {type} SUCCESS !'
                            ''.format(loc=self.obj_on_fs_to_parse.get_pretty_location(
                    blank_parent_part=not GLOBAL_CONFIG.full_paths_in_logs,
                    compact_file_ext=True),
                    type=get_pretty_type_str(self.obj_type)))
            else:
                logger.info('SUCCESS parsed [{loc}] as a [{type}] successfully. Parser used was [{parser}]'
                            ''.format(loc=self.obj_on_fs_to_parse.get_pretty_location(compact_file_ext=True),
                                      type=get_pretty_type_str(self.obj_type),
                                      parser=str(self.parser)))
            if in_root_call:
                # print('Completed parsing successfully')
                logger.debug('Completed parsing successfully')
            return res

        finally:
            # remove threadlocal flag if needed
            if in_root_call:
                _BaseParsingPlan.thrd_locals.flag_exec = 0"
1221,"def _execute(self, logger: Logger, options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        Implementation of the parent class method.
        Checks that self.parser is a _BaseParser, and calls the appropriate parsing method.

        :param logger:
        :param options:
        :return:
        """"""
        if isinstance(self.parser, _BaseParser):
            if (not self.is_singlefile) and self.parser.supports_multifile():
                return self.parser._parse_multifile(self.obj_type, self.obj_on_fs_to_parse,
                                                    self._get_children_parsing_plan(), logger, options)

            elif self.is_singlefile and self.parser.supports_singlefile():
                return self.parser._parse_singlefile(self.obj_type, self.get_singlefile_path(),
                                                     self.get_singlefile_encoding(), logger, options)
            else:
                raise _InvalidParserException.create(self.parser, self.obj_on_fs_to_parse)
        else:
            raise TypeError('Parser attached to this _BaseParsingPlan is not a ' + str(_BaseParser))"
1222,"def create_parsing_plan(self, desired_type: Type[T], filesystem_object: PersistedObject, logger: Logger,
                            _main_call: bool = True):
        """"""
        Implements the abstract parent method by using the recursive parsing plan impl. Subclasses wishing to produce
        their own parsing plans should rather override _create_parsing_plan in order to benefit from this same log msg.

        :param desired_type:
        :param filesystem_object:
        :param logger:
        :param _main_call: internal parameter for recursive calls. Should not be changed by the user.
        :return:
        """"""
        in_root_call = False

        # -- log msg only for the root call, not for the children that will be created by the code below
        if _main_call and (not hasattr(AnyParser.thrd_locals, 'flag_init') or AnyParser.thrd_locals.flag_init == 0):
            # print('Building a parsing plan to parse ' + str(filesystem_object) + ' into a ' +
            #      get_pretty_type_str(desired_type))
            logger.debug('Building a parsing plan to parse [{location}] into a {type}'
                         ''.format(location=filesystem_object.get_pretty_location(append_file_ext=False),
                                   type=get_pretty_type_str(desired_type)))
            AnyParser.thrd_locals.flag_init = 1
            in_root_call = True

        # -- create the parsing plan
        try:
            pp = self._create_parsing_plan(desired_type, filesystem_object, logger, log_only_last=(not _main_call))
        finally:
            # remove threadlocal flag if needed
            if in_root_call:
                AnyParser.thrd_locals.flag_init = 0

        # -- log success only if in root call
        if in_root_call:
            # print('Parsing Plan created successfully')
            logger.debug('Parsing Plan created successfully')

        # -- finally return
        return pp"
1223,"def _create_parsing_plan(self, desired_type: Type[T], filesystem_object: PersistedObject, logger: Logger,
                             log_only_last: bool = False):
        """"""
        Adds a log message and creates a recursive parsing plan.

        :param desired_type:
        :param filesystem_object:
        :param logger:
        :param log_only_last: a flag to only log the last part of the file path (default False)
        :return:
        """"""
        logger.debug('(B) ' + get_parsing_plan_log_str(filesystem_object, desired_type,
                                                       log_only_last=log_only_last, parser=self))
        return AnyParser._RecursiveParsingPlan(desired_type, filesystem_object, self, logger)"
1224,"def _get_parsing_plan_for_multifile_children(self, obj_on_fs: PersistedObject, desired_type: Type[T],
                                                 logger: Logger) -> Dict[str, ParsingPlan[T]]:
        """"""
        This method is called by the _RecursiveParsingPlan when created.
        Implementing classes should return a dictionary containing a ParsingPlan for each child they plan to parse
        using this framework. Note that for the files that will be parsed using a parsing library it is not necessary to
        return a ParsingPlan.

        In other words, implementing classes should return here everything they need for their implementation of
        _parse_multifile to succeed. Indeed during parsing execution, the framework will call their _parse_multifile
        method with that same dictionary as an argument (argument name is 'parsing_plan_for_children', see _BaseParser).

        :param obj_on_fs:
        :param desired_type:
        :param logger:
        :return:
        """"""
        pass"
1225,"def _parse_singlefile(self, desired_type: Type[T], file_path: str, encoding: str, logger: Logger,
                          options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        Implementation of the parent method : since this is a multifile parser, this is not implemented.

        :param desired_type:
        :param file_path:
        :param encoding:
        :param logger:
        :param options:
        :return:
        """"""
        raise Exception('Not implemented since this is a MultiFileParser')"
1226,"def create(parser_func: Union[ParsingMethodForStream, ParsingMethodForFile], caught: Exception):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param parser_func:
        :param caught:
        :return:
        """"""
        msg = 'Caught TypeError while calling parsing function \'' + str(parser_func.__name__) + '\'. ' \
              'Note that the parsing function signature should be ' + parsing_method_stream_example_signature_str \
              + ' (streaming=True) or ' + parsing_method_file_example_signature_str + ' (streaming=False).' \
              'Caught error message is : ' + caught.__class__.__name__ + ' : ' + str(caught)
        return CaughtTypeError(msg).with_traceback(caught.__traceback__)"
1227,"def _parse_singlefile(self, desired_type: Type[T], file_path: str, encoding: str, logger: Logger,
                          options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        Relies on the inner parsing function to parse the file.
        If _streaming_mode is True, the file will be opened and closed by this method. Otherwise the parsing function
        will be responsible to open and close.

        :param desired_type:
        :param file_path:
        :param encoding:
        :param options:
        :return:
        """"""
        opts = get_options_for_id(options, self.get_id_for_options())

        if self._streaming_mode:

            # We open the stream, and let the function parse from it
            file_stream = None
            try:
                # Open the file with the appropriate encoding
                file_stream = open(file_path, 'r', encoding=encoding)

                # Apply the parsing function
                if self.function_args is None:
                    return self._parser_func(desired_type, file_stream, logger, **opts)
                else:
                    return self._parser_func(desired_type, file_stream, logger, **self.function_args, **opts)

            except TypeError as e:
                raise CaughtTypeError.create(self._parser_func, e)

            finally:
                if file_stream is not None:
                    # Close the File in any case
                    file_stream.close()

        else:
            # the parsing function will open the file itself
            if self.function_args is None:
                return self._parser_func(desired_type, file_path, encoding, logger, **opts)
            else:
                return self._parser_func(desired_type, file_path, encoding, logger, **self.function_args, **opts)"
1228,"def queryByPortSensor(portiaConfig, edgeId, port, sensor, strategy=SummaryStrategies.PER_HOUR, interval=1, params={ 'from': None, 'to': None, 'order': None, 'precision': 'ms', 'fill':'none', 'min': True, 'max': True, 'sum': True, 'avg': True, 'median': False, 'mode': False, 'stddev': False, 'spread': False }):
    """"""Returns a pandas data frame with the portia select resultset""""""

    header = {'Accept': 'text/csv'}
    endpoint = '/summary/device/{0}/port/{1}/sensor/{2}/{3}/{4}{5}'.format( edgeId, port, sensor, resolveStrategy(strategy), interval, utils.buildGetParams(params) )
    response = utils.httpGetRequest(portiaConfig, endpoint, header)

    if response.status_code == 200:
        try:

            dimensionSeries = pandas.read_csv( StringIO(response.text), sep=';' )
            if portiaConfig['debug']:
                print( '[portia-debug]: {0} rows'.format( len(dimensionSeries.index) ) )

            return dimensionSeries

        except:
            raise Exception('couldn\'t create pandas data frame')
    else:
        raise Exception('couldn\'t retrieve data')"
1229,"def _process_counter_example(self, mma, w_string):
        """"""""
        Process a counterexample in the Rivest-Schapire way.
        Args:
            mma (DFA): The hypothesis automaton
            w_string (str): The examined string to be consumed
        Returns:
            None
        """"""
        diff = len(w_string)
        same = 0
        membership_answer = self._membership_query(w_string)
        while True:
            i = (same + diff) / 2
            access_string = self._run_in_hypothesis(mma, w_string, i)
            if membership_answer != self._membership_query(access_string + w_string[i:]):
                diff = i
            else:
                same = i
            if diff - same == 1:
                break
        exp = w_string[diff:]
        self.observation_table.em_vector.append(exp)
        for row in self.observation_table.sm_vector + self.observation_table.smi_vector:
            self._fill_table_entry(row, exp)
        return 0"
1230,"def get_dfa_conjecture(self):
        """"""
        Utilize the observation table to construct a Mealy Machine.
        The library used for representing the Mealy Machine is the python
        bindings of the openFST library (pyFST).
        Args:
            None
        Returns:
            MealyMachine: A mealy machine build based on a closed and consistent
        observation table.
        """"""
        dfa = DFA(self.alphabet)
        for s in self.observation_table.sm_vector:
            for i in self.alphabet:
                dst = self.observation_table.equiv_classes[s + i]
                # If dst == None then the table is not closed.
                if dst == None:
                    logging.debug('Conjecture attempt on non closed table.')
                    return None
                obsrv = self.observation_table[s, i]
                src_id = self.observation_table.sm_vector.index(s)
                dst_id = self.observation_table.sm_vector.index(dst)
                dfa.add_arc(src_id, dst_id, i, obsrv)

        # Mark the final states in the hypothesis automaton.
        i = 0
        for s in self.observation_table.sm_vector:
            dfa[i].final = self.observation_table[s, self.epsilon]
            i += 1
        return dfa"
1231,"def _init_table(self):
        """"""
        Initialize the observation table.
        """"""
        self.observation_table.sm_vector.append(self.epsilon)
        self.observation_table.smi_vector = list(self.alphabet)
        self.observation_table.em_vector.append(self.epsilon)

        self._fill_table_entry(self.epsilon, self.epsilon)
        for s in self.observation_table.smi_vector:
            self._fill_table_entry(s, self.epsilon)"
1232,"def learn_dfa(self, mma=None):
        """"""
        Implements the high level loop of the algorithm for learning a
        Mealy machine.
        Args:
            mma (DFA): The input automaton
        Returns:
            MealyMachine: A string and a model for the Mealy machine to be learned.
        """"""
        logging.info('Initializing learning procedure.')
        if mma:
            self._init_table_from_dfa(mma)
        else:
            self._init_table()

        logging.info('Generating a closed and consistent observation table.')
        while True:

            closed = False
            # Make sure that the table is closed
            while not closed:
                logging.debug('Checking if table is closed.')
                closed, string = self.observation_table.is_closed()
                if not closed:
                    logging.debug('Closing table.')
                    self._ot_make_closed(string)
                else:
                    logging.debug('Table closed.')

            # Create conjecture

            dfa = self.get_dfa_conjecture()

            logging.info('Generated conjecture machine with %d states.',len(list(dfa.states)))

            # _check correctness
            logging.debug('Running equivalence query.')
            found, counter_example = self._equivalence_query(dfa)

            # Are we done?
            if found:
                logging.info('No counterexample found. Hypothesis is correct!')
                break

            # Add the new experiments into the table to reiterate the
            # learning loop
            logging.info('Processing counterexample %s with length %d.', counter_example, len(counter_example))
            self._process_counter_example(dfa, counter_example)

        logging.info('Learning complete.')
        logging.info('Learned em_vector table is the following:')
        logging.info(self.observation_table.em_vector)
        return '', dfa"
1233,"def print_error_to_io_stream(err: Exception, io: TextIOBase, print_big_traceback : bool = True):
    """"""
    Utility method to print an exception's content to a stream

    :param err:
    :param io:
    :param print_big_traceback:
    :return:
    """"""
    if print_big_traceback:
        traceback.print_tb(err.__traceback__, file=io, limit=-GLOBAL_CONFIG.multiple_errors_tb_limit)
    else:
        traceback.print_tb(err.__traceback__, file=io, limit=-1)
    io.writelines('  ' + str(err.__class__.__name__) + ' : ' + str(err))"
1234,"def should_hide_traceback(e):
    """""" Returns True if we can hide the error traceback in the warnings messages """"""
    if type(e) in {WrongTypeCreatedError, CascadeError, TypeInformationRequiredError}:
        return True
    elif type(e).__name__ in {'InvalidAttributeNameForConstructorError', 'MissingMandatoryAttributeFiles'}:
        return True
    else:
        return False"
1235,"def _get_parsing_plan_for_multifile_children(self, obj_on_fs: PersistedObject, desired_type: Type[Any],
                                                 logger: Logger) -> Dict[str, Any]:
        """"""
        Implementation of AnyParser API
        """"""
        raise Exception('This should never happen, since this parser relies on underlying parsers')"
1236,"def _parse_multifile(self, desired_type: Type[T], obj: PersistedObject,
                         parsing_plan_for_children: Dict[str, AnyParser._RecursiveParsingPlan],
                         logger: Logger, options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        Implementation of AnyParser API
        """"""
        raise Exception('This should never happen, since this parser relies on underlying parsers')"
1237,"def add_parser_to_cascade(self, parser: AnyParser, typ: Type = None):
        """"""
        Adds the provided parser to this cascade. If this is the first parser, it will configure the cascade according
        to the parser capabilities (single and multifile support, extensions).
        Subsequent parsers will have to support the same capabilities at least, to be added.

        :param parser:
        :param typ:
        :return:
        """"""
        # the first parser added will configure the cascade
        if not self.configured:
            self.supported_exts = parser.supported_exts
            self.supported_types = parser.supported_types

        # check if new parser is compliant with previous ones
        if self.supports_singlefile():
            if not parser.supports_singlefile():
                raise ValueError(
                    'Cannot add this parser to this parsing cascade : it does not match the rest of the cascades '
                    'configuration (singlefile support)')

        if self.supports_multifile():
            if not parser.supports_multifile():
                raise ValueError(
                    'Cannot add this parser to this parsing cascade : it does not match the rest of the cascades '
                    'configuration (multifile support)')

        if AnyObject not in parser.supported_types:
            if typ is None:
                # in that case the expected types for this parser will be self.supported_types
                if AnyObject in self.supported_types:
                    raise ValueError(
                        'Cannot add this parser to this parsing cascade : it does not match the rest of the cascades '
                        'configuration (the cascade supports any type while the parser only supports '
                        + str(parser.supported_types) + ')')
                else:
                    missing_types = set(self.supported_types) - set(parser.supported_types)
                    if len(missing_types) > 0:
                        raise ValueError(
                            'Cannot add this parser to this parsing cascade : it does not match the rest of the '
                            'cascades configuration (supported types should at least contain the supported types '
                            'already in place. The parser misses type(s) ' + str(missing_types) + ')')
            else:
                # a parser is added but with a specific type target (parallel cascade)
                if typ == AnyObject:
                    raise ValueError(
                        'Cannot add this parser to this parsing cascade : it does not match the expected type ""Any"", '
                        'it only supports ' + str(parser.supported_types))
                # else:
                #     if get_base_generic_type(typ) not in parser.supported_types:
                #         raise ValueError(
                #             'Cannot add this parser to this parsing cascade : it does not match the expected type ' +
                #             str(typ) + ', it only supports ' + str(parser.supported_types))

        missing_exts = set(self.supported_exts) - set(parser.supported_exts)
        if len(missing_exts) > 0:
            raise ValueError(
                'Cannot add this parser to this parsing cascade : it does not match the rest of the cascades '
                'configuration (supported extensions should at least contain the supported extensions already in '
                'place. The parser misses extension(s) ' + str(missing_exts) + ')')

        # finally add it
        self._parsers_list.append((typ, parser))"
1238,"def _create_parsing_plan(self, desired_type: Type[T], filesystem_object: PersistedObject, logger: Logger,
                             log_only_last: bool = False) -> ParsingPlan[T]:
        """"""
        Creates a parsing plan to parse the given filesystem object into the given desired_type.
        This overrides the method in AnyParser, in order to provide a 'cascading' parsing plan

        :param desired_type:
        :param filesystem_object:
        :param logger:
        :param log_only_last: a flag to only log the last part of the file path (default False)
        :return:
        """"""
        # build the parsing plan
        logger.debug('(B) ' + get_parsing_plan_log_str(filesystem_object, desired_type,
                                                       log_only_last=log_only_last, parser=self))
        return CascadingParser.CascadingParsingPlan(desired_type, filesystem_object, self, self._parsers_list,
                                                    logger=logger)"
1239,"def _parse_singlefile(self, desired_type: Type[T], file_path: str, encoding: str, logger: Logger,
                          options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        Implementation of AnyParser API
        """"""
        # first use the base parser to parse something compliant with the conversion chain
        first = self._base_parser._parse_singlefile(self._converter.from_type, file_path, encoding,
                                                    logger, options)

        # then apply the conversion chain
        return self._converter.convert(desired_type, first, logger, options)"
1240,"def _get_parsing_plan_for_multifile_children(self, obj_on_fs: PersistedObject, desired_type: Type[Any],
                                                 logger: Logger) -> Dict[str, Any]:
        """"""
        Implementation of AnyParser API
        """"""
        return self._base_parser._get_parsing_plan_for_multifile_children(obj_on_fs, self._converter.from_type, logger)"
1241,"def _parse_multifile(self, desired_type: Type[T], obj: PersistedObject,
                         parsing_plan_for_children: Dict[str, ParsingPlan],
                         logger: Logger, options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        Implementation of AnyParser API
        """"""
        # first use the base parser
        # first = self._base_parser._parse_multifile(desired_type, obj, parsing_plan_for_children, logger, options)
        first = self._base_parser._parse_multifile(self._converter.from_type, obj, parsing_plan_for_children, logger,
                                                   options)

        # then apply the conversion chain
        return self._converter.convert(desired_type, first, logger, options)"
1242,"def are_worth_chaining(base_parser: Parser, to_type: Type[S], converter: Converter[S,T]) -> bool:
        """"""
        Utility method to check if it makes sense to chain this parser configured with the given to_type, with this
        converter.  It is an extension of ConverterChain.are_worth_chaining

        :param base_parser:
        :param to_type:
        :param converter:
        :return:
        """"""
        if isinstance(converter, ConversionChain):
            for conv in converter._converters_list:
                if not Parser.are_worth_chaining(base_parser, to_type, conv):
                    return False
            # all good
            return True
        else:
            return Parser.are_worth_chaining(base_parser, to_type, converter)"
1243,"def set_mode(self, mode):
        """"""Set Lupusec alarm mode.""""""
        _LOGGER.debug('State change called from alarm device')
        if not mode:
            _LOGGER.info('No mode supplied')
        elif mode not in CONST.ALL_MODES:
            _LOGGER.warning('Invalid mode')
        response_object = self._lupusec.set_mode(CONST.MODE_TRANSLATION[mode])
        if response_object['result'] != 1:
            _LOGGER.warning('Mode setting unsuccessful')

        self._json_state['mode'] = mode
        _LOGGER.info('Mode set to: %s', mode)
        return True"
1244,"def parse_amendements_summary(url, json_response):
    """"""
    json schema :
    {
      infoGenerales: {
        nb_resultats, debut, nb_docs
      },
      data_table: 'id|numInit|titreDossierLegislatif|urlDossierLegislatif|'
                  'instance|numAmend|urlAmend|designationArticle|'
                  'designationAlinea|dateDepot|signataires|sort'
    }

    NB : the json response does not contain the dispositif and expose, that's
    why we call it ""amendement's summary""
    """"""

    amendements = []
    fields = [convert_camelcase_to_underscore(field) for field in
              json_response['infoGenerales']['description_schema'].split('|')]

    for row in json_response['data_table']:
        values = row.split('|')
        amd = AmendementSummary(**dict(zip(fields, values)))
        amd.legislature = re.search(r'www.assemblee-nationale.fr/(\d+)/',
                                    amd.url_amend).groups()[0]
        amendements.append(amd)

    return AmendementSearchResult(**{
        'url': url,
        'total_count': json_response['infoGenerales']['nb_resultats'],
        'start': json_response['infoGenerales']['debut'],
        'size': json_response['infoGenerales']['nb_docs'],
        'results': amendements
    })"
1245,"def get(self, **kwargs):
        """"""
        :param texteRecherche:
        :param numAmend:
        :param idArticle:
        :param idAuteur:
        :param idDossierLegislatif:
        :param idExamen:
        :param idExamens:
        :param periodeParlementaire:
        :param dateDebut:
        :param dateFin:
        :param rows:
        :param start:
        :param sort:
        """"""
        params = self.default_params.copy()
        params.update(kwargs)

        start = time.time()
        response = requests.get(self.base_url, params=params)
        end = time.time()

        LOGGER.debug(
            'fetched amendements with search params: %s in %0.2f s',
            params,
            end - start
        )

        return parse_amendements_summary(response.url, response.json())"
1246,"def to_utf8(value):
  """"""Returns a string encoded using UTF-8.

  This function comes from `Tornado`_.

  :param value:
    A unicode or string to be encoded.
  :returns:
    The encoded string.
  """"""
  if isinstance(value, unicode):
    return value.encode('utf-8')

  assert isinstance(value, str)
  return value"
1247,"def to_unicode(value):
  """"""Returns a unicode string from a string, using UTF-8 to decode if needed.

  This function comes from `Tornado`_.

  :param value:
    A unicode or string to be decoded.
  :returns:
    The decoded string.
  """"""
  if isinstance(value, str):
    return value.decode('utf-8')

  assert isinstance(value, unicode)
  return value"
1248,"def find_all_commands(management_dir):
    """"""
    Find all valid commands in a directory
    management_dir : directory path
    return - List of commands
    """"""
    try:
        #Find all commands in the directory that are not __init__.py and end in .py.  Then, remove the trailing .py
        return [f[:-3] for f in os.listdir(management_dir) if f.endswith('.py') and not f.startswith(""__"")]
    except OSError:
        #If nothing is found, return empty
        return []"
1249,"def find_commands_module(app_name):
    """"""
    Find the commands module in each app (if it exists) and return the path
    app_name : The name of an app in the INSTALLED_APPS setting
    return - path to the app
    """"""
    parts = app_name.split('.')
    parts.append('commands')
    parts.reverse()
    part = parts.pop()
    path = None

    #Load the module if needed
    try:
        f, path, descr = imp.find_module(part, path)
    except ImportError as e:
        if os.path.basename(os.getcwd()) != part:
            raise e
        else:
            try:
                if f:
                    f.close()
            except UnboundLocalError:
                log.error(""Could not import module {0} at path {1}.  Sys.path is {2}"".format(part, path, sys.path))

    #Go down level by and level and try to load the module at each level
    while parts:
        part = parts.pop()
        f, path, descr = imp.find_module(part, [path] if path else None)
        if f:
            f.close()
    return path"
1250,"def get_commands():
    """"""
    Get all valid commands
    return - all valid commands in dictionary form
    """"""
    commands = {}

    #Try to load the settings file (settings can be specified on the command line) and get the INSTALLED_APPS
    try:
        from percept.conf.base import settings
        apps = settings.INSTALLED_APPS
    except KeyError:
        apps = []

    #For each app, try to find the command module (command folder in the app)
    #Then, try to load all commands in the directory
    for app_name in apps:
        try:
            path = find_commands_module(app_name)
            commands.update(dict([(name, app_name) for name in find_all_commands(path)]))
        except ImportError as e:
            pass

    return commands"
1251,"def execute(self):
        """"""
        Run the command with the command line arguments
        """"""
        #Initialize the option parser
        parser = LaxOptionParser(
            usage=""%prog subcommand [options] [args]"",
            option_list=BaseCommand.option_list #This will define what is allowed input to the parser (ie --settings=)
        )

        #Parse the options
        options, args = parser.parse_args(self.argv)
        #Handle --settings and --pythonpath properly
        options = handle_default_options(options)

        try:
            #Get the name of the subcommand
            subcommand = self.argv[1]
        except IndexError:
            #If the subcommand name cannot be found, set it to help
            subcommand = 'help'

        #If the subcommand is help, print the usage of the parser, and available command names
        if subcommand == 'help':
            if len(args) <= 2:
                parser.print_help()
                sys.stdout.write(self.help_text + '\n')
        else:
            #Otherwise, run the given command
            self.fetch_command(subcommand).run_from_argv(self.argv)"
1252,"def help_text(self):
        """"""
        Formats and prints the help text from the command list
        """"""
        help_text = '\n'.join(sorted(get_commands().keys()))
        help_text = ""\nCommands:\n"" + help_text
        return help_text"
1253,"def missing(self, field, last=True):
        '''
        Numeric fields support specific handling for missing fields in a doc.
        The missing value can be _last, _first, or a custom value
        (that will be used for missing docs as the sort value).

        missing('price')
        > {""price"" : {""missing"": ""_last"" } }
        missing('price',False)
        > {""price"" : {""missing"": ""_first""} }
        '''
        if last:
            self.append({field: {'missing': '_last'}})
        else:
            self.append({field: {'missing': '_first'}})

        return self"
1254,"def ensure_table(self, cls):
        """"""Ensure table's existence - as per the gludb spec.""""""
        cur = self._conn().cursor()

        table_name = cls.get_table_name()
        index_names = cls.index_names() or []

        cols = ['id text primary key', 'value text']
        for name in index_names:
            cols.append(name + ' text')

        cur.execute('create table if not exists %s (%s)' % (
            table_name,
            ','.join(cols)
        ))

        for name in index_names:
            cur.execute('create index if not exists %s on %s(%s)' % (
                table_name + '_' + name + '_idx',
                table_name,
                name
            ))

        self._conn().commit()
        cur.close()"
1255,"def find_by_index(self, cls, index_name, value):
        """"""Find all rows matching index query - as per the gludb spec.""""""
        cur = self._conn().cursor()

        query = 'select id,value from %s where %s = ?' % (
            cls.get_table_name(),
            index_name
        )

        found = []
        for row in cur.execute(query, (value,)):
            id, data = row[0], row[1]
            obj = cls.from_data(data)
            assert id == obj.id
            found.append(obj)

        cur.close()

        return found"
1256,"def delete(self, obj):
        """"""Required functionality.""""""
        del_id = obj.get_id()
        if not del_id:
            return

        cur = self._conn().cursor()

        tabname = obj.__class__.get_table_name()
        query = 'delete from %s where id = ?' % tabname
        cur.execute(query, (del_id,))

        self._conn().commit()
        cur.close()"
1257,"def register(self):
        """""" Registers a new device with the name entity_id. This device has permissions for services like subscribe,
        publish and access historical data.

        """"""
        register_url = self.base_url + ""api/0.1.0/register""
        register_headers = {
            ""apikey"": str(self.owner_api_key),
            ""resourceID"": str(self.entity_id),
            ""serviceType"": ""publish,subscribe,historicData""
        }
        with self.no_ssl_verification():
            r = requests.get(register_url, {}, headers=register_headers)
        response = r.content.decode(""utf-8"")
        if ""APIKey"" in str(r.content.decode(""utf-8"")):
            response = json.loads(response[:-331] + ""}"")  # Temporary fix to a middleware bug, should be removed in future
            response[""Registration""] = ""success""
        else:
            response = json.loads(response)
            response[""Registration""] = ""failure""
        return response"
1258,"def no_ssl_verification(self):
        """""" Requests module fails due to lets encrypt ssl encryption. Will be fixed in the future release.""""""
        try:
            from functools import partialmethod
        except ImportError:
            # Python 2 fallback: https://gist.github.com/carymrobbins/8940382
            from functools import partial

            class partialmethod(partial):
                def __get__(self, instance, owner):
                    if instance is None:
                        return self

                    return partial(self.func, instance, *(self.args or ()), **(self.keywords or {}))

        old_request = requests.Session.request
        requests.Session.request = partialmethod(old_request, verify=False)
        warnings.filterwarnings('ignore', 'Unverified HTTPS request')
        yield
        warnings.resetwarnings()
        requests.Session.request = old_request"
1259,"def publish(self, data):
        """""" This function allows an entity to publish data to the middleware.

        Args:
            data    (string): contents to be published by this entity.
        """"""
        if self.entity_api_key == """":
            return {'status': 'failure', 'response': 'No API key found in request'}
        publish_url = self.base_url + ""api/0.1.0/publish""
        publish_headers = {""apikey"": self.entity_api_key}
        publish_data = {
            ""exchange"": ""amq.topic"",
            ""key"": str(self.entity_id),
            ""body"": str(data)
        }
        with self.no_ssl_verification():
            r = requests.post(publish_url, json.dumps(publish_data), headers=publish_headers)
        response = dict()
        if ""No API key"" in str(r.content.decode(""utf-8"")):
            response[""status""] = ""failure""
            r = json.loads(r.content.decode(""utf-8""))['message']
        elif 'publish message ok' in str(r.content.decode(""utf-8"")):
            response[""status""] = ""success""
            r = r.content.decode(""utf-8"")
        else:
            response[""status""] = ""failure""
            r = r.content.decode(""utf-8"")
        response[""response""] = str(r)
        return response"
1260,"def db(self, entity, query_filters=""size=10""):
        """""" This function allows an entity to access the historic data.

        Args:
            entity        (string): Name of the device to listen to
            query_filters (string): Elastic search response format string
                                    example, ""pretty=true&size=10""
        """"""
        if self.entity_api_key == """":
            return {'status': 'failure', 'response': 'No API key found in request'}

        historic_url = self.base_url + ""api/0.1.0/historicData?"" + query_filters
        historic_headers = {
            ""apikey"": self.entity_api_key,
            ""Content-Type"": ""application/json""
        }

        historic_query_data = json.dumps({
            ""query"": {
                ""match"": {
                    ""key"": entity
                }
            }
        })

        with self.no_ssl_verification():
            r = requests.get(historic_url, data=historic_query_data, headers=historic_headers)
        response = dict()
        if ""No API key"" in str(r.content.decode(""utf-8"")):
            response[""status""] = ""failure""
        else:
            r = r.content.decode(""utf-8"")
            response = r
        return response"
1261,"def bind(self, devices_to_bind):
        """""" This function allows an entity to list the devices to subscribe for data. This function must be called
        at least once, before doing a subscribe. Subscribe function will listen to devices that are bound here.

        Args:
            devices_to_bind  (list): an array of devices to listen to.
                                     Example bind([""test100"",""testDemo""])

        """"""
        if self.entity_api_key == """":
            return {'status': 'failure', 'response': 'No API key found in request'}
        url = self.base_url + ""api/0.1.0/subscribe/bind""
        headers = {""apikey"": self.entity_api_key}
        data = {
            ""exchange"": ""amq.topic"",
            ""keys"": devices_to_bind,
            ""queue"": self.entity_id
        }

        with self.no_ssl_verification():
            r = requests.post(url, json=data, headers=headers)
        response = dict()
        if ""No API key"" in str(r.content.decode(""utf-8"")):
            response[""status""] = ""failure""
            r = json.loads(r.content.decode(""utf-8""))['message']
        elif 'bind queue ok' in str(r.content.decode(""utf-8"")):
            response[""status""] = ""success""
            r = r.content.decode(""utf-8"")
        else:
            response[""status""] = ""failure""
            r = r.content.decode(""utf-8"")
        response[""response""] = str(r)
        return response"
1262,"def unbind(self, devices_to_unbind):
        """""" This function allows an entity to unbound devices that are already bound.

        Args:
            devices_to_unbind (list): an array of devices that are to be unbound ( stop listening)
                                     Example unbind([""test10"",""testDemo105""])
        """"""
        if self.entity_api_key == """":
            return {'status': 'failure', 'response': 'No API key found in request'}
        url = self.base_url + ""api/0.1.0/subscribe/unbind""
        headers = {""apikey"": self.entity_api_key}
        data = {
            ""exchange"": ""amq.topic"",
            ""keys"": devices_to_unbind,
            ""queue"": self.entity_id
        }

        with self.no_ssl_verification():
            r = requests.delete(url, json=data, headers=headers)
            print(r)
        response = dict()
        if ""No API key"" in str(r.content.decode(""utf-8"")):
            response[""status""] = ""failure""
            r = json.loads(r.content.decode(""utf-8""))['message']
        elif 'unbind' in str(r.content.decode(""utf-8"")):
            response[""status""] = ""success""
            r = r.content.decode(""utf-8"")
        else:
            response[""status""] = ""failure""
            r = r.content.decode(""utf-8"")
        response[""response""] = str(r)
        return response"
1263,"def subscribe(self, devices_to_bind=[]):
        """""" This function allows an entity to subscribe for data from the devices specified in the bind operation. It
        creates a thread with an event loop to manager the tasks created in start_subscribe_worker.

        Args:
            devices_to_bind (list): an array of devices to listen to
        """"""
        if self.entity_api_key == """":
            return {'status': 'failure', 'response': 'No API key found in request'}
        self.bind(devices_to_bind)
        loop = asyncio.new_event_loop()
        t1 = threading.Thread(target=self.start_subscribe_worker, args=(loop,))
        t1.daemon = True
        t1.start()"
1264,"def start_subscribe_worker(self, loop):
        """""" Switch to new event loop as a thread and run until complete. """"""
        url = self.base_url + ""api/0.1.0/subscribe""
        task = loop.create_task(self.asynchronously_get_data(url + ""?name={0}"".format(self.entity_id)))
        asyncio.set_event_loop(loop)
        loop.run_until_complete(task)
        self.event_loop = loop"
1265,"async def asynchronously_get_data(self, url):
        """""" Asynchronously get data from Chunked transfer encoding of https://smartcity.rbccps.org/api/0.1.0/subscribe.
        (Only this function requires Python 3. Rest of the functions can be run in python2.

        Args:
             url (string): url to subscribe
        """"""
        headers = {""apikey"": self.entity_api_key}
        try:
            async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(verify_ssl=False)) as session:
                async with session.get(url, headers=headers, timeout=3000) as response:
                    while True:  # loop over for each chunk of data
                        chunk = await response.content.readchunk()
                        if not chunk:
                            break
                        if platform == ""linux"" or platform == ""linux2"": # In linux systems, readchunk() returns a tuple
                            chunk = chunk[0]
                        resp = dict()
                        resp[""data""] = chunk.decode()
                        current_milli_time = lambda: int(round(time() * 1000))
                        resp[""timestamp""] = str(current_milli_time())
                        self.subscribe_data = resp
        except Exception as e:
            print(""\n*********    Oops: "" + url + "" "" + str(type(e)) + str(e) + ""     *********\n"")
        print('\n*********    Closing TCP: {}     *********\n'.format(url))"
1266,"def stop_subscribe(self):
        """""" This function is used to stop the event loop created when subscribe is called. But this function doesn't
        stop the thread and should be avoided until its completely developed.

        """"""
        asyncio.gather(*asyncio.Task.all_tasks()).cancel()
        self.event_loop.stop()
        self.event_loop.close()"
1267,"def timesince(d, now=None):
    """"""
    Takes two datetime objects and returns the time between d and now
    as a nicely formatted string, e.g. ""10 minutes"".  If d occurs after now,
    then ""0 minutes"" is returned.

    Units used are years, months, weeks, days, hours, and minutes.
    Seconds and microseconds are ignored.  Up to two adjacent units will be
    displayed.  For example, ""2 weeks, 3 days"" and ""1 year, 3 months"" are
    possible outputs, but ""2 weeks, 3 hours"" and ""1 year, 5 days"" are not.

    Adapted from http://blog.natbat.co.uk/archive/2003/Jun/14/time_since
    """"""
    chunks = (
      (60 * 60 * 24 * 365, lambda n: ungettext('year', 'years', n)),
      (60 * 60 * 24 * 30, lambda n: ungettext('month', 'months', n)),
      (60 * 60 * 24 * 7, lambda n : ungettext('week', 'weeks', n)),
      (60 * 60 * 24, lambda n : ungettext('day', 'days', n)),
      (60 * 60, lambda n: ungettext('hour', 'hours', n)),
      (60, lambda n: ungettext('minute', 'minutes', n))
    )
    # Convert datetime.date to datetime.datetime for comparison.
    if not isinstance(d, datetime.datetime):
        d = datetime.datetime(d.year, d.month, d.day)
    if now and not isinstance(now, datetime.datetime):
        now = datetime.datetime(now.year, now.month, now.day)

    if not now:
        if d.tzinfo:
            now = datetime.datetime.now(LocalTimezone(d))
        else:
            now = datetime.datetime.now()

    # ignore microsecond part of 'd' since we removed it from 'now'
    delta = now - (d - datetime.timedelta(0, 0, d.microsecond))
    since = delta.days * 24 * 60 * 60 + delta.seconds
    if since <= 0:
        # d is in the future compared to now, stop processing.
        return u'0 ' + ugettext('minutes')
    for i, (seconds, name) in enumerate(chunks):
        count = since // seconds
        if count != 0:
            break
    s = ugettext('%(number)d %(type)s') % {'number': count, 'type': name(count)}
    if i + 1 < len(chunks):
        # Now get the second item
        seconds2, name2 = chunks[i + 1]
        count2 = (since - (seconds * count)) // seconds2
        if count2 != 0:
            s += ugettext(', %(number)d %(type)s') % {'number': count2, 'type': name2(count2)}
    return s"
1268,"def timeuntil(d, now=None):
    """"""
    Like timesince, but returns a string measuring the time until
    the given time.
    """"""
    if not now:
        if getattr(d, 'tzinfo', None):
            now = datetime.datetime.now(LocalTimezone(d))
        else:
            now = datetime.datetime.now()
    return timesince(now, d)"
1269,"def updateCache(self, service, url, new_data, new_data_dt):
        """"""
        :param new_data: a string representation of the data
        :param new_data_dt: a timezone aware datetime object giving
                the timestamp of the new_data
        :raise MemcachedException: if update failed
        """"""
        key = self._get_key(service, url)

        # clear existing data
        try:
            value = self.client.get(key)
            if value:
                data = pickle.loads(value, encoding=""utf8"")
                if ""time_stamp"" in data:
                    cached_data_dt = parse(data[""time_stamp""])
                    if new_data_dt > cached_data_dt:
                        self.client.delete(key)
                        # may raise MemcachedException
                        logger.info(
                            ""IN cache (key: {}), older DELETE"".format(key))
                    else:
                        logger.info(
                            ""IN cache (key: {}), newer KEEP"".format(key))
                        return
            else:
                logger.info(""NOT IN cache (key: {})"".format(key))

        except MemcachedException as ex:
            logger.error(
                ""Clear existing data (key: {}) ==> {}"".format(key, str(ex)))
            return

        # store new value in cache
        cdata, time_to_store = self._make_cache_data(
            service, url, new_data, {}, 200, new_data_dt)

        self.client.set(key, cdata, time=time_to_store)
        # may raise MemcachedException
        logger.info(
            ""MemCached SET (key {}) for {:d} seconds"".format(
                key, time_to_store))"
1270,"def delete_all_eggs(self):
        """""" delete all the eggs in the directory specified """"""
        path_to_delete = os.path.join(self.egg_directory, ""lib"", ""python"")
        if os.path.exists(path_to_delete):
            shutil.rmtree(path_to_delete)"
1271,"def install_egg(self, egg_name):
        """""" Install an egg into the egg directory """"""
        if not os.path.exists(self.egg_directory):
            os.makedirs(self.egg_directory)
        self.requirement_set.add_requirement(
            InstallRequirement.from_line(egg_name, None))
        try:
            self.requirement_set.prepare_files(self.finder)
            self.requirement_set.install(['--prefix=' + self.egg_directory], [])
        except DistributionNotFound:
            self.requirement_set.requirements._keys.remove(egg_name)
            raise PipException()"
1272,"def call(cls, iterable, *a, **kw):
    """"""
    Calls every item in *iterable* with the specified arguments.
    """"""

    return cls(x(*a, **kw) for x in iterable)"
1273,"def map(cls, iterable, func, *a, **kw):
    """"""
    Iterable-first replacement of Python's built-in `map()` function.
    """"""

    return cls(func(x, *a, **kw) for x in iterable)"
1274,"def filter(cls, iterable, cond, *a, **kw):
    """"""
    Iterable-first replacement of Python's built-in `filter()` function.
    """"""

    return cls(x for x in iterable if cond(x, *a, **kw))"
1275,"def unique(cls, iterable, key=None):
    """"""
    Yields unique items from *iterable* whilst preserving the original order.
    """"""

    if key is None:
      key = lambda x: x
    def generator():
      seen = set()
      seen_add = seen.add
      for item in iterable:
        key_val = key(item)
        if key_val not in seen:
          seen_add(key_val)
          yield item
    return cls(generator())"
1276,"def chunks(cls, iterable, n, fill=None):
    """"""
    Collects elements in fixed-length chunks.
    """"""

    return cls(itertools.zip_longest(*[iter(iterable)] * n, fillvalue=fill))"
1277,"def concat(cls, iterables):
    """"""
    Similar to #itertools.chain.from_iterable().
    """"""

    def generator():
      for it in iterables:
        for element in it:
          yield element
    return cls(generator())"
1278,"def chain(cls, *iterables):
    """"""
    Similar to #itertools.chain.from_iterable().
    """"""

    def generator():
      for it in iterables:
        for element in it:
          yield element
    return cls(generator())"
1279,"def attr(cls, iterable, attr_name):
    """"""
    Applies #getattr() on all elements of *iterable*.
    """"""

    return cls(getattr(x, attr_name) for x in iterable)"
1280,"def of_type(cls, iterable, types):
    """"""
    Filters using #isinstance().
    """"""

    return cls(x for x in iterable if isinstance(x, types))"
1281,"def partition(cls, iterable, pred):
    """"""
    Use a predicate to partition items into false and true entries.
    """"""

    t1, t2 = itertools.tee(iterable)
    return cls(itertools.filterfalse(pred, t1), filter(pred, t2))"
1282,"def count(cls, iterable):
    """"""
    Returns the number of items in an iterable.
    """"""

    iterable = iter(iterable)
    count = 0
    while True:
      try:
        next(iterable)
      except StopIteration:
        break
      count += 1
    return count"
1283,"def column_names(self, table):
      """"""An iterable of column names, for a particular table or
      view.""""""

      table_info = self.execute(
        u'PRAGMA table_info(%s)' % quote(table))
      return (column['name'] for column in table_info)"
1284,"def execute(self, sql, *args, **kwargs):
    '''
    Run raw SQL on the database, and receive relaxing output.
    This is sort of the foundational method that most of the
    others build on.
    '''
    try:
      self.cursor.execute(sql, *args)
    except self.sqlite3.InterfaceError, msg:
      raise self.sqlite3.InterfaceError(unicode(msg) + '\nTry converting types or pickling.')
    rows = self.cursor.fetchall()

    self.__commit_if_necessary(kwargs)

    if None == self.cursor.description:
      return None
    else:
      colnames = [d[0].decode('utf-8') for d in self.cursor.description]
      rawdata = [OrderedDict(zip(colnames,row)) for row in rows]
      return rawdata"
1285,"def create_index(self, columns, table_name, if_not_exists = True, unique = False, **kwargs):
    'Create a unique index on the column(s) passed.'
    index_name = simplify(table_name) + u'_' + u'_'.join(map(simplify, columns))
    if unique:
      sql = u'CREATE UNIQUE INDEX %s ON %s (%s)'
    else:
      sql = u'CREATE INDEX %s ON %s (%s)'

    first_param = u'IF NOT EXISTS ' + index_name if if_not_exists else index_name

    params = (first_param, quote(table_name), ','.join(map(quote, columns)))
    self.execute(sql % params, **kwargs)"
1286,"def create_table(self, data, table_name, error_if_exists = False, **kwargs):
    'Create a table based on the data, but don\'t insert anything.'

    converted_data = convert(data)
    if len(converted_data) == 0 or converted_data[0] == []:
      raise ValueError(u'You passed no sample values, or all the values you passed were null.')
    else:
      startdata = OrderedDict(converted_data[0])

    # Select a non-null item
    for k, v in startdata.items():
      if v != None:
        break
    else:
      v = None

    if_not_exists = u'' if error_if_exists else u'IF NOT EXISTS'

    # Do nothing if all items are null.
    if v != None:
      try:
        # This is vulnerable to injection.
        sql = u'''
          CREATE TABLE %s %s (
            %s %s
          );''' % (if_not_exists, quote(table_name), quote(k), get_column_type(startdata[k]))
        self.execute(sql, commit = False)
      except:
        raise
      else:
        self.commit()

      for row in converted_data:
        self.__check_and_add_columns(table_name, row)"
1287,"def get_var(self, key):
    'Retrieve one saved variable from the database.'
    vt = quote(self.__vars_table)
    data = self.execute(u'SELECT * FROM %s WHERE `key` = ?' % vt, [key], commit = False)
    if data == []:
      raise NameError(u'The DumpTruck variables table doesn\'t have a value for %s.' % key)
    else:
      tmp = quote(self.__vars_table_tmp)
      row = data[0]

      self.execute(u'DROP TABLE IF EXISTS %s' % tmp, commit = False)

      # This is vulnerable to injection
      self.execute(u'CREATE TEMPORARY TABLE %s (`value` %s)' % (tmp, row['type']), commit = False)

      # This is ugly
      self.execute(u'INSERT INTO %s (`value`) VALUES (?)' % tmp, [row['value']], commit = False)
      value = self.dump(tmp)[0]['value']
      self.execute(u'DROP TABLE %s' % tmp, commit = False)

      return value"
1288,"def save_var(self, key, value, **kwargs):
    'Save one variable to the database.'

    # Check whether Highwall's variables table exists
    self.__check_or_create_vars_table()

    column_type = get_column_type(value)
    tmp = quote(self.__vars_table_tmp)

    self.execute(u'DROP TABLE IF EXISTS %s' % tmp, commit = False)

    # This is vulnerable to injection
    self.execute(u'CREATE TABLE %s (`value` %s)' % (tmp, column_type), commit = False)

    # This is ugly
    self.execute(u'INSERT INTO %s (`value`) VALUES (?)' % tmp, [value], commit = False)
    table = (quote(self.__vars_table), tmp)
    params = [key, column_type]
    self.execute(u'''
INSERT OR REPLACE INTO %s (`key`, `type`, `value`)
  SELECT
    ? AS key,
    ? AS type,
    value
  FROM %s
''' % table, params)
    self.execute(u'DROP TABLE %s' % tmp, commit = False)

    self.__commit_if_necessary(kwargs)"
1289,"def tablesAndViews(self):
      """"""Return a sequence of (name,type) pairs where type is
      either ""table"" or ""view"".""""""
      result = self.execute(
        u'SELECT name,type FROM sqlite_master WHERE type in (""table"", ""view"")',
        commit=False)
      return ((row['name'],row['type']) for row in result)"
1290,"def drop(self, table_name = 'dumptruck', if_exists = False, **kwargs):
    'Drop a table.'
    return self.execute(u'DROP TABLE %s %s;' % ('IF EXISTS' if if_exists else '', quote(table_name)), **kwargs)"
1291,"def __install_perforce(self, config):
        """""" install perforce binary """"""
        if not system.is_64_bit():
            self.logger.warn(""Perforce formula is only designed for 64 bit systems! Not install executables..."")
            return False
        version = config.get('version', 'r13.2')
        key = 'osx' if system.is_osx() else 'linux'
        perforce_packages = package_dict[version][key]
        d = self.directory.install_directory(self.feature_name)
        if not os.path.exists(d):
            os.makedirs(d)
        self.logger.info(""Downloading p4 executable..."")
        with open(os.path.join(d, ""p4""), 'wb+') as fh:
            fh.write(lib.cleaned_request('get', url_prefix + perforce_packages['p4']).content)
        self.directory.symlink_to_bin(""p4"", os.path.join(d, ""p4""))
        self.p4_command = os.path.join(d, ""p4"")
        self.logger.info(""Installing p4v..."")
        if system.is_osx():
            return self._install_p4v_osx(url_prefix + perforce_packages['p4v'])
        else:
            return self._install_p4v_linux(url_prefix + perforce_packages['p4v'])"
1292,"def _install_p4v_osx(self, url, overwrite=False):
        """""" Install perforce applications and binaries for mac """"""
        package_exists = False
        root_dir = os.path.expanduser(os.path.join(""~"", ""Applications""))
        package_exists = len([x for x in P4V_APPLICATIONS if os.path.exists(os.path.join(root_dir, x))])
        if not package_exists or overwrite:
            lib.extract_dmg(url, root_dir)
        else:
            self.logger.warn(""P4V exists already in %s! Not overwriting..."" % root_dir)
        return True"
1293,"def _install_p4v_linux(self, url):
        """""" Install perforce applications and binaries for linux """"""
        lib.extract_targz(url,
                          self.directory.install_directory(self.feature_name),
                          remove_common_prefix=True)
        bin_path = os.path.join(self.directory.install_directory(self.feature_name), 'bin')
        if os.path.exists(bin_path):
            for f in os.listdir(bin_path):
                self.directory.symlink_to_bin(f, os.path.join(bin_path, f))
        return True"
1294,"def __write_p4settings(self, config):
        """""" write perforce settings """"""
        self.logger.info(""Writing p4settings..."")
        root_dir = os.path.expanduser(config.get('root_path'))
        p4settings_path = os.path.join(root_dir, "".p4settings"")
        if os.path.exists(p4settings_path):
            if self.target.get('overwrite_p4settings', False):
                self.logger.info(""Overwriting existing p4settings..."")
                os.remove(p4settings_path)
            else:
                return
        with open(p4settings_path, ""w+"") as p4settings_file:
            p4settings_file.write(p4settings_template % config.to_dict())
            if config.get('write_password_p4settings', 'no'):
                p4settings_file.write(""\nP4PASSWD=%s"" % config['password'])"
1295,"def __configure_client(self, config):
        """""" write the perforce client """"""
        self.logger.info(""Configuring p4 client..."")
        client_dict = config.to_dict()
        client_dict['root_path'] = os.path.expanduser(config.get('root_path'))
        os.chdir(client_dict['root_path'])
        client_dict['hostname'] = system.NODE
        client_dict['p4view'] = config['p4view'] % self.environment.target.get_context_dict()
        client = re.sub('//depot', '    //depot', p4client_template % client_dict)
        self.logger.info(lib.call(""%s client -i"" % self.p4_command,
                                  stdin=client,
                                  env=self.p4environ,
                                  cwd=client_dict['root_path']))"
1296,"def __install_eggs(self, config):
        """""" Install eggs for a particular configuration """"""
        egg_carton = (self.directory.install_directory(self.feature_name),
                      'requirements.txt')
        eggs = self.__gather_eggs(config)

        self.logger.debug(""Installing eggs %s..."" % eggs)
        self.__load_carton(egg_carton, eggs)

        self.__prepare_eggs(egg_carton, config)"
1297,"def __add_paths(self, config):
        """""" add the proper resources into the environment """"""
        bin_path = os.path.join(self.directory.install_directory(self.feature_name), 'bin')
        whitelist_executables = self._get_whitelisted_executables(config)
        for f in os.listdir(bin_path):
            for pattern in BLACKLISTED_EXECUTABLES:
                if re.match(pattern, f):
                    continue
            if whitelist_executables and f not in whitelist_executables:
                continue
            self.directory.symlink_to_bin(f, os.path.join(bin_path, f))"
1298,"def analyse_body_paragraph(body_paragraph, labels=None):
    """"""Analyse commit body paragraph and return (label, message).

    >>> analyse_body_paragraph('* BETTER Foo and bar.',
    >>> ... {'BETTER': 'Improvements'})
    ('BETTER', 'Foo and bar.')
    >>> analyse_body_paragraph('* Foo and bar.')
    (None, 'Foo and bar.')
    >>> analyse_body_paragraph('Foo and bar.')
    (None, None)
    """"""
    # try to find leading label first:
    for label, dummy in labels:
        if body_paragraph.startswith('* ' + label):
            return (label, body_paragraph[len(label) + 3:].replace('\n  ',
                                                                   ' '))
    # no conformed leading label found; do we have leading asterisk?
    if body_paragraph.startswith('* '):
        return (None, body_paragraph[2:].replace('\n  ', ' '))
    # no leading asterisk found; ignore this paragraph silently:
    return (None, None)"
1299,"def remove_ticket_directives(message):
    """"""Remove ticket directives like ""(closes #123).

    >>> remove_ticket_directives('(closes #123)')
    '(#123)'
    >>> remove_ticket_directives('(foo #123)')
    '(foo #123)'
    """"""
    if message:
        message = re.sub(r'closes #', '#', message)
        message = re.sub(r'addresses #', '#', message)
        message = re.sub(r'references #', '#', message)
    return message"
1300,"def amended_commits(commits):
    """"""Return those git commit sha1s that have been amended later.""""""
    # which SHA1 are declared as amended later?
    amended_sha1s = []
    for message in commits.values():
        amended_sha1s.extend(re.findall(r'AMENDS\s([0-f]+)', message))
    return amended_sha1s"
1301,"def enrich_git_log_dict(messages, labels):
    """"""Enrich git log with related information on tickets.""""""
    for commit_sha1, message in messages.items():
        # detect module and ticket numbers for each commit:
        component = None
        title = message.split('\n')[0]
        try:
            component, title = title.split("":"", 1)
            component = component.strip()
        except ValueError:
            pass  # noqa

        paragraphs = [analyse_body_paragraph(p, labels)
                      for p in message.split('\n\n')]
        yield {
            'sha1': commit_sha1,
            'component': component,
            'title': title.strip(),
            'tickets': re.findall(r'\s(#\d+)', message),
            'paragraphs': [
                (label, remove_ticket_directives(message))
                for label, message in paragraphs
            ],
        }"
1302,"def release(obj, commit='HEAD', components=False):
    """"""Generate release notes.""""""
    options = obj.options
    repository = obj.repository

    try:
        sha = 'oid'
        commits = _pygit2_commits(commit, repository)
    except ImportError:
        try:
            sha = 'hexsha'
            commits = _git_commits(commit, repository)
        except ImportError:
            click.echo('To use this feature, please install pygit2. '
                       'GitPython will also work but is not recommended '
                       '(python <= 2.7 only).', file=sys.stderr)
            return 2

    messages = OrderedDict([(getattr(c, sha), c.message) for c in commits])

    for commit_sha1 in amended_commits(messages):
        if commit_sha1 in messages:
            del messages[commit_sha1]

    full_messages = list(
        enrich_git_log_dict(messages, options.get('commit_msg_labels'))
    )
    indent = '  ' if components else ''
    wrapper = textwrap.TextWrapper(
        width=70,
        initial_indent=indent + '- ',
        subsequent_indent=indent + '  ',
    )

    for label, section in options.get('commit_msg_labels'):
        if section is None:
            continue
        bullets = []
        for commit in full_messages:
            bullets += [
                {'text': bullet, 'component': commit['component']}
                for lbl, bullet in commit['paragraphs']
                if lbl == label and bullet is not None
            ]
        if len(bullets) > 0:
            click.echo(section)
            click.echo('~' * len(section))
            click.echo()
            if components:
                def key(cmt):
                    return cmt['component']

                for component, bullets in itertools.groupby(
                        sorted(bullets, key=key), key):
                    bullets = list(bullets)
                    if len(bullets) > 0:
                        click.echo('+ {}'.format(component))
                        click.echo()
                    for bullet in bullets:
                        click.echo(wrapper.fill(bullet['text']))
                    click.echo()
            else:
                for bullet in bullets:
                    click.echo(wrapper.fill(bullet['text']))
            click.echo()

    return 0"
1303,"def incr(**vars):
    """"""Increments context variables
    """"""
    for k, v in vars:
        current_context.vars.setdefault(k, 0)
        current_context[k] += v"
1304,"def set_default_var(**vars):
    """"""Sets context variables using the key/value provided in the options
    """"""
    for k, v in vars.iteritems():
        current_context.vars.setdefault(k, v)"
1305,"def incr_obj(obj, **attrs):
    """"""Increments context variables
    """"""
    for name, value in attrs.iteritems():
        v = getattr(obj, name, None)
        if not hasattr(obj, name) or v is None:
            v = 0
        setattr(obj, name, v + value)"
1306,"def redirect(view=None, url=None, **kwargs):
    """"""Redirects to the specified view or url
    """"""
    if view:
        if url:
            kwargs[""url""] = url
        url = flask.url_for(view, **kwargs)
    current_context.exit(flask.redirect(url))"
1307,"def lines(query):
	""""""lines(query) -- print the number of lines in a given file
	""""""
	filename = support.get_file_name(query)
	if(os.path.isfile(filename)):
		with open(filename) as openfile:
			print len(openfile.readlines())
	else:
		print 'File not found : ' + filename"
1308,"def words(query):
	""""""lines(query) -- print the number of words in a given file
	""""""
	filename = support.get_file_name(query)
	if(os.path.isfile(filename)):
		with open(filename) as openfile:
			print len(openfile.read().split())
	else:
		print 'File not found : ' + filename"
1309,"def file_info(query):
	""""""file_info(query) -- print some human readable information of a given file
	""""""
	filename = support.get_file_name(query)
	if(os.path.isfile(filename)):
		stat_info = os.stat(filename)
		owner_name = pwd.getpwuid(stat_info.st_uid).pw_name
		print 'owner : ' + owner_name
		file_size = support.get_readable_filesize(stat_info.st_size)
		print 'size : ' + file_size
		print 'created : ' + time.ctime(stat_info.st_ctime)
		print 'last modified : ' + time.ctime(stat_info.st_mtime)
	else:
		print 'file not found'"
1310,"def make_executable(query):
	""""""make_executable(query) -- give executable permissions to a given file
	""""""
	filename = support.get_file_name(query)
	if(os.path.isfile(filename)):
		os.system('chmod +x '+filename)
	else:
		print 'file not found'"
1311,"def add_to_path(query):
	"""""" add_to_path(query) -- add user given path to environment PATH variable.
	""""""
	new_entry = support.get_path(query)
	if(new_entry):
		print 'Adding '+new_entry+' to PATH variable.'
		print '''1 : confirm
		2 : cancel
		'''
		choice = int(raw_input('>> '))
		if(choice == 1):
			home_dir = os.path.expanduser('~')
			bashrc = open(os.path.join(home_dir, "".bashrc""), ""a"")
			bashrc.write('\n\nexport PATH=\""'+new_entry+':$PATH\""\n')
			bashrc.close()
			os.system('source '+os.path.join(os.path.expanduser('~'),'.bashrc'))
			print 'Success!!'
			print os.system('echo $PATH')
	else:
		print 'We were unable to extract the \'path\' from your query.'"
1312,"def system_info(query):
	""""""system_info(query) -- print system specific information like OS, kernel,
	architecture etc.
	""""""
	proc = subprocess.Popen([""uname -o""], stdout=subprocess.PIPE, shell=True)
	(out, err) = proc.communicate()
	print ""operating system : ""+str(out),

	proc = subprocess.Popen([""uname""], stdout=subprocess.PIPE, shell=True)
	(out, err) = proc.communicate()
	print ""kernel : ""+str(out),

	proc = subprocess.Popen([""uname -r""], stdout=subprocess.PIPE, shell=True)
	(out, err) = proc.communicate()
	print ""kernel release : ""+str(out),

	proc = subprocess.Popen([""uname -m""], stdout=subprocess.PIPE, shell=True)
	(out, err) = proc.communicate()
	print ""architecture : ""+str(out),

	proc = subprocess.Popen([""uname -n""], stdout=subprocess.PIPE, shell=True)
	(out, err) = proc.communicate()
	print ""network node name : ""+str(out),"
1313,"def statsd_metric(name, count, elapsed):
    """"""Metric that records to statsd & graphite""""""
    with statsd.pipeline() as pipe:
        pipe.incr(name, count)
        pipe.timing(name, int(round(1000 * elapsed)))"
1314,"def setup(template_paths={}, autoescape=False, cache_size=100, auto_reload=True, bytecode_cache=True):
  """"""Setup Jinja enviroment
  
  eg. sketch.jinja.setup({
      'app': self.config.paths['app_template_basedir'],
      'sketch': self.config.paths['sketch_template_dir'],
    })
  
  :param template_paths: Dictionary of paths to templates (template_name => template_path)
  :param autoescape: Autoescape
  :param cache_size:
  :param auto_reload:
  :param bytecode_cache: 
  """"""
  global _jinja_env, _jinja_loaders
  
  if not _jinja_env:
    _jinja_env = JinjaEnviroment(
      autoescape=autoescape,
      cache_size=cache_size,
      auto_reload=auto_reload,
      bytecode_cache=None)

  # @TODO alter so Marshall is not used
  # if bytecode_cache and GAE_CACHE:
    # _jinja_env.bytecode_cache = GAEMemcacheBytecodeCache()

  if type(template_paths) == type(''):
    template_paths = {'site': template_paths}
  
  if len(template_paths) < 1:
    logging.exception('Sketch: jinja.setup: no template sets configured')
    return False

  if len(template_paths) == 1:
    template_set_name = template_paths.keys()[0]
    tp = template_paths[template_set_name]
    if tp in _jinja_loaders:
      _jinja_env.loader = _jinja_loaders[tp]
    else:
      _jinja_env.loader = _jinja_loaders[tp] = jinja2.FileSystemLoader(tp)
    return True
      
  if len(template_paths) > 1:
    loaders = {}
    for dirn, path in template_paths.items():
      loaders[dirn] = jinja2.FileSystemLoader(path)
    _jinja_env.loader = SubdirLoader(loaders)
    return True
  logging.error('Sketch: jinja.setup: no template sets configured (fallthrough)')
  logging.error(_jinja_loaders)"
1315,"def render(template_name, template_vars={}, template_set='site', template_theme=None, template_extension='html', template_content=None):
  """"""Given a template path, a template name and template variables
  will return rendered content using jinja2 library
  
  :param template_path: Path to template directory
  :param template_name: Name of template
  :param vars: (Optional) Template variables
  """"""
  global _jinja_env
  
  if not _jinja_env:
    raise 'Jinja env not setup'

  try:
    _jinja_env.filters['timesince'] = timesince
    _jinja_env.filters['timeuntil'] = timeuntil
    _jinja_env.filters['date'] = date_format
    _jinja_env.filters['time'] = time_format
    _jinja_env.filters['shortdate'] = short_date
    _jinja_env.filters['isodate'] = iso_date
    _jinja_env.filters['rfcdate'] = rfc2822_date
    _jinja_env.filters['tformat'] = datetimeformat
    _jinja_env.filters['timestamp'] = timestamp
  except NameError as errstr:
    logging.info('Helper import error: %s' % errstr)

  _template_name = ""%s.%s"" % (template_name, template_extension)
  template = _jinja_env.get_template(_template_name, parent=template_theme)
  
  return template.render(template_vars)"
1316,"def compile_file(env, src_path, dst_path, encoding='utf-8', base_dir=''):
  """"""Compiles a Jinja2 template to python code.

  :param env: a Jinja2 Environment instance.
  :param src_path: path to the source file.
  :param dst_path: path to the destination file.
  :param encoding: template encoding.
  :param base_dir: the base path to be removed from the compiled template filename.
  """"""
  src_file = file(src_path, 'r')
  source = src_file.read().decode(encoding)
  name = src_path.replace(base_dir, '')
  raw = env.compile(source, name=name, filename=name, raw=True)
  src_file.close()

  dst_file = open(dst_path, 'w')
  dst_file.write(raw)
  dst_file.close()"
1317,"def compile_dir(env, src_path, dst_path, pattern=r'^.*\.html$', encoding='utf-8', base_dir=None):
  """"""Compiles a directory of Jinja2 templates to python code.
  
  :param env: a Jinja2 Environment instance.
  :param src_path: path to the source directory.
  :param dst_path: path to the destination directory.
  :param encoding: template encoding.
  :param base_dir: the base path to be removed from the compiled template filename.
  """"""
  from os import path, listdir, mkdir
  file_re = re.compile(pattern)

  if base_dir is None:
    base_dir = src_path

  for filename in listdir(src_path):
    src_name = path.join(src_path, filename)
    dst_name = path.join(dst_path, filename)

    if path.isdir(src_name):
      mkdir(dst_name)
      compile_dir(env, src_name, dst_name, encoding=encoding, base_dir=base_dir)
    elif path.isfile(src_name) and file_re.match(filename):
      compile_file(env, src_name, dst_name, encoding=encoding, base_dir=base_dir)"
1318,"def _pre_dump(cls):
        """"""Output all recorded stats""""""
        shutil.rmtree(cls.outdir, ignore_errors=True)
        os.makedirs(cls.outdir)
        super(PlotMetric, cls)._pre_dump()"
1319,"def _histogram(self, which, mu, sigma, data):
        """"""plot a histogram. For internal use only""""""

        weights = np.ones_like(data)/len(data) # make bar heights sum to 100%
        n, bins, patches = plt.hist(data, bins=25, weights=weights, facecolor='blue', alpha=0.5)

        plt.title(r'%s %s: $\mu=%.2f$, $\sigma=%.2f$' % (self.name, which.capitalize(), mu, sigma))
        plt.xlabel('Items' if which == 'count' else 'Seconds')
        plt.ylabel('Frequency')
        plt.gca().yaxis.set_major_formatter(FuncFormatter(lambda y, position: ""{:.1f}%"".format(y*100)))"
1320,"def _scatter(self):
        """"""plot a scatter plot of count vs. elapsed. For internal use only""""""

        plt.scatter(self.count_arr, self.elapsed_arr)
        plt.title('{}: Count vs. Elapsed'.format(self.name))
        plt.xlabel('Items')
        plt.ylabel('Seconds')"
1321,"def bind(self, __fun, *args, **kwargs):
    """"""
    Bind a worker function to the future. This worker function will be
    executed when the future is executed.
    """"""

    with self._lock:
      if self._running or self._completed or self._cancelled:
        raise RuntimeError('Future object can not be reused')
      if self._worker:
        raise RuntimeError('Future object is already bound')
      self._worker = functools.partial(__fun, *args, **kwargs)
    return self"
1322,"def add_done_callback(self, fun):
    """"""
    Adds the callback *fun* to the future so that it be invoked when the
    future completed. The future completes either when it has been completed
    after being started with the :meth:`start` method (independent of whether
    an error occurs or not) or when either :meth:`set_result` or
    :meth:`set_exception` is called.

    If the future is already complete, *fun* will be invoked directly.

    The function *fun* must accept the future as its sole argument.
    """"""

    with self._lock:
      if self._completed:
        fun()
      else:
        self._done_callbacks.append(fun)"
1323,"def enqueue(self):
    """"""
    Mark the future as being enqueued in some kind of executor for futures.
    Calling :meth:`start()` with the *as_thread* parameter as :const:`True`
    will raise a :class:`RuntimeError` after this method has been called.

    This method will also validate the state of the future.
    """"""

    with self._lock:
      if self._enqueued:
        raise RuntimeError('Future object is already enqueued')
      if self._running:
        raise RuntimeError('Future object is already running')
      if self._completed:
        raise RuntimeError('Future object can not be restarted')
      if not self._worker:
        raise RuntimeError('Future object is not bound')
      self._enqueued = True"
1324,"def start(self, as_thread=True):
    """"""
    Execute the future in a new thread or in the current thread as specified
    by the *as_thread* parameter.

    :param as_thread: Execute the future in a new, separate thread. If this
      is set to :const:`False`, the future will be executed in the calling
      thread.
    """"""

    with self._lock:
      if as_thread:
        self.enqueue()  # Validate future state
      if self._cancelled:
        return

      self._running = True
      if as_thread:
        self._thread = threading.Thread(target=self._run)
        self._thread.start()
        return self

    self._run()"
1325,"def result(self, timeout=None, do_raise=True):
    """"""
    Retrieve the result of the future, waiting for it to complete or at
    max *timeout* seconds.

    :param timeout: The number of maximum seconds to wait for the result.
    :param do_raise: Set to False to prevent any of the exceptions below
      to be raised and return :const:`None` instead.
    :raise Cancelled: If the future has been cancelled.
    :raise Timeout: If the *timeout* has been exceeded.
    :raise BaseException: Anything the worker has raised.
    :return: Whatever the worker bound to the future returned.
    """"""

    with self._lock:
      self.wait(timeout, do_raise=do_raise)
      if self._exc_info:
        if not do_raise:
          return None
        # Its more important to re-raise the exception from the worker.
        self._exc_retrieved = True
        reraise(*self._exc_info)
      if self._cancelled:
        if not do_raise:
          return None
        raise self.Cancelled()
      return self._result"
1326,"def exception(self, timeout=None, do_raise=True):
    """"""
    Returns the exception value by the future's worker or :const:`None`.

    :param timeout:
    :param do_raise:
    :param Cancelled:
    :param Timeout:
    :return: :const:`None` or an exception value.
    """"""

    with self._lock:
      self.wait(timeout, do_raise=do_raise)
      if not self._exc_info:
        return None
      self._exc_retrieved = True
      if self._cancelled:
        raise self.Cancelled()
      return self._exc_info[1]"
1327,"def cancel(self, mark_completed_as_cancelled=False):
    """"""
    Cancel the future. If the future has not been started yet, it will never
    start running. If the future is already running, it will run until the
    worker function exists. The worker function can check if the future has
    been cancelled using the :meth:`cancelled` method.

    If the future has already been completed, it will not be marked as
    cancelled unless you set *mark_completed_as_cancelled* to :const:`True`.

    :param mark_completed_as_cancelled: If this is :const:`True` and the
      future has already completed, it will be marked as cancelled anyway.
    """"""

    with self._lock:
      if not self._completed or mark_completed_as_cancelled:
        self._cancelled = True
      callbacks = self._prepare_done_callbacks()
    callbacks()"
1328,"def set_result(self, result):
    """"""
    Allows you to set the result of the future without requiring the future
    to actually be executed. This can be used if the result is available
    before the future is run, allowing you to keep the future as the interface
    for retrieving the result data.

    :param result: The result of the future.
    :raise RuntimeError: If the future is already enqueued.
    """"""

    with self._lock:
      if self._enqueued:
        raise RuntimeError('can not set result of enqueued Future')
      self._result = result
      self._completed = True
      callbacks = self._prepare_done_callbacks()
    callbacks()"
1329,"def set_exception(self, exc_info):
    """"""
    This method allows you to set an exception in the future without requring
    that exception to be raised from the futures worker. This method can be
    called on an unbound future.

    :param exc_info: Either an exception info tuple or an exception value.
      In the latter case, the traceback will be automatically generated
      from the parent frame.
    :raise RuntimeError: If the future is already enqueued.
    """"""

    if not isinstance(exc_info, tuple):
      if not isinstance(exc_info, BaseException):
        raise TypeError('expected BaseException instance')
      try:
        # TODO: Filld the traceback so it appears as if the exception
        #       was actually raised by the caller? (Not sure if possible)
        raise exc_info
      except:
        exc_info = sys.exc_info()
        exc_info = (exc_info[0], exc_info[1], exc_info[2])

    with self._lock:
      if self._enqueued:
        raise RuntimeError('can not set exception of enqueued Future')
      self._exc_info = exc_info
      self._completed = True
      callbacks = self._prepare_done_callbacks()
    callbacks()"
1330,"def wait(self, timeout=None, do_raise=False):
    """"""
    Wait for the future to complete. If *timeout* is specified, it must be a
    floating point number representing the maximum number of seconds to wait.

    :param timeout: The maximum number of seconds to wait for the future
      to complete.
    :param do_raise: Raise :class:`Timeout` when a timeout occurred.
    :raise Timeout: If a timeout occurred and *do_raise* was True.
    :return: :const:`True` if the future completed, :const:`False` if a
      timeout occurred and *do_raise* was set to False.
    """"""

    if timeout is not None:
      timeout = float(timeout)
      start = time.clock()

    with self._lock:
      while not self._completed and not self._cancelled:
        if timeout is not None:
          time_left = timeout - (time.clock() - start)
        else:
          time_left = None
        if time_left is not None and time_left <= 0.0:
          if do_raise:
            raise self.Timeout()
          else:
            return False
        self._lock.wait(time_left)
    return True"
1331,"def enqueue(self, future):
    """"""
    Enqueue a future to be processed by one of the threads in the pool.
    The future must be bound to a worker and not have been started yet.
    """"""

    future.enqueue()
    with self._lock:
      if self._shutdown:
        raise RuntimeError('ThreadPool has been shut down and can no '
          'longer accept futures.')
      self._queue.append(future)
      if len(self._running) == len(self._workers):
        self._new_worker()
      self._lock.notify_all()"
1332,"def submit(self, __fun, *args, **kwargs):
    """"""
    Creates a new future and enqueues it. Returns the future.
    """"""

    future = Future().bind(__fun, *args, **kwargs)
    self.enqueue(future)
    return future"
1333,"def cancel(self, cancel_running=True, mark_completed_as_cancelled=False):
    """"""
    Cancel all futures queued in the pool. If *cancel_running* is True,
    futures that are currently running in the pool are cancelled as well.
    """"""

    with self._lock:
      for future in self._queue:
        future.cancel(mark_completed_as_cancelled)
      if cancel_running:
        for future in self._running:
          future.cancel(mark_completed_as_cancelled)
      self._queue.clear()"
1334,"def shutdown(self, wait=True):
    """"""
    Shut down the pool. If *wait* is True, it will wait until all futures
    are completed. Alternatively, you can use the #wait() method to wait
    with timeout supported.
    """"""

    with self._lock:
      self._shutdown = True
      self._lock.notify_all()
    if wait:
      self.wait()"
1335,"def wait(self, timeout=None):
    """"""
    Wait until all futures are completed. You should call this method only
    after calling #shutdown(). Returns #False if all futures are complete,
    #False if there are still some running.
    """"""

    tbegin = _get_timeout_begin(timeout)
    with self._lock:
      while self._queue or self._running:
        remainder = _get_timeout_remainder(tbegin, timeout)
        if remainder is not None and remainder <= 0.0:
          return False  # timeout
        self._lock.wait(remainder)
      if self._shutdown:
        for worker in self._workers:
          worker.join()
    return True"
1336,"def timeit(func):
    """"""
    Returns the number of seconds that a function took along with the result
    """"""

    @wraps(func)
    def timer_wrapper(*args, **kwargs):
        """"""
        Inner function that uses the Timer context object
        """"""
        with Timer() as timer:
            result = func(*args, **kwargs)

        return result, timer

    return timer_wrapper"
1337,"def timeout(seconds):
    """"""
    Raises a TimeoutError if a function does not terminate within
    specified seconds.
    """"""
    def _timeout_error(signal, frame):
        raise TimeoutError(""Operation did not finish within \
        {} seconds"".format(seconds))

    def timeout_decorator(func):

        @wraps(func)
        def timeout_wrapper(*args, **kwargs):
            signal.signal(signal.SIGALRM, _timeout_error)
            signal.alarm(seconds)
            try:
                return func(*args, **kwargs)
            finally:
                signal.alarm(0)

        return timeout_wrapper

    return timeout_decorator"
1338,"def create(location: str, extensions_found: List[str] = None):  # -> NoParserFoundForObject:
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param location:
        :param extensions_found:
        :return:
        """"""
        if not extensions_found:
            return ObjectPresentMultipleTimesOnFileSystemError('Object : ' + location + ' is present multiple '
                                                               'times on the file system.')
        else:
            return ObjectPresentMultipleTimesOnFileSystemError('Object : ' + location + ' is present multiple '
                                                               'times on the file system , with extensions : ' +
                                                               str(extensions_found) + '. Only one version of each '
                                                               'object should be provided. If you need multiple files'
                                                               ' to create this object, you should create a multifile'
                                                               ' object instead (with each file having its own name and'
                                                               ' a shared prefix)')"
1339,"def create(location: str, simpleobjects_found = None, complexobject_attributes_found = None):  # -> ObjectNotFoundOnFileSystemError:
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param location:
        :return:
        """"""
        if len(complexobject_attributes_found) > 0 or len(simpleobjects_found) > 0:
            return ObjectNotFoundOnFileSystemError('Mandatory object : ' + location + ' could not be found on the file'
                                                   ' system, either as a multifile or as a singlefile with any '
                                                   'extension, but it seems that this is because you have left the '
                                                   'extension in the location name. Please remove the file extension '
                                                   'from the location name and try again')
        else:
            return ObjectNotFoundOnFileSystemError('Mandatory object : ' + location + ' could not be found on the file'
                                                   ' system, either as a multifile or as a singlefile with any '
                                                   'extension.')"
1340,"def get_unique_object_contents(self, location: str) -> Tuple[bool, str, Union[str, Dict[str, str]]]:
        """"""
        Utility method to find a unique singlefile or multifile object.
        This method throws
        * ObjectNotFoundOnFileSystemError if no file is found
        * ObjectPresentMultipleTimesOnFileSystemError if the object is found multiple times (for example with
        several file extensions, or as a file AND a folder)
        * IllegalContentNameError if a multifile child name is None or empty string.

        It relies on the abstract methods of this class (find_simpleobject_file_occurrences and
        find_multifile_object_children) to find the various files present.

        :param location: a location identifier compliant with the provided file mapping configuration
        :return: [True, singlefile_ext, singlefile_path] if a unique singlefile object is present ;
        False, MULTIFILE_EXT, complexobject_attributes_found] if a unique multifile object is present, with
        complexobject_attributes_found being a dictionary {name: location}
        """"""

        # First check what is present on the filesystem according to the filemapping
        simpleobjects_found = self.find_simpleobject_file_occurrences(location)
        complexobject_attributes_found = self.find_multifile_object_children(location, no_errors=True)

        # Then handle the various cases
        if len(simpleobjects_found) > 1 \
                or (len(simpleobjects_found) == 1 and len(complexobject_attributes_found) > 0):
            # the object is present several times > error
            u = simpleobjects_found
            u.update(complexobject_attributes_found)
            raise ObjectPresentMultipleTimesOnFileSystemError.create(location, list(u.keys()))

        elif len(simpleobjects_found) == 1:
            # a singlefile object > create the output
            is_single_file = True
            ext = list(simpleobjects_found.keys())[0]
            singlefile_object_file_path = simpleobjects_found[ext]
            return is_single_file, ext, singlefile_object_file_path

        elif len(complexobject_attributes_found) > 0:
            # a multifile object > create the output
            is_single_file = False
            ext = MULTIFILE_EXT
            if '' in complexobject_attributes_found.keys() or None in complexobject_attributes_found.keys():
                raise IllegalContentNameError.create(location, complexobject_attributes_found[MULTIFILE_EXT])
            return is_single_file, ext, complexobject_attributes_found

        else:
            # handle special case of multifile object with no children (if applicable)
            if self.is_multifile_object_without_children(location):
                is_single_file = False
                ext = MULTIFILE_EXT
                return is_single_file, ext, dict()
            else:
                # try if by any chance the issue is that location has an extension
                loc_without_ext = splitext(location)[0]
                simpleobjects_found = self.find_simpleobject_file_occurrences(loc_without_ext)
                complexobject_attributes_found = self.find_multifile_object_children(loc_without_ext, no_errors=True)

                # the object was not found in a form that can be parsed
                raise ObjectNotFoundOnFileSystemError.create(location, simpleobjects_found,
                                                             complexobject_attributes_found)"
1341,"def find_multifile_object_children(self, parent_location: str, no_errors: bool = False) -> Dict[str, str]:
        """"""
        Implementing classes should return a dictionary of <item_name>, <item_location> containing the named elements
        in this multifile object.

        :param parent_location: the absolute file prefix of the parent item.
        :return: a dictionary of {item_name : item_prefix}
        """"""
        pass"
1342,"def get_pretty_location(self, blank_parent_part: bool = False, append_file_ext: bool = True,
                            compact_file_ext: bool = False):
        """"""
        Utility method to return a string representing the location, mode and extension of this file.
        :return:
        """"""
        if append_file_ext:
            if compact_file_ext:
                suffix = self.ext if self.is_singlefile else ''
            else:
                suffix = ' (' + self.get_pretty_file_ext() + ')'
        else:
            suffix = ''
        if blank_parent_part:
            # TODO sep should be replaced with the appropriate separator in flat mode
            idx = self.location.rfind(sep)
            return (' ' * (idx-1-len(sep))) + '|--' + self.location[(idx+1):] + suffix
        else:
            return self.location + suffix"
1343,"def get_pretty_child_location(self, child_name, blank_parent_part: bool = False):
        """"""
        Utility method to return a string representation of the location of a child
        :param child_name:
        :param blank_parent_part:
        :return:
        """"""
        if blank_parent_part:
            idx = len(self.location)
            return (' ' * (idx-3)) + '|--' + child_name
        else:
            # TODO sep should be replaced with the appropriate separator in flat mode
            return self.location + sep + child_name"
1344,"def create_persisted_object(self, location: str, logger: Logger) -> PersistedObject:
        """"""
        Creates a PersistedObject representing the object at location 'location', and recursively creates all of its
        children

        :param location:
        :param logger:
        :return:
        """"""
        #print('Checking all files under ' + location)
        logger.debug('Checking all files under [{loc}]'.format(loc=location))
        obj = FileMappingConfiguration.RecursivePersistedObject(location=location, file_mapping_conf=self,
                                                                logger=logger)
        #print('File checks done')
        logger.debug('File checks done')
        return obj"
1345,"def find_multifile_object_children(self, parent_location, no_errors: bool = False) -> Dict[str, str]:
        """"""
        Implementation of the parent abstract method.

        In this mode, root_path should be a valid folder, and each item is a subfolder (multifile) or a file
        (singlefile):

            location/
            |-singlefile_sub_item1.<ext>
            |-singlefile_sub_item2.<ext>
            |-multifile_sub_item3/
              |- ...

        :param parent_location: the absolute file prefix of the parent item. it may be a folder (non-flat mode)
        or a folder + a file name prefix (flat mode)
        :param no_errors: a boolean used in internal recursive calls in order to catch errors. Should not be changed by
        users.
        :return: a dictionary of {item_name : item_prefix}
        """"""

        # (1) Assert that folder_path is a folder
        if not isdir(parent_location):
            if no_errors:
                return dict()
            else:
                raise ValueError('Cannot find a multifileobject at location \'' + parent_location + '\' : location is '
                                 'not a valid folder')

        else:
            # (2) List folders (multifile objects or collections)
            all_subfolders = [dir_ for dir_ in listdir(parent_location) if isdir(join(parent_location, dir_))]
            items = {item_name: join(parent_location, item_name) for item_name in all_subfolders}

            # (3) List singlefiles *without* their extension
            items.update({
                          item_name: join(parent_location, item_name)
                          for item_name in [file_name[0:file_name.rindex(EXT_SEPARATOR)]
                                            for file_name in listdir(parent_location)
                                            if isfile(join(parent_location, file_name))
                                            and EXT_SEPARATOR in file_name]
                         })
        # (4) return all
        return items"
1346,"def is_multifile_object_without_children(self, location: str) -> bool:
        """"""
        Returns True if an item with this location is present as a multifile object without children.
        For this implementation, this means that there is a folder without any files in it

        :param location:
        :return:
        """"""
        return isdir(location) and len(self.find_multifile_object_children(location)) == 0"
1347,"def get_multifile_object_child_location(self, parent_item_prefix: str, child_name: str) -> str:
        """"""
        Implementation of the parent abstract method.
        In this mode the attribute is a file inside the parent object folder

        :param parent_item_prefix: the absolute file prefix of the parent item.
        :return: the file prefix for this attribute
        """"""
        check_var(parent_item_prefix, var_types=str, var_name='parent_item_prefix')
        check_var(child_name, var_types=str, var_name='item_name')

        # assert that folder_path is a folder
        if not isdir(parent_item_prefix):
            raise ValueError(
                'Cannot get attribute item in non-flat mode, parent item path is not a folder : ' + parent_item_prefix)
        return join(parent_item_prefix, child_name)"
1348,"def find_multifile_object_children(self, parent_location, no_errors: bool = False) -> Dict[str, str]:
        """"""
        Implementation of the parent abstract method.

        In this mode, each item is a set of files with the same prefix than location, separated from the
        attribute name by the character sequence <self.separator>. The location may also be directly a folder,
        in which case the sub items dont have a prefix.

        example if location = '<parent_folder>/<file_prefix>'

        parent_folder/
        |-file_prefix<sep>singlefile_sub_item1.<ext>
        |-file_prefix<sep>singlefile_sub_item2.<ext>
        |-file_prefix<sep>multifile_sub_item3<sep>singlesub1.<ext>
        |-file_prefix<sep>multifile_sub_item3<sep>singlesub2.<ext>

        example if location = '<parent_folder>/

        parent_folder/
        |-singlefile_sub_item1.<ext>
        |-singlefile_sub_item2.<ext>
        |-multifile_sub_item3<sep>singlesub1.<ext>
        |-multifile_sub_item3<sep>singlesub2.<ext>

        :param parent_location: the absolute file prefix of the parent item. It may be a folder (special case of the
         root folder) but typically is just a file prefix
        :param no_errors:
        :return: a dictionary of <item_name>, <item_path>
        """"""
        if parent_location == '':
            parent_location = '.'

        # (1) Find the base directory and base name
        if isdir(parent_location):  # special case: parent location is the root folder where all the files are.
            parent_dir = parent_location
            base_prefix = ''
            start_with = ''
        else:
            parent_dir = dirname(parent_location)
            if parent_dir is '':
                parent_dir = '.'
            # TODO one day we'll rather want to have a uniform definition of 'location' across filemappings
            # Indeed as of today, location is not abstract from the file mapping implementation, since we
            # ""just"" use basename() rather than replacing os separators with our separator:
            base_prefix = basename(parent_location)  # --> so it should already include self.separator to be valid
            start_with = self.separator

        # (2) list children files that are singlefiles
        content_files = [content_file for content_file in listdir(parent_dir)
                         # -> we are in flat mode : should be a file not a folder :
                         if isfile(join(parent_dir,content_file))
                         # -> we are looking for children of a specific item :
                         and content_file.startswith(base_prefix)
                         # -> we are looking for multifile child items only :
                         and content_file != base_prefix
                         # -> they should start with the separator (or with nothing in case of the root folder) :
                         and (content_file[len(base_prefix):]).startswith(start_with)
                         # -> they should have a valid extension :
                         and (content_file[len(base_prefix + start_with):]).count(EXT_SEPARATOR) >= 1
                         ]
        # (3) build the resulting dictionary of item_name > item_prefix
        item_prefixes = dict()
        for item_file in content_files:
            end_name = item_file.find(self.separator, len(base_prefix + start_with))
            if end_name == -1:
                end_name = item_file.find(EXT_SEPARATOR, len(base_prefix + start_with))
            item_name = item_file[len(base_prefix + start_with):end_name]
            item_prefixes[item_name] = join(parent_dir, base_prefix + start_with + item_name)

        return item_prefixes"
1349,"def is_multifile_object_without_children(self, location: str) -> bool:
        """"""
        Returns True if an item with this location is present as a multifile object without children.
        For this implementation, this means that there is a file with the appropriate name but without extension

        :param location:
        :return:
        """"""
        # (1) Find the base directory and base name
        if isdir(location):  # special case: parent location is the root folder where all the files are.
            return len(self.find_multifile_object_children(location)) == 0
        else:
            # TODO same comment than in find_multifile_object_children
            if exists(location):
                # location is a file without extension. We can accept that as being a multifile object without children
                return True
            else:
                return False"
1350,"def get_multifile_object_child_location(self, parent_location: str, child_name: str):
        """"""
        Implementation of the parent abstract method.

        In this mode the attribute is a file with the same prefix, separated from the parent object name by
        the character sequence <self.separator>

        :param parent_location: the absolute file prefix of the parent item.
        :param child_name:
        :return: the file prefix for this attribute
        """"""
        check_var(parent_location, var_types=str, var_name='parent_path')
        check_var(child_name, var_types=str, var_name='item_name')

        # a child location is built by adding the separator between the child name and the parent location
        return parent_location + self.separator + child_name"
1351,"def find_simpleobject_file_occurrences(self, location) -> Dict[str, str]:
        """"""
        Implementation of the parent abstract method.

        :param location:
        :return: a dictionary{ext : file_path}
        """"""
        parent_dir = dirname(location)
        if parent_dir is '':
            parent_dir = '.'
        base_prefix = basename(location)

        # trick : is sep_for_flat is a dot, we have to take into account that there is also a dot for the extension
        min_sep_count = (1 if self.separator == EXT_SEPARATOR else 0)
        possible_object_files = {object_file[len(base_prefix):]: join(parent_dir, object_file)
                                 for object_file in listdir(parent_dir) if isfile(parent_dir + '/' + object_file)
                                 and object_file.startswith(base_prefix)
                                 # file must be named base_prefix.something
                                 and object_file != base_prefix
                                 and object_file[len(base_prefix)] == EXT_SEPARATOR
                                 and (object_file[len(base_prefix):]).count(EXT_SEPARATOR) == 1
                                 # and no other item separator should be present in the something
                                 and (object_file[len(base_prefix):]).count(self.separator) == min_sep_count}

        return possible_object_files"
1352,"def special_links_replace(text, urls):
    '''
    Replace simplified Regulations and Guidelines links into actual links.
    'urls' dictionary is expected to provide actual links to the targeted
    Regulations and Guidelines, as well as to the PDF file.
    '''
    match_number = r'([A-Za-z0-9]+)' + r'(\+*)'
    reference_list = [(r'regulations:article:' + match_number, urls['regulations']),
                      (r'regulations:regulation:' + match_number, urls['regulations']),
                      (r'guidelines:article:' + match_number, urls['guidelines']),
                      (r'guidelines:guideline:' + match_number, urls['guidelines']),
                     ]
    anchor_list = [(r'regulations:contents', urls['regulations'] + r'#contents'),
                   (r'guidelines:contents', urls['guidelines'] + r'#contents'),
                   (r'regulations:top', urls['regulations'] + r'#'),
                   (r'guidelines:top', urls['guidelines'] + r'#'),
                   (r'link:pdf', urls['pdf'] + '.pdf'),
                  ]
    retval = text
    for match, repl in reference_list:
        retval = re.sub(match, repl + r'#\1\2', retval)
    for match, repl in anchor_list:
        retval = re.sub(match, repl, retval)
    return retval"
1353,"def list2html(text):
    '''
    Very simple replacement for lists, no nesting, not even two lists in the
    same 'text'... (yet sufficient for the current regulations)
    Assumes list is in a paragraph.
    '''
    match = r'- (.+)\n'
    replace = r'<li>\1</li>\n'
    text = re.sub(match, replace, text)
    # Set start of list
    text = text.replace('<li>', '</p><ul><li>', 1)
    # Set end of list
    tmp = text.rsplit('</li>', 1)
    return '</li></ul><p>'.join(tmp)"
1354,"def link2html(text):
    ''' Turns md links to html '''
    match = r'\[([^\]]+)\]\(([^)]+)\)'
    replace = r'<a href=""\2"">\1</a>'
    return re.sub(match, replace, text)"
1355,"def simple_md2html(text, urls):
    ''' Convert a text from md to html '''
    retval = special_links_replace(text, urls)
    # Create a par break for double newlines
    retval = re.sub(r'\n\n', r'</p><p>', retval)
    # Create a visual br for every new line
    retval = re.sub(r'\n', r'<br />\n', retval)
    # Do we really need this ? Help reduce the diff to only '\n' diff.
    retval = re.sub(r'""', r'&quot;', retval)
    retval = list2html(retval)
    return link2html(retval)"
1356,"def generate_ul(self, a_list):
        ''' Determines if we should generate th 'ul' around the list 'a_list' '''
        return len(a_list) > 0 and (isinstance(a_list[0], Rule) or
                                    isinstance(a_list[0], LabelDecl))"
1357,"def get_version_info():
    """"""Extract version information as a dictionary from version.py.""""""
    version_info = {}
    with open(os.path.join(""refcycle"", ""version.py""), 'r') as f:
        version_code = compile(f.read(), ""version.py"", 'exec')
        exec(version_code, version_info)
    return version_info"
1358,"def div_filter(key: str, value: list, format: str, meta: Any) -> Optional[list]:
    """"""Filter the JSON ``value`` for alert divs.

    Arguments
    ---------
    key
        Key of the structure
    value
        Values in the structure
    format
        Output format of the processing
    meta
        Meta information
    """"""
    if key != ""Div"" or format != ""latex"":
        return None

    [[_, classes, _], contents] = value
    try:
        alert_type = [name.split(""-"")[1] for name in classes if ""-"" in name][0]
    except IndexError:
        return None

    if alert_type not in ALLOWED_ALERT_TYPES.__members__:
        return None

    filtered = [RawBlock(""latex"", rf""\begin{{{alert_type}box}}"")]
    filtered.extend(contents)
    filtered.append(RawBlock(""latex"", rf""\end{{{alert_type}box}}""))
    return filtered"
1359,"def convert_div(text: str, format: Optional[str] = None) -> ""applyJSONFilters"":
    """"""Apply the `dev_filter` action to the text.""""""
    return applyJSONFilters([div_filter], text, format=format)"
1360,"def raw_html_filter(key: str, value: list, format: str, meta: Any) -> Optional[list]:
    """"""Filter the JSON ``value`` for raw html to convert to LaTeX.

    Arguments
    ---------
    key
        Key of the structure
    value
        Values in the structure
    format
        Output format of the processing
    meta
        Meta information
    """"""
    if key == ""RawInline"" and format == ""latex"" and value[0] == ""html"":
        if value[1] == ""<sup>"":
            filtered = [RawInline(""latex"", r""\textsuperscript{"")]
        elif value[1] == ""</sup>"":
            filtered = [RawInline(""latex"", ""}"")]
        elif value[1] == ""<sub>"":
            filtered = [RawInline(""latex"", r""\textsubscript{"")]
        elif value[1] == ""</sub>"":
            filtered = [RawInline(""latex"", ""}"")]
        else:
            return None
        return filtered

    return None"
1361,"def convert_raw_html(text: str, format: Optional[str] = None) -> ""applyJSONFilters"":
    """"""Apply the `raw_html_filter` action to the text.""""""
    return applyJSONFilters([raw_html_filter], text, format=format)"
1362,"def add(self, element):
        """"""Add an element to this set.""""""
        key = self._transform(element)
        if key not in self._elements:
            self._elements[key] = element"
1363,"def discard(self, element):
        """"""Remove an element.  Do not raise an exception if absent.""""""
        key = self._transform(element)
        if key in self._elements:
            del self._elements[key]"
1364,"def add_items_to_message(msg, log_dict):
    """"""Utility function to add dictionary items to a log message.""""""
    out = msg
    for key, value in log_dict.items():
        out += "" {}={}"".format(key, value)
    return out"
1365,"def log_event(event, logger=root_logger, **log_dict):
    """"""
    Utility function for logging an event (e.g. for metric analysis).

    If no logger is given, fallback to the root logger.

    """"""
    msg = ""event={}"".format(event)
    msg = add_items_to_message(msg, log_dict)
    log_dict.update({'event': event})
    logger.info(msg, extra=log_dict)"
1366,"def metric(cls, name, count, elapsed):
        """"""A metric function that writes multiple CSV files

        :arg str name: name of the metric
        :arg int count: number of items
        :arg float elapsed: time in seconds
        """"""

        if name is None:
            warnings.warn(""Ignoring unnamed metric"", stacklevel=3)
            return

        with cls.lock:
            if not cls.instances:
                # first call
                shutil.rmtree(cls.outdir, ignore_errors=True)
                os.makedirs(cls.outdir)

                if cls.dump_atexit: atexit.register(cls.dump)

            try:
                self = cls.instances[name]
            except KeyError:
                self = cls.instances[name] = cls(name)

            self.writer.writerow((count, ""%f""%elapsed))"
1367,"def dump(cls):
        """"""Output all recorded metrics""""""
        with cls.lock:
            if not cls.instances: return
            atexit.unregister(cls.dump)

            for self in cls.instances.values():
                self.fh.close()"
1368,"def metric(self, name, count, elapsed):
        """"""A metric function that writes a single CSV file

        :arg str name: name of the metric
        :arg int count: number of items
        :arg float elapsed: time in seconds
        """"""

        if name is None:
            warnings.warn(""Ignoring unnamed metric"", stacklevel=3)
            return

        with self.lock:
            self.writer.writerow((name, count, ""%f""%elapsed))"
1369,"def dump(self):
        """"""Output all recorded metrics""""""
        with self.lock:
            atexit.unregister(self.dump)
            self.fh.close()"
1370,"def read(parts):
    """"""
    Build an absolute path from parts array and and return the contents
    of the resulting file.  Assume UTF-8 encoding.
    """"""
    cur_dir = os.path.abspath(os.path.dirname(__file__))
    with codecs.open(os.path.join(cur_dir, *parts), ""rb"", ""utf-8"") as f:
        return f.read()"
1371,"def find_meta(meta):
    """"""
    Extract __*meta*__ from META_FILE.
    """"""
    meta_match = re.search(
        r""^__{meta}__ = ['\""]([^'\""]*)['\""]"".format(meta=meta),
        META_FILE, re.M
    )
    if meta_match:
        return meta_match.group(1)
    raise RuntimeError(""Unable to find __{meta}__ string."".format(meta=meta))"
1372,"def ensure_clean_git(operation='operation'):
    """""" Verify that git has no uncommitted changes """"""
    if os.system('git diff-index --quiet HEAD --'):
        print(""Unstaged or uncommitted changes detected. {} aborted."".format(
            operation.capitalize()))
        sys.exit()"
1373,"def load(self):
        """"""
        _load_

        Load the defaults file if specified
        and overlay the json file on top of that

        """"""
        if self._defaults_file is not None:
            if not os.path.exists(self._defaults_file):
                msg = ""Unable to find defaults file: {}"".format(self._defaults_file)
                LOGGER.error(msg)
                raise RuntimeError(msg)
            with open(self._defaults_file, 'r') as handle:
                self._defaults = json.load(handle)
                self.update(self._defaults)

        if self._settings_file is None:
            msg = ""No context file has been provided""
            LOGGER.error(msg)
            raise RuntimeError(msg)
        if not os.path.exists(self._settings_file):
            msg = ""Unable to find settings file: {}"".format(self._settings_file)
            LOGGER.error(msg)
            raise RuntimeError(msg)
        with open(self._settings_file, 'r') as handle:
            settings = json.load(handle)
            update(self, settings)

        return"
1374,"def check_var(var, var_types:Union[type, List[type]] =None, var_name=None, enforce_not_none:bool = True,
              allowed_values:Set = None, min_value = None, min_strict:bool = False,
              max_value = None, max_strict:bool = False, min_len:int = None, min_len_strict:bool = False,
              max_len:int = None, max_len_strict:bool = False):
    """"""
    Helper method to check that an object has certain properties:
    * not none
    * a certain type
    * in some accepted values
    * in some accepted range

    :param var: the object to check
    :param var_types: the type(s) to enforce. If None, type will not be enforced
    :param var_name: the name of the varioable to be used in error messages
    :param enforce_not_none: boolean, default True. Whether to enforce that var is not None.
    :param allowed_values: an optional set of allowed values
    :param min_value: an optional minimum value
    :param min_strict: if True, only values strictly greater than the minimum value will be accepted
    :param max_value: an optional maximum value
    :param max_strict: if True, only values strictly lesser than the minimum value will be accepted
    :return:
    """"""

    var_name = var_name or 'object'

    if enforce_not_none and (var is None):
        # enforce not none
        raise MissingMandatoryParameterException('Error, ' + var_name + '"" is mandatory, it should be non-None')

    if not (var is None) and not (var_types is None):
        # enforce type
        if not isinstance(var_types, list):
            var_types = [var_types]

        match = False
        for var_type in var_types:
            # just in case, even though users should use FunctionType or MethodType which is the true type
            if var_type is Callable:
                if callable(var):
                    match = True
                    break
            else:
                if isinstance(var, var_type):
                    match = True
                    break

        if not match:
            raise TypeError('Error, ' + var_name + '"" should be one of type(s) ' + str(var_types) + ', found: ' + str(type(var)))

    if var is not None:
        if allowed_values is not None:
            # enforce allowed values
            if var not in allowed_values:
                raise TypeError('Error, ' + var_name + '"" should be one of ""' + str(allowed_values) + '"", found: ' + str(var))

        if min_value is not None:
            # enforce min value
            if min_strict:
                if not (var > min_value):
                    raise TypeError(
                        'Error, ' + var_name + '"" should be strictly greater than ""' + str(min_value) + '"", found: ' + str(var))
            else:
                if not (var >= min_value):
                    raise TypeError(
                        'Error, ' + var_name + '"" should be greater than ""' + str(min_value) + '"", found: ' + str(var))

        if max_value is not None:
            # enforce max value
            if max_strict:
                if not (var < max_value):
                    raise TypeError(
                        'Error, ' + var_name + '"" should be strictly lesser than ""' + str(max_value) + '"", found: ' + str(var))
            else:
                if not (var <= max_value):
                    raise TypeError(
                        'Error, ' + var_name + '"" should be lesser than ""' + str(max_value) + '"", found: ' + str(var))

        if min_len is not None:
            # enforce min length
            if min_len_strict:
                if not (len(var) > min_len):
                    raise TypeError(
                        'Error, ' + var_name + '"" length should be strictly greater than ""' + str(min_len) + '"", found: ' + str(len(var)))
            else:
                if not (len(var) >= min_len):
                    raise TypeError(
                        'Error, ' + var_name + '"" length should be greater than ""' + str(min_len) + '"", found: ' + str(len(var)))

        if max_len is not None:
            # enforce max length
            if max_len_strict:
                if not (len(var) < max_len):
                    raise TypeError(
                        'Error, ' + var_name + '"" length should be strictly lesser than ""' + str(max_len) + '"", found: ' + str(len(var)))
            else:
                if not (len(var) <= max_len):
                    raise TypeError(
                        'Error, ' + var_name + '"" length should be lesser than ""' + str(max_len) + '"", found: ' + str(len(var)))"
1375,"def hasmethod(obj, meth):
  """"""
    Checks if an object, obj, has a callable method, meth
    
    return True or False
  """"""
  if hasattr(obj, meth):
    return callable(getattr(obj,meth))
  return False"
1376,"def hasvar(obj, var):
  """"""
    Checks if object, obj has a variable var
    
    return True or False
  """"""
  if hasattr(obj, var):
    return not callable(getattr(obj, var))
  return False"
1377,"def getmethattr(obj, meth):
  """"""
    Returns either the variable value or method invocation
  """"""
  if hasmethod(obj, meth):
    return getattr(obj, meth)()
  elif hasvar(obj, meth):
    return getattr(obj, meth)
  return None"
1378,"def assure_obj_child_dict(obj, var):
  """"""Assure the object has the specified child dict
  """"""
  if not var in obj or type(obj[var]) != type({}):
    obj[var] = {}
  return obj"
1379,"def warmup(f):
    """""" Decorator to run warmup before running a command """"""

    @wraps(f)
    def wrapped(self, *args, **kwargs):
        if not self.warmed_up:
            self.warmup()
        return f(self, *args, **kwargs)
    return wrapped"
1380,"def install_required(f):
    """""" Return an exception if the namespace is not already installed """"""

    @wraps(f)
    def wrapped(self, *args, **kwargs):
        if self.directory.new:
            raise SprinterException(""Namespace %s is not yet installed!"" % self.namespace)
        return f(self, *args, **kwargs)
    return wrapped"
1381,"def install(self):
        """""" Install the environment """"""
        self.phase = PHASE.INSTALL
        if not self.directory.new:
            self.logger.info(""Namespace %s directory already exists!"" % self.namespace)
            self.source = load_manifest(self.directory.manifest_path)
            return self.update()
        try:
            self.logger.info(""Installing environment %s..."" % self.namespace)
            self.directory.initialize()
            self.install_sandboxes()
            self.instantiate_features()
            self.grab_inputs()
            self._specialize()
            for feature in self.features.run_order:
                self.run_action(feature, 'sync')
            self.inject_environment_config()
            self._finalize()
        except Exception:
            self.logger.debug("""", exc_info=sys.exc_info())
            self.logger.info(""An error occured during installation!"")
            if not self.ignore_errors:
                self.clear_all()
                self.logger.info(""Removing installation %s..."" % self.namespace)
                self.directory.remove()
                et, ei, tb = sys.exc_info()
                reraise(et, ei, tb)"
1382,"def update(self, reconfigure=False):
        """""" update the environment """"""
        try:
            self.phase = PHASE.UPDATE
            self.logger.info(""Updating environment %s..."" % self.namespace)
            self.install_sandboxes()
            self.instantiate_features()
            # We don't grab inputs, only on install
            # updates inputs are grabbed on demand
            # self.grab_inputs(reconfigure=reconfigure)
            if reconfigure:
                self.grab_inputs(reconfigure=True)
            else:
                self._copy_source_to_target()
            self._specialize(reconfigure=reconfigure)
            for feature in self.features.run_order:
                self.run_action(feature, 'sync')
            self.inject_environment_config()
            self._finalize()
        except Exception:
            self.logger.debug("""", exc_info=sys.exc_info())
            et, ei, tb = sys.exc_info()
            reraise(et, ei, tb)"
1383,"def remove(self):
        """""" remove the environment """"""
        try:
            self.phase = PHASE.REMOVE
            self.logger.info(""Removing environment %s..."" % self.namespace)
            self.instantiate_features()
            self._specialize()
            for feature in self.features.run_order:
                try:
                    self.run_action(feature, 'sync')
                except FormulaException:
                    # continue trying to remove any remaining features.
                    pass
            self.clear_all()
            self.directory.remove()
            self.injections.commit()
            if self.error_occured:
                self.logger.error(warning_template)
                self.logger.error(REMOVE_WARNING)
        except Exception:
            self.logger.debug("""", exc_info=sys.exc_info())
            et, ei, tb = sys.exc_info()
            reraise(et, ei, tb)"
1384,"def deactivate(self):
        """""" deactivate the environment """"""
        try:
            self.phase = PHASE.DEACTIVATE
            self.logger.info(""Deactivating environment %s..."" % self.namespace)
            self.directory.rewrite_config = False
            self.instantiate_features()
            self._specialize()
            for feature in self.features.run_order:
                self.logger.info(""Deactivating %s..."" % feature[0])
                self.run_action(feature, 'deactivate')
            self.clear_all()
            self._finalize()
        except Exception:
            self.logger.debug("""", exc_info=sys.exc_info())
            et, ei, tb = sys.exc_info()
            reraise(et, ei, tb)"
1385,"def validate(self):
        """""" Validate the target environment """"""
        self.phase = PHASE.VALIDATE
        self.logger.info(""Validating %s..."" % self.namespace)
        self.instantiate_features()
        context_dict = {}
        if self.target:
            for s in self.target.formula_sections():
                context_dict[""%s:root_dir"" % s] = self.directory.install_directory(s)
                context_dict['config:root_dir'] = self.directory.root_dir
                context_dict['config:node'] = system.NODE
                self.target.add_additional_context(context_dict)
        for feature in self.features.run_order:
            self.run_action(feature, 'validate', run_if_error=True)"
1386,"def clear_all(self):
        """""" clear all files that were to be injected """"""
        self.injections.clear_all()
        for config_file in CONFIG_FILES:
            self.injections.clear(os.path.join(""~"", config_file))"
1387,"def write_debug_log(self, file_path):
        """""" Write the debug log to a file """"""
        with open(file_path, ""wb+"") as fh:
            fh.write(system.get_system_info().encode('utf-8'))
            # writing to debug stream
            self._debug_stream.seek(0)
            fh.write(self._debug_stream.read().encode('utf-8'))
            fh.write(""The following errors occured:\n"".encode('utf-8'))
            for error in self._errors:
                fh.write((error + ""\n"").encode('utf-8'))
            for k, v in self._error_dict.items():
                if len(v) > 0:
                    fh.write((""Error(s) in %s with formula %s:\n"" % k).encode('utf-8'))
                    for error in v:
                        fh.write((error + ""\n"").encode('utf-8'))"
1388,"def write_manifest(self):
        """""" Write the manifest to the file """"""
        if os.path.exists(self.directory.manifest_path):
            self.main_manifest.write(open(self.directory.manifest_path, ""w+""))"
1389,"def message_failure(self):
        """""" return a failure message, if one exists """"""
        if not isinstance(self.main_manifest, Manifest):
            return None
        return self.main_manifest.get('config', 'message_failure', default=None)"
1390,"def warmup(self):
        """""" initialize variables necessary to perform a sprinter action """"""
        self.logger.debug(""Warming up..."")

        try:
            if not isinstance(self.source, Manifest) and self.source:
                self.source = load_manifest(self.source)
            if not isinstance(self.target, Manifest) and self.target:
                self.target = load_manifest(self.target)
            self.main_manifest = self.target or self.source
        except lib.BadCredentialsException:
            e = sys.exc_info()[1]
            self.logger.error(str(e))
            raise SprinterException(""Fatal error! Bad credentials to grab manifest!"")

        if not getattr(self, 'namespace', None):
            if self.target:
                self.namespace = self.target.namespace
            elif not self.namespace and self.source:
                self.namespace = self.source.namespace
            else:
                raise SprinterException(""No environment name has been specified!"")

        self.directory_root = self.custom_directory_root

        if not self.directory:
            if not self.directory_root:
                self.directory_root = os.path.join(self.root, self.namespace)

            self.directory = Directory(self.directory_root,
                                       shell_util_path=self.shell_util_path)

        if not self.injections:
            self.injections = Injections(wrapper=""%s_%s"" % (self.sprinter_namespace.upper(),
                                                            self.namespace),
                                         override=""SPRINTER_OVERRIDES"")
        if not self.global_injections:
            self.global_injections = Injections(wrapper=""%s"" % self.sprinter_namespace.upper() + ""GLOBALS"",
                                                override=""SPRINTER_OVERRIDES"")
        # append the bin, in the case sandboxes are necessary to
        # execute commands further down the sprinter lifecycle
        os.environ['PATH'] = self.directory.bin_path() + "":"" + os.environ['PATH']
        self.warmed_up = True"
1391,"def _inject_config_source(self, source_filename, files_to_inject):
        """"""
        Inject existing environmental config with namespace sourcing.
        Returns a tuple of the first file name and path found.
        """"""
        # src_path = os.path.join(self.directory.root_dir, source_filename)
        # src_exec = ""[ -r %s ] && . %s"" % (src_path, src_path)
        src_exec = ""[ -r {0} ] && . {0}"".format(os.path.join(self.directory.root_dir, source_filename))
        # The ridiculous construction above is necessary to avoid failing tests(!)

        for config_file in files_to_inject:
            config_path = os.path.expanduser(os.path.join(""~"", config_file))
            if os.path.exists(config_path):
                self.injections.inject(config_path, src_exec)
                break
        else:
            config_file = files_to_inject[0]
            config_path = os.path.expanduser(os.path.join(""~"", config_file))
            self.logger.info(""No config files found to source %s, creating ~/%s!"" % (source_filename, config_file))
            self.injections.inject(config_path, src_exec)

        return (config_file, config_path)"
1392,"def _finalize(self):
        """""" command to run at the end of sprinter's run """"""
        self.logger.info(""Finalizing..."")
        self.write_manifest()

        if self.directory.rewrite_config:
            # always ensure .rc is written (sourcing .env)
            self.directory.add_to_rc('')
            # prepend brew for global installs
            if system.is_osx() and self.main_manifest.is_affirmative('config', 'use_global_packagemanagers'):
                self.directory.add_to_env('__sprinter_prepend_path ""%s"" PATH' % '/usr/local/bin')
            self.directory.add_to_env('__sprinter_prepend_path ""%s"" PATH' % self.directory.bin_path())
            self.directory.add_to_env('__sprinter_prepend_path ""%s"" LIBRARY_PATH' % self.directory.lib_path())
            self.directory.add_to_env('__sprinter_prepend_path ""%s"" C_INCLUDE_PATH' % self.directory.include_path())
            self.directory.finalize()

        self.injections.commit()
        self.global_injections.commit()

        if not os.path.exists(os.path.join(self.root, "".global"")):
            self.logger.debug(""Global directory doesn't exist! creating..."")
            os.makedirs(os.path.join(self.root, "".global""))

        self.logger.debug(""Writing shell util file..."")
        with open(self.shell_util_path, 'w+') as fh:
            fh.write(shell_utils_template)

        if self.error_occured:
            raise SprinterException(""Error occured!"")

        if self.message_success():
            self.logger.info(self.message_success())

        self.logger.info(""Done!"")
        self.logger.info(""NOTE: Please remember to open new shells/terminals to use the modified environment"")"
1393,"def _build_logger(self, level=logging.INFO):
        """""" return a logger. if logger is none, generate a logger from stdout """"""
        self._debug_stream = StringIO()
        logger = logging.getLogger('sprinter')
        # stdout log
        out_hdlr = logging.StreamHandler(sys.stdout)
        out_hdlr.setLevel(level)
        logger.addHandler(out_hdlr)
        # debug log
        debug_hdlr = logging.StreamHandler(self._debug_stream)
        debug_hdlr.setFormatter(logging.Formatter('%(asctime)s %(message)s'))
        debug_hdlr.setLevel(logging.DEBUG)
        logger.addHandler(debug_hdlr)
        logger.setLevel(logging.DEBUG)
        return logger"
1394,"def run_action(self, feature, action,
                   run_if_error=False,
                   raise_exception=True):
        """""" Run an action, and log it's output in case of errors """"""
        if len(self._error_dict[feature]) > 0 and not run_if_error:
            return

        error = None
        instance = self.features[feature]
        try:
            getattr(instance, action)()
        # catch a generic exception within a feature
        except Exception as e:
            e = sys.exc_info()[1]
            self.logger.info(""An exception occurred with action %s in feature %s!"" %
                             (action, feature))
            self.logger.debug(""Exception"", exc_info=sys.exc_info())
            error = str(e)
            self.log_feature_error(feature, str(e))
        # any error in a feature should fail immediately - unless it occurred
        # from the remove() method in which case continue the rest of the
        # feature removal from there
        if error is not None and raise_exception:
            exception_msg = ""%s action failed for feature %s: %s"" % (action, feature, error)
            if self.phase == PHASE.REMOVE:
                raise FormulaException(exception_msg)
            else:
                raise SprinterException(exception_msg)
        return error"
1395,"def _specialize(self, reconfigure=False):
        """""" Add variables and specialize contexts """"""
        # add in the 'root_dir' directories to the context dictionaries
        for manifest in [self.source, self.target]:
            context_dict = {}
            if manifest:
                for s in manifest.formula_sections():
                    context_dict[""%s:root_dir"" % s] = self.directory.install_directory(s)
                    context_dict['config:root_dir'] = self.directory.root_dir
                    context_dict['config:node'] = system.NODE
                manifest.add_additional_context(context_dict)
        self._validate_manifest()
        for feature in self.features.run_order:
            if not reconfigure:
                self.run_action(feature, 'resolve')
            # if a target doesn't exist, no need to prompt.
            instance = self.features[feature]
            if instance.target:
                self.run_action(feature, 'prompt')"
1396,"def _copy_source_to_target(self):
        """""" copy source user configuration to target """"""
        if self.source and self.target:
            for k, v in self.source.items('config'):
                # always have source override target.
                self.target.set_input(k, v)"
1397,"def grab_inputs(self, reconfigure=False):
        """""" Resolve the source and target config section """"""
        self._copy_source_to_target()
        if self.target:
            self.target.grab_inputs(force=reconfigure)"
1398,"def connect(host, username, password, port=443, verify=False, debug=False):
    '''
    Connect to a vCenter via the API
    :param host: Hostname or IP of the vCenter
    :type host: str or unicode
    :param username: Username
    :type user: str or unicode
    :param password: Password
    :type user: str or unicode
    :param port: Port on which the vCenter API is running (default: 443)
    :type port: int
    :param verify: Whether to verify SSL certs upon connection (default: False)
    :type verify: bool
    :param debug: Debug option (default: False)
    :type debug: bool
    :return: Content
    :rtype: vim.ServiceInstanceContent
    '''
    context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
    if not verify:
        # Disable warnings about unsigned certificates
        context.verify_mode = ssl.CERT_NONE
        requests.packages.urllib3.disable_warnings()

    try:
        si = SmartConnect(
            host=host,
            user=username,
            pwd=password,
            port=port,
            sslContext=context
        )
        # Register auto disconnect
        atexit.register(Disconnect, si)
        # Return content
        return si.RetrieveContent()
    except IOError as e:
        print('I/O error({0}): {1}'.format(e.errno, e.strerror))
    except vmodl.MethodFault as e:
        print('Connection could not be established', file=sys.stderr)
        raise ConnectionError('Connection could not be established')
        print('Caught vmodl fault: ', e.msg, file=sys.stderr)
        if debug:
            traceback.print_exc()
    except Exception as e:
        print('Caught exception:', str(e), file=sys.stderr)
        if debug:
            traceback.print_exc()"
1399,"def parse(ignore_file='.gitignore', git_dir='.git', additional_files=(),
          global_=True, root_dir=None, defaults=True):
  """"""
  Collects a list of all ignore patterns configured in a local Git repository
  as specified in the Git documentation. See
  https://git-scm.com/docs/gitignore#_description

  The returned #IgnoreListCollection is guaranteed to contain at least one
  #IgnoreList with #IgnoreList.root pointing to the specified *root_dir* (which
  defaults to the parent directory of *git_dir*) as the first element.
  """"""

  result = IgnoreListCollection()

  if root_dir is None:
    if git_dir is None:
      raise ValueError(""root_dir or git_dir must be specified"")
    root_dir = os.path.dirname(os.path.abspath(git_dir))

  def parse(filename, root=None):
    if os.path.isfile(filename):
      if root is None:
        root = os.path.dirname(os.path.abspath(filename))
      with open(filename) as fp:
        result.parse(fp, root)

  result.append(IgnoreList(root_dir))
  if ignore_file is not None:
    parse(ignore_file)
  for filename in additional_files:
    parse(filename)
  if git_dir is not None:
    parse(os.path.join(git_dir, 'info', 'exclude'), root_dir)
  if global_:
    # TODO: Read the core.excludeFiles configuration value.
    parse(os.path.expanduser('~/.gitignore'), root_dir)
  if defaults:
    result.append(get_defaults(root_dir))
  return result"
1400,"def walk(patterns, dirname):
  """"""
  Like #os.walk(), but filters the files and directories that are excluded by
  the specified *patterns*.

  # Arguments
  patterns (IgnoreList, IgnoreListCollection): Can also be any object that
    implements the #IgnoreList.match() interface.
  dirname (str): The directory to walk.
  """"""

  join = os.path.join
  for root, dirs, files in os.walk(dirname, topdown=True):
    dirs[:] = [d for d in dirs if patterns.match(join(root, d), True) != MATCH_IGNORE]
    files[:] = [f for f in files if patterns.match(join(root, f), False) != MATCH_IGNORE]
    yield root, dirs, files"
1401,"def parse(self, lines):
    """"""
    Parses the `.gitignore` file represented by the *lines*.
    """"""

    if isinstance(lines, str):
      lines = lines.split('\n')
    sub = _re.sub
    for line in lines:
      if line.endswith('\n'):
        line = line[:-1]
      line = line.lstrip()
      if not line.startswith('#'):
        invert = False
        if line.startswith('!'):
          line = line[1:]
          invert = True
        while line.endswith(' ') and line[-2:] != '\ ':
          line = line[:-1]
        line = sub(r'\\([!# ])', r'\1', line)
        if '/' in line and not line.startswith('/'):
          # Patterns with a slash can only be matched absolute.
          line = '/' + line
        self.patterns.append(Pattern(line, invert))"
1402,"def match(self, filename, isdir):
    """"""
    Match the specified *filename*. If *isdir* is False, directory-only
    patterns will be ignored.

    Returns one of

    - #MATCH_DEFAULT
    - #MATCH_IGNORE
    - #MATCH_INCLUDE
    """"""

    fnmatch = _fnmatch.fnmatch
    ignored = False
    filename = self.convert_path(filename)
    basename = os.path.basename(filename)

    for pattern in self.patterns:
      if pattern.dir_only and not isdir:
        continue
      if (not ignored or pattern.invert) and pattern.match(filename):
        if pattern.invert: # This file is definitely NOT ignored, no matter what other patterns match
          return MATCH_INCLUDE
        ignored = True
    if ignored:
      return MATCH_IGNORE
    else:
      return MATCH_DEFAULT"
1403,"def parse(self, lines, root):
    """"""
    Shortcut for #IgnoreList.parse() and #IgnoreListCollection.append().
    """"""

    lst = IgnoreList(root)
    lst.parse(lines)
    self.append(lst)"
1404,"def match(self, filename, isdir=False):
    """"""
    Match all the #IgnoreList#s` in this collection. Returns one of

    - #MATCH_DEFAULT
    - #MATCH_IGNORE
    - #MATCH_INCLUDE
    """"""

    for lst in self:
      result = lst.match(filename, isdir)
      if result != MATCH_DEFAULT:
        return result
    return MATCH_DEFAULT"
1405,"def reply(self,message,message_type):
        """"""
        Send a reply message of the given type
        
        Args:
            - message: the message to publish
            - message_type: the type of message being sent
        """"""
        if message_type == MULTIPART:
            raise Exception(""Unsupported reply type"")
            
        super(Replier,self).send(message,message_type)"
1406,"def parse_domain(url):
    """""" parse the domain from the url """"""
    domain_match = lib.DOMAIN_REGEX.match(url)
    if domain_match:
        return domain_match.group()"
1407,"def get_credentials(options, environment):
    """""" Get credentials or prompt for them from options """"""
    if options['--username'] or options['--auth']:
        if not options['--username']:
            options['<username>'] = lib.prompt(""Please enter the username for %s..."" % environment)
        if not options['--password']:
            options['<password>'] = lib.prompt(""Please enter the password for %s..."" % environment, secret=True)
    return options"
1408,"def check_type(self, value):
    """"""
    Raises a #TypeError if *value* is not an instance of the field's #type.
    """"""

    if self.null and value is None:
      return
    if self.type is not None and not isinstance(value, self.type):
      msg = '{0!r} expected type {1}'
      raise TypeError(msg.format(self.full_name, self.type.__name__))"
1409,"def get_default(self):
    """"""
    Return the default value of the field. Returns either #default, the return
    value of #default_factory or raises a #RuntimeError if the field has no
    default value.
    """"""

    if self.default is not NotImplemented:
      return self.default
    elif self.default_factory is not None:
      return self.default_factory()
    else:
      raise RuntimeError('{0!r} has no default value'.format(self.full_name))"
1410,"def full_name(self):
    """"""
    The full name of the field. This is the field's entities name
    concatenated with the field's name. If the field is unnamed or
    not bound to an entity, the result respectively contains None.
    """"""

    entity = self.entity.__name__ if self.entity is not None else None
    name = self.name if self.name is not None else None
    if entity and name:
      return entity + '.' + name
    elif entity:
      return entity + '.<unnamed>'
    elif name:
      return '<unbound>.' + name
    else:
      return '<unbound>.<unnamed>'"
1411,"def type_name(self):
    """"""
    Returns the full type identifier of the field.
    """"""

    res = self.type.__name__
    if self.type.__module__ not in ('__builtin__', 'builtins'):
      res = self.type.__module__ + '.' + res
    return res"
1412,"def get_subclass_from_module(module, parent_class):
    """"""
    Get a subclass of parent_class from the module at module

    get_subclass_from_module performs reflection to find the first class that
    extends the parent_class in the module path, and returns it.
    """"""
    try:
        r = __recursive_import(module)
        member_dict = dict(inspect.getmembers(r))
        sprinter_class = parent_class
        for v in member_dict.values():
            if inspect.isclass(v) and issubclass(v, parent_class) and v != parent_class:
                if sprinter_class is parent_class:
                    sprinter_class = v
        if sprinter_class is None:
            raise SprinterException(""No subclass %s that extends %s exists in classpath!"" % (module, str(parent_class)))
        return sprinter_class
    except ImportError:
        e = sys.exc_info()[1]
        raise e"
1413,"def __recursive_import(module_name):
    """"""
    Recursively looks for and imports the names, returning the
    module desired

    >>> __recursive_import(""sprinter.formula.unpack"") # doctest: +ELLIPSIS
    <module 'unpack' from '...'>

    currently module with relative imports don't work.
    """"""
    names = module_name.split(""."")
    path = None
    module = None
    while len(names) > 0:
        if module:
            path = module.__path__
        name = names.pop(0)
        (module_file, pathname, description) = imp.find_module(name, path)
        module = imp.load_module(name, module_file, pathname, description)
    return module"
1414,"def err_exit(msg, rc=1):
    """"""Print msg to stderr and exit with rc.
    """"""
    print(msg, file=sys.stderr)
    sys.exit(rc)"
1415,"def popen(self, cmd):
        """"""Execute an external command and return (rc, output).
        """"""
        process = Popen(cmd, shell=True, stdout=PIPE, env=self.env)
        stdoutdata, stderrdata = process.communicate()
        return process.returncode, stdoutdata"
1416,"def read_file(self, infile):
        """"""Read a reST file into a string.
        """"""
        try:
            with open(infile, 'rt') as file:
                return file.read()
        except UnicodeDecodeError as e:
            err_exit('Error reading %s: %s' % (infile, e))
        except (IOError, OSError) as e:
            err_exit('Error reading %s: %s' % (infile, e.strerror or e))"
1417,"def write_file(self, html, outfile):
        """"""Write an HTML string to a file.
        """"""
        try:
            with open(outfile, 'wt') as file:
                file.write(html)
        except (IOError, OSError) as e:
            err_exit('Error writing %s: %s' % (outfile, e.strerror or e))"
1418,"def convert_string(self, rest):
        """"""Convert a reST string to an HTML string.
        """"""
        try:
            html = publish_string(rest, writer_name='html')
        except SystemExit as e:
            err_exit('HTML conversion failed with error: %s' % e.code)
        else:
            if sys.version_info[0] >= 3:
                return html.decode('utf-8')
            return html"
1419,"def apply_styles(self, html, styles):
        """"""Insert style information into the HTML string.
        """"""
        index = html.find('</head>')
        if index >= 0:
            return ''.join((html[:index], styles, html[index:]))
        return html"
1420,"def publish_string(self, rest, outfile, styles=''):
        """"""Render a reST string as HTML.
        """"""
        html = self.convert_string(rest)
        html = self.strip_xml_header(html)
        html = self.apply_styles(html, styles)
        self.write_file(html, outfile)
        return outfile"
1421,"def publish_file(self, infile, outfile, styles=''):
        """"""Render a reST file as HTML.
        """"""
        rest = self.read_file(infile)
        return self.publish_string(rest, outfile, styles)"
1422,"def upgrade(self):
        """"""Upgrade the config file.
        """"""
        warn('Upgrading ' + self.filename)
        if self.backup_config(self.filename):
            return self.write_default_config(self.filename)
        return False"
1423,"def backup_config(self, filename):
        """"""Backup the current config file.
        """"""
        backup_name = filename + '-' + self.version
        warn('Moving current configuration to ' + backup_name)
        try:
            shutil.copy2(filename, backup_name)
            return True
        except (IOError, OSError) as e:
            print('Error copying %s: %s' % (filename, e.strerror or e), file=sys.stderr)
            return False"
1424,"def write_default_config(self, filename):
        """"""Write the default config file.
        """"""
        try:
            with open(filename, 'wt') as file:
                file.write(DEFAULT_CONFIG)
            return True
        except (IOError, OSError) as e:
            print('Error writing %s: %s' % (filename, e.strerror or e), file=sys.stderr)
            return False"
1425,"def set_defaults(self, config_file):
        """"""Set defaults.
        """"""
        self.defaults = Defaults(config_file)
        self.python = Python()
        self.setuptools = Setuptools()
        self.docutils = Docutils()
        self.styles = self.defaults.styles
        self.browser = self.defaults.browser
        self.list = False"
1426,"def reset_defaults(self, config_file):
        """"""Reset defaults.
        """"""
        if not exists(config_file):
            err_exit('No such file: %(config_file)s' % locals())
        if not isfile(config_file):
            err_exit('Not a file: %(config_file)s' % locals())
        if not os.access(config_file, os.R_OK):
            err_exit('File cannot be read: %(config_file)s' % locals())
        self.set_defaults(config_file)"
1427,"def write_defaults(self):
        """"""Create default config file and reload.
        """"""
        self.defaults.write()
        self.reset_defaults(self.defaults.filename)"
1428,"def upgrade_defaults(self):
        """"""Upgrade config file and reload.
        """"""
        self.defaults.upgrade()
        self.reset_defaults(self.defaults.filename)"
1429,"def parse_options(self, args, depth=0):
        """"""Parse command line options.
        """"""
        style_names = tuple(self.defaults.known_styles)
        style_opts = tuple('--'+x for x in style_names)

        try:
            options, remaining_args = getopt.gnu_getopt(args, 'b:c:hls:v',
                ('help', 'style=', 'version', 'list-styles', 'browser=',
                 'config-file=') + style_names)
        except getopt.GetoptError as e:
            err_exit('viewdoc: %s\n%s' % (e.msg, USAGE))

        for name, value in options:
            if name in ('-s', '--style'):
                self.styles = self.defaults.known_styles.get(value, '')
            elif name in style_opts:
                self.styles = self.defaults.known_styles.get(name[2:], '')
            elif name in ('-b', '--browser'):
                self.browser = value
            elif name in ('-l', '--list-styles'):
                self.list = True
            elif name in ('-h', '--help'):
                msg_exit(HELP)
            elif name in ('-v', '--version'):
                msg_exit(VERSION)
            elif name in ('-c', '--config-file') and depth == 0:
                self.reset_defaults(expanduser(value))
                return self.parse_options(args, depth+1)

        if len(remaining_args) > 1:
            err_exit('viewdoc: too many arguments\n%s' % USAGE)

        if not isfile(self.defaults.filename) and depth == 0:
            self.write_defaults()
            return self.parse_options(args, depth+1)

        if self.defaults.version < CONFIG_VERSION and depth == 0:
            self.upgrade_defaults()
            return self.parse_options(args, depth+1)

        if self.list:
            self.list_styles()

        return remaining_args"
1430,"def list_styles(self):
        """"""Print available styles and exit.
        """"""
        known = sorted(self.defaults.known_styles)
        if not known:
            err_exit('No styles', 0)
        for style in known:
            if style == self.defaults.default_style:
                print(style, '(default)')
            else:
                print(style)
        sys.exit(0)"
1431,"def render_file(self, filename):
        """"""Convert a reST file to HTML.
        """"""
        dirname, basename = split(filename)
        with changedir(dirname):
            infile = abspath(basename)
            outfile = abspath('.%s.html' % basename)
            self.docutils.publish_file(infile, outfile, self.styles)
            return outfile"
1432,"def render_long_description(self, dirname):
        """"""Convert a package's long description to HTML.
        """"""
        with changedir(dirname):
            self.setuptools.check_valid_package()
            long_description = self.setuptools.get_long_description()
            outfile = abspath('.long-description.html')
            self.docutils.publish_string(long_description, outfile, self.styles)
            return outfile"
1433,"def open_in_browser(self, outfile):
        """"""Open the given HTML file in a browser.
        """"""
        if self.browser == 'default':
            webbrowser.open('file://%s' % outfile)
        else:
            browser = webbrowser.get(self.browser)
            browser.open('file://%s' % outfile)"
1434,"def run(self):
        """"""Render and display Python package documentation.
        """"""
        os.environ['JARN_RUN'] = '1'
        self.python.check_valid_python()

        args = self.parse_options(self.args)
        if args:
            arg = args[0]
        else:
            arg = os.curdir
        if arg:
            arg = expanduser(arg)

        if isfile(arg):
            outfile = self.render_file(arg)
        elif isdir(arg):
            outfile = self.render_long_description(arg)
        else:
            err_exit('No such file or directory: %s' % arg)

        self.open_in_browser(outfile)"
1435,"def preprocess_cell(
        self, cell: ""NotebookNode"", resources: dict, cell_index: int
    ) -> Tuple[""NotebookNode"", dict]:
        """"""Apply a transformation on each cell.

        Parameters
        ----------
        cell : NotebookNode cell
            Notebook cell being processed
        resources : dictionary
            Additional resources used in the conversion process.  Allows
            preprocessors to pass variables into the Jinja engine.
        cell_index : int
            Index of the cell being processed (see base.py)

        """"""
        # Get files directory if it has been specified
        output_files_dir = resources.get(""output_files_dir"", None)

        # Make sure outputs key exists
        if not isinstance(resources[""outputs""], dict):
            resources[""outputs""] = {}

        # Loop through all of the attachments in the cell
        for name, attach in cell.get(""attachments"", {}).items():
            orig_name = name
            name = re.sub(r""%[\w\d][\w\d]"", ""-"", name)
            for mime, data in attach.items():
                if mime not in self.extract_output_types:
                    continue

                # Binary files are base64-encoded, SVG is already XML
                if mime in {""image/png"", ""image/jpeg"", ""application/pdf""}:
                    # data is b64-encoded as text (str, unicode),
                    # we want the original bytes
                    data = a2b_base64(data)
                elif sys.platform == ""win32"":
                    data = data.replace(""\n"", ""\r\n"").encode(""UTF-8"")
                else:
                    data = data.encode(""UTF-8"")

                filename = self.output_filename_template.format(
                    cell_index=cell_index,
                    name=name,
                    unique_key=resources.get(""unique_key"", """"),
                )

                if output_files_dir is not None:
                    filename = os.path.join(output_files_dir, filename)

                if name.endswith("".gif"") and mime == ""image/png"":
                    filename = filename.replace("".gif"", "".png"")

                # In the resources, make the figure available via
                #   resources['outputs']['filename'] = data
                resources[""outputs""][filename] = data

                # now we need to change the cell source so that it links to the
                # filename instead of `attachment:`
                attach_str = ""attachment:"" + orig_name
                if attach_str in cell.source:
                    cell.source = cell.source.replace(attach_str, filename)

        return cell, resources"
1436,"def combine_pdf_as_bytes(pdfs: List[BytesIO]) -> bytes:
    """"""Combine PDFs and return a byte-string with the result.

    Arguments
    ---------
    pdfs
        A list of BytesIO representations of PDFs

    """"""
    writer = PdfWriter()
    for pdf in pdfs:
        writer.addpages(PdfReader(pdf).pages)
    bio = BytesIO()
    writer.write(bio)
    bio.seek(0)
    output = bio.read()
    bio.close()
    return output"
1437,"def split(self, granularity_after_split, exclude_partial=True):
        """"""
        Split a period into a given granularity. Optionally include partial
        periods at the start and end of the period.
        """"""

        if granularity_after_split == Granularity.DAY:
            return self.get_days()

        elif granularity_after_split == Granularity.WEEK:
            return self.get_weeks(exclude_partial)

        elif granularity_after_split == Granularity.MONTH:
            return self.get_months(exclude_partial)

        elif granularity_after_split == Granularity.QUARTER:
            return self.get_quarters(exclude_partial)

        elif granularity_after_split == Granularity.HALF_YEAR:
            return self.get_half_years(exclude_partial)

        elif granularity_after_split == Granularity.YEAR:
            return self.get_years(exclude_partial)

        else:
            raise Exception(""Invalid granularity: %s"" % granularity_after_split)"
1438,"def fit_fb_calibration(df, calibration):
    '''
    Fit feedback calibration data to solve for values of `C_fb[:]` and
    `R_fb[:]`.

    Returns a `pandas.DataFrame` indexed by the feedback resistor/capacitance
    index, and with the following columns:
     - Model: Either with parasitic capacitance term or not.
     - N: Number of samples used for fit.
     - F: F-value
     - p-value: p-value from Chi squared test.
     - R_fb: Feedback resistor value based on fit.
     - R-CI %: Confidence interval for feedback resistor value.
     - C_fb: Feedback capacitor value based on fit (0 if no-capacitance model
       is used).
     - C-CI %: Confidence interval for feedback capacitance value.

    __N.B.__ This function does not actually _update_ the calibration, it only
    performs the fit.
    See `apply_calibration`.
    '''
    # Set initial guesses for the feedback parameters.
    R_fb = pd.Series([2e2, 2e3, 2e4, 2e5, 2e6])
    C_fb = pd.Series(len(calibration.C_fb) * [50e-12])

    # Error function.
    def error(p0, df, calibration):
        # Impedance of the reference resistor on the HV attenuator circuit.
        Z = 10e6
        R_fb = p0[0]

        # If the parameter vector only contains one variable, the capacitance
        # is zero
        if len(p0) == 2:
            C_fb = p0[1]
        else:
            C_fb = 0

        R_hv = calibration.R_hv[df.hv_resistor.values]
        C_hv = calibration.C_hv[df.hv_resistor.values]

        # Solve feedback transfer function for the actuation voltage, _(i.e.,
        # `V1`)_, based on the high-voltage measurements.
        # Note that the transfer function definition depends on the hardware
        # version.
        V_actuation = compute_from_transfer_function(calibration.hw_version
                                                     .major, 'V1', V2=df.V_hv,
                                                     R1=Z, R2=R_hv, C2=C_hv,
                                                     f=df.frequency)

        # Solve feedback transfer function for the expected impedance feedback
        # voltage, _(i.e., `V2`)_, based on the actuation voltage, the proposed
        # values for `R2` and `C2`, and the reported `C1` value from the
        # feedback measurements.
        # Note that the transfer function definition depends on the hardware
        # version.
        # __NB__ If we do not specify a value for `R1`, a symbolic value of
        # infinity is used.  However, in this case, we have `R1` in both the
        # numerator and denominator.  The result is a value of zero returned
        # regardless of the values of the other arguments.  We avoid this issue
        # by specifying a *very large* value for `R1`.
        # TODO Update comment if this works...
        V_impedance = compute_from_transfer_function(calibration.hw_version
                                                     .major, 'V2',
                                                     V1=V_actuation,
                                                     C1=df.test_capacitor,
                                                     R2=R_fb, C2=C_fb,
                                                     f=df.frequency)
        return df.V_fb - V_impedance

    # Perform a nonlinear least-squares fit of the data.
    def fit_model(p0, df, calibration):
        p1, cov_x, infodict, mesg, ier = scipy.optimize.leastsq(
            error, p0, args=(df, calibration), full_output=True)
        p1 = np.abs(p1)
        E = error(p1, df, calibration)
        return p1, E, cov_x

    CI = []

    feedback_records = []
    # Fit feedback parameters for each feedback resistor.
    for i in range(len(calibration.R_fb)):
        # Only include data points for the given feedback resistor (and where
        # `hv_resistor` is a valid index).
        df_i = df.loc[(df.fb_resistor == i)].dropna()

        if df_i.shape[0] < 2:
            CI.append([0, 0])
            continue

        # Fit the data assuming no parasitic capacitance (model 1).
        p0_1 = [R_fb[i]]
        p1_1, E_1, cov_x_1 = fit_model(p0_1, df_i, calibration)
        df_1 = (len(E_1) - len(p0_1))
        chi2_1 = np.sum(E_1 ** 2)
        chi2r_1 = chi2_1 / (df_1 - 1)

        # fit the data including parasitic capacitance (model 2)
        p0_2 = [R_fb[i], C_fb[i]]
        p1_2, E_2, cov_x_2 = fit_model(p0_2, df_i, calibration)
        df_2 = (len(E_2) - len(p0_2))
        chi2_2 = np.sum(E_2 ** 2)
        chi2r_2 = chi2_2 / (df_2 - 1)

        # do an F-test to compare the models
        F = (chi2_1 - chi2_2) / chi2r_2
        p_value = scipy.stats.f.cdf(F, 1, df_2-1)

        # if the p_value is > 0.95, we assume that the capacitive term is
        # necessary
        if p_value > .95 and cov_x_2 is not None:
            model = 'w/Parasitic C'
            chi2r = chi2r_2
            R_fb_i = p1_2[0]
            C_fb_i = p1_2[1]
            CI.append((100 * np.sqrt(chi2r_2 * np.diag(cov_x_2)) / p1_2))
        else:  # otherwise, set the capacitance to zero
            model = 'w/o Parasitic C'
            chi2r = chi2r_2
            R_fb_i = p1_1[0]
            C_fb_i = 0
            if cov_x_1 is None:
                cov_x_1 = [0]
            CI.append((100 * np.sqrt(chi2r_1 * np.diag(cov_x_1)) /
                       p1_1).tolist() + [0])
        feedback_records.append([int(i), model, df_i.shape[0], R_fb_i, CI[i][0],
                                 C_fb_i, CI[i][1], F, (1e3 * np.sqrt(chi2r)),
                                 p_value])

    calibration_df = pd.DataFrame(feedback_records,
                                  columns=['fb_resistor', 'Model', 'N', 'R_fb', 'R-CI %',
                                           'C_fb', 'C-CI %', 'F',
                                           'sqrt(Chi2r*sigma^2)', 'p-value'])
    return calibration_df"
1439,"def apply_calibration(df, calibration_df, calibration):
    '''
    Apply calibration values from `fit_fb_calibration` result to `calibration`
    object.
    '''
    from dmf_control_board_firmware import FeedbackResults

    for i, (fb_resistor, R_fb, C_fb) in calibration_df[['fb_resistor', 'R_fb', 'C_fb']].iterrows():
        calibration.R_fb[int(fb_resistor)] = R_fb
        calibration.C_fb[int(fb_resistor)] = C_fb

    cleaned_df = df.dropna()
    grouped = cleaned_df.groupby(['frequency', 'test_capacitor', 'repeat_index'])

    for (f, channel, repeat_index), group in grouped:
        r = FeedbackResults(group.V_actuation.iloc[0], f, 5.0,
                            group.V_hv.values, group.hv_resistor.values,
                            group.V_fb.values, group.fb_resistor.values,
                            calibration)
        # Update the measured capacitance values based on the updated
        # calibration model.
        df.loc[group.index, 'C'] = r.capacitance()"
1440,"def config_dict(config):
    """"""
    Given a Sphinx config object, return a dictionary of config
    values.
    """"""
    return dict(
        (key, getattr(config, key))
        for key in config.values
    )"
1441,"def from_defn(cls, defn):
        ""Return the first Repl subclass that works with this""
        instances = (subcl(defn) for subcl in cls.__subclasses__())
        return next(filter(None, instances))"
1442,"def from_definition(cls, defn, names={}):
        """"""
        A definition may contain the following members:

        - using: a dictionary of variables available for substitution
        - replace: a list of replacement definitions.
        """"""
        repls = map(Repl.from_defn, defn.get('replace', []))
        self = cls(repls)
        vars(self).update(names)
        vars(self).update(defn.get('using', {}))
        return self"
1443,"def data(self, index, role=Qt.DisplayRole):
        """"""Cell content""""""
        if not index.isValid():
            return None
        if role == Qt.DisplayRole or role == Qt.EditRole:
            return ' '
        if role == Qt.BackgroundColorRole:
            color = self.color_da[index.row(), index.column()].values
            return QtGui.QColor.fromRgbF(*color)
        return None"
1444,"def headerData(self, section, orientation, role=Qt.DisplayRole):
        """"""Set header data""""""
        if role != Qt.DisplayRole:
            return None
        if orientation == Qt.Vertical:
            return six.text_type(self.color_da.cmap[section].values)
        return super(ColormapModel, self).headerData(section, orientation,
                                                     role)"
1445,"def get_colormap(cls, names=[], N=10, *args, **kwargs):
        """"""Open a :class:`ColormapDialog` and get a colormap

        Parameters
        ----------
        %(ColormapModel.parameters)s

        Other Parameters
        ----------------
        ``*args, **kwargs``
            Anything else that is passed to the ColormapDialog

        Returns
        -------
        str or matplotlib.colors.Colormap
            Either the name of a standard colormap available via
            :func:`psy_simple.colors.get_cmap` or a colormap
        """"""
        names = safe_list(names)
        obj = cls(names, N, *args, **kwargs)
        vbox = obj.layout()
        buttons = QDialogButtonBox(
            QDialogButtonBox.Ok | QDialogButtonBox.Cancel, parent=obj)
        buttons.button(QDialogButtonBox.Ok).setEnabled(False)
        vbox.addWidget(buttons)
        buttons.accepted.connect(obj.accept)
        buttons.rejected.connect(obj.reject)

        obj.table.selectionModel().selectionChanged.connect(
            lambda indices: buttons.button(QDialogButtonBox.Ok).setEnabled(
                bool(indices)))
        accepted = obj.exec_()
        if accepted:
            return obj.table.chosen_colormap"
1446,"def show_colormap(cls, names=[], N=10, show=True, *args, **kwargs):
        """"""Show a colormap dialog

        Parameters
        ----------
        %(show_colormaps.parameters.no_use_qt)s""""""
        names = safe_list(names)
        obj = cls(names, N, *args, **kwargs)
        vbox = obj.layout()
        buttons = QDialogButtonBox(QDialogButtonBox.Close, parent=obj)
        buttons.rejected.connect(obj.close)
        vbox.addWidget(buttons)
        if show:
            obj.show()
        return obj"
1447,"def cmd_list(args):
    """"""List all element in pen""""""
    for penlist in penStore.data:
        puts(penlist + "" ("" + str(len(penStore.data[penlist])) + "")"")"
1448,"def cmd_all(args):
    """"""List everything recursively""""""
    for penlist in penStore.data:
        puts(penlist)
        with indent(4, '  -'):
            for penfile in penStore.data[penlist]:
                puts(penfile)"
1449,"def cmd_create(args):
    """"""Creates a list""""""
    name = args.get(0)
    if name:
        penStore.createList(name)
    else:
        puts(""not valid"")"
1450,"def cmd_touch_note(args):
    """"""Create a note""""""
    major = args.get(0)
    minor = args.get(1)
    if major in penStore.data:
        if minor is None:  # show items in list
            for note in penStore.data[major]:
                puts(note)
        elif minor in penStore.data[major]:
            penStore.openNote(major, minor)
        else:
            penStore.createNote(major, minor)
            penStore.openNote(major, minor)
    else:
        puts(""No list of that name."")"
1451,"def cmd_delete(args):
    """"""Deletes a node""""""
    major = args.get(0)
    minor = args.get(1)
    if major is not None:
        if major in penStore.data:
            if minor is None:
                if len(penStore.data[major]) > 0:
                    if raw_input(""are you sure (y/n)? "") not in ['y', 'Y', 'yes', 'Yes']:
                        return ExitStatus.ABORT
                penStore.deleteList(major)
                puts(""list deleted"")
            elif minor in penStore.data[major]:
                penStore.deleteNote(major, minor)
                puts(""note deleted"")
            else:
                puts(""no such note, sorry! (%s)"" % minor)
        else:
            puts(""no such list, sorry! (%s)"" % major)
    else:
        print """"""
- pen: delete help ------------------------------------------------------------

pen delete <list>                 deletes list and all of its notes
pen delete <list> <note>          deletes note
"""""""
1452,"def restclient_admin_required(view_func):
    """"""
    View decorator that checks whether the user is permitted to view proxy
    restclients. Calls login_required in case the user is not authenticated.
    """"""
    def wrapper(request, *args, **kwargs):
        template = 'access_denied.html'
        if hasattr(settings, 'RESTCLIENTS_ADMIN_AUTH_MODULE'):
            auth_func = import_string(settings.RESTCLIENTS_ADMIN_AUTH_MODULE)
        else:
            context = {'error_msg': (
                ""Your application must define an authorization function as ""
                ""RESTCLIENTS_ADMIN_AUTH_MODULE in settings.py."")}
            return render(request, template, context=context, status=401)

        service = args[0] if len(args) > 0 else None
        url = args[1] if len(args) > 1 else None
        if auth_func(request, service, url):
            return view_func(request, *args, **kwargs)

        return render(request, template, status=401)

    return login_required(function=wrapper)"
1453,"def open_file(filepath):
    """"""
    Open file with the default system app.
    Copied from https://stackoverflow.com/a/435669/1224456
    """"""
    if sys.platform.startswith('darwin'):
        subprocess.Popen(('open', filepath))
    elif os.name == 'nt':
        os.startfile(filepath)
    elif os.name == 'posix':
        subprocess.Popen(('xdg-open', filepath))"
1454,"def destination_heuristic(data):
    """"""
    A heuristic to get the folder with all other files from bib, using majority
    vote.
    """"""
    counter = collections.Counter()
    for entry in data:
        file_field = entry['fields'].get('file')
        if not file_field:
            continue
        path = os.path.dirname(file_field)
        counter[path] += 1

    if not counter:  # No paths found
        raise click.ClickException(
            'Path finding heuristics failed: no paths in the database'
        )

    # Find the paths that appears most often
    sorted_paths = sorted(counter, reverse=True)
    groupby = itertools.groupby(sorted_paths, key=len)
    _, group = next(groupby)

    # We know that there's at least one candidate. Make sure it's
    # the only one
    candidate = next(group)
    try:
        next(group)
    except StopIteration:
        return candidate
    else:
        raise click.ClickException(
            'Path finding heuristics failed: '
            'there are multiple equally valid paths in the database'
        )"
1455,"def remove_entry(data, entry):
    '''
    Remove an entry in place.
    '''
    file_field = entry['fields'].get('file')
    if file_field:
        try:
            os.remove(file_field)
        except IOError:
            click.echo('This entry\'s file was missing')

    data.remove(entry)"
1456,"def string_to_basename(s):
    '''
    Converts to lowercase, removes non-alpha characters,
    and converts spaces to hyphens.
    '''
    s = s.strip().lower()
    s = re.sub(r'[^\w\s-]', '', s)
    return re.sub(r'[\s-]+', '-', s)"
1457,"def editor(*args, **kwargs):
    '''
    Wrapper for `click.edit` that raises an error when None is returned.
    '''
    result = click.edit(*args, **kwargs)
    if result is None:
        msg = 'Editor exited without saving, command aborted'
        raise click.ClickException(msg)
    return result"
1458,"def terms(self, facet_name, field, size=10, order=None, all_terms=False, exclude=[], regex='', regex_flags=''):
        '''
        Allow to specify field facets that return the N most frequent terms.

        Ordering: Allow to control the ordering of the terms facets, to be ordered by count, term, reverse_count or reverse_term. The default is count.
        All Terms: Allow to get all the terms in the terms facet, ones that do not match a hit, will have a count of 0. Note, this should not be used with fields that have many terms.
        Excluding Terms: It is possible to specify a set of terms that should be excluded from the terms facet request result.
        Regex Patterns: The terms API allows to define regex expression that will control which terms will be included in the faceted list.
        '''

        self[facet_name] = dict(terms=dict(field=field, size=size))
        if order:
            self[facet_name][terms]['order'] = order
        if all_terms:
            self[facet_name][terms]['all_terms'] = True
        if exclude:
            self[facet_name][terms]['exclude'] = exclude
        if regex:
            self[facet_name][terms]['regex'] = regex
        if regex_flags:
            self[facet_name][terms]['regex_flags'] = regex_flags

        return self"
1459,"def range(self, facet_name, field, ranges=[]):
        '''
        Range facet allow to specify a set of ranges and get both the number of docs (count) that fall within each range, and aggregated data either based on the field, or using another field.
        http://www.elasticsearch.org/guide/reference/api/search/facets/range-facet.html

        > ElasticFacet().range('range1', 'field_name', [ slice(50), slice(20,70), slice(50,-1) ])
        {
          ""range1"" : {
            ""range"" : {
                ""field"" : ""field_name"",
                ""ranges"" : [
                    { ""to"" : 50 },
                    { ""from"" : 20, ""to"" : 70 },
                    { ""from"" : 70, ""to"" : 120 },
                    { ""from"" : 150 }
                ]
            }
           }
        }
        '''

        self[facet_name] = {'range': {'field': field, 'ranges': []}}
        for s in ranges:
            if not isinstance(s, slice):
                continue
            entry = dict()
            if s.start:
                entry['from'] = s.start
            if s.stop != -1:
                entry['to'] = s.stop
            self[facet_name]['range']['ranges'].append(entry)

        return self"
1460,"def parse_gpx(gpx_element, gpxns=None):
    """"""Parse a GPX file into a GpxModel.

    Args:
        gpx_element: The root <gpx> element of an XML document containing a
            version attribute. GPX versions 1.0 and 1.1 are supported.

        gpxns: The XML namespace for GPX in Clarke notation (i.e. delimited
             by curly braces).

    Returns:
        A GpxModel representing the data from the supplies xml.

    Raises:
        ValueError: The supplied XML could not be parsed as GPX.
    """"""
    gpxns = gpxns if gpxns is not None else determine_gpx_namespace(gpx_element)

    if gpx_element.tag != gpxns+'gpx':
        raise ValueError(""No gpx root element"")

    version = gpx_element.attrib['version']

    if version == '1.0':
        return parse_gpx_1_0(gpx_element, gpxns=gpxns)
    elif version == '1.1':
        return parse_gpx_1_1(gpx_element, gpxns=gpxns)
    else:
        raise ValueError(""Cannot parse GPX version {0}"".format(version))"
1461,"def backup_file(filename):
    """""" create a backup of the file desired """"""
    if not os.path.exists(filename):
        return

    BACKUP_SUFFIX = "".sprinter.bak""

    backup_filename = filename + BACKUP_SUFFIX
    shutil.copyfile(filename, backup_filename)"
1462,"def inject(self, filename, content):
        """""" add the injection content to the dictionary """"""
        # ensure content always has one trailing newline
        content = _unicode(content).rstrip() + ""\n""
        if filename not in self.inject_dict:
            self.inject_dict[filename] = """"
        self.inject_dict[filename] += content"
1463,"def commit(self):
        """""" commit the injections desired, overwriting any previous injections in the file. """"""
        self.logger.debug(""Starting injections..."")
        self.logger.debug(""Injections dict is:"")
        self.logger.debug(self.inject_dict)
        self.logger.debug(""Clear list is:"")
        self.logger.debug(self.clear_set)
        for filename, content in self.inject_dict.items():
            content = _unicode(content)
            self.logger.debug(""Injecting values into %s..."" % filename)
            self.destructive_inject(filename, content)
        for filename in self.clear_set:
            self.logger.debug(""Clearing injection from %s..."" % filename)
            self.destructive_clear(filename)"
1464,"def injected(self, filename):
        """""" Return true if the file has already been injected before. """"""
        full_path = os.path.expanduser(filename)
        if not os.path.exists(full_path):
            return False
        with codecs.open(full_path, 'r+', encoding=""utf-8"") as fh:
            contents = fh.read()
        return self.wrapper_match.search(contents) is not None"
1465,"def destructive_inject(self, filename, content):
        """"""
        Injects the injections desired immediately. This should
        generally be run only during the commit phase, when no future
        injections will be done.
        """"""
        content = _unicode(content)
        backup_file(filename)
        full_path = self.__generate_file(filename)
        with codecs.open(full_path, 'r', encoding=""utf-8"") as f:
            new_content = self.inject_content(f.read(), content)
        with codecs.open(full_path, 'w+', encoding=""utf-8"") as f:
            f.write(new_content)"
1466,"def __generate_file(self, file_path):
        """"""
        Generate the file at the file_path desired. Creates any needed
        directories on the way. returns the absolute path of the file.
        """"""
        file_path = os.path.expanduser(file_path)
        if not os.path.exists(os.path.dirname(file_path)):
            self.logger.debug(""Directories missing! Creating directories for %s..."" % file_path)
            os.makedirs(os.path.dirname(file_path))
        if not os.path.exists(file_path):
            open(file_path, ""w+"").close()
        return file_path"
1467,"def in_noninjected_file(self, file_path, content):
        """""" Checks if a string exists in the file, sans the injected """"""
        if os.path.exists(file_path):
            file_content = codecs.open(file_path, encoding=""utf-8"").read()
            file_content = self.wrapper_match.sub(u"""", file_content)
        else:
            file_content = """"
        return file_content.find(content) != -1"
1468,"def inject_content(self, content, inject_string):
        """"""
        Inject inject_string into a text buffer, wrapped with
        #{{ wrapper }} comments if condition lambda is not
        satisfied or is None. Remove old instances of injects if they
        exist.
        """"""
        inject_string = _unicode(inject_string)
        content = self.wrapper_match.sub("""", _unicode(content))
        if self.override_match:
            sprinter_overrides = self.override_match.search(content)
            if sprinter_overrides:
                content = self.override_match.sub("""", content)
                sprinter_overrides = sprinter_overrides.groups()[0]
            else:
                sprinter_overrides = """"
        content += """"""
%s
%s
%s
"""""" % (self.wrapper, inject_string.rstrip(), self.wrapper)
        if self.override_match:
            content += sprinter_overrides.rstrip() + ""\n""
        return content"
1469,"def clear_content(self, content):
        """"""
        Clear the injected content from the content buffer, and return the results
        """"""
        content = _unicode(content)
        return self.wrapper_match.sub("""", content)"
1470,"def get_all_orders_ungrouped(self):
        """"""
        Uses a generator to return all orders within. :py:class:`MarketOrder`
        objects are yielded directly, instead of being grouped in
        :py:class:`MarketItemsInRegionList` instances.

        .. note:: This is a generator!

        :rtype: generator
        :returns: Generates a list of :py:class:`MarketOrder` instances.
        """"""
        for olist in self._orders.values():
            for order in olist.orders:
                yield order"
1471,"def add_order(self, order):
        """"""
        Adds a MarketOrder instance to the list of market orders contained
        within this order list. Does some behind-the-scenes magic to get it
        all ready for serialization.

        :param MarketOrder order: The order to add to this order list.
        """"""
        # This key is used to group the orders based on region.
        key = '%s_%s' % (order.region_id, order.type_id)
        if not self._orders.has_key(key):
            # We don't have any orders for this yet. Prep the region+item
            # combo by instantiating a new MarketItemsInRegionList for
            # the MarketOrders.
            self.set_empty_region(
                order.region_id,
                order.type_id,
                order.generated_at
            )

        # The MarketOrder gets stuffed into the MarketItemsInRegionList for this
        # item+region combo.
        self._orders[key].add_order(order)"
1472,"def set_empty_region(self, region_id, type_id, generated_at,
                         error_if_orders_present=True):
        """"""
        Prepares for the given region+item combo by instantiating a
        :py:class:`MarketItemsInRegionList` instance, which will track
        region ID, type ID, and generated time. This is mostly used for
        the JSON deserialization process in case there are no orders for
        the given region+item combo.

        :param int region_id: The region ID.
        :param int type_id: The item's type ID.
        :param datetime.datetime generated_at: The time that the order set
            was generated.
        :keyword bool error_if_orders_present: If True, raise an exception if
            an order already exists for this item+region combo when this is
            called. This failsafe may be disabled by passing False here.
        """"""
        key = '%s_%s' % (region_id, type_id)
        if error_if_orders_present and self._orders.has_key(key):
            raise ItemAlreadyPresentError(
                ""Orders already exist for the given region and type ID. ""
                ""Pass error_if_orders_present=False to disable this failsafe, ""
                ""if desired.""
            )

        self._orders[key] = MarketItemsInRegionList(
            region_id, type_id, generated_at)"
1473,"def add_entry(self, entry):
        """"""
        Adds a MarketHistoryEntry instance to the list of market history entries
        contained within this instance. Does some behind-the-scenes magic to
        get it all ready for serialization.

        :param MarketHistoryEntry entry: The history entry to add to
            instance.
        """"""
        # This key is used to group the orders based on region.
        key = '%s_%s' % (entry.region_id, entry.type_id)
        if not self._history.has_key(key):
            # We don't have any orders for this yet. Prep the region+item
            # combo by instantiating a new MarketItemsInRegionList for
            # the MarketOrders.
            self.set_empty_region(
                entry.region_id,
                entry.type_id,
                entry.generated_at
            )

        # The MarketOrder gets stuffed into the MarketItemsInRegionList for this
        # item+region combo.
        self._history[key].add_entry(entry)"
1474,"def set_empty_region(self, region_id, type_id, generated_at,
                         error_if_entries_present=True):
        """"""
        Prepares for the given region+item combo by instantiating a
        :py:class:`HistoryItemsInRegionList` instance, which will track
        region ID, type ID, and generated time. This is mostly used for
        the JSON deserialization process in case there are no orders for
        the given region+item combo.

        :param int region_id: The region ID.
        :param int type_id: The item's type ID.
        :param datetime.datetime generated_at: The time that the order set
            was generated.
        :keyword bool error_if_entries_present: If True, raise an exception if
            an entry already exists for this item+region combo when this is
            called. This failsafe may be disabled by passing False here.
        """"""
        key = '%s_%s' % (region_id, type_id)
        if error_if_entries_present and self._history.has_key(key):
            raise ItemAlreadyPresentError(
                ""Orders already exist for the given region and type ID. ""
                ""Pass error_if_orders_present=False to disable this failsafe, ""
                ""if desired.""
            )

        self._history[key] = HistoryItemsInRegionList(
            region_id, type_id, generated_at)"
1475,"def _find_file(self, file_name: str, lookup_dir: Path) -> Path or None:
        '''Find a file in a directory by name. Check subdirectories recursively.

        :param file_name: Name of the file
        :lookup_dir: Starting directory

        :returns: Path to the found file or None if the file was not found
        :raises: FileNotFoundError
        '''

        self.logger.debug('Trying to find the file {file_name} inside the directory {lookup_dir}')

        result = None

        for item in lookup_dir.rglob('*'):
            if item.name == file_name:
                result = item
                break
        else:
            raise FileNotFoundError(file_name)

        self.logger.debug('File found: {result}')

        return result"
1476,"def _sync_repo(self, repo_url: str, revision: str or None = None) -> Path:
        '''Clone a Git repository to the cache dir. If it has been cloned before, update it.

        :param repo_url: Repository URL
        :param revision: Revision: branch, commit hash, or tag

        :returns: Path to the cloned repository
        '''

        repo_name = repo_url.split('/')[-1].rsplit('.', maxsplit=1)[0]
        repo_path = (self._cache_path / repo_name).resolve()

        self.logger.debug(f'Synchronizing with repo; URL: {repo_url}, revision: {revision}')

        try:
            self.logger.debug(f'Cloning repo {repo_url} to {repo_path}')

            run(
                f'git clone {repo_url} {repo_path}',
                shell=True,
                check=True,
                stdout=PIPE,
                stderr=STDOUT
            )

        except CalledProcessError as exception:
            if repo_path.exists():
                self.logger.debug('Repo already cloned; pulling from remote')

                try:
                    run(
                        'git pull',
                        cwd=repo_path,
                        shell=True,
                        check=True,
                        stdout=PIPE,
                        stderr=STDOUT
                    )

                except CalledProcessError as exception:
                    self.logger.warning(str(exception))

            else:
                self.logger.error(str(exception))

        if revision:
            run(
                f'git checkout {revision}',
                cwd=repo_path,
                shell=True,
                check=True,
                stdout=PIPE,
                stderr=STDOUT
            )

        return repo_path"
1477,"def _shift_headings(self, content: str, shift: int) -> str:
        '''Shift Markdown headings in a string by a given value. The shift can
        be positive or negative.

        :param content: Markdown content
        :param shift: Heading shift

        :returns: Markdown content with headings shifted by ``shift``
        '''

        def _sub(heading):
            new_heading_level = len(heading.group('hashes')) + shift

            self.logger.debug(f'Shift heading level to {new_heading_level}, heading title: {heading.group(""title"")}')

            if new_heading_level <= 6:
                return f'{""#"" * new_heading_level} {heading.group(""title"")}{heading.group(""tail"")}'

            else:
                self.logger.debug('New heading level is out of range, using bold paragraph text instead of heading')

                return f'**{heading.group(""title"")}**{heading.group(""tail"")}'

        return self._heading_pattern.sub(_sub, content)"
1478,"def _find_top_heading_level(self, content: str) -> int:
        '''Find the highest level heading (i.e. having the least '#'s)
        in a Markdown string.

        :param content: Markdown content

        :returns: Maximum heading level detected; if no heading is found, 0 is returned
        '''

        result = float('inf')

        for heading in self._heading_pattern.finditer(content):
            heading_level = len(heading.group('hashes'))

            if heading_level < result:
                result = heading_level

            self.logger.debug(f'Maximum heading level: {result}')

        return result if result < float('inf') else 0"
1479,"def _cut_from_heading_to_heading(
            self,
            content: str,
            from_heading: str,
            to_heading: str or None = None,
            options={}
        ) -> str:
        '''Cut part of Markdown string between two headings, set internal heading level,
        and remove top heading.

        If only the starting heading is defined, cut to the next heading
        of the same level.

        Heading shift and top heading elimination are optional.

        :param content: Markdown content
        :param from_heading: Starting heading
        :param to_heading: Ending heading (will not be incuded in the output)
        :param options: ``sethead``, ``nohead``

        :returns: Part of the Markdown content between headings with internal headings adjusted
        '''

        self.logger.debug(f'Cutting from heading: {from_heading}, to heading: {to_heading}, options: {options}')

        from_heading_pattern = re.compile(r'^\#{1,6}\s+' + rf'{from_heading}\s*$', flags=re.MULTILINE)

        if not from_heading_pattern.findall(content):
            return ''

        from_heading_line = from_heading_pattern.findall(content)[0]
        from_heading_level = len(self._heading_pattern.match(from_heading_line).group('hashes'))

        self.logger.debug(f'From heading level: {from_heading_level}')

        result = from_heading_pattern.split(content)[1]

        if to_heading:
            to_heading_pattern = re.compile(r'^\#{1,6}\s+' + rf'{to_heading}\s*$', flags=re.MULTILINE)

        else:
            to_heading_pattern = re.compile(
                rf'^\#{{1,{from_heading_level}}}[^\#]+?$',
                flags=re.MULTILINE
            )

        result = to_heading_pattern.split(result)[0]

        if not options.get('nohead'):
            result = from_heading_line + result

        if options.get('sethead'):
            if options['sethead'] > 0:
                result = self._shift_headings(
                    result,
                    options['sethead'] - from_heading_level
                )

        return result"
1480,"def _cut_to_heading(
            self,
            content: str,
            to_heading: str or None = None,
            options={}
        ) -> str:
        '''Cut part of Markdown string from the start to a certain heading,
        set internal heading level, and remove top heading.

        If not heading is defined, the whole string is returned.

        Heading shift and top heading elimination are optional.

        :param content: Markdown content
        :param to_heading: Ending heading (will not be incuded in the output)
        :param options: ``sethead``, ``nohead``

        :returns: Part of the Markdown content from the start to ``to_heading``,
            with internal headings adjusted
        '''

        self.logger.debug(f'Cutting to heading: {to_heading}, options: {options}')

        content_buffer = StringIO(content)

        first_line = content_buffer.readline()

        if self._heading_pattern.fullmatch(first_line):
            from_heading_line = first_line
            from_heading_level = len(self._heading_pattern.match(from_heading_line).group('hashes'))
            result = content_buffer.read()

        else:
            from_heading_line = ''
            from_heading_level = self._find_top_heading_level(content)
            result = content

        self.logger.debug(f'From heading level: {from_heading_level}')

        if to_heading:
            to_heading_pattern = re.compile(r'^\#{1,6}\s+' + rf'{to_heading}\s*$', flags=re.MULTILINE)
            result = to_heading_pattern.split(result)[0]

        if not options.get('nohead'):
            result = from_heading_line + result

        if options.get('sethead'):
            if options['sethead'] > 0:
                result = self._shift_headings(
                    result,
                    options['sethead'] - from_heading_level
                )

        return result"
1481,"def _adjust_image_paths(self, content: str, md_file_path: Path) -> str:
        '''Locate images referenced in a Markdown string and replace their paths
        with the absolute ones.

        :param content: Markdown content
        :param md_file_path: Path to the Markdown file containing the content

        :returns: Markdown content with absolute image paths
        '''

        def _sub(image):
            image_caption = image.group('caption')
            image_path = md_file_path.parent / Path(image.group('path'))

            self.logger.debug(
                f'Updating image reference; user specified path: {image.group(""path"")}, ' +
                f'absolute path: {image_path}, caption: {image_caption}'
            )

            return f'![{image_caption}]({image_path.absolute().as_posix()})'

        return self._image_pattern.sub(_sub, content)"
1482,"def _get_src_file_path(self, markdown_file_path: Path) -> Path:
        '''Translate the path of Markdown file that is located inside the temporary working directory
        into the path of the corresponding Markdown file that is located inside the source directory
        of Foliant project.

        :param markdown_file_path: Path to Markdown file that is located inside the temporary working directory

        :returns: Mapping of Markdown file path to the source directory
        '''

        path_relative_to_working_dir = markdown_file_path.relative_to(self.working_dir.resolve())

        self.logger.debug(
            'Currently processed Markdown file path relative to working dir: ' +
            f'{path_relative_to_working_dir}'
        )

        path_mapped_to_src_dir = (
            self.project_path.resolve() /
            self.config['src_dir'] /
            path_relative_to_working_dir
        )

        self.logger.debug(
            'Currently processed Markdown file path mapped to source dir: ' +
            f'{path_mapped_to_src_dir}'
        )

        return path_mapped_to_src_dir"
1483,"def _get_included_file_path(self, user_specified_path: str, current_processed_file_path: Path) -> Path:
        '''Resolve user specified path to the local included file.

        :param user_specified_path: User specified string that represents
            the path to a local file

        :param current_processed_file_path: Path to the currently processed Markdown file
            that contains include statements

        :returns: Local path of the included file relative to the currently processed Markdown file
        '''

        self.logger.debug(f'Currently processed Markdown file: {current_processed_file_path}')

        included_file_path = (current_processed_file_path.parent / user_specified_path).resolve()

        self.logger.debug(f'User-specified included file path: {included_file_path}')

        if (
            self.working_dir.resolve() in current_processed_file_path.parents
            and
            self.working_dir.resolve() not in included_file_path.parents
        ):
            self.logger.debug(
                'Currently processed file is located inside the working dir, ' +
                'but included file is located outside the working dir. ' +
                'So currently processed file path should be rewritten with the path of corresponding file ' +
                'that is located inside the source dir'
            )

            included_file_path = (
                self._get_src_file_path(current_processed_file_path).parent / user_specified_path
            ).resolve()

        else:
            self.logger.debug(
                'Using these paths without changes'
            )

        self.logger.debug(f'Finally, included file path: {included_file_path}')

        return included_file_path"
1484,"def _process_include(
            self,
            file_path: Path,
            from_heading: str or None = None,
            to_heading: str or None = None,
            options={}
        ) -> str:
        '''Replace a local include statement with the file content. Necessary
        adjustments are applied to the content: cut between certain headings,
        strip the top heading, set heading level.

        :param file_path: Path to the included file
        :param from_heading: Include starting from this heading
        :param to_heading: Include up to this heading (not including the heading itself)
        :param options: ``sethead``, ``nohead``

        :returns: Included file content
        '''

        self.logger.debug(
            f'Included file path: {file_path}, from heading: {from_heading}, ' +
            f'to heading: {to_heading}, options: {options}'
        )

        if file_path.name.startswith('^'):
            file_path = self._find_file(file_path.name[1:], file_path.parent)

        with open(file_path, encoding='utf8') as incl_file:
            incl_content = incl_file.read()

            if from_heading:
                incl_content = self._cut_from_heading_to_heading(
                    incl_content,
                    from_heading,
                    to_heading,
                    options
                )

            else:
                incl_content = self._cut_to_heading(
                    incl_content,
                    to_heading,
                    options
                )

            incl_content = self._adjust_image_paths(incl_content, file_path)

        return incl_content"
1485,"def process_includes(self, markdown_file_path: Path, content: str) -> str:
        '''Replace all include statements with the respective file contents.

        :param markdown_file_path: Path to curently processed Markdown file
        :param content: Markdown content

        :returns: Markdown content with resolved includes
        '''

        markdown_file_path = markdown_file_path.resolve()

        self.logger.debug(f'Processing Markdown file: {markdown_file_path}')

        processed_content = ''

        include_statement_pattern = re.compile(
            rf'((?<!\<)\<{""|"".join(self.tags)}(?:\s[^\<\>]*)?\>.*?\<\/{""|"".join(self.tags)}\>)',
            flags=re.DOTALL
        )

        content_parts = include_statement_pattern.split(content)

        for content_part in content_parts:
            include_statement = self.pattern.fullmatch(content_part)

            if include_statement:
                body = self._tag_body_pattern.match(include_statement.group('body').strip())
                options = self.get_options(include_statement.group('options'))

                self.logger.debug(f'Processing include statement; body: {body}, options: {options}')

                if body.group('repo'):
                    repo = body.group('repo')
                    repo_from_alias = self.options['aliases'].get(repo)

                    revision = None

                    if repo_from_alias:
                        self.logger.debug(f'Alias found: {repo}, resolved as: {repo_from_alias}')

                        if '#' in repo_from_alias:
                            repo_url, revision = repo_from_alias.split('#', maxsplit=1)

                        else:
                            repo_url = repo_from_alias

                    else:
                        repo_url = repo

                    if body.group('revision'):
                        revision = body.group('revision')

                        self.logger.debug(f'Highest priority revision specified in the include statement: {revision}')

                    self.logger.debug(f'File in Git repository referenced; URL: {repo_url}, revision: {revision}')

                    repo_path = self._sync_repo(repo_url, revision)

                    self.logger.debug(f'Local path of the repo: {repo_path}')

                    included_file_path = repo_path / body.group('path')

                    self.logger.debug(f'Resolved path to the included file: {included_file_path}')

                    processed_content_part = self._process_include(
                        included_file_path,
                        body.group('from_heading'),
                        body.group('to_heading'),
                        options
                    )

                else:
                    self.logger.debug('Local file referenced')

                    included_file_path = self._get_included_file_path(body.group('path'), markdown_file_path)

                    self.logger.debug(f'Resolved path to the included file: {included_file_path}')

                    processed_content_part = self._process_include(
                        included_file_path,
                        body.group('from_heading'),
                        body.group('to_heading'),
                        options
                    )

                if self.options['recursive'] and self.pattern.search(processed_content_part):
                    self.logger.debug('Recursive call of include statements processing')

                    processed_content_part = self.process_includes(included_file_path, processed_content_part)

                if options.get('inline'):
                    self.logger.debug('Processing included content part as inline')

                    processed_content_part = re.sub(r'\s+', ' ', processed_content_part).strip()

            else:
                processed_content_part = content_part

            processed_content += processed_content_part

        return processed_content"
1486,"def create_view_from_dict(name, spec, template=None, cls=ActionsView):
    """"""Creates a view from an spec dict (typically, the YAML front-matter).
    """"""
    kwargs = dict(spec)
    if template is not None:
        kwargs.setdefault(""template"", template)
    actions = load_grouped_actions(kwargs, pop_keys=True)
    view = cls(name=name, **kwargs)
    if isinstance(view, ActionsView):
        view.actions.extend(actions)
    return view"
1487,"def _parse_argv(argv=copy(sys.argv)):
    """"""return argv as a parsed dictionary, looks like the following:

    app --option1 likethis --option2 likethat --flag

    ->

    {'option1': 'likethis', 'option2': 'likethat', 'flag': True}
    """"""

    cfg = DotDict()
    cfg_files = []

    argv = argv[1:] # Skip command name
    while argv:
        arg = argv.pop(0)

        # split up arg in format --arg=val
        key_val = re.split('=| ', arg)
        arg = key_val[0]
        try:
            val = key_val[1]
        except IndexError:
            if len(argv) > 0 and argv[0][0] != '-':
                val = argv.pop(0)
            else:
                # No val available, probably a flag
                val = None

        if arg[0] == '-':
            key = arg.lstrip('-')
            if not val:
                val = True
            new_cfg = _dict_from_dotted(key, val)
            cfg = dict_merge(cfg, new_cfg)
        else:
            if arg.endswith("".yml""):
                cfg_files.append(arg)

    return cfg, cfg_files"
1488,"def _dict_from_dotted(key, val):
    """"""takes a key value pair like:
    key: ""this.is.a.key""
    val: ""the value""

    and returns a dictionary like:

    {""this"":
        {""is"":
            {""a"":
                {""key"":
                    ""the value""
                }
            }
        }
    }
    """"""
    split_key = key.split(""."")
    split_key.reverse()
    for key_part in split_key:
        new_dict = DotDict()
        new_dict[key_part] = val
        val = new_dict
    return val"
1489,"def get_logger(name, CFG=None):
    """"""set up logging for a service using the py 2.7 dictConfig
    """"""

    logger = logging.getLogger(name)

    if CFG:
        # Make log directory if it doesn't exist
        for handler in CFG.get('handlers', {}).itervalues():
            if 'filename' in handler:
                log_dir = os.path.dirname(handler['filename'])
                if not os.path.exists(log_dir):
                    os.makedirs(log_dir)
        try:
            #TODO: This requires python 2.7
            logging.config.dictConfig(CFG)
        except AttributeError:
            print >> sys.stderr, '""logging.config.dictConfig"" doesn\'t seem to be supported in your python'
            raise

    return logger"
1490,"def t_TITLE(self, token):
        ur'\#\s+<wca-title>(?P<title>.+)\n'
        token.value = token.lexer.lexmatch.group(""title"").decode(""utf8"")
        token.lexer.lineno += 1
        return token"
1491,"def t_LABELDECL(self, token):
        ur'-\s<label>\s*\[(?P<label>.+?)\]\s*(?P<text>.+?)\n'
        label = token.lexer.lexmatch.group(""label"").decode(""utf8"")
        text = token.lexer.lexmatch.group(""text"").decode(""utf8"")
        token.value = (label, text)
        token.lexer.lineno += 1
        return token"
1492,"def t_ARTICLEHEADER(self, token):
        # \xef\xbc\x9a is the ""fullwidth colon"" used in Japanese for instance
        ur'\#\#\s+<article-(?P<number>[A-Z0-9]+)><(?P<newtag>[a-zA-Z0-9-]+)><(?P<oldtag>[a-zA-Z0-9-]+)>[ ]*(?P<name>[^\<]+?)(?P<sep>:\s|\xef\xbc\x9a)(?P<title>[^<\n]+)\n'
        number = token.lexer.lexmatch.group(""number"").decode(""utf8"")
        newtag = token.lexer.lexmatch.group(""newtag"").decode(""utf8"")
        oldtag = token.lexer.lexmatch.group(""oldtag"").decode(""utf8"")
        name = token.lexer.lexmatch.group(""name"").decode(""utf8"")
        sep = token.lexer.lexmatch.group(""sep"").decode(""utf8"")
        title = token.lexer.lexmatch.group(""title"").decode(""utf8"")
        token.value = (number, newtag, oldtag, name, title, sep)
        token.lexer.lineno += 1
        return token"
1493,"def t_STATESHEADER(self, token):
        ur'\#\#\s+<states-list>(?P<title>[^<\n]*)\n'
        title = token.lexer.lexmatch.group(""title"").decode(""utf8"")
        token.value = title
        token.lexer.lineno += 1
        return token"
1494,"def t_REGULATION(self, token):
        ur'(?P<indents>\s{4,})*-\s(?P<reg>[a-zA-Z0-9]+)\)\s*(?P<text>.+?[^ ])\n'
        indents = token.lexer.lexmatch.group(""indents"")
        indents = len(indents)/4 if indents else 0
        reg = token.lexer.lexmatch.group(""reg"").decode(""utf8"")
        text = token.lexer.lexmatch.group(""text"").decode(""utf8"")
        token.value = (indents, reg, text)
        token.lexer.lineno += 1
        return token"
1495,"def t_GUIDELINE(self, token):
        ur'-\s(?P<reg>[a-zA-Z0-9]+[+]+)\)\s\[(?P<label>.+?)\]\s*(?P<text>.+?[^ ])\n'
        reg = token.lexer.lexmatch.group(""reg"").decode(""utf8"")
        text = token.lexer.lexmatch.group(""text"").decode(""utf8"")
        label = token.lexer.lexmatch.group(""label"").decode(""utf8"")
        token.value = (0, reg, text, label)
        token.lexer.lineno += 1
        return token"
1496,"def t_STATE(self, token):
        ur'-\s\((?P<state>[A-Z]{2}):(?P<continent>[_A-Za-z ]+)(:(?P<friendly_id>[A-Za-z_]+))?\)\s(?P<name>[A-Z].+?[^ ])\n'
        state = token.lexer.lexmatch.group(""state"").decode(""utf8"")
        continent = token.lexer.lexmatch.group(""continent"").decode(""utf8"")
        name = token.lexer.lexmatch.group(""name"").decode(""utf8"")
        friendly_id = token.lexer.lexmatch.group(""friendly_id"")
        if friendly_id:
            friendly_id = friendly_id.decode(""utf8"")
        else:
            friendly_id = unidecode(name).replace(""'"", ""_"")
        token.value = (state, continent, name, friendly_id)
        token.lexer.lineno += 1
        return token"
1497,"def t_TEXT(self, token):
        ur'(?P<text>[^<#\n ].+?[^ ])(?=\n)'
        text = token.lexer.lexmatch.group(""text"").decode(""utf8"")
        token.value = text
        return token"
1498,"def t_PARBREAK(self, token):
        ur'\n{2,}'
        token.lexer.lineno += len(token.value)
        return token"
1499,"def t_trailingwhitespace(self, token):
        ur'.+? \n'
        print ""Error: trailing whitespace at line %s in text '%s'"" % (token.lexer.lineno + 1, token.value[:-1])
        token.lexer.lexerror = True
        token.lexer.skip(1)"
1500,"def register_event(cls, event_name, event, method):
        """"""
        Register an event class on it's name with a method to process it.
        :param event_name: name of the event.
        :param event: class of the event.
        :param method: a method used to process this event.
        """"""
        log.info('@Registry.register_event `{}` with subscriber `{}`'
                 .format(event_name, method.__name__))

        if event_name not in cls._events:
            cls._events[event_name] = {}

        if event not in cls._events[event_name]:
            cls._events[event_name][event] = []

        cls._events[event_name][event].append(method)"
1501,"def register_producer(cls, producer):
        """"""
        Register a default producer for events to use.
        :param producer: the default producer to to dispatch events on.
        """"""
        log.info('@Registry.register_producer `{}`'
                 .format(producer.__class__.__name__))
        cls._producer = (cls._producer or producer)"
1502,"def exec_before_request_actions(actions, **kwargs):
    """"""Execute actions in the ""before"" and ""before_METHOD"" groups
    """"""
    groups = (""before"", ""before_"" + flask.request.method.lower())
    return execute_actions(actions, limit_groups=groups, **kwargs)"
1503,"def exec_after_request_actions(actions, response, **kwargs):
    """"""Executes actions of the ""after"" and ""after_METHOD"" groups.
    A ""response"" var will be injected in the current context.
    """"""
    current_context[""response""] = response
    groups = (""after_"" + flask.request.method.lower(), ""after"")
    try:
        rv = execute_actions(actions, limit_groups=groups, **kwargs)
    except ReturnValueException as e:
        rv = e.value
    if rv:
        return rv
    return response"
1504,"def full_exec_request_actions(actions, func=None, render_func=None):
    """"""Full process to execute before, during and after actions.
    If func is specified, it will be called after exec_request_actions()
    unless a ContextExitException was raised. If render_func is specified,
    it will be called after exec_request_actions() only if there is no
    response. exec_after_request_actions() is always called.
    """"""
    response = None
    try:
        exec_before_request_actions(actions, catch_context_exit=False)
        exec_request_actions(actions, catch_context_exit=False)
        if func:
            response = func()
    except ContextExitException as e:
        response = e.result
    except ReturnValueException as e:
        response = e.value
    if render_func and response is None:
        response = render_func()
    return exec_after_request_actions(actions, response)"
1505,"def as_view(url=None, methods=None, view_class=ActionsView, name=None, url_rules=None, **kwargs):
    """"""Decorator to transform a function into a view class. Be warned that this will replace
    the function with the view class.
    """"""
    def decorator(f):
        if url is not None:
            f = expose(url, methods=methods)(f)

        clsdict = {""name"": name or f.__name__,
                   ""actions"": getattr(f, ""actions"", None),
                   ""url_rules"": url_rules or getattr(f, ""urls"", None)}

        if isinstance(f, WithActionsDecorator):
            f = f.func
        clsdict['func'] = f

        def constructor(self, **ctorkwargs):
            for k, v in kwargs.items():
                if k not in ctorkwargs or ctorkwargs[k] is None:
                    ctorkwargs[k] = v
            view_class.__init__(self, func=f, **ctorkwargs)

        clsdict[""__init__""] = constructor
        return type(f.__name__, (view_class,), clsdict)

    return decorator"
1506,"def register(self, target):
        """"""Registers url_rules on the blueprint
        """"""
        for rule, options in self.url_rules:
            target.add_url_rule(rule, self.name, self.dispatch_request, **options)"
1507,"def view(self, *args, **kwargs):
        """"""Decorator to automatically apply as_view decorator and register it.
        """"""
        def decorator(f):
            kwargs.setdefault(""view_class"", self.view_class)
            return self.add_view(as_view(*args, **kwargs)(f))
        return decorator"
1508,"def add_action_view(self, name, url, actions, **kwargs):
        """"""Creates an ActionsView instance and registers it.
        """"""
        view = ActionsView(name, url=url, self_var=self, **kwargs)
        if isinstance(actions, dict):
            for group, actions in actions.iteritems():
                view.actions.extend(load_actions(actions, group=group or None))
        else:
            view.actions.extend(load_actions(actions))
        self.add_view(view)
        return view"
1509,"def process(exam_num: int, time: str, date: str) -> None:
    """"""Process the exams in the exam_num folder for the time.""""""
    prefix = Path(f""exams/exam-{exam_num}"")

    problems = list(prefix.glob(f""exam-{exam_num}-{time}-[0-9].ipynb""))
    problems = sorted(problems, key=lambda k: k.stem[-1])

    output_directory = (prefix / ""output"").resolve()
    fw = FilesWriter(build_directory=str(output_directory))

    assignment_zip_name = output_directory / f""exam-{exam_num}-{time}.zip""
    solution_zip_name = output_directory / f""exam-{exam_num}-{time}-soln.zip""

    solution_pdfs: List[BytesIO] = []

    exam_date_time = datetime.strptime(time + date, ""%H%M%d-%b-%Y"")
    res: Dict[str, Union[str, int]] = {
        ""exam_num"": exam_num,
        ""time"": exam_date_time.strftime(""%I:%M %p""),
        ""date"": exam_date_time.strftime(""%b. %d, %Y""),
        ""delete_pymarkdown"": True,
    }

    for problem in problems:
        res[""unique_key""] = problem.stem
        problem_fname = str(problem.resolve())
        if problem.stem.endswith(""1""):

            assignment_nb, _ = sa_nb_exp.from_filename(problem_fname, resources=res)

            with ZipFile(assignment_zip_name, mode=""a"") as zip_file:
                zip_file.writestr(problem.name, assignment_nb)
        else:
            assignment_nb, _ = prob_nb_exp.from_filename(problem_fname, resources=res)

            with ZipFile(assignment_zip_name, mode=""a"") as zip_file:
                zip_file.writestr(problem.name, assignment_nb)

        solution_pdf, _ = solution_pdf_exp.from_filename(problem_fname, resources=res)
        solution_pdfs.append(BytesIO(solution_pdf))

        solution_nb, _ = solution_nb_exp.from_filename(problem_fname, resources=res)
        with ZipFile(solution_zip_name, mode=""a"") as zip_file:
            zip_file.writestr(problem.name, solution_nb)

    resources: Dict[str, Any] = {
        ""metadata"": {
            ""name"": f""exam-{exam_num}-{time}-soln"",
            ""path"": str(prefix),
            ""modified_date"": datetime.today().strftime(""%B %d, %Y""),
        },
        ""output_extension"": "".pdf"",
    }
    fw.write(
        combine_pdf_as_bytes(solution_pdfs), resources, f""exam-{exam_num}-{time}-soln""
    )"
1510,"def main(argv: Optional[Sequence[str]] = None) -> None:
    """"""Parse arguments and process the exam assignment.""""""
    parser = ArgumentParser(description=""Convert Jupyter Notebook exams to PDFs"")
    parser.add_argument(
        ""--exam"",
        type=int,
        required=True,
        help=""Exam number to convert"",
        dest=""exam_num"",
    )
    parser.add_argument(
        ""--time"", type=str, required=True, help=""Time of exam to convert""
    )
    parser.add_argument(
        ""--date"", type=str, required=True, help=""The date the exam will take place""
    )
    args = parser.parse_args(argv)
    process(args.exam_num, args.time, args.date)"
1511,"def get_profile_model():
    """"""
    Returns configured user profile model or None if not found
    """"""
    auth_profile_module = getattr(settings, 'AUTH_PROFILE_MODULE', None)
    profile_model = None
    if auth_profile_module:
        # get the profile model. TODO: super flacky, refactor
        app_label, model = auth_profile_module.split('.')
        profile_model = getattr(__import__(""%s.models"" % app_label, \
                globals(), locals(), [model, ], -1), model, None)

    return profile_model"
1512,"def is_on(self):
        """"""
        Get sensor state.

        Assume offline or open (worst case).
        """"""
        return self.status not in (CONST.STATUS_OFF, CONST.STATUS_OFFLINE,
                                   CONST.STATUS_CLOSED, CONST.STATUS_OPEN)"
1513,"def extract_meta(self, text):
        """"""
        Takes input as the entire file.
        Reads the first yaml document as metadata.
        and the rest of the document as text
        """"""
        first_line = True
        metadata = []
        content = []
        metadata_parsed = False

        for line in text.split('\n'):
            if first_line:
                first_line = False
                if line.strip() != '---':
                    raise MetaParseException('Invalid metadata')
                else:
                    continue
            if line.strip() == '' and not metadata_parsed:
                continue
            if line.strip() == '---' and not metadata_parsed:
                # reached the last line
                metadata_parsed = True
            elif not metadata_parsed:
                metadata.append(line)
            else:
                content.append(line)

        content = '\n'.join(content)
        try:
            metadata = yaml.load('\n'.join(metadata))
        except:
            raise
            content = text
            metadata = yaml.load('')

        return content, metadata"
1514,"def set_defaults(self):
        """""" Add each model entry with it's default
        """"""
        for key, value in self.spec.items():
            setattr(self, key.upper(), value.get(""default"", None))"
1515,"def load_env(self):
        """""" Load the model fron environment variables
        """"""
        for key, value in self.spec.items():
            if value['type'] in (dict, list):
                envar = (self.env_prefix + ""_"" + key).upper()
                try:
                    envvar = env.json(envar,
                                      default=getattr(self, key.upper(), value.get('default')))
                except ConfigurationError as _err:  #pragma: no cover
                    print(_err)
                    self.log.critical(f""Error parsing json from env var. {os.environ.get(envar)}"")
                    print(envar)
                    raise
            else:
                envvar = env((self.env_prefix + ""_"" + key).upper(),
                             default=getattr(self, key.upper(), value.get('default')),
                             cast=value['type'])
            setattr(self, key.upper(), envvar)"
1516,"def parse_args(self):
        """""" Parse the cli args

            Returns:
                args (namespace): The args
        """"""
        parser = ArgumentParser(description='',
                                formatter_class=RawTextHelpFormatter)
        parser.add_argument(""--generate"", action=""store"", dest='generate',
                            choices=['command', 'docker-run', 'docker-compose',
                                     'ini', 'env', 'kubernetes', 'readme', 'drone-plugin'],
                            help=""Generate a template "")
        parser.add_argument(""--settings"", action=""store"", dest='settings',
                            help=""Specify a settings file. (ie settings.dev)"")
        for key, value in self.spec.items():
            if value['type'] in [str, int, float]:
                parser.add_argument(f""--{key.lower()}"", action=""store"", dest=key,
                                    type=value['type'],
                                    choices=value.get(""choices""),
                                    help=self.help(value))
            elif value['type'] == bool:
                parser.add_argument(f""--{key.lower()}"", action=""store"", dest=key,
                                    type=lambda x:bool(strtobool(x)),
                                    choices=value.get(""choices""),
                                    help=self.help(value))
            elif value['type'] == list:
                parser.add_argument(f""--{key.lower()}"", action=""store"", dest=key,
                                    nargs='+',
                                    choices=value.get(""choices""),
                                    help=self.help(value))
            elif value['type'] == dict:
                parser.add_argument(f""--{key.lower()}"", action=""store"", dest=key,
                                    type=json.loads,
                                    choices=value.get(""choices""),
                                    help=self.help(value))
        args, _unknown = parser.parse_known_args()
        return args"
1517,"def add_args(self, args):
        """""" Add the args

            Args:
                args (namespace): The commandline args

        """"""
        for key, value in vars(args).items():
            if value is not None:
                setattr(self, key.upper(), value)"
1518,"def load_ini(self, ini_file):
        """""" Load the contents from the ini file

            Args:
                ini_file (str): The file from which the settings should be loaded

        """"""
        if ini_file and not os.path.exists(ini_file):
            self.log.critical(f""Settings file specified but not found. {ini_file}"")
            sys.exit(1)
        if not ini_file:
            ini_file = f""{self.cwd}/settings.ini""
        if os.path.exists(ini_file):
            config = configparser.RawConfigParser(allow_no_value=True)
            config.read(ini_file)
            for key, value in self.spec.items():
                entry = None
                if value['type'] == str:
                    entry = config.get(""settings"", option=key.lower(), fallback=None)
                elif value['type'] == bool:
                    entry = config.getboolean(""settings"", option=key.lower(), fallback=None)
                elif value['type'] == int:
                    entry = config.getint(""settings"", option=key.lower(), fallback=None)
                elif value['type'] == float:
                    entry = config.getfloat(""settings"", option=key.lower(), fallback=None)
                elif value['type'] in [list, dict]:
                    entries = config.get(""settings"", option=key.lower(), fallback=None)
                    if entries:
                        try:
                            entry = json.loads(entries)
                        except json.decoder.JSONDecodeError as _err:  #pragma: no cover
                            self.log.critical(f""Error parsing json from ini file. {entries}"")
                            sys.exit(1)
                if entry is not None:
                    setattr(self, key.upper(), entry)"
1519,"def check_required(self):
        """""" Check all required settings have been provided
        """"""
        die = False
        for key, value in self.spec.items():
            if not getattr(self, key.upper()) and value['required']:
                print(f""{key} is a required setting. ""
                      ""Set via command-line params, env or file. ""
                      ""For examples, try '--generate' or '--help'."")
                die = True
        if die:
            sys.exit(1)"
1520,"def generate(self):
        """""" Generate sample settings
        """"""
        otype = getattr(self, 'GENERATE')
        if otype:
            if otype == 'env':
                self.generate_env()
            elif otype == ""command"":
                self.generate_command()
            elif otype == ""docker-run"":
                self.generate_docker_run()
            elif otype == ""docker-compose"":
                self.generate_docker_compose()
            elif otype == ""kubernetes"":
                self.generate_kubernetes()
            elif otype == 'ini':
                self.generate_ini()
            elif otype == 'readme':
                self.generate_readme()
            elif otype == 'drone-plugin':
                self.generate_drone_plugin()

        sys.exit(0)"
1521,"def generate_env(self):
        """""" Generate sample environment variables
        """"""
        for key in sorted(list(self.spec.keys())):
            if self.spec[key]['type'] in (dict, list):
                value = f""\'{json.dumps(self.spec[key].get('example', ''))}\'""
            else:
                value = f""{self.spec[key].get('example', '')}""
            print(f""export {self.env_prefix}_{key.upper()}={value}"")"
1522,"def generate_command(self):
        """""" Generate a sample command
        """"""
        example = []
        example.append(f""{sys.argv[0]}"")
        for key in sorted(list(self.spec.keys())):
            if self.spec[key]['type'] == list:
                value = "" "".join(self.spec[key].get('example', ''))
            elif self.spec[key]['type'] == dict:
                value = f""\'{json.dumps(self.spec[key].get('example', ''))}\'""
            else:
                value = self.spec[key].get('example', '')
            string = f""     --{key.lower()} {value}""
            example.append(string)
        print("" \\\n"".join(example))"
1523,"def generate_docker_run(self):
        """""" Generate a sample docker run
        """"""
        example = []
        example.append(""docker run -it"")
        for key in sorted(list(self.spec.keys())):
            if self.spec[key]['type'] in (dict, list):
                value = f""\'{json.dumps(self.spec[key].get('example', ''))}\'""
            else:
                value = f""{self.spec[key].get('example', '')}""
            string = f""     -e {self.env_prefix}_{key.upper()}={value}""
            example.append(string)
        example.append(""     <container-name>"")
        print("" \\\n"".join(example))"
1524,"def generate_docker_compose(self):
        """""" Generate a sample docker compose
        """"""
        example = {}
        example['app'] = {}
        example['app']['environment'] = []
        for key in sorted(list(self.spec.keys())):
            if self.spec[key]['type'] in (dict, list):
                value = f""\'{json.dumps(self.spec[key].get('example', ''))}\'""
            else:
                value = f""{self.spec[key].get('example', '')}""
            example['app']['environment'].append(f""{self.env_prefix}_{key.upper()}={value}"")
        print(yaml.dump(example, default_flow_style=False))"
1525,"def generate_ini(self):
        """""" Generate a sample ini
        """"""
        example = []
        example.append(""[settings]"")
        for key in sorted(list(self.spec.keys())):
            if self.spec[key]['type'] in [list, dict]:
                value = json.dumps(self.spec[key].get('example', ''))
            else:
                value = self.spec[key].get('example', '')
            string = f""{key.lower()}={value}""
            example.append(string)
        print(""\n"".join(example))"
1526,"def generate_kubernetes(self):
        """""" Generate a sample kubernetes
        """"""
        example = {}
        example['spec'] = {}
        example['spec']['containers'] = []
        example['spec']['containers'].append({""name"": '', ""image"": '', ""env"": []})
        for key, value in self.spec.items():
            if value['type'] in (dict, list):
                kvalue = f""\'{json.dumps(value.get('example', ''))}\'""
            else:
                kvalue = f""{value.get('example', '')}""
            entry = {""name"": f""{self.env_prefix}_{key.upper()}"", ""value"": kvalue}
            example['spec']['containers'][0]['env'].append(entry)
        print(yaml.dump(example, default_flow_style=False))"
1527,"def generate_drone_plugin(self):
        """""" Generate a sample drone plugin configuration
        """"""
        example = {}
        example['pipeline'] = {}
        example['pipeline']['appname'] = {}
        example['pipeline']['appname']['image'] = """"
        example['pipeline']['appname']['secrets'] = """"
        for key, value in self.spec.items():
            if value['type'] in (dict, list):
                kvalue = f""\'{json.dumps(value.get('example', ''))}\'""
            else:
                kvalue = f""{value.get('example', '')}""
            example['pipeline']['appname'][key.lower()] = kvalue
        print(yaml.dump(example, default_flow_style=False))"
1528,"def generate_readme(self):
        """""" Generate a readme with all the generators
        """"""
        print(""## Examples of settings runtime params"")
        print(""### Command-line parameters"")
        print(""```"")
        self.generate_command()
        print(""```"")
        print(""###  Environment variables"")
        print(""```"")
        self.generate_env()
        print(""```"")
        print(""###  ini file"")
        print(""```"")
        self.generate_ini()
        print(""```"")
        print(""###  docker run"")
        print(""```"")
        self.generate_docker_run()
        print(""```"")
        print(""###  docker compose"")
        print(""```"")
        self.generate_docker_compose()
        print(""```"")
        print(""###  kubernetes"")
        print(""```"")
        self.generate_kubernetes()
        print(""```"")
        print(""###  drone plugin"")
        print(""```"")
        self.generate_drone_plugin()
        print(""```"")"
1529,"def file_exists(self, subdir, prefix, suffix):
        """"""Returns true if the resource file exists, else False.

        Positional arguments:
        subdir -- sub directory name under the resource's main directory (e.g. css or js, or an empty string if the
            resource's directory structure is flat).
        prefix -- file name without the file extension.
        suffix -- file extension (if self.minify = True, includes .min before the extension).
        """"""
        real_path = os.path.join(self.STATIC_DIR, self.DIR, subdir, prefix + suffix)
        return os.path.exists(real_path)"
1530,"def add_css(self, subdir, file_name_prefix):
        """"""Add a css file for this resource.

        If self.minify is True, checks if the .min.css file exists. If not, falls back to non-minified file. If that
        file also doesn't exist, IOError is raised.

        Positional arguments:
        subdir -- sub directory name under the resource's main directory (e.g. css or js, or an empty string).
        file_name_prefix -- file name without the file extension.
        """"""
        suffix_maxify = '.css'
        suffix_minify = '.min.css'
        if self.minify and self.file_exists(subdir, file_name_prefix, suffix_minify):
            self.resources_css.append(posixpath.join(self.DIR, subdir, file_name_prefix + suffix_minify))
        elif self.file_exists(subdir, file_name_prefix, suffix_maxify):
            self.resources_css.append(posixpath.join(self.DIR, subdir, file_name_prefix + suffix_maxify))
        else:
            file_path = os.path.join(self.STATIC_DIR, self.DIR, subdir, file_name_prefix + suffix_maxify)
            raise IOError('Resource file not found: {0}'.format(file_path))"
1531,"def read_dataframe_from_xls(desired_type: Type[T], file_path: str, encoding: str,
                            logger: Logger, **kwargs) -> pd.DataFrame:
    """"""
    We register this method rather than the other because pandas guesses the encoding by itself.

    Also, it is easier to put a breakpoint and debug by trying various options to find the good one (in streaming mode
    you just have one try and then the stream is consumed)

    :param desired_type:
    :param file_path:
    :param encoding:
    :param logger:
    :param kwargs:
    :return:
    """"""
    return pd.read_excel(file_path, **kwargs)"
1532,"def read_df_or_series_from_csv(desired_type: Type[pd.DataFrame], file_path: str, encoding: str,
                               logger: Logger, **kwargs) -> pd.DataFrame:
    """"""
    Helper method to read a dataframe from a csv file. By default this is well suited for a dataframe with
    headers in the first row, for example a parameter dataframe.

    :param desired_type:
    :param file_path:
    :param encoding:
    :param logger:
    :param kwargs:
    :return:
    """"""
    if desired_type is pd.Series:
        # as recommended in http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.from_csv.html
        # and from http://stackoverflow.com/questions/15760856/how-to-read-a-pandas-series-from-a-csv-file

        # TODO there should be a way to decide between row-oriented (squeeze=True) and col-oriented (index_col=0)
        # note : squeeze=true only works for row-oriented, so we dont use it. We rather expect that a row-oriented
        # dataframe would be convertible to a series using the df to series converter below
        if 'index_col' not in kwargs.keys():
            one_col_df = pd.read_csv(file_path, encoding=encoding, index_col=0, **kwargs)
        else:
            one_col_df = pd.read_csv(file_path, encoding=encoding, **kwargs)

        if one_col_df.shape[1] == 1:
            return one_col_df[one_col_df.columns[0]]
        else:
            raise Exception('Cannot build a series from this csv: it has more than two columns (one index + one value).'
                            ' Probably the parsing chain $read_df_or_series_from_csv => single_row_or_col_df_to_series$'
                            'will work, though.')
    else:
        return pd.read_csv(file_path, encoding=encoding, **kwargs)"
1533,"def get_default_pandas_parsers() -> List[AnyParser]:
    """"""
    Utility method to return the default parsers able to parse a dictionary from a file.
    :return:
    """"""
    return [SingleFileParserFunction(parser_function=read_dataframe_from_xls,
                                     streaming_mode=False,
                                     supported_exts={'.xls', '.xlsx', '.xlsm'},
                                     supported_types={pd.DataFrame},
                                     option_hints=pandas_parsers_option_hints_xls),
            SingleFileParserFunction(parser_function=read_df_or_series_from_csv,
                                     streaming_mode=False,
                                     supported_exts={'.csv', '.txt'},
                                     supported_types={pd.DataFrame, pd.Series},
                                     option_hints=pandas_parsers_option_hints_csv),
            ]"
1534,"def dict_to_df(desired_type: Type[T], dict_obj: Dict, logger: Logger, orient: str = None, **kwargs) -> pd.DataFrame:
    """"""
    Helper method to convert a dictionary into a dataframe. It supports both simple key-value dicts as well as true
    table dicts. For this it uses pd.DataFrame constructor or pd.DataFrame.from_dict intelligently depending on the
    case.

    The orientation of the resulting dataframe can be configured, or left to default behaviour. Default orientation is
    different depending on the contents:
    * 'index' for 2-level dictionaries, in order to align as much as possible with the natural way to express rows in
    JSON
    * 'columns' for 1-level (simple key-value) dictionaries, so as to preserve the data types of the scalar values in
    the resulting dataframe columns if they are different

    :param desired_type:
    :param dict_obj:
    :param logger:
    :param orient: the orientation of the resulting dataframe.
    :param kwargs:
    :return:
    """"""

    if len(dict_obj) > 0:
        first_val = dict_obj[next(iter(dict_obj))]
        if isinstance(first_val, dict) or isinstance(first_val, list):
            # --'full' table

            # default is index orientation
            orient = orient or 'index'

            # if orient is 'columns':
            #     return pd.DataFrame(dict_obj)
            # else:
            return pd.DataFrame.from_dict(dict_obj, orient=orient)
        else:
            # --scalar > single-row or single-col

            # default is columns orientation
            orient = orient or 'columns'

            if orient is 'columns':
                return pd.DataFrame(dict_obj, index=[0])
            else:
                res = pd.DataFrame.from_dict(dict_obj, orient=orient)
                res.index.name = 'key'
                return res.rename(columns={0: 'value'})
    else:
        # for empty dictionaries, orientation does not matter
        # but maybe we should still create a column 'value' in this empty dataframe ?
        return pd.DataFrame.from_dict(dict_obj)"
1535,"def single_row_or_col_df_to_series(desired_type: Type[T], single_rowcol_df: pd.DataFrame, logger: Logger, **kwargs)\
        -> pd.Series:
    """"""
    Helper method to convert a dataframe with one row or one or two columns into a Series

    :param desired_type:
    :param single_col_df:
    :param logger:
    :param kwargs:
    :return:
    """"""
    if single_rowcol_df.shape[0] == 1:
        # one row
        return single_rowcol_df.transpose()[0]
    elif single_rowcol_df.shape[1] == 2 and isinstance(single_rowcol_df.index, pd.RangeIndex):
        # two columns but the index contains nothing but the row number : we can use the first column
        d = single_rowcol_df.set_index(single_rowcol_df.columns[0])
        return d[d.columns[0]]
    elif single_rowcol_df.shape[1] == 1:
        # one column and one index
        d = single_rowcol_df
        return d[d.columns[0]]
    else:
        raise ValueError('Unable to convert provided dataframe to a series : '
                         'expected exactly 1 row or 1 column, found : ' + str(single_rowcol_df.shape) + '')"
1536,"def single_row_or_col_df_to_dict(desired_type: Type[T], single_rowcol_df: pd.DataFrame, logger: Logger, **kwargs)\
        -> Dict[str, str]:
    """"""
    Helper method to convert a dataframe with one row or one or two columns into a dictionary

    :param desired_type:
    :param single_rowcol_df:
    :param logger:
    :param kwargs:
    :return:
    """"""
    if single_rowcol_df.shape[0] == 1:
        return single_rowcol_df.transpose()[0].to_dict()
        # return {col_name: single_rowcol_df[col_name][single_rowcol_df.index.values[0]] for col_name in single_rowcol_df.columns}
    elif single_rowcol_df.shape[1] == 2 and isinstance(single_rowcol_df.index, pd.RangeIndex):
        # two columns but the index contains nothing but the row number : we can use the first column
        d = single_rowcol_df.set_index(single_rowcol_df.columns[0])
        return d[d.columns[0]].to_dict()
    elif single_rowcol_df.shape[1] == 1:
        # one column and one index
        d = single_rowcol_df
        return d[d.columns[0]].to_dict()
    else:
        raise ValueError('Unable to convert provided dataframe to a parameters dictionary : '
                         'expected exactly 1 row or 1 column, found : ' + str(single_rowcol_df.shape) + '')"
1537,"def get_default_pandas_converters() -> List[Union[Converter[Any, pd.DataFrame],
                                                  Converter[pd.DataFrame, Any]]]:
    """"""
    Utility method to return the default converters associated to dataframes (from dataframe to other type,
    and from other type to dataframe)
    :return:
    """"""
    return [ConverterFunction(from_type=pd.DataFrame, to_type=dict, conversion_method=single_row_or_col_df_to_dict),
            ConverterFunction(from_type=dict, to_type=pd.DataFrame, conversion_method=dict_to_df,
                              option_hints=dict_to_single_row_or_col_df_opts),
            ConverterFunction(from_type=pd.DataFrame, to_type=pd.Series,
                              conversion_method=single_row_or_col_df_to_series)]"
1538,"def full_subgraph(self, vertices):
        """"""
        Return the subgraph of this graph whose vertices
        are the given ones and whose edges are all the edges
        of the original graph between those vertices.

        """"""
        subgraph_vertices = {v for v in vertices}
        subgraph_edges = {edge
                          for v in subgraph_vertices
                          for edge in self._out_edges[v]
                          if self._heads[edge] in subgraph_vertices}
        subgraph_heads = {edge: self._heads[edge]
                          for edge in subgraph_edges}
        subgraph_tails = {edge: self._tails[edge]
                          for edge in subgraph_edges}
        return DirectedGraph._raw(
            vertices=subgraph_vertices,
            edges=subgraph_edges,
            heads=subgraph_heads,
            tails=subgraph_tails,
        )"
1539,"def _raw(cls, vertices, edges, heads, tails):
        """"""
        Private constructor for direct construction of
        a DirectedGraph from its consituents.

        """"""
        self = object.__new__(cls)
        self._vertices = vertices
        self._edges = edges
        self._heads = heads
        self._tails = tails

        # For future use, map each vertex to its outward and inward edges.
        # These could be computed on demand instead of precomputed.
        self._out_edges = collections.defaultdict(set)
        self._in_edges = collections.defaultdict(set)
        for edge in self._edges:
            self._out_edges[self._tails[edge]].add(edge)
            self._in_edges[self._heads[edge]].add(edge)
        return self"
1540,"def from_out_edges(cls, vertices, edge_mapper):
        """"""
        Create a DirectedGraph from a collection of vertices and
        a mapping giving the vertices that each vertex is connected to.

        """"""
        vertices = set(vertices)
        edges = set()
        heads = {}
        tails = {}

        # Number the edges arbitrarily.
        edge_identifier = itertools.count()
        for tail in vertices:
            for head in edge_mapper[tail]:
                edge = next(edge_identifier)
                edges.add(edge)
                heads[edge] = head
                tails[edge] = tail

        return cls._raw(
            vertices=vertices,
            edges=edges,
            heads=heads,
            tails=tails,
        )"
1541,"def from_edge_pairs(cls, vertices, edge_pairs):
        """"""
        Create a DirectedGraph from a collection of vertices
        and a collection of pairs giving links between the vertices.

        """"""
        vertices = set(vertices)
        edges = set()
        heads = {}
        tails = {}

        # Number the edges arbitrarily.
        edge_identifier = itertools.count()
        for tail, head in edge_pairs:
            edge = next(edge_identifier)
            edges.add(edge)
            heads[edge] = head
            tails[edge] = tail

        return cls._raw(
            vertices=vertices,
            edges=edges,
            heads=heads,
            tails=tails,
        )"
1542,"def annotated(self):
        """"""
        Return an AnnotatedGraph with the same structure
        as this graph.

        """"""
        annotated_vertices = {
            vertex: AnnotatedVertex(
                id=vertex_id,
                annotation=six.text_type(vertex),
            )
            for vertex_id, vertex in zip(itertools.count(), self.vertices)
        }

        annotated_edges = [
            AnnotatedEdge(
                id=edge_id,
                annotation=six.text_type(edge),
                head=annotated_vertices[self.head(edge)].id,
                tail=annotated_vertices[self.tail(edge)].id,
            )
            for edge_id, edge in zip(itertools.count(), self.edges)
        ]

        return AnnotatedGraph(
            vertices=annotated_vertices.values(),
            edges=annotated_edges,
        )"
1543,"def execute_command(working_dir, cmd, env_dict):
    """"""
    execute_command: run the command provided in the working dir
    specified adding the env_dict settings to the
    execution environment

    :param working_dir: path to directory to execute command
       also gets added to the PATH
    :param cmd: Shell command to execute
    :param env_dict: dictionary of additional env vars to
      be passed to the subprocess environment

    """"""
    proc_env = os.environ.copy()
    proc_env[""PATH""] = ""{}:{}:."".format(proc_env[""PATH""], working_dir)
    proc_env.update(env_dict)
    proc = subprocess.Popen(
        cmd,
        cwd=working_dir,
        env=proc_env,
        shell=True,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )
    status = proc.wait()
    stdout, stderr = proc.communicate()
    if status:
        msg = (
            ""Non zero {} exit from command {}\n""
            ""Stdout: {}\n""
            ""Stderr: {}\n""
        ).format(status, cmd, stdout, stderr)
        LOGGER.error(msg)
        raise RuntimeError(msg)
    LOGGER.info(stdout)"
1544,"def load(self):
        """"""
        read dotfile and populate self
        opts will override the dotfile settings,
        make sure everything is synced in both
        opts and this object

        """"""
        if self.exists():
            with open(self.dot_file, 'r') as handle:
                self.update(json.load(handle))
        if self.options['context'] is not None:
            self['context'] = self.options['context']
        else:
            self.options['context'] = self['context']
        if self.options['defaults'] is not None:
            self['defaults'] = self.options['defaults']
        else:
            self.options['defaults'] = self['defaults']
        if self.options['output'] is not None:
            self['output'] = self.options['output']

        if self.options.get('inclusive', False):
            self['inclusive'] = True

        if self.options.get('exclude', []):
            self['exclude'].extend(self.options['exclude'])

        if self['output'] is None:
            self['output'] = os.path.join(os.getcwd(), 'dockerstache-output')
        self['output_path'] = self.abs_output_dir()
        self['input_path'] = self.abs_input_dir()
        if self['context'] is not None:
            self['context_path'] = absolute_path(self['context'])
        if self['defaults'] is not None:
            self['defaults_path'] = absolute_path(self['defaults'])"
1545,"def env_dictionary(self):
        """"""
        convert the options to this script into an
        env var dictionary for pre and post scripts
        """"""
        none_to_str = lambda x: str(x) if x else """"
        return {""DOCKERSTACHE_{}"".format(k.upper()): none_to_str(v) for k, v in six.iteritems(self)}"
1546,"def pre_script(self):
        """"""
        execute the pre script if it is defined
        """"""
        if self['pre_script'] is None:
            return
        LOGGER.info(""Executing pre script: {}"".format(self['pre_script']))
        cmd = self['pre_script']
        execute_command(self.abs_input_dir(), cmd, self.env_dictionary())
        LOGGER.info(""Pre Script completed"")"
1547,"def say(
    text               = None,
    preference_program = ""festival"",
    background         = False,
    silent             = True,
    filepath           = None
    ):
    """"""
    Say specified text to speakers or to file, as specified. Determine the
    program to use based on the specified program preference and availability,
    then say the text to speakers or synthesize speech of the text and save it
    to file, as specified.
    """"""
    if not text:
        if not silent:
            print(""text not specified"")
        return False
    # Determine the program to use based on program preference and program
    # availability.
    preference_order_programs = [
        ""festival"",
        ""espeak"",
        ""pico2wave"",
        ""deep_throat.py""
    ]
    # Remove the specified preference program from the default program
    # preferences order and prioritise it.
    preference_order_programs.remove(preference_program)
    preference_order_programs.insert(0, preference_program)
    # Determine first program that is available in the programs order of
    # preference.
    preference_order_programs_available =\
        [program for program in preference_order_programs \
            if shijian.which(program) is not None]
    if not preference_order_programs_available:
        if not silent:
            print(""text-to-speech program unavailable"")
        return False
    program = preference_order_programs_available[0]
    if program != preference_program and not silent:
        print(""text-to-speech preference program unavailable, using {program}"".format(program = program))
    if program == ""festival"":
        if not filepath:
            command = """"""
            echo ""{text}"" | festival --tts
            """""".format(text = text)
        else:
            command = """"""
            echo ""{text}"" | text2wave -o {filepath}
            """""".format(text = text, filepath = filepath)
    elif program == ""espeak"":
        if not filepath:
            command = """"""
            echo ""{text}"" | espeak
            """""".format(text = text)
        else:
            command = """"""
            echo ""{text}"" | espeak -w {filepath}
            """""".format(text = text, filepath = filepath)
    elif program == ""pico2wave"":
        if not filepath:
            command = """"""
            pico2wave --wave=""{filepath}"" ""{text}""
            aplay --quiet ""{filepath}""
            """""".format(text = text, filepath = shijian.tmp_filepath() + "".wav"")
        else:
            command = """"""
            pico2wave --wave=""{filepath}"" ""{text}""
            """""".format(text = text, filepath = filepath)
    elif program == ""deep_throat.py"":
        if not filepath:
            command = """"""
            echo ""{text}"" | deep_throat.py
            """""".format(text = text)
        else:
            command = """"""
            deep_throat.py --text=""{text}"" --savetowavefile --outfile=""{filepath}""
            """""".format(text = text, filepath = filepath)
    if filepath:
        background = False
    if background:
        command = command.rstrip().rstrip(""\n"") + "" &""
    command = textwrap.dedent(command)
    engage_command(command = command, background = background)"
1548,"def say_tmp_filepath(
    text               = None,
    preference_program = ""festival""
    ):
    """"""
    Say specified text to a temporary file and return the filepath.
    """"""
    filepath = shijian.tmp_filepath() + "".wav""
    say(
        text               = text,
        preference_program = preference_program,
        filepath           = filepath
    )
    return filepath"
1549,"def clacks_overhead(fn):
    """"""
    A Django view decorator that will add the `X-Clacks-Overhead` header.

    Usage:

        @clacks_overhead
        def my_view(request):
            return my_response

    """"""
    @wraps(fn)
    def _wrapped(*args, **kw):
        response = fn(*args, **kw)
        response['X-Clacks-Overhead'] = 'GNU Terry Pratchett'
        return response

    return _wrapped"
1550,"def render(self, request, template, context):
        """"""
        Returns a response. By default, this will contain the rendered PDF, but
        if both ``allow_force_html`` is ``True`` and the querystring
        ``html=true`` was set it will return a plain HTML.
        """"""
        if self.allow_force_html and self.request.GET.get('html', False):
            html = get_template(template).render(context)
            return HttpResponse(html)
        else:
            response = HttpResponse(content_type='application/pdf')
            if self.prompt_download:
                response['Content-Disposition'] = 'attachment; filename=""{}""' \
                    .format(self.get_download_name())
            helpers.render_pdf(
                template=template,
                file_=response,
                url_fetcher=self.url_fetcher,
                context=context,
            )
            return response"
1551,"def _bfs_path_states(self, graph, start):
        """"""
        Find state access strings (DFA shortest paths for every state)
        using BFS
        Args:
            graph (DFA): The DFA states
            start (int): The DFA initial state
        Return:
            list: A list of all the DFA shortest paths for every state
        """"""
        pathstates = {}
        # maintain a queue of paths
        queue = []
        visited = []
        # push the first path into the queue
        queue.append([['', start]])
        while queue:
            # get the first path from the queue
            path = queue.pop(0)
            # get the last node from the path
            node = path[-1][1]
            # path found """"""
            if node.stateid not in pathstates and node.stateid != len(list(graph.states)):
                pathstates[node.stateid] = ''.join(
                    [mnode[0] for mnode in path])
            visited.append(node.stateid)
            # enumerate all adjacent nodes, construct a new path and push it
            # into the queue
            for arc in node.arcs:
                char = graph.isyms.find(arc.ilabel)
                next_state = graph[arc.nextstate]
                if next_state.stateid not in visited:
                    new_path = list(path)
                    new_path.append([char, next_state])
                    queue.append(new_path)
        return pathstates"
1552,"def _get_accepted(self, graph):
        """"""
        Find the accepted states
        Args:
            graph (DFA): The DFA states
        Return:
            list: Returns the list of the accepted states
        """"""
        accepted = []
        for state in graph.states:
            if state.final != TropicalWeight(float('inf')):
                accepted.append(state)
        return accepted"
1553,"def _object_set_to_state_list(self, objectset):
        """"""
        Args:
            objectset (list): A list of all the DFA states (as objects)
        Return:
            list: A list of all the DFA states (as identifiers)
        """"""
        state_list = []
        for state in list(objectset):
            state_list.append(state.stateid)
        return state_list"
1554,"def _get_group_from_state(self, sid):
        """"""
        Args:
            sid (int): The state identifier
        Return:
            int: The group identifier that the state belongs
        """"""
        for index, selectgroup in enumerate(self.groups):
            if sid in selectgroup:
                return index"
1555,"def _reverse_to_source(self, target, group1):
        """"""
        Args:
            target (dict): A table containing the reverse transitions for each state
            group1 (list): A group of states
        Return:
            Set: A set of states for which there is a transition with the states of the group
        """"""
        new_group = []
        for dst in group1:
            new_group += target[dst]
        return set(new_group)"
1556,"def _partition_group(self, group):
        """"""
        Args:
            group (list):  A group of states
        Return:
            tuple: A set of two groups
        """"""
        for (group1, group2, distinguish_string) in self.bookeeping:
            if group & group1 != set() and not group.issubset(group1):
                new_g1 = group & group1
                new_g2 = group - group1
                return (new_g1, new_g2, distinguish_string)
            if group & group2 != set() and not group.issubset(group2):
                new_g1 = group & group2
                new_g2 = group - group2
                return (new_g1, new_g2, distinguish_string)
        assert False, ""Unmatched group partition"""
1557,"def _init_smi(self, graph, access_strings_map):
        """"""
        Args:
            graph (DFA): The DFA states
            access_strings_map (list): a dict containing all the access strings for each state
        Return:
            list: SMI transition table
        """"""
        smi = []
        for selected_state in sorted(graph.states, key=attrgetter('initial'), reverse=True):
            # Initially gather all transitions of the state into a dictionary
            transitions_map = defaultdict(list)
            for character in self.alphabet:
                destination_state = self._delta(graph, selected_state, character)
                transitions_map[destination_state.stateid].append(character)

            chars_in_smi = []
            sorted_transitions = sorted(
                transitions_map.items(),
                key=lambda x: len(
                    x[1]))

            if len(sorted_transitions) == 1:
                # Just put 1 symbol is enough all other'input_string will be generalized
                # by the guardgen algorithm
                chars_in_smi.append(self.alphabet[0])
            else:
                # Otherwise insert in smi_vector all transitions as explicit except
                # the one from the sink transition where we add just enough
                # explicity transitions to make sure that this state will be
                # selected as the sink state.
                #
                # If no transition has a clear advantage in terms of symbols then
                # just add all transitions in explicit form because it may be the
                # case the guardgen() will generalize in the wrong transition.
                for (_, char_list) in sorted_transitions[:-1]:
                    chars_in_smi += char_list

                sink_chars = len(sorted_transitions[-2][1]) + 1
                chars_in_smi.extend(sorted_transitions[-1][1][:sink_chars])

            access_string = access_strings_map[selected_state.stateid]
            smi.extend([access_string + character for character in chars_in_smi])
        return smi"
1558,"def _init_using_k_equivalence(self, given_graph, sfa=False):
        """"""
        Args:
            given_graph (DFA): The DFA states
            sfa (boolean): A boolean for chosing SFA
        Return:
            list, list, list: sm_vector, smi_vector, em_vector initialization vectors
        """"""
        graph = DFA(self.alphabet)
        graph.init_from_acceptor(given_graph)
        graph.fixminimized(self.alphabet)

        # Access Strings
        self.access_strings_map = self._bfs_path_states(graph, sorted(
            graph.states, key=attrgetter('initial'), reverse=True)[0])

        # Find Q
        set_q = set(self._object_set_to_state_list(graph.states))
        # We will work with states addresses here instead of states stateid for
        # more convenience
        set_f = set(self._object_set_to_state_list(self._get_accepted(graph)))
        # Perform P := {F, Q-F}
        set_nf = set_q.copy() - set_f.copy()
        self.groups = [set_f.copy(), set_nf.copy()]
        self.bookeeping = [(set_f, set_nf, '')]

        done = False
        while not done:
            done = True
            new_groups = []
            for selectgroup in self.groups:
                # _check for each letter if it splits the current group
                for character in self.alphabet:
                    # print 'Testing symbol: ', c
                    target = defaultdict(list)
                    target_states = defaultdict(int)
                    new_g = [set(selectgroup)]
                    for sid in selectgroup:
                        # _check if all transitions using c are going in a state
                        # in the same group. If they are going on a different
                        # group then split
                        deststate = self._delta(graph, graph[sid], character)
                        destgroup = self._get_group_from_state(
                            deststate.stateid)
                        target[destgroup].append(sid)
                        target_states[destgroup] = deststate.stateid
                    if len(target) > 1:

                        inv_target_states = {
                            v: k for k, v in target_states.iteritems()}
                        new_g = [set(selectedstate) for selectedstate in target.values()]
                        done = False
                        # Get all the partitions of destgroups
                        queue = [set([x for x in target_states.values()])]
                        while queue:
                            top = queue.pop(0)
                            (group1, group2, distinguish_string) = self._partition_group(top)
                            ng1 = self._reverse_to_source(
                                target, [inv_target_states[x] for x in group1])
                            ng2 = self._reverse_to_source(
                                target, [inv_target_states[x] for x in group2])
                            dist_string = character + distinguish_string

                            self.bookeeping.append((ng1, ng2, dist_string))

                            if len(group1) > 1:
                                queue.append(group1)
                            if len(group2) > 1:
                                queue.append(group2)
                        break
                new_groups += new_g

            # End of iteration for the k-equivalence
            # Assign new groups and check if any change occured
            self.groups = new_groups

        sm_vector = [
            i for (a, i) in sorted(
                self.access_strings_map.items(),
                key=lambda x: len(x[1]))]
        if not sfa:
            smi_vector = ['{}{}'.format(a, b)
                          for b in self.alphabet for a in sm_vector]
        else:
            smi_vector = self._init_smi(graph, self.access_strings_map)
        em_vector = [distinguish_string for (_, _, distinguish_string) in self.bookeeping]

        return sm_vector, smi_vector, em_vector"
1559,"def initialize(self, givengraph, sfa=False):
        """"""
        Args:
            givengraph (DFA): The DFA states
            sfa (bool): A boolean for chosing SFA
        Return:
            list, list, list: sm_vector, smi_vector, em_vector initialization vectors
        """"""
        sm_vector, smi_vector, em_vector = self._init_using_k_equivalence(
            givengraph, sfa)
        return sm_vector, smi_vector, em_vector"
1560,"def push(self,message,message_type):
        """"""
        Send a reply message of the given type
        
        Args:
            - message: the message to publish
            - message_type: the type of message being sent
        """"""
            
        super(Producer,self).send(message,message_type)"
1561,"def label_weight(base, label_name=None, children=[], parents=[],
                 dependencies=[]):
    """"""
    Function that returns a Formatoption class for modifying the fontweight

    This function returns a :class:`~psyplot.plotter.Formatoption` instance
    that modifies the weight of the given `base` formatoption

    Parameters
    ----------
    base: Formatoption
        The base formatoption instance that is used in the
        :class:`psyplot.Plotter` subclass to create the label. The instance
        must have a ``texts`` attribute which stores all the
        :class:`matplotlib.text.Text` instances.
    label_name: str
        The name of the label to use in the documentation. If None,
        it will be ``key``, where ``key`` is the
        :attr:`psyplot.plotter.Formatoption.key`` attribute of `base`
    children: list of str
        The childrens of the resulting formatoption class (besides the `base`
        formatoption which is included anyway)
    parents: list of str
        The parents of the resulting formatoption class (besides the `base`
        the properties formatoption from `base` (see :func:`label_props`))
    dependencies: list of str
        The dependencies of the formatoption

    Returns
    -------
    Formatoption
        The formatoption instance that modifies the fontweight of `base`

    See Also
    --------
    label_size, label_props, Figtitle, Title""""""
    label_name = label_name or base.key
    cl_children = children
    cl_parents = parents
    cl_dependencies = dependencies

    class LabelWeight(Formatoption):
        __doc__ = """"""
        Set the fontweight of the %s

        Possible types
        --------------
        %%(fontweights)s

        See Also
        --------
        %s, %s, %s"""""" % (label_name, base.key, base.key + 'size',
                         base.key + 'props')
        children = [base.key] + \
            cl_children
        parent = [base.key + 'props'] + cl_parents
        dependencies = cl_dependencies

        group = 'labels'

        name = 'Font weight of ' + (base.name or base.key)

        def update(self, value):
            for text in getattr(self, base.key).texts:
                text.set_weight(value)

        def get_fmt_widget(self, parent, project):
            """"""Get a widget with the different font weights""""""
            from psy_simple.widgets.texts import FontWeightWidget
            return FontWeightWidget(
                parent, self, next(iter(getattr(self, base.key).texts), None),
                base)

    return LabelWeight(base.key + 'weight')"
1562,"def label_size(base, label_name=None, children=[], parents=[],
               dependencies=[]):
    """"""
    Function that returns a Formatoption class for modifying the fontsite

    This function returns a :class:`~psyplot.plotter.Formatoption` instance
    that modifies the size of the given `base` formatoption

    Parameters
    ----------
    %(label_weight.parameters)s

    Returns
    -------
    Formatoption
        The formatoption instance that modifies the fontsize of `base`

    See Also
    --------
    label_weight, label_props, Figtitle, Title""""""
    label_name = label_name or base.key
    cl_children = children
    cl_parents = parents
    cl_dependencies = dependencies

    class LabelSize(Formatoption):
        __doc__ = """"""
        Set the size of the %s

        Possible types
        --------------
        %%(fontsizes)s

        See Also
        --------
        %s, %s, %s"""""" % (label_name, base.key, base.key + 'weight',
                         base.key + 'props')
        children = [base.key] + cl_children
        parent = [base.key + 'props'] + cl_parents
        dependencies = cl_dependencies

        group = 'labels'

        name = 'Font size of ' + (base.name or base.key)

        def update(self, value):
            for text in getattr(self, base.key).texts:
                text.set_size(value)

        def get_fmt_widget(self, parent, project):
            """"""Get a widget with the different font weights""""""
            from psy_simple.widgets.texts import FontSizeWidget
            return FontSizeWidget(
                parent, self, next(iter(getattr(self, base.key).texts), None),
                base)

    return LabelSize(base.key + 'size')"
1563,"def label_props(base, label_name=None, children=[], parents=[],
                dependencies=[]):
    """"""
    Function that returns a Formatoption class for modifying the fontsite

    This function returns a :class:`~psyplot.plotter.Formatoption` instance
    that modifies the size of the given `base` formatoption

    Parameters
    ----------
    %(label_weight.parameters)s
    children: list of str
        The childrens of the resulting formatoption class (besides the `base`
        formatoption, the ``base.key + 'size'`` and ``base.key + 'weight'``
        keys, which are included anyway (see :func:`label_size`,
        :func:`label_weight`))
    parents: list of str
        The parents of the resulting formatoption class

    Returns
    -------
    Formatoption
        The formatoption instance that modifies the fontsize of `base`

    See Also
    --------
    label_weight, label_props, Figtitle, Title""""""
    label_name = label_name or base.key
    cl_children = children
    cl_parents = parents
    cl_dependencies = dependencies

    class LabelProps(Formatoption):
        __doc__ = """"""
        Properties of the %s

        Specify the font properties of the figure title manually.

        Possible types
        --------------
        dict
            Items may be any valid text property

        See Also
        --------
        %s, %s, %s"""""" % (label_name, base.key, base.key + 'size',
                         base.key + 'weight')
        children = [base.key, base.key + 'size', base.key + 'weight'] + \
            cl_children
        parents = cl_parents
        dependencies = cl_dependencies

        group = 'labels'

        name = 'Font properties of ' + (base.name or base.key)

        def __init__(self, *args, **kwargs):
            super(LabelProps, self).__init__(*args, **kwargs)
            self.default_props = {}
            self._todefault = False

        def set_value(self, value, validate=True, todefault=False):
            self._todefault = todefault
            super(LabelProps, self).set_value(value, validate, todefault)

        def update(self, fontprops):
            fontprops = fontprops.copy()
            # store default font properties
            try:
                text = next(iter(getattr(self, base.key).texts))
            except StopIteration:
                return
            # TODO: This handling of the default management is not really
            # satisfying because you run into troubles when using alternate
            # property names (e.g. if you use 'ha' and 'horizontalalignment'
            # at the same time)
            if not self._todefault:
                for key in fontprops:
                    if key == 'bbox':
                        default = dict(facecolor='none', edgecolor='none')
                    else:
                        default = getattr(text, 'get_' + key)()
                    self.default_props.setdefault(key, default)
            else:
                fontprops = self.default_props.copy()
                self.default_props.clear()
            if 'size' not in fontprops and 'fontsize' not in fontprops:
                fontprops['size'] = getattr(self, base.key + 'size').value
            if 'weight' not in fontprops and 'fontweight' not in fontprops:
                fontprops['weight'] = getattr(self, base.key + 'weight').value
            for text in getattr(self, base.key).texts:
                text.update(fontprops)
            self._todefault = False

        def get_fmt_widget(self, parent, project):
            """"""Get a widget with the different font weights""""""
            from psy_simple.widgets.texts import FontPropertiesWidget
            return FontPropertiesWidget(
                parent, self, next(iter(getattr(self, base.key).texts), None),
                base)

    return LabelProps(base.key + 'props')"
1564,"def replace(self, s, data, attrs=None):
        """"""
        Replace the attributes of the plotter data in a string

        %(replace_note)s

        Parameters
        ----------
        s: str
            String where the replacements shall be made
        data: InteractiveBase
            Data object from which to use the coordinates and insert the
            coordinate and attribute informations
        attrs: dict
            Meta attributes that shall be used for replacements. If None, it
            will be gained from `data.attrs`

        Returns
        -------
        str
            `s` with inserted informations""""""
        # insert labels
        s = s.format(**self.rc['labels'])
        # replace attributes
        attrs = attrs or data.attrs
        if hasattr(getattr(data, 'psy', None), 'arr_name'):
            attrs = attrs.copy()
            attrs['arr_name'] = data.psy.arr_name
        s = safe_modulo(s, attrs)
        # replace datetime.datetime like time informations
        if isinstance(data, InteractiveList):
            data = data[0]
        tname = self.any_decoder.get_tname(
            next(self.plotter.iter_base_variables), data.coords)
        if tname is not None and tname in data.coords:
            time = data.coords[tname]
            if not time.values.ndim:
                try:  # assume a valid datetime.datetime instance
                    s = pd.to_datetime(str(time.values[()])).strftime(s)
                except ValueError:
                    pass
        if six.PY2:
            return s.decode('utf-8')
        return s"
1565,"def get_fig_data_attrs(self, delimiter=None):
        """"""Join the data attributes with other plotters in the project

        This method joins the attributes of the
        :class:`~psyplot.InteractiveBase` instances in the project that
        draw on the same figure as this instance does.

        Parameters
        ----------
        delimiter: str
            Specifies the delimiter with what the attributes are joined. If
            None, the :attr:`delimiter` attribute of this instance or (if the
            latter is also None), the rcParams['texts.delimiter'] item is used.

        Returns
        -------
        dict
            A dictionary with all the meta attributes joined by the specified
            `delimiter`""""""
        if self.project is not None:
            delimiter = next(filter(lambda d: d is not None, [
                delimiter, self.delimiter, self.rc['delimiter']]))
            figs = self.project.figs
            fig = self.ax.get_figure()
            if self.plotter._initialized and fig in figs:
                ret = figs[fig].joined_attrs(delimiter=delimiter,
                                             plot_data=True)
            else:
                ret = self.get_enhanced_attrs(self.plotter.plot_data)
                self.logger.debug(
                    'Can not get the figure attributes because plot has not '
                    'yet been initialized!')
            return ret
        else:
            return self.get_enhanced_attrs(self.plotter.plot_data)"
1566,"def get_fmt_widget(self, parent, project):
        """"""Create a combobox with the attributes""""""
        from psy_simple.widgets.texts import LabelWidget
        return LabelWidget(parent, self, project)"
1567,"def clear_other_texts(self, remove=False):
        """"""Make sure that no other text is a the same position as this one

        This method clears all text instances in the figure that are at the
        same position as the :attr:`_text` attribute

        Parameters
        ----------
        remove: bool
            If True, the Text instances are permanently deleted from the
            figure, otherwise there text is simply set to ''""""""
        fig = self.ax.get_figure()
        # don't do anything if our figtitle is the only Text instance
        if len(fig.texts) == 1:
            return
        for i, text in enumerate(fig.texts):
            if text == self._text:
                continue
            if text.get_position() == self._text.get_position():
                if not remove:
                    text.set_text('')
                else:
                    del fig[i]"
1568,"def transform(self):
        """"""Dictionary containing the relevant transformations""""""
        ax = self.ax
        return {'axes': ax.transAxes,
                'fig': ax.get_figure().transFigure,
                'data': ax.transData}"
1569,"def _remove_texttuple(self, pos):
        """"""Remove a texttuple from the value in the plotter

        Parameters
        ----------
        pos: tuple (x, y, cs)
            x and y are the x- and y-positions and cs the coordinate system""""""
        for i, (old_x, old_y, s, old_cs, d) in enumerate(self.value):
            if (old_x, old_y, old_cs) == pos:
                self.value.pop(i)
                return
        raise ValueError(""{0} not found!"".format(pos))"
1570,"def _update_texttuple(self, x, y, s, cs, d):
        """"""Update the text tuple at `x` and `y` with the given `s` and `d`""""""
        pos = (x, y, cs)
        for i, (old_x, old_y, old_s, old_cs, old_d) in enumerate(self.value):
            if (old_x, old_y, old_cs) == pos:
                self.value[i] = (old_x, old_y, s, old_cs, d)
                return
        raise ValueError(""No text tuple found at {0}!"".format(pos))"
1571,"def share(self, fmto, **kwargs):
        """"""Share the settings of this formatoption with other data objects

        Parameters
        ----------
        fmto: Formatoption
            The :class:`Formatoption` instance to share the attributes with
        ``**kwargs``
            Any other keyword argument that shall be passed to the update
            method of `fmto`

        Notes
        -----
        The Text formatoption sets the 'texts_to_remove' keyword to the
        :attr:`_texts_to_remove` attribute of this instance (if not already
        specified in ``**kwargs``""""""
        kwargs.setdefault('texts_to_remove', self._texts_to_remove)
        super(Text, self).share(fmto, **kwargs)"
1572,"def save(self, *args, **kwargs):
        """"""
        **uid**: :code:`person:{slug}`
        """"""

        self.slug = uuslug(
            self.name,
            instance=self,
            max_length=100,
            separator='-',
            start_no=2
        )
        if not self.uid:
            self.uid = 'organization:{}'.format(self.slug)

        super(Organization, self).save(*args, **kwargs)"
1573,"def replace_variables(self, source: str, variables: dict) -> str:
        """"""Replace {{variable-name}} with stored value.""""""
        try:
            replaced = re.sub(
                ""{{(.*?)}}"", lambda m: variables.get(m.group(1), """"), source
            )
        except TypeError:
            replaced = source
        return replaced"
1574,"def preprocess_cell(
        self, cell: ""NotebookNode"", resources: dict, index: int
    ) -> Tuple[""NotebookNode"", dict]:
        """"""Preprocess cell.

        Parameters
        ----------
        cell : NotebookNode cell
            Notebook cell being processed
        resources : dictionary
            Additional resources used in the conversion process. Allows
            preprocessors to pass variables into the Jinja engine.
        cell_index : int
            Index of the cell being processed (see base.py)

        """"""
        if cell.cell_type == ""markdown"":
            variables = cell[""metadata""].get(""variables"", {})
            if len(variables) > 0:
                cell.source = self.replace_variables(cell.source, variables)
                if resources.get(""delete_pymarkdown"", False):
                    del cell.metadata[""variables""]
        return cell, resources"
1575,"def emit(self, ast_reg, ast_guide):
        ''' Default emit method: visit both ASTs and return the codegen '''
        if (ast_reg):
            self.visit(ast_reg)
        codegen_reg = self.codegen
        self.codegen = self.cg_type()
        if (ast_guide):
            self.visit(ast_guide)
        return (codegen_reg, self.codegen)"
1576,"def index_dir(self, folder):
        """"""
        Creates a nested dictionary that represents the folder structure of folder.
        Also extracts meta data from all markdown posts and adds to the dictionary.
        """"""
        folder_path = folder
        print('Indexing folder: ' + folder_path)
        nested_dir = {}
        folder = folder_path.rstrip(os.sep)
        start = folder.rfind(os.sep) + 1
        for root, dirs, files in os.walk(folder):
            folders = root[start:].split(os.sep)
            # subdir = dict.fromkeys(files)
            subdir = {}
            for f in files:
                # Create an entry for every markdown file
                if os.path.splitext(f)[1] == '.md':
                    with open(os.path.abspath(os.path.join(root, f)), encoding='utf-8') as fp:
                        try:
                            _, meta = self.mrk.extract_meta(fp.read())
                        except:
                            print(""Skipping indexing "" + f +""; Could not parse metadata"")
                            meta = {'title': f}
                            pass
                    # Value of the entry (the key) is it's metadata
                    subdir[f] = meta
            parent = nested_dir
            for fold in folders[:-1]:
                parent = parent.get(fold)
            # Attach the config of all children nodes onto the parent
            parent[folders[-1]] = subdir
        return nested_dir"
1577,"def _parse_orders(self, orders):
        """"""
        Transform orders from list objects to PHP arrays:
            [
                {
                    'PNAME': 'CD Player',
                    'PCODE': 'PROD_04891',
                    'PINFO': 'Extended Warranty - 5 Years',
                    'PRICE': '82.3',
                    'PRICE_TYPE': 'GROSS',
                    'QTY': '7',
                    'VAT':'20'
                },
                {
                    'PNAME': 'Mobile Phone',
                    'PCODE': 'PROD_07409',
                    'PINFO': 'Dual SIM',
                    'PRICE': '1945.75',
                    'PRICE_TYPE': 'GROSS',
                    'QTY': '3',
                    'VAT':'20'
                },
                {
                    'PNAME': 'Laptop',
                    'PCODE': 'PROD_04965',
                    'PINFO': '17"" Display',
                    'PRICE': '5230',
                    'PRICE_TYPE': 'GROSS',
                    'QTY': '1',
                    'VAT':'20'
                }
            ]

                ||
                \/

            {
                 'ORDER_PCODE[0]': 'PROD_04891',
                 'ORDER_PCODE[1]': 'PROD_07409',
                 'ORDER_PCODE[2]': 'PROD_04965',
                 'ORDER_PINFO[0]': 'Extended Warranty - 5 Years',
                 'ORDER_PINFO[1]': 'Dual SIM',
                 'ORDER_PINFO[2]': '17"" Display',
                 'ORDER_PNAME[0]': 'CD Player',
                 'ORDER_PNAME[1]': 'Mobile Phone',
                 'ORDER_PNAME[2]': 'Laptop',
                 'ORDER_PRICE[0]': '82.3',
                 'ORDER_PRICE[1]': '1945.75',
                 'ORDER_PRICE[2]': '5230',
                 'ORDER_PRICE_TYPE[0]': 'GROSS',
                 'ORDER_PRICE_TYPE[1]': 'GROSS',
                 'ORDER_PRICE_TYPE[2]': 'GROSS',
                 'ORDER_QTY[0]': '7',
                 'ORDER_QTY[1]': '3',
                 'ORDER_QTY[2]': '1',
                 'ORDER_VAT[0]': '20',
                 'ORDER_VAT[1]': '20',
                 'ORDER_VAT[2]': '20'
            }
        """"""

        result = {}

        for index, order in enumerate(orders):
            for detail, value in order.iteritems():
                result[""ORDER_%s[%s]"" % (detail, index)] = value

        return result"
1578,"def average_detections(detections, predictions, relative_prediction_threshold = 0.25):
  """"""average_detections(detections, predictions, [relative_prediction_threshold]) -> bounding_box, prediction

  Computes the weighted average of the given detections, where the weights are computed based on the prediction values.

  **Parameters:**

  ``detections`` : [:py:class:`BoundingBox`]
    The overlapping bounding boxes.

  ``predictions`` : [float]
    The predictions for the ``detections``.

  ``relative_prediction_threshold`` : float between 0 and 1
    Limits the bounding boxes to those that have a prediction value higher then ``relative_prediction_threshold * max(predictions)``

  **Returns:**

  ``bounding_box`` : :py:class:`BoundingBox`
    The bounding box which has been merged from the detections

  ``prediction`` : float
    The prediction value of the bounding box, which is a weighted sum of the predictions with minimum overlap
  """"""
  # remove the predictions that are too low
  prediction_threshold = relative_prediction_threshold * max(predictions)
  detections, predictions = zip(*[[d,p] for d,p in zip(detections, predictions) if p >= prediction_threshold])

  # turn remaining predictions into weights
  s = sum(predictions)
  weights = [p/s for p in predictions]
  # compute weighted average of bounding boxes
  top = sum(w * b.topleft_f[0] for w, b in zip(weights, detections))
  left = sum(w * b.topleft_f[1] for w, b in zip(weights, detections))
  bottom = sum(w * b.bottomright_f[0] for w, b in zip(weights, detections))
  right = sum(w * b.bottomright_f[1] for w, b in zip(weights, detections))

  # compute the average prediction value
  value = sum(w*p for w,p in zip(weights, predictions))

  # return the average bounding box
  return BoundingBox((top, left), (bottom-top, right-left)), value"
1579,"def best_detection(detections, predictions, minimum_overlap = 0.2, relative_prediction_threshold = 0.25):
  """"""best_detection(detections, predictions, [minimum_overlap], [relative_prediction_threshold]) -> bounding_box, prediction

  Computes the best detection for the given detections and according predictions.

  This is achieved by computing a weighted sum of detections that overlap with the best detection (the one with the highest prediction), where the weights are based on the predictions.
  Only detections with according prediction values > 0 are considered.

  **Parameters:**

  ``detections`` : [:py:class:`BoundingBox`]
    The detected bounding boxes.

  ``predictions`` : [float]
    The predictions for the ``detections``.

  ``minimum_overlap`` : float between 0 and 1
    The minimum overlap (in terms of Jaccard :py:meth:`BoundingBox.similarity`) of bounding boxes with the best detection to be considered.

  ``relative_prediction_threshold`` : float between 0 and 1
    Limits the bounding boxes to those that have a prediction value higher then ``relative_prediction_threshold * max(predictions)``

  **Returns:**

  ``bounding_box`` : :py:class:`BoundingBox`
    The bounding box which has been merged from the detections

  ``prediction`` : float
    The prediction value of the bounding box, which is a weighted sum of the predictions with minimum overlap
  """"""
  # remove all negative predictions since they harm the calculation of the weights
  detections = [detections[i] for i in range(len(detections)) if predictions[i] > 0]
  predictions = [predictions[i] for i in range(len(predictions)) if predictions[i] > 0]

  if not detections:
    raise ValueError(""No detections with a prediction value > 0 have been found"")

  # keep only the bounding boxes with the highest overlap
  detections, predictions = overlapping_detections(detections, numpy.array(predictions), minimum_overlap)

  return average_detections(detections, predictions, relative_prediction_threshold)"
1580,"def detect_single_face(image, cascade = None, sampler = None, minimum_overlap=0.2, relative_prediction_threshold = 0.25):
  """"""detect_single_face(image, [cascade], [sampler], [minimum_overlap], [relative_prediction_threshold]) -> bounding_box, quality

  Detects a single face in the given image, i.e., the one with the highest prediction value.

  **Parameters:**

  ``image`` : array_like (2D aka gray or 3D aka RGB)
    The image to detect a face in.

  ``cascade`` : str or :py:class:`Cascade` or ``None``
    If given, the cascade file name or the loaded cascade to be used.
    If not given, the :py:func:`default_cascade` is used.

  ``sampler`` : :py:class:`Sampler` or ``None``
    The sampler that defines the sampling of bounding boxes to search for the face.
    If not specified, a default Sampler is instantiated, which will perform a tight sampling.

  ``minimum_overlap`` : float between 0 and 1
    Computes the best detection using the given minimum overlap, see :py:func:`best_detection`

  ``relative_prediction_threshold`` : float between 0 and 1
    Limits the bounding boxes to those that have a prediction value higher then ``relative_prediction_threshold * max(predictions)``

  **Returns:**

  ``bounding_box`` : :py:class:`BoundingBox`
    The bounding box containing the detected face.

  ``quality`` : float
    The quality of the detected face, a value greater than 0.
  """"""

  if cascade is None:
    cascade = default_cascade()
  elif isinstance(cascade, str):
    cascade = Cascade(bob.io.base.HDF5File(cascade))

  if sampler is None:
    sampler = Sampler(patch_size = cascade.extractor.patch_size, distance=2, scale_factor=math.pow(2.,-1./16.), lowest_scale=0.125)

  if image.ndim == 3:
    image = bob.ip.color.rgb_to_gray(image)

  detections = []
  predictions = []
  # get the detection scores for the image
  for prediction, bounding_box in sampler.iterate_cascade(cascade, image, None):
    detections.append(bounding_box)
    predictions.append(prediction)

  if not detections:
    return None

  # compute average over the best locations
  bb, quality = best_detection(detections, predictions, minimum_overlap, relative_prediction_threshold)

  return bb, quality"
1581,"def detect_all_faces(image, cascade = None, sampler = None, threshold = 0, overlaps = 1, minimum_overlap = 0.2, relative_prediction_threshold = 0.25):
  """"""detect_all_faces(image, [cascade], [sampler], [threshold], [overlaps], [minimum_overlap], [relative_prediction_threshold]) -> bounding_boxes, qualities

  Detects all faces in the given image, whose prediction values are higher than the given threshold.

  If the given ``minimum_overlap`` is lower than 1, overlapping bounding boxes are grouped, with the ``minimum_overlap`` being the minimum Jaccard similarity between two boxes to be considered to be overlapping.
  Afterwards, all groups which have less than ``overlaps`` elements are discarded (this measure is similar to the Viola-Jones face detector).
  Finally, :py:func:`average_detections` is used to compute the average bounding box for each of the groups, including averaging the detection value (which will, hence, usually decrease in value).

  **Parameters:**

  ``image`` : array_like (2D aka gray or 3D aka RGB)
    The image to detect a face in.

  ``cascade`` : str or :py:class:`Cascade` or ``None``
    If given, the cascade file name or the loaded cascade to be used to classify image patches.
    If not given, the :py:func:`default_cascade` is used.

  ``sampler`` : :py:class:`Sampler` or ``None``
    The sampler that defines the sampling of bounding boxes to search for the face.
    If not specified, a default Sampler is instantiated.

  ``threshold`` : float
    The threshold of the quality of detected faces.
    Detections with a quality lower than this value will not be considered.
    Higher thresholds will not detect all faces, while lower thresholds will generate false detections.

  ``overlaps`` : int
    The number of overlapping boxes that must exist for a bounding box to be considered.
    Higher values will remove a lot of false-positives, but might increase the chance of a face to be missed.
    The default value ``1`` will not limit the boxes.

  ``minimum_overlap`` : float between 0 and 1
    Groups detections based on the given minimum bounding box overlap, see :py:func:`group_detections`.

  ``relative_prediction_threshold`` : float between 0 and 1
    Limits the bounding boxes to those that have a prediction value higher then ``relative_prediction_threshold * max(predictions)``

  **Returns:**

  ``bounding_boxes`` : [:py:class:`BoundingBox`]
    The bounding box containing the detected face.

  ``qualities`` : [float]
    The qualities of the ``bounding_boxes``, values greater than ``threshold``.
  """"""
  if cascade is None:
    cascade = default_cascade()
  elif isinstance(cascade, str):
    cascade = Cascade(bob.io.base.HDF5File(cascade))

  if sampler is None:
    sampler = Sampler(patch_size = cascade.extractor.patch_size, distance=2, scale_factor=math.pow(2.,-1./16.), lowest_scale=0.125)

  if image.ndim == 3:
    image = bob.ip.color.rgb_to_gray(image)

  detections = []
  predictions = []
  # get the detection scores for the image
  for prediction, bounding_box in sampler.iterate_cascade(cascade, image, threshold):
    detections.append(bounding_box)
    predictions.append(prediction)

  if not detections:
    # No face detected
    return None

  # group overlapping detections
  if minimum_overlap < 1.:
    detections, predictions = group_detections(detections, predictions, minimum_overlap, threshold, overlaps)

    if not detections:
      return None

    # average them
    detections, predictions = zip(*[average_detections(b, q, relative_prediction_threshold) for b,q in zip(detections, predictions)])

  return detections, predictions"
1582,"def cycles_created_by(callable):
    """"""
    Return graph of cyclic garbage created by the given callable.

    Return an :class:`~refcycle.object_graph.ObjectGraph` representing those
    objects generated by the given callable that can't be collected by Python's
    usual reference-count based garbage collection.

    This includes objects that will eventually be collected by the cyclic
    garbage collector, as well as genuinely unreachable objects that will
    never be collected.

    `callable` should be a callable that takes no arguments; its return
    value (if any) will be ignored.

    """"""
    with restore_gc_state():
        gc.disable()
        gc.collect()
        gc.set_debug(gc.DEBUG_SAVEALL)
        callable()
        new_object_count = gc.collect()
        if new_object_count:
            objects = gc.garbage[-new_object_count:]
            del gc.garbage[-new_object_count:]
        else:
            objects = []
        return ObjectGraph(objects)"
1583,"def garbage():
    """"""
    Collect garbage and return an :class:`~refcycle.object_graph.ObjectGraph`
    based on collected garbage.

    The collected elements are removed from ``gc.garbage``, but are still kept
    alive by the references in the graph.  Deleting the
    :class:`~refcycle.object_graph.ObjectGraph` instance and doing another
    ``gc.collect`` will remove those objects for good.

    """"""
    with restore_gc_state():
        gc.disable()
        gc.set_debug(gc.DEBUG_SAVEALL)
        collected_count = gc.collect()
        if collected_count:
            objects = gc.garbage[-collected_count:]
            del gc.garbage[-collected_count:]
        else:
            objects = []
        return ObjectGraph(objects)"
1584,"def objects_reachable_from(obj):
    """"""
    Return graph of objects reachable from *obj* via ``gc.get_referrers``.

    Returns an :class:`~refcycle.object_graph.ObjectGraph` object holding all
    objects reachable from the given one by following the output of
    ``gc.get_referrers``.  Note that unlike the
    :func:`~refcycle.creators.snapshot` function, the output graph may
    include non-gc-tracked objects.

    """"""
    # Depth-first search.
    found = ObjectGraph.vertex_set()
    to_process = [obj]
    while to_process:
        obj = to_process.pop()
        found.add(obj)
        for referent in gc.get_referents(obj):
            if referent not in found:
                to_process.append(referent)
    return ObjectGraph(found)"
1585,"def snapshot():
    """"""Return the graph of all currently gc-tracked objects.

    Excludes the returned :class:`~refcycle.object_graph.ObjectGraph` and
    objects owned by it.

    Note that a subsequent call to :func:`~refcycle.creators.snapshot` will
    capture all of the objects owned by this snapshot.  The
    :meth:`~refcycle.object_graph.ObjectGraph.owned_objects` method may be
    helpful when excluding these objects from consideration.

    """"""
    all_objects = gc.get_objects()
    this_frame = inspect.currentframe()
    selected_objects = []
    for obj in all_objects:
        if obj is not this_frame:
            selected_objects.append(obj)
    graph = ObjectGraph(selected_objects)
    del this_frame, all_objects, selected_objects, obj
    return graph"
1586,"def extendMarkdown(self, md, md_globals):
        """"""
        Every extension requires a extendMarkdown method to tell the markdown
        renderer how use the extension.
        """"""
        md.registerExtension(self)

        for processor in (self.preprocessors or []):
            md.preprocessors.add(processor.__name__.lower(), processor(md), '_end')

        for pattern in (self.inlinepatterns or []):
            md.inlinePatterns.add(pattern.__name__.lower(), pattern(md), '_end')

        for processor in (self.postprocessors or []):
            md.postprocessors.add(processor.__name__.lower(), processor(md), '_end')"
1587,"def run(
    paths,
    output=_I_STILL_HATE_EVERYTHING,
    recurse=core.flat,
    sort_by=None,
    ls=core.ls,
    stdout=stdout,
):
    """"""
    Project-oriented directory and file information lister.

    """"""

    if output is _I_STILL_HATE_EVERYTHING:
        output = core.columnized if stdout.isatty() else core.one_per_line
    if sort_by is None:
        if output == core.as_tree:
            def sort_by(thing):
                return (
                    thing.parent(),
                    thing.basename().lstrip(string.punctuation).lower(),
                )
        else:
            def sort_by(thing):
                return thing

    def _sort_by(thing):
        return not getattr(thing, ""_always_sorts_first"", False), sort_by(thing)

    contents = [
        path_and_children
        for path in paths or (project.from_path(FilePath(""."")),)
        for path_and_children in recurse(path=path, ls=ls)
    ]
    for line in output(contents, sort_by=_sort_by):
        stdout.write(line)
        stdout.write(""\n"")"
1588,"def getCustomLogger(name, logLevel, logFormat='%(asctime)s %(levelname)-9s:%(name)s:%(module)s:%(funcName)s: %(message)s'):
  '''
  Set up logging

  :param str name: What log level to set
  :param str logLevel: What log level to use
  :param str logFormat: Format string for logging
  :rtype: logger
  '''
  assert isinstance(logFormat, basestring), (""logFormat must be a string but is %r"" % logFormat)
  assert isinstance(logLevel, basestring), (""logLevel must be a string but is %r"" % logLevel)
  assert isinstance(name, basestring), (""name must be a string but is %r"" % name)

  validLogLevels = ['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'WARNING']

  if not logLevel:
    logLevel = 'DEBUG'

  # If they don't specify a valid log level, err on the side of verbosity
  if logLevel.upper() not in validLogLevels:
    logLevel = 'DEBUG'

  numericLevel = getattr(logging, logLevel.upper(), None)
  if not isinstance(numericLevel, int):
    raise ValueError(""Invalid log level: %s"" % logLevel)

  logging.basicConfig(level=numericLevel, format=logFormat)
  logger = logging.getLogger(name)
  return logger"
1589,"def mkdir_p(path):
  '''
  Mimic `mkdir -p` since os module doesn't provide one.

  :param str path: directory to create
  '''
  assert isinstance(path, basestring), (""path must be a string but is %r"" % path)
  try:
    os.makedirs(path)
  except OSError as exception:
    if exception.errno != errno.EEXIST:
      raise"
1590,"def limit_chord_unlock_tasks(app):
    """"""
    Set max_retries for chord.unlock tasks to avoid infinitely looping
    tasks. (see celery/celery#1700 or celery/celery#2725)
    """"""
    task = app.tasks['celery.chord_unlock']
    if task.max_retries is None:
        retries = getattr(app.conf, 'CHORD_UNLOCK_MAX_RETRIES', None)
        task.max_retries = retries"
1591,"def setup_exchanges(app):
    """"""
    Setup result exchange to route all tasks to platform queue.
    """"""
    with app.producer_or_acquire() as P:
        # Ensure all queues are noticed and configured with their
        # appropriate exchange.
        for q in app.amqp.queues.values():
            P.maybe_declare(q)"
1592,"def setup_app(app, throw=True):
    """"""
    Ensure application is set up to expected configuration. This function is
    typically triggered by the worker_init signal, however it must be called
    manually by codebases that are run only as task producers or from within
    a Python shell.
    """"""
    success = True
    try:
        for func in SETUP_FUNCS:
            try:
                func(app)
            except Exception:
                success = False
                if throw:
                    raise
                else:
                    msg = ""Failed to run setup function %r(app)""
                    logger.exception(msg, func.__name__)
    finally:
        setattr(app, 'is_set_up', success)"
1593,"def insert(self, item, priority):
        """"""Adds item to DEPQ with given priority by performing a binary
        search on the concurrently rotating deque. Amount rotated R of
        DEPQ of length n would be n <= R <= 3n/2. Performance: O(n)""""""

        with self.lock:

            self_data = self.data
            rotate = self_data.rotate
            self_items = self.items
            maxlen = self._maxlen

            try:

                if priority <= self_data[-1][1]:
                    self_data.append((item, priority))
                elif priority > self_data[0][1]:
                    self_data.appendleft((item, priority))
                else:

                    length = len(self_data) + 1
                    mid = length // 2
                    shift = 0

                    while True:

                        if priority <= self_data[0][1]:
                            rotate(-mid)
                            shift += mid
                            mid //= 2
                            if mid == 0:
                                mid += 1

                        else:
                            rotate(mid)
                            shift -= mid
                            mid //= 2
                            if mid == 0:
                                mid += 1

                        if self_data[-1][1] >= priority > self_data[0][1]:
                            self_data.appendleft((item, priority))

                            # When returning to original position, never shift
                            # more than half length of DEPQ i.e. if length is
                            # 100 and we rotated -75, rotate -25, not 75
                            if shift > length // 2:
                                shift = length % shift
                                rotate(-shift)
                            else:
                                rotate(shift)

                            break

                try:
                    self_items[item] += 1
                except TypeError:
                    self_items[repr(item)] += 1

            except IndexError:
                self_data.append((item, priority))
                try:
                    self_items[item] = 1
                except TypeError:
                    self_items[repr(item)] = 1

            if maxlen is not None and maxlen < len(self_data):
                self._poplast()"
1594,"def addfirst(self, item, new_priority=None):
        """"""Adds item to DEPQ as highest priority. The default
        starting priority is 0, the default new priority is
        self.high(). Performance: O(1)""""""

        with self.lock:

            self_data = self.data

            try:
                priority = self_data[0][1]
                if new_priority is not None:
                    if new_priority < priority:
                        raise ValueError('Priority must be >= '
                                         'highest priority.')
                    else:
                        priority = new_priority
            except IndexError:
                priority = 0 if new_priority is None else new_priority

            self_data.appendleft((item, priority))
            self_items = self.items
            maxlen = self._maxlen

            try:
                self_items[item] += 1
            except TypeError:
                self_items[repr(item)] += 1

            if maxlen is not None and maxlen < len(self_data):
                self._poplast()"
1595,"def addlast(self, item, new_priority=None):
        """"""Adds item to DEPQ as lowest priority. The default
        starting priority is 0, the default new priority is
        self.low(). Performance: O(1)""""""

        with self.lock:

            self_data = self.data
            maxlen = self._maxlen

            if maxlen is not None and maxlen == len(self_data):
                return

            try:
                priority = self_data[-1][1]
                if new_priority is not None:
                    if new_priority > priority:
                        raise ValueError('Priority must be <= '
                                         'lowest priority.')
                    else:
                        priority = new_priority
            except IndexError:
                priority = 0 if new_priority is None else new_priority

            self_data.append((item, priority))
            self_items = self.items

            try:
                self_items[item] += 1
            except TypeError:
                self_items[repr(item)] += 1"
1596,"def popfirst(self):
        """"""Removes item with highest priority from DEPQ. Returns
        tuple(item, priority). Performance: O(1)""""""

        with self.lock:

            try:
                tup = self.data.popleft()
            except IndexError as ex:
                ex.args = ('DEPQ is already empty',)
                raise

            self_items = self.items

            try:
                self_items[tup[0]] -= 1
                if self_items[tup[0]] == 0:
                    del self_items[tup[0]]
            except TypeError:
                r = repr(tup[0])
                self_items[r] -= 1
                if self_items[r] == 0:
                    del self_items[r]

            return tup"
1597,"def _poplast(self):
        """"""For avoiding lock during inserting to keep maxlen""""""

        try:
            tup = self.data.pop()
        except IndexError as ex:
            ex.args = ('DEPQ is already empty',)
            raise

        self_items = self.items

        try:
            self_items[tup[0]] -= 1
            if self_items[tup[0]] == 0:
                del self_items[tup[0]]
        except TypeError:
            r = repr(tup[0])
            self_items[r] -= 1
            if self_items[r] == 0:
                del self_items[r]

        return tup"
1598,"def first(self):
        """"""Gets item with highest priority. Performance: O(1)""""""
        with self.lock:
            try:
                return self.data[0][0]
            except IndexError as ex:
                ex.args = ('DEPQ is empty',)
                raise"
1599,"def last(self):
        """"""Gets item with lowest priority. Performance: O(1)""""""
        with self.lock:
            try:
                return self.data[-1][0]
            except IndexError as ex:
                ex.args = ('DEPQ is empty',)
                raise"
1600,"def high(self):
        """"""Gets highest priority. Performance: O(1)""""""
        with self.lock:
            try:
                return self.data[0][1]
            except IndexError as ex:
                ex.args = ('DEPQ is empty',)
                raise"
1601,"def low(self):
        """"""Gets lowest priority. Performance: O(1)""""""
        with self.lock:
            try:
                return self.data[-1][1]
            except IndexError as ex:
                ex.args = ('DEPQ is empty',)
                raise"
1602,"def clear(self):
        """"""Empties DEPQ. Performance: O(1)""""""
        with self.lock:
            self.data.clear()
            self.items.clear()"
1603,"def set_maxlen(self, length):
        """"""Sets maxlen""""""
        with self.lock:
            self._maxlen = length
            while len(self.data) > length:
                self._poplast()"
1604,"def count(self, item):
        """"""Returns number of occurrences of item in DEPQ. Performance: O(1)""""""
        try:
            return self.items.get(item, 0)
        except TypeError:
            return self.items.get(repr(item), 0)"
1605,"def remove(self, item, count=1):
        """"""Removes occurrences of given item in ascending priority. Default
        number of removals is 1. Useful for tasks that no longer require
        completion, inactive clients, certain algorithms, etc. Returns a
        list of tuple(item, priority). Performance: O(n)""""""

        with self.lock:

            try:
                count = int(count)
            except ValueError as ex:
                ex.args = ('{} cannot be represented as an '
                           'integer'.format(count),)
                raise
            except TypeError as ex:
                ex.args = ('{} cannot be represented as an '
                           'integer'.format(count),)
                raise

            removed = []
            self_items = self.items

            try:
                item_freq = self_items[item]
                item_repr = item
                if item_freq == 0:
                    return removed
            except TypeError:
                item_freq = self_items[repr(item)]
                item_repr = repr(item)
                if item_freq == 0:
                    return removed

            if count == -1:
                count = item_freq

            self_data = self.data
            rotate = self_data.rotate
            pop = self_data.pop
            counter = 0

            for i in range(len(self_data)):
                if count > counter and item == self_data[-1][0]:
                    removed.append(pop())
                    counter += 1
                    continue
                rotate()

            if item_freq <= count:
                del self_items[item_repr]
            else:
                self_items[item_repr] -= count

            return removed"
1606,"def DatabaseEnabled(cls):
    """"""Given persistence methods to classes with this annotation.

    All this really does is add some functions that forward to the mapped
    database class.
    """"""
    if not issubclass(cls, Storable):
        raise ValueError(
            ""%s is not a subclass of gludb.datab.Storage"" % repr(cls)
        )

    cls.ensure_table = classmethod(_ensure_table)
    cls.find_one = classmethod(_find_one)
    cls.find_all = classmethod(_find_all)
    cls.find_by_index = classmethod(_find_by_index)
    cls.save = _save
    cls.delete = _delete

    return cls"
1607,"def _find_playlist(self):
        """"""
        Internal method to populate the object given the ``id`` or
        ``reference_id`` that has been set in the constructor.
        """"""
        data = None
        if self.id:
            data = self.connection.get_item(
                'find_playlist_by_id', playlist_id=self.id)
        elif self.reference_id:
            data = self.connection.get_item(
                'find_playlist_by_reference_id',
                reference_id=self.reference_id)

        if data:
            self._load(data)"
1608,"def _to_dict(self):
        """"""
        Internal method that serializes object into a dictionary.
        """"""
        data = {
            'name': self.name,
            'referenceId': self.reference_id,
            'shortDescription': self.short_description,
            'playlistType': self.type,
            'id': self.id}
        if self.videos:
            for video in self.videos:
                if video.id not in self.video_ids:
                    self.video_ids.append(video.id)
        if self.video_ids:
            data['videoIds'] = self.video_ids
        [data.pop(key) for key in data.keys() if data[key] == None]
        return data"
1609,"def _load(self, data):
        """"""
        Internal method that deserializes a ``pybrightcove.playlist.Playlist``
        object.
        """"""
        self.raw_data = data
        self.id = data['id']
        self.reference_id = data['referenceId']
        self.name = data['name']
        self.short_description = data['shortDescription']
        self.thumbnail_url = data['thumbnailURL']
        self.videos = []
        self.video_ids = data['videoIds']
        self.type = data['playlistType']

        for video in data.get('videos', []):
            self.videos.append(pybrightcove.video.Video(
                data=video, connection=self.connection))"
1610,"def save(self):
        """"""
        Create or update a playlist.
        """"""
        d = self._to_dict()
        if len(d.get('videoIds', [])) > 0:
            if not self.id:
                self.id = self.connection.post('create_playlist', playlist=d)
            else:
                data = self.connection.post('update_playlist', playlist=d)
                if data:
                    self._load(data)"
1611,"def delete(self, cascade=False):
        """"""
        Deletes this playlist.
        """"""
        if self.id:
            self.connection.post('delete_playlist', playlist_id=self.id,
                cascade=cascade)
            self.id = None"
1612,"def find_all(connection=None, page_size=100, page_number=0,
        sort_by=DEFAULT_SORT_BY, sort_order=DEFAULT_SORT_ORDER):
        """"""
        List all playlists.
        """"""
        return pybrightcove.connection.ItemResultSet(""find_all_playlists"",
            Playlist, connection, page_size, page_number, sort_by, sort_order)"
1613,"def find_by_ids(ids, connection=None, page_size=100, page_number=0,
        sort_by=DEFAULT_SORT_BY, sort_order=DEFAULT_SORT_ORDER):
        """"""
        List playlists by specific IDs.
        """"""
        ids = ','.join([str(i) for i in ids])
        return pybrightcove.connection.ItemResultSet('find_playlists_by_ids',
            Playlist, connection, page_size, page_number, sort_by, sort_order,
            playlist_ids=ids)"
1614,"def find_by_reference_ids(reference_ids, connection=None, page_size=100,
        page_number=0, sort_by=DEFAULT_SORT_BY, sort_order=DEFAULT_SORT_ORDER):
        """"""
        List playlists by specific reference_ids.
        """"""
        reference_ids = ','.join([str(i) for i in reference_ids])
        return pybrightcove.connection.ItemResultSet(
            ""find_playlists_by_reference_ids"", Playlist, connection, page_size,
            page_number, sort_by, sort_order, reference_ids=reference_ids)"
1615,"def find_for_player_id(player_id, connection=None, page_size=100,
        page_number=0, sort_by=DEFAULT_SORT_BY, sort_order=DEFAULT_SORT_ORDER):
        """"""
        List playlists for a for given player id.
        """"""
        return pybrightcove.connection.ItemResultSet(
            ""find_playlists_for_player_id"", Playlist, connection, page_size,
            page_number, sort_by, sort_order, player_id=player_id)"
1616,"def is_any_type_set(sett: Set[Type]) -> bool:
    """"""
    Helper method to check if a set of types is the {AnyObject} singleton

    :param sett:
    :return:
    """"""
    return len(sett) == 1 and is_any_type(min(sett))"
1617,"def get_validated_types(object_types: Set[Type], set_name: str) -> Set[Type]:
    """"""
    Utility to validate a set of types :
    * None is not allowed as a whole or within the set,
    * object and Any are converted into AnyObject
    * if AnyObject is in the set, it must be the only element

    :param object_types: the set of types to validate
    :param set_name: a name used in exceptions if any
    :return: the fixed set of types
    """"""
    check_var(object_types, var_types=set, var_name=set_name)
    res = {get_validated_type(typ, set_name + '[x]') for typ in object_types}
    if AnyObject in res and len(res) > 1:
        raise ValueError('The set of types contains \'object\'/\'Any\'/\'AnyObject\', so no other type must be present '
                         'in the set')
    else:
        return res"
1618,"def get_validated_type(object_type: Type[Any], name: str, enforce_not_joker: bool = True) -> Type[Any]:
    """"""
    Utility to validate a type :
    * None is not allowed,
    * 'object', 'AnyObject' and 'Any' lead to the same 'AnyObject' type
    * JOKER is either rejected (if enforce_not_joker is True, default) or accepted 'as is'

    :param object_type: the type to validate
    :param name: a name used in exceptions if any
    :param enforce_not_joker: a boolean, set to False to tolerate JOKER types
    :return: the fixed type
    """"""
    if object_type is object or object_type is Any or object_type is AnyObject:
        return AnyObject
    else:
        # -- !! Do not check TypeVar or Union : this is already handled at higher levels --
        if object_type is JOKER:
            # optionally check if JOKER is allowed
            if enforce_not_joker:
                raise ValueError('JOKER is not allowed for object_type')
        else:
            # note: we dont check var earlier, since 'typing.Any' is not a subclass of type anymore
            check_var(object_type, var_types=type, var_name=name)
        return object_type"
1619,"def get_options_for_id(options: Dict[str, Dict[str, Any]], identifier: str):
    """"""
    Helper method, from the full options dict of dicts, to return either the options related to this parser or an
    empty dictionary. It also performs all the var type checks

    :param options:
    :param identifier:
    :return:
    """"""
    check_var(options, var_types=dict, var_name='options')
    res = options[identifier] if identifier in options.keys() else dict()
    check_var(res, var_types=dict, var_name='options[' + identifier + ']')
    return res"
1620,"def is_able_to_convert_detailed(self, strict: bool, from_type: Type[Any], to_type: Type[Any]) \
            -> Tuple[bool, bool, bool]:
        """"""
        Utility method to check if a parser is able to convert a given type to the given type, either in
        * strict mode : provided_type and desired_type must be equal to this converter's from_type and to_type
        respectively (or the to_type does not match but this converter is generic
        * inference mode (non-strict) : provided_type may be a subclass of from_type, and to_type may be a subclass
        of desired_type

        If a custom function was provided at construction time, it is called to enable converters to reject some
        conversions based on source and/or dest type provided.

        :param strict: a boolean indicating if matching should be in strict mode or not
        :param from_type:
        :param to_type:
        :return: a tuple of 3 booleans : (does match?, strict source match? (None if no match), strict dest match?
        (None if no match))
        """"""
        # (1) first handle the easy joker+joker case
        if from_type is JOKER and to_type is JOKER:
            return True, None, None

        # Don't validate types -- this is called too often at the initial RootParser instance creation time,
        # and this is quite 'internal' so the risk is very low
        #
        # check_var(strict, var_types=bool, var_name='strict')
        # if from_type is not JOKER:
        #     check_var(from_type, var_types=type, var_name='from_type')
        # if to_type is not JOKER:
        #     check_var(to_type, var_types=type, var_name='to_type')

        # -- first call custom checker if provided
        if self.is_able_to_convert_func is not None:
            # TODO Maybe one day, rather push the JOKER to the function ? not sure that it will be more explicit..
            if not self.is_able_to_convert_func(strict,
                                                from_type=None if from_type is JOKER else from_type,
                                                to_type=None if to_type is JOKER else to_type):
                return False, None, None

        # -- from_type strict match
        if (from_type is JOKER) or (from_type is self.from_type) or is_any_type(from_type):
            # -- check to type strict
            if (to_type is JOKER) or self.is_generic() or (to_type is self.to_type):
                return True, True, True  # strict to_type match
            # -- check to type non-strict
            elif (not strict) and issubclass(self.to_type, to_type):
                return True, True, False  # approx to_type match

        # -- from_type non-strict match
        elif (not strict) and issubclass(from_type, self.from_type):
            # -- check to type strict
            if (to_type is JOKER) or self.is_generic() or (to_type is self.to_type):
                return True, False, True  # exact to_type match
            # -- check to type non-strict
            elif (not strict) and issubclass(self.to_type, to_type):
                return True, False, False  # approx to_type match

        # -- otherwise no match
        return False, None, None"
1621,"def are_worth_chaining(left_converter, right_converter) -> bool:
        """"""
        Utility method to check if it makes sense to chain these two converters. Returns True if it brings value to
        chain the first converter with the second converter. To bring value,
        * the second converter's input should not be a parent class of the first converter's input (in that case, it is
          always more interesting to use the second converter directly for any potential input)
        * the second converter's output should not be a parent class of the first converter's input or output. Otherwise
        the chain does not even make any progress :)
        * The first converter has to allow chaining (with converter.can_chain=True)

        :param left_converter:
        :param right_converter:
        :return:
        """"""
        if not left_converter.can_chain:
            return False

        elif not is_any_type(left_converter.to_type) and is_any_type(right_converter.to_type):
            # we gain the capability to generate any type. So it is interesting.
            return True

        elif issubclass(left_converter.from_type, right_converter.to_type) \
                or issubclass(left_converter.to_type, right_converter.to_type) \
                or issubclass(left_converter.from_type, right_converter.from_type):
            # Not interesting : the outcome of the chain would be not better than one of the converters alone
            return False

        # Note: we dont say that chaining a generic converter with a converter is useless. Indeed it might unlock some
        # capabilities for the user (new file extensions, etc.) that would not be available with the generic parser
        # targetting to_type alone. For example parsing object A from its constructor then converting A to B might
        # sometimes be interesting, rather than parsing B from its constructor

        else:
            # interesting
            return True"
1622,"def can_be_appended_to(self, left_converter, strict: bool) -> bool:
        """"""
        Utility method to check if this (self) converter can be appended after the output of the provided converter.
        This method does not check if it makes sense, it just checks if the output type of the left converter is
        compliant with the input type of this converter. Compliant means:
        * strict mode : type equality
        * non-strict mode : output type of left_converter should be a subclass of input type of this converter

        In addition, the custom function provided in constructor may be used to reject conversion (see
        is_able_to_convert for details)

        :param left_converter:
        :param strict: boolean to
        :return:
        """"""
        is_able_to_take_input = self.is_able_to_convert(strict, from_type=left_converter.to_type, to_type=JOKER)
        if left_converter.is_generic():
            return is_able_to_take_input \
                   and left_converter.is_able_to_convert(strict, from_type=JOKER, to_type=self.from_type)
        else:
            return is_able_to_take_input"
1623,"def get_applicable_options(self, options: Dict[str, Dict[str, Any]]):
        """"""
        Returns the options that are applicable to this particular converter, from the full map of options.
        It first uses 'get_id_for_options()' to know the id of this parser, and then simply extracts the contents of
        the options corresponding to this id, or returns an empty dict().

        :param options: a dictionary converter_id > options
        :return:
        """"""
        return get_options_for_id(options, self.get_id_for_options())"
1624,"def _convert(self, desired_type: Type[T], source_obj: S, logger: Logger, options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        Implementing classes should implement this method to perform the conversion itself

        :param desired_type: the destination type of the conversion
        :param source_obj: the source object that should be converter
        :param logger: a logger to use if any is available, or None
        :param options: additional options map. Implementing classes may use 'self.get_applicable_options()' to get the
        options that are of interest for this converter.
        :return:
        """"""
        pass"
1625,"def create_not_able_to_convert(source: S, converter: Converter, desired_type: Type[T]):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param source:
        :param converter:
        :param desired_type:
        :return:
        """"""
        base_msg = 'Converter ' + str(converter) + ' is not able to ingest source value \'' + str(source) + '\''\
                   ' of type \'' + get_pretty_type_str(type(source)) + '\' and/or convert it to type \'' \
                   + get_pretty_type_str(desired_type) + '\'.'
        base_msg += ' This can happen in a chain when the previous step in the chain is generic and actually produced '\
                    ' an output of the wrong type/content'

        return ConversionException(base_msg)"
1626,"def create(converter_func: ConversionMethod, caught: Exception):
        """"""
        Helper method provided because we actually can't put that in the constructor, it creates a bug in Nose tests
        https://github.com/nose-devs/nose/issues/725

        :param converter_func:
        :param caught:
        :return:
        """"""
        msg = 'Caught TypeError while calling conversion function \'' + str(converter_func.__name__) + '\'. ' \
              'Note that the conversion function signature should be \'' + conversion_method_example_signature_str \
              + '\' (unpacked options mode - default) or ' + multioptions_conversion_method_example_signature_str \
              + ' (unpack_options = False).' \
              + 'Caught error message is : ' + caught.__class__.__name__ + ' : ' + str(caught)
        return CaughtTypeError(msg).with_traceback(caught.__traceback__)"
1627,"def _convert(self, desired_type: Type[T], source_obj: S, logger: Logger, options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        Delegates to the user-provided method. Passes the appropriate part of the options according to the
        function name.

        :param desired_type:
        :param source_obj:
        :param logger:
        :param options:
        :return:
        """"""
        try:
            if self.unpack_options:
                opts = self.get_applicable_options(options)
                if self.function_args is not None:
                    return self.conversion_method(desired_type, source_obj, logger, **self.function_args, **opts)
                else:
                    return self.conversion_method(desired_type, source_obj, logger, **opts)
            else:
                if self.function_args is not None:
                    return self.conversion_method(desired_type, source_obj, logger, options, **self.function_args)
                else:
                    return self.conversion_method(desired_type, source_obj, logger, options)

        except TypeError as e:
            raise CaughtTypeError.create(self.conversion_method, e)"
1628,"def is_able_to_convert_detailed(self, strict: bool, from_type: Type[Any], to_type: Type[Any]):
        """"""
        Overrides the parent method to delegate left check to the first (left) converter of the chain and right check
        to the last (right) converter of the chain. This includes custom checking if they have any...
        see Converter.is_able_to_convert for details

        :param strict:
        :param from_type:
        :param to_type:
        :return:
        """"""
        # check if first and last converters are happy
        if not self._converters_list[0].is_able_to_convert(strict, from_type=from_type, to_type=JOKER):
            return False, None, None
        elif not self._converters_list[-1].is_able_to_convert(strict, from_type=JOKER, to_type=to_type):
            return False, None, None
        else:
            # behave as usual. This is probably useless but lets be sure.
            return super(ConversionChain, self).is_able_to_convert_detailed(strict, from_type, to_type)"
1629,"def remove_first(self, inplace: bool = False):
        """"""
        Utility method to remove the first converter of this chain. If inplace is True, this object is modified and
        None is returned. Otherwise, a copy is returned

        :param inplace: boolean indicating whether to modify this object (True) or return a copy (False)
        :return: None or a copy with the first converter removed
        """"""
        if len(self._converters_list) > 1:
            if inplace:
                self._converters_list = self._converters_list[1:]
                # update the current source type
                self.from_type = self._converters_list[0].from_type
                return
            else:
                new = copy(self)
                new._converters_list = new._converters_list[1:]
                # update the current source type
                new.from_type = new._converters_list[0].from_type
                return new
        else:
            raise ValueError('cant remove first: would make it empty!')"
1630,"def add_conversion_steps(self, converters: List[Converter], inplace: bool = False):
        """"""
        Utility method to add converters to this chain. If inplace is True, this object is modified and
        None is returned. Otherwise, a copy is returned

        :param converters: the list of converters to add
        :param inplace: boolean indicating whether to modify this object (True) or return a copy (False)
        :return: None or a copy with the converters added
        """"""
        check_var(converters, var_types=list, min_len=1)
        if inplace:
            for converter in converters:
                self.add_conversion_step(converter, inplace=True)
        else:
            new = copy(self)
            new.add_conversion_steps(converters, inplace=True)
            return new"
1631,"def add_conversion_step(self, converter: Converter[S, T], inplace: bool = False):
        """"""
        Utility method to add a converter to this chain. If inplace is True, this object is modified and
        None is returned. Otherwise, a copy is returned

        :param converter: the converter to add
        :param inplace: boolean indicating whether to modify this object (True) or return a copy (False)
        :return: None or a copy with the converter added
        """"""
        # it the current chain is generic, raise an error
        if self.is_generic() and converter.is_generic():
            raise ValueError('Cannot chain this generic converter chain to the provided converter : it is generic too!')

        # if the current chain is able to transform its input into a valid input for the new converter
        elif converter.can_be_appended_to(self, self.strict):
            if inplace:
                self._converters_list.append(converter)
                # update the current destination type
                self.to_type = converter.to_type
                return
            else:
                new = copy(self)
                new._converters_list.append(converter)
                # update the current destination type
                new.to_type = converter.to_type
                return new
        else:
            raise TypeError('Cannnot register a converter on this conversion chain : source type \'' +
                            get_pretty_type_str(converter.from_type)
                            + '\' is not compliant with current destination type of the chain : \'' +
                            get_pretty_type_str(self.to_type) + ' (this chain performs '
                            + ('' if self.strict else 'non-') + 'strict mode matching)')"
1632,"def insert_conversion_steps_at_beginning(self, converters: List[Converter], inplace: bool = False):
        """"""
        Utility method to insert converters at the beginning ofthis chain. If inplace is True, this object is modified
        and  None is returned. Otherwise, a copy is returned

        :param converters: the list of converters to insert
        :param inplace: boolean indicating whether to modify this object (True) or return a copy (False)
        :return: None or a copy with the converters added
        """"""
        if inplace:
            for converter in reversed(converters):
                self.insert_conversion_step_at_beginning(converter, inplace=True)
            return
        else:
            new = copy(self)
            for converter in reversed(converters):
                # do inplace since it is a copy
                new.insert_conversion_step_at_beginning(converter, inplace=True)
            return new"
1633,"def _convert(self, desired_type: Type[T], obj: S, logger: Logger, options: Dict[str, Dict[str, Any]]) -> T:
        """"""
        Apply the converters of the chain in order to produce the desired result. Only the last converter will see the
        'desired type', the others will be asked to produce their declared to_type.

        :param desired_type:
        :param obj:
        :param logger:
        :param options:
        :return:
        """"""
        for converter in self._converters_list[:-1]:
            # convert into each converters destination type
            obj = converter.convert(converter.to_type, obj, logger, options)

        # the last converter in the chain should convert to desired type
        return self._converters_list[-1].convert(desired_type, obj, logger, options)"
1634,"def are_worth_chaining(first_converter: Converter, second_converter: Converter) -> bool:
        """"""
        This is a generalization of Converter.are_worth_chaining(), to support ConversionChains.

        :param first_converter:
        :param second_converter:
        :return:
        """"""
        if isinstance(first_converter, ConversionChain):
            if isinstance(second_converter, ConversionChain):
                # BOTH are chains
                for sec_conv in second_converter._converters_list:
                    for fir_conv in first_converter._converters_list:
                        if not Converter.are_worth_chaining(fir_conv, sec_conv):
                            return False
            else:
                for fir_conv in first_converter._converters_list:
                    if not Converter.are_worth_chaining(fir_conv, second_converter):
                        return False
        else:
            if isinstance(second_converter, ConversionChain):
                for sec_conv in second_converter._converters_list:
                    if not Converter.are_worth_chaining(first_converter, sec_conv):
                        return False
            else:
                # Neither is a chain
                if not Converter.are_worth_chaining(first_converter, second_converter):
                    return False

        # finally return True if nothing proved otherwise
        return True"
1635,"def chain(first_converter, second_converter, strict: bool):
        """"""
        Utility method to chain two converters. If any of them is already a ConversionChain, this method ""unpacks"" it
        first. Note: the created conversion chain is created with the provided 'strict' flag, that may be different
        from the ones of the converters (if compliant). For example you may chain a 'strict' chain with a 'non-strict'
        chain, to produce a 'non-strict' chain.

        :param first_converter:
        :param second_converter:
        :param strict:
        :return:
        """"""
        if isinstance(first_converter, ConversionChain):
            if isinstance(second_converter, ConversionChain):
                # BOTH are chains
                if (first_converter.strict == strict) and (second_converter.strict == strict):
                    return first_converter.add_conversion_steps(second_converter._converters_list)
                else:
                    if not strict:
                        # create a non-strict chain
                        return ConversionChain(initial_converters=first_converter._converters_list,
                                               strict_chaining=False) \
                            .add_conversion_steps(second_converter._converters_list)
                    else:
                        raise ValueError('Trying to chain conversion chains with different strict modes than expected')

            else:
                # FIRST is a chain
                if strict == first_converter.strict:
                    return first_converter.add_conversion_step(second_converter)
                else:
                    if not strict:
                        # create a non-strict chain
                        return ConversionChain(initial_converters=[second_converter], strict_chaining=False) \
                            .insert_conversion_steps_at_beginning(first_converter._converters_list)
                    else:
                        raise ValueError('Trying to chain after a conversion chain that has different strict mode than '
                                         'expected')

        else:
            if isinstance(second_converter, ConversionChain):
                # SECOND is a chain
                if strict == second_converter.strict:
                    return second_converter.insert_conversion_step_at_beginning(first_converter)
                else:
                    if not strict:
                        # create a non-strict chain
                        return ConversionChain(initial_converters=[first_converter], strict_chaining=False) \
                            .add_conversion_steps(second_converter._converters_list)
                    else:
                        raise ValueError(
                            'Trying to chain before a conversion chain that has different strict mode than '
                            'expected')
            else:
                # Neither is a chain
                return ConversionChain([first_converter, second_converter], strict)"
1636,"def main(as_module=False):
    """"""This is copy/paste of flask.cli.main to instanciate our own group
    """"""
    this_module = __package__
    args = sys.argv[1:]

    if as_module:
        if sys.version_info >= (2, 7):
            name = 'python -m ' + this_module.rsplit('.', 1)[0]
        else:
            name = 'python -m ' + this_module

        # This module is always executed as ""python -m flask.run"" and as such
        # we need to ensure that we restore the actual command line so that
        # the reloader can properly operate.
        sys.argv = ['-m', this_module] + sys.argv[1:]
    else:
        name = None

    cli.main(args=args, prog_name=name)"
1637,"def init_app(self, app, entry_point_group='invenio_queues.queues'):
        """"""Flask application initialization.""""""
        self.init_config(app)
        app.extensions['invenio-queues'] = _InvenioQueuesState(
            app,
            app.config['QUEUES_CONNECTION_POOL'],
            entry_point_group=entry_point_group
        )
        return app"
1638,"def parse_result(result):
	""""""parse_result(json result) -- print the web query according to the type 
	of result from duckduckgo.
	""""""

	if(result['Type'] == 'D'):
		print """"""There is more than one answer for this. Try making your query\
		more specific. For example, if you want to learn about apple the company\
		and not apple the fruit, try something like apple inc or apple computers.  
		""""""
	
	elif(result['Type'] == 'A'):
		print result['AbstractText']
		print '\nResults from DuckDuckGo'
	
	elif(result['Type'] == 'C'):
		for entry in result['RelatedTopics']:
			print entry['Text']
			print ""\n""
	else:
		print ""I do not know how to process this query at the moment."""
1639,"def query(string):
	""""""query(user string) -- make http request to duckduckgo api, to get result
	in json format, then call parse_result.
	""""""
	url = ""https://api.duckduckgo.com/?q=""
	formating = ""&format=json""
	query_string = url+'+'.join(string)+formating
	try:
		result = json.loads(requests.get(query_string).text)
	except:
		print ""I'm sorry! Something went wrong. Maybe we could try again later.""
		return
	parse_result(result)"
1640,"def parse_gpx(gpx_element, gpx_extensions_parser=None,
                   metadata_extensions_parser=None,
                   waypoint_extensions_parser=None,
                   route_extensions_parser=None,
                   track_extensions_parser=None,
                   segment_extensions_parser=None,
                   gpxns=None):
    """"""Parse a GPX file into a GpxModel.

    Args:
        gpx_element: gpx_element: The root <gpx> element of an XML document
            containing a version attribute. GPX versions 1.1 is supported.

        gpx_extensions_parser: An optional callable which accepts an Element
            with the 'extensions' tag and returns a list of model objects
            representing the extensions. If not specified, extensions are
            ignored.

        metadata_extensions_parser: An optional callable which accepts an
            Element with the 'extensions' tag and returns a list of model
            objects representing the extensions. If not specified, extensions
            are ignored.

        waypoint_extensions_parser: An optional callable which accepts an
            Element with the 'extensions' tag and returns a list of model
            objects representing the extensions. If not specified, extensions
            are ignored.

        route_extensions_parser: An optional callable which accepts an Element
            with the 'extensions' tag and returns a list of model objects
            representing the extensions. If not specified, extensions are
            ignored.

        track_extensions_parser: An optional callable which accepts an Element
            with the 'extensions' tag and returns a list of model objects
            representing the extensions. If not specified, extensions are
            ignored.

        segment_extensions_parser: An optional callable which accepts an
            Element with the 'extensions' tag and returns a list of model
            objects representing the extensions. If not specified, extensions
            are ignored.


    Returns:
        A GpxModel representing the data from the supplies xml.

    Raises:
        ValueError: The supplied XML could not be parsed as GPX.
    """"""
    gpxns = gpxns if gpxns is not None else determine_gpx_namespace(gpx_element)

    if gpx_element.tag != gpxns+'gpx':
        raise ValueError(""No gpx root element"")

    creator = gpx_element.attrib['creator']
    version = gpx_element.attrib['version']

    if not version.startswith('1.1'):
        raise ValueError(""Not a GPX 1.1 file"")

    metadata_element = gpx_element.find(gpxns+'metadata')
    metadata = nullable(parse_metadata)(metadata_element, gpxns)

    waypoint_elements = gpx_element.findall(gpxns+'wpt')
    waypoints = [parse_waypoint(waypoint_element, gpxns) for waypoint_element in waypoint_elements]

    route_elements = gpx_element.findall(gpxns+'rte')
    routes = [parse_route(route_element, gpxns) for route_element in route_elements]

    track_elements = gpx_element.findall(gpxns+'trk')
    tracks = [parse_track(track_element, gpxns) for track_element in track_elements]

    extensions_element = gpx_element.find(gpxns+'extensions')
    extensions = nullable(parse_gpx_extensions)(extensions_element, gpxns)

    gpx_model = GpxModel(creator, metadata, waypoints, routes, tracks,
                         extensions)

    return gpx_model"
1641,"def listens_to(name, sender=None, weak=True):
    """"""Listens to a named signal
    """"""
    def decorator(f):
        if sender:
            return signal(name).connect(f, sender=sender, weak=weak)
        return signal(name).connect(f, weak=weak)
    return decorator"
1642,"def LoadInstallations(counter):
    """"""Load installed packages and export the version map.

    This function may be called multiple times, but the counters will
    be increased each time. Since Prometheus counters are never
    decreased, the aggregated results will not make sense.
    """"""
    process = subprocess.Popen([""pip"", ""list"", ""--format=json""],
                               stdout=subprocess.PIPE)
    output, _ = process.communicate()
    installations = json.loads(output)
    for i in installations:
        counter.labels(i[""name""], i[""version""]).inc()"
1643,"def RESTrequest(*args, **kwargs):
    """"""return and save the blob of data that is returned
    from kegg without caring to the format""""""
    verbose = kwargs.get('verbose', False)
    force_download = kwargs.get('force', False)
    save = kwargs.get('force', True)

    # so you can copy paste from kegg
    args = list(chain.from_iterable(a.split('/') for a in args))
    args = [a for a in args if a]
    request = 'http://rest.kegg.jp/' + ""/"".join(args)
    print_verbose(verbose, ""richiedo la pagina: "" + request)
    filename = ""KEGG_"" + ""_"".join(args)
    try:
        if force_download:
            raise IOError()
        print_verbose(verbose, ""loading the cached file "" + filename)
        with open(filename, 'r') as f:
            data = pickle.load(f)
    except IOError:
        print_verbose(verbose, ""downloading the library,it may take some time"")
        import urllib2
        try:
            req = urllib2.urlopen(request)
            data = req.read()
            if save:
                with open(filename, 'w') as f:
                    print_verbose(verbose, ""saving the file to "" + filename)
                    pickle.dump(data, f)
        # clean the error stacktrace
        except urllib2.HTTPError as e:
            raise e
    return data"
1644,"def command_help_long(self):
    """"""
      Return command help for use in global parser usage string
      
      @TODO update to support self.current_indent from formatter
    """"""
    indent = "" "" * 2 # replace with current_indent
    help = ""Command must be one of:\n""
    for action_name in self.parser.valid_commands:
      help += ""%s%-10s %-70s\n"" % (indent, action_name, self.parser.commands[action_name].desc_short.capitalize())
    help += '\nSee \'%s help COMMAND\' for help and information on a command' % self.parser.prog
    return help"
1645,"def _print(self, helpstr, file=None):
    """""".
    """"""
    if file is None:
        file = sys.stdout
    encoding = self._get_encoding(file)
    file.write(helpstr.encode(encoding, ""replace""))"
1646,"def run(self):
    """"""
      Run the multiopt parser
    """"""
    self.parser = MultioptOptionParser(
      usage=""%prog <command> [options] [args]"",
      prog=self.clsname,
      version=self.version,
      option_list=self.global_options,
      description=self.desc_short,
      commands=self.command_set,
      epilog=self.footer
    )
    
    try:
      self.options, self.args = self.parser.parse_args(self.argv)    
    except Exception, e:
      print str(e)
      pass

    if len(self.args) < 1:
      self.parser.print_lax_help()
      return 2
    
    self.command = self.args.pop(0)
    showHelp = False
    
    if self.command == 'help': 
      if len(self.args) < 1:
        self.parser.print_lax_help()
        return 2
      else:
        self.command = self.args.pop()
        showHelp = True

    if self.command not in self.valid_commands:
      self.parser.print_cmd_error(self.command)
      return 2

    self.command_set[self.command].set_cmdname(self.command)
    subcmd_parser = self.command_set[self.command].get_parser(self.clsname, self.version, self.global_options)
    subcmd_options, subcmd_args = subcmd_parser.parse_args(self.args)

    if showHelp:
      subcmd_parser.print_help_long()
      return 1

    try:
      self.command_set[self.command].func(subcmd_options, *subcmd_args)
    except (CommandError, TypeError), e:
      # self.parser.print_exec_error(self.command, str(e))
      subcmd_parser.print_exec_error(self.command, str(e))
      print 
      # @TODO show command help
      # self.parser.print_lax_help()
      return 2

      
    return 1"
1647,"def list(self, community=None, hostfilter=None, host=None):
        """"""
        Returns a list of SNMP information for a community, hostfilter or host
        :param snmpstring: A specific SNMP string to list
        :param hostfilter: Valid hostfilter or None
        :param host: t_hosts.id or t_hosts.f_ipaddr
        :return: [ [ record_id, ipaddr, hostname, community, access, version ] ... ]
        """"""
        return self.send.snmp_list(community, hostfilter, host)"
1648,"def add(self, host=None, f_community=None, f_access=None, f_version=None):
        """"""
        Add an SNMP community string to a host

        :param host: t_hosts.id or t_hosts.f_ipaddr
        :param f_community: Community string to add
        :param f_access: READ or WRITE
        :param f_version: v1, v2c or v3
        :return: (True/False, t_snmp.id/Error string)
        """"""
        return self.send.snmp_add(host, f_community, f_access, f_version)"
1649,"def delete_collection(db_name, collection_name, host='localhost', port=27017):
    """"""Almost exclusively for testing.""""""
    client = MongoClient(""mongodb://%s:%d"" % (host, port))
    client[db_name].drop_collection(collection_name)"
1650,"def ensure_table(self, cls):
        """"""Required functionality.""""""
        coll_name = cls.get_table_name()
        try:
            db = self.mongo_client.get_default_database()
            db.create_collection(coll_name)
        except CollectionInvalid:
            pass  # Expected if collection already exists

        # Make sure we have indexes
        coll = self.get_collection(coll_name)
        for idx_name in cls.index_names():
            coll.ensure_index(idx_name)"
1651,"def find_one(self, cls, id):
        """"""Required functionality.""""""
        one = self._find(cls, {""_id"": id})
        if not one:
            return None
        return one[0]"
1652,"def find_by_index(self, cls, index_name, value):
        """"""Required functionality.""""""
        return self._find(cls, {index_name: str(value)})"
1653,"def save(self, obj):
        """"""Required functionality.""""""
        if not obj.id:
            obj.id = uuid()

        stored_data = {
            '_id': obj.id,
            'value': json.loads(obj.to_data())
        }

        index_vals = obj.indexes() or {}
        for key in obj.__class__.index_names() or []:
            val = index_vals.get(key, '')
            stored_data[key] = str(val)

        coll = self.get_collection(obj.__class__.get_table_name())
        coll.update({""_id"": obj.id}, stored_data, upsert=True)"
1654,"def delete(self, obj):
        """"""Required functionality.""""""
        del_id = obj.get_id()
        if not del_id:
            return

        coll = self.get_collection(obj.__class__.get_table_name())
        coll.delete_one({""_id"": del_id})"
1655,"def new(cls, __name, __fields, **defaults):
    '''
    Creates a new class that can represent a record with the
    specified *fields*. This is equal to a mutable namedtuple.
    The returned class also supports keyword arguments in its
    constructor.

    :param __name: The name of the recordclass.
    :param __fields: A string or list of field names.
    :param defaults: Default values for fields. The defaults
      may list field names that haven't been listed in *fields*.
    '''

    name = __name
    fields = __fields
    fieldset = set(fields)

    if isinstance(fields, str):
      if ',' in fields:
        fields = fields.split(',')
      else:
        fields = fields.split()
    else:
      fields = list(fields)

    for key in defaults.keys():
      if key not in fields:
        fields.append(key)

    class _record(cls):
      __slots__ = fields
      __defaults__ = defaults
    _record.__name__ = name
    return _record"
1656,"def _check_1st_line(line, **kwargs):
    """"""First line check.

    Check that the first line has a known component name followed by a colon
    and then a short description of the commit.

    :param line: first line
    :type line: str
    :param components: list of known component names
    :type line: list
    :param max_first_line: maximum length of the first line
    :type max_first_line: int
    :return: errors as in (code, line number, *args)
    :rtype: list

    """"""
    components = kwargs.get(""components"", ())
    max_first_line = kwargs.get(""max_first_line"", 50)

    errors = []
    lineno = 1
    if len(line) > max_first_line:
        errors.append((""M190"", lineno, max_first_line, len(line)))

    if line.endswith("".""):
        errors.append((""M191"", lineno))

    if ':' not in line:
        errors.append((""M110"", lineno))
    else:
        component, msg = line.split(':', 1)
        if component not in components:
            errors.append((""M111"", lineno, component))

    return errors"
1657,"def _check_bullets(lines, **kwargs):
    """"""Check that the bullet point list is well formatted.

    Each bullet point shall have one space before and after it. The bullet
    character is the ""*"" and there is no space before it but one after it
    meaning the next line are starting with two blanks spaces to respect the
    indentation.

    :param lines: all the lines of the message
    :type lines: list
    :param max_lengths: maximum length of any line. (Default 72)
    :return: errors as in (code, line number, *args)
    :rtype: list

    """"""
    max_length = kwargs.get(""max_length"", 72)
    labels = {l for l, _ in kwargs.get(""commit_msg_labels"", tuple())}

    def _strip_ticket_directives(line):
        return re.sub(r'( \([^)]*\)){1,}$', '', line)

    errors = []
    missed_lines = []
    skipped = []

    for (i, line) in enumerate(lines[1:]):
        if line.startswith('*'):
            dot_found = False
            if len(missed_lines) > 0:
                errors.append((""M130"", i + 2))
            if lines[i].strip() != '':
                errors.append((""M120"", i + 2))
            if _strip_ticket_directives(line).endswith('.'):
                dot_found = True

            label = _re_bullet_label.search(line)
            if label and label.group('label') not in labels:
                errors.append((""M122"", i + 2, label.group('label')))

            for (j, indented) in enumerate(lines[i + 2:]):
                if indented.strip() == '':
                    break
                if not re.search(r""^ {2}\S"", indented):
                    errors.append((""M121"", i + j + 3))
                else:
                    skipped.append(i + j + 1)
                    stripped_line = _strip_ticket_directives(indented)
                    if stripped_line.endswith('.'):
                        dot_found = True
                    elif stripped_line.strip():
                        dot_found = False

            if not dot_found:
                errors.append((""M123"", i + 2))

        elif i not in skipped and line.strip():
            missed_lines.append((i + 2, line))

        if len(line) > max_length:
            errors.append((""M190"", i + 2, max_length, len(line)))

    return errors, missed_lines"
1658,"def _check_signatures(lines, **kwargs):
    """"""Check that the signatures are valid.

    There should be at least three signatures. If not, one of them should be a
    trusted developer/reviewer.

    Formatting supported being: [signature] full name <email@address>

    :param lines: lines (lineno, content) to verify.
    :type lines: list
    :param signatures: list of supported signature
    :type signatures: list
    :param alt_signatures: list of alternative signatures, not counted
    :type alt_signatures: list
    :param trusted: list of trusted reviewers, the e-mail address.
    :type trusted: list
    :param min_reviewers: minimal number of reviewers needed. (Default 3)
    :type min_reviewers: int
    :return: errors as in (code, line number, *args)
    :rtype: list

    """"""
    trusted = kwargs.get(""trusted"", ())
    signatures = tuple(kwargs.get(""signatures"", ()))
    alt_signatures = tuple(kwargs.get(""alt_signatures"", ()))
    min_reviewers = kwargs.get(""min_reviewers"", 3)

    matching = []
    errors = []
    signatures += alt_signatures

    test_signatures = re.compile(""^({0})"".format(""|"".join(signatures)))
    test_alt_signatures = re.compile(""^({0})"".format(""|"".join(alt_signatures)))
    for i, line in lines:
        if signatures and test_signatures.search(line):
            if line.endswith("".""):
                errors.append((""M191"", i))
            if not alt_signatures or not test_alt_signatures.search(line):
                matching.append(line)
        else:
            errors.append((""M102"", i))

    if not matching:
        errors.append((""M101"", 1))
        errors.append((""M100"", 1))
    elif len(matching) < min_reviewers:
        pattern = re.compile('|'.join(map(lambda x: '<' + re.escape(x) + '>',
                                          trusted)))
        trusted_matching = list(filter(None, map(pattern.search, matching)))
        if len(trusted_matching) == 0:
            errors.append((""M100"", 1))

    return errors"
1659,"def check_message(message, **kwargs):
    """"""Check the message format.

    Rules:

    - the first line must start by a component name
    - and a short description (52 chars),
    - then bullet points are expected
    - and finally signatures.

    :param components: compontents, e.g. ``('auth', 'utils', 'misc')``
    :type components: `list`
    :param signatures: signatures, e.g. ``('Signed-off-by', 'Reviewed-by')``
    :type signatures: `list`
    :param alt_signatures: alternative signatures, e.g. ``('Tested-by',)``
    :type alt_signatures: `list`
    :param trusted: optional list of reviewers, e.g. ``('john.doe@foo.org',)``
    :type trusted: `list`
    :param max_length: optional maximum line length (by default: 72)
    :type max_length: int
    :param max_first_line: optional maximum first line length (by default: 50)
    :type max_first_line: int
    :param allow_empty: optional way to allow empty message (by default: False)
    :type allow_empty: bool
    :return: errors sorted by line number
    :rtype: `list`
    """"""
    if kwargs.pop(""allow_empty"", False):
        if not message or message.isspace():
            return []

    lines = re.split(r""\r\n|\r|\n"", message)
    errors = _check_1st_line(lines[0], **kwargs)
    err, signature_lines = _check_bullets(lines, **kwargs)
    errors += err
    errors += _check_signatures(signature_lines, **kwargs)

    def _format(code, lineno, args):
        return ""{0}: {1} {2}"".format(lineno,
                                     code,
                                     _messages_codes[code].format(*args))

    return list(map(lambda x: _format(x[0], x[1], x[2:]),
                    sorted(errors, key=lambda x: x[0])))"
1660,"def _register_pyflakes_check():
    """"""Register the pyFlakes checker into PEP8 set of checks.""""""
    from flake8_isort import Flake8Isort
    from flake8_blind_except import check_blind_except

    # Resolving conflicts between pep8 and pyflakes.
    codes = {
        ""UnusedImport"": ""F401"",
        ""ImportShadowedByLoopVar"": ""F402"",
        ""ImportStarUsed"": ""F403"",
        ""LateFutureImport"": ""F404"",
        ""Redefined"": ""F801"",
        ""RedefinedInListComp"": ""F812"",
        ""UndefinedName"": ""F821"",
        ""UndefinedExport"": ""F822"",
        ""UndefinedLocal"": ""F823"",
        ""DuplicateArgument"": ""F831"",
        ""UnusedVariable"": ""F841"",
    }

    for name, obj in vars(pyflakes.messages).items():
        if name[0].isupper() and obj.message:
            obj.tpl = ""{0} {1}"".format(codes.get(name, ""F999""), obj.message)

    pep8.register_check(_PyFlakesChecker, codes=['F'])
    # FIXME parser hack
    parser = pep8.get_parser('', '')
    Flake8Isort.add_options(parser)
    options, args = parser.parse_args([])
    # end of hack
    pep8.register_check(Flake8Isort, codes=['I'])
    pep8.register_check(check_blind_except, codes=['B90'])"
1661,"def is_file_excluded(filename, excludes):
    """"""Check if the file should be excluded.

    :param filename: file name
    :param excludes: list of regex to match
    :return: True if the file should be excluded
    """"""
    # check if you need to exclude this file
    return any([exclude and re.match(exclude, filename) is not None
                for exclude in excludes])"
1662,"def check_pep8(filename, **kwargs):
    """"""Perform static analysis on the given file.

    :param filename: path of file to check.
    :type filename: str
    :param ignore: codes to ignore, e.g. ``('E111', 'E123')``
    :type ignore: `list`
    :param select: codes to explicitly select.
    :type select: `list`
    :param pyflakes: run the pyflakes checks too (default ``True``)
    :type pyflakes: bool
    :return: errors
    :rtype: `list`

    .. seealso:: :py:class:`pycodestyle.Checker`
    """"""
    options = {
        ""ignore"": kwargs.get(""ignore""),
        ""select"": kwargs.get(""select""),
    }

    if not _registered_pyflakes_check and kwargs.get(""pyflakes"", True):
        _register_pyflakes_check()

    checker = pep8.Checker(filename, reporter=_Report, **options)
    checker.check_all()

    errors = []
    for error in sorted(checker.report.errors, key=lambda x: x[0]):
        errors.append(""{0}:{1}: {3}"".format(*error))
    return errors"
1663,"def check_pydocstyle(filename, **kwargs):
    """"""Perform static analysis on the given file docstrings.

    :param filename: path of file to check.
    :type filename: str
    :param ignore: codes to ignore, e.g. ('D400',)
    :type ignore: `list`
    :param match: regex the filename has to match to be checked
    :type match: str
    :param match_dir: regex everydir in path should match to be checked
    :type match_dir: str
    :return: errors
    :rtype: `list`

    .. seealso::
        `PyCQA/pydocstyle <https://github.com/GreenSteam/pydocstyle/>`_

    """"""
    ignore = kwargs.get(""ignore"")
    match = kwargs.get(""match"", None)
    match_dir = kwargs.get(""match_dir"", None)

    errors = []

    if match and not re.match(match, os.path.basename(filename)):
        return errors

    if match_dir:
        # FIXME here the full path is checked, be sure, if match_dir doesn't
        # match the path (usually temporary) before the actual application path
        # it may not run the checks when it should have.
        path = os.path.split(os.path.abspath(filename))[0]
        while path != ""/"":
            path, dirname = os.path.split(path)
            if not re.match(match_dir, dirname):
                return errors

    checker = pydocstyle.PEP257Checker()
    with open(filename) as fp:
        try:
            for error in checker.check_source(fp.read(), filename):
                if ignore is None or error.code not in ignore:
                    # Removing the colon ':' after the error code
                    message = re.sub(""(D[0-9]{3}): ?(.*)"",
                                     r""\1 \2"",
                                     error.message)
                    errors.append(""{0}: {1}"".format(error.line, message))
        except tokenize.TokenError as e:
            errors.append(""{1}:{2} {0}"".format(e.args[0], *e.args[1]))
        except pydocstyle.AllError as e:
            errors.append(str(e))

    return errors"
1664,"def check_license(filename, **kwargs):
    """"""Perform a license check on the given file.

    The license format should be commented using # and live at the top of the
    file. Also, the year should be the current one.

    :param filename: path of file to check.
    :type filename: str
    :param year: default current year
    :type year: int
    :param ignore: codes to ignore, e.g. ``('L100', 'L101')``
    :type ignore: `list`
    :param python_style: False for JavaScript or CSS files
    :type python_style: bool
    :return: errors
    :rtype: `list`

    """"""
    year = kwargs.pop(""year"", datetime.now().year)
    python_style = kwargs.pop(""python_style"", True)
    ignores = kwargs.get(""ignore"")
    template = ""{0}: {1} {2}""

    if python_style:
        re_comment = re.compile(r""^#.*|\{#.*|[\r\n]+$"")
        starter = ""# ""
    else:
        re_comment = re.compile(r""^/\*.*| \*.*|[\r\n]+$"")
        starter = "" *""

    errors = []
    lines = []
    file_is_empty = False
    license = """"
    lineno = 0
    try:
        with codecs.open(filename, ""r"", ""utf-8"") as fp:
            line = fp.readline()
            blocks = []
            while re_comment.match(line):
                if line.startswith(starter):
                    line = line[len(starter):].lstrip()
                    blocks.append(line)
                    lines.append((lineno, line.strip()))
                lineno, line = lineno + 1, fp.readline()
            file_is_empty = line == """"
            license = """".join(blocks)
    except UnicodeDecodeError:
        errors.append((lineno + 1, ""L190"", ""utf-8""))
        license = """"

    if file_is_empty and not license.strip():
        return errors

    match_year = _re_copyright_year.search(license)
    if match_year is None:
        errors.append((lineno + 1, ""L101""))
    elif int(match_year.group(""year"")) != year:
        theline = match_year.group(0)
        lno = lineno
        for no, l in lines:
            if theline.strip() == l:
                lno = no
                break
        errors.append((lno + 1, ""L102"", year, match_year.group(""year"")))
    else:
        program_match = _re_program.search(license)
        program_2_match = _re_program_2.search(license)
        program_3_match = _re_program_3.search(license)
        if program_match is None:
            errors.append((lineno, ""L100""))
        elif (program_2_match is None or
              program_3_match is None or
              (program_match.group(""program"").upper() !=
               program_2_match.group(""program"").upper() !=
               program_3_match.group(""program"").upper())):
            errors.append((lineno, ""L103""))

    def _format_error(lineno, code, *args):
        return template.format(lineno, code,
                               _licenses_codes[code].format(*args))

    def _filter_codes(error):
        if not ignores or error[1] not in ignores:
            return error

    return list(map(lambda x: _format_error(*x),
                    filter(_filter_codes, errors)))"
1665,"def check_file(filename, **kwargs):
    """"""Perform static analysis on the given file.

    .. seealso::

        - :data:`.SUPPORTED_FILES`
        - :func:`.check_pep8`
        - :func:`.check_pydocstyle`
        - and :func:`.check_license`

    :param filename: path of file to check.
    :type filename: str
    :return: errors sorted by line number or None if file is excluded
    :rtype: `list`

    """"""
    excludes = kwargs.get(""excludes"", [])
    errors = []

    if is_file_excluded(filename, excludes):
        return None

    if filename.endswith("".py""):
        if kwargs.get(""pep8"", True):
            errors += check_pep8(filename, **kwargs)
        if kwargs.get(""pydocstyle"", True):
            errors += check_pydocstyle(filename, **kwargs)
        if kwargs.get(""license"", True):
            errors += check_license(filename, **kwargs)
    elif re.search(""\.(tpl|html)$"", filename):
        errors += check_license(filename, **kwargs)
    elif re.search(""\.(js|jsx|css|less)$"", filename):
        errors += check_license(filename, python_style=False, **kwargs)

    def try_to_int(value):
        try:
            return int(value.split(':', 1)[0])
        except ValueError:
            return 0

    return sorted(errors, key=try_to_int)"
1666,"def check_author(author, **kwargs):
    """"""Check the presence of the author in the AUTHORS/THANKS files.

    Rules:

    - the author full name and email must appear in AUTHORS file

    :param authors: name of AUTHORS files
    :type authors: `list`
    :param path: path to the repository home
    :type path: str
    :return: errors
    :rtype: `list`
    """"""
    errors = []

    authors = kwargs.get(""authors"")
    if not authors:
        errors.append('1:A100: ' + _author_codes['A100'])
        return errors

    exclude_author_names = kwargs.get(""exclude_author_names"")
    if exclude_author_names and author in exclude_author_names:
        return []

    path = kwargs.get(""path"")
    if not path:
        path = os.getcwd()

    for afile in authors:
        if not os.path.exists(path + os.sep + afile):
            errors.append('1:A101: ' + _author_codes['A101'].format(afile))

    if errors:
        return errors

    status = subprocess.Popen(['grep', '-q', author] +
                              [path + os.sep + afile for afile in authors],
                              stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE,
                              cwd=path).wait()
    if status:
        errors.append('1:A102: ' + _author_codes['A102'].format(author))

    return errors"
1667,"def get_options(config=None):
    """"""Build the options from the config object.""""""
    if config is None:
        from . import config
        config.get = lambda key, default=None: getattr(config, key, default)

    base = {
        ""components"": config.get(""COMPONENTS""),
        ""signatures"": config.get(""SIGNATURES""),
        ""commit_msg_template"": config.get(""COMMIT_MSG_TEMPLATE""),
        ""commit_msg_labels"": config.get(""COMMIT_MSG_LABELS""),
        ""alt_signatures"": config.get(""ALT_SIGNATURES""),
        ""trusted"": config.get(""TRUSTED_DEVELOPERS""),
        ""pep8"": config.get(""CHECK_PEP8"", True),
        ""pydocstyle"": config.get(""CHECK_PYDOCSTYLE"", True),
        ""license"": config.get(""CHECK_LICENSE"", True),
        ""pyflakes"": config.get(""CHECK_PYFLAKES"", True),
        ""ignore"": config.get(""IGNORE""),
        ""select"": config.get(""SELECT""),
        ""match"": config.get(""PYDOCSTYLE_MATCH""),
        ""match_dir"": config.get(""PYDOCSTYLE_MATCH_DIR""),
        ""min_reviewers"": config.get(""MIN_REVIEWERS""),
        ""colors"": config.get(""COLORS"", True),
        ""excludes"": config.get(""EXCLUDES"", []),
        ""authors"": config.get(""AUTHORS""),
        ""exclude_author_names"": config.get(""EXCLUDE_AUTHOR_NAMES""),
    }
    options = {}
    for k, v in base.items():
        if v is not None:
            options[k] = v
    return options"
1668,"def run(self):
        """"""Yield the error messages.""""""
        for msg in self.messages:
            col = getattr(msg, 'col', 0)
            yield msg.lineno, col, (msg.tpl % msg.message_args), msg.__class__"
1669,"def error(self, line_number, offset, text, check):
        """"""Run the checks and collect the errors.""""""
        code = super(_Report, self).error(line_number, offset, text, check)
        if code:
            self.errors.append((line_number, offset + 1, code, text, check))"
1670,"def prompt(prompt_string, default=None, secret=False, boolean=False, bool_type=None):
    """"""
    Prompt user for a string, with a default value

    * secret converts to password prompt
    * boolean converts return value to boolean, checking for starting with a Y
    """"""
    if boolean or bool_type in BOOLEAN_DEFAULTS:
        if bool_type is None:
            bool_type = 'y_n'
        default_msg = BOOLEAN_DEFAULTS[bool_type][is_affirmative(default)]
    else:
        default_msg = "" (default {val}): ""
    prompt_string += (default_msg.format(val=default) if default else "": "")
    if secret:
        val = getpass(prompt_string)
    else:
        val = input(prompt_string)
    val = (val if val else default)
    if boolean:
        val = val.lower().startswith('y')
    return val"
1671,"def prop_unc(jc):
    """"""
    Propagate uncertainty.

    :param jc: the Jacobian and covariance matrix
    :type jc: sequence

    This method is mainly designed to be used as the target for a
    multiprocessing pool.
    """"""
    j, c = jc
    return np.dot(np.dot(j, c), j.T)"
1672,"def partial_derivative(f, x, n, nargs, delta=DELTA):
    """"""
    Calculate partial derivative using central finite difference approximation.

    :param f: function
    :param x: sequence of arguments
    :param n: index of argument derivateve is with respect to
    :param nargs: number of arguments
    :param delta: optional step size, default is :math:`\\epsilon^{1/3}` where
        :math:`\\epsilon` is machine precision
    """"""
    dx = np.zeros((nargs, len(x[n])))
    # scale delta by (|x| + 1.0) to avoid noise from machine precision
    dx[n] += np.where(x[n], x[n] * delta, delta)
    # apply central difference approximation
    x_dx = zip(*[xi + (dxi, -dxi) for xi, dxi in zip(x, dx)])
    return (f(x_dx[0]) - f(x_dx[1])) / dx[n] / 2.0"
1673,"def jacobian(func, x, nf, nobs, *args, **kwargs):
    """"""
    Estimate Jacobian matrices :math:`\\frac{\\partial f_i}{\\partial x_{j,k}}`
    where :math:`k` are independent observations of :math:`x`.

    The independent variable, :math:`x`, must be a numpy array with exactly 2
    dimensions. The first dimension is the number of independent arguments,
    and the second dimensions is the number of observations.

    The function must return a Numpy array with exactly 2 dimensions. The first
    is the number of returns and the second dimension corresponds to the number
    of observations. If the input argument is 2-D then the output should also
    be 2-D

    Constant arguments can be passed as additional positional arguments or
    keyword arguments. If any constant argument increases the number of
    observations of the return value, tile the input arguments to match.

    Use :func:`numpy.atleast_2d` or :func:`numpy.reshape` to get the
    correct dimensions for scalars.

    :param func: function
    :param x: independent variables grouped by observation
    :param nf: number of return in output (1st dimension)
    :param nobs: number of observations in output (2nd dimension)
    :return: Jacobian matrices for each observation
    """"""
    nargs = len(x)  # degrees of freedom
    f = lambda x_: func(x_, *args, **kwargs)
    j = np.zeros((nargs, nf, nobs))  # matrix of zeros
    for n in xrange(nargs):
        j[n] = partial_derivative(f, x, n, nargs)
        # better to transpose J once than transpose partial derivative each time
        # j[:,:,n] = df.T
    return j.T"
1674,"def jflatten(j):
    """"""
    Flatten 3_D Jacobian into 2-D.
    """"""
    nobs, nf, nargs = j.shape
    nrows, ncols = nf * nobs, nargs * nobs
    jflat = np.zeros((nrows, ncols))
    for n in xrange(nobs):
        r, c = n * nf, n * nargs
        jflat[r:(r + nf), c:(c + nargs)] = j[n]
    return jflat"
1675,"def jtosparse(j):
    """"""
    Generate sparse matrix coordinates from 3-D Jacobian.
    """"""
    data = j.flatten().tolist()
    nobs, nf, nargs = j.shape
    indices = zip(*[(r, c) for n in xrange(nobs)
                    for r in xrange(n * nf, (n + 1) * nf)
                    for c in xrange(n * nargs, (n + 1) * nargs)])
    return csr_matrix((data, indices), shape=(nobs * nf, nobs * nargs))"
1676,"def unc_wrapper_args(*covariance_keys):
    """"""
    Wrap function, calculate its Jacobian and calculate the covariance of the
    outputs given the covariance of the specified inputs.

    :param covariance_keys: indices and names of arguments corresponding to
        covariance
    :return: wrapped function bound to specified covariance keys

    This is the outer uncertainty wrapper that allows you to specify the
    arguments in the original function that correspond to the covariance. The
    inner wrapper takes the original function to be wrapped. ::

        def f(a, b, c, d, kw1='foo', *args, **kwargs):
            pass

        # arguments a, c, d and kw1 correspond to the covariance matrix
        f_wrapped = unc_wrapper_args(0, 2, 3, 'kw1')(f)

        cov = np.array([[0.0001, 0., 0., 0.], [0., 0.0001, 0., 0.],
                        [0., 0., 0.0001, 0.], [0., 0., 0., 0.0001])
        y, cov, jac = f_wrapped(a, b, c, d, kw1='bar', __covariance__=cov)

    The covariance keys can be indices of positional arguments or the names of
    keywords argument used in calling the function. If no covariance keys are
    specified then the arguments that correspond to the covariance shoud be
    grouped into a sequence. If ``None`` is anywhere in ``covariance_keys`` then
    all of the arguments will be used to calculate the Jacobian.

    The covariance matrix must be a symmetrical matrix with positive numbers on
    the diagonal that correspond to the square of the standard deviation, second
    moment around the mean or root-mean-square(RMS) of the function with respect
    to the arguments specified as covariance keys. The other elements are the
    covariances corresponding to the arguments intersecting at that element.
    Pass the covariance matrix with the keyword ``__covariance__`` and it will
    be popped from the dictionary of keyword arguments provided to the wrapped
    function.

    The wrapped function will return the evaluation of the original function,
    its Jacobian, which is the sensitivity of the return output to each
    argument specified as a covariance key and the covariance propagated using
    the first order terms of a Taylor series expansion around the arguments.

    An optional keyword argument ``__method__`` can also be passed to the
    wrapped function (not the wrapper) that specifies the method used to
    calculate the dot product. The default method is ``'loop'``. The other
    methods are ``'dense'``, ``'sparse'`` and ``'pool'``.

    If the arguments specified as covariance keys are arrays, they should all be
    the same size. These dimensions will be considered as separate observations.
    Another argument, not in the covariance keys, may also create observations.
    The resulting Jacobian will have dimensions of number of observations (nobs)
    by number of return output (nf) by number of covariance keys (nargs). The
    resulting covariance will be nobs x nf x nf.
    """"""
    def wrapper(f):
        @wraps(f)
        def wrapped_function(*args, **kwargs):
            cov = kwargs.pop('__covariance__', None)  # pop covariance
            method = kwargs.pop('__method__', 'loop')  # pop covariance
            # covariance keys cannot be defaults, they must be in args or kwargs
            cov_keys = covariance_keys
            # convert args to kwargs by index
            kwargs.update({n: v for n, v in enumerate(args)})
            args = ()  # empty args
            if None in cov_keys:
                # use all keys
                cov_keys = kwargs.keys()
            # group covariance keys
            if len(cov_keys) > 0:
                # uses specified keys
                x = [np.atleast_1d(kwargs.pop(k)) for k in cov_keys]
            else:
                # arguments already grouped
                x = kwargs.pop(0)  # use first argument
            # remaining args
            args_dict = {}

            def args_from_kwargs(kwargs_):
                """"""unpack positional arguments from keyword arguments""""""
                # create mapping of positional arguments by index
                args_ = [(n, v) for n, v in kwargs_.iteritems()
                         if not isinstance(n, basestring)]
                # sort positional arguments by index
                idx, args_ = zip(*sorted(args_, key=lambda m: m[0]))
                # remove args_ and their indices from kwargs_
                args_dict_ = {n: kwargs_.pop(n) for n in idx}
                return args_, args_dict_

            if kwargs:
                args, args_dict = args_from_kwargs(kwargs)

            def f_(x_, *args_, **kwargs_):
                """"""call original function with independent variables grouped""""""
                args_dict_ = args_dict
                if cov_keys:
                    kwargs_.update(zip(cov_keys, x_), **args_dict_)
                if kwargs_:
                    args_, _ = args_from_kwargs(kwargs_)
                    return np.array(f(*args_, **kwargs_))
                # assumes independent variables already grouped
                return f(x_, *args_, **kwargs_)

            # evaluate function and Jacobian
            avg = f_(x, *args, **kwargs)
            # number of returns and observations
            if avg.ndim > 1:
                nf, nobs = avg.shape
            else:
                nf, nobs = avg.size, 1
            jac = jacobian(f_, x, nf, nobs, *args, **kwargs)
            # calculate covariance
            if cov is not None:
                # covariance must account for all observations
                # scale covariances by x squared in each direction
                if cov.ndim == 3:
                    x = np.array([np.repeat(y, nobs) if len(y)==1
                                  else y for y in x])
                    LOGGER.debug('x:\n%r', x)
                    cov = np.array([c * y * np.row_stack(y)
                                    for c, y in zip(cov, x.T)])
                else: # x are all only one dimension
                    x = np.asarray(x)
                    cov = cov * x * x.T
                    assert jac.size / nf / nobs == cov.size / len(x)
                    cov = np.tile(cov, (nobs, 1, 1))
                # propagate uncertainty using different methods
                if method.lower() == 'dense':
                    j, c = jflatten(jac), jflatten(cov)
                    cov = prop_unc((j, c))
                # sparse
                elif method.lower() == 'sparse':
                    j, c = jtosparse(jac), jtosparse(cov)
                    cov = j.dot(c).dot(j.transpose())
                    cov = cov.todense()
                # pool
                elif method.lower() == 'pool':
                    try:
                        p = Pool()
                        cov = np.array(p.map(prop_unc, zip(jac, cov)))
                    finally:
                        p.terminate()
                # loop is the default
                else:
                    cov = np.array([prop_unc((jac[o], cov[o]))
                                    for o in xrange(nobs)])
                # dense and spares are flattened, unravel them into 3-D list of
                # observations
                if method.lower() in ['dense', 'sparse']:
                    cov = np.array([
                        cov[(nf * o):(nf * (o + 1)), (nf * o):(nf * (o + 1))]
                        for o in xrange(nobs)
                    ])
            # unpack returns for original function with ungrouped arguments
            if None in cov_keys or len(cov_keys) > 0:
                return tuple(avg.tolist() + [cov, jac])
            # independent variables were already grouped
            return avg, cov, jac
        return wrapped_function
    return wrapper"
1677,"def assign_handler(query, category):
	""""""assign_handler(query, category) -- assign the user's query to a 
	particular category, and call the appropriate handler.
	""""""
	if(category == 'count lines'):
		handler.lines(query)
	elif(category == 'count words'):
		handler.words(query)
	elif(category == 'weather'):
		web.weather(query)
	elif(category == 'no match'):
		web.generic(query)
	elif(category == 'file info'):
		handler.file_info(query)
	elif(category == 'executable'):
		handler.make_executable(query)
	elif(category == 'search'):
		handler.search(query)
	elif(category == 'path'):
		handler.add_to_path(query)
	elif(category == 'uname'):
		handler.system_info(query)
	else:
		print 'I\'m not able to understand your query'"
1678,"def get_file_name(query):
	""""""get_file_name(query) -> filename -- return the filename found in a
	given, found by matching a regular expression.
	""""""
	match = re.search(r'\S*\.[\d\w]{1,4}', query)
	if(match):
		filename = match.group()
		return filename
	else:
		start = match.start()
		end = match.end()
		spaces = re.finditer(r' ', query)
		space_index = []
		for space in spaces:
			space_index.append(space.start())
		space_index.pop()
		for i in space_index:
			filename = query[i+1:end]
			if(os.path.isfile(filename)):
				return filename
		return None"
1679,"def get_path(query):
	""""""get_path(query) -> pathname -- return the path found in a
	given, found by matching a regular expression.
	""""""
	match = re.search(r'/(.*/)+(\S*(\.[\d\w]{1,4})?)', query)
	if(os.path.isfile(match.group()) or os.path.isdir(match.group())):
		return match.group()
	else:
		return None"
1680,"def get_readable_filesize(size):
	""""""get_readable_filesize(size) -> filesize -- return human readable 
	filesize from given size in bytes.
	""""""
	if(size < 1024):
		return str(size)+' bytes'
	temp = size/1024.0
	level = 1
	while(temp >= 1024 and level< 3):
		temp = temp/1024
		level += 1
	if(level == 1):
		return str(round(temp,2))+' KB'
	elif(level == 2):
		return str(round(temp,2))+' MB'
	else:
		return str(round(temp,2))+' GB'"
1681,"def list(self, svc_rec=None, hostfilter=None, compromised=False):
        """"""
        List user accounts

        :param svc_rec: db.t_services.id
        :param hostfilter:
        :param compromised: Show only compromised accounts
        :return: [acct.t_accounts.f_services_id, acct.t_hosts.f_ipaddr,
                     acct.t_hosts.f_hostname,
                     acct.t_accounts.id, acct.t_accounts.f_username,
                     acct.t_accounts.f_fullname, acct.t_accounts.f_password,
                     acct.t_accounts.f_compromised, acct.t_accounts.f_hash1,
                     acct.t_accounts.f_hash1_type, acct.t_accounts.f_hash2,
                     acct.t_accounts.f_hash2_type, acct.t_accounts.f_source,
                     acct.t_accounts.f_uid, acct.t_accounts.f_gid,
                     acct.t_accounts.f_level, acct.t_accounts.f_domain,
                     acct.t_accounts.f_message, acct.t_accounts.f_lockout,
                     acct.t_accounts.f_duration, acct.t_accounts.f_active,
                     acct.t_accounts.f_description,
                     acct.t_services.f_proto, acct.t_services.f_number,
                   ]
        """"""
        return self.send.accounts_list(svc_rec, hostfilter, compromised)"
1682,"def upload_file(self, service_rec=None, host_service=None, filename=None,
                    pw_data=None, f_type=None, add_to_evidence=True):
        """"""
        Upload a password file

        :param service_rec: db.t_services.id
        :param host_service: db.t_hosts.id
        :param filename: Filename
        :param pw_data: Content of file
        :param f_type: Type of file
        :param add_to_evidence: True/False to add to t_evidence
        :return: (True/False, Response Message)
        """"""
        return self.send.accounts_upload_file(service_rec, host_service, filename, pw_data, f_type, add_to_evidence)"
1683,"def _columns_to_kwargs(conversion_table, columns, row):
    """"""
    Given a list of column names, and a list of values (a row), return a dict
    of kwargs that may be used to instantiate a MarketHistoryEntry
    or MarketOrder object.

    :param dict conversion_table: The conversion table to use for mapping
        spec names to kwargs.
    :param list columns: A list of column names.
    :param list row: A list of values.
    """"""
    kwdict = {}

    counter = 0
    for column in columns:
        # Map the column name to the correct MarketHistoryEntry kwarg.
        kwarg_name = conversion_table[column]
        # Set the kwarg to the correct value from the row.
        kwdict[kwarg_name] = row[counter]
        counter += 1

    return kwdict"
1684,"def parse_datetime(time_str):
    """"""
    Wraps dateutil's parser function to set an explicit UTC timezone, and
    to make sure microseconds are 0. Unified Uploader format and EMK format
    bother don't use microseconds at all.

    :param str time_str: The date/time str to parse.
    :rtype: datetime.datetime
    :returns: A parsed, UTC datetime.
    """"""
    try:
        return dateutil.parser.parse(
            time_str
        ).replace(microsecond=0).astimezone(UTC_TZINFO)
    except ValueError:
        # This was some kind of unrecognizable time string.
        raise ParseError(""Invalid time string: %s"" % time_str)"
1685,"def merge(self, po_file, source_files):
        """"""从源码中获取所有条目，合并到 po_file 中。

        :param string po_file: 待写入的 po 文件路径。
        :param list source_files :  所有待处理的原文件路径 list。

        """"""
        # Create a temporary file to write pot file
        pot_file = tempfile.NamedTemporaryFile(mode='wb', prefix='rookout_', delete=False)
        pot_filename = pot_file.name
        slog.info('Create POT file [%s].', pot_filename)
        xargs = [self._xgettext,
                ""--package-name=main"",
                ""--package-version=0.1"",
                ""--default-domain=main"",
                ""--from-code=UTF-8"",
                ""-C"", ""-k_"",
                ""--output"", pot_filename]
        txt = subprocess.check_output(xargs+source_files, 
                stderr=subprocess.STDOUT, 
                universal_newlines=True)
        if len(txt) > 0:
            raise(ChildProcessError(txt))
        slog.info('Start merge [%s] to [%s].', pot_filename, po_file)
        xargs = [self._msgmerge, ""-U"", po_file, pot_filename]
        txt = subprocess.check_output(xargs, universal_newlines=True)
        slog.info(txt)
        pot_file.close()
        os.remove(pot_filename)"
1686,"def fmt(self, po_file, mo_file):
        """"""将 po 文件转换成 mo 文件。

        :param string po_file: 待转换的 po 文件路径。
        :param string mo_file: 目标 mo 文件的路径。

        """"""
        if not os.path.exists(po_file):
            slog.error('The PO file [%s] is non-existen!'%po_file)
            return
        txt = subprocess.check_output([self._msgfmt, 
            '--check', ""--strict"", '--verbose', 
            ""--output-file"", mo_file, po_file], 
                stderr=subprocess.STDOUT, 
                universal_newlines=True)
        slog.info(txt)"
1687,"def add_suffix(filename, suffix):
        """"""
        ADD suffix TO THE filename (NOT INCLUDING THE FILE EXTENSION)
        """"""
        path = filename.split(""/"")
        parts = path[-1].split(""."")
        i = max(len(parts) - 2, 0)
        parts[i] = parts[i] + suffix
        path[-1] = ""."".join(parts)
        return ""/"".join(path)"
1688,"def find(self, pattern):
        """"""
        :param pattern: REGULAR EXPRESSION TO MATCH NAME (NOT INCLUDING PATH)
        :return: LIST OF File OBJECTS THAT HAVE MATCHING NAME
        """"""
        output = []

        def _find(dir):
            if re.match(pattern, dir._filename.split(""/"")[-1]):
                output.append(dir)
            if dir.is_directory():
                for c in dir.children:
                    _find(c)
        _find(self)
        return output"
1689,"def set_extension(self, ext):
        """"""
        RETURN NEW FILE WITH GIVEN EXTENSION
        """"""
        path = self._filename.split(""/"")
        parts = path[-1].split(""."")
        if len(parts) == 1:
            parts.append(ext)
        else:
            parts[-1] = ext

        path[-1] = ""."".join(parts)
        return File(""/"".join(path))"
1690,"def set_name(self, name):
        """"""
        RETURN NEW FILE WITH GIVEN EXTENSION
        """"""
        path = self._filename.split(""/"")
        parts = path[-1].split(""."")
        if len(parts) == 1:
            path[-1] = name
        else:
            path[-1] = name + ""."" + parts[-1]
        return File(""/"".join(path))"
1691,"def backup_name(self, timestamp=None):
        """"""
        RETURN A FILENAME THAT CAN SERVE AS A BACKUP FOR THIS FILE
        """"""
        suffix = datetime2string(coalesce(timestamp, datetime.now()), ""%Y%m%d_%H%M%S"")
        return File.add_suffix(self._filename, suffix)"
1692,"def read(self, encoding=""utf8""):
        """"""
        :param encoding:
        :return:
        """"""
        with open(self._filename, ""rb"") as f:
            if self.key:
                return get_module(""mo_math.crypto"").decrypt(f.read(), self.key)
            else:
                content = f.read().decode(encoding)
                return content"
1693,"def read_zipfile(self, encoding='utf8'):
        """"""
        READ FIRST FILE IN ZIP FILE
        :param encoding:
        :return: STRING
        """"""
        from zipfile import ZipFile
        with ZipFile(self.abspath) as zipped:
            for num, zip_name in enumerate(zipped.namelist()):
                return zipped.open(zip_name).read().decode(encoding)"
1694,"def append(self, content, encoding='utf8'):
        """"""
        add a line to file
        """"""
        if not self.parent.exists:
            self.parent.create()
        with open(self._filename, ""ab"") as output_file:
            if not is_text(content):
                Log.error(u""expecting to write unicode only"")
            output_file.write(content.encode(encoding))
            output_file.write(b""\n"")"
1695,"def url_param2value(param):
    """"""
    CONVERT URL QUERY PARAMETERS INTO DICT
    """"""
    if param == None:
        return Null
    if param == None:
        return Null

    def _decode(v):
        output = []
        i = 0
        while i < len(v):
            c = v[i]
            if c == ""%"":
                d = hex2chr(v[i + 1:i + 3])
                output.append(d)
                i += 3
            else:
                output.append(c)
                i += 1

        output = text_type("""".join(output))
        try:
            return json2value(output)
        except Exception:
            pass
        return output

    query = Data()
    for p in param.split('&'):
        if not p:
            continue
        if p.find(""="") == -1:
            k = p
            v = True
        else:
            k, v = p.split(""="")
            v = _decode(v)

        u = query.get(k)
        if u is None:
            query[k] = v
        elif is_list(u):
            u += [v]
        else:
            query[k] = [u, v]

    return query"
1696,"def value2url_param(value):
    """"""
    :param value:
    :return: ascii URL
    """"""
    if value == None:
        Log.error(""Can not encode None into a URL"")

    if is_data(value):
        value_ = wrap(value)
        output = ""&"".join([
            value2url_param(k) + ""="" + (value2url_param(v) if is_text(v) else value2url_param(value2json(v)))
            for k, v in value_.leaves()
            ])
    elif is_text(value):
        output = """".join(_map2url[c] for c in value.encode('utf8'))
    elif is_binary(value):
        output = """".join(_map2url[c] for c in value)
    elif hasattr(value, ""__iter__""):
        output = "","".join(value2url_param(v) for v in value)
    else:
        output = str(value)
    return output"
1697,"def configfile_from_path(path, strict=True):
    """"""Get a ConfigFile object based on a file path.

    This method will inspect the file extension and return the appropriate
    ConfigFile subclass initialized with the given path.

    Args:
        path (str): The file path which represents the configuration file.
        strict (bool): Whether or not to parse the file in strict mode.

    Returns:
        confpy.loaders.base.ConfigurationFile: The subclass which is
            specialized for the given file path.

    Raises:
        UnrecognizedFileExtension: If there is no loader for the path.
    """"""
    extension = path.split('.')[-1]
    conf_type = FILE_TYPES.get(extension)
    if not conf_type:

        raise exc.UnrecognizedFileExtension(
            ""Cannot parse file of type {0}. Choices are {1}."".format(
                extension,
                FILE_TYPES.keys(),
            )
        )

    return conf_type(path=path, strict=strict)"
1698,"def configuration_from_paths(paths, strict=True):
    """"""Get a Configuration object based on multiple file paths.

    Args:
        paths (iter of str): An iterable of file paths which identify config
            files on the system.
        strict (bool): Whether or not to parse the files in strict mode.

    Returns:
        confpy.core.config.Configuration: The loaded configuration object.

    Raises:
        NamespaceNotRegistered: If a file contains a namespace which is not
            defined.
        OptionNotRegistered: If a file contains an option which is not defined
            but resides under a valid namespace.
        UnrecognizedFileExtension: If there is no loader for a path.
    """"""
    for path in paths:

        cfg = configfile_from_path(path, strict=strict).config

    return cfg"
1699,"def set_environment_var_options(config, env=None, prefix='CONFPY'):
    """"""Set any configuration options which have an environment var set.

    Args:
        config (confpy.core.config.Configuration): A configuration object which
            has been initialized with options.
        env (dict): Optional dictionary which contains environment variables.
            The default is os.environ if no value is given.
        prefix (str): The string prefix prepended to all environment variables.
            This value will be set to upper case. The default is CONFPY.

    Returns:
        confpy.core.config.Configuration: A configuration object with
            environment variables set.

    The pattern to follow when setting environment variables is:

        <PREFIX>_<SECTION>_<OPTION>

    Each value should be upper case and separated by underscores.
    """"""
    env = env or os.environ
    for section_name, section in config:

        for option_name, _ in section:

            var_name = '{0}_{1}_{2}'.format(
                prefix.upper(),
                section_name.upper(),
                option_name.upper(),
            )
            env_var = env.get(var_name)
            if env_var:

                setattr(section, option_name, env_var)

    return config"
1700,"def set_cli_options(config, arguments=None):
    """"""Set any configuration options which have a CLI value set.

    Args:
        config (confpy.core.config.Configuration): A configuration object which
            has been initialized with options.
        arguments (iter of str): An iterable of strings which contains the CLI
            arguments passed. If nothing is give then sys.argv is used.

    Returns:
        confpy.core.config.Configuration: A configuration object with CLI
            values set.

    The pattern to follow when setting CLI values is:

        <section>_<option>

    Each value should be lower case and separated by underscores.
    """"""
    arguments = arguments or sys.argv[1:]
    parser = argparse.ArgumentParser()
    for section_name, section in config:

        for option_name, _ in section:

            var_name = '{0}_{1}'.format(
                section_name.lower(),
                option_name.lower(),
            )
            parser.add_argument('--{0}'.format(var_name))

    args, _ = parser.parse_known_args(arguments)
    args = vars(args)
    for section_name, section in config:

        for option_name, _ in section:

            var_name = '{0}_{1}'.format(
                section_name.lower(),
                option_name.lower(),
            )
            value = args.get(var_name)
            if value:

                setattr(section, option_name, value)

    return config"
1701,"def check_for_missing_options(config):
    """"""Iter over a config and raise if a required option is still not set.

    Args:
        config (confpy.core.config.Configuration): The configuration object
            to validate.

    Raises:
        MissingRequiredOption: If any required options are not set in the
            configuration object.

    Required options with default values are considered set and will not cause
    this function to raise.
    """"""
    for section_name, section in config:

        for option_name, option in section:

            if option.required and option.value is None:

                raise exc.MissingRequiredOption(
                    ""Option {0} in namespace {1} is required."".format(
                        option_name,
                        section_name,
                    )
                )

    return config"
1702,"def parse_options(files, env_prefix='CONFPY', strict=True):
    """"""Parse configuration options and return a configuration object.

    Args:
        files (iter of str): File paths which identify configuration files.
            These files are processed in order with values in later files
            overwriting values in earlier files.
        env_prefix (str): The static prefix prepended to all options when set
            as environment variables. The default is CONFPY.
        strict (bool): Whether or not to parse the files in strict mode.

    Returns:
        confpy.core.config.Configuration: The loaded configuration object.

    Raises:
        MissingRequiredOption: If a required option is not defined in any file.
        NamespaceNotRegistered: If a file contains a namespace which is not
            defined.
        OptionNotRegistered: If a file contains an option which is not defined
            but resides under a valid namespace.
        UnrecognizedFileExtension: If there is no loader for a path.
    """"""
    return check_for_missing_options(
        config=set_cli_options(
            config=set_environment_var_options(
                config=configuration_from_paths(
                    paths=files,
                    strict=strict,
                ),
                prefix=env_prefix,
            ),
        )
    )"
1703,"def buy_product(self, product_pk):
        """"""
        determina si el customer ha comprado un producto
        """"""
        if self.invoice_sales.filter(line_invoice_sales__line_order__product__pk=product_pk).exists() \
                or self.ticket_sales.filter(line_ticket_sales__line_order__product__pk=product_pk).exists():
            return True
        else:
            return False"
1704,"def template(self):
        """""" Get the template from: YAML or class """"""

        # First try props
        if self.props.template:
            return self.props.template
        else:
            # Return the wtype of the widget, and we'll presume that,
            # like resources, there's a .html file in that directory
            return self.wtype"
1705,"def render(self, sphinx_app: Sphinx, context):
        """""" Given a Sphinx builder and context with sphinx_app in it,
         generate HTML """"""

        # Called from kaybee.plugins.widgets.handlers.render_widgets

        builder: StandaloneHTMLBuilder = sphinx_app.builder
        resource = sphinx_app.env.resources[self.docname]
        context['sphinx_app'] = sphinx_app
        context['widget'] = self
        context['resource'] = resource

        # make_context is optionally implemented on the concrete class
        # for each widget
        self.make_context(context, sphinx_app)

        # NOTE: Can use builder.templates.render_string
        template = self.template + '.html'
        html = builder.templates.render(template, context)
        return html"
1706,"def desc(t=None, reg=True):
    """"""
    Describe Class Dependency

    :param reg: should we register this class as well
    :param t: custom type as well
    :return:
    """"""

    def decorated_fn(cls):
        if not inspect.isclass(cls):
            return NotImplemented('For now we can only describe classes')
        name = t or camel_case_to_underscore(cls.__name__)[0]
        if reg:
            di.injector.register(name, cls)
        else:
            di.injector.describe(name, cls)
        return cls

    return decorated_fn"
1707,"def add(self, key, value=None):
        """"""
        Adds the new key to this enumerated type.
        
        :param      key | <str>
        """"""
        if value is None:
            value = 2 ** (len(self))

        self[key] = value
        setattr(self, key, self[key])
        return value"
1708,"def all(self):
        """"""
        Returns all the values joined together.
        
        :return     <int>
        """"""
        out = 0
        for key, value in self.items():
            out |= value
        return out"
1709,"def base(self, value, recurse=True):
        """"""
        Returns the root base for the given value from this enumeration.
        
        :param      value   | <variant>
                    recurse | <bool>
        """"""
        while value in self._bases:
            value = self._bases[value]
            if not recurse:
                break
        return value"
1710,"def displayText(self, value, blank='', joiner=', '):
        """"""
        Returns the display text for the value associated with
        the inputted text.  This will result in a comma separated
        list of labels for the value, or the blank text provided if
        no text is found.
        
        :param      value  | <variant>
                    blank  | <str>
                    joiner | <str>
        
        :return     <str>
        """"""
        if value is None:
            return ''

        labels = []
        for key, my_value in sorted(self.items(), key=lambda x: x[1]):
            if value & my_value:
                labels.append(self._labels.get(my_value, text.pretty(key)))

        return joiner.join(labels) or blank"
1711,"def extend(self, base, key, value=None):
        """"""
        Adds a new definition to this enumerated type, extending the given
        base type.  This will create a new key for the type and register
        it as a new viable option from the system, however, it will also
        register its base information so you can use enum.base to retrieve
        the root type.
        
        :param      base  | <variant> | value for this enumeration
                    key   | <str>     | new key for the value
                    value | <variant> | if None is supplied, it will be auto-assigned
        
        :usage      |>>> from projex.enum import enum
                    |>>> Types = enum('Integer', 'Boolean')
                    |>>> Types.Integer
                    |1
                    |>>> Types.Boolean
                    |2
                    |>>> Types.extend(Types.Integer, 'BigInteger')
                    |>>> Types.BigInteger
                    |4
                    |>>> Types.base(Types.BigInteger)
                    |1
        """"""
        new_val = self.add(key, value)
        self._bases[new_val] = base"
1712,"def fromSet(self, values):
        """"""
        Generates a flag value based on the given set of values.

        :param values: <set>

        :return: <int>
        """"""
        value = 0
        for flag in values:
            value |= self(flag)
        return value"
1713,"def label(self, value):
        """"""
        Returns a pretty text version of the key for the inputted value.

        :param      value | <variant>

        :return     <str>
        """"""
        return self._labels.get(value) or text.pretty(self(value))"
1714,"def labels(self):
        """"""
        Return a list of ""user friendly"" labels.
        
        :return     <list> [ <str>, .. ]
        """"""
        return [self._labels.get(value) or text.pretty(key)
                for key, value in sorted(self.items(), key=lambda x: x[1])]"
1715,"def setLabel(self, value, label):
        """"""
        Sets the label text for the inputted value.  This will override the default pretty
        text label that is used for the key.

        :param      value | <variant>
                    label | <str>
        """"""
        if label:
            self._labels[value] = label
        else:
            self._labels.pop(value, None)"
1716,"def text(self, value, default=''):
        """"""
        Returns the text for the inputted value.
        
        :return     <str>
        """"""
        for key, val in self.items():
            if val == value:
                return key
        return default"
1717,"def toSet(self, flags):
        """"""
        Generates a flag value based on the given set of values.

        :param values: <set>

        :return: <int>
        """"""
        return {key for key, value in self.items() if value & flags}"
1718,"def valueByLabel(self, label):
        """"""
        Determine a given value based on the inputted label.

        :param      label   <str>
        
        :return     <int>
        """"""
        keys = self.keys()
        labels = [text.pretty(key) for key in keys]
        if label in labels:
            return self[keys[labels.index(label)]]
        return 0"
1719,"def cli(ctx, name,all):
    """"""Show example for doing some task in bubble(experimental)""""""
    ctx.gbc.say('all_example_functions',stuff=all_examples_functions, verbosity=1000)

    for example in all_examples_functions:
        if all or (name and example['name'] == name):
            if all:
                ctx.gbc.say('example',stuff=example, verbosity=100)
                name = example['name']
            #click.echo_via_pager(example['fun']())
            click.echo(""#""*80)
            click.echo(""### start of bubble example: ""+name)
            click.echo(""#""*80)
            click.echo(example['fun']())
            click.echo(""#""*80)
            click.echo(""### end of bubble example: ""+name)
            click.echo(""#""*80)
            click.echo()

        else:
            click.echo(""available example: "" + example['name'])"
1720,"def check_if_alive(self):
        """"""Check if the content is available on the host server. Returns `True` if available, else `False`.
        This method is `lazy`-evaluated or only executes when called.
        :rtype: bool
        """"""

        try:
            from urllib2 import urlopen, URLError, HTTPError
        except ImportError:
            from urllib.request import urlopen, URLError, HTTPError

        if len(self.instance.STATUS_LINK):
            check_url = self.instance.STATUS_LINK % ({'content_uid': self.get_content_uid()})
        else:
            # fallback
            check_url = self.instance.url

        try:
            response = urlopen(check_url)
        except (HTTPError, URLError):
            return False
        except ValueError:
            raise URLError('Invalid URL: %s'.format(check_url))
        else:
            return True if response.code == 200 else False"
1721,"def load_config_file(self):
        """"""Parse configuration file and get config values.""""""
        config_parser = SafeConfigParser()

        config_parser.read(self.CONFIG_FILE)

        if config_parser.has_section('handlers'):
            self._config['handlers_package'] = config_parser.get('handlers', 'package')

        if config_parser.has_section('auth'):
            self._config['consumer_key'] = config_parser.get('auth', 'consumer_key')
            self._config['consumer_secret'] = config_parser.get('auth', 'consumer_secret')
            self._config['token_key'] = config_parser.get('auth', 'token_key')
            self._config['token_secret'] = config_parser.get('auth', 'token_secret')

        if config_parser.has_section('stream'):
            self._config['user_stream'] = config_parser.get('stream', 'user_stream').lower() == 'true'
        else:
            self._config['user_stream'] = False

        if config_parser.has_option('general', 'min_seconds_between_errors'):
            self._config['min_seconds_between_errors'] = config_parser.get('general', 'min_seconds_between_errors')
        if config_parser.has_option('general', 'sleep_seconds_on_consecutive_errors'):
            self._config['sleep_seconds_on_consecutive_errors'] = config_parser.get(
                'general', 'sleep_seconds_on_consecutive_errors')"
1722,"def load_config_from_cli_arguments(self, *args, **kwargs):
        """"""
        Get config values of passed in CLI options.

        :param dict kwargs: CLI options
        """"""
        self._load_config_from_cli_argument(key='handlers_package', **kwargs)
        self._load_config_from_cli_argument(key='auth', **kwargs)
        self._load_config_from_cli_argument(key='user_stream', **kwargs)
        self._load_config_from_cli_argument(key='min_seconds_between_errors', **kwargs)
        self._load_config_from_cli_argument(key='sleep_seconds_on_consecutive_errors', **kwargs)"
1723,"def validate_configs(self):
        """"""
        Check that required config are set.
        :raises :class:`~responsebot.common.exceptions.MissingConfigError`: if a required config is missing
        """"""
        # Check required arguments, validate values
        for conf in self.REQUIRED_CONFIGS:
            if conf not in self._config:
                raise MissingConfigError('Missing required configuration %s' % conf)"
1724,"def get(self, id):
        """""" Gets the dict data and builds the item object.
        """"""
        data = self.db.get_data(self.get_path, id=id)
        return self._build_item(**data['Data'][self.name])"
1725,"def save(self, entity):
        """"""Maps entity to dict and returns future""""""
        assert isinstance(entity, Entity), "" entity must have an instance of Entity""
        return self.__collection.save(entity.as_dict())"
1726,"def find_one(self, **kwargs):
        """"""Returns future.

        Executes collection's find_one method based on keyword args
        maps result ( dict to instance ) and return future

        Example::

           manager = EntityManager(Product)
           product_saved = yield manager.find_one(_id=object_id)

         """"""
        future = TracebackFuture()

        def handle_response(result, error):
            if error:
                future.set_exception(error)
            else:
                instance = self.__entity()
                instance.map_dict(result)
                future.set_result(instance)

        self.__collection.find_one(kwargs, callback=handle_response)

        return future"
1727,"def find(self, **kwargs):
        """"""Returns List(typeof=).

        Executes collection's find method based on keyword args
        maps results ( dict to list of entity instances).

        Set max_limit parameter to limit the amount of data send back through network

        Example::

            manager = EntityManager(Product)
            products = yield manager.find(age={'$gt': 17}, max_limit=100)

         """"""
        max_limit = None
        if 'max_limit' in kwargs:
            max_limit = kwargs.pop('max_limit')
        cursor = self.__collection.find(kwargs)
        instances = []
        for doc in (yield cursor.to_list(max_limit)):
            instance = self.__entity()
            instance.map_dict(doc)
            instances.append(instance)
        return instances"
1728,"def update(self, entity):
        """""" Executes collection's update method based on keyword args.

        Example::

            manager = EntityManager(Product)
            p = Product()
            p.name = 'new name'
            p.description = 'new description'
            p.price = 300.0

            yield manager.update(p)

         """"""
        assert isinstance(entity, Entity), ""Error: entity must have an instance of Entity""
        return self.__collection.update({'_id': entity._id}, {'$set': entity.as_dict()})"
1729,"async def get_poll(poll_id):
    """""" Get a strawpoll.

    Example:

        poll = strawpy.get_poll('11682852')

    :param poll_id:
    :return: strawpy.Strawpoll object
    """"""
    async with aiohttp.get('{api_url}/{poll_id}'.format(api_url=api_url, poll_id=poll_id)) as r:
        return await StrawPoll(r)"
1730,"async def create_poll(title, options, multi=True, permissive=True, captcha=False, dupcheck='normal'):
    """""" Create a strawpoll.

    Example:

        new_poll = strawpy.create_poll('Is Python the best?', ['Yes', 'No'])

    :param title:
    :param options:
    :param multi:
    :param permissive:
    :param captcha:
    :param dupcheck:
    :return: strawpy.Strawpoll object
    """"""

    query = {
        'title': title,
        'options': options,
        'multi': multi,
        'permissive': permissive,
        'captcha': captcha,
        'dupcheck': dupcheck
    }

    async with aiohttp.post(api_url, data=json.dumps(query)) as r:
        return await StrawPoll(r)"
1731,"def raise_status(response):
    """"""Raise an exception if the request did not return a status code of 200.

    :param response: Request response body
    """"""
    if response.status != 200:
        if response.status == 401:
            raise StrawPollException('Unauthorized', response)
        elif response.status == 403:
            raise StrawPollException('Forbidden', response)
        elif response.status == 404:
            raise StrawPollException('Not Found', response)
        else:
            response.raise_for_status()"
1732,"def results_with_percent(self):
        """""" Zip options, votes and percents (as integers) together.

        :return: List of tuples (option, votes, percent)
        """"""

        percents = [int(float(v) / sum(self.votes) * 100) if sum(self.votes) > 0 else 0 for v in self.votes]
        return zip(self.options, self.votes, percents)"
1733,"def open(self, results=False):
        """""" Open the strawpoll in a browser. Can specify to open the main or results page.

        :param results: True/False
        """"""

        webbrowser.open(self.results_url if results else self.url)"
1734,"def main():
    """"""
    Testing function for DFA brzozowski algebraic method Operation
    """"""
    argv = sys.argv
    if len(argv) < 2:
        targetfile = 'target.y'
    else:
        targetfile = argv[1]
    print 'Parsing ruleset: ' + targetfile,
    flex_a = Flexparser()
    mma = flex_a.yyparse(targetfile)
    print 'OK'
    print 'Perform minimization on initial automaton:',
    mma.minimize()
    print 'OK'
    print 'Perform Brzozowski on minimal automaton:',
    brzozowski_a = Brzozowski(mma)
    mma_regex = brzozowski_a.get_regex()
    print mma_regex"
1735,"def _bfs_sort(self, start):
        """"""
        maintain a map of states distance using BFS
        Args:
            start (fst state): The initial DFA state
        Returns:
            list: An ordered list of DFA states
                  using path distance
        """"""
        pathstates = {}
        # maintain a queue of nodes to be visited. Both current and previous
        # node must be included.
        queue = []
        # push the first path into the queue
        queue.append([0, start])
        pathstates[start.stateid] = 0
        while queue:
            # get the first node from the queue
            leaf = queue.pop(0)
            node = leaf[1]
            pathlen = leaf[0]
            # enumerate all adjacent nodes, construct a new path and push it
            # into the queue
            for arc in node.arcs:
                next_state = self.mma[arc.nextstate]
                if next_state.stateid not in pathstates:
                    queue.append([pathlen + 1, next_state])
                    pathstates[next_state.stateid] = pathlen + 1
        orderedstatesdict = OrderedDict(
            sorted(
                pathstates.items(),
                key=lambda x: x[1],
                reverse=False))
        for state in self.mma.states:
            orderedstatesdict[state.stateid] = state
        orderedstates = [x[1] for x in list(orderedstatesdict.items())]
        return orderedstates"
1736,"def star(self, input_string):
        """"""
        Kleene star operation
        Args:
            input_string (str): The string that the kleene star will be made
        Returns:
            str: The applied Kleene star operation on the input string
        """"""
        if input_string != self.epsilon and input_string != self.empty:
            return ""("" + input_string + "")*""
        else:
            return """""
1737,"def _brzozowski_algebraic_method_init(self):
        """"""Initialize Brzozowski Algebraic Method""""""
        # Initialize B
        for state_a in self.mma.states:
            if state_a.final:
                self.B[state_a.stateid] = self.epsilon
            else:
                self.B[state_a.stateid] = self.empty
            # Initialize A
            for state_b in self.mma.states:
                self.A[state_a.stateid, state_b.stateid] = self.empty
                for arc in state_a.arcs:
                    if arc.nextstate == state_b.stateid:
                        self.A[state_a.stateid, state_b.stateid] = \
                            self.mma.isyms.find(arc.ilabel)"
1738,"def _brzozowski_algebraic_method_solve(self):
        """"""Perform Brzozowski Algebraic Method""""""
        orderedstates = self._bfs_sort(
            sorted(
                self.mma.states,
                key=attrgetter('initial'),
                reverse=True)[0])
        for n in range(len(orderedstates) - 1, 0, -1):
            # print ""n:"" + repr(n)
            if self.A[
                    orderedstates[n].stateid,
                    orderedstates[n].stateid] != self.empty:
                # B[n] := star(A[n,n]) . B[n]
                if self.B[orderedstates[n].stateid] != self.empty:
                    self.B[orderedstates[n].stateid] = \
                        self.star(self.A[orderedstates[n].stateid, orderedstates[n].stateid]) \
                        + self.B[orderedstates[n].stateid]
                else:
                    self.B[orderedstates[n].stateid] = self.star(
                        self.A[orderedstates[n].stateid, orderedstates[n].stateid])
                for j in range(0, n):
                    # A[n,j] := star(A[n,n]) . A[n,j]
                    if self.A[
                            orderedstates[n].stateid,
                            orderedstates[j].stateid] != self.empty:
                        self.A[
                            orderedstates[n].stateid,
                            orderedstates[j].stateid] = \
                            self.star(self.A[orderedstates[n].stateid, orderedstates[n].stateid]) \
                            + self.A[orderedstates[n].stateid, orderedstates[j].stateid]
                    else:
                        self.A[orderedstates[n].stateid, orderedstates[j].stateid] = self.star(
                            self.A[orderedstates[n].stateid, orderedstates[n].stateid])
            for i in range(0, n):
                # B[i] += A[i,n] . B[n]
                newnode = None
                if self.A[orderedstates[i].stateid, orderedstates[n].stateid] != self.empty \
                        and self.B[orderedstates[n].stateid] != self.empty:
                    newnode = self.A[orderedstates[i].stateid, orderedstates[
                        n].stateid] + self.B[orderedstates[n].stateid]
                elif self.A[orderedstates[i].stateid, orderedstates[n].stateid] != self.empty:
                    newnode = self.A[
                        orderedstates[i].stateid,
                        orderedstates[n].stateid]
                elif self.B[orderedstates[n].stateid] != self.empty:
                    newnode = self.B[orderedstates[n].stateid]
                if self.B[orderedstates[i].stateid] != self.empty:
                    if newnode is not None:
                        self.B[orderedstates[i].stateid] += newnode
                else:
                    self.B[orderedstates[i].stateid] = newnode
                for j in range(0, n):
                    # A[i,j] += A[i,n] . A[n,j]
                    newnode = None
                    if self.A[
                            orderedstates[i].stateid,
                            orderedstates[n].stateid] != self.empty \
                            and self.A[orderedstates[n].stateid, orderedstates[j].stateid] \
                                    != self.empty:
                        newnode = self.A[orderedstates[i].stateid, orderedstates[
                            n].stateid] + self.A[orderedstates[n].stateid, orderedstates[j].stateid]
                    elif self.A[orderedstates[i].stateid, orderedstates[n].stateid] != self.empty:
                        newnode = self.A[
                            orderedstates[i].stateid,
                            orderedstates[n].stateid]
                    elif self.A[orderedstates[n].stateid, orderedstates[j].stateid] != self.empty:
                        newnode = self.A[
                            orderedstates[n].stateid,
                            orderedstates[j].stateid]
                    if self.A[
                            orderedstates[i].stateid,
                            orderedstates[j].stateid] != self.empty:
                        if newnode is not None:
                            self.A[
                                orderedstates[i].stateid,
                                orderedstates[j].stateid] += newnode
                    else:
                        self.A[
                            orderedstates[i].stateid,
                            orderedstates[j].stateid] = newnode"
1739,"def load_mmd():
    """"""Loads libMultiMarkdown for usage""""""
    global _MMD_LIB
    global _LIB_LOCATION
    try:
        lib_file = 'libMultiMarkdown' + SHLIB_EXT[platform.system()]
        _LIB_LOCATION = os.path.abspath(os.path.join(DEFAULT_LIBRARY_DIR, lib_file))

        if not os.path.isfile(_LIB_LOCATION):
            _LIB_LOCATION = ctypes.util.find_library('MultiMarkdown')

        _MMD_LIB = ctypes.cdll.LoadLibrary(_LIB_LOCATION)
    except:
        _MMD_LIB = None"
1740,"def _expand_source(source, dname, fmt):
    """"""Expands source text to include headers, footers, and expands Multimarkdown transclusion
    directives.

    Keyword arguments:
    source -- string containing the Multimarkdown text to expand
    dname -- directory name to use as the base directory for transclusion references
    fmt -- format flag indicating which format to use to convert transclusion statements
    """"""
    _MMD_LIB.g_string_new.restype = ctypes.POINTER(GString)
    _MMD_LIB.g_string_new.argtypes = [ctypes.c_char_p]
    src = source.encode('utf-8')
    gstr = _MMD_LIB.g_string_new(src)

    _MMD_LIB.prepend_mmd_header(gstr)
    _MMD_LIB.append_mmd_footer(gstr)

    manif = _MMD_LIB.g_string_new(b"""")
    _MMD_LIB.transclude_source.argtypes = [ctypes.POINTER(GString), ctypes.c_char_p,
                                           ctypes.c_char_p, ctypes.c_int, ctypes.POINTER(GString)]
    _MMD_LIB.transclude_source(gstr, dname.encode('utf-8'), None, fmt, manif)
    manifest_txt = manif.contents.str
    full_txt = gstr.contents.str
    _MMD_LIB.g_string_free(manif, True)
    _MMD_LIB.g_string_free(gstr, True)

    manifest_txt = [ii for ii in manifest_txt.decode('utf-8').split('\n') if ii]
    return full_txt.decode('utf-8'), manifest_txt"
1741,"def has_metadata(source, ext):
    """"""Returns a flag indicating if a given block of MultiMarkdown text contains metadata.""""""
    _MMD_LIB.has_metadata.argtypes = [ctypes.c_char_p, ctypes.c_int]
    _MMD_LIB.has_metadata.restype = ctypes.c_bool
    return _MMD_LIB.has_metadata(source.encode('utf-8'), ext)"
1742,"def convert(source, ext=COMPLETE, fmt=HTML, dname=None):
    """"""Converts a string of MultiMarkdown text to the requested format.
    Transclusion is performed if the COMPATIBILITY extension is not set, and dname is set to a
    valid directory

    Keyword arguments:
    source -- string containing MultiMarkdown text
    ext -- extension bitfield to pass to conversion process
    fmt -- flag indicating output format to use
    dname -- Path to use for transclusion - if None, transclusion functionality is bypassed
    """"""
    if dname and not ext & COMPATIBILITY:
        if os.path.isfile(dname):
            dname = os.path.abspath(os.path.dirname(dname))
        source, _ = _expand_source(source, dname, fmt)
    _MMD_LIB.markdown_to_string.argtypes = [ctypes.c_char_p, ctypes.c_ulong, ctypes.c_int]
    _MMD_LIB.markdown_to_string.restype = ctypes.c_char_p
    src = source.encode('utf-8')
    return _MMD_LIB.markdown_to_string(src, ext, fmt).decode('utf-8')"
1743,"def convert_from(fname, ext=COMPLETE, fmt=HTML):
    """"""
    Reads in a file and performs MultiMarkdown conversion, with transclusion ocurring based on the
    file directory. Returns the converted string.

    Keyword arguments:
    fname -- Filename of document to convert
    ext -- extension bitfield to pass to conversion process
    fmt -- flag indicating output format to use
    """"""

    dname = os.path.abspath(os.path.dirname(fname))
    with open(fname, 'r') as fp:
        src = fp.read()

    return convert(src, ext, fmt, dname)"
1744,"def manifest(txt, dname):
    """"""Extracts file manifest for a body of text with the given directory.""""""
    _, files = _expand_source(txt, dname, HTML)
    return files"
1745,"def keys(source, ext=COMPLETE):
    """"""Extracts metadata keys from the provided MultiMarkdown text.

    Keyword arguments:
    source -- string containing MultiMarkdown text
    ext -- extension bitfield for extracting MultiMarkdown
    """"""
    _MMD_LIB.extract_metadata_keys.restype = ctypes.c_char_p
    _MMD_LIB.extract_metadata_keys.argtypes = [ctypes.c_char_p, ctypes.c_ulong]
    src = source.encode('utf-8')
    all_keys = _MMD_LIB.extract_metadata_keys(src, ext)
    all_keys = all_keys.decode('utf-8') if all_keys else ''
    key_list = [ii for ii in all_keys.split('\n') if ii]
    return key_list"
1746,"def value(source, key, ext=COMPLETE):
    """"""Extracts value for the specified metadata key from the given extension set.

    Keyword arguments:
    source -- string containing MultiMarkdown text
    ext -- extension bitfield for processing text
    key -- key to extract
    """"""
    _MMD_LIB.extract_metadata_value.restype = ctypes.c_char_p
    _MMD_LIB.extract_metadata_value.argtypes = [ctypes.c_char_p, ctypes.c_ulong, ctypes.c_char_p]

    src = source.encode('utf-8')
    dkey = key.encode('utf-8')

    value = _MMD_LIB.extract_metadata_value(src, ext, dkey)
    return value.decode('utf-8') if value else ''"
1747,"def tweet(self, text, in_reply_to=None, filename=None, file=None):
        """"""
        Post a new tweet.

        :param text: the text to post
        :param in_reply_to: The ID of the tweet to reply to
        :param filename: If `file` param is not provided, read file from this path
        :param file: A file object, which will be used instead of opening `filename`. `filename` is still required, for
        MIME type detection and to use as a form field in the POST data
        :return: Tweet object
        """"""

        if filename is None:
            return Tweet(self._client.update_status(status=text, in_reply_to_status_id=in_reply_to)._json)
        else:
            return Tweet(self._client.update_with_media(filename=filename, file=file,
                                                        status=text, in_reply_to_status_id=in_reply_to)._json)"
1748,"def retweet(self, id):
        """"""
        Retweet a tweet.

        :param id: ID of the tweet in question
        :return: True if success, False otherwise
        """"""
        try:
            self._client.retweet(id=id)
            return True
        except TweepError as e:
            if e.api_code == TWITTER_PAGE_DOES_NOT_EXISTS_ERROR:
                return False
            raise"
1749,"def get_tweet(self, id):
        """"""
        Get an existing tweet.

        :param id: ID of the tweet in question
        :return: Tweet object. None if not found
        """"""
        try:
            return Tweet(self._client.get_status(id=id)._json)
        except TweepError as e:
            if e.api_code == TWITTER_TWEET_NOT_FOUND_ERROR:
                return None
            raise"
1750,"def get_user(self, id):
        """"""
        Get a user's info.

        :param id: ID of the user in question
        :return: User object. None if not found
        """"""
        try:
            return User(self._client.get_user(user_id=id)._json)
        except TweepError as e:
            if e.api_code == TWITTER_USER_NOT_FOUND_ERROR:
                return None
            raise"
1751,"def remove_tweet(self, id):
        """"""
        Delete a tweet.

        :param id: ID of the tweet in question
        :return: True if success, False otherwise
        """"""
        try:
            self._client.destroy_status(id=id)
            return True
        except TweepError as e:
            if e.api_code in [TWITTER_PAGE_DOES_NOT_EXISTS_ERROR, TWITTER_DELETE_OTHER_USER_TWEET]:
                return False
            raise"
1752,"def follow(self, user_id, notify=False):
        """"""
        Follow a user.

        :param user_id: ID of the user in question
        :param notify: whether to notify the user about the following
        :return: user that are followed
        """"""
        try:
            return User(self._client.create_friendship(user_id=user_id, follow=notify)._json)
        except TweepError as e:
            if e.api_code in [TWITTER_ACCOUNT_SUSPENDED_ERROR]:
                return self.get_user(user_id)
            raise"
1753,"def unfollow(self, user_id):
        """"""
        Follow a user.

        :param user_id: ID of the user in question
        :return: The user that were unfollowed
        """"""
        return User(self._client.destroy_friendship(user_id=user_id)._json)"
1754,"def create_list(self, name, mode='public', description=None):
        """"""
        Create a list

        :param name: Name of the new list
        :param mode: :code:`'public'` (default) or :code:`'private'`
        :param description: Description of the new list
        :return: The new list object
        :rtype: :class:`~responsebot.models.List`
        """"""
        return List(tweepy_list_to_json(self._client.create_list(name=name, mode=mode, description=description)))"
1755,"def destroy_list(self, list_id):
        """"""
        Destroy a list

        :param list_id: list ID number
        :return: The destroyed list object
        :rtype: :class:`~responsebot.models.List`
        """"""
        return List(tweepy_list_to_json(self._client.destroy_list(list_id=list_id)))"
1756,"def update_list(self, list_id, name=None, mode=None, description=None):
        """"""
        Update a list

        :param list_id: list ID number
        :param name: New name for the list
        :param mode: :code:`'public'` (default) or :code:`'private'`
        :param description: New description of the list
        :return: The updated list object
        :rtype: :class:`~responsebot.models.List`
        """"""
        return List(tweepy_list_to_json(
            self._client.update_list(list_id=list_id, name=name, mode=mode, description=description))
        )"
1757,"def list_timeline(self, list_id, since_id=None, max_id=None, count=20):
        """"""
        List the tweets of specified list.

        :param list_id: list ID number
        :param since_id: results will have ID greater than specified ID (more recent than)
        :param max_id: results will have ID less than specified ID (older than)
        :param count: number of results per page
        :return: list of :class:`~responsebot.models.Tweet` objects
        """"""
        statuses = self._client.list_timeline(list_id=list_id, since_id=since_id, max_id=max_id, count=count)
        return [Tweet(tweet._json) for tweet in statuses]"
1758,"def get_list(self, list_id):
        """"""
        Get info of specified list

        :param list_id: list ID number
        :return: :class:`~responsebot.models.List` object
        """"""
        return List(tweepy_list_to_json(self._client.get_list(list_id=list_id)))"
1759,"def add_list_member(self, list_id, user_id):
        """"""
        Add a user to list

        :param list_id: list ID number
        :param user_id: user ID number
        :return: :class:`~responsebot.models.List` object
        """"""
        return List(tweepy_list_to_json(self._client.add_list_member(list_id=list_id, user_id=user_id)))"
1760,"def remove_list_member(self, list_id, user_id):
        """"""
        Remove a user from a list

        :param list_id: list ID number
        :param user_id: user ID number
        :return: :class:`~responsebot.models.List` object
        """"""
        return List(tweepy_list_to_json(self._client.remove_list_member(list_id=list_id, user_id=user_id)))"
1761,"def list_members(self, list_id):
        """"""
        List users in a list

        :param list_id: list ID number
        :return: list of :class:`~responsebot.models.User` objects
        """"""
        return [User(user._json) for user in self._client.list_members(list_id=list_id)]"
1762,"def is_list_member(self, list_id, user_id):
        """"""
        Check if a user is member of a list

        :param list_id: list ID number
        :param user_id: user ID number
        :return: :code:`True` if user is member of list, :code:`False` otherwise
        """"""
        try:
            return bool(self._client.show_list_member(list_id=list_id, user_id=user_id))
        except TweepError as e:
            if e.api_code == TWITTER_USER_IS_NOT_LIST_MEMBER_SUBSCRIBER:
                return False
            raise"
1763,"def subscribe_list(self, list_id):
        """"""
        Subscribe to a list

        :param list_id: list ID number
        :return: :class:`~responsebot.models.List` object
        """"""
        return List(tweepy_list_to_json(self._client.subscribe_list(list_id=list_id)))"
1764,"def unsubscribe_list(self, list_id):
        """"""
        Unsubscribe to a list

        :param list_id: list ID number
        :return: :class:`~responsebot.models.List` object
        """"""
        return List(tweepy_list_to_json(self._client.unsubscribe_list(list_id=list_id)))"
1765,"def list_subscribers(self, list_id):
        """"""
        List subscribers of a list

        :param list_id: list ID number
        :return: :class:`~responsebot.models.User` object
        """"""
        return [User(user._json) for user in self._client.list_subscribers(list_id=list_id)]"
1766,"def is_subscribed_list(self, list_id, user_id):
        """"""
        Check if user is a subscribed of specified list

        :param list_id: list ID number
        :param user_id: user ID number
        :return: :code:`True` if user is subscribed of list, :code:`False` otherwise
        """"""
        try:
            return bool(self._client.show_list_subscriber(list_id=list_id, user_id=user_id))
        except TweepError as e:
            if e.api_code == TWITTER_USER_IS_NOT_LIST_MEMBER_SUBSCRIBER:
                return False
            raise"
1767,"def auth(config):
    """"""
    Perform authentication with Twitter and return a client instance to communicate with Twitter

    :param config: ResponseBot config
    :type config: :class:`~responsebot.utils.config_utils.ResponseBotConfig`
    :return: client instance to execute twitter action
    :rtype: :class:`~responsebot.responsebot_client.ResponseBotClient`
    :raises: :class:`~responsebot.common.exceptions.AuthenticationError`: If failed to authenticate
    :raises: :class:`~responsebot.common.exceptions.APIQuotaError`: If API call rate reached limit
    """"""
    auth = tweepy.OAuthHandler(config.get('consumer_key'), config.get('consumer_secret'))
    auth.set_access_token(config.get('token_key'), config.get('token_secret'))

    api = tweepy.API(auth)
    try:
        api.verify_credentials()
    except RateLimitError as e:
        raise APIQuotaError(e.args[0][0]['message'])
    except TweepError as e:
        raise AuthenticationError(e.args[0][0]['message'])
    else:
        logging.info('Successfully authenticated as %s' % api.me().screen_name)

        return ResponseBotClient(config=config, client=api)"
1768,"def json2py(json_obj):
    """"""
    Converts the inputted JSON object to a python value.
    
    :param      json_obj | <variant>
    """"""
    for key, value in json_obj.items():
        if type(value) not in (str, unicode):
            continue

        # restore a datetime
        if re.match('^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}:\d+$', value):
            value = datetime.datetime.strptime(value, '%Y-%m-%d %H:%M:%S:%f')
        elif re.match('^\d{4}-\d{2}-\d{2}$', value):
            year, month, day = map(int, value.split('-'))
            value = datetime.date(year, month, day)
        elif re.match('^\d{2}:\d{2}:\d{2}:\d+$', value):
            hour, minute, second, micro = map(int, value.split(':'))
            value = datetime.time(hour, minute, second, micro)
        else:
            found = False
            for decoder in _decoders:
                success, new_value = decoder(value)
                if success:
                    value = new_value
                    found = True
                    break

            if not found:
                continue

        json_obj[key] = value
    return json_obj"
1769,"def jsonify(py_data, default=None, indent=4, sort_keys=True):
    """"""
    Converts the inputted Python data to JSON format.
    
    :param      py_data | <variant>
    """"""
    return json.dumps(py_data, default=py2json, indent=indent, sort_keys=sort_keys)"
1770,"def py2json(py_obj):
    """"""
    Converts the inputted python object to JSON format.
    
    :param      py_obj | <variant>
    """"""
    method = getattr(py_obj, '__json__', None)

    if method:
        return method()
    elif type(py_obj) == datetime.datetime:
        return py_obj.isoformat()
    elif type(py_obj) == datetime.date:
        return py_obj.isoformat()
    elif type(py_obj) == datetime.time:
        return py_obj.isoformat()
    elif type(py_obj) == set:
        return list(py_obj)
    elif type(py_obj) == decimal.Decimal:
        return str(py_obj)
    else:
        # look through custom plugins
        for encoder in _encoders:
            success, value = encoder(py_obj)
            if success:
                return value

        opts = (py_obj, type(py_obj))
        raise TypeError('Unserializable object {} of type {}'.format(*opts))"
1771,"def register(encoder=None, decoder=None):
    """"""
    Registers an encoder method and/or a decoder method for processing
    custom values.  Encoder and decoders should take a single argument
    for the value to encode or decode, and return a tuple of (<bool>
    success, <variant> value).  A successful decode or encode should
    return True and the value.
    
    :param      encoder | <callable> || None
                decoder | <callable> || None
    """"""
    if encoder:
        _encoders.append(encoder)
    if decoder:
        _decoders.append(decoder)"
1772,"def xmlresponse(py_data):
    """"""
    Generates an XML formatted method response for the given python
    data.
    
    :param      py_data | <variant>
    """"""
    xroot = ElementTree.Element('methodResponse')
    xparams = ElementTree.SubElement(xroot, 'params')
    xparam = ElementTree.SubElement(xparams, 'param')

    type_map = {'bool': 'boolean',
                'float': 'double',
                'str': 'string',
                'unicode': 'string',
                'datetime': 'dateTime.iso8601',
                'date': 'date.iso8601',
                'time': 'time.iso8601'}

    def xobj(xparent, py_obj):
        # convert a list of information
        if type(py_obj) in (tuple, list):
            xarr = ElementTree.SubElement(xparent, 'array')
            xdata = ElementTree.SubElement(xarr, 'data')
            for val in py_obj:
                xval = ElementTree.SubElement(xdata, 'value')
                xobj(xval, val)

        # convert a dictionary of information
        elif type(py_obj) == dict:
            xstruct = ElementTree.SubElement(xparent, 'struct')
            for key, val in py_obj.items():
                xmember = ElementTree.SubElement(xstruct, 'member')
                xname = ElementTree.SubElement(xmember, 'name')
                xname.text = key
                xval = ElementTree.SubElement(xmember, 'value')
                xobj(xval, val)

        # convert a None value
        elif py_obj is None:
            ElementTree.SubElement(xparent, 'nil')

        # convert a basic value
        else:
            typ = type(py_obj).__name__
            typ = type_map.get(typ, typ)
            xitem = ElementTree.SubElement(xparent, typ)

            # convert a datetime/date/time
            if isinstance(py_obj, datetime.date) or \
                    isinstance(py_obj, datetime.time) or \
                    isinstance(py_obj, datetime.datetime):

                if py_obj.tzinfo and pytz:
                    data = py_obj.astimezone(pytz.utc).replace(tzinfo=None)
                    xitem.text = data.isoformat()
                else:
                    xitem.text = py_obj.isoformat()

            # convert a boolean
            elif type(py_obj) == bool:
                xitem.text = nstr(int(py_obj))

            # convert a non-string object
            elif not type(py_obj) in (str, unicode):
                xitem.text = nstr(py_obj)

            # convert a string object
            else:
                xitem.text = py_obj

    xobj(xparam, py_data)
    projex.text.xmlindent(xroot)
    return ElementTree.tostring(xroot)"
1773,"def _read_file(fname):
    """"""
    Args:
        fname (str): Name of the grammar file to be parsed
    Return:
        list: The grammar rules
    """"""
    with open(fname) as input_file:
        re_grammar = [x.strip('\n') for x in input_file.readlines()]
    return re_grammar"
1774,"def main():
    """"""
    Function for PDA to CNF Operation
    :type argv: list
    :param argv: Parameters
    """"""
    if len(argv) < 3:
        print 'Usage for getting CFG: %s CFG_fileA CFG ' % argv[0]
        print 'Usage for getting STR: %s CFG_fileA STR ' \
              'Optimize[0 or 1] splitstring[0 or 1] ' % argv[0]
        print ''
        print 'For example: python pdacnf.py grammar.y STR 1 0'
        print '             python pdacnf.py grammar.y STR 1 1'
        print '             python pdacnf.py grammar.y CFG'
        return

    alphabet = createalphabet()

    mode = argv[2]

    optimized = 0
    splitstring = 0
    if mode == 'STR':
        optimized = int(argv[3])
        splitstring = int(argv[4])

    cfgtopda = CfgPDA(alphabet)
    print '* Parsing Grammar:',
    mma = cfgtopda.yyparse(argv[1])
    print 'OK'
    print ' - Total PDA states are ' + repr(len(mma.s))

    print '* Simplify State IDs:',
    simple_a = SimplifyStateIDs()
    mma.s, biggestid, newaccepted = simple_a.get(mma.s)
    if newaccepted:
        print 'OK'
    else:
        print 'OK'

    print '* Eliminate READ states:',
    replace = ReadReplace(mma.s, biggestid)
    mma.s = replace.replace_read()
    print 'OK'
    print ' - Total PDA states now are ' + repr(len(mma.s))
    maxstate = replace.nextstate() - 1

    print '* Reduce PDA:',
    simple_b = ReducePDA()
    mma.s = simple_b.get(mma.s)
    print 'OK'
    print ' - Total PDA states now are ' + repr(len(mma.s))

    print '* PDA to CFG transformation:',
    cnfgenerator = PdaCnf(mma.s)
    grammar = cnfgenerator.get_rules(optimized)
    print 'OK'
    print ' - Total CFG rules generated: ' + repr(len(grammar))

    if mode == 'STR':
        gen = CFGGenerator(CNFGenerator(grammar),
                           optimized=optimized,
                           splitstring=splitstring,
                           maxstate=maxstate)
        print gen.generate()
    else:
        print grammar"
1775,"def get(self, statediag, dfaaccepted):
        """"""
        # - Remove all the POP (type - 2) transitions to state 0,non DFA accepted
        # for symbol @closing
        # - Generate the accepted transitions
        - Replace DFA accepted States with a push - pop symbol and two extra states
        Args:
            statediag (list): The states of the PDA
            dfaaccepted (list):The list of DFA accepted states
        Returns:
            list: A cleaned, smaller list of DFA states
        """"""

        newstatediag = {}

        newstate = PDAState()
        newstate.id = 'AI,I'  # BECAREFUL WHEN SIMPLIFYING...
        newstate.type = 1
        newstate.sym = '@wrapping'
        transitions = {}
        transitions[(0, 0)] = [0]
        newstate.trans = transitions
        i = 0
        newstatediag[i] = newstate
        # print 'accepted:'
        # print dfaaccepted
        for stateid in statediag:
            state = statediag[stateid]
            # print state.id
            if state.type == 2:
                for state2id in dfaaccepted:
                    # print state.id[1]
                    if state.id[1] == state2id:
                        # print 'adding...'
                        state.trans['AI,I'] = ['@wrapping']
                        # print state.trans
                        break
            i = i + 1
            newstatediag[i] = state
        return newstatediag"
1776,"def bfs(self, graph, start):
        """"""
        Performs BFS operation for eliminating useless loop transitions
        Args:
            graph (PDA): the PDA object
            start (PDA state): The PDA initial state
        Returns:
            list: A cleaned, smaller list of DFA states
        """"""
        newstatediag = {}

        # maintain a queue of paths
        queue = []
        visited = []
        # push the first path into the queue
        queue.append(start)
        while queue:
            # get the first path from the queue
            state = queue.pop(0)
            # get the last node from the path
            # visited
            visited.append(state.id)
            # enumerate all adjacent nodes, construct a new path and push it
            # into the queue
            for key in state.trans:
                if state.trans[key] != []:
                    if key not in visited:
                        for nextstate in graph:
                            if graph[nextstate].id == key:
                                queue.append(graph[nextstate])
                                break
        i = 0
        for state in graph:
            if graph[state].id in visited:
                newstatediag[i] = graph[state]
                i = i + 1

        return newstatediag"
1777,"def get(self, statediag):
        """"""
        Args:
            statediag (list): The states of the PDA
        Returns:
            list: A reduced list of states using BFS
        """"""
        if len(statediag) < 1:
            print 'PDA is empty and can not be reduced'
            return statediag
        newstatediag = self.bfs(statediag, statediag[0])
        return newstatediag"
1778,"def get(self, statediag, accepted=None):
        """"""
        Replaces complex state IDs as generated from the product operation,
        into simple sequencial numbers. A dictionaty is maintained in order
        to map the existed IDs.
        Args:
            statediag (list): The states of the PDA
            accepted (list): the list of DFA accepted states
        Returns:
            list:
        """"""
        count = 0
        statesmap = {}
        newstatediag = {}
        for state in statediag:

            # Simplify state IDs
            if statediag[state].id not in statesmap:
                statesmap[statediag[state].id] = count
                mapped = count
                count = count + 1
            else:
                mapped = statesmap[statediag[state].id]

            # Simplify transitions IDs

            transitions = {}
            for nextstate in statediag[state].trans:
                if nextstate not in statesmap:
                    statesmap[nextstate] = count
                    transmapped = count
                    count = count + 1
                else:
                    transmapped = statesmap[nextstate]
                transitions[transmapped] = statediag[state].trans[nextstate]
            newstate = PDAState()
            newstate.id = mapped
            newstate.type = statediag[state].type
            newstate.sym = statediag[state].sym
            newstate.trans = transitions
            newstatediag[mapped] = newstate
        newaccepted = None
        if accepted is not None:
            newaccepted = []
            for accepted_state in accepted :
                if (0, accepted_state) in statesmap:
                    newaccepted.append(statesmap[(0, accepted_state)])
        return newstatediag, count, newaccepted"
1779,"def _generate_state(self, trans):
        """"""
        Creates a new POP state (type - 2) with the same transitions.
        The POPed symbol is the unique number of the state.
        Args:
            trans (dict): Transition dictionary
        Returns:
            Int: The state identifier
        """"""
        state = PDAState()
        state.id = self.nextstate()
        state.type = 2
        state.sym = state.id
        state.trans = trans.copy()
        self.toadd.append(state)
        return state.id"
1780,"def replace_read(self):
        """"""
        Replaces all READ (type - 3) states to a PUSH (type - 1) and a POP (type - 2).
        The actual state is replaced with the PUSH, and a new POP is created.
        """"""
        for statenum in self.statediag:
            state = self.statediag[statenum]
            if state.type == 3:  # READ state
                state.type = 1
                destination_and_symbol = self._generate_state(state.trans)
                state.sym = destination_and_symbol
                state.trans = {}
                state.trans[destination_and_symbol] = [0]
        statenumber_identifier = len(self.statediag) + 1
        for state in self.toadd:
            self.statediag[statenumber_identifier] = state
            statenumber_identifier = statenumber_identifier + 1
        return self.statediag"
1781,"def insert_self_to_empty_and_insert_all_intemediate(self, optimized):
        """"""
        For each state qi of the PDA, we add the rule Aii -> e
        For each triplet of states qi, qj and qk, we add the rule Aij -> Aik Akj.
        Args:
            optimized (bool): Enable or Disable optimization - Do not produce O(n^3)
        """"""
        for state_a in self.statediag:
            self.rules.append('A' +repr(state_a.id) +',' + repr(state_a.id) + ': @empty_set')

            # If CFG is not requested, avoid the following O(n^3) rule.
            # It can be solved and a string can be generated faster with BFS of DFS

            if optimized == 0:
                for state_b in self.statediag:
                    if state_b.id != state_a.id:
                        for state_c in self.statediag:
                            if state_c.id != state_a.id \
                                    and state_b.id != state_c.id:
                                self.rules.append('A' + repr(state_a.id)
                                                  + ',' + repr(state_c.id)
                                                  + ': A' + repr(state_a.id)
                                                  + ',' + repr(state_b.id)
                                                  + ' A' + repr(state_b.id)
                                                  + ',' + repr(state_c.id)
                                                  + '')"
1782,"def insert_symbol_pushpop(self):
        """"""
        For each stack symbol t E G, we look for a pair of states, qi and qj,
        such that the PDA in state qi can read some input a E S and push t
        on the stack and in state state qj can read some input b E S and pop t
        off the stack. In that case, we add the rule Aik -> a Alj b
        where (ql,t) E d(qi,a,e) and (qk,e) E d(qj,b,t).
        """"""

        for state_a in self.statediag:
            if state_a.type == 1:
                found = 0
                for state_b in self.statediag:
                    if state_b.type == 2 and state_b.sym == state_a.sym:
                        found = 1
                        for j in state_a.trans:
                            if state_a.trans[j] == [0]:
                                read_a = ''
                            else:
                                new = []
                                for selected_transition in state_a.trans[j]:
                                    if selected_transition == ' ':
                                        new.append('&')
                                    else:
                                        new.append(selected_transition)

                                read_a = "" | "".join(new)
                            for i in state_b.trans:
                                if state_b.trans[i] == [0]:
                                    read_b = ''
                                else:
                                    new = []
                                    for selected_transition in state_b.trans[i]:
                                        if selected_transition == ' ':
                                            new.append('&')
                                        else:
                                            new.append(selected_transition)
                                    read_b = "" | "".join(new)
                                self.rules.append(
                                    'A' + repr(state_a.id)
                                    + ',' + repr(i)
                                    + ':' + read_a
                                    + ' A' + repr(j)
                                    + ',' + repr(state_b.id)
                                    + ' ' + read_b)
                if found == 0:

                    # A special case is required for State 2, where the POPed symbols
                    # are part of the transitions array and not defined for ""sym"" variable.

                    for state_b in self.statediag:
                        if state_b.type == 2 and state_b.sym == 0:
                            for i in state_b.trans:
                                if state_a.sym in state_b.trans[i]:
                                    for j in state_a.trans:
                                        if state_a.trans[j] == [0]:
                                            read_a = ''
                                        else:
                                            read_a = "" | "".join(
                                                state_a.trans[j])
                                        self.rules.append(
                                            'A' + repr(state_a.id)
                                            + ',' + repr(i)
                                            + ':' + read_a
                                            + ' A' + repr(j)
                                            + ',' + repr(state_b.id))
                                        # print
                                        # 'A'+`state_a.id`+','+`i`+':'+read_a+'
                                        # A'+`j`+','+`state_b.id`
                                        found = 1
                if found == 0:
                    print ""ERROR: symbol "" + repr(state_a.sym) \
                          + "". It was not found anywhere in the graph."""
1783,"def get_rules(self, optimized):
        """"""
        Args:
            optimized (bool): Enable or Disable optimization - Do not produce O(n^3)
        Return:
            list: The CFG rules
        """"""
        self.insert_start_to_accepting()
        # If CFG is not requested, avoid the following O(n^3) rule.
        # It can be solved and a string can be generated faster with BFS of DFS

        if optimized == 0:
            self.insert_self_to_empty_and_insert_all_intemediate(optimized)
        self.insert_symbol_pushpop()
        return self.rules"
1784,"def provision(self, instance_id: str, service_details: ProvisionDetails, async_allowed: bool) -> ProvisionedServiceSpec:
        """"""Provision the new instance
        
        see openbrokerapi documentation
        
        Returns:
            ProvisionedServiceSpec
        """"""
        
        if service_details.plan_id == self._backend.config.UUID_PLANS_EXISTING_CLUSTER:
            # Provision the instance on an Existing Atlas Cluster
            
            # Find or create the instance
            instance = self._backend.find(instance_id)
            
            # Create the instance if needed
            return self._backend.create(instance, service_details.parameters, existing=True)
        
        # Plan not supported
        raise ErrPlanUnsupported(service_details.plan_id)"
1785,"def unbind(self, instance_id: str, binding_id: str, details: UnbindDetails):
        """"""Unbinding the instance
        
        see openbrokerapi documentation
        
        Raises:
            ErrBindingDoesNotExist: Binding does not exist.
        """"""
        
        # Find the instance
        instance = self._backend.find(instance_id)
        
        # Find the binding
        binding = self._backend.find(binding_id, instance)
        if not binding.isProvisioned():
            # The binding does not exist
            raise ErrBindingDoesNotExist()
        
        # Delete the binding
        self._backend.unbind(binding)"
1786,"def bind(self, instance_id: str, binding_id: str, details: BindDetails) -> Binding:
        """"""Binding the instance
        
        see openbrokerapi documentation
        """"""
        
        # Find the instance
        instance = self._backend.find(instance_id)
        
        # Find or create the binding
        binding = self._backend.find(binding_id, instance)
        
        # Create the binding if needed
        return self._backend.bind(binding, details.parameters)"
1787,"def deprovision(self, instance_id: str, details: DeprovisionDetails, async_allowed: bool) -> DeprovisionServiceSpec:
        """"""Deprovision an instance
        
        see openbrokerapi documentation
        
        Raises:
            ErrInstanceDoesNotExist: Instance does not exist.
        """"""
        
        # Find the instance
        instance = self._backend.find(instance_id)
        if not instance.isProvisioned():
            # the instance does not exist
            raise ErrInstanceDoesNotExist()
        
        return self._backend.delete(instance)"
1788,"def _ddns(self, ip):
        """"""
        curl -X POST https://dnsapi.cn/Record.Ddns -d 'login_token=LOGIN_TOKEN&format=json&domain_id=2317346&record_id=16894439&record_line=默认&sub_domain=www'
        :return:
        """"""

        headers = {""Accept"": ""text/json"", ""User-Agent"": ""ddns/0.1.0 (imaguowei@gmail.com)""}

        data = {
            'login_token': self.login_token,
            'format': ""json"",
            'domain_id': self.domain_id,
            'record_id': self.record_id,
            'sub_domain': self.sub_domain,
            'record_line': '默认',
            'value': ip
        }

        res = requests.post(Ddns.DNSPOD_API, data, headers=headers)
        logger.debug(res.json())
        return res.json()['status']['code'] == '1'"
1789,"def post(self, path, data={}):
        '''Perform POST Request '''
        response = requests.post(API_URL + path, data=json.dumps(data), headers=self._set_headers())
        return self._check_response(response, self.post, path, data)"
1790,"def delete(self, path, data={}):
        '''Perform DELETE Request'''
        if len(data) != 0:
            parameter_string = ''
            for k,v in data.items():
                parameter_string += '{}={}'.format(k,v)
                parameter_string += '&'
            path += '?' + parameter_string

        response = requests.delete(API_URL + path, headers=self._set_headers())
        return self._check_response(response, self.delete, path, data)"
1791,"def parsed(self):
        """"""Get the ConfigParser object which represents the content.

        This property is cached and only parses the content once.
        """"""
        if not self._parsed:

            self._parsed = ConfigParser()
            self._parsed.readfp(io.StringIO(self.content))

        return self._parsed"
1792,"def create_cache(directory, compress_level=6, value_type_is_binary=False, **kwargs):
    """"""
    Create a html cache. Html string will be automatically compressed.

    :param directory: path for the cache directory.
    :param compress_level: 0 ~ 9, 9 is slowest and smallest.
    :param kwargs: other arguments.
    :return: a `diskcache.Cache()`
    """"""
    cache = diskcache.Cache(
        directory,
        disk=CompressedDisk,
        disk_compress_level=compress_level,
        disk_value_type_is_binary=value_type_is_binary,
        **kwargs
    )
    return cache"
1793,"def timeticks(tdiff):
    """"""
    NOTE do NOT use ""interval"" or ticks are misaligned!  use ""bysecond"" only!
    """"""
    if isinstance(tdiff, xarray.DataArray):  # len==1
        tdiff = timedelta(seconds=tdiff.values / np.timedelta64(1, 's'))

    assert isinstance(tdiff, timedelta), 'expecting datetime.timedelta'

    if tdiff > timedelta(hours=2):
        return None, None

    elif tdiff > timedelta(minutes=20):
        return MinuteLocator(byminute=range(0, 60, 5)), MinuteLocator(byminute=range(0, 60, 2))

    elif (timedelta(minutes=10) < tdiff) & (tdiff <= timedelta(minutes=20)):
        return MinuteLocator(byminute=range(0, 60, 2)), MinuteLocator(byminute=range(0, 60, 1))

    elif (timedelta(minutes=5) < tdiff) & (tdiff <= timedelta(minutes=10)):
        return MinuteLocator(byminute=range(0, 60, 1)), SecondLocator(bysecond=range(0, 60, 30))

    elif (timedelta(minutes=1) < tdiff) & (tdiff <= timedelta(minutes=5)):
        return SecondLocator(bysecond=range(0, 60, 30)), SecondLocator(bysecond=range(0, 60, 10))

    elif (timedelta(seconds=30) < tdiff) & (tdiff <= timedelta(minutes=1)):
        return SecondLocator(bysecond=range(0, 60, 10)), SecondLocator(bysecond=range(0, 60, 2))

    else:
        return SecondLocator(bysecond=range(0, 60, 2)),  SecondLocator(bysecond=range(0, 60, 1))"
1794,"def cli(ctx, bubble_home, config, verbose, barverbose, profile):
    """"""Bubble: command line tool for bubbling information between services

    .oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.\n
    Making single point to point API connections:\n
    _________________>>>>>>>>>pump>>>>>>>>>>>>>_____________________\n
    (source-service)->pull->(transform)->push->(target-service)\n
    _________________>>>>>>>>>pump>>>>>>>>>>>>>_____________________\n
    bubble can:\n
    * pull data from the source client\n
    * transform the data with flexible mapping and filtering rules\n
    * rules can use (custom) rule functions\n
    * push the result to  the target client\n

    A Bubble can process a list of basic python dicts(LOD),
    which are persisted in files or a database,
    for each step and stage that produced it.

    The only requirement for the service clients is that they have a:\n
    * source sevice: pull method which provides a LOD\n
    * target sevice: push method which accepts a dict\n


    A Bubble tries hard not to forget any step that has taken place,
    the results of any completed step is stored in a file,
    in the remember directory inside the Bubble.

    Without rules and bubble will ""just"" copy.\n

    Commands marked with (experimental) might work,
    but have not fully ""behave"" tested yet.

    For help on a specific command you can use:
        bubble <cmd> --help

    Create a bubble, make the information flow and start bubbling.\n
    .oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.\n
    """"""

    # Create a bubble object and remember it as the context object.
    # From this point onwards other commands can refer to it by using the
    # @pass_bubble decorator.

    cis = ctx.invoked_subcommand
    initing = False

    if cis == 'stats':
        nagios = False
        try:
            monitor = ctx.args[ctx.args.index('--monitor') + 1]
            if monitor == 'nagios':
                nagios = True
        except (ValueError, IndexError):
            pass
        if nagios:
            verbose = 0

    BUBBLE_CLI_GLOBALS['profiling'] = profile
    if profile:
        start_profile()

    global VERBOSE
    VERBOSE = verbose

    global VERBOSE_BAR
    VERBOSE_BAR = barverbose

    if bubble_home != '.':
        bubble_home_abs = os.path.abspath(bubble_home)
    else:
        bubble_home_abs = os.path.abspath(os.getcwd())

    if cis == 'init':
        initing = True
    if initing:
        if not os.path.exists(bubble_home_abs):
            os.makedirs(bubble_home_abs)

    if os.path.exists(bubble_home_abs):
        os.chdir(bubble_home_abs)
        ctx.obj = BubbleCli(home=bubble_home_abs,
                            verbose=verbose,
                            verbose_bar=barverbose)
    else:
        click.echo('Bubble home path does not exist: ' + bubble_home_abs)
        raise click.Abort()

    BUBBLE_CLI_GLOBALS['full_command'] = ' '.join(sys.argv)

    for key, value in config:
        ctx.obj.set_config(key, value)
    if not ctx.obj.bubble and not initing:
        ctx.obj.say_yellow('There is no bubble in %s' %
                           bubble_home_abs, verbosity=10)
        ctx.obj.say('You can start one with: bubble init', verbosity=10)"
1795,"def consume(self, msg):
        """"""Called with each incoming fedmsg.

        From here we trigger an rpm-ostree compose by touching a specific file
        under the `touch_dir`. Then our `doRead` method is called with the
        output of the rpm-ostree-toolbox treecompose, which we monitor to
        determine when it has completed.
        """"""
        self.log.info(msg)
        body = msg['body']
        topic = body['topic']
        repo = None

        if 'rawhide' in topic:
            arch = body['msg']['arch']
            self.log.info('New rawhide %s compose ready', arch)
            repo = 'rawhide'
        elif 'branched' in topic:
            arch = body['msg']['arch']
            branch = body['msg']['branch']
            self.log.info('New %s %s branched compose ready', branch, arch)
            log = body['msg']['log']
            if log != 'done':
                self.log.warn('Compose not done?')
                return
            repo = branch
        elif 'updates.fedora' in topic:
            self.log.info('New Fedora %(release)s %(repo)s compose ready',
                          body['msg'])
            repo = 'f%(release)s-%(repo)s' % body['msg']
        else:
            self.log.warn('Unknown topic: %s', topic)

        release = self.releases[repo]
        reactor.callInThread(self.compose, release)"
1796,"def parse_addr(text):
    ""Parse a 1- to 3-part address spec.""
    if text:
        parts = text.split(':')
        length = len(parts)
        if length== 3:
            return parts[0], parts[1], int(parts[2])
        elif length == 2:
            return None, parts[0], int(parts[1])
        elif length == 1:
            return None, '', int(parts[0])
    return None, None, None"
1797,"def start(self):
        ""Start the service""
        # register signals
        gevent.signal(signal.SIGINT, self._shutdown)

        # spawn the flush trigger
        def _flush_impl():
            while 1:
                gevent.sleep(self._stats.interval)

                # rotate stats
                stats = self._stats
                self._reset_stats()

                # send the stats to the sink which in turn broadcasts
                # the stats packet to one or more hosts.
                try:
                    self._sink.send(stats)
                except Exception, ex:
                    trace = traceback.format_tb(sys.exc_info()[-1])
                    self.error(''.join(trace))

        self._flush_task = gevent.spawn(_flush_impl)

        # start accepting connections
        self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
            socket.IPPROTO_UDP)
        self._sock.bind(self._bindaddr)
        while 1:
            try:
                data, _ = self._sock.recvfrom(MAX_PACKET)
                for p in data.split('\n'):
                    if p:
                        self._process(p)
            except Exception, ex:
                self.error(str(ex))"
1798,"def _process(self, data):
        ""Process a single packet and update the internal tables.""
        parts = data.split(':')
        if self._debug:
            self.error('packet: %r' % data)
        if not parts:
            return

        # interpret the packet and update stats
        stats = self._stats
        key = parts[0].translate(KEY_TABLE, KEY_DELETIONS)
        if self._key_prefix:
            key = '.'.join([self._key_prefix, key])
        for part in parts[1:]:
            srate = 1.0
            fields = part.split('|')
            length = len(fields)
            if length < 2:
                continue
            value = fields[0]
            stype = fields[1].strip()

            with stats_lock:
                # timer (milliseconds)
                if stype == 'ms':
                    stats.timers[key].append(float(value if value else 0))

                # counter with optional sample rate
                elif stype == 'c':
                    if length == 3 and fields[2].startswith('@'):
                        srate = float(fields[2][1:])
                    value = float(value if value else 1) * (1 / srate)
                    stats.counts[key] += value
                elif stype == 'g':
                    value = float(value if value else 1)
                    stats.gauges[key] = value"
1799,"def step_note_that(context, remark):
    """"""
    Used as generic step that provides an additional remark/hint
    and enhance the readability/understanding without performing any check.

    .. code-block:: gherkin

        Given that today is ""April 1st""
          But note that ""April 1st is Fools day (and beware)""
    """"""
    log = getattr(context, ""log"", None)
    if log:
        log.info(u""NOTE: %s;"" % remark)"
1800,"def section(self, resources):
        """""" Which section is this in, if any """"""

        section = [p for p in self.parents(resources) if p.rtype == 'section']
        if section:
            return section[0]
        return None"
1801,"def in_navitem(self, resources, nav_href):
        """""" Given  href of nav item, determine if resource is in it """"""

        # The navhref might end with '/index' so remove it if so
        if nav_href.endswith('/index'):
            nav_href = nav_href[:-6]

        return self.docname.startswith(nav_href)"
1802,"def is_published(self):
        """""" Return true if this resource has published date in the past """"""

        now = datetime.now()
        published = self.props.published
        if published:
            return published < now
        return False"
1803,"def request(self, method, path, query=None, content=None):
        """"""
        Sends an HTTP request.

        This constructs a full URL, encodes and decodes HTTP bodies, and
        handles invalid responses in a pythonic way.

        @type method: string
        @param method: HTTP method to use
        @type path: string
        @param path: HTTP URL path
        @type query: list of two-tuples
        @param query: query arguments to pass to urllib.urlencode
        @type content: str or None
        @param content: HTTP body content

        @rtype: object
        @return: JSON-Decoded response

        @raises GanetiApiError: If an invalid response is returned
        """"""

        kwargs = {
            ""headers"": headers,
            ""timeout"": self.timeout,
            ""verify"": False,
        }

        if self.username and self.password:
            kwargs[""auth""] = self.username, self.password

        if content is not None:
            kwargs[""data""] = self._json_encoder.encode(content)

        if query:
            prepare_query(query)
            kwargs[""params""] = query

        url = self._base_url + path

        # print ""Sending request to %s %s"" % (url, kwargs)

        try:
            r = requests.request(method, url, **kwargs)
        except requests.ConnectionError:
            raise GanetiApiError(""Couldn't connect to %s"" % self._base_url)
        except requests.Timeout:
            raise GanetiApiError(""Timed out connecting to %s"" %
                                 self._base_url)

        if r.status_code != requests.codes.ok:
            raise NotOkayError(str(r.status_code), code=r.status_code)

        if r.content:
            return json.loads(r.content)
        else:
            return None"
1804,"def start(self):
        """"""
        Confirm that we may access the target cluster.
        """"""

        version = self.request(""get"", ""/version"")

        if version != 2:
            raise GanetiApiError(""Can't work with Ganeti RAPI version %d"" %
                                 version)

        logging.info(""Accessing Ganeti RAPI, version %d"" % version)
        self.version = version

        try:
            features = self.request(""get"", ""/2/features"")
        except NotOkayError, noe:
            if noe.code == 404:
                # Okay, let's calm down, this is totally reasonable. Certain
                # older Ganeti RAPIs don't have a list of features.
                features = []
            else:
                # No, wait, panic was the correct thing to do.
                raise

        logging.info(""RAPI features: %r"" % (features,))
        self.features = features"
1805,"def _create_driver(self, **kwargs):
        """"""
        Create webdriver, assign it to ``self.driver``, and run webdriver
        initiation process, which is usually used for manual login.
        """"""
        if self.driver is None:
            self.driver = self.create_driver(**kwargs)
            self.init_driver_func(self.driver)"
1806,"def get_html(self,
                 url,
                 params=None,
                 cache_cb=None,
                 **kwargs):
        """"""
        Get html of an url.
        """"""
        url = add_params(url, params)
        cache_consumed, value = self.try_read_cache(url)
        if cache_consumed:
            html = value
        else:
            self._create_driver()
            self.driver.get(url)
            html = self.driver.page_source

        if self.should_we_update_cache(html, cache_cb, cache_consumed):
            self.cache.set(
                url, html,
                expire=kwargs.get(""cache_expire"", self.cache_expire),
            )
        return html"
1807,"def deserialize_time(data):
    """"""Return a time instance based on the values of the data param""""""
    parsed = parser.parse(data)
    return parsed.time().replace(tzinfo=parsed.tzinfo)"
1808,"def freeze():
    '''
    Show arguments to require() to recreate what has been installed
    '''
    installations = {}
    for dist in get_installed_distributions():
        req = pip.FrozenRequirement.from_dist(dist, [], find_tags=False)
        installations[req.name] = req

    return [str(installation).rstrip() for installation in
        sorted(installations.values(), key=lambda x: x.name.lower())]"
1809,"def require(*args, **kwargs):
    '''
    Install a set of packages using pip
    
    This is designed to be an interface for IPython notebooks that
    replicates the requirements.txt pip format. This lets notebooks
    specify which versions of packages they need inside the notebook
    itself.

    This function is the general-purpose interface that lets
    the caller specify any version string for any package.

    '''
    # If called with no arguments, returns requirements list
    if not args and not kwargs:
        return freeze()

    # Construct array of requirements
    requirements = list(args)
    extra = ['{}{}'.format(kw, kwargs[kw]) for kw in kwargs]
    requirements.extend(extra)
    args = ['install', '-q']
    args.extend(requirements)
    pip.main(args)"
1810,"def handle(self, *args, **options):
        """"""
        Compares current database with a migrations.
        
        Creates a temporary database, applies all the migrations to it, and
        then dumps the schema from both current and temporary, diffs them,
        then report the diffs to the user.
        """"""
        self.db = options.get(""database"", DEFAULT_DB_ALIAS)
        self.current_name = connections[self.db].settings_dict[""NAME""]
        self.compare_name = options.get(""db_name"")
        self.lines = options.get(""lines"")
        self.ignore = int(options.get('ignore'))

        if not self.compare_name:
            self.compare_name = ""%s_compare"" % self.current_name
        
        command = NASHVEGAS.get(""dumpdb"", ""pg_dump -s {dbname}"")
        
        print ""Getting schema for current database...""
        current_sql = Popen(
            command.format(dbname=self.current_name),
            shell=True,
            stdout=PIPE
        ).stdout.readlines()
        
        print ""Getting schema for fresh database...""
        self.setup_database()
        connections[self.db].close()
        connections[self.db].settings_dict[""NAME""] = self.compare_name
        try:
            call_command(""syncdb"", interactive=False, verbosity=0, migrations=False)
            new_sql = Popen(
                command.format(dbname=self.compare_name).split(),
                stdout=PIPE
            ).stdout.readlines()
        finally:
            connections[self.db].close()
            connections[self.db].settings_dict[""NAME""] = self.current_name
            self.teardown_database()
        
        print ""Outputing diff between the two...""
        print """".join(difflib.unified_diff(normalize_sql(current_sql, self.ignore),
                                           normalize_sql(new_sql, self.ignore),
                                           n=int(self.lines)))"
1811,"def render_widgets(kb_app: kb,
                   sphinx_app: Sphinx,
                   doctree: doctree,
                   fromdocname: str,
                   ):
    """""" Go through docs and replace widget directive with rendering """"""

    builder: StandaloneHTMLBuilder = sphinx_app.builder

    for node in doctree.traverse(widget):
        # Render the output
        w = sphinx_app.env.widgets.get(node.name)
        context = builder.globalcontext.copy()

        # Add in certain globals
        context['resources'] = sphinx_app.env.resources
        context['references'] = sphinx_app.env.references
        output = w.render(sphinx_app, context)

        # Put the output into the node contents
        listing = [nodes.raw('', output, format='html')]
        node.replace_self(listing)"
1812,"def attr_string(filterKeys=(), filterValues=(), **kwargs):
    """"""Build a string consisting of 'key=value' substrings for each keyword
    argument in :kwargs:

    @param filterKeys: list of key names to ignore
    @param filterValues: list of values to ignore (e.g. None will ignore all
                         key=value pairs that has that value.
    """"""
    return ', '.join([str(k)+'='+repr(v) for k, v in kwargs.items()
                      if k not in filterKeys and v not in filterValues])"
1813,"def auth_string(self):
        """"""
        Get the auth string. If the token is expired and auto refresh enabled,
        a new token will be fetched

        :return: the auth string
        :rtype: str
        """"""
        if not self._token:
            self.execute()

        if not self._token.expired:
            return 'Bearer {}'.format(self._token.access_token)

        if self.auto_refresh:
            self.execute()
            return 'Bearer {}'.format(self._token.access_token)

        raise TokenExpired()"
1814,"async def main():
    """"""Get the data from a *hole instance.""""""
    async with aiohttp.ClientSession() as session:
        data = Hole('192.168.0.215', loop, session)
        await data.get_data()

        # Get the raw data
        print(json.dumps(data.data, indent=4, sort_keys=True))

        print(""Status:"", data.status)
        print(""Domains being blocked:"", data.domains_being_blocked)"
1815,"async def enable():
    """"""Get the data from a *hole instance.""""""
    async with aiohttp.ClientSession() as session:
        data = Hole('192.168.0.215', loop, session, api_token=API_TOKEN)
        await data.enable()"
1816,"def admin_penalty(self, column=None, value=None, **kwargs):
        """"""
        An enforcement action that results in levying the permit holder with a
        penalty or fine. It is used to track judicial hearing dates, penalty
        amounts, and type of administrative penalty order.

        >>> PCS().admin_penalty('enfor_action_date', '16-MAR-01')
        """"""
        return self._resolve_call('PCS_ADMIN_PENALTY_ORDER', column,
                                  value, **kwargs)"
1817,"def audit(self, column=None, value=None, **kwargs):
        """"""
        Pretreatment Compliance Inspections (PCI) or Pretreatment Audits
        collect information resulting from inspections pertaining to a Publicly
        Owned Treatment Works (POTWs) that receive pollutants from in direct
        dischargers.

        >>> PCS().audit('insp_date', '16-MAR-01')
        """"""
        return self._resolve_call('PCS_PCI_AUDIT', column, value, **kwargs)"
1818,"def code_description(self, column=None, value=None, **kwargs):
        """"""
        The Permit Compliance System (PCS) records milestones, events, and many
        other parameters in code format. To provide text descriptions that
        explain the code meanings, the PCS_CODE_DESC provide s complete
        information on all types of codes, and for each type, the text
        description of each possible code value.

        >>> PCS().code_description('code', 110)
        """"""
        return self._resolve_call('PCS_CODE_DESC', column, value, **kwargs)"
1819,"def compliance_schedule(self, column=None, value=None, **kwargs):
        """"""
        A sequence of activities with associated milestones which pertains to a
        given permit.

        >>> PCS().compliance_schedule('cmpl_schd_evt', '62099')
        """"""
        return self._resolve_call('PCS_CMPL_SCHD', column, value, **kwargs)"
1820,"def compliance_violation(self, column=None, value=None, **kwargs):
        """"""
        A compliance schedule violation reflects the non-achievement of a
        given compliance schedule event including the type of violation and ty
        pe of resolution.

        >>> PCS().compliance_violation('cs_rnc_detect_date', '16-MAR-04')
        """"""
        return self._resolve_call('PCS_CMPL_SCHD_VIOL', column, value, **kwargs)"
1821,"def dmr_measurement(self, column=None, value=None, **kwargs):
        """"""
        Measurements of effluents reported on the Discharge Monitoring Report
        (DMR). The violations are detected by comparing the measurement values
        against the corresponding effluent limit.

        >>> PCS().dmr_measurement('season_num', 2)
        """"""
        return self._resolve_call('PCS_DMR_MEASUREMENT', column, value, **kwargs)"
1822,"def enforcement_action(self, column=None, value=None, **kwargs):
        """"""
         A disciplinary action taken against a permit facility. The action may
         be applicable to one or more violations.

         >>> PCS().enforcement_action('ea_code', '09')
        """"""
        return self._resolve_call('PCS_ENFOR_ACTION', column, value, **kwargs)"
1823,"def hearing(self, column=None, value=None, **kwargs):
        """"""
        An evidentiary hearing.

        >>> PCS().hearing('event_date', '23-MAY-01')
        """"""
        return self._resolve_call('PCS_EVIDENTIARY_HEARING_EVENT', column,
                                  value, **kwargs)"
1824,"def industrial_user(self, column=None, value=None, **kwargs):
        """"""
        Information from the PCI_AUDIT table pertaining to industrial users,
        i.e. the number of significant industrial users.

        >>> PCS().industrial_user('insp_date', '16-MAR-01')
        """"""
        return self._resolve_call('PCS_INDUSTRIAL_USER_INFO', column,
                                  value, **kwargs)"
1825,"def inspection(self, column=None, value=None, **kwargs):
        """"""
        An official visit to the permit facility on a periodic basis which
        consists of the following inspection types: NPDES, Biomonitoring,
        Pretreatment, and Industrial User.

        >>> PCS().inspection('insp_date', '16-MAR-01')
        """"""
        return self._resolve_call('PCS_INSPECTION', column, value, **kwargs)"
1826,"def permit_event(self, column=None, value=None, **kwargs):
        """"""
        A permit event tracks the lifecycle of a permit from issuance to
        expiration. Examples include 'Application Received' and 'Permit
        Issued', etc.

        >>> PCS().permit_event('event_actual_date', '16-MAR-04')
        """"""
        return self._resolve_call('PCS_PERMIT_EVENT', column, value, **kwargs)"
1827,"def pipe_schedule(self, column=None, value=None, **kwargs):
        """"""
        Particular discharge points at a permit facility that are governed by
        effluent limitations and monitoring and submission requirements.

        >>> PCS().pipe_schedule('state_submission_units', 'M')
        """"""
        return self._resolve_call('PCS_PIPE_SCHED', column, value, **kwargs)"
1828,"def single_violation(self, column=None, value=None, **kwargs):
        """"""
        A single event violation is a one-time event that occurred on a fixed
        date, and is associated with one permitted facility.

        >>> PCS().single_violation('single_event_viol_date', '16-MAR-01')
        """"""
        return self._resolve_call('PCS_SINGLE_EVENT_VIOL', column,
                                  value, **kwargs)"
1829,"def sludge(self, column=None, value=None, **kwargs):
        """"""
        Sludge information describes the volumn of sludge produced at a
        facility, identification information on a sludge handler, and
        classification/permitting information on a facility that handles
        sludge, such as a pretreatment POTW.

        >>> PCS().sludge('county_name', 'San Francisco')
        """"""
        return self._resolve_call('PCS_SLUDGE', column, value, **kwargs)"
1830,"def typify(value: Union[dict, list, set, str]):
    """""" Enhance block operation with native types.

    Typify takes a blockchain operation or dict/list/value,
    and then it parses and converts string types into native data types where appropriate.
    """"""
    if type(value) == dict:
        return walk_values(typify, value)

    if type(value) in [list, set]:
        return list(map(typify, value))

    if type(value) == str:
        if re.match('^\d+\.\d+ (STEEM|SBD|VESTS)$', value):
            return keep_in_dict(dict(Amount(value)), ['amount', 'asset'])

        if re.match('^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$', value):
            return parse_time(value)

    return value"
1831,"def json_expand(json_op):
    """""" For custom_json ops. """"""
    if type(json_op) == dict and 'json' in json_op:
        return update_in(json_op, ['json'], safe_json_loads)

    return json_op"
1832,"def delete(self, subnet_id):
        """"""
        This is bad delete function
        because one vpc can have more than one subnet.
        It is Ok if user only use CAL for manage cloud resource
        We will update ASAP.
        """"""
        # 1 : show subnet
        subnet = self.client.describe_subnets(
            SubnetIds=[subnet_id]).get('Subnets')[0]
        vpc_id = subnet.get('VpcId')
        # 2 : delete subnet
        self.client.delete_subnet(SubnetId=subnet_id)
        # 3 : delete vpc
        return self.client.delete_vpc(VpcId=vpc_id)"
1833,"def generate(self):
        """"""
        Generates a new random string from the start symbol
        Args:
            None
        Returns:
            str: The generated string
        """"""

        result = self._gen(self.optimized, self.splitstring)
        if self.splitstring and result is not None:
            result = result[1:]
        return result"
1834,"def _clean_terminals(self):
        """"""
        Because of the optimization, there are some non existing terminals
        on the generated list. Remove them by checking for terms in form Ax,x
        """"""
        new_terminals = []
        for term in self.grammar.grammar_terminals:
            x_term = term.rfind('@')
            y_term = term.rfind('A')
            if y_term > x_term:
                x_term = y_term
            ids = term[x_term + 1:].split(',')
            if len(ids) < 2:
                """"""It'input_string a normal terminal, not a state""""""
                new_terminals.append(term)
        self.grammar.grammar_terminals = new_terminals"
1835,"def _check_self_to_empty(self, stateid):
        """"""
        Because of the optimization, the rule for empty states is missing
        A check takes place live
        Args:
            stateid (int): The state identifier
        Returns:
            bool: A true or false response
        """"""
        x_term = stateid.rfind('@')
        y_term = stateid.rfind('A')
        if y_term > x_term:
            x_term = y_term
        ids = stateid[x_term + 1:].split(',')
        if len(ids) < 2:
            return 0
        if ids[0] == ids[1]:
            #    print 'empty'
            return 1
        return 0"
1836,"def _check_intemediate(self, myntr, maxstate):
        """"""
        For each state Apq which is a known terminal, this function
        searches for rules Apr -> Apq Aqr and Arq -> Arp Apq where
        Aqr is also a known terminal or Arp is also a known terminal.
        It is mainly used as an optimization in order to avoid the O(n^3)
        for generating all the Apq -> Apr Arq rules during the PDA to CFG
        procedure.
        Args:
            myntr (str): The examined non terminal that was poped out
                        of the queue
            maxstate (int): The maxstate is used for generating in a
                            dynamic way the CNF rules that were not
                            included due to the optimization. As a
                            result, the algorithm generates these
                            rules only if required.
        Returns:
            bool: Returns true if the algorithm was applied
                at least one time
        """"""
        # print 'BFS Dictionary Update - Intermediate'
        x_term = myntr.rfind('@')
        y_term = myntr.rfind('A')
        if y_term > x_term:
            x_term = y_term
        ids = myntr[x_term + 1:].split(',')
        if len(ids) < 2:
            return 0
        i = ids[0]
        j = ids[1]
        r = 0
        find = 0
        while r < maxstate:
            if r != i and r != j:
                if 'A' + i + ',' + \
                        repr(r) not in self.resolved \
                        and 'A' + j + ',' + repr(r) in self.resolved:
                    self.resolved[
                        'A' + i + ',' + repr(r)] = self.resolved[myntr] \
                                                   + self.resolved['A' + j + ',' + repr(r)]
                    if self._checkfinal('A' + i + ',' + repr(r)):
                        return self.resolved['A' + i + ',' + repr(r)]
                    if 'A' + i + ',' + repr(r) not in self.bfs_queue:
                        self.bfs_queue.append('A' + i + ',' + repr(r))
                    find = 1
                if 'A' + repr(r) + ',' + j not in self.resolved and 'A' + \
                        repr(r) + ',' + i in self.resolved:
                    self.resolved[
                        'A' + repr(r) + ',' + j] = self.resolved['A' + repr(r) + ',' + i] \
                                                   + self.resolved[myntr]
                    if self._checkfinal('A' + repr(r) + ',' + j):
                        return self.resolved['A' + repr(r) + ',' + j]
                    if 'A' + repr(r) + ',' + j not in self.bfs_queue:
                        self.bfs_queue.append('A' + repr(r) + ',' + j)
                    find = 1
            r = r + 1
        if find == 1:
            return 1
        return 0"
1837,"def _check_self_replicate(self, myntr):
        """"""
        For each Rule B -> c where c is a known terminal, this function
        searches for B occurences in rules with the form A -> B and sets
        A -> c.
        """"""
        # print 'BFS Dictionary Update - Self Replicate'
        find = 0
        for nonterm in self.grammar.grammar_nonterminals_map:
            for i in self.grammar.grammar_nonterminals_map[nonterm]:
                if self.grammar.grammar_rules[i][0] not in self.resolved and not isinstance(
                        self.grammar.grammar_rules[i][1], (set, tuple)) \
                        and self.grammar.grammar_rules[i][1] == myntr:
                    self.resolved[self.grammar.grammar_rules[i][0]] = self.resolved[myntr]
                    if self._checkfinal(self.grammar.grammar_rules[i][0]):
                        return self.resolved[self.grammar.grammar_rules[i][0]]
                    if self.grammar.grammar_rules[i][0] not in self.bfs_queue:
                        self.bfs_queue.append(self.grammar.grammar_rules[i][0])
                    find = 1
        if find == 1:
            return 1
        return 0"
1838,"def _check_self_nonterminals(self, optimized):
        """"""
        For each Rule A -> BC where B and C are known terminals (B -> c1 and C -> c2),
        this function searches replaces A to the corresponding terminals A -> c1c2
        """"""
        # print 'BFS Dictionary Update - Self Non Terminals'
        find = 0
        for nt in self.grammar.grammar_nonterminals_map:
            for i in self.grammar.grammar_nonterminals_map[nt]:
                if (self.grammar.grammar_rules[i][0] not in self.resolved\
                    or self.grammar.grammar_rules[i][0] == 'S') \
                    and isinstance(self.grammar.grammar_rules[i][1], (set, tuple)):
                    # All rules are in CNF form, so first check the A -> BC rules
                    part_a = None
                    if optimized and self._check_self_to_empty(
                            self.grammar.grammar_rules[i][1][0]):
                        part_a = ''
                    elif self.grammar.grammar_rules[i][1][0] in self.resolved:
                        part_a = self.resolved[self.grammar.grammar_rules[i][1][0]]
                    part_b = None
                    if optimized and self._check_self_to_empty(
                            self.grammar.grammar_rules[i][1][1]):
                        part_b = ''
                    elif self.grammar.grammar_rules[i][1][1] in self.resolved:
                        part_b = self.resolved[self.grammar.grammar_rules[i][1][1]]
                    if part_a is not None and part_b is not None:
                        self.resolved[self.grammar.grammar_rules[i][0]] = part_a + part_b
                        # print 'Non Terminals Resolving
                        # '+self.g.Rules[i][0]+"": ""+
                        # self.Resolved[self.g.Rules[i][0]]
                        if self._checkfinal(self.grammar.grammar_rules[i][0]):
                            return self.resolved[self.grammar.grammar_rules[i][0]]
                        if self.grammar.grammar_rules[i][0] not in self.bfs_queue:
                            self.bfs_queue.append(self.grammar.grammar_rules[i][0])
                        find = 1

        if find == 1:
            return 1
        return 0"
1839,"def _gen(self, optimized, splitstring):
        """"""Generates a new random object generated from the nonterminal
        Args:
            optimized (bool): mode of operation - if enabled not all
                            CNF rules are included (mitigate O(n^3))
            splitstring (bool): A boolean for enabling or disabling
        Returns:
            str: The generated string
        """"""
        # Define Dictionary that holds resolved rules
        # (only in form A -> terminals sequence)
        self.resolved = {}
        # First update Resolved dictionary by adding rules
        # that contain only terminals (resolved rules)
        for nt in self.grammar.grammar_nonterminals_map:
            for i in self.grammar.grammar_nonterminals_map[nt]:
                if self.grammar.grammar_rules[i][0] not in self.resolved\
                        and not isinstance(self.grammar.grammar_rules[i][1], (set, tuple)):
                    if self.grammar.grammar_rules[i][1] != '@empty_set' \
                            and self.grammar.grammar_rules[i][1] in self.grammar.grammar_terminals:

                        if splitstring:
                            self.resolved[
                                self.grammar.grammar_rules[i][0]] = self.grammar.grammar_rules[i][1]
                        else:
                            if self.grammar.grammar_rules[i][1] == '&':
                                self.resolved[self.grammar.grammar_rules[i][0]] = ' '
                            else:
                                self.resolved[
                                    self.grammar.grammar_rules[i][0]] = self.grammar.grammar_rules[i][1]
                        # print 'ResolvingA '+self.g.Rules[i][0]+"": ""+
                        # self.g.Rules[i][1]
                        if self._checkfinal(self.grammar.grammar_rules[i][0]):
                            return self.resolved[self.grammar.grammar_rules[i][0]]
                        if self.grammar.grammar_rules[i][0] not in self.bfs_queue:
                            self.bfs_queue.append(self.grammar.grammar_rules[i][0])
                    if self.grammar.grammar_rules[i][1] == '@empty_set':
                        self.resolved[self.grammar.grammar_rules[i][0]] = ''
                        # print 'ResolvingB '+self.g.Rules[i][0]+"": ""
                        self.bfs_queue.append(self.grammar.grammar_rules[i][0])
                    if optimized and self._check_self_to_empty(
                            self.grammar.grammar_rules[i][1]):
                        self.resolved[self.grammar.grammar_rules[i][0]] = ''
                        # print 'ResolvingC '+self.g.Rules[i][0]+"": ""
                        if self.grammar.grammar_rules[i][0] not in self.bfs_queue:
                            self.bfs_queue.append(self.grammar.grammar_rules[i][0])

        # Then try to use the rules from Resolved dictionary and check
        # if there is another rule that can be resolved.
        # This should be done in a while loop
        change = 1
        while change:
            change = 0
            if not change:
                ret = self._check_self_nonterminals(optimized)
                if ret == 1:
                    change = 1
                elif ret != 0:
                    return ret
            if not change:
                while not change and len(self.bfs_queue) > 0:
                    myntr = self.bfs_queue.pop()
                    ret = self._check_self_replicate(myntr)
                    if ret == 1:
                        change = 1
                    elif ret != 0:
                        return ret
                    if optimized and self._check_intemediate(
                            myntr, self.maxstate):
                        change = 1
                        break"
1840,"def project_workspace_addsitedir(sitedir):
    """"""
    Similar to site.addsitedir() but prefers new sitedir over existing ones.
    Therefore, prefers local packages over installed packages.

    .. note::
        This allows to support *.pth files and zip-/egg-imports
        similar to an installed site-packages directory.
    """"""
    assert os.path.isdir(sitedir)
    try:
        from site import addsitedir
    except ImportError:
        # -- USE: Python2.7 site.py package
        from pysite import addsitedir
    next_package_pos = len(sys.path)
    addsitedir(sitedir)

    # -- POST-PROCESS: Move new packages from end to begin of sys.path list.
    pos = 0
    new_packages = sys.path[next_package_pos:]
    del sys.path[next_package_pos:]
    sys.path[pos:pos] = new_packages"
1841,"def create(self, name, description=None, units=None,
               agg_method=""priority_fill"", overwrite=False):
        """""" Create, or get if exists, a Symbol.
        
        Parameters
        ----------
        name : str
            A symbol's name is a primary key, used across
            the Trump ORM.
        description : str, optional
            An arbitrary string, used to store user information
            related to the symbol.
        units : str, optional
            This is a string used to denote the units of the final
            data Series.
        agg_method : str, optional
            The aggregation method, used to calculate
            the final feed.  Defaults to priority_fill.
        overwrite : bool, optional
            Set to True, to force deletion an existing symbol.
            defaults to False.
            
        Returns
        -------
        Symbol
        """"""
        sym = self.try_to_get(name)

        if sym is not None:
            if overwrite:
                print ""Deleting {}"".format(sym.name)
                self.ses.delete(sym)
                self.ses.commit()
            else:
                msg = 'Symbol {} already exists.\n' + \
                      'Consider setting overwrite to True.'
                msg = msg.format(name)
                raise Exception(msg)

        sym = Symbol(name, description, units, agg_method)
        
        self.ses.add(sym)

        print ""Creating {}"".format(sym.name)
        sym.add_alias(name)

        sym.handle = SymbolHandle(sym=sym)
        self.ses.commit()

        return sym"
1842,"def delete(self, symbol):
        """"""
        Deletes a Symbol.
        
        Parameters
        ----------
        symbol : str or Symbol
        """"""
        if isinstance(symbol, (str, unicode)):
            sym = self.get(symbol)
        elif isinstance(symbol, Symbol):
            sym = symbol
        else:
            raise Exception(""Invalid symbol {}"".format((repr(symbol))))

        # Has to handle the case where the table would exist already
        # and where it wouldn't.
        try:
            sym.datatable = Table(sym.name, Base.metadata, autoload=True)
            sym.datatable.drop(self.eng, checkfirst=True)
        except NoSuchTableError:
            print ""No worries, {} never existed to begin with."".format(sym.name)

        self.ses.delete(sym)
        self.ses.commit()"
1843,"def exists(self, symbol):
        """"""Checks to if a symbol exists, by name.
        
        Parameters
        ----------
        symbol : str or Symbol

        Returns
        -------
        bool
        """"""

        if isinstance(symbol, str):
            sym = symbol
        elif isinstance(symbol, Symbol):
            sym = symbol.name

        syms = self.ses.query(Symbol).filter(Symbol.name == sym).all()
        if len(syms) == 0:
            return False
        else:
            return True"
1844,"def get(self, symbol):
        """""" Gets a Symbol based on name, which is expected to exist. 
        
        Parameters
        ----------
        symbol : str or Symbol
        
        Returns
        -------
        Symbol
        
        Raises
        ------
        Exception
            If it does not exist. Use .try_to_get(), 
            if the symbol may or may not exist.
        """"""
        syms = self.try_to_get(symbol)
        if syms is None:
            raise Exception(""Symbol {} does not exist"".format(symbol))
        else:
            return syms"
1845,"def try_to_get(self, symbol):
        """""" Gets a Symbol based on name, which may or may not exist.
        
        Parameters
        ----------
        symbol : str
        
        Returns
        -------
        Symbol or None.  
        
        Note
        ----
        Use .get(), if the symbol should exist, and an exception 
        is needed if it doesn't.

        """"""
        syms = self.ses.query(Symbol).filter(Symbol.name == symbol).all()
        if len(syms) == 0:
            return None
        else:
            return syms[0]"
1846,"def search_meta(self, attr, value=None, stronly=False):
        """""" Get a list of Symbols by searching a specific meta
        attribute, and optionally the value.  

        Parameters
        ----------
        attr : str
            The meta attribute to query.
        value : None, str or list
            The meta attribute to query.  If you pass a float, or an int,
            it'll be converted to a string, prior to searching.
        stronly : bool, optional, default True
            Return only a list of symbol names, as opposed
            to the (entire) Symbol objects.
        
        Returns
        -------
        List of Symbols or empty list
        
        """"""        
        if stronly:
            qry = self.ses.query(Symbol.name).join(SymbolMeta)
        else:
            qry = self.ses.query(Symbol).join(SymbolMeta)
            
        crits = []
        
        if value is None:
            crits.append(SymbolMeta.attr == attr) 
        else:
            if isinstance(value, str):
                values = [value]
            elif isinstance(value, (tuple, list)):
                values = value
            
            for v in values:
                crits.append(and_(SymbolMeta.attr == attr, SymbolMeta.value.like(value))) 

        if len(crits):
            qry = qry.filter(or_(*crits))
        
        qry = qry.order_by(Symbol.name)

        if stronly:
            return [sym[0] for sym in qry.distinct()]
        else:
            return [sym for sym in qry.distinct()]"
1847,"def search(self, usrqry=None, name=False, desc=False, tags=False, meta=False, stronly=False, dolikelogic=True):
        """""" Get a list of Symbols by searching a combination of 
        a Symbol's name, description, tags or meta values.

        Parameters
        ----------
        usrqry : str
            The string used to query.  Appending '%' will use SQL's ""LIKE""
            functionality.
        name : bool, optional, default False
            Search by symbol name.
        desc : bool, optional, default False
            Search by symbol descriptions.
        tags : bool, optional, default False
            Search by symbol tags.
        meta : bool, optional, default False
            Search within a symbol's meta attribute's value.
        stronly : bool, optional, default True
            Return only a list of symbol names, as opposed
            to the (entire) Symbol objects.
        dolikelogic : 
            Append '%' to either side of the string, if the string
            doesn't already have % specified.
        
        Returns
        -------
        List of Symbols or empty list
        
        """"""
        if stronly:
            qry = self.ses.query(Symbol.name)
        else:
            qry = self.ses.query(Symbol)

        if tags:
            qry = qry.join(SymbolTag)
        if meta:
            qry = qry.join(SymbolMeta)
        
        if dolikelogic:
            if usrqry is not None:
                if '%' not in usrqry:
                    usrqry = '%' + usrqry + '%'
        
        crits = []
        if name:
            crits.append(Symbol.name.like(usrqry))
        if tags:
            crits.append(SymbolTag.tag.like(usrqry))
        if desc:
            crits.append(Symbol.description.like(usrqry))
        if meta:
            crits.append(SymbolMeta.value.like(usrqry)) 
        
        if len(crits):
            qry = qry.filter(or_(*crits))
        
        qry = qry.order_by(Symbol.name)

        if stronly:
            return [sym[0] for sym in qry.distinct()]
        else:
            return [sym for sym in qry.distinct()]"
1848,"def search_tag(self, tag, symbols=True, feeds=False):
        """""" Get a list of Symbols by searching a tag or partial tag.

        Parameters
        ----------
        tag : str
            The tag to search.  Appending '%' will use SQL's ""LIKE""
            functionality.
        symbols : bool, optional
            Search for Symbol's based on their tags.
        feeds : bool, optional
            Search for Symbol's based on their Feeds' tags.
        
        Returns
        -------
        List of Symbols or empty list
        
        """"""

        syms = []
        
        if isinstance(tag, (str, unicode)):
            tags = [tag]
        else:
            tags = tag

        if symbols:
            crits = []
            for tag in tags:
                if ""%"" in tag:
                    crit = SymbolTag.tag.like(tag)
                else:
                    crit = SymbolTag.tag == tag
                crits.append(crit)

            qry = self.ses.query(SymbolTag)
            qry = qry.filter(or_(*crits))
            syms = qry.all()
            
            syms = [tagged.symbol for tagged in syms]
        if feeds:
            crits = []
            for tag in tags:
                if ""%"" in tag:
                    crit = FeedTag.tag.like(tag)
                else:
                    crit = FeedTag.tag == tag
                crits.append(crit)
                    
            qry = self.ses.query(Symbol).select_from(FeedTag)
            qry = qry.join(FeedTag.feed).join(Feed.symbol)
            qry = qry.filter(or_(*crits))
            fds = qry.distinct()
            
            syms = syms + [sym for sym in fds]
            return list(set(syms))
        return syms"
1849,"def search_meta_specific(self, **avargs):
        """"""Search list of Symbol objects by by querying specific 
        meta attributes and their respective values.
        
        Parameters
        ----------
        avargs
            The attributes and values passed as key word arguments.
            If more than one criteria is specified, AND logic is applied.
            Appending '%' to values will use SQL's ""LIKE"" functionality.
        
        Example
        -------
        >>> sm.search_meta(geography='Canada', sector='Gov%')
            
        Returns
        -------
        List of Symbols or empty list
        """"""
        
        qry = self.ses.query(Symbol).join(SymbolMeta.symbol)


        for attr, value in avargs.iteritems():
            SMA = aliased(SymbolMeta)
            if ""%"" in value:
                acrit = SMA.value.like(value)
            else:
                acrit = SMA.value == value
            
            crit = and_(acrit, SMA.attr == attr)

            qry = qry.filter(crit).join(SMA, SMA.symname == SymbolMeta.symname)

        qry = qry.order_by(Symbol.name)
        return qry.all()"
1850,"def tag_counts(self):
        """""" Get a list of tags and the number of each.

        Returns
        -------
        List of tuples, in order (tag, # of Symbols w/Tag)
        
        """"""                    
        qry = self.ses.query(SymbolTag.tag, func.count(SymbolTag.tag))
        qry = qry.group_by(SymbolTag.tag)
        qry = qry.order_by(SymbolTag.tag)
        tags = list(qry.all())
        return tags"
1851,"def bulk_cache_of_tag(self, tag):
        """""" Caches all the symbols by a certain tag.

        For now, there is no different, than 
        caching each symbol individually.  In the future,
        this functionality could have speed improvements.

        Parameters
        ----------
        tag : str
            Use '%' to enable SQL's ""LIKE"" functionality.

        Returns
        -------
        TrumpReport
        """"""

        syms = self.search_tag(tag)
        
        name = 'Bulk Cache of Symbols tagged {}'.format(tag)
        tr = TrumpReport(name)
        for sym in syms:
            sr = sym.cache()
            tr.add_symbolreport(sr)
        
        return tr"
1852,"def build_view_from_tag(self, tag):
        """"""
        Build a view of group of Symbols based on their tag.
        
        Parameters
        ----------
        tag : str
            Use '%' to enable SQL's ""LIKE"" functionality.
        
        Note
        ----
        
        This function is written without SQLAlchemy,
        so it only tested on Postgres.

        """"""
        
        syms = self.search_tag(tag)
        
        names = [sym.name for sym in syms]
        
        subs = [""SELECT indx, '{}' AS symbol, final FROM {}"".format(s, s) for s in names]
        
        qry = "" UNION ALL "".join(subs)
        
        qry = ""CREATE VIEW {} AS {};"".format(tag, qry)

        self.ses.execute(""DROP VIEW IF EXISTS {};"".format(tag))
        self.ses.commit()        
        self.ses.execute(qry)
        self.ses.commit()"
1853,"def _add_orfs(self, which, symbol, ind, val, dt_log=None, user=None, comment=None):
        """"""
        Appends a single indexed-value pair, to a symbol object, to be
        used during the final steps of the aggregation of the datatable.

        See add_override and add_fail_safe.
        
        Parameters
        ----------
        which : str
            Fail Safe or Override?
        symbol : Symbol or str
            The Symbol to apply the fail safe
        ind : obj
            The index value where the fail safe should be applied
        val : obj
            The data value which will be used in the fail safe
        dt_log : datetime
            A log entry, for saving when this fail safe was created.
        user : str
            A string representing which user made the fail safe
        comment : str
            A string to store any notes related to this fail safe.
        """"""
        if not isinstance(symbol, (str, unicode)):
            symbol = symbol.name

        if not dt_log:
            dt_log = dt.datetime.now()

        if which.lower() == 'override':
            qry = self.ses.query(func.max(Override.ornum).label('max_ornum'))
            override = True
        elif which.lower() == 'failsafe':
            qry = self.ses.query(func.max(FailSafe.fsnum).label('max_fsnum'))
            override = False
            
        qry = qry.filter_by(symname = symbol)
        
        cur_num = qry.one()
        
        if cur_num[0] is None:
            next_num = 0
        else:
            next_num = cur_num[0] + 1            

        if override:
            tmp = Override(symname=symbol,
                           ind=ind,
                           val=val,
                           dt_log=dt_log,
                           user=user,
                           comment=comment,
                           ornum=next_num)
        else:
            tmp = FailSafe(symname=symbol,
                           ind=ind,
                           val=val,
                           dt_log=dt_log,
                           user=user,
                           comment=comment,
                           fsnum=next_num)
                                             
        self.ses.add(tmp)
        self.ses.commit()"
1854,"def add_override(self, symbol, ind, val, dt_log=None, user=None, comment=None):
        """"""
        Appends a single indexed-value pair, to a symbol object, to be
        used during the final steps of the aggregation of the datatable.

        With default settings Overrides, get applied with highest priority.
        
        Parameters
        ----------
        symbol : Symbol or str
            The Symbol to override
        ind : obj
            The index value where the override should be applied
        val : obj
            The data value which will be used in the override
        dt_log : datetime
            A log entry, for saving when this override was created.
        user : str
            A string representing which user made the override
        comment : str
            A string to store any notes related to this override.
        """"""
        self._add_orfs('override', symbol, ind, val, dt_log, user, comment)"
1855,"def get_converted(self, symbol, units='CAD', system=None, tag=None):
        """"""
        Uses a Symbol's Dataframe, to build a new Dataframe,
        with the data converted to the new units
        
        Parameters
        ----------
        symbol : str or tuple of the form (Dataframe, str)
            String representing a symbol's name, or a dataframe
            with the data required to be converted.  If supplying a 
            dataframe, units must be passed.
        units : str, optional
            Specify the units to convert the symbol to, default to CAD 
        system : str, optional
            If None, the default system specified at instantiation
            is used.  System defines which conversion approach to take.
        tag : str, optional
            Tags define which set of conversion data is used.  If None, the
            default tag specified at instantiation is used.  
        """"""
        if isinstance(symbol, (str, unicode)):
            sym = self.get(symbol)
            df = sym.df
            curu = sym.units
            requ = units
        elif isinstance(symbol, tuple):
            df = symbol[0]
            curu = symbol[1]
            requ = units
        else:
            raise TypeError(""Expected str or (DataFrame, str), found {}"".format(type(symbol)))
        
        system = system or self.default_system
        tag = tag or self.default_tag
        
        conv = self.converters[system][tag]

        newdf = conv.convert(df, curu, requ)
        newdf = pd.merge(df, newdf, left_index=True, right_index=True)
        newdf = newdf[df.columns[0] + ""_y""].to_frame()
        newdf.columns = df.columns
        return newdf"
1856,"def last_cache(self,result='COMPLETE'):
        """"""
        The date and time of the previous cache.

        Parameters
        ----------
        result : string, default 'COMPLETE'
            A string to choose which point in the log,
            should be returned.
            - COMPLETE - the last time a cache was completed
            - STARTED - the last time a cache was started
        Returns
        -------
        datetime.datetime

        """"""
        crit = and_(SymbolLogEvent.event == 'CACHE',
                    SymbolLogEvent.evresult == result)
        qry = self.log.filter(crit)
        qry = qry.order_by(SymbolLogEvent.evtime.desc())
        
        t = qry.first()
        
        if t:
            return t.evtime
        else:
            return None"
1857,"def set_indexing(self, index_template):
        """"""
        Update a symbol's indexing strategy
        
        Parameters
        ----------
        index_template : bIndex or bIndex-like
            An index template used to overwrite all 
            details about the symbol's current index.

        """"""
        objs = object_session(self)
        
        if self.index.indimp != index_template.imp_name:
            self._refresh_datatable_schema()
        
        self.index.name = index_template.name
        self.index.indimp = index_template.imp_name
        self.index.case = index_template.case
        self.index.setkwargs(**index_template.kwargs)
        objs.commit()"
1858,"def add_meta(self, **metadict):
        """"""Add meta information to a Symbol.
                
        Parameters
        ----------
        metadict 
            Attributes are passed as keywords, with their
            associated values as strings.  For meta attributes with spaces,
            use an unpacked dict.
                    
        """"""
        
        objs = object_session(self)
        
        for attr,val in metadict.iteritems():
            newmeta = SymbolMeta(self, attr, val)
            self.meta.append(newmeta)
            
        objs.commit()"
1859,"def add_validator(self, val_template):
        """"""
        Creates and adds a SymbolValidity object to the Symbol.

        Parameters
        ----------
        validity_template : bValidity or bValidity-like
            a validity template.

        """"""
        validator = val_template.validator
        
        args = []
        for arg in SymbolValidity.argnames:
            if arg in val_template.__dict__.keys():
                args.append(getattr(val_template, arg))

        objs = object_session(self)
        qry = objs.query(func.max(SymbolValidity.vid).label('max_vid'))
        qry = qry.filter_by(symname = self.name)
        
        cur_vid = qry.one()[0]
        
        if cur_vid is None:
            next_vid = 0
        else:
            next_vid = cur_vid + 1   
            
       
        self.validity.append(SymbolValidity(self, next_vid, validator, *args))
        objs.commit()"
1860,"def cache(self, checkvalidity=True, staleonly=False, allowraise=True):
        """""" Re-caches the Symbol's datatable by querying each Feed. 
        
        Parameters
        ----------
        checkvalidity : bool, optional
            Optionally, check validity post-cache.  Improve speed by
            turning to False.
        staleonly : bool, default False
            Set to True, for speed up, by looking at staleness
        allowraise : bool, default True
            AND with the Symbol.handle and Feed.handle's 'raise',
            set to False, to do a list of symbols.  Note, this
            won't silence bugs in Trump, eg. unhandled edge cases.
            So, those still need to be handled by the application.
        
        Returns
        -------
        SymbolReport
        """"""
        note = ""staleonly = {}"".format(staleonly)
        self._log_an_event('CACHE','START',note)

        docache = True
        if staleonly:
            lc = self.last_cache()
            if lc:
                freshthresh = self.freshthresh 
                
                nw = dt.datetime.now()
                freshness = (nw - lc).total_seconds() / 60.0

                if freshness <= freshthresh:
                    docache = False
        
        smrp = SymbolReport(self.name)
        if docache:
            data = []
            cols = ['final', 'override_feed000', 'failsafe_feed999']
    
            if len(self.feeds) == 0:
                err_msg = ""Symbol has no Feeds. Can't cache a feed-less Symbol.""
                raise Exception(err_msg)
    
            try:
                datt = datadefs[self.dtype.datadef]

                indtt = indexingtypes[self.index.indimp]
                indkwargs = self.index.getkwargs()
                indt = indtt(self.index.case, **indkwargs)
                
                rp = ReportPoint('datadef', 'class', datt)
                smrp.add_reportpoint(rp)
                
                for afeed in self.feeds:
                    fdrp = afeed.cache(allowraise)
                    smrp.add_feedreport(fdrp)
                    tmp = datt(afeed.data).converted
                    tmp = indt.process_post_feed_cache(tmp)
                    data.append(tmp)
                    cols.append(afeed.data.name)
            except:
                point = ""caching""
                smrp = self._generic_exception(point, smrp, allowraise)
                    
            try:
                data = pd.concat(data, axis=1)
            except:
                point = ""concatenation""
                smrp = self._generic_exception(point, smrp, allowraise)
            
            # We shouldn't need to do anything here, as the concatenation
            # should be smooth...
            
#            preindlen = len(data)
#
#                     
#            if preindlen > 0 : 
#                #indt = indtt(data, self.index.case, indkwargs)
#                #data = indt.final_dataframe()
#                data = indt.process_post_concat(data)
#
#                postindlen = len(data)   
#                if postindlen == 0 and preindlen > 0:
#                    raise Exception(""Indexing Implementer likely poorly designed"")
#            else:
#                postindlen = 0
            
            
            def build_hi_df(which, colname):
                
                objs = object_session(self)
    
                qry = objs.query(which.ind,
                                 func.max(which.dt_log).label('max_dt_log'))
                
                qry = qry.filter_by(symname = self.name)
                
                grb = qry.group_by(which.ind).subquery()
        
                qry = objs.query(which)
                ords = qry.join((grb, and_(which.ind == grb.c.ind,
                                           which.dt_log == grb.c.max_dt_log))).all()
            
                if len(ords):
                    orind = [row.ind for row in ords]
                    orval = [row.val for row in ords]
                    ordf = indt.build_ordf(orind, orval, colname)
                else:
                    ordf = pd.DataFrame(columns=[colname])
                return ordf
            
            ordf = build_hi_df(Override, 'override_feed000')
            fsdf = build_hi_df(FailSafe, 'failsafe_feed999')
            
            orfsdf = pd.merge(ordf, fsdf, how='outer', left_index=True, right_index=True)
            data = pd.merge(orfsdf, data, how='outer', left_index=True, right_index=True)
            
            data = indt.process_post_orfs(data)

            try:
                data = data.fillna(value=pd.np.nan)
                data = data[sorted_feed_cols(data)]
                data['final'] = FeedAggregator(self.agg_method).aggregate(data)
            except:
                point = ""aggregation""
                smrp = self._generic_exception(point, smrp, allowraise)
    
    
            # SQLAQ There are several states to deal with at this point
            # A) the datatable exists but a feed has been added
            # B) the datatable doesn't exist and needs to be created
            # C) the datatable needs to be updated for more or less feeds
            # D) the datatable_exists flag is incorrect because all edge cases
            #    haven't been handled yet.
            #
            # My logic is that once Trump is more functional, I'll be able to
            # eliminate this hacky solution.  But, SQLAlchemy might have
            # a more elegant answer.  A check, of somekind prior to deletion?
    
            # if not self.datatable_exists:
            #     self._init_datatable() #older version of _init_datatable
            # delete(self.datatable).execute()
            # self._init_datatable() #older version of _init_datatable
    
            # Is this the best way to check?
            # if engine.dialect.has_table(session.connection(), self.name):
            #    delete(self.datatable).execute()
            self._refresh_datatable_schema()
            
            if len(data) > 0:
                data.index.name = 'indx'
                data = data.reset_index()
                datarecords = data.to_dict(orient='records')
                
                objs = object_session(self)
                objs.execute(self.datatable.insert(), datarecords)
                objs.commit()
            
            
            if checkvalidity:
                try:
                    isvalid, reports = self.check_validity(report=True)
                    for rep in reports:
                        smrp.add_reportpoint(rep)
                    if not isvalid:
                        raise Exception('{} is not valid'.format(self.name))
                except:
                    point = ""validity_check""
                    smrp = self._generic_exception(point, smrp, allowraise)
            self._log_an_event('CACHE','COMPLETE', ""Fresh!"")
        else:
            self._log_an_event('CACHE','FRESH', ""Was still fresh"")
        return smrp"
1861,"def check_validity(self, checks=None, report=True):
        """""" Runs a Symbol's validity checks.
        
        Parameters
        ----------
        checks : str, [str,], optional
            Only run certain checks.  
        report : bool, optional
            If set to False, the method will return only the result of the
            check checks (True/False).  Set to True, to have a 
            SymbolReport returned as well.
            
        Returns
        -------
        Bool, or a Tuple of the form (Bool, SymbolReport)
        """"""        
        if report:
            reportpoints = []
            
        allchecks = []
        
        checks_specified=False
        
        if isinstance(checks, (str, unicode)):
            checks = [checks]
            checks_specified = True
        elif isinstance(checks, (list, tuple)):
            checks_specified = True
        else:
            checks = []
            
        for val in self.validity:
            
            if (val.validator in checks) or (not checks_specified):
                ValCheck = validitychecks[val.validator]

                anum = ValCheck.__init__.func_code.co_argcount - 2
                
                args = []
                for arg in SymbolValidity.argnames:
                    args.append(getattr(val, arg))
                
                valid = ValCheck(self.datatable_df, *args[:anum])
                res = valid.result
                allchecks.append(res)
                
                rp = ReportPoint('validation', val.validator, res, str(args[:anum]))
                reportpoints.append(rp)
        
        if report:
            return all(allchecks), reportpoints
        else:
            return all(allchecks)"
1862,"def describe(self):
        """""" describes a Symbol, returns a string """"""
        lines = []
        lines.append(""Symbol = {}"".format(self.name))
        if len(self.tags):
            tgs = "", "".join(x.tag for x in self.tags)
            lines.append(""  tagged = {}"".format(tgs))
        if len(self.aliases):
            als = "", "".join(x.alias for x in self.aliases)
            lines.append(""  aliased = {}"".format(als))
        if len(self.feeds):
            lines.append(""  feeds:"")

            for fed in self.feeds:
                lines.append(""    {}. {}"".format(fed.fnum,
                                                       fed.ftype))
        return ""\n"".join(lines)"
1863,"def del_tags(self, tags):
        """""" remove a tag or tags from a symbol 
        
        Parameters
        ----------
        tags : str or [str,]
            Tags to be removed
        """"""
        # SQLA Adding a SymbolTag object, feels awkward/uneccessary.
        # Should I be implementing this functionality a different way?

        if isinstance(tags, (str, unicode)):
            tags = [tags]

        objs = object_session(self)

        docommit = False
        for symboltag in self.tags:
            if symboltag.tag in tags:
                objs.delete(symboltag)
                docommit = True

        
        if docommit:
            objs.commit()"
1864,"def add_tags(self, tags):
        """""" add a tag or tags to a symbol
        
        Parameters
        ----------
        tags : str or [str,]
            Tags to be added
        """"""
        # SQLA Adding a SymbolTag object, feels awkward/uneccessary.
        # Should I be implementing this functionality a different way?

        if isinstance(tags, (str, unicode)):
            tags = [tags]

        objs = object_session(self)
        tmps = [SymbolTag(tag=t, sym=self) for t in tags]
        objs.add_all(tmps)
        objs.commit()"
1865,"def _log_an_event(self, event, evresult='No Result', note='No Note'):
        """""" log an event
        
        Parameters
        ----------
        event : string
        evresult : string
        note : string
        """"""
        objs = object_session(self)
        evnt = SymbolLogEvent(event, evresult, note, sym=self.name)
        objs.add(evnt)
        objs.commit()"
1866,"def add_feed(self, feedlike, **kwargs):
        """""" Add a feed to the Symbol
        
        Parameters
        ----------
        feedlike : Feed or bFeed-like
            The feed template, or Feed object to be added.
        kwargs
            Munging instructions
        """"""
        if 'fnum' in kwargs:
            fnum = kwargs['fnum']
            del kwargs['fnum']
        else:
            fnum = None

        if isinstance(feedlike, bFeed):
            munging = feedlike.munging
            if 'munging' in kwargs:
                explicit_munging = kwargs['munging'].as_odict
                for key in explicit_munging:
                    munging[key] = explicit_munging[key]
            fed = Feed(self, feedlike.ftype,
                       feedlike.sourcing,
                       munging,
                       feedlike.meta,
                       fnum)

        elif isinstance(feedlike, Feed):
            fed = feedlike
        else:
            raise Exception(""Invalid Feed {}"".format(repr(feedlike)))
        self.feeds.append(fed)
        
        objs = object_session(self)
        objs.add(fed)
        objs.commit()"
1867,"def add_alias(self, alias):
        """""" Add an alias to a Symbol
        
        Parameters
        ----------
        alias : str
            The alias
        """"""
        objs = object_session(self)
        
        if isinstance(alias, list):
            raise NotImplementedError
        elif isinstanceofany(alias, (str, unicode)):
            a = SymbolAlias(self, alias)
            self.aliases.append(a)
            objs.add(a)"
1868,"def _final_data(self):
        """"""
        Returns
        -------
        A list of tuples representing rows from the datatable's index
        and final column, sorted accordingly.
        """"""
        dtbl = self.datatable

        objs = object_session(self)
        if isinstance(dtbl, Table):
            return objs.query(dtbl.c.indx, dtbl.c.final).all()
        else:
            raise Exception(""Symbol has no datatable, likely need to cache first."")"
1869,"def _max_min(self):
        """"""
        Returns
        -------
        A tuple consisting of (max, min) of the index.
        """"""
        dtbl = self.datatable

        objs = object_session(self)
        if isinstance(dtbl, Table):
            return objs.query(func.max(dtbl.c.indx).label(""max_indx""),
                              func.min(dtbl.c.indx).label(""min_indx"")).one()
        else:
            raise Exception(""Symbol has no datatable"")"
1870,"def _all_datatable_data(self):
        """"""
        Returns
        -------
        A list of tuples representing rows from all columns of the datatable,
        sorted accordingly.
        """"""
        dtbl = self.datatable
        objs = object_session(self)
        imcols = [dtbl.c.indx, dtbl.c.final, dtbl.c.override_feed000, dtbl.c.failsafe_feed999]
        cols = imcols[:3] + [c for c in dtbl.c if c not in (imcols)] + [imcols[3]]
        if isinstance(dtbl, Table):
            return objs.query(*cols).order_by(dtbl.c.indx).all()
        else:
            raise Exception(""Symbol has no datatable"")"
1871,"def df(self):
        """"""
        Note: this accessor is read-only.  It should be copied, if accessed in
        an application, more than once.
        
        Returns
        -------
            Dataframe of the symbol's final data.
        """"""
        data = self._final_data()
        
        if len(data) == 0:
            adf = pd.DataFrame(columns = [self.index.name, self.name])
            return adf.set_index(self.index.name)
            
        adf = pd.DataFrame(data)
        
        if len(adf.columns) != 2:
            msg = ""Symbol ({}) needs to be cached prior to building a Dataframe""
            msg = msg.format(self.name)
            raise Exception(msg)
        adf.columns = [self.index.name, self.name]
        return self._finish_df(adf, 'FINAL')"
1872,"def datatable_df(self):
        """""" returns the dataframe representation of the symbol's final data """"""
        data = self._all_datatable_data()
        adf = pd.DataFrame(data)
        adf.columns = self.dt_all_cols
        return self._finish_df(adf, 'ALL')"
1873,"def _init_datatable(self):
        """"""
        Instantiates the .datatable attribute, pointing to a table in the
        database that stores all the cached data
        """"""
        try:
            self.datatable = Table(self.name, Base.metadata, autoload=True)
        except NoSuchTableError:
            print ""Creating datatable, cause it doesn't exist""
            self.datatable = self._datatable_factory()
            self.datatable.create()
        self.datatable_exists = True"
1874,"def _datatable_factory(self):
        """"""
        creates a SQLAlchemy Table object with the appropriate number of
        columns given the number of feeds
        """"""
        feed_cols = ['feed{0:03d}'.format(i + 1) for i in range(self.n_feeds)]
        feed_cols = ['override_feed000'] + feed_cols + ['failsafe_feed999']

        ind_sqlatyp = indexingtypes[self.index.indimp].sqlatyp
        dat_sqlatyp = datadefs[self.dtype.datadef].sqlatyp

        atbl = Table(self.name, Base.metadata,
                     Column('indx', ind_sqlatyp, primary_key=True),
                     Column('final', dat_sqlatyp),
                     *(Column(fed_col, dat_sqlatyp) for fed_col in feed_cols),
                     extend_existing=True)
        
        self.dt_feed_cols = feed_cols[:]
        self.dt_all_cols = ['indx', 'final'] + feed_cols[:]
        return atbl"
1875,"def update_handle(self, chkpnt_settings):
        """"""
        Update a feeds's handle checkpoint settings

        :param chkpnt_settings, dict:
            a dictionary where the keys are stings representing
            individual handle checkpoint names, for a Feed
            (eg. api_failure, feed_type, monounique...)
            See FeedHandle.__table__.columns for the
            current list.

            The values can be either integer or BitFlags.

        :return: None
        """"""

        # Note, for now, this function is nearly identical
        # to the Symbol version.  Careful when augmenting,
        # to get the right one.

        objs = object_session(self)

        # override with anything passed in
        for checkpoint in chkpnt_settings:
            if checkpoint in FeedHandle.__table__.columns:
                settings = chkpnt_settings[checkpoint]
                setattr(self.handle, checkpoint, settings)
        objs.commit()"
1876,"def add_tags(self, tags):
        """""" add a tag or tags to a Feed """"""

        if isinstance(tags, (str, unicode)):
            tags = [tags]

        objs = object_session(self)
        tmps = [FeedTag(tag=t, feed=self) for t in tags]
        objs.add_all(tmps)
        objs.commit()"
1877,"def initiate_browser(self):

        # Create a unique tempdir for downloaded files
        tempdir = os.getenv(TEMPDIR_ENVVAR, DEFAULT_TEMPDIR)
        tempsubdir = uuid4().hex
        # TODO: Remove this directory when finished!
        self.tempdir = os.path.join(tempdir, tempsubdir)
        try:
            # Try and create directory before checking if it exists,
            # to avoid race condition
            os.makedirs(self.tempdir)
        except OSError:
            if not os.path.isdir(self.tempdir):
                raise

        profile = webdriver.FirefoxProfile()
        # Set download location, avoid download dialogues if possible
        # Different settings needed for different Firefox versions
        # This will be a long list...
        profile.set_preference('browser.download.folderList', 2)
        profile.set_preference('browser.download.manager.showWhenStarting', False)
        profile.set_preference('browser.download.manager.closeWhenDone', True)
        profile.set_preference('browser.download.dir', self.tempdir)
        profile.set_preference(""browser.helperApps.neverAsk.saveToDisk"", ""application/octet-stream;application/vnd.ms-excel"")
        profile.set_preference(""browser.helperApps.alwaysAsk.force"", False)
        profile.set_preference(""browser.download.manager.useWindow"", False)

        self.browser = webdriver.Firefox(profile)

        self.browser.get('http://webbstat.av.se')
        detailed_cls = ""Document_TX_GOTOTAB_Avancerad""
        """""" The button for expanded detailed options. This
        also happens to be a good indicator as to wheter
        all content is loaded.
        """"""

        # Wait for a content element, and 3 extra seconds just in case
        WebDriverWait(self.browser, PAGELOAD_TIMEOUT)\
            .until(EC.presence_of_element_located((By.CLASS_NAME,
                                                  detailed_cls)))
        self.browser.implicitly_wait(3)

        self.browser\
            .find_element_by_class_name(detailed_cls)\
            .find_element_by_tag_name(""td"")\
            .click()
        # Wait for a content element, and 3 extra seconds just in case
        WebDriverWait(self.browser, PAGELOAD_TIMEOUT)\
            .until(EC.presence_of_element_located((By.CLASS_NAME,
                                                   detailed_cls)))
        self.browser.implicitly_wait(3)"
1878,"def _fetch_dimensions(self, dataset):
        """""" Declaring available dimensions like this is not mandatory,
         but nice, especially if they differ from dataset to dataset.

         If you are using a built in datatype, you can specify the dialect
         you are expecting, to have values normalized. This scraper will
         look for Swedish month names (e.g. 'Januari'), but return them
         according to the Statscraper standard ('january').
        """"""
        yield Dimension(u""region"",
                        label=""municipality or county"",
                        datatype=""region"",
                        dialect=""arbetsmiljoverket"")
        yield Dimension(u""period"",
                        label=""Year or month"")"
1879,"def _fetch_itemslist(self, item):
        """""" We define two collection:
        - Number of work injuries (""Arbetsolycka"")
        - Number of workrelated diseases (""Arbetssjukdom"")
        Each contains four datasets:
        - Per municipality and year
        - Per county and year
        - Per municipality and month
        - Per municipality and year
        """"""
        if item.is_root:
            for c in [""Arbetsolycka"", ""Arbetssjukdom""]:
                yield Collection(c, blob=(c, None, None))
        else:
            c = item.id
            for r in [u""kommun"", u""län""]:
                for p in [u""år"", u""månad""]:
                    yield Dataset(u""%s-%s-%s"" % (c, r, p),
                                  blob=(c, r, p),
                                  label=u""%s, antal per %s och %s"" % (c, r, p))"
1880,"def make_log_record_output(category, level, message,
                           format=None, datefmt=None, **kwargs):
    """"""
    Create the output for a log record, like performed by :mod:`logging` module.

    :param category:    Name of the logger (as string or None).
    :param level:       Log level (as number).
    :param message:     Log message to use.
    :returns: Log record output (as string)
    """"""
    if not category or (category == ""__ROOT__""):
        category = ""root""
    levelname = logging.getLevelName(level)
    record_data = dict(name=category, levelname=levelname, msg=message)
    record_data.update(kwargs)
    record = logging.makeLogRecord(record_data)
    formatter = logging.Formatter(format, datefmt=datefmt)
    return formatter.format(record)"
1881,"def step_I_create_logrecords_with_table(context):
    """"""
    Step definition that creates one more log records by using a table.

    .. code-block: gherkin

        When I create log records with:
            | category | level | message   |
            |  foo     | ERROR | Hello Foo |
            |  foo.bar | WARN  | Hello Foo.Bar |

    Table description
    ------------------

    | Column   | Type     | Required | Description |
    | category | string   | yes      | Category (or logger) to use. |
    | level    | LogLevel | yes      | Log level to use.   |
    | message  | string   | yes      | Log message to use. |

    .. code-block: python

        import logging
        from behave.configuration import LogLevel
        for row in table.rows:
            logger = logging.getLogger(row.category)
            level  = LogLevel.parse_type(row.level)
            logger.log(level, row.message)
    """"""
    assert context.table, ""REQUIRE: context.table""
    context.table.require_columns([""category"", ""level"", ""message""])
    for row in context.table.rows:
        category = row[""category""]
        if category == ""__ROOT__"":
            category = None
        level = LogLevel.parse_type(row[""level""])
        message = row[""message""]
        make_log_record(category, level, message)"
1882,"def step_I_create_logrecord_with_table(context):
    """"""
    Create an log record by using a table to provide the parts.

    .. seealso: :func:`step_I_create_logrecords_with_table()`
    """"""
    assert context.table, ""REQUIRE: context.table""
    assert len(context.table.rows) == 1, ""REQUIRE: table.row.size == 1""
    step_I_create_logrecords_with_table(context)"
1883,"def step_command_output_should_contain_log_records(context):
    """"""
    Verifies that the command output contains the specified log records
    (in any order).

    .. code-block: gherkin

        Then the command output should contain the following log records:
            | category | level   | message |
            | bar      | CURRENT | xxx     |
    """"""
    assert context.table, ""REQUIRE: context.table""
    context.table.require_columns([""category"", ""level"", ""message""])
    format = getattr(context, ""log_record_format"", context.config.logging_format)
    for row in context.table.rows:
        output = LogRecordTable.make_output_for_row(row, format)
        context.execute_steps(u'''
            Then the command output should contain:
                """"""
                {expected_output}
                """"""
            '''.format(expected_output=output))"
1884,"def step_command_output_should_not_contain_log_records(context):
    """"""
    Verifies that the command output contains the specified log records
    (in any order).

    .. code-block: gherkin

        Then the command output should contain the following log records:
            | category | level   | message |
            | bar      | CURRENT | xxx     |
    """"""
    assert context.table, ""REQUIRE: context.table""
    context.table.require_columns([""category"", ""level"", ""message""])
    format = getattr(context, ""log_record_format"", context.config.logging_format)
    for row in context.table.rows:
        output = LogRecordTable.make_output_for_row(row, format)
        context.execute_steps(u'''
            Then the command output should not contain:
                """"""
                {expected_output}
                """"""
            '''.format(expected_output=output))"
1885,"def step_command_output_should_contain_log_records_from_categories(context):
    """"""
    Verifies that the command output contains the specified log records
    (in any order).

    .. code-block: gherkin

        Given I define a log record schema:
            | category | level | message |
            | root     | ERROR | __LOG_MESSAGE__ |
        Then the command output should contain log records from categories:
            | category |
            | bar      |
    """"""
    assert context.table, ""REQUIRE: context.table""
    context.table.require_column(""category"")
    record_schema = context.log_record_row_schema
    LogRecordTable.annotate_with_row_schema(context.table, record_schema)
    step_command_output_should_contain_log_records(context)
    context.table.remove_columns([""level"", ""message""])"
1886,"def step_command_output_should_not_contain_log_records_from_categories(context):
    """"""
    Verifies that the command output contains not log records from
    the provided log categories (in any order).

    .. code-block: gherkin

        Given I define the log record schema:
            | category | level | message |
            | root     | ERROR | __LOG_MESSAGE__ |
        Then the command output should not contain log records from categories:
            | category |
            | bar      |
    """"""
    assert context.table, ""REQUIRE: context.table""
    context.table.require_column(""category"")
    record_schema = context.log_record_row_schema
    LogRecordTable.annotate_with_row_schema(context.table, record_schema)
    step_command_output_should_not_contain_log_records(context)
    context.table.remove_columns([""level"", ""message""])"
1887,"def step_file_should_contain_log_records(context, filename):
    """"""
    Verifies that the command output contains the specified log records
    (in any order).

    .. code-block: gherkin

        Then the file ""xxx.log"" should contain the log records:
            | category | level   | message |
            | bar      | CURRENT | xxx     |
    """"""
    assert context.table, ""REQUIRE: context.table""
    context.table.require_columns([""category"", ""level"", ""message""])
    format = getattr(context, ""log_record_format"", context.config.logging_format)
    for row in context.table.rows:
        output = LogRecordTable.make_output_for_row(row, format)
        context.text = output
        step_file_should_contain_multiline_text(context, filename)"
1888,"def step_file_should_not_contain_log_records(context, filename):
    """"""
    Verifies that the command output contains the specified log records
    (in any order).

    .. code-block: gherkin

        Then the file ""xxx.log"" should not contain the log records:
            | category | level   | message |
            | bar      | CURRENT | xxx     |
    """"""
    assert context.table, ""REQUIRE: context.table""
    context.table.require_columns([""category"", ""level"", ""message""])
    format = getattr(context, ""log_record_format"", context.config.logging_format)
    for row in context.table.rows:
        output = LogRecordTable.make_output_for_row(row, format)
        context.text = output
        step_file_should_not_contain_multiline_text(context, filename)"
1889,"def step_use_log_record_configuration(context):
    """"""
    Define log record configuration parameters.

    .. code-block: gherkin

        Given I use the log record configuration:
            | property | value |
            | format   |       |
            | datefmt  |       |
    """"""
    assert context.table, ""REQUIRE: context.table""
    context.table.require_columns([""property"", ""value""])
    for row in context.table.rows:
        property_name = row[""property""]
        value = row[""value""]
        if property_name == ""format"":
            context.log_record_format = value
        elif property_name == ""datefmt"":
            context.log_record_datefmt = value
        else:
            raise KeyError(""Unknown property=%s"" % property_name)"
1890,"def annotate_with_row_schema(table, row_schema):
        """"""
        Annotate/extend a table of log-records with additional columns from
        the log-record schema if columns are missing.

        :param table:   Table w/ log-records (as :class:`behave.model.Table`)
        :param row_schema:  Log-record row schema (as dict).
        """"""
        for column, value in row_schema.items():
            if column not in table.headings:
                table.add_column(column, default_value=value)"
1891,"def smart_decode(binary, errors=""strict""):
    """"""
    Automatically find the right codec to decode binary data to string.

    :param binary: binary data
    :param errors: one of 'strict', 'ignore' and 'replace'
    :return: string
    """"""
    d = chardet.detect(binary)
    encoding = d[""encoding""]
    confidence = d[""confidence""]

    text = binary.decode(encoding, errors=errors)
    return text, encoding, confidence"
1892,"def decode(self, binary, url, encoding=None, errors=""strict""):
        """"""
        Decode binary to string.

        :param binary: binary content of a http request.
        :param url: endpoint of the request.
        :param encoding: manually specify the encoding.
        :param errors: errors handle method.

        :return: str
        """"""
        if encoding is None:
            domain = util.get_domain(url)
            if domain in self.domain_encoding_table:
                encoding = self.domain_encoding_table[domain]
                html = binary.decode(encoding, errors=errors)
            else:
                html, encoding, confidence = smart_decode(
                    binary, errors=errors)
                # cache domain name and encoding
                self.domain_encoding_table[domain] = encoding
        else:
            html = binary.decode(encoding, errors=errors)

        return html"
1893,"def modify_number_pattern(number_pattern, **kwargs):
    """"""Modifies a number pattern by specified keyword arguments.""""""
    params = ['pattern', 'prefix', 'suffix', 'grouping',
              'int_prec', 'frac_prec', 'exp_prec', 'exp_plus']
    for param in params:
        if param in kwargs:
            continue
        kwargs[param] = getattr(number_pattern, param)
    return NumberPattern(**kwargs)"
1894,"def format_currency_field(__, prec, number, locale):
    """"""Formats a currency field.""""""
    locale = Locale.parse(locale)
    currency = get_territory_currencies(locale.territory)[0]
    if prec is None:
        pattern, currency_digits = None, True
    else:
        prec = int(prec)
        pattern = locale.currency_formats['standard']
        pattern = modify_number_pattern(pattern, frac_prec=(prec, prec))
        currency_digits = False
    return format_currency(number, currency, pattern, locale=locale,
                           currency_digits=currency_digits)"
1895,"def format_decimal_field(__, prec, number, locale):
    """"""Formats a decimal field:

    .. sourcecode::

       1234 ('D') -> 1234
       -1234 ('D6') -> -001234

    """"""
    prec = 0 if prec is None else int(prec)
    if number < 0:
        prec += 1
    return format(number, u'0%dd' % prec)"
1896,"def format_float_field(__, prec, number, locale):
    """"""Formats a fixed-point field.""""""
    format_ = u'0.'
    if prec is None:
        format_ += u'#' * NUMBER_DECIMAL_DIGITS
    else:
        format_ += u'0' * int(prec)
    pattern = parse_pattern(format_)
    return pattern.apply(number, locale)"
1897,"def format_number_field(__, prec, number, locale):
    """"""Formats a number field.""""""
    prec = NUMBER_DECIMAL_DIGITS if prec is None else int(prec)
    locale = Locale.parse(locale)
    pattern = locale.decimal_formats.get(None)
    return pattern.apply(number, locale, force_frac=(prec, prec))"
1898,"def format_percent_field(__, prec, number, locale):
    """"""Formats a percent field.""""""
    prec = PERCENT_DECIMAL_DIGITS if prec is None else int(prec)
    locale = Locale.parse(locale)
    pattern = locale.percent_formats.get(None)
    return pattern.apply(number, locale, force_frac=(prec, prec))"
1899,"def format_hexadecimal_field(spec, prec, number, locale):
    """"""Formats a hexadeciaml field.""""""
    if number < 0:
        # Take two's complement.
        number &= (1 << (8 * int(math.log(-number, 1 << 8) + 1))) - 1
    format_ = u'0%d%s' % (int(prec or 0), spec)
    return format(number, format_)"
1900,"def format_field(self, value, format_spec):
        """"""Format specifiers are described in :func:`format_field` which is a
        static function.
        """"""
        if format_spec:
            spec, arg = format_spec[0], format_spec[1:]
            arg = arg or None
        else:
            spec = arg = None
        return self._format_field(spec, arg, value, self.numeric_locale)"
1901,"def delegate(attribute_name, method_names):
    """"""
    Decorator factory to delegate methods to an attribute.

    Decorate a class to map every method in `method_names` to the attribute `attribute_name`.

    """"""
    call_attribute_method = partial(_call_delegated_method, attribute_name)

    def decorate(class_):
        for method in method_names:
            setattr(class_, method, partialmethod(call_attribute_method, method))

        return class_
    return decorate"
1902,"def prepare_query(query):
    """"""
    Prepare a query object for the RAPI.

    RAPI has lots of curious rules for coercing values.

    This function operates on dicts in-place and has no return value.

    @type query: dict
    @param query: Query arguments
    """"""

    for name in query:
        value = query[name]

        # None is sent as an empty string.
        if value is None:
            query[name] = """"

        # Booleans are sent as 0 or 1.
        elif isinstance(value, bool):
            query[name] = int(value)

        # XXX shouldn't this just check for basestring instead?
        elif isinstance(value, dict):
            raise ValueError(""Invalid query data type %r"" %
                             type(value).__name__)"
1903,"def itemgetters(*args):
    """"""
    Get a handful of items from an iterable.

    This is just map(itemgetter(...), iterable) with a list comprehension.
    """"""

    f = itemgetter(*args)

    def inner(l):
        return [f(x) for x in l]

    return inner"
1904,"def create_container(self, container, **kwargs):
        """"""Create container

        :param container(string): container name (Container is equivalent to
                                  Bucket term in Amazon).
        :param **kwargs(dict): extend args for specific driver.
        """"""
        try:
            LOG.debug('create_container() with %s is success.', self.driver)
            return self.driver.create_container(container, **kwargs)
        except DriverException as e:
            LOG.exception('create_container() with %s raised\
                            an exception %s.', self.driver, e)"
1905,"def delete_container(self, container):
        """"""Delete container

        :param container: container name (Container is equivalent to
                          Bucket term in Amazon).
        """"""
        try:
            LOG.debug('delete_container() with %s is success.', self.driver)
            return self.driver.delete_container(container)
        except DriverException as e:
            LOG.exception('delete_container() with %s raised\
                            an exception %s.', self.driver, e)"
1906,"def stat_container(self, container):
        """"""Stat container metadata

        :param container: container name (Container is equivalent to
                          Bucket term in Amazon).
        """"""
        LOG.debug('stat_container() with %s is success.', self.driver)
        return self.driver.stat_container(container)"
1907,"def update_container(self, container, metadata, **kwargs):
        """"""Update container metadata

        :param container: container name (Container is equivalent to
                          Bucket term in Amazon).
        :param metadata(dict): additional metadata to include in the request.
        :param **kwargs(dict): extend args for specific driver.
        """"""
        LOG.debug('update_object() with %s is success.', self.driver)
        return self.driver.update_container(container, metadata, **kwargs)"
1908,"def upload_object(self, container, obj, contents,
                      content_length=None, metadata=None, **kwargs):
        """"""Upload object

        :param container: container name (Container is equivalent to
                          Bucket term in Amazon).
        :param obj: object name (Object is equivalent to
                    Key term in Amazon).
        :param contents: object content.
        :param content_length(int): content length.
        :param metadata (dict): addition infomation.
        :param **kwargs(dict): extend args for specific driver.
        """"""
        try:
            LOG.debug('upload_object() with %s is success.', self.driver)
            return self.driver.upload_object(container, obj,
                                             contents=contents,
                                             content_length=content_length,
                                             metadata=metadata,
                                             **kwargs)
        except DriverException as e:
            LOG.exception('upload_object() with %s raised\
                            an exception %s.', self.driver, e)"
1909,"def stat_object(self, container, obj):
        """"""Stat object metadata

        :param container: container name (Container is equivalent to
                          Bucket term in Amazon).
        :param obj: object name (Object is equivalent to
                    Key term in Amazon).
        """"""
        LOG.debug('stat_object() with %s is success.', self.driver)
        return self.driver.stat_object(container, obj)"
1910,"def delete_object(self, container, obj, **kwargs):
        """"""Delete object in container

        :param container: container name (Container is equivalent to
                          Bucket term in Amazon).
        :param obj: object name (Object is equivalent to
                    Key term in Amazon).
        """"""
        try:
            LOG.debug('delete_object() with %s is success.', self.driver)
            return self.driver.delete_object(container, obj, **kwargs)
        except DriverException as e:
            LOG.exception('download_object() with %s raised\
                            an exception %s.', self.driver, e)"
1911,"def list_container_objects(self, container, prefix=None, delimiter=None):
        """"""List container objects

        :param container: container name (Container is equivalent to
                          Bucket term in Amazon).
        :param prefix: prefix query
        :param delimiter: string to delimit the queries on
        """"""
        LOG.debug('list_container_objects() with %s is success.', self.driver)
        return self.driver.list_container_objects(container, prefix, delimiter)"
1912,"def update_object(self, container, obj, metadata, **kwargs):
        """"""Update object metadata

        :param container: container name (Container is equivalent to
                          Bucket term in Amazon).
        :param obj: object name (Object is equivalent to
                    Key term in Amazon).
        :param metadata(dict): additional metadata to include in the request.
        """"""
        try:
            LOG.debug('update_object() with %s is success.', self.driver)
            return self.driver.update_object(container, obj,
                                             metadata, **kwargs)
        except DriverException as e:
            LOG.exception('copy_object() with %s raised\
                            an exception %s.', self.driver, e)"
1913,"def copy_object(self, container, obj, metadata=None,
                    destination=None, **kwargs):
        """"""Copy object

        :param container: container name (Container is equivalent to
                          Bucket term in Amazon).
        :param obj: object name (Object is equivalent to
                    Key term in Amazon).
        :param destination: The container and object name of the destination
                            object in the form of /container/object; if None,
                            the copy will use the source as the destination.
        :param metadata(dict): additional metadata(headers)
                               to include in the request
        :param **kwargs(dict): extend args for specific driver.
        """"""
        try:
            LOG.debug('copy_object() with %s is success.', self.driver)
            return self.driver.copy_object(container, obj, metadata=metadata,
                                           destination=destination, **kwargs)
        except DriverException as e:
            LOG.exception('copy_object() with %s raised\
                            an exception %s.', self.driver, e)"
1914,"def permission_required(*actions, obj=None, raise_exception=False):
    """"""Permission checking decorator -- works like the
    ``permission_required`` decorator in the default Django
    authentication system, except that it takes a sequence of actions
    to check, an object must be supplied, and the user must have
    permission to perform all of the actions on the given object for
    the permissions test to pass.  *Not actually sure how useful this
    is going to be: in any case where obj is not None, it's going to
    be tricky to get the object into the decorator.  Class-based views
    are definitely best here...*

    """"""
    def checker(user):
        ok = False
        if user.is_authenticated() and check_perms(user, actions, [obj]):
            ok = True
        if raise_exception and not ok:
            raise PermissionDenied
        else:
            return ok

    def decorator(view_func):
        @wraps(view_func, assigned=available_attrs(view_func))
        def _wrapped_view(request, *args, **kwargs):
            if checker(request.user):
                return view_func(request, *args, **kwargs)
        return _wrapped_view
    return decorator"
1915,"def get_path_fields(cls, base=[]):
    """"""Get object fields used for calculation of django-tutelary object
    paths.

    """"""
    pfs = []
    for pf in cls.TutelaryMeta.path_fields:
        if pf == 'pk':
            pfs.append(base + ['pk'])
        else:
            f = cls._meta.get_field(pf)
            if isinstance(f, models.ForeignKey):
                pfs += get_path_fields(f.target_field.model, base=base + [pf])
            else:
                pfs.append(base + [f.name])
    return pfs"
1916,"def get_perms_object(obj, action):
    """"""Get the django-tutelary path for an object, based on the fields
    listed in ``TutelaryMeta.pfs``.

    """"""
    def get_one(pf):
        if isinstance(pf, str):
            return pf
        else:
            return str(reduce(lambda o, f: getattr(o, f), pf, obj))
    return Object([get_one(pf) for pf in obj.__class__.TutelaryMeta.pfs])"
1917,"def make_get_perms_object(perms_objs):
    """"""Make a function to delegate permission object rendering to some
    other (foreign key) field of an object.

    """"""
    def retfn(obj, action):
        if action in perms_objs:
            if perms_objs[action] is None:
                return None
            else:
                return get_perms_object(getattr(obj, perms_objs[action]),
                                        action)
        else:
            return get_perms_object(obj, action)
    return retfn"
1918,"def permissioned_model(cls, perm_type=None, path_fields=None, actions=None):
    """"""Function to set up a model for permissioning.  Can either be called
    directly, passing a class and suitable values for ``perm_type``,
    ``path_fields`` and ``actions``, or can be used as a class
    decorator, taking values for ``perm_type``, ``path_fields`` and
    ``actions`` from the ``TutelaryMeta`` subclass of the decorated
    class.

    """"""
    if not issubclass(cls, models.Model):
        raise DecoratorException(
            'permissioned_model',
            ""class '"" + cls.__name__ + ""' is not a Django model""
        )
    added = False
    try:
        if not hasattr(cls, 'TutelaryMeta'):
            if perm_type is None or path_fields is None or actions is None:
                raise DecoratorException(
                    'permissioned_model',
                    (""missing argument: all of perm_type, path_fields and "" +
                     ""actions must be supplied"")
                )
            added = True
            cls.TutelaryMeta = type('TutelaryMeta', (object,),
                                    dict(perm_type=perm_type,
                                         path_fields=path_fields,
                                         actions=actions))
        cls.TutelaryMeta.pfs = ([cls.TutelaryMeta.perm_type] +
                                get_path_fields(cls))
        perms_objs = {}
        for a in cls.TutelaryMeta.actions:
            an = a
            ap = {}
            if isinstance(a, tuple):
                an = a[0]
                ap = a[1]
            Action.register(an)
            if isinstance(ap, dict) and 'permissions_object' in ap:
                po = ap['permissions_object']
                if po is not None:
                    try:
                        t = cls._meta.get_field(po).__class__
                        if t not in [models.ForeignKey,
                                     models.OneToOneField]:
                            raise PermissionObjectException(po)
                    except:
                        raise PermissionObjectException(po)
                perms_objs[an] = po
        if len(perms_objs) == 0:
            cls.get_permissions_object = get_perms_object
        else:
            cls.get_permissions_object = make_get_perms_object(perms_objs)
        return cls
    except:
        if added:
            del cls.TutelaryMeta
        raise"
1919,"def _getArrays(items, attr, defaultValue):
    """"""Return arrays with equal size of item attributes from a list of sorted
    ""items"" for fast and convenient data processing.

    :param attr: list of item attributes that should be added to the returned
        array.
    :param defaultValue: if an item is missing an attribute, the ""defaultValue""
        is added to the array instead.

    :returns: {'attribute1': numpy.array([attributeValue1, ...]), ...}
    """"""
    arrays = dict([(key, []) for key in attr])
    for item in items:
        for key in attr:
            arrays[key].append(getattr(item, key, defaultValue))
    for key in [_ for _ in viewkeys(arrays)]:
        arrays[key] = numpy.array(arrays[key])

    return arrays"
1920,"def _getItems(container, containerKeys=None, sort=False, reverse=False,
              selector=lambda item: True):
    """"""Generator that yields filtered and/or sorted items from the specified
    ""container"".

    :param container: The container has to be a dictionary of dictionaries that
        contain some kind of items. Depending on the specified parameters all or
        a subset of these items are yielded.
        ``{containerKey1: {key1: item1, key2: item2, ...}, ...}``
    :param containerKeys: valid keys of the ""container"", if None all keys are
        considered.
    :type containerKeys: a single dictionary key or a list of keys
    :param sort: if ""sort"" is specified the returned list of items is sorted
        according to the item attribute specified by ""sort"", if the attribute is
        not present the item is skipped.
    :param reverse: bool, ``True`` reverses the sort order
    :param selector: a function which is called with each item and returns
        True (include item) or False (discard item). If not specified all items
        are returned

    :returns: items from container that passed the selector function
    """"""
    if containerKeys is None:
        containerKeys = [_ for _ in viewkeys(container)]
    else:
        containerKeys = aux.toList(containerKeys)

    if sort:
        sortIdentifier = list()
        for containerKey in containerKeys:
            for identifier in [_ for _ in viewkeys(container[containerKey])]:
                item = container[containerKey][identifier]
                if selector(item):
                    try:
                        sortIdentifier.append((getattr(item, sort),
                                               containerKey, identifier
                                               )
                                              )
                    except AttributeError:
                        pass
        sortIdentifier.sort(key=ITEMGETTER(0), reverse=reverse)
        for _, containerKey, identifier in sortIdentifier:
            yield container[containerKey][identifier]
    else:
        for containerKey in containerKeys:
            for identifier in [_ for _ in viewkeys(container[containerKey])]:
                item = container[containerKey][identifier]
                if selector(item):
                    yield item"
1921,"def _containerSetPath(container, folderpath, specfiles):
    """"""Helper function for :class:`MsrunContainer`, :class:`SiiContainer` and
    :class:`FiContainer`. Changes the folderpath of the specified specfiles in
    container.info: ``container.info[specfile]['path'] = folderpath``.

    :param container: a container like class that has an attribute ``.info``
    :param folderpath: a filedirectory
    :param specfiles: a list of ms-run names
    """"""
    if not os.path.exists(folderpath):
        warntext = 'Error while calling ""_containerSetPath()"": The specified '\
                   'directory ""%s"" does not exist!' %(folderpath, )
        warnings.warn(warntext)
    for specfile in specfiles:
        if specfile in container.info:
            container.info[specfile]['path'] = folderpath
        else:
            warntext = 'Error while calling ""_containerSetPath()"": The '\
                       'specfile ""%s"" is not present in the container!'\
                       %(specfile, )
            warnings.warn(warntext)"
1922,"def _mzmlListAttribToTuple(oldList):
    """"""Turns the param entries of elements in a list elements into tuples, used
    in :func:`MzmlScan._fromJSON()` and :func:`MzmlPrecursor._fromJSON()`.

    .. note:: only intended for a list of elements that contain params. For
        example the mzML element ``selectedIonList`` or ``scanWindowList``.

    :param oldList: [[paramList, paramList, ...], ...]

    :returns: [[paramTuple, paramTuple, ...], ...]
    """"""
    newList = list()
    for oldParamList in oldList:
        newParamLIst = [tuple(param) for param in oldParamList]
        newList.append(newParamLIst)
    return newList"
1923,"def addMsrunContainers(mainContainer, subContainer):
    """"""Adds the complete content of all specfile entries from the subContainer
    to the mainContainer. However if a specfile of ``subContainer.info`` is
    already present in ``mainContainer.info`` its contents are not added to the
    mainContainer.

    :param mainContainer: :class:`MsrunContainer`
    :param subContainer: :class:`MsrunContainer`

    .. warning:: does not generate new items, all items added to the
        ``mainContainer`` are still present in the ``subContainer`` and changes
        made to elements of one container also affects the elements of the other
        one (ie elements share same memory location).
    """"""
    typeToContainer = {'rm': 'rmc', 'ci': 'cic', 'smi': 'smic',
                       'sai': 'saic', 'si': 'sic'
                       }
    for specfile in subContainer.info:
        if specfile in mainContainer.info:
            continue

        mainContainer.addSpecfile(specfile, subContainer.info[specfile]['path'])
        for datatype, status in listitems(subContainer.info[specfile]['status']):
            if not status:
                continue
            datatypeContainer = typeToContainer[datatype]
            dataTypeContainer = getattr(mainContainer, datatypeContainer)
            subContainerData = getattr(subContainer,
                                       datatypeContainer
                                       )[specfile]
            dataTypeContainer[specfile] = subContainerData
            mainContainer.info[specfile]['status'][datatype] = True"
1924,"def getArrays(self, attr=None, specfiles=None, sort=False, reverse=False,
                  selector=None, defaultValue=None):
        """"""Return a condensed array of data selected from :class:`Si` instances
        from ``self.sic`` for fast and convenient data processing.

        :param attr: list of :class:`Si` item attributes that should be added to
            the returned array. The attributes ""id"" and ""specfile"" are always
            included, in combination they serve as a unique id.
        :param defaultValue: if an item is missing an attribute, the
            ""defaultValue"" is added to the array instead.
        :param specfiles: filenames of ms-run files, if specified return only
            items from those files
        :type specfiles: str or [str, str, ...]
        :param sort: if ""sort"" is specified the returned list of items is sorted
            according to the :class:`Si` attribute specified by ""sort"", if the
            attribute is not present the item is skipped.
        :param reverse: bool, set True to reverse sort order
        :param selector: a function which is called with each :class:`Si` item
            and has to return True (include item) or False (discard item).
            Default function is: ``lambda si: True``

        :returns: {'attribute1': numpy.array(),
                   'attribute2': numpy.array(),
                   ...
                   }
        """"""
        selector = (lambda si: True) if selector is None else selector
        attr = attr if attr is not None else []
        attr = set(['id', 'specfile'] + aux.toList(attr))
        items = self.getItems(specfiles, sort, reverse, selector)
        return _getArrays(items, attr, defaultValue)"
1925,"def getItems(self, specfiles=None, sort=False, reverse=False,
                 selector=None):
        """"""Generator that yields filtered and/or sorted :class:`Si` instances
        from ``self.sic``.

        :param specfiles: filenames of ms-run files - if specified return only
            items from those files
        :type specfiles: str or [str, str, ...]
        :param sort: if ""sort"" is specified the returned list of items is sorted
            according to the :class:`Si` attribute specified by ""sort"", if the
            attribute is not present the item is skipped.
        :param reverse: bool, ``True`` reverses the sort order
        :param selector: a function which is called with each ``Si`` item
            and returns True (include item) or False (discard item). Default
            function is: ``lambda si: True``

        :returns: items from container that passed the selector function
        """"""
        selector = (lambda si: True) if selector is None else selector
        if specfiles is None:
            specfiles = [_ for _ in viewkeys(self.info)]
        else:
            specfiles = aux.toList(specfiles)
        return _getItems(self.sic, specfiles, sort, reverse, selector)"
1926,"def addSpecfile(self, specfiles, path):
        """"""Prepares the container for loading ``mrc`` files by adding specfile
        entries to ``self.info``. Use :func:`MsrunContainer.load()` afterwards
        to actually import the files

        :param specfiles: the name of an ms-run file or a list of names
        :type specfiles: str or [str, str, ...]
        :param path: filedirectory used for loading and saving ``mrc`` files
        """"""
        for specfile in aux.toList(specfiles):
            if specfile not in self.info:
                self._addSpecfile(specfile, path)
            else:
                warntext = 'Error while calling ""MsrunContainer.addSpecfile()""'\
                           ': ""%s"" is already present ""MsrunContainer.info""'\
                            % (specfile, )
                warnings.warn(warntext)"
1927,"def _addSpecfile(self, specfile, path):
        """"""Adds a new specfile entry to MsrunContainer.info. See also
        :class:`MsrunContainer.addSpecfile()`.

        :param specfile: the name of an ms-run file
        :param path: filedirectory used for loading and saving ``mrc`` files
        """"""
        datatypeStatus = {'rm': False, 'ci': False, 'smi': False, 'sai': False,
                          'si': False
                          }
        self.info[specfile] = {'path': path, 'status': datatypeStatus}"
1928,"def setPath(self, folderpath, specfiles=None):
        """"""Changes the folderpath of the specified specfiles. The folderpath is
        used for saving and loading of ``mrc`` files.

        :param specfiles: the name of an ms-run file or a list of names. If None
            all specfiles are selected.
        :type specfiles: None, str, [str, str]
        :param folderpath: a filedirectory
        """"""
        if specfiles is None:
            specfiles = [_ for _ in viewkeys(self.info)]
        else:
            specfiles = aux.toList(specfiles)

        _containerSetPath(self, folderpath, specfiles)"
1929,"def removeData(self, specfiles=None, rm=False, ci=False, smi=False,
                   sai=False, si=False):
        """"""Removes the specified datatypes of the specfiles from the
        msrunContainer. To completely remove a specfile use
        :func:`MsrunContainer.removeSpecfile`, which also removes the complete
        entry from ``self.info``.

        :param specfiles: the name of an ms-run file or a list of names. If None
            all specfiles are selected.
        :type specfiles: None, str, [str, str]
        :param rm: bool, True to select ``self.rmc``
        :param ci: bool, True to select ``self.cic``
        :param smi: bool, True to select ``self.smic``
        :param sai: bool, True to select ``self.saic``
        :param si: bool, True to select ``self.sic``
        """"""
        if specfiles is None:
            specfiles = [_ for _ in viewkeys(self.info)]
        else:
            specfiles = aux.toList(specfiles)
        #TODO: add a check if specfiles are present in the container
        typeToContainer = {'rm': 'rmc', 'ci': 'cic', 'smi': 'smic',
                           'sai': 'saic', 'si': 'sic'
                           }
        datatypes = self._processDatatypes(rm, ci, smi, sai, si)
        for specfile in specfiles:
            for datatype in datatypes:
                datatypeContainer = typeToContainer[datatype]
                dataContainer = getattr(self, datatypeContainer)
                try:
                    del dataContainer[specfile]
                except KeyError:
                    pass
                finally:
                    self.info[specfile]['status'][datatype] = False"
1930,"def removeSpecfile(self, specfiles):
        """"""Completely removes the specified specfiles from the
        ``msrunContainer``.

        :param specfiles: the name of an ms-run file or a list of names. If None
            all specfiles are selected.
        :type specfiles: str, [str, str]
        """"""
        for specfile in aux.toList(specfiles):
            for datatypeContainer in ['rmc', 'cic', 'smic', 'saic', 'sic']:
                dataContainer = getattr(self, datatypeContainer)
                try:
                    del dataContainer[specfile]
                except KeyError:
                    pass
            del self.info[specfile]"
1931,"def _processDatatypes(self, rm, ci, smi, sai, si):
        """"""Helper function that returns a list of datatype strings, depending
        on the parameters boolean value.

        :param rm: bool, True to add ``rm``
        :param ci: bool, True to add ``ci``
        :param smi: bool, True to add ``smi``
        :param sai: bool, True to add ``sai``
        :param si: bool, True to add ``si``

        :returns: [datatype1, ...]
        """"""
        datatypes = list()
        for datatype, value in [('rm', rm), ('ci', ci), ('smi', smi),
                                ('sai', sai), ('si', si)]:
            if value:
                datatypes.append(datatype)
        return datatypes"
1932,"def save(self, specfiles=None, rm=False, ci=False, smi=False, sai=False,
             si=False, compress=True, path=None):
        """"""Writes the specified datatypes to ``mrc`` files on the hard disk.

        .. note::
            If ``.save()`` is called and no ``mrc`` files are present in the
            specified path new files are generated, otherwise old files are
            replaced.

        :param specfiles: the name of an ms-run file or a list of names. If None
            all specfiles are selected.
        :type specfiles: None, str, [str, str]
        :param rm: bool, True to select ``self.rmc`` (run metadata)
        :param ci: bool, True to select ``self.cic`` (chromatogram items)
        :param smi: bool, True to select ``self.smic`` (spectrum metadata items)
        :param sai: bool, True to select ``self.saic`` (spectrum array items)
        :param si: bool, True to select ``self.sic`` (spectrum items)
        :param compress: bool, True to use zip file compression
        :param path: filedirectory to which the ``mrc`` files are written. By
            default the parameter is set to ``None`` and the filedirectory is
            read from ``self.info[specfile]['path']``
        """"""
        if specfiles is None:
            specfiles = [_ for _ in viewkeys(self.info)]
        else:
            specfiles = aux.toList(specfiles)
        datatypes = self._processDatatypes(rm, ci, smi, sai, si)
        if len(datatypes) == 0:
            datatypes = ['rm', 'ci', 'smi', 'sai', 'si']

        for specfile in specfiles:
            if specfile not in self.info:
                warntext = 'Error while calling ""MsrunContainer.save()"": ""%s"" '\
                           'is not present in ""MsrunContainer.info""!'\
                            % (specfile, )
                warnings.warn(warntext)
                continue
            else:
                msrunInfo = self.info[specfile]
                specfilePath = msrunInfo['path'] if path is None else path

            with aux.PartiallySafeReplace() as msr:
                for datatype in datatypes:
                    filename = specfile + '.mrc_' + datatype
                    filepath = aux.joinpath(specfilePath, filename)
                    with msr.open(filepath, 'w+b') as openfile:
                        if datatype == 'rm':
                           self._writeRmc(openfile, specfile)
                        elif datatype == 'ci':
                           self._writeCic(openfile, specfile, compress)
                        elif datatype == 'si':
                           self._writeSic(openfile, specfile, compress)
                        elif datatype == 'smi':
                           self._writeSmic(openfile, specfile, compress)
                        elif datatype == 'sai':
                           self._writeSaic(openfile, specfile, compress)"
1933,"def _writeCic(self, filelike, specfile, compress):
        """"""Writes the ``.cic`` container entry of the specified specfile to the
        ``mrc_cic`` format. For details see
         :func:`maspy.auxiliary.writeBinaryItemContainer()`

        :param filelike: path to a file (str) or a file-like object
        :param specfile: name of an ms-run file present in ``self.info``
        :param compress: bool, True to use zip file compression
        """"""
        aux.writeBinaryItemContainer(filelike, self.cic[specfile], compress)"
1934,"def _writeSaic(self, filelike, specfile, compress):
        """"""Writes the ``.ssic`` container entry of the specified specfile to the
        ``mrc_saic`` format. For details see
         :func:`maspy.auxiliary.writeBinaryItemContainer()`

        :param filelike: path to a file (str) or a file-like object
        :param specfile: name of an ms-run file present in ``self.info``
        :param compress: bool, True to use zip file compression
        """"""
        aux.writeBinaryItemContainer(filelike, self.saic[specfile], compress)"
1935,"def _writeSmic(self, filelike, specfile, compress):
        """"""Writes the ``.smic`` container entry of the specified specfile to the
        ``mrc_smic`` format. For details see
         :func:`maspy.auxiliary.writeJsonZipfile()`

        :param filelike: path to a file (str) or a file-like object
        :param specfile: name of an ms-run file present in ``self.info``
        :param compress: bool, True to use zip file compression
        """"""
        aux.writeJsonZipfile(filelike, self.smic[specfile], compress)"
1936,"def _writeSic(self, filelike, specfile, compress):
        """"""Writes the ``.sic`` container entry of the specified specfile to the
        ``mrc_sic`` format. For details see
         :func:`maspy.auxiliary.writeJsonZipfile()`

        :param filelike: path to a file (str) or a file-like object
        :param specfile: name of an ms-run file present in ``self.info``
        :param compress: bool, True to use zip file compression
        """"""
        aux.writeJsonZipfile(filelike, self.sic[specfile], compress)"
1937,"def _writeRmc(self, filelike, specfile):
        """"""Writes the ``.rmc`` container entry of the specified specfile as an
        human readable and pretty formatted xml string.

        :param filelike: path to a file (str) or a file-like object
        :param specfile: name of an ms-run file present in ``self.info``
        """"""
        xmlString = ETREE.tostring(self.rmc[specfile], pretty_print=True)
        filelike.write(xmlString)"
1938,"def load(self, specfiles=None, rm=False, ci=False, smi=False, sai=False,
             si=False):
        """"""Import the specified datatypes from ``mrc`` files on the hard disk.

        :param specfiles: the name of an ms-run file or a list of names. If None
            all specfiles are selected.
        :type specfiles: None, str, [str, str]
        :param rm: bool, True to import ``mrc_rm`` (run metadata)
        :param ci: bool, True to import ``mrc_ci`` (chromatogram items)
        :param smi: bool, True to import ``mrc_smi`` (spectrum metadata items)
        :param sai: bool, True to import ``mrc_sai`` (spectrum array items)
        :param si: bool, True to import ``mrc_si`` (spectrum items)
        """"""
        if specfiles is None:
            specfiles = [_ for _ in viewkeys(self.info)]
        else:
            specfiles = aux.toList(specfiles)

        #Select only specfiles which are present in the ``self.info``.
        selectedSpecfiles = list()
        for specfile in specfiles:
            if specfile not in self.info:
                warntext = 'Error while calling ""MsrunContainer.load()"": ""%s"" '\
                           'not present in MsrunContainer.info' % specfile
                warnings.warn(warntext)
            else:
                selectedSpecfiles.append(specfile)

        datatypes = self._processDatatypes(rm, ci, smi, sai, si)
        if len(datatypes) == 0:
            datatypes = ['rm', 'ci', 'smi', 'sai', 'si']

        for specfile in selectedSpecfiles:
            msrunInfo = self.info[specfile]
            specfilePath = msrunInfo['path']

            if 'rm' in datatypes:
                rmPath = aux.joinpath(specfilePath, specfile+'.mrc_rm')
                with open(rmPath, 'rb') as openfile:
                    xmlString = openfile.read()
                self.rmc[specfile] = ETREE.fromstring(xmlString)
                msrunInfo['status']['rm'] = True

            if 'ci' in datatypes:
                ciPath = aux.joinpath(specfilePath, specfile+'.mrc_ci')
                self.cic[specfile] = aux.loadBinaryItemContainer(ciPath,
                                                                 Ci.jsonHook)
                msrunInfo['status']['ci'] = True

            if 'smi' in datatypes:
                smiPath = aux.joinpath(specfilePath, specfile+'.mrc_smi')
                with zipfile.ZipFile(smiPath, 'r') as containerZip:
                    #Convert the zipfile data into a str object,necessary since
                    #containerZip.read() returns a bytes object.
                    jsonString = io.TextIOWrapper(containerZip.open('data'),
                                                  encoding='utf-8'
                                                  ).read()
                self.smic[specfile] = json.loads(jsonString,
                                                 object_hook=Smi.jsonHook
                                                 )
                msrunInfo['status']['smi'] = True

            if 'sai' in datatypes:
                saiPath = aux.joinpath(specfilePath, specfile+'.mrc_sai')
                self.saic[specfile] = aux.loadBinaryItemContainer(saiPath,
                                                                  Sai.jsonHook
                                                                  )
                msrunInfo['status']['sai'] = True

            if 'si' in datatypes:
                siPath = aux.joinpath(specfilePath, specfile+'.mrc_si')
                with zipfile.ZipFile(siPath, 'r') as containerZip:
                    #Convert the zipfile data into a str object, necessary since
                    #containerZip.read() returns a bytes object.
                    jsonString = io.TextIOWrapper(containerZip.open('data'),
                                                  encoding='utf-8'
                                                  ).read()
                self.sic[specfile] = json.loads(jsonString,
                                                object_hook=Si.jsonHook
                                                )
                msrunInfo['status']['si'] = True"
1939,"def _reprJSON(self):
        """"""Returns a JSON serializable represenation of a ``Ci`` class instance.
        Use :func:`maspy.core.Ci._fromJSON()` to generate a new ``Ci`` instance
        from the return value.

        :returns: a JSON serializable python object
        """"""
        return {'__Ci__': (self.id, self.specfile, self.dataProcessingRef,
                           self.precursor, self.product, self.params,
                           self.attrib, self.arrayInfo
                           )
                }"
1940,"def _fromJSON(cls, jsonobject):
        """"""Generates a new instance of :class:`maspy.core.Ci` from a decoded
        JSON object (as generated by :func:`maspy.core.Ci._reprJSON()`).

        :param jsonobject: decoded JSON object

        :returns: a new instance of :class:`Ci`
        """"""
        newInstance = cls(jsonobject[0], jsonobject[1])
        attribDict = {}
        attribDict['dataProcessingRef'] = jsonobject[2]
        attribDict['precursor'] = jsonobject[3]
        attribDict['product'] = jsonobject[4]
        attribDict['params'] = [tuple(param) for param in jsonobject[5]]
        attribDict['attrib'] = jsonobject[6]
        attribDict['arrayInfo'] = dict()
        for arrayType, jsonEntry in viewitems(jsonobject[7]):
            arrayEntry = {'dataProcessingRef': jsonEntry['dataProcessingRef'],
                          'params': [tuple(_) for _ in jsonEntry['params']]
                          }
            attribDict['arrayInfo'][arrayType] = arrayEntry
        for key, value in viewitems(attribDict):
            setattr(newInstance, key, value)
        return newInstance"
1941,"def jsonHook(encoded):
        """"""Custom JSON decoder that allows construction of a new ``Ci`` instance
        from a decoded JSON object.

        :param encoded: a JSON decoded object literal (a dict)

        :returns: ""encoded"" or one of the these objects: :class:`Ci`,
            :class:`MzmlProduct`, :class:`MzmlPrecursor`
        """"""
        if '__Ci__' in encoded:
            return Ci._fromJSON(encoded['__Ci__'])
        elif '__MzmlProduct__' in encoded:
            return MzmlProduct._fromJSON(encoded['__MzmlProduct__'])
        elif '__MzmlPrecursor__' in encoded:
            return MzmlPrecursor._fromJSON(encoded['__MzmlPrecursor__'])
        else:
            return encoded"
1942,"def _fromJSON(cls, jsonobject):
        """"""Generates a new instance of :class:`maspy.core.Sai` from a decoded
        JSON object (as generated by :func:`maspy.core.Sai._reprJSON()`).

        :param jsonobject: decoded JSON object

        :returns: a new instance of :class:`Sai`
        """"""
        newInstance = cls(jsonobject[0], jsonobject[1])
        for arrayType, jsonEntry in viewitems(jsonobject[2]):
            arrayEntry = {'dataProcessingRef': jsonEntry['dataProcessingRef'],
                          'params': [tuple(_) for _ in jsonEntry['params']]
                          }
            newInstance.arrayInfo[arrayType] = arrayEntry

        return newInstance"
1943,"def _reprJSON(self):
        """"""Returns a JSON serializable represenation of a ``Smi`` class
        instance. Use :func:`maspy.core.Sai._fromJSON()` to generate a new
        ``Smi`` instance from the return value.

        :returns: a JSON serializable python object
        """"""
        return {'__Smi__': (self.id, self.specfile, self.attributes,
                            self.params, self.scanListParams, self.scanList,
                            self.precursorList, self.productList
                            )
                }"
1944,"def _fromJSON(cls, jsonobject):
        """"""Generates a new instance of :class:`maspy.core.Smi` from a decoded
        JSON object (as generated by :func:`maspy.core.Smi._reprJSON()`).

        :param jsonobject: decoded JSON object

        :returns: a new instance of :class:`Smi`
        """"""
        newInstance = cls(None, None)
        attribDict = {}
        attribDict['id'] = jsonobject[0]
        attribDict['specfile'] = jsonobject[1]
        attribDict['attributes'] = jsonobject[2]
        attribDict['params'] = [tuple(param) for param in jsonobject[3]]
        attribDict['scanListParams'] = [tuple(param) for param in jsonobject[4]]
        attribDict['scanList'] = jsonobject[5]
        attribDict['precursorList'] = jsonobject[6]
        attribDict['productList'] = jsonobject[7]
        for key, value in viewitems(attribDict):
            setattr(newInstance, key, value)
        return newInstance"
1945,"def jsonHook(encoded):
        """"""Custom JSON decoder that allows construction of a new ``Smi``
        instance from a decoded JSON object.

        :param encoded: a JSON decoded object literal (a dict)

        :returns: ""encoded"" or one of the these objects: :class:`Smi`,
            :class:`MzmlScan`, :class:`MzmlProduct`, :class:`MzmlPrecursor`
        """"""
        if '__Smi__' in encoded:
            return Smi._fromJSON(encoded['__Smi__'])
        elif '__MzmlScan__' in encoded:
            return MzmlScan._fromJSON(encoded['__MzmlScan__'])
        elif '__MzmlProduct__' in encoded:
            return MzmlProduct._fromJSON(encoded['__MzmlProduct__'])
        elif '__MzmlPrecursor__' in encoded:
            return MzmlPrecursor._fromJSON(encoded['__MzmlPrecursor__'])
        else:
            return encoded"
1946,"def _fromJSON(cls, jsonobject):
        """"""Generates a new instance of :class:`maspy.core.Si` from a decoded
        JSON object (as generated by :func:`maspy.core.Si._reprJSON()`).

        :param jsonobject: decoded JSON object

        :returns: a new instance of :class:`Si`
        """"""
        newInstance = cls(None, None)
        newInstance.__dict__.update(jsonobject)
        return newInstance"
1947,"def _fromJSON(cls, jsonobject):
        """"""Generates a new instance of :class:`maspy.core.MzmlScan` from a
        decoded JSON object (as generated by
        :func:`maspy.core.MzmlScan._reprJSON()`).

        :param jsonobject: decoded JSON object

        :returns: a new instance of :class:`MzmlScan`
        """"""
        scanWindowList = _mzmlListAttribToTuple(jsonobject[0])
        params = [tuple(param) for param in jsonobject[1]]
        return cls(scanWindowList, params)"
1948,"def _fromJSON(cls, jsonobject):
        """"""Generates a new instance of :class:`maspy.core.MzmlProduct` from a
        decoded JSON object (as generated by
        :func:`maspy.core.MzmlProduct._reprJSON()`).

        :param jsonobject: decoded JSON object

        :returns: a new instance of :class:`MzmlProduct`
        """"""
        isolationWindow =[tuple(param) for param in jsonobject]
        return cls(isolationWindow)"
1949,"def _reprJSON(self):
        """"""Returns a JSON serializable represenation of a ``MzmlPrecursor``
        class instance. Use :func:`maspy.core.MzmlPrecursor._fromJSON()` to
        generate a new ``MzmlPrecursor`` instance from the return value.

        :returns: a JSON serializable python object
        """"""
        return {'__MzmlPrecursor__': (self.spectrumRef, self.activation,
                                      self.isolationWindow, self.selectedIonList
                                      )
                }"
1950,"def _fromJSON(cls, jsonobject):
        """"""Generates a new instance of :class:`maspy.core.MzmlPrecursor` from a
        decoded JSON object (as generated by
        :func:`maspy.core.MzmlPrecursor._reprJSON()`).

        :param jsonobject: decoded JSON object

        :returns: a new instance of :class:`MzmlPrecursor`
        """"""
        spectrumRef = jsonobject[0]
        activation = [tuple(param) for param in jsonobject[1]]
        isolationWindow =[tuple(param) for param in jsonobject[2]]
        selectedIonList = _mzmlListAttribToTuple(jsonobject[3])
        return cls(spectrumRef, activation, isolationWindow, selectedIonList)"
1951,"def getItems(self, specfiles=None, sort=False, reverse=False,
                 selector=None):
        """"""Generator that yields filtered and/or sorted :class:`Sii` instances
        from ``self.container``.

        :param specfiles: filenames of ms-run files - if specified return only
            items from those files
        :type specfiles: str or [str, str, ...]
        :param sort: if ""sort"" is specified the returned list of items is sorted
            according to the :class:`Sii` attribute specified by ""sort"", if the
            attribute is not present the item is skipped.
        :param reverse: bool, ``True`` reverses the sort order
        :param selector: a function which is called with each ``Sii`` item and
            has to return True (include item) or False (discard item). By
            default only items with ``Sii.isValid == True`` are returned.

        :returns: items from container that passed the selector function
        """"""
        selector = (lambda sii: sii.isValid) if selector is None else selector
        if specfiles is None:
            specfiles = [_ for _ in viewkeys(self.info)]
        else:
            specfiles = aux.toList(specfiles)
        return _getListItems(self.container, specfiles, sort, reverse, selector)"
1952,"def getValidItem(self, specfile, identifier):
        """"""Returns a ``Sii`` instance from ``self.container`` if it is valid,
        if all elements of ``self.container[specfile][identifier] are
        ``Sii.isValid == False`` then ``None`` is returned.

        :param specfile: a ms-run file name
        :param identifier: item identifier ``Sii.id``

        :returns: ``Sii`` or ``None``
        """"""
        for item in self.container[specfile][identifier]:
            if item.isValid:
                return item
        else:
            return None"
1953,"def _addSpecfile(self, specfile, path):
        """"""Adds a new specfile entry to SiiContainer.info. See also
        :class:`SiiContainer.addSpecfile()`.

        :param specfile: the name of an ms-run file
        :param path: filedirectory for loading and saving the ``siic`` files
        """"""
        self.info[specfile] = {'path': path, 'qcAttr': None, 'qcCutoff': None,
                               'qcLargerBetter': None, 'rankAttr': None,
                               'rankLargerBetter': None
                               }
        self.container[specfile] = dict()"
1954,"def removeSpecfile(self, specfiles):
        """"""Completely removes the specified specfiles from the ``SiiContainer``.

        :param specfiles: the name of an ms-run file or a list of names.
        """"""
        for specfile in aux.toList(specfiles):
            del self.container[specfile]
            del self.info[specfile]"
1955,"def save(self, specfiles=None, compress=True, path=None):
        """"""Writes the specified specfiles to ``siic`` files on the hard disk.

        .. note::
            If ``.save()`` is called and no ``siic`` files are present in the
            specified path new files are generated, otherwise old files are
            replaced.

        :param specfiles: the name of an ms-run file or a list of names. If None
            all specfiles are selected.
        :param compress: bool, True to use zip file compression
        :param path: filedirectory to which the ``siic`` files are written. By
            default the parameter is set to ``None`` and the filedirectory is
            read from ``self.info[specfile]['path']``
        """"""
        if specfiles is None:
            specfiles = [_ for _ in viewkeys(self.info)]
        else:
            specfiles = aux.toList(specfiles)

        for specfile in specfiles:
            if specfile not in self.info:
                warntext = 'Error while calling ""SiiContainer.save()"": ""%s"" is'\
                           ' not present in ""SiiContainer.info""!'\
                            % (specfile, )
                warnings.warn(warntext)
                continue
            else:
                path = self.info[specfile]['path'] if path is None else path

            with aux.PartiallySafeReplace() as msr:
                filename = specfile + '.siic'
                filepath = aux.joinpath(path, filename)
                with msr.open(filepath, mode='w+b') as openfile:
                    self._writeContainer(openfile, specfile, compress)"
1956,"def addSiInfo(self, msrunContainer, specfiles=None,
                  attributes=['obsMz', 'rt', 'charge']):
        """"""Transfer attributes to :class:`Sii` elements from the corresponding
        :class`Si` in :class:`MsrunContainer.sic <MsrunContainer>`. If an
        attribute is not present in the ``Si`` the attribute value in the
        ``Sii``is set to ``None``.

        Attribute examples: 'obsMz', 'rt', 'charge', 'tic', 'iit', 'ms1Id'

        :param msrunContainer: an instance of :class:`MsrunContainer` which has
            imported the corresponding specfiles
        :param specfiles: the name of an ms-run file or a list of names. If None
            all specfiles are selected.
        :param attributes: a list of ``Si`` attributes that should be
            transfered.
        """"""
        if specfiles is None:
            specfiles = [_ for _ in viewkeys(self.info)]
        else:
            specfiles = aux.toList(specfiles)

        for specfile in specfiles:
            if specfile not in self.info:
                warntext = 'Error while calling ""SiiContainer.addSiInfo()"": '\
                           '""%s"" is not present in ""SiiContainer.info""!'\
                            % (specfile, )
                warnings.warn(warntext)
            elif specfile not in msrunContainer.info:
                warntext = 'Error while calling ""SiiContainer.addSiInfo()"": '\
                           '""%s"" is not present in ""MsrunContainer.info""'\
                            % (specfile, )
                warnings.warn(warntext)
            else:
                for identifier in self.container[specfile]:
                    si = msrunContainer.sic[specfile][identifier]
                    for sii in self.container[specfile][identifier]:
                        for attribute in attributes:
                            setattr(sii, attribute,
                                    getattr(si, attribute, None)
                                    )"
1957,"def calcMz(self, specfiles=None, guessCharge=True, obsMzKey='obsMz'):
        """"""Calculate the exact mass for ``Sii`` elements from the
        ``Sii.peptide`` sequence.

        :param specfiles: the name of an ms-run file or a list of names. If None
            all specfiles are selected.
        :param guessCharge: bool, True if the charge should be guessed if the
            attribute ``charge`` is missing from ``Sii``. Uses the calculated
            peptide mass and the observed m/z value to calculate the charge.
        :param obsMzKey: attribute name of the observed m/z value in ``Sii``.
        """"""
        #TODO: important to test function, since changes were made
        _calcMass = maspy.peptidemethods.calcPeptideMass
        _calcMzFromMass = maspy.peptidemethods.calcMzFromMass
        _massProton = maspy.constants.atomicMassProton
        _guessCharge = lambda mass, mz: round(mass / (mz - _massProton), 0)

        if specfiles is None:
            specfiles = [_ for _ in viewkeys(self.info)]
        else:
            specfiles = aux.toList(specfiles)

        tempMasses = dict()
        for specfile in specfiles:
            if specfile not in self.info:
                warntext = 'Error while calling ""SiiContainer.calcMz()"": '\
                           '""%s"" is not present in ""SiiContainer.info""!'\
                            % (specfile, )
                warnings.warn(warntext)
            else:
                for sii in self.getItems(specfiles=specfile):
                    peptide = sii.peptide
                    if peptide not in tempMasses:
                        if hasattr(sii, 'diPeptide'):
                            tempMasses[peptide] = (_calcMass(sii.peptide1) +
                                                   _calcMass(sii.peptide2)
                                                   )
                        else:
                            tempMasses[peptide] = _calcMass(peptide)
                    peptideMass = tempMasses[peptide]
                    if sii.charge is not None:
                        sii.excMz = _calcMzFromMass(peptideMass, sii.charge)
                    elif guessCharge:
                        guessedCharge = _guessCharge(peptideMass,
                                                     getattr(sii, obsMzKey)
                                                     )
                        sii.excMz = _calcMzFromMass(peptideMass, guessedCharge)
                        sii.charge = guessedCharge
                    else:
                        sii.excMz = None
        del(tempMasses)"
1958,"def getArrays(self, attr=None, specfiles=None, sort=False, reverse=False,
                  selector=None, defaultValue=None):
        """"""Return a condensed array of data selected from :class:`Fi` instances
        from ``self.container`` for fast and convenient data processing.

        :param attr: list of :class:`Fi` item attributes that should be added
            to the returned array. The attributes ""id"" and ""specfile"" are always
            included, in combination they serve as a unique id.
        :param defaultValue: if an item is missing an attribute, the
            ""defaultValue"" is added to the array instead.
        :param specfiles: filenames of ms-run files - if specified return only
            items from those files
        :type specfiles: str or [str, str, ...]
        :param sort: if ""sort"" is specified the returned list of items is sorted
            according to the :class:`Fi` attribute specified by ""sort"", if the
            attribute is not present the item is skipped.
        :param reverse: bool, set True to reverse sort order
        :param selector: a function which is called with each `Fi` item and has
            to return True (include item) or False (discard item).
            Default function is: ``lambda si: True``. By default only items with
            ``Fi.isValid == True`` are returned.

        :returns: {'attribute1': numpy.array(),
                   'attribute2': numpy.array(),
                   ...
                   }
        """"""
        selector = (lambda fi: fi.isValid) if selector is None else selector
        attr = attr if attr is not None else []
        attr = set(['id', 'specfile'] + aux.toList(attr))
        items = self.getItems(specfiles, sort, reverse, selector)
        return _getArrays(items, attr, defaultValue)"
1959,"def getItems(self, specfiles=None, sort=False, reverse=False,
                 selector=None):
        """"""Generator that yields filtered and/or sorted :class:`Fi` instances
        from ``self.container``.

        :param specfiles: filenames of ms-run files - if specified return only
            items from those files
        :type specfiles: str or [str, str, ...]
        :param sort: if ""sort"" is specified the returned list of items is sorted
            according to the :class:`Fi` attribute specified by ""sort"", if the
            attribute is not present the item is skipped.
        :param reverse: bool, ``True`` reverses the sort order
        :param selector: a function which is called with each ``Fi`` item and
            has to return True (include item) or False (discard item). By
            default only items with ``Fi.isValid == True`` are returned.

        :returns: items from container that passed the selector function
        """"""
        selector = (lambda fi: fi.isValid) if selector is None else selector
        if specfiles is None:
            specfiles = [_ for _ in viewkeys(self.info)]
        else:
            specfiles = aux.toList(specfiles)
        return _getItems(self.container, specfiles, sort, reverse, selector)"
1960,"def _writeContainer(self, filelike, specfile, compress):
        """"""Writes the ``self.container`` entry of the specified specfile to the
        ``fic`` format.

        :param filelike: path to a file (str) or a file-like object
        :param specfile: name of an ms-run file present in ``self.info``
        :param compress: bool, True to use zip file compression

        .. note::
            In addition it could also dump the ``self.info`` entry to the
            zipfile with the filename ``info``, but this is not used at the
            moment. For details see :func:`maspy.auxiliary.writeJsonZipfile()`
        """"""
        aux.writeJsonZipfile(filelike, self.container[specfile],
                             compress=compress
                             )"
1961,"def load(self, specfiles=None):
        """"""Imports the specified ``fic`` files from the hard disk.

        :param specfiles: the name of an ms-run file or a list of names. If None
            all specfiles are selected.
        :type specfiles: None, str, [str, str]
        """"""
        if specfiles is None:
            specfiles = [_ for _ in viewkeys(self.info)]
        else:
            specfiles = aux.toList(specfiles)

        for specfile in specfiles:
            if specfile not in self.info:
                warntext = 'Error while calling ""FiContainer.load()"": ""%s"" is'\
                           ' not present in ""FiContainer.info""!'\
                            % (specfile, )
                warnings.warn(warntext)
                continue
            else:
                fiPath = aux.joinpath(self.info[specfile]['path'],
                                      specfile+'.fic'
                                      )
                with zipfile.ZipFile(fiPath, 'r') as containerZip:
                    #Convert the zipfile data into a str object, necessary since
                    #containerZip.read() returns a bytes object.
                    jsonString = io.TextIOWrapper(containerZip.open('data'),
                                                  encoding='utf-8'
                                                  ).read()
                    #infoString = io.TextIOWrapper(containerZip.open('info'),
                    #                              encoding='utf-8'
                    #                              ).read()
                self.container[specfile] = json.loads(jsonString,
                                                      object_hook=Fi.jsonHook
                                                      )"
1962,"def removeAnnotation(self, specfiles=None):
        """"""Remove all annotation information from :class:`Fi` elements.

        :param specfiles: the name of an ms-run file or a list of names. If None
            all specfiles are selected.
        :type specfiles: None, str, [str, str]
        """"""
        if specfiles is None:
            specfiles = [_ for _ in viewkeys(self.info)]
        else:
            specfiles = aux.toList(specfiles)

        for specfile in aux.toList(specfiles):
            for item in viewvalues(self.container[specfile]):
                item.isMatched = False
                item.isAnnotated = False
                item.siIds = list()
                item.siiIds = list()
                item.peptide = None
                item.sequence = None
                item.bestScore = None"
1963,"def as_dict(self):
        """"""Returns a JSON-serializeable object representing this tree.""""""
        def conv(v):
            if isinstance(v, SerializableAttributesHolder):
                return v.as_dict()
            elif isinstance(v, list):
                return [conv(x) for x in v]
            elif isinstance(v, dict):
                return {x:conv(y) for (x,y) in v.items()}
            else:
                return v
        return {k.replace('_', '-'): conv(v) for (k, v) in self._attributes.items()}"
1964,"def from_json(cls, data):
        """"""Decode a JSON string and inflate a node instance.""""""
        # Decode JSON string
        assert isinstance(data, str)
        data = json.loads(data)
        assert isinstance(data, dict)
        return cls.from_dict(data)"
1965,"def _pred(aclass):
    """"""
    :param aclass
    :return: boolean
    """"""
    isaclass = inspect.isclass(aclass)
    return isaclass and aclass.__module__ == _pred.__module__"
1966,"def extract_keywords(func):
    """"""
    Parses the keywords from the given function.

    :param      func | <function>
    """"""
    if hasattr(func, 'im_func'):
        func = func.im_func

    try:
        return func.func_code.co_varnames[-len(func.func_defaults):]
    except (TypeError, ValueError, IndexError):
        return tuple()"
1967,"def _get_adv_trans_stats(self, cmd, return_tdo=False):
        """"""Utility function to fetch the transfer statistics for the last
        advanced transfer. Checking the stats appears to sync the
        controller. For details on the advanced transfer please refer
        to the documentation at
        http://diamondman.github.io/Adapt/cable_digilent_adept.html#bulk-requests

        """"""
        t = time()
        code, res = self.bulkCommand(b'\x03\x02%c\x00'%(0x80|cmd), 10)
        if self._scanchain and self._scanchain._print_statistics:
            print(""GET STATS TIME"", time()-t)#pragma: no cover
        if len(res) == 4:
            count = struct.unpack('<I', res)[0]
            return count
        elif len(res) == 8:
            written, read =  struct.unpack('<II', res)
            return written, read
        return res"
1968,"def jtag_enable(self):
        """"""
        Enables JTAG output on the controller. JTAG operations executed
        before this function is called will return useless data or fail.

        Usage:
            >>> from proteusisc import getAttachedControllers, bitarray
            >>> c = getAttachedControllers()[0]
            >>> c.jtag_enable()
            >>> c.write_tms_bits(bitarray(""001011111""), return_tdo=True)
            >>> c.jtag_disable()
        """"""
        status, _ = self.bulkCommand(_BMSG_ENABLE_JTAG)
        if status == 0:
            self._jtagon = True
        elif status == 3:
            self._jtagon = True
            raise JTAGAlreadyEnabledError()
        else:
            raise JTAGEnableFailedError(""Error enabling JTAG. Error code: %s."" %status)"
1969,"def jtag_disable(self):
        """"""
        Disables JTAG output on the controller. JTAG operations executed
        immediately after this function will return useless data or fail.

        Usage:
            >>> from proteusisc import getAttachedControllers, bitarray
            >>> c = getAttachedControllers()[0]
            >>> c.jtag_enable()
            >>> c.write_tms_bits(bitarray(""001011111""), return_tdo=True)
            >>> c.jtag_disable()
        """"""

        if not self._jtagon: return
        status, _ = self.bulkCommand(_BMSG_DISABLE_JTAG)
        if status == 0:
            self._jtagon = False
        elif status == 3:
            raise JTAGControlError(""Error Code %s""%status)

        self.close_handle()"
1970,"def write_tms_bits(self, data, return_tdo=False, TDI=False):
        """"""
        Command controller to write TMS data (with constant TDI bit)
        to the physical scan chain. Optionally return TDO bits sent
        back from scan the chain.

        Args:
            data - bits to send over TMS line of scan chain (bitarray)
            return_tdo (bool) - return the devices bitarray response
            TDI (bool) - whether TDI should send a bitarray of all 0's
                         of same length as `data` (i.e False) or all 1's
                         (i.e. True)

        Returns:
            None by default or the (bitarray) response of the device
            after receiving data, if return_tdo is True.

        Usage:
            >>> from proteusisc import getAttachedControllers, bitarray
            >>> c = getAttachedControllers()[0]
            >>> c.jtag_enable()
            >>> c.write_tms_bits(bitarray(""001011111""), return_tdo=True)
            >>> c.jtag_disable()
        """"""
        self._check_jtag()
        self._update_scanchain(data)
        self.bulkCommandDefault(_BMSG_WRITE_TMS %
            (return_tdo, TDI, len(data).to_bytes(4, 'little')))
        self.bulkWriteData(build_byte_align_buff(data).tobytes()[::-1])
        tdo_bits = self._read_tdo(len(data)) if return_tdo else None
        self._get_adv_trans_stats(0x0B, return_tdo)
        return tdo_bits"
1971,"def write_tdi_bits(self, buff, return_tdo=False, TMS=True):
        """"""
        Command controller to write TDI data (with constant TMS bit)
        to the physical scan chain. Optionally return TDO bits sent
        back from scan the chain.

        Args:
            data - bits to send over TDI line of scan chain (bitarray)
            return_tdo (bool) - return the devices bitarray response
            TMS (bool) - whether TMS should send a bitarray of all 0's
                         of same length as `data` (i.e False) or all 1's
                         (i.e. True)

        Returns:
            None by default or the (bitarray) response of the device
            after receiving data, if return_tdo is True.

        Usage:
            >>> from proteusisc import getAttachedControllers, bitarray
            >>> c = getAttachedControllers()[0]
            >>> c.jtag_enable()
            >>> c.write_tdi_bits(bitarray(""11111""), return_tdo=True)
            >>> c.jtag_disable()
        """"""
        self._check_jtag()
        tms_bits = bitarray([TMS]*len(buff))
        self._update_scanchain(tms_bits)

        self.bulkCommandDefault(_BMSG_WRITE_TDI %
                    (return_tdo, TMS,  len(buff).to_bytes(4, 'little')))
        self.bulkWriteData(build_byte_align_buff(buff).tobytes()[::-1])
        tdo_bits = self._read_tdo(len(buff)) if return_tdo else None
        self._get_adv_trans_stats(0x08, return_tdo)
        return tdo_bits"
1972,"def write_tms_tdi_bits(self, tmsdata, tdidata, return_tdo=False):
        """"""
        Command controller to write arbitrary TDI and TMS data to the
        physical scan chain. Optionally return TDO bits sent back
        from the scan chain.

        Args:
            tmsdata - bits to send over TMS line of scan chain (bitarray)
                      must be the same length ad tdidata
            tdidata - bits to send over TDI line of scan chain (bitarray)
                      must be the same length ad tmsdata
            return_tdo (bool) - return the devices bitarray response

        Returns:
            None by default or the (bitarray) response of the device
            after receiving data, if return_tdo is True.

        Usage:
            >>> from proteusisc import getAttachedControllers, bitarray
            >>> c = getAttachedControllers()[0]
            >>> c.jtag_enable()
            >>> c.write_tms_tdi_bits(bitarray(""00001""),
                                     bitarray(""11111""), return_tdo=True)
            >>> c.jtag_disable()
        """"""
        self._check_jtag()
        if len(tmsdata) != len(tdidata):
            raise Exception(""TMSdata and TDIData must be the same length"")
        self._update_scanchain(tmsdata)
        count = len(tmsdata)

        t = time()
        outdata = bitarray([val for pair in zip(tmsdata, tdidata)
                            for val in pair])
        outdata = build_byte_align_buff(outdata).tobytes()[::-1]

        if self._scanchain and self._scanchain._print_statistics:
            print(""TDI/TDI DATA PREP TIME"", time()-t)#pragma: no cover
            t = time()

        self.bulkCommandDefault(_BMSG_WRITE_TMS_TDI % \
                  (return_tdo, count.to_bytes(4, 'little')))
        self.bulkWriteData(outdata)

        if self._scanchain and self._scanchain._print_statistics:
            print(""TRANSFER TIME"", time()-t)
            t = time()

        tdo_bits = self._read_tdo(count) if return_tdo else None

        if self._scanchain and self._scanchain._print_statistics:
            print(""TDO READ TIME"", time()-t)#pragma: no cover

        self._get_adv_trans_stats(0x0A, return_tdo)
        return tdo_bits"
1973,"def read_tdo_bits(self, count, TMS=True, TDI=False):
        """"""
        Command controller to issue [count] bit transfers to the physicsl
        scan chain, with a constant TMS and TDI value, and reading back
        the returned TDO bits.

        Args:
            count (int) - Number of bits to read from TDO and write
                          to TMS/TDI
            TMS (bool) - constant value to write to TMS for each bit read
                         from TDO.
            TDI (bool) - constant value to write to TDI for each bit read
                         from TDO.

        Returns:
            Returns the response (bitarray) from the physical scanchain's
            TDO line.

        Usage:
            >>> from proteusisc import getAttachedControllers
            >>> c = getAttachedControllers()[0]
            >>> c.jtag_enable()
            >>> data = c.read_tdo_bits(32)
            >>> c.jtag_disable()
        """"""
        self._check_jtag()
        self._update_scanchain(bool(TMS))

        self.bulkCommandDefault(
            _BMSG_READ_TDO % (TMS, TDI, count.to_bytes(4, 'little')))
        res = self._read_tdo(count)
        self._get_adv_trans_stats(_BMSG_READ_TDO[2], True)
        return res"
1974,"def importProteinDatabase(filePath, proteindb=None, decoyTag='[decoy]',
        contaminationTag='[cont]', headerParser=None, forceId=False,
        cleavageRule='[KR]', minLength=5, maxLength=40, missedCleavage=2,
        ignoreIsoleucine=False, removeNtermM=True):
    """"""Generates a :class:`ProteinDatabase` by in silico digestion of proteins
    from a fasta file.

    :param filePath: File path
    :param proteindb: optional an existing :class:`ProteinDatabase` can be
        specified, otherwise a new instance is generated and returned
    :param decoyTag: If a fasta file contains decoy protein entries, they should
        be specified with a sequence tag
    :param contaminationTag: If a fasta file contains contamination protein
        entries, they should be specified with a sequence tag
    :param headerParser: optional a headerParser can be specified
        #TODO: describe how a parser looks like
    :param forceId: bool, if True and no id can be extracted from the fasta
        header the whole header sequence is used as a protein id instead of
        raising an exception.
    :param cleavageRule: cleavage rule expressed in a regular expression, see
        :attr:`maspy.constants.expasy_rules`
    :param missedCleavage: number of allowed missed cleavage sites
    :param removeNtermM: bool, True to consider also peptides with the
        N-terminal Methionine of the protein removed
    :param minLength: int, only yield peptides with length >= minLength
    :param maxLength: int, only yield peptides with length <= maxLength
    :param ignoreIsoleucine: bool, if True treat Isoleucine and Leucine in
        peptide sequences as indistinguishable

    See also :func:`maspy.peptidemethods.digestInSilico`
    """"""
    proteindb = ProteinDatabase() if proteindb is None else proteindb
    fastaRead = _readFastaFile(filePath)

    for header, sequence in fastaRead:
        proteinTags = list()
        if header.startswith(decoyTag):
            isDecoy = True
            header = header.replace(decoyTag, '')
            proteinTags.append(decoyTag)
        else:
            isDecoy = False

        if header.startswith(contaminationTag):
            isCont = True
            header = header.replace(contaminationTag, '')
            proteinTags.append(contaminationTag)
        else:
            isCont = False

        headerInfo = _extractFastaHeader(header, headerParser, forceId)
        proteinId = ''.join(itertools.chain(proteinTags, [headerInfo['id']]))
        if 'name' in headerInfo:
            proteinName = ''.join(itertools.chain(proteinTags,
                                                  [headerInfo['name']]
                                                  )
                                  )
        else:
            proteinName = proteinId

        if proteinId not in proteindb.proteins:
            protein = ProteinSequence(proteinId, sequence)
            protein.name = proteinName
            protein.fastaHeader = header
            protein.fastaInfo = headerInfo
            proteindb.proteins[protein.id] = protein

        #Perform the insilico digestion
        _digestion = maspy.peptidemethods.digestInSilico(sequence, cleavageRule,
                                                         missedCleavage,
                                                         removeNtermM,
                                                         minLength, maxLength
                                                         )

        #Add peptides to the protein database
        for unmodPeptide, info in _digestion:
            if ignoreIsoleucine:
                unmodPeptideNoIsoleucine = unmodPeptide.replace('I', 'L')
                if unmodPeptideNoIsoleucine in proteindb.peptides:
                    currPeptide = proteindb.peptides[unmodPeptideNoIsoleucine]
                else:
                    currPeptide = PeptideSequence(unmodPeptideNoIsoleucine,
                                                  mc=info['missedCleavage']
                                                  )
                    proteindb.peptides[unmodPeptideNoIsoleucine] = currPeptide

                if unmodPeptide not in proteindb.peptides:
                    proteindb.peptides[unmodPeptide] = currPeptide
            else:
                if unmodPeptide in proteindb.peptides:
                    currPeptide = proteindb.peptides[unmodPeptide]
                else:
                    currPeptide = PeptideSequence(unmodPeptide,
                                                  mc=info['missedCleavage']
                                                  )
                    proteindb.peptides[unmodPeptide] = currPeptide

            if proteinId not in currPeptide.proteins:
                currPeptide.proteins.add(proteinId)
                #TODO: change that a peptide can appear multiple times in a
                #  protein sequence.
                currPeptide.proteinPositions[proteinId] = (info['startPos'],
                                                           info['endPos']
                                                           )

    #Add peptide entries to the protein entries, define wheter a peptide can be
    #uniquely assigend to a single protein (.isUnique = True).
    for peptide, peptideEntry in viewitems(proteindb.peptides):
        numProteinMatches = len(peptideEntry.proteins)
        if numProteinMatches == 1:
            peptideEntry.isUnique = True
        elif numProteinMatches > 1:
            peptideEntry.isUnique = False
        else:
            raise Exception('No protein matches in proteindb for peptide' +
                            'sequence: ' + peptide)

        for proteinId in peptideEntry.proteins:
            if peptideEntry.isUnique:
                proteindb.proteins[proteinId].uniquePeptides.add(peptide)
            else:
                proteindb.proteins[proteinId].sharedPeptides.add(peptide)

    #Check protein entries if the digestions generated at least one peptide that
    #is uniquely assigned to the protein (.isUnique = True)
    for proteinEntry in viewvalues(proteindb.proteins):
        if len(proteinEntry.uniquePeptides) > 0:
            proteinEntry.isUnique = True
        else:
            proteinEntry.isUnique = False
    #Note: TODO, altough isoleucin is ignored, the protein entry should only
    #show the actually present ILE / LEU occurence, not any possibilities
    return proteindb"
1975,"def _readFastaFile(filepath):
    """"""Read a FASTA file and yields tuples of 'header' and 'sequence' entries.

    :param filepath: file path of the FASTA file

    :yields: FASTA entries in the format ('header', 'sequence').
        The 'header' string does not contain the '>' and trailing white spaces.
        The 'sequence' string does not contain trailing white spaces, a '*' at
            the end of the sequence is removed.

    See also :func:`importProteinDatabase` and
    :func:`maspy.peptidemethods.digestInSilico`.
    """"""
    processSequences = lambda i: ''.join([s.rstrip() for s in i]).rstrip('*')
    processHeaderLine = lambda line: line[1:].rstrip()
    with io.open(filepath) as openfile:
        #Iterate through lines until the first header is encountered
        try:
            line = next(openfile)
            while line[0] != '>':
                line = next(openfile)
            header = processHeaderLine(line)
            sequences = list()
        except StopIteration:
            errorText = 'File does not contain fasta entries.'
            raise maspy.errors.FileFormatError(errorText)

        for line in openfile:
            if line[0] == '>':
                yield header, processSequences(sequences)
                header = processHeaderLine(line)
                sequences = list()
            else:
                sequences.append(line)

        #Yield last entry
        if sequences:
            yield header, processSequences(sequences)"
1976,"def _extractFastaHeader(fastaHeader, parser=None, forceId=False):
    """"""Parses a fasta header and returns extracted information in a dictionary.

    Unless a custom parser is specified, a ``Pyteomics`` function is used, which
    provides parsers for the formats of UniProtKB, UniRef, UniParc and  UniMES
    (UniProt Metagenomic and Environmental Sequences), described at
    `www.uniprot.org <http://www.uniprot.org/help/fasta-headers>_`.

    :param fastaHeader: str, protein entry header from a fasta file
    :param parser: is a function that takes a fastaHeader string and returns a
        dictionary, containing at least the key ""id"". If None the parser
        function from pyteomics ``pyteomics.fasta.parse()`` is used.
    :param forceId: bool, if True and no id can be extracted from the fasta
        header the whole header sequence is used as a protein id instead of
        raising an exception.

    :returns: dict, describing a fasta header
    """"""
    if parser is None:
        try:
            headerInfo = pyteomics.fasta.parse(fastaHeader)
        except pyteomics.auxiliary.PyteomicsError as pyteomicsError:
            #If forceId is set True, it uses the whole header as an id
            if forceId:
                headerInfo = {'id': fastaHeader}
            else:
                raise pyteomicsError
    else:
        headerInfo = parser(fastaHeader)
    return headerInfo"
1977,"def fastaParseSgd(header):
    """"""Custom parser for fasta headers in the SGD format, see
    www.yeastgenome.org.

    :param header: str, protein entry header from a fasta file

    :returns: dict, parsed header
    """"""
    rePattern = '([\S]+)\s([\S]+).+(\"".+\"")'
    ID, name, description = re.match(rePattern, header).groups()
    info = {'id':ID, 'name':name, 'description':description}
    return info"
1978,"def _reprJSON(self):
        """"""Returns a JSON serializable represenation of a ``PeptideSequence``
        class instance. Use :func:`maspy.proteindb.PeptideSequence._fromJSON()`
        to generate a new ``PeptideSequence`` instance from the return value.

        :returns: a JSON serializable python object
        """"""
        return {'__PepSeq__': [self.sequence, self.missedCleavage,
                               self.isUnique, list(self.proteins),
                               self.proteinPositions]}"
1979,"def _fromJSON(cls, jsonobject):
        """"""Generates a new instance of :class:`maspy.proteindb.PeptideSequence`
        from a decoded JSON object (as generated by
        :func:`maspy.proteindb.PeptideSequence._reprJSON()`).

        :param jsonobject: decoded JSON object

        :returns: a new instance of :class:`PeptideSequence`
        """"""
        newInstance = cls(jsonobject[0], jsonobject[1])
        newInstance.isUnique = jsonobject[2]
        newInstance.proteins = set(jsonobject[3])
        newInstance.proteinPositions = jsonobject[4]
        return newInstance"
1980,"def _reprJSON(self):
        """"""Returns a JSON serializable represenation of a ``ProteinSequence``
        class instance. Use :func:`maspy.proteindb.ProteinSequence._fromJSON()`
        to generate a new ``ProteinSequence`` instance from the return value.

        :returns: a JSON serializable python object
        """"""

        jsonDict = self.__dict__
        jsonDict['uniquePeptides'] = list(jsonDict['uniquePeptides'])
        jsonDict['sharedPeptides'] = list(jsonDict['sharedPeptides'])
        return {'__ProtSeq__': jsonDict}"
1981,"def _fromJSON(cls, jsonobject):
        """"""Generates a new instance of :class:`maspy.proteindb.ProteinSequence`
        from a decoded JSON object (as generated by
        :func:`maspy.proteindb.ProteinSequence._reprJSON()`).

        :param jsonobject: decoded JSON object

        :returns: a new instance of :class:`ProteinSequence`
        """"""
        newInstance = cls(None, None)
        newInstance.__dict__.update(jsonobject)
        newInstance.uniquePeptides = set(newInstance.uniquePeptides)
        newInstance.sharedPeptides = set(newInstance.sharedPeptides)
        return newInstance"
1982,"def save(self, path, compress=True):
        """"""Writes the ``.proteins`` and ``.peptides`` entries to the hard disk
        as a ``proteindb`` file.

        .. note::
            If ``.save()`` is called and no ``proteindb`` file is present in the
            specified path a new files is generated, otherwise the old file is
            replaced.

        :param path: filedirectory to which the ``proteindb`` file is written.
            The output file name is specified by ``self.info['name']``
        :param compress: bool, True to use zip file compression
        """"""
        with aux.PartiallySafeReplace() as msr:
            filename = self.info['name'] + '.proteindb'
            filepath = aux.joinpath(path, filename)
            with msr.open(filepath, mode='w+b') as openfile:
                self._writeContainer(openfile, compress=compress)"
1983,"def _writeContainer(self, filelike, compress=True):
        """"""Writes the ``.proteins`` and ``.peptides`` entries to the
        ``proteindb`` format. In addition it also dumps the ``self.info`` entry
        to the zipfile with the filename ``info``. For details see
        :func:`maspy.auxiliary.writeJsonZipfile()`

        :param filelike: path to a file (str) or a file-like object
        :param compress: bool, True to use zip file compression
        """"""
        aux.writeJsonZipfile(filelike, self.proteins, compress, 'w', 'proteins')
        aux.writeJsonZipfile(filelike, self.peptides, compress, 'a', 'peptides')
        zipcomp = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
        with zipfile.ZipFile(filelike, 'a', allowZip64=True) as containerFile:
            infodata = {key: value for key, value in
                        viewitems(self.info) if key != 'path'
                        }
            containerFile.writestr('info', json.dumps(infodata, zipcomp))"
1984,"def load(cls, path, name):
        """"""Imports the specified ``proteindb`` file from the hard disk.

        :param path: filedirectory of the ``proteindb`` file
        :param name: filename without the file extension "".proteindb""

        .. note:: this generates rather large files, which actually take longer
            to import than to newly generate. Maybe saving / loading should be
            limited to the protein database whitout in silico digestion
            information.
        """"""

        filepath = aux.joinpath(path, name + '.proteindb')
        with zipfile.ZipFile(filepath, 'r', allowZip64=True) as containerZip:
            #Convert the zipfile data into a str object, necessary since
            #containerZip.read() returns a bytes object.
            proteinsString = io.TextIOWrapper(containerZip.open('proteins'),
                                              encoding='utf-8'
                                              ).read()
            peptidesString = io.TextIOWrapper(containerZip.open('peptides'),
                                              encoding='utf-8'
                                              ).read()
            infoString = io.TextIOWrapper(containerZip.open('info'),
                                          encoding='utf-8'
                                          ).read()
        newInstance = cls()
        newInstance.proteins = json.loads(proteinsString,
                                          object_hook=ProteinSequence.jsonHook)
        newInstance.peptides = json.loads(peptidesString,
                                          object_hook=PeptideSequence.jsonHook)
        newInstance.info.update(json.loads(infoString))
        return newInstance"
1985,"def _calculateCoverageMasks(proteindb, peptidedb):
        """"""Calcualte the sequence coverage masks for all proteindb elements.
        Private method used by :class:`ProteinDatabase`.

        A coverage mask is a numpy boolean array with the length of the protein
        sequence. Each protein position that has been covered in at least one
        peptide is set to True. Coverage masks are calculated for unique and for
        shared peptides. Peptides are matched to proteins according to positions
        derived by the digestion of the FASTA file.

        Alternatively peptides could also be matched to proteins just by
        sequence as it is done in :func:`pyteomics.parser.coverage`, but this is
        not the case here.

        :param proteindb: a dictionary containing :class:`ProteinSequence`
            entries, for example ``ProteinDatabase.proteins``
        :param proteindb: a dictionary containing :class:`PeptideSequence`
            entries, for example ``ProteinDatabase.peptides``

        Sets two attributes for each ``ProteinSequence`` entry:
            ``.coverageMaskUnique`` = coverage mask of unique peptides
            ``.coverageMaskShared`` = coverage mask of shared peptides
        """"""
        for proteinId, proteinEntry in viewitems(proteindb):
            coverageMaskUnique = numpy.zeros(proteinEntry.length(), dtype='bool')
            for peptide in proteinEntry.uniquePeptides:
                startPos, endPos = peptidedb[peptide].proteinPositions[proteinId]
                coverageMaskUnique[startPos-1:endPos] = True
            coverageMaskShared = numpy.zeros(proteinEntry.length(), dtype='bool')
            for peptide in proteinEntry.sharedPeptides:
                startPos, endPos = peptidedb[peptide].proteinPositions[proteinId]
                coverageMaskShared[startPos-1:endPos] = True
            setattr(proteinEntry, 'coverageMaskUnique', coverageMaskUnique)
            setattr(proteinEntry, 'coverageMaskShared', coverageMaskShared)"
1986,"def fetch_keywords(codedata) :
	"""""" Fetch keywords by shaman.KeywordFetcher
		Get average probabilities of keyword and language
	""""""

	# Read row in codedata and count keywords in codes with langauge
	tmp = {}
	language_counts = {}

	for index, (language, code) in enumerate(codedata) :
		if language not in shaman.SUPPORTING_LANGUAGES :
			continue

		if language not in tmp :
			tmp[language] = {}
			language_counts[language] = 0

		language_counts[language] += 1

		for keyword in shaman.KeywordFetcher.fetch( code ) :
			# if keyword exists in fetched data, add '1' to keyword data
			tmp[language][keyword] = tmp[language].get(keyword, 0) + 1

		print('Fetch keyword %d/%d    ' % (index, len(codedata)), end='\r')


	# Get dataset indexed by keyword
	ret = {}

	for language in tmp :
		for keyword, count in tmp[ language ].items() :	
			if keyword not in ret :
				ret[ keyword ] = {}

			ret[ keyword ][ language ] = (count / language_counts[ language ]) # Probability

	print('Fetch keyword completed        ')
	return ret"
1987,"def match_patterns(codedata) :
	"""""" Match patterns by shaman.PatternMatcher
		Get average ratio of pattern and language
	""""""

	ret = {}

	for index1, pattern in enumerate(shaman.PatternMatcher.PATTERNS) :
		print('Matching pattern %d ""%s""' % (index1+1, pattern))

		matcher = shaman.PatternMatcher(pattern)
		tmp = {}

		for index2, (language, code) in enumerate(codedata) :
			if language not in shaman.SUPPORTING_LANGUAGES :
				continue

			if len(code) <= 20 or len(code) > 100000 :
				continue

			if language not in tmp :
				tmp[language] = []

			ratio = matcher.getratio(code)
			tmp[language].append(ratio)

			print('Matching patterns %d/%d    ' % (index2, len(codedata)), end='\r')


		ret[pattern] = {}
		for language, data in tmp.items() :
			ret[pattern][language] = sum(tmp[language]) / max(len(tmp[language]), 1)

	print('Matching patterns completed          ')
	return ret"
1988,"def facility(self, column=None, value=None, **kwargs):
        """"""
        Check information related to Radiation facilities.

        >>> RADInfo().facility('state_code', 'CA')
        """"""
        return self._resolve_call('RAD_FACILITY', column, value, **kwargs)"
1989,"def facility_type(self, column=None, value=None, **kwargs):
        """"""
        Basic identifying information for a RADInfo facility, including
        the improved facility information maintained by the Facility
        Registry System (FRS). 

        >>> RADInfo().facility_type('cit_ref_code', '40CFR300')
        """"""
        return self._resolve_call('RAD_FACILITY_TYPE', column, value, **kwargs)"
1990,"def geo(self, column=None, value=None, **kwargs):
        """"""
        Locate a facility through geographic location.

        >>> RADInfo().geo('geometric_type_code', '001')
        """"""
        return self._resolve_call('RAD_GEO_LOCATION', column, value, **kwargs)"
1991,"def regulation(self, column=None, value=None, **kwargs):
        """"""
        Provides relevant information about applicable regulations.

        >>> RADInfo().regulation('title_id', 40)
        """"""
        return self._resolve_call('RAD_REGULATION', column, value, **kwargs)"
1992,"def regulatory_program(self, column=None, value=None, **kwargs):
        """"""
        Identifies the regulatory authority governing a facility, and, by
        virtue of that identification, also identifies the regulatory program
        of interest and the type of facility. 

        >>> RADInfo().regulatory_program('sec_cit_ref_flag', 'N')
        """"""
        return self._resolve_call('RAD_REGULATORY_PROG', column,
                                  value, **kwargs)"
1993,"def collect_basic_info():
    """"""
    collect basic info about the system, os, python version...
    """"""

    s = sys.version_info
    _collect(json.dumps({'sys.version_info':tuple(s)}))
    _collect(sys.version)
    return sys.version"
1994,"def call(function):
    """"""
    decorator that collect function call count.
    """"""
    message = 'call:%s.%s' % (function.__module__,function.__name__)
    @functools.wraps(function)
    def wrapper(*args, **kwargs):
        _collect(message)
        return function(*args, **kwargs)

    return wrapper"
1995,"def _parse_ip_addr_show(raw_result):
    """"""
    Parse the 'ip addr list dev' command raw output.

    :param str raw_result: os raw result string.
    :rtype: dict
    :return: The parsed result of the show interface command in a \
        dictionary of the form:

     ::

        {
            'os_index' : '0',
            'dev' : 'eth0',
            'falgs_str': 'BROADCAST,MULTICAST,UP,LOWER_UP',
            'mtu': 1500,
            'state': 'down',
            'link_type' 'ether',
            'mac_address': '00:50:56:01:2e:f6',
            'inet': '20.1.1.2',
            'inet_mask': '24',
            'inet6': 'fe80::42:acff:fe11:2',
            'inte6_mask': '64'
        }
    """"""
    # does link exist?
    show_re = (
        r'""(?P<dev>\S+)""\s+does not exist'
    )
    re_result = search(show_re, raw_result)
    result = None

    if not (re_result):
        # match top two lines for serveral 'always there' variables
        show_re = (
            r'\s*(?P<os_index>\d+):\s+(?P<dev>\S+):\s+<(?P<falgs_str>.*)?>.*?'
            r'mtu\s+(?P<mtu>\d+).+?state\s+(?P<state>\w+).*'
            r'\s*link/(?P<link_type>\w+)\s+(?P<mac_address>\S+)'
        )

        re_result = search(show_re, raw_result, DOTALL)
        result = re_result.groupdict()

        # seek inet if its there
        show_re = (
                r'((inet )\s*(?P<inet>[^/]+)/(?P<inet_mask>\d{1,2}))'
            )
        re_result = search(show_re, raw_result)
        if (re_result):
            result.update(re_result.groupdict())

        # seek inet6 if its there
        show_re = (
                r'((?<=inet6 )(?P<inet6>[^/]+)/(?P<inet6_mask>\d{1,2}))'
            )
        re_result = search(show_re, raw_result)
        if (re_result):
            result.update(re_result.groupdict())

        # cleanup dictionary before returning
        for key, value in result.items():
            if value is not None:
                if value.isdigit():
                    result[key] = int(value)

    return result"
1996,"def _parse_ip_stats_link_show(raw_result):
    """"""
    Parse the 'ip -s link show dev <dev>' command raw output.

    :param str raw_result: vtysh raw result string.
    :rtype: dict
    :return: The parsed result of the show interface command in a \
        dictionary of the form:

     ::

        {
            'rx_bytes': 0,
            'rx_packets': 0,
            'rx_errors': 0,
            'rx_dropped': 0,
            'rx_overrun': 0,
            'rx_mcast': 0,
            'tx_bytes': 0,
            'tx_packets': 0,
            'tx_errors': 0,
            'tx_dropped': 0,
            'tx_carrier': 0,
            'tx_collisions': 0,

        }
    """"""

    show_re = (
        r'.+?RX:.*?\n'
        r'\s*(?P<rx_bytes>\d+)\s+(?P<rx_packets>\d+)\s+(?P<rx_errors>\d+)\s+'
        r'(?P<rx_dropped>\d+)\s+(?P<rx_overrun>\d+)\s+(?P<rx_mcast>\d+)'
        r'.+?TX:.*?\n'
        r'\s*(?P<tx_bytes>\d+)\s+(?P<tx_packets>\d+)\s+(?P<tx_errors>\d+)\s+'
        r'(?P<tx_dropped>\d+)\s+(?P<tx_carrier>\d+)\s+(?P<tx_collisions>\d+)'
    )

    re_result = match(show_re, raw_result, DOTALL)
    result = None

    if (re_result):
        result = re_result.groupdict()
        for key, value in result.items():
            if value is not None:
                if value.isdigit():
                    result[key] = int(value)

    return result"
1997,"def interface(enode, portlbl, addr=None, up=None, shell=None):
    """"""
    Configure a interface.

    All parameters left as ``None`` are ignored and thus no configuration
    action is taken for that parameter (left ""as-is"").

    :param enode: Engine node to communicate with.
    :type enode: topology.platforms.base.BaseNode
    :param str portlbl: Port label to configure. Port label will be mapped to
     real port automatically.
    :param str addr: IPv4 or IPv6 address to add to the interface:
     - IPv4 address and netmask to assign to the interface in the form
     ``'192.168.20.20/24'``.
     - IPv6 address and subnets to assign to the interface in the form
     ``'2001::1/120'``.
    :param bool up: Bring up or down the interface.
    :param str shell: Shell name to execute commands.
     If ``None``, use the Engine Node default shell.
    """"""
    assert portlbl
    port = enode.ports[portlbl]

    if addr is not None:
        assert ip_interface(addr)
        cmd = 'ip addr add {addr} dev {port}'.format(addr=addr, port=port)
        response = enode(cmd, shell=shell)
        assert not response

    if up is not None:
        cmd = 'ip link set dev {port} {state}'.format(
            port=port, state='up' if up else 'down'
        )
        response = enode(cmd, shell=shell)
        assert not response"
1998,"def remove_ip(enode, portlbl, addr, shell=None):
    """"""
    Remove an IP address from an interface.

    All parameters left as ``None`` are ignored and thus no configuration
    action is taken for that parameter (left ""as-is"").

    :param enode: Engine node to communicate with.
    :type enode: topology.platforms.base.BaseNode
    :param str portlbl: Port label to configure. Port label will be mapped to
     real port automatically.
    :param str addr: IPv4 or IPv6 address to remove from the interface:
     - IPv4 address to remove from the interface in the form
     ``'192.168.20.20'`` or ``'192.168.20.20/24'``.
     - IPv6 address to remove from the interface in the form
     ``'2001::1'`` or ``'2001::1/120'``.
    :param str shell: Shell name to execute commands.
     If ``None``, use the Engine Node default shell.
    """"""
    assert portlbl
    assert ip_interface(addr)
    port = enode.ports[portlbl]

    cmd = 'ip addr del {addr} dev {port}'.format(addr=addr, port=port)
    response = enode(cmd, shell=shell)
    assert not response"
1999,"def add_route(enode, route, via, shell=None):
    """"""
    Add a new static route.

    :param enode: Engine node to communicate with.
    :type enode: topology.platforms.base.BaseNode
    :param str route: Route to add, an IP in the form ``'192.168.20.20/24'``
     or ``'2001::0/24'`` or ``'default'``.
    :param str via: Via for the route as an IP in the form
     ``'192.168.20.20/24'`` or ``'2001::0/24'``.
    :param shell: Shell name to execute commands. If ``None``, use the Engine
     Node default shell.
    :type shell: str or None
    """"""
    via = ip_address(via)

    version = '-4'
    if (via.version == 6) or \
            (route != 'default' and ip_network(route).version == 6):
        version = '-6'

    cmd = 'ip {version} route add {route} via {via}'.format(
        version=version, route=route, via=via
    )

    response = enode(cmd, shell=shell)
    assert not response"
2000,"def add_link_type_vlan(enode, portlbl, name, vlan_id, shell=None):
    """"""
    Add a new virtual link with the type set to VLAN.

    Creates a new vlan device {name} on device {port}.
    Will raise an exception if value is already assigned.

    :param enode: Engine node to communicate with.
    :type enode: topology.platforms.base.BaseNode
    :param str portlbl: Port label to configure. Port label will be mapped
     automatically.
    :param str name: specifies the name of the new virtual device.
    :param str vlan_id: specifies the VLAN identifier.
    :param str shell: Shell name to execute commands. If ``None``, use the
     Engine Node default shell.
    """"""
    assert name
    if name in enode.ports:
        raise ValueError('Port {name} already exists'.format(name=name))

    assert portlbl
    assert vlan_id
    port = enode.ports[portlbl]

    cmd = 'ip link add link {dev} name {name} type vlan id {vlan_id}'.format(
        dev=port, name=name, vlan_id=vlan_id)

    response = enode(cmd, shell=shell)
    assert not response, 'Cannot add virtual link {name}'.format(name=name)

    enode.ports[name] = name"
2001,"def remove_link_type_vlan(enode, name, shell=None):
    """"""
    Delete a virtual link.

    Deletes a vlan device with the name {name}.
    Will raise an expection if the port is not already present.

    :param enode: Engine node to communicate with.
    :type enode: topology.platforms.base.BaseNode
    :param str name: specifies the name of the new
     virtual device.
    :param str shell: Shell name to execute commands. If ``None``, use the
     Engine Node default shell.
    """"""
    assert name
    if name not in enode.ports:
        raise ValueError('Port {name} doesn\'t exists'.format(name=name))

    cmd = 'ip link del link dev {name}'.format(name=name)

    response = enode(cmd, shell=shell)
    assert not response, 'Cannot remove virtual link {name}'.format(name=name)

    del enode.ports[name]"
2002,"def show_interface(enode, dev, shell=None):
    """"""
    Show the configured parameters and stats of an interface.

    :param enode: Engine node to communicate with.
    :type enode: topology.platforms.base.BaseNode
    :param str dev: Unix network device name. Ex 1, 2, 3..
    :rtype: dict
    :return: A combined dictionary as returned by both
     :func:`topology_lib_ip.parser._parse_ip_addr_show`
     :func:`topology_lib_ip.parser._parse_ip_stats_link_show`
    """"""
    assert dev

    cmd = 'ip addr list dev {ldev}'.format(ldev=dev)
    response = enode(cmd, shell=shell)

    first_half_dict = _parse_ip_addr_show(response)

    d = None
    if (first_half_dict):
        cmd = 'ip -s link list dev {ldev}'.format(ldev=dev)
        response = enode(cmd, shell=shell)
        second_half_dict = _parse_ip_stats_link_show(response)

        d = first_half_dict.copy()
        d.update(second_half_dict)
    return d"
2003,"def build_mmd(target_folder=DEFAULT_LIBRARY_DIR):
    """"""Build and install the MultiMarkdown shared library.""""""
    mmd_dir = tempfile.mkdtemp()
    mmd_repo = pygit2.clone_repository('https://github.com/jasedit/MultiMarkdown-5', mmd_dir,
                                       checkout_branch='fix_windows')
    mmd_repo.init_submodules()
    mmd_repo.update_submodules()
    build_dir = os.path.join(mmd_dir, 'build')
    old_pwd = os.getcwd()
    os.chdir(build_dir)

    cmake_cmd = ['cmake', '-DCMAKE_BUILD_TYPE=Release', '-DSHAREDBUILD=1', '..']
    if platform.system() == 'Windows':
        is_64bit = platform.architecture()[0] == '64bit'
        generator = 'Visual Studio 14 2015{0}'.format(' Win64' if is_64bit else '')
        cmake_cmd.insert(-1, '-G')
        cmake_cmd.insert(-1, '{0}'.format(generator))
    subprocess.call(cmake_cmd)
    PLATFORM_BUILDS[platform.system()]()

    lib_file = 'libMultiMarkdown' + SHLIB_EXT[platform.system()]
    if not os.path.exists(target_folder):
        os.mkdir(target_folder)
    src = os.path.join(build_dir, SHLIB_PREFIX[platform.system()], lib_file)
    dest = os.path.join(target_folder, lib_file)
    shutil.copyfile(src, dest)
    os.chdir(old_pwd)
    shutil.rmtree(mmd_dir, ignore_errors=True)"
2004,"def cli(ctx, amount, index, stage, deststage, stepresult, tostep, select, where, order, position):
    """"""Promote data from one stage to another(experimental)

    First collect the correct information with export,
    and promote result by adjusting command to promote and adding missing options.
    """"""
    if not ctx.bubble:
        msg = 'There is no bubble present, will not promote'
        ctx.say_yellow(msg)
        raise click.Abort()

    if stage not in STAGES:
        ctx.say_yellow('There is no known stage:' + stage)
        raise click.Abort()
    if stepresult not in exportables:
        ctx.say_yellow('stepresult not one of: ' + ', '.join(exportables))
        raise click.Abort()
    ctx.gbc.say('promote:args', stuff=(ctx, amount, index, stage,
                                       deststage, stepresult, tostep, select, where, order, position))
    data_gen = bubble_lod_load(ctx, stepresult, stage)

    ctx.gbc.say('data_gen:', stuff=data_gen, verbosity=20)

    part = get_gen_slice(ctx.gbc, data_gen, amount, index)
    ctx.gbc.say('selected part:', stuff=part, verbosity=20)

    aliases = get_pairs(ctx.gbc, select, missing_colon=True)
    if position:
        ctx.gbc.say('adding position to selection of columns:',
                    stuff=aliases, verbosity=20)
        aliases.insert(0, {'key': buts('index'), 'val': 'BUBBLE_IDX'})
        ctx.gbc.say('added position to selection of columns:',
                    stuff=aliases, verbosity=20)

    wheres = get_pairs(ctx.gbc, where)
    # TODO: use aliases as lookup for wheres

    data = tablib.Dataset()

    data.headers = [sel['val'] for sel in aliases]
    ctx.gbc.say('select wheres:' + str(wheres), verbosity=20)
    ctx.gbc.say('select aliases:' + str(aliases), verbosity=20)
    ctx.gbc.say('select data.headers:' + str(data.headers), verbosity=20)

    # TODO: get this selecting stuff into a shared function from export

    try:
        for ditem in part:
            row = []
            ctx.gbc.say('curr dict', stuff=ditem, verbosity=101)

            flitem = flat(ctx, ditem)
            ctx.gbc.say('curr flat dict', stuff=flitem, verbosity=101)
            row_ok = True
            for wp in wheres:
                # TODO: negative selects: k:None, k:False,k:Zero,k:Null,k:0,k:-1,k:'',k:"""",
                # TODO: negative selects: k:BUBBLE_NO_KEY,k:BUBBLE_NO_VAL

                if not wp['val'] in str(flitem[wp['key']]):
                    row_ok = False
            if not row_ok:
                continue

            for sel in aliases:
                if sel['key'] in flitem:
                    row.append(flitem[sel['key']])
                else:
                    # temporary to check, not use case for buts()
                    bnp = '____BTS_NO_PATH_'
                    tempv = get_flat_path(ctx, flitem, sel['key'] + '.*', bnp)
                    if tempv != bnp:
                        row.append(tempv)
                    else:
                        row.append('None')
                        # TODO maybe 'NONE', or just '' or something like:
                        # magic.export_format_none

            data.append(row)

    except Exception as excpt:
        ctx.say_red('Cannot promote data', stuff=excpt)
        raise click.Abort()

    if order:
        olast2 = order[-2:]
        ctx.gbc.say('order:' + order + ' last2:' + olast2, verbosity=100)
        if olast2 not in [':+', ':-']:
            data = data.sort(order, False)
        else:
            if olast2 == ':+':
                data = data.sort(order[:-2], False)
            if olast2 == ':-':
                data = data.sort(order[:-2], True)"
2005,"def _setup():
        """"""
        Sets up the global import environment variables by registering the
        sub-folders for projex as import locations.  When defining your 
        custom manager, you will want to overload this method to do any
        sort of global initialization that you wish before continuing.
        
        :warning    This method is called by the _setup method, and should 
                    not be called directly.
        """"""
        projex_path = os.getenv('PROJEX_PATH')
        if not projex_path:
            return

        base_path = os.path.dirname(__file__)

        logger.debug('Loading PROJEX_PATH: %s' % projex_path)

        # load the defaults from the install directory
        # load the paths from the environment
        paths = projex_path.split(os.path.pathsep)
        paths += [
            os.path.join(base_path, 'userplug'),
            os.path.join(base_path, 'stdplug'),
            os.path.join(base_path, 'lib'),
        ]

        sys.path = paths + sys.path"
2006,"def appendPath(self, path):
        """"""
        Appends the inputted path to the end of the sys.path variable,
        provided the path does not already exist in it.
        
        :param      path
        :type       str
        
        :return     bool: success
        """"""
        # normalize the path
        path = os.path.normcase(nstr(path)).strip()
        if path and path != '.' and path not in sys.path:
            sys.path.append(path)
            self._addedpaths.append(path)
            return True
        return False"
2007,"def expandvars(self, text, environ=None, cache=None):
        """"""
            Recursively expands the text variables, vs. the os.path \
            method which only works at one level.  The cache value should be \
            left blank as it is used to protect against recursion.
            
            :param      text    | <str>
                        environ | <dict> || None
                        cache   | <dict> { <str>: <str>, .. }
                        
            :return     <str>
        """"""
        if not environ:
            environ = os.environ

        # make sure we have data
        if not text:
            return ''

        # check for circular dependencies
        cache = cache or {}

        # return the cleaned variable
        output = nstr(text)
        keys = re.findall('\$(\w+)|\${(\w+)\}|\%(\w+)\%', text)

        for first, second, third in keys:
            repl = ''
            key = ''
            if first:
                repl = '$%s' % first
                key = first
            elif second:
                repl = '${%s}' % second
                key = second
            elif third:
                repl = '%%%s%%' % third
                key = third
            else:
                continue

            value = environ.get(key)
            if value:
                if key not in cache:
                    cache[key] = value
                    value = self.expandvars(value, environ, cache)
                else:
                    err = '%s environ variable causes an infinite loop.' % key
                    logger.warning(err)
                    value = cache[key]
            else:
                value = repl

            output = output.replace(repl, value)

        return os.path.expanduser(output)"
2008,"def pushPath(self, path):
        """"""
        Pushes the inputted path at the front of the sys.path variable, making
        it the first path python uses when importing a module.
        
        :param      path
        :type       str
        
        :return     bool: success
        """"""
        # normalize the path
        path = os.path.normcase(nstr(path)).strip()
        if path and path != '.' and path not in sys.path:
            sys.path.append(path)
            self._addedpaths.insert(0, path)
            return True
        return False"
2009,"def requires(self, *modules):
        """"""
        Registers the system paths for the inputted modules so that they can
        be imported properly.  By default, this will check to see if the
        key PROJEX_[MODULE]_PATH exists in the environment, and if so, insert
        that path to the front of the sys.path for import.  Out of the box
        installations will register import paths to default projex folders
        and won't need to define these path variables. (lib/,stdplug/,userplug)
        
        :param      *modules     ( <str>, .. )
        
        :usage      |>>> import projex
                    |>>> projex.logger.setLevel( projex.logging.DEBUG )
                    |>>> projex.environ().requires( 'orb', 'anansi' )
                    |DEBUG: EnvManager.requires: PROJEX_ORB_PATH
                    |DEBUG: EnvManager.requires: PROJEX_ANANSI_PATH
                    |>>> import opb
                    |>>> import openwebdk
        """"""
        self._setup()

        for module in modules:
            if '-' in module:
                parts = module.split('-')
                module = parts[0]
                version = '-'.join(parts)
            else:
                version = ''

            if module in self._loadedRequires:
                continue

            self._loadedRequires.append(module)
            path_key = 'PROJEX_%s_PATH' % nstr(module).upper()
            env_path = os.getenv(path_key)

            logger.debug('Looking up %s: %s' % (path_key, env_path))

            # push the path for the particular module if found in the env
            if env_path:
                self.pushPath(env_path)"
2010,"def refactor(module, name, repl):
        """"""
        Replaces the name in the module dictionary with the inputted replace \
        value.
        
        :param      module  | <str> || <module>
                    name    | <str>
                    repl    | <variant>
        
        :return     <bool>
        """"""
        name = nstr(name)

        # import a module when refactoring based on a string
        if isinstance(module, basestring):
            try:
                module = __import__(module)
            except ImportError:
                logger.exception('Could not import module: %s' % module)
                return False

        try:
            glbls = module.__dict__
        except AttributeError:
            err = '%s cannot support refactoring.' % module.__name__
            logger.exception(err)
            return False

        if name in glbls:
            # refactor the value
            glbls[name] = repl

            return True
        else:
            err = '%s is not a member of %s.' % (name, module.__name__)
            logger.warning(err)
            return False"
2011,"def current():
        """"""
        Returns the current environment manager for the projex system.
        
        :return     <EnvManager>
        """"""
        if not EnvManager._current:
            path = os.environ.get('PROJEX_ENVMGR_PATH')
            module = os.environ.get('PROJEX_ENVMGR_MODULE')
            clsname = os.environ.get('PROJEX_ENVMGR_CLASS')
            cls = EnvManager

            if module and clsname:
                # check if the user specified an import path
                if path:
                    logger.info('Adding env manager path: %s' % path)
                    sys.path.insert(0, path)

                logger.info('Loading env manager: %s.%s' % (module, clsname))

                try:
                    __import__(module)
                    mod = sys.modules[module]
                    cls = getattr(mod, clsname)

                except ImportError:
                    logger.error('Could not import env manager %s', module)

                except KeyError:
                    logger.error('Could not import env manager %s', module)

                except AttributeError:
                    msg = '%s is not a valid class of %s' % (clsname, module)
                    logger.error(msg)

            EnvManager._current = cls()
        return EnvManager._current"
2012,"def fileImport(filepath, ignore=None):
        """"""
        Imports the module located at the given filepath.
        
        :param      filepath    | <str>
                    ignore      | [<str>, ..] || None
        
        :return     <module> || None
        """"""
        basepath, package = EnvManager.packageSplit(filepath)
        if not (basepath and package):
            return None

        # make sure this is not part of the ignored package list
        if ignore and package in ignore:
            return None

        basepath = os.path.normcase(basepath)
        if basepath not in sys.path:
            sys.path.insert(0, basepath)

        logger.debug('Importing: %s' % package)

        try:
            __import__(package)
            module = sys.modules[package]
        except ImportError:
            logger.exception('ImportError: %s' % package)
            return None
        except KeyError:
            logger.exception('Could not find sys.modules package: %s' % package)
            return None
        except StandardError:
            logger.exception('Unknown error occurred not import %s' % package)
            return None

        return module"
2013,"def packageSplit(filepath):
        """""" 
        Determines the python path, and package information for the inputted
        filepath.
        
        :param      filepath  |  <str>
        
        :return     (<str> path, <str> package)
        """"""
        filepath = nstr(filepath).strip().strip('.')
        if not filepath:
            return '', ''

        basepath, module = os.path.split(nstr(filepath))
        module = os.path.splitext(module)[0]
        pathsplit = os.path.normpath(basepath).split(os.path.sep)
        packagesplit = []

        if module and module != '__init__':
            packagesplit.append(module)

        testpath = os.path.sep.join(pathsplit + ['__init__.py'])
        while os.path.exists(testpath):
            packagesplit.insert(0, pathsplit[-1])
            pathsplit = pathsplit[:-1]
            testpath = os.path.sep.join(pathsplit + ['__init__.py'])

        return os.path.sep.join(pathsplit), '.'.join(packagesplit)"
2014,"def save(keystorerc=None, keystore=None, files=[], verbose=False):
  '''create a keystore, compress and encrypt to file'''

  config = None
  if keystorerc:
    config = config_reader.read(keystorerc)
    if not config:
      print('No configuration found.', file=sys.stderr)
      sys.exit(-1)
  elif keystore and len(files) > 0:
    config = {
      'keystore': keystore,
      'files': files
    }

  if 'verbose' in config and config['verbose']:
    verbose = True

  keystore_path = None
  if 'keystore' not in config:
    print('.keystorerc needs to specify a keystore file path.', file=sys.stderr)
    sys.exit(-1)

  keystore_path = os.path.expanduser(config['keystore'])
  if os.path.isdir(keystore_path):
    print('keystore cannot be a folder: {}'.format(config['keystore']), file=sys.stderr)
    sys.exit(-1)
  elif not os.path.isfile(keystore_path):
    # If keystore file does not exist already, attempt to create one
    try:
      pathlib.Path(keystore_path).touch()
    except OSError as err:
      print('keystore cannot be accessed: {}\n{}'.format(config['keystore'], err), file=sys.stderr)
      sys.exit(-1)

  # iterate through keys and add them here

  keystore = {}
  try:
    for p in config['files']:

      expanded_path = os.path.expanduser(p)
      path = pathlib.Path(expanded_path)
      if verbose: print('Inspecting {}:'.format(expanded_path))

      if not path.exists():
        print('Error: File or folder does not exist: {}'.format(p), file=sys.stderr)
        sys.exit(-1)
      if path.is_dir():
        for dirpath, dirnames, filenames in os.walk(expanded_path):
          for name in filenames:
            fullpath = os.path.join(dirpath, name)
            if verbose: print('Adding {} ...'.format(fullpath))
            with open(fullpath, 'rb') as keyfile:
              b64_bytes = base64.encodebytes(keyfile.read()).decode('utf-8')
              keystore[fullpath] = b64_bytes
      elif path.is_file():
        fullpath = expanded_path
        if verbose: print('Adding {} ...'.format(fullpath))
        with open(fullpath, 'rb') as keyfile:
          b64_bytes = base64.encodebytes(keyfile.read()).decode('utf-8')
          keystore[fullpath] = b64_bytes

    if verbose: print('Added {} key(s) to keystore.\n'.format(len(keystore)))

    # prompt user for a one-time passphase for encryption

    do_passphrases_match = False
    passphrase = None
    print('This passphrase is used to decrypt your keystore. Please remember it.')
    while not do_passphrases_match:
      passphrase = getpass.getpass('Please enter a passphrase: ')
      passphrase_verify = getpass.getpass('Please verify your passphrase: ')
      do_passphrases_match = passphrase != '' and passphrase == passphrase_verify
      if passphrase == '':
        print('Passphrase cannot be empty.')
      elif not do_passphrases_match:
        print('Passphrases do not match. Please try again.')
    if verbose: print('Passphrase accepted. Encrypting ...')

    # serialise, compress, encrypt

    serial_keystore = json.dumps(keystore)
    compressed_keystore = gzip.compress(serial_keystore.encode('utf-8'))
    try:
      encrypted_keystore = simplecrypt.encrypt(passphrase, compressed_keystore)
    except simplecrypt.EncryptionException as err:
      print('You managed to bump into a very, very rare issue with AES.\nPlease contact the author. {}'.format(err), file=sys.stder)
      sys.exit(-1)

    # save encrypted keystore to file
    keystore_path = os.path.expanduser(keystore_path)
    if verbose: print('Writing to keystore file {}'.format(keystore_path))

    with open(keystore_path, 'wb') as keystore_file:
      keystore_file.write(encrypted_keystore)

    if verbose: print('Keystore successfully created: ')
    # if verbose: print(encrypted_keystore)

  except KeyError as err:
    print('.keystorerc config is missing `files` attribute: {}'.format(err), file=sys.stderr)
    sys.exit(-1)
  except TypeError as err:
    print('Error: {}'.format(err), file=sys.stderr)
    traceback.print_exc()
    sys.exit(-1)
  except OSError as err:
    print('The file system gave an error: {}'.format(err), file=sys.stderr)
    sys.exit(-1)
  except Exception as err:
    print('Serious error. Please report this bug to the author: {}'.format(err), file=sys.stderr)
    sys.exit(-1)"
2015,"def join_all(self, *parts):
        """"""
        Join all parts with domain. Example domain: https://www.python.org

        :param parts: Other parts, example: ""/doc"", ""/py27""
        :return: url
        """"""
        url = util.join_all(self.domain, *parts)
        return url"
2016,"def add_params(self, endpoint, params):
        """"""
        Combine query endpoint and params.
        """"""
        assert endpoint.startswith(self.domain)
        return util.add_params(endpoint, params)"
2017,"def generate_requirements_files(self, base_dir='.'):
        """""" Generate set of requirements files for config """"""

        print(""Creating requirements files\n"")

        # TODO How to deal with requirements that are not simple, e.g. a github url

        shared = self._get_shared_section()

        requirements_dir = self._make_requirements_directory(base_dir)

        for section in self.config.sections():
            if section == 'metadata':
                continue

            requirements = {}
            for option in self.config.options(section):
                requirements[option] = self.config.get(section, option)

            if not requirements:
                # No need to write out an empty file
                continue

            filename = os.path.join(requirements_dir, '%s.txt' % section)
            self._write_requirements_file(shared, section, requirements, filename)"
2018,"def _write_default_sections(self):
        """""" Starting from scratch, so create a default rc file """"""
        self.config.add_section('metadata')
        self.config.set('metadata', 'shared', 'common')
        self.config.add_section('common')
        self.config.add_section('development')
        self.config.add_section('production')"
2019,"def _parse_requirements(self, input):
        """""" Parse a list of requirements specifications.
            Lines that look like ""foobar==1.0"" are parsed; all other lines are
            silently ignored.

            Returns a tuple of tuples, where each inner tuple is:
                (package, version) """"""

        results = []

        for line in input:
            (package, version) = self._parse_line(line)
            if package:
                results.append((package, version))

        return tuple(results)"
2020,"def create_rc_file(self, packages):
        """""" Create a set of requirements files for config """"""

        print(""Creating rcfile '%s'\n"" % self.rc_filename)

        # TODO bug with == in config file

        if not self.config.sections():
            self._write_default_sections()

        sections = {}
        section_text = []
        for i, section in enumerate(self.config.sections()):
            if section == 'metadata':
                continue
            sections[i] = section
            section_text.append('%s. %s' % (i, section))
        section_text = ' / '.join(section_text)

        self._remap_stdin()
        package_names = set()
        lines = packages.readlines()
        requirements = self._parse_requirements(lines)
        for (package, version) in requirements:
            package_names.add(package)
            section, configured_version = self._get_option(package)
            # Package already exists in configuration
            if section:
                # If there is a configured version, update it. If not, leave it unversioned.
                if configured_version:
                    if configured_version != version:
                        print(""Updating '%s' version from '%s' to '%s'""
                              % (package, configured_version, version))
                        self.config.set(section, package, version)
                continue

            section = self._get_section(package, sections, section_text)
            self._set_option(section, package, version)

        for section in self.config.sections():
            if section == 'metadata':
                continue
            for option in self.config.options(section):
                if option not in package_names:
                    print(""Removing package '%s'"" % option)
                    self.config.remove_option(section, option)

        rc_file = open(self.rc_filename, 'w+')
        self.config.write(rc_file)
        rc_file.close()"
2021,"def upgrade_packages(self, packages):
        """""" Upgrade all specified packages to latest version """"""

        print(""Upgrading packages\n"")

        package_list = []
        requirements = self._parse_requirements(packages.readlines())
        for (package, version) in requirements:
            package_list.append(package)

        if package_list:
            args = [
                ""pip"",
                ""install"",
                ""-U"",
            ]
            args.extend(package_list)
            subprocess.check_call(args)
        else:
            print(""No packages to upgrade"")"
2022,"def determine_extra_packages(self, packages):
        """""" Return all packages that are installed, but missing from ""packages"".
            Return value is a tuple of the package names """"""

        args = [
            ""pip"",
            ""freeze"",
        ]
        installed = subprocess.check_output(args, universal_newlines=True)

        installed_list = set()
        lines = installed.strip().split('\n')
        for (package, version) in self._parse_requirements(lines):
            installed_list.add(package)

        package_list = set()
        for (package, version) in self._parse_requirements(packages.readlines()):
            package_list.add(package)

        removal_list = installed_list - package_list
        return tuple(removal_list)"
2023,"def remove_extra_packages(self, packages, dry_run=False):
        """""" Remove all packages missing from list """"""

        removal_list = self.determine_extra_packages(packages)
        if not removal_list:
            print(""No packages to be removed"")
        else:
            if dry_run:
                print(""The following packages would be removed:\n    %s\n"" %
                      ""\n    "".join(removal_list))
            else:
                print(""Removing packages\n"")
                args = [
                    ""pip"",
                    ""uninstall"",
                    ""-y"",
                ]
                args.extend(list(removal_list))
                subprocess.check_call(args)"
2024,"def rewrap(self, **kwargs):
        """"""Inplace constructor. Depending on `self.inplace`, rewrap `obj`, or
        just update internal vars, possibly including the `obj`.
        """"""
        if self.inplace:
            for key, val in kwargs.items():
                setattr(self, key, val)
            return self
        else:
            for key in ['obj', 'default', 'skipmissing', 'inplace', 'empty']:
                kwargs.setdefault(key, getattr(self, key))
            return pluckable(**kwargs)"
2025,"def _filtered_list(self, selector):
        """"""Iterate over `self.obj` list, extracting `selector` from each
        element. The `selector` can be a simple integer index, or any valid
        key (hashable object).
        """"""
        res = []
        for elem in self.obj:
            self._append(elem, selector, res)
        return res"
2026,"def _sliced_list(self, selector):
        """"""For slice selectors operating on lists, we need to handle them
        differently, depending on ``skipmissing``. In explicit mode, we may have
        to expand the list with ``default`` values.
        """"""
        if self.skipmissing:
            return self.obj[selector]

        # TODO: can be optimized by observing list bounds
        keys = xrange(selector.start or 0,
                      selector.stop or sys.maxint,
                      selector.step or 1)
        res = []
        for key in keys:
            self._append(self.obj, key, res, skipmissing=False)
        return res"
2027,"def _extract_from_object(self, selector):
        """"""Extracts all values from `self.obj` object addressed with a `selector`.
        Selector can be a ``slice``, or a singular value extractor in form of a
        valid dictionary key (hashable object).
        
        Object (operated on) can be anything with an itemgetter or attrgetter,
        including, but limited to `dict`, and `list`.
        Itemgetter is preferred over attrgetter, except when called as `.key`.
        
        If `selector` is a singular value extractor (like a string, integer,
        etc), a single value (for a given key) is returned if key exists, an
        empty list if not.
        
        If `selector` is a ``slice``, each key from that range is extracted;
        failing-back, again, to an empty list.
        """"""
        if isinstance(selector, slice):
            # we must expand the slice manually, in order to be able to apply to
            # for example, to mapping types, or general objects
            # (e.g. slice `4::2` will filter all even numerical keys/attrs >=4)
            start = selector.start or 0
            step = selector.step or 1
            if selector.stop is None:
                if hasattr(self.obj, ""keys""):
                    # filter keys by slice
                    keys = \
                        [k for k in self.obj.keys() if isinstance(k, baseinteger) \
                            and k >= start and (k - start) % step == 0]
                elif hasattr(self.obj, ""__len__""):
                    # object we slice should have a length (__len__ method),
                    keys = xrange(start, len(self.obj), step)
                else:
                    # otherwise, we don't know how to slice, so just skip it,
                    # instead of failing
                    keys = []
            else:
                keys = xrange(start, selector.stop, step)

        else:
            keys = [selector]
        
        res = []
        for key in keys:
            self._append(self.obj, key, res)
        return res"
2028,"def items(self):
        """"""Behave like `dict.items` for mapping types (iterator over (key, value)
        pairs), and like `iter` for sequence types (iterator over values).
        """"""
        if self.empty:
            return iter([])

        val = self.value
        if hasattr(val, ""iteritems""):
            return val.iteritems()
        elif hasattr(val, ""items""):
            return val.items()
        else:
            return iter(self)"
2029,"def _mkpda(self, nonterms, productions, productions_struct, terminals, splitstring=1):
        """"""
        This function generates a PDA from a CNF grammar as described in:
          -  http://www.oit.edu/faculty/sherry.yang/CST229/Lectures/7_pda.pdf
          -  http://www.eng.utah.edu/~cs3100/lectures/l18/pda-notes.pdf

        If all of the grammar productions are in the Chomsky Normal Form,
        then follow the template for constructing a pushdown symautomata:

        1. Start
        2. Push S
        3. Pop
        4. Case:
            Nonterminal A: For every production rule of this form: A: BC, Push C and then Push B

        Args:
             nonterms (list): Non terminals list
             productions (dict): productions in the CNF form:
                                    A -> a or A -> b0b1, or S -> e
             productions_struct (dict):  productions in the CNF form in structure form
                                    object.a for A -> a,
                                    object.b0 and object.b1 for A -> b0b1
                                    and object.type where type is
                                        1 for A-->a and 2 for A-->b0b1
             terminals (list): All terminals
             splitstring (bool): If enabled an extra space is added after each symbol.
        Returns:
            PDA: The generated PDA
        """"""
        pda = PDA(self.alphabet)
        pda.nonterminals = nonterms
        pda.terminals = terminals

        pda.s[pda.n] = PDAState()
        pda.s[pda.n].id = pda.n
        pda.s[pda.n].sym = '@closing'
        pda.s[pda.n].type = 1
        pda.s[pda.n].trans[1] = [0]

        pda.n = pda.n + 1
        pda.s[pda.n] = PDAState()
        pda.s[pda.n].id = pda.n
        pda.s[pda.n].type = 1
        pda.s[pda.n].sym = nonterms[0]
        pda.s[pda.n].trans[2] = [0]

        pda.n = pda.n + 1
        pda.s[pda.n] = PDAState()
        pda.s[pda.n].id = pda.n
        pda.s[pda.n].type = 2
        pda.s[pda.n].trans[0] = ['@closing']

        counter = 0
        i = 0
        while i < len(nonterms):
            j = 0
            while j < len(productions[nonterms[i]]):
                if productions_struct[counter].type == 1:
                    # ADD AND CONNECT STATE
                    pda.n = pda.n + 1
                    pda.s[pda.n] = PDAState()
                    pda.s[pda.n].id = pda.n
                    if pda.n not in pda.s[2].trans:
                        pda.s[2].trans[pda.n] = []
                    pda.s[2].trans[pda.n].append(nonterms[i])

                    if splitstring == 0:

                        # FILL NEW STATE  READ
                        pda.s[pda.n].type = 3
                        pda.s[pda.n].trans[2] = [productions_struct[counter].a]

                    else:
                        # THE FOLLOWIN SWITCH IS DUE TO THE REQUIREMENT OF
                        # HAVING STRINGS SPLITTED TO SYMBOLS AND CAN INTERSECT
                        # WITH DFA

                        if productions_struct[counter].a not in terminals or \
                                        len(productions_struct[counter].a) == 1:
                            # FILL NEW STATE  READ
                            pda.s[pda.n].type = 3
                            pda.s[pda.n].trans[pda.n + 1] = [productions_struct[counter].a.lower()]
                            pda.n = pda.n + 1
                            pda.s[pda.n] = PDAState()
                            pda.s[pda.n].id = pda.n
                            pda.s[pda.n].type = 3
                            pda.s[pda.n].trans[2] = [' ']

                        else:
                            pda.s[pda.n].type = 3
                            pda.s[pda.n].trans[pda.n + 1] = \
                                [productions_struct[counter].a[0].lower()]
                            k = 1
                            while k < len(productions_struct[counter].a) - 1:
                                pda.n = pda.n + 1
                                pda.s[pda.n] = PDAState()
                                pda.s[pda.n].id = pda.n
                                pda.s[pda.n].type = 3
                                pda.s[pda.n].trans[pda.n +1] = \
                                    [productions_struct[counter].a[k].lower()]
                                k = k + 1
                            pda.n = pda.n + 1
                            pda.s[pda.n] = PDAState()
                            pda.s[pda.n].id = pda.n
                            pda.s[pda.n].type = 3

                            pda.s[pda.n].trans[pda.n + 1] = \
                                [productions_struct[counter].a[-1].lower()]
                            pda.n = pda.n + 1
                            pda.s[pda.n] = PDAState()
                            pda.s[pda.n].id = pda.n
                            pda.s[pda.n].type = 3
                            pda.s[pda.n].trans[2] = [' ']

                else:
                    # ADD AND CONNECT PUSH STATE
                    pda.n = pda.n + 1
                    pda.s[pda.n] = PDAState()
                    pda.s[pda.n].id = pda.n
                    if pda.n not in pda.s[2].trans:
                        pda.s[2].trans[pda.n] = []
                    pda.s[2].trans[pda.n].append(nonterms[i])

                    # FILL NEW STATE
                    pda.s[pda.n].type = 1
                    pda.s[pda.n].sym = productions_struct[counter].b1
                    pda.s[pda.n].trans[(pda.n) + 1] = [0]

                    # ADD AND CONNECT PUSH STATE (ALREADY CONNECTED)
                    pda.n = pda.n + 1
                    pda.s[pda.n] = PDAState()
                    pda.s[pda.n].id = pda.n

                    # FILL NEW STATE
                    pda.s[pda.n].type = 1
                    pda.s[pda.n].sym = productions_struct[counter].b0
                    pda.s[pda.n].trans[2] = [0]

                j = j + 1
                counter = counter + 1

            i = i + 1
        return pda"
2030,"def forceutc(t: Union[str, datetime.datetime, datetime.date, np.datetime64]) -> Union[datetime.datetime, datetime.date]:
    """"""
    Add UTC to datetime-naive and convert to UTC for datetime aware

    input: python datetime (naive, utc, non-utc) or Numpy datetime64  #FIXME add Pandas and AstroPy time classes
    output: utc datetime
    """"""
    # need to passthrough None for simpler external logic.
# %% polymorph to datetime
    if isinstance(t, str):
        t = parse(t)
    elif isinstance(t, np.datetime64):
        t = t.astype(datetime.datetime)
    elif isinstance(t, datetime.datetime):
        pass
    elif isinstance(t, datetime.date):
        return t
    elif isinstance(t, (np.ndarray, list, tuple)):
        return np.asarray([forceutc(T) for T in t])
    else:
        raise TypeError('datetime only input')
# %% enforce UTC on datetime
    if t.tzinfo is None:  # datetime-naive
        t = t.replace(tzinfo=UTC)
    else:  # datetime-aware
        t = t.astimezone(UTC)  # changes timezone, preserving absolute time. E.g. noon EST = 5PM UTC

    return t"
2031,"def on_assert_failed_print_details(actual, expected):
    """"""
    Print text details in case of assertation failed errors.

    .. sourcecode:: python

        with on_assert_failed_print_details(actual_text, expected_text):
            assert actual == expected
    """"""
    try:
        yield
    except AssertionError:
        # diff = difflib.unified_diff(expected.splitlines(), actual.splitlines(),
        #                            ""expected"", ""actual"")
        diff = difflib.ndiff(expected.splitlines(), actual.splitlines())
        diff_text = u""\n"".join(diff)
        print(u""DIFF (+ ACTUAL, - EXPECTED):\n{0}\n"".format(diff_text))
        if DEBUG:
            print(u""expected:\n{0}\n"".format(expected))
            print(u""actual:\n{0}\n"".format(actual))
        raise"
2032,"def on_error_print_details(actual, expected):
    """"""
    Print text details in case of assertation failed errors.

    .. sourcecode:: python

        with on_error_print_details(actual_text, expected_text):
            ... # Do something
    """"""
    try:
        yield
    except Exception:
        diff = difflib.ndiff(expected.splitlines(), actual.splitlines())
        diff_text = u""\n"".join(diff)
        print(u""DIFF (+ ACTUAL, - EXPECTED):\n{0}\n"".format(diff_text))
        if DEBUG:
            print(u""expected:\n{0}\n"".format(expected))
            print(u""actual:\n{0}"".format(actual))
        raise"
2033,"def step_a_new_working_directory(context):
    """"""
    Creates a new, empty working directory
    """"""
    command_util.ensure_context_attribute_exists(context, ""workdir"", None)
    command_util.ensure_workdir_exists(context)
    shutil.rmtree(context.workdir, ignore_errors=True)"
2034,"def step_use_curdir_as_working_directory(context):
    """"""
    Uses the current directory as working directory
    """"""
    context.workdir = os.path.abspath(""."")
    command_util.ensure_workdir_exists(context)"
2035,"def step_a_file_named_filename_and_encoding_with(context, filename, encoding):
    """"""Creates a textual file with the content provided as docstring.""""""
    __encoding_is_valid = True
    assert context.text is not None, ""ENSURE: multiline text is provided.""
    assert not os.path.isabs(filename)
    assert __encoding_is_valid
    command_util.ensure_workdir_exists(context)
    filename2 = os.path.join(context.workdir, filename)
    pathutil.create_textfile_with_contents(filename2, context.text, encoding)"
2036,"def step_a_file_named_filename_with(context, filename):
    """"""Creates a textual file with the content provided as docstring.""""""
    step_a_file_named_filename_and_encoding_with(context, filename, ""UTF-8"")

    # -- SPECIAL CASE: For usage with behave steps.
    if filename.endswith("".feature""):
        command_util.ensure_context_attribute_exists(context, ""features"", [])
        context.features.append(filename)"
2037,"def step_an_empty_file_named_filename(context, filename):
    """"""
    Creates an empty file.
    """"""
    assert not os.path.isabs(filename)
    command_util.ensure_workdir_exists(context)
    filename2 = os.path.join(context.workdir, filename)
    pathutil.create_textfile_with_contents(filename2, """")"
2038,"def step_i_run_command(context, command):
    """"""
    Run a command as subprocess, collect its output and returncode.
    """"""
    command_util.ensure_workdir_exists(context)
    context.command_result = command_shell.run(command, cwd=context.workdir)
    command_util.workdir_save_coverage_files(context.workdir)
    if False and DEBUG:
        print(u""run_command: {0}"".format(command))
        print(u""run_command.output {0}"".format(context.command_result.output))"
2039,"def step_it_should_pass_with(context):
    '''
    EXAMPLE:
        ...
        when I run ""behave ...""
        then it should pass with:
            """"""
            TEXT
            """"""
    '''
    assert context.text is not None, ""ENSURE: multiline text is provided.""
    step_command_output_should_contain(context)
    assert_that(context.command_result.returncode, equal_to(0),
                context.command_result.output)"
2040,"def step_it_should_fail_with(context):
    '''
    EXAMPLE:
        ...
        when I run ""behave ...""
        then it should fail with:
            """"""
            TEXT
            """"""
    '''
    assert context.text is not None, ""ENSURE: multiline text is provided.""
    step_command_output_should_contain(context)
    assert_that(context.command_result.returncode, is_not(equal_to(0)))"
2041,"def step_command_output_should_contain_text(context, text):
    '''
    EXAMPLE:
        ...
        Then the command output should contain ""TEXT""
    '''
    expected_text = text
    if ""{__WORKDIR__}"" in expected_text or ""{__CWD__}"" in expected_text:
        expected_text = textutil.template_substitute(text,
             __WORKDIR__ = posixpath_normpath(context.workdir),
             __CWD__     = posixpath_normpath(os.getcwd())
        )
    actual_output = context.command_result.output
    with on_assert_failed_print_details(actual_output, expected_text):
        textutil.assert_normtext_should_contain(actual_output, expected_text)"
2042,"def step_command_output_should_not_contain_text(context, text):
    '''
    EXAMPLE:
        ...
        then the command output should not contain ""TEXT""
    '''
    expected_text = text
    if ""{__WORKDIR__}"" in text or ""{__CWD__}"" in text:
        expected_text = textutil.template_substitute(text,
             __WORKDIR__ = posixpath_normpath(context.workdir),
             __CWD__     = posixpath_normpath(os.getcwd())
        )
    actual_output  = context.command_result.output
    with on_assert_failed_print_details(actual_output, expected_text):
        textutil.assert_normtext_should_not_contain(actual_output, expected_text)"
2043,"def step_command_output_should_contain_exactly_text(context, text):
    """"""
    Verifies that the command output of the last command contains the
    expected text.

    .. code-block:: gherkin

        When I run ""echo Hello""
        Then the command output should contain ""Hello""
    """"""
    expected_text = text
    if ""{__WORKDIR__}"" in text or ""{__CWD__}"" in text:
        expected_text = textutil.template_substitute(text,
             __WORKDIR__ = posixpath_normpath(context.workdir),
             __CWD__     = posixpath_normpath(os.getcwd())
        )
    actual_output  = context.command_result.output
    textutil.assert_text_should_contain_exactly(actual_output, expected_text)"
2044,"def compile(self, prog, features=Features.ALL):
        """"""Currently this compiler simply returns an interpreter instead of compiling
        TODO: Write this compiler to increase LPProg run speed and to prevent exceeding maximum recursion depth

        Args:
            prog (str): A string containing the program.
            features (FeatureSet): The set of features to enable during compilation.

        Returns:
            LPProg
        """"""
        return LPProg(Parser(Tokenizer(prog, features), features).program(), features)"
2045,"def cprint(self, cstr):
        """"""
        Clear line, then reprint on same line
        :param cstr: string to print on current line
        """"""
        cstr = str(cstr)  # Force it to be a string
        cstr_len = len(cstr)
        prev_cstr_len = len(self._prev_cstr)
        num_spaces = 0
        if cstr_len < prev_cstr_len:
            num_spaces = abs(prev_cstr_len - cstr_len)
        try:
            print(cstr + "" "" * num_spaces, end='\r')
            self._prev_cstr = cstr
        except UnicodeEncodeError:
            print('Processing...', end='\r')
            self._prev_cstr = 'Processing...'"
2046,"def get_sql_for_new_models(apps=None, using=DEFAULT_DB_ALIAS):
    """"""
    Unashamedly copied and tweaked from django.core.management.commands.syncdb
    """"""
    connection = connections[using]
    
    # Get a list of already installed *models* so that references work right.
    tables = connection.introspection.table_names()
    seen_models = connection.introspection.installed_models(tables)
    created_models = set()
    pending_references = {}
    
    if apps:
        apps = [models.get_app(a) for a in apps]
    else:
        apps = models.get_apps()
    
    # Build the manifest of apps and models that are to be synchronized
    all_models = [
        (app.__name__.split('.')[-2], [
            m
            for m in models.get_models(app, include_auto_created=True)
            if router.allow_syncdb(using, m)
        ])
        for app in apps
    ]
    
    def model_installed(model):
        opts = model._meta
        converter = connection.introspection.table_name_converter
        db_table_in = (converter(opts.db_table) in tables)
        auto_create_in = (
            opts.auto_created and
            converter(opts.auto_created._meta.db_table) in tables
        )
        return not (db_table_in or auto_create_in)
    
    manifest = SortedDict(
        (app_name, filter(model_installed, model_list))
        for app_name, model_list in all_models
    )
    
    statements = []
    sql = None
    for app_name, model_list in manifest.items():
        for model in model_list:
            # Create the model's database table, if it doesn't already exist.
            sql, references = connection.creation.sql_create_model(
                model,
                no_style(),
                seen_models
            )
            
            seen_models.add(model)
            created_models.add(model)
            statements.append(""### New Model: %s.%s"" % (
                app_name,
                str(model).replace(""'>"", """").split(""."")[-1]
            ))
            
            for refto, refs in references.items():
                pending_references.setdefault(refto, []).extend(refs)
                if refto in seen_models:
                    sql.extend(
                        connection.creation.sql_for_pending_references(
                            refto,
                            no_style(),
                            pending_references
                        )
                    )
            
            sql.extend(
                connection.creation.sql_for_pending_references(
                    model,
                    no_style(),
                    pending_references
                )
            )
            statements.extend(sql)
    
    custom_sql = None
    for app_name, model_list in manifest.items():
        for model in model_list:
            if model in created_models:
                custom_sql = custom_sql_for_model(
                    model,
                    no_style(),
                    connection
                )
                
                if custom_sql:
                    statements.extend(custom_sql)
    
    index_sql = None
    for app_name, model_list in manifest.items():
        for model in model_list:
            if model in created_models:
                index_sql = connection.creation.sql_indexes_for_model(
                    model,
                    no_style()
                )
                
                if index_sql:
                    statements.extend(index_sql)
    
    return statements"
2047,"def get_file_list(path, max_depth=1, cur_depth=0):
    """"""
    Recursively returns a list of all files up to ``max_depth``
    in a directory.
    """"""
    if os.path.exists(path):
        for name in os.listdir(path):
            if name.startswith('.'):
                continue
            
            full_path = os.path.join(path, name)
            if os.path.isdir(full_path):
                if cur_depth == max_depth:
                    continue
                
                file_list = get_file_list(full_path, max_depth, cur_depth + 1)
                for result in file_list:
                    yield result
            else:
                yield full_path"
2048,"def get_applied_migrations(databases=None):
    """"""
    Returns a dictionary containing lists of all applied migrations
    where the key is the database alias.
    """"""
    if not databases:
        databases = get_capable_databases()
    else:
        # We only loop through databases that are listed as ""capable""
        all_databases = list(get_capable_databases())
        databases = list(
            itertools.ifilter(lambda x: x in all_databases, databases)
        )
    
    results = defaultdict(list)
    for db in databases:
        for x in Migration.objects.using(db).order_by(""migration_label""):
            results[db].append(x.migration_label)
    
    return results"
2049,"def get_all_migrations(path, databases=None):
    """"""
    Returns a dictionary of database => [migrations] representing all
    migrations contained in ``path``.
    """"""
    # database: [(number, full_path)]
    possible_migrations = defaultdict(list)
    
    try:
        in_directory = sorted(get_file_list(path))
    except OSError:
        import traceback
        print ""An error occurred while reading migrations from %r:"" % path
        traceback.print_exc()
        return {}
    
    # Iterate through our results and discover which migrations are
    # actually runnable
    for full_path in in_directory:
        child_path, script = os.path.split(full_path)
        name, ext = os.path.splitext(script)
        
        # the database component is default if this is in the root directory
        # is <directory> if in a subdirectory
        if path == child_path:
            db = DEFAULT_DB_ALIAS
        else:
            db = os.path.split(child_path)[-1]
        
        # filter by database if set
        if databases and db not in databases:
            continue
        
        match = MIGRATION_NAME_RE.match(name)
        if match is None:
            raise MigrationError(""Invalid migration file prefix %r ""
                                 ""(must begin with a number)"" % name)
        
        number = int(match.group(1))
        if ext in ["".sql"", "".py""]:
            possible_migrations[db].append((number, full_path))
    
    return possible_migrations"
2050,"def get_pending_migrations(path, databases=None, stop_at=None):
    """"""
    Returns a dictionary of database => [migrations] representing all pending
    migrations.
    """"""
    if stop_at is None:
        stop_at = float(""inf"")
    
    # database: [(number, full_path)]
    possible_migrations = get_all_migrations(path, databases)
    # database: [full_path]
    applied_migrations = get_applied_migrations(databases)
    # database: [full_path]
    to_execute = defaultdict(list)
    
    for database, scripts in possible_migrations.iteritems():
        applied = applied_migrations[database]
        pending = to_execute[database]
        for number, migration in scripts:
            path, script = os.path.split(migration)
            if script not in applied and number <= stop_at:
                pending.append(script)
    
    return dict((k, v) for k, v in to_execute.iteritems() if v)"
2051,"def updateFgiAnnotationFromFi(fgiContainer, fiContainer, largerBetter):
    """""" #TODO: docstring

    :param fgiContainer:
    :param fiContainer:
    :param largerBetter:
    """"""
    for fgi in listvalues(fgiContainer.container):
        annotations = list()
        for specfile, fiId in zip(fgi.specfiles, fgi.featureIds):
            fi = fiContainer.getItem(specfile, fiId)
            if not fi.isAnnotated:
                continue
            annotations.append([fi.score, fi.peptide, fi.sequence])
        annotations.sort(reverse=largerBetter)
        if len(annotations) > 0:
            fgi.isAnnotated = True
            fgi.score = annotations[0][0]
            fgi.peptide = annotations[0][1]
            fgi.sequence = annotations[0][2]
        else:
            fgi.isAnnotated = False"
2052,"def continuityGrouping(values, limit):
    """""" #TODO docstring

    :param values: ``numpy.array`` containg ``int`` or ``float``, must be sorted
    :param limit: the maximal difference between two values, if this number is
        exceeded a new group is generated

    :returns: a list containing array start and end positions of continuous
        groups
    """"""
    lastValue = values[0]
    lastPos = 0
    groupStartPos = 0

    groupPos = list()
    for currPos, currValue in enumerate(values):
        if currValue - lastValue > limit:
            groupPos.append((groupStartPos, lastPos))
            groupStartPos = currPos
        lastPos = currPos
        lastValue = currValue
    groupPos.append((groupStartPos, lastPos))
    return groupPos"
2053,"def massTimeContinuityGroups(arrays, mKey, tKey, mLimit, tLimit):
    """""" #TODO docstring

    :param arrays: a dictionary containing ``numpy.arrays``, must be sorted
        according to the ""mKey"" (mass key) value.
    :param mKey: ""arrays"" key that contains the mass ``numpy.array``
    :param tKey: ""arrays"" key that contains the time ``numpy.array``
    :param mLimit: maximal mass difference for separating continuity groups
    :param tLimit: maximal time difference for separating continuity groups

    :returns: a list containing array positions of continuous groups.""""""
    arrayPositions = numpy.array(range(listvalues(arrays)[0].size))

    finalGroupPositions = list()
    for start, end in continuityGrouping(arrays[mKey], mLimit):
        if start == end:
            finalGroupPositions.append(arrayPositions[start:end+1])
            continue

        #Perform time continuity grouping on the mass continuity groups
        preSelectionT = arrays[tKey][start:end+1]
        preSelectionM = arrays[mKey][start:end+1]
        preSelectionPositions = arrayPositions[start:end+1]
        _sort = numpy.argsort(preSelectionT)
        preGroups = continuityGrouping(preSelectionT[_sort], tLimit)

        #Perform a second round of mass continuity grouping
        finalGroupPrePos = list()
        for _start, _end in preGroups:
            preGroupPos = sorted(_sort[_start:_end+1])
            secGroups = continuityGrouping(preSelectionM[preGroupPos], mLimit)
            for fStart, fEnd in secGroups:
                finalGroupPrePos.append(preGroupPos[fStart:fEnd+1])

        #Add the final group positions
        for _pos in finalGroupPrePos:
            finalGroupPositions.append(preSelectionPositions[_pos])

    return finalGroupPositions"
2054,"def getContGroupArrays(arrays, groupPositions, arrayKeys=None):
    """"""Convinience function to generate a subset of arrays from specified array
    positions.

    :param arrays: a dictionary containing ``numpy.arrays``
    :param groupPositions: arrays positions that should be included in the
        subset of arrays
    :param arrayKeys: a list of ""arrays"" keys that should be included in the
        subset of arrays, if None all keys are selected

    :returns: a dictionary containing ``numpy.arrays``
    """"""
    if arrayKeys is None:
        arrayKeys = list(viewkeys(arrays))
    matchingArrays = dict()
    for key in arrayKeys:
        matchingArrays[key] = arrays[key][groupPositions]
    return matchingArrays"
2055,"def calcDistMatchArr(matchArr, tKey, mKey):
    """"""Calculate the euclidean distance of all array positions in ""matchArr"".

    :param matchArr: a dictionary of ``numpy.arrays`` containing at least two
        entries that are treated as cartesian coordinates.
    :param tKey: #TODO: docstring
    :param mKey: #TODO: docstring

    :returns: #TODO: docstring

            {'eucDist': numpy.array([eucDistance, eucDistance, ...]),
             'posPairs': numpy.array([[pos1, pos2], [pos1, pos2], ...])
             }
    """"""
    #Calculate all sorted list of all eucledian feature distances
    matchArrSize = listvalues(matchArr)[0].size

    distInfo = {'posPairs': list(), 'eucDist': list()}
    _matrix = numpy.swapaxes(numpy.array([matchArr[tKey], matchArr[mKey]]), 0, 1)

    for pos1 in range(matchArrSize-1):
        for pos2 in range(pos1+1, matchArrSize):
            distInfo['posPairs'].append((pos1, pos2))
    distInfo['posPairs'] = numpy.array(distInfo['posPairs'])
    distInfo['eucDist'] = scipy.spatial.distance.pdist(_matrix)

    distSort = numpy.argsort(distInfo['eucDist'])
    for key in list(viewkeys(distInfo)):
        distInfo[key] = distInfo[key][distSort]

    return distInfo"
2056,"def proximityGrouping(matchArr, distInfo, distLimit, categoryKey):
    """""" #TODO: docstring. Group according to the distance value provided by
        ``distInfo['eucDist']`` with the limitation that each ... category value
        can occur only once per group.

    :param matchArr: #TODO: docstring
    :param distInfo: #TODO: docstring, must be sorted, provide keys ""posPairs""
        and ""eucDist"". As generated by :func:`calcDistMatchArr()`
    :param distLimit: #TODO: docstring
    :param categoryKey: #TODO: docstring

    :returns: #TODO: docstring
    """"""
    #Group fi according to their proximity
    matchArrSize = listvalues(matchArr)[0].size

    linkageGroups = {p: [p] for p in range(matchArrSize)}
    posToGroup = {p: p for p in range(matchArrSize)}
    groupCategories = {p: set([s]) for p, s in zip(range(matchArrSize),
                                                  matchArr[categoryKey]
                                                  )
                      }
    for (pos1, pos2), dist in zip(distInfo['posPairs'], distInfo['eucDist']):
        if dist > distLimit:
            break

        id1 = posToGroup[pos1]
        id2 = posToGroup[pos2]
        if groupCategories[id1].intersection(groupCategories[id2]):
            continue

        linkageGroups[id1].extend(linkageGroups[id2])
        groupCategories[id1].update(groupCategories[id2])
        for _pos in linkageGroups[id2]:
            posToGroup[_pos] = id1
        del linkageGroups[id2]
        del groupCategories[id2]

    return linkageGroups"
2057,"def fiGroupFromLinkageGroup(matchArr, arrPos, groupId, timeKey, massKey):
    """""" #TODO: docstring
    """"""
    fgi = Fgi(groupId)
    matchArr['isAnnotated'][arrPos]

    minT = numpy.min(matchArr[timeKey][arrPos])
    maxT = numpy.max(matchArr[timeKey][arrPos])
    minM = numpy.min(matchArr[massKey][arrPos])
    maxM = numpy.max(matchArr[massKey][arrPos])

    fgi.isValid = True
    fgi.specfiles = matchArr['specfile'][arrPos].tolist()
    fgi.featureIds = matchArr['id'][arrPos].tolist()
    fgi.isAnnotated = numpy.any(matchArr['isAnnotated'][arrPos])
    fgi.coordinates = ((minT, maxT), (minM, maxM))
    #fgi.clusterType = clusterType

    return fgi"
2058,"def generateFeatureGroups(fgiContainer, linkageGroups, matchArr, timeKey,
                          massKey, logMassKey, massScalingFactor):
    """""" #TODO: docstring

    :param fgiContainer:
    :param linkageGroups:

    :returns: a list of ids of the newly generated :class:`Fgi`
    """"""
    #Generate feature groups from the linked features
    newFgiIds = list()
    for linkageGroup in viewvalues(linkageGroups):
        fgiId = fgiContainer._getNextFgiId()
        fgi = fiGroupFromLinkageGroup(matchArr, linkageGroup, fgiId,
                                      timeKey, massKey
                                      )
        fgiContainer.container[fgiId] = fgi
        fgi.metrics = clusterMetrics(matchArr[timeKey][linkageGroup],
                                     matchArr[logMassKey][linkageGroup],
                                     massScalingFactor=massScalingFactor
                                     )
        fgi.rt = fgi.metrics['meanTime']
        fgi.mz = fgi.metrics['meanMass']
        newFgiIds.append(fgiId)
    return newFgiIds"
2059,"def clusterMetrics(timeValues, massValues, massScalingFactor=1):
    """""" #TODO: docstring
    """"""
    metrics = dict()
    metrics['meanTime'] = numpy.mean(timeValues)
    metrics['meanMass'] = numpy.mean(massValues)
    metrics['devTime'] = timeValues - metrics['meanTime']
    metrics['devMass'] = massValues - metrics['meanMass']
    #metrics['devMass'] = (1-metrics['meanMass']/massValues)
    metrics['spreadTime'] = numpy.max(timeValues) - numpy.min(timeValues)
    metrics['spreadMass'] = numpy.max(massValues) - numpy.min(massValues)
    #metrics['spreadMass'] = (1-numpy.min(massValues) / numpy.max(massValues))
    metrics['devEuc'] = numpy.sqrt(numpy.power(metrics['devTime'], 2) +
                                   numpy.power(metrics['devMass']*massScalingFactor, 2)
                                   )
    metrics['meanEuc'] = numpy.mean(metrics['devEuc'])
    metrics['devTime'] = metrics['devTime'].tolist()
    metrics['devMass'] = metrics['devMass'].tolist()
    metrics['devEuc'] = metrics['devEuc'].tolist()
    return metrics"
2060,"def lfqFeatureGrouping(fiContainer, timeLimit=40, massLimit=10*1e-6,
                       eucLimit=None, timeKey='rt', massKey='mz',
                       massScalingFactor=None, categoryKey='specfile',
                       charges=None, matchArraySelector=None, specfiles=None):
    """""" #TODO: docstring

    :param fiContainer: #TODO: docstring
    :param timeLimit: #TODO: docstring
    :param massLimit: #TODO: docstring
    :param eucLimit: #TODO: docstring
    :param timeKey: #TODO: docstring
    :param massKey: #TODO: docstring
    :param massScalingFactor: #TODO: docstring
    :param categoryKey: #TODO: docstring
    :param charges: #TODO: docstring
    :param matchArraySelector: #TODO: docstring
    :param specfiles: limit grouping to these specfiles

    :returns: #TODO docstring, :class:`FgiContainer`
    """"""
    # --- perform the whole feature grouping process --- #
    targetChargeStates = range(1, 6) if charges is None else charges
    if matchArraySelector is None:
        matchArraySelector = lambda arr: numpy.any(arr['isAnnotated'])
    if massScalingFactor is None:
        massScalingFactor = timeLimit / massLimit
    if eucLimit is None:
        eucLimit = timeLimit
    if specfiles is None:
        specfiles = sorted(viewkeys(fiContainer.info))

    #'massToleranceMode': 'relative'
    #'timeToleranceMode': 'absolute'
    fgiContainer = FgiContainer(specfiles)

    logMassLimit = log2RelativeMassLimit(massLimit)
    logMassKey = 'logMass'

    logToleranceFactor = massLimit / log2RelativeMassLimit(massLimit)
    logMassScalingFactor = massScalingFactor * logToleranceFactor
    """""" Note: because ""a"" is similar to ""b""
    a = (1- 400 / 400.001) * massScalingFactor
    b = (numpy.log2(400.001) - numpy.log2(400)) * logMassScalingFactor
    """"""

    fiArrayKeys = [massKey, timeKey, 'isAnnotated', 'isMatched']

    for _charge in targetChargeStates:
        # - Prepare feature arrays - #
        fiSelector = lambda fi: fi.charge == _charge and fi.isValid
        fiArrays = fiContainer.getArrays(fiArrayKeys, specfiles, sort=massKey,
                                         selector=fiSelector)
        fiArrays['logMass'] = numpy.log2(fiArrays[massKey])
        if listvalues(fiArrays)[0].size == 0:
            continue

        # - group features which are in close mass and time proximity - #
        continuousGroups = massTimeContinuityGroups(fiArrays, logMassKey,
                                                    timeKey, logMassLimit,
                                                    timeLimit
                                                    )

        # - perform proximity grouping - #
        matchArrayKeys = list(viewkeys(fiArrays))

        for groupId in range(len(continuousGroups)):
            #Grab the arrays of the current feature continuity group
            groupPositions = continuousGroups[groupId]
            matchArr = getContGroupArrays(fiArrays, groupPositions,
                                          matchArrayKeys
                                          )
            if not matchArraySelector(matchArr):
                continue

            #Calculate a sorted list of all euclidean feature distances
            matchArr['mNorm'] = matchArr[logMassKey] * logMassScalingFactor
            distInfo = calcDistMatchArr(matchArr, timeKey, 'mNorm')

            #Group fi according to their proximity
            linkageGroups = proximityGrouping(matchArr, distInfo, eucLimit,
                                              categoryKey
                                              )

            #Generate feature groups from the linked features
            fgiIds = generateFeatureGroups(fgiContainer, linkageGroups,
                                           matchArr, timeKey, massKey,
                                           logMassKey, logMassScalingFactor
                                           )

            #Set charge manually
            for fgiId in fgiIds:
                fgiContainer.container[fgiId].charge = _charge

            #Mark overlapping groups as not valid (fgi.isValid = False)
            fgiDoOverlap = findFgiOverlaps(fgiContainer, fgiIds)

        #Add feature intensities to the feature groups
        fgiContainer.updateIntensities(fiContainer)
    return fgiContainer"
2061,"def getArrays(self, attr=None, sort=False, reverse=False,
                  selector=None, defaultValue=None, report='lfq'):
        """""" #TODO: docstring
        """"""
        selector = (lambda fgi: fgi.isValid) if selector is None else selector
        attr = attr if attr is not None else []
        attr = set(['id', 'intensities'] + aux.toList(attr))
        items = self.getItems(sort, reverse, selector)
        arrays = _getArrays(items, attr, defaultValue)

        for specfile in self._matrixTemplate:
            arrays[specfile] = list()
        for intensities in arrays['intensities']:
            for specfile, intensitiy in zip(self._matrixTemplate, intensities):
                arrays[specfile].append(intensitiy)
        for specfile in self._matrixTemplate:
            arrays[specfile] = numpy.array(arrays[specfile],
                                           dtype=numpy.float64
                                           )
        del arrays['intensities']

        return arrays"
2062,"def getItems(self, sort=False, reverse=False,  selector=None):
        """""" #TODO: docstring
        """"""
        selector = (lambda fgi: fgi.isValid) if selector is None else selector
        _container = {'_': self.container}
        return _getItems(_container, '_', sort, reverse, selector)"
2063,"def load(self, path, name):
        """"""Imports the specified ``fgic`` file from the hard disk.

        :param path: filedirectory to which the ``fgic`` file is written.
        :param name: filename, without file extension
        """"""

        filename = name + '.fgic'
        filepath = aux.joinpath(path, filename)
        with zipfile.ZipFile(filepath, 'r') as containerZip:
            #Convert the zipfile data into a str object, necessary since
            #containerZip.read() returns a bytes object.
            jsonString = io.TextIOWrapper(containerZip.open('data'),
                                          encoding='utf-8'
                                          ).read()
            infoString = io.TextIOWrapper(containerZip.open('info'),
                                          encoding='utf-8'
                                          ).read()
        self.container = json.loads(jsonString, object_hook=Fgi.jsonHook)
        self.info.update(json.loads(infoString))
        self._matrixTemplate = self.info['_matrixTemplate']
        del self.info['_matrixTemplate']"
2064,"def updateIntensities(self, fiContainer, iKey='intensity'):
        """""" #TODO: docstring
        :param fiContainer:
        :param iKey: Attribute name of :class:`Fi` that contains the feature
            intensity or an abundance measure. Default ""intensity""
        """"""
        for fgi in listvalues(self.container):
            intensities = list()
            specfileIds = {i: j for i, j in zip(fgi.specfiles, fgi.featureIds)}
            for specfile in self._matrixTemplate:
                if specfile in specfileIds:
                    fi = fiContainer.getItem(specfile, specfileIds[specfile])
                    intensities.append(getattr(fi, iKey))
                else:
                    intensities.append(None)
            fgi.intensities = intensities"
2065,"def command(argv, scope):
    """"""
    Looks up a particular command from the inputted arguments for the given \
    scope.
    
    :param      argv    | [<str>, ..]
                scope   | <dict>
    
    :return     <climethod> || None
    """"""
    if inspect.ismodule(scope):
        scope = vars(scope)

    for cmd in scope.values():
        if not isinstance(cmd, climethod):
            continue

        if cmd.__name__ in argv:
            return cmd
    return None"
2066,"def commands(scope):
    """"""
    Looks up all climethod instances from the inputted scope.
    
    :return     [<climethod>, ..]
    """"""
    if inspect.ismodule(scope):
        scope = vars(scope)

    return [cmd for cmd in scope.values() if isinstance(cmd, climethod)]"
2067,"def generate(module):
    """"""
    Generates a new interface from the inputted module.
    
    :param      module | <module>
    
    :return     <Interface>
    """"""
    inter = Interface(PROGRAM_NAME)
    inter.register(module, True)
    return inter"
2068,"def parser(scope, usage=''):
    """"""
    Generates a default parser for the inputted scope.
    
    :param      scope    | <dict> || <module>
                usage    | <str>
                callable | <str>
    
    :return     <OptionParser>
    """"""
    subcmds = []
    for cmd in commands(scope):
        subcmds.append(cmd.usage())

    if subcmds:
        subcmds.sort()
        usage += '\n\nSub-Commands:\n  '
        usage += '\n  '.join(subcmds)

    parse = PARSER_CLASS(usage=usage)
    parse.prog = PROGRAM_NAME
    return parse"
2069,"def process(argv, scope, interface=None):
    """"""
    Processes any commands within the scope that matches the inputted arguments.
    If a subcommand is found, then it is run, and the system exists with the 
    return value from the command.
    
    :param      argv    | [<str>, ..]
                scope   | <dict>
    
    :return     (<dict> options, <tuple> arguments)
    """"""
    cmd = command(argv, scope)
    if cmd:
        sys.exit(cmd.run(argv))

    name = PROGRAM_NAME
    if interface:
        name = interface.name()

    _parser = parser(scope, '{0} [options] [<subcommand>] [<arg>]'.format(name))
    options, args = _parser.parse_args(argv)
    return options.__dict__, args"
2070,"def usage(self):
        """"""
        Returns the usage string for this method.
        
        :return     <str>
        """"""
        arg_list = ' '.join(self.cmd_args).upper()
        name = self.interface.name()
        return '%s [options] %s %s' % (name, self.__name__, arg_list)"
2071,"def parser(self):
        """"""
        Creates a parser for the method based on the documentation.
        
        :return     <OptionParser>
        """"""
        usage = self.usage()
        if self.__doc__:
            usage += '\n' + nstr(self.__doc__)

        parse = PARSER_CLASS(usage=usage)

        shorts = {v: k for k, v in self.short_keys.items()}
        for key, default in self.cmd_opts.items():
            # default key, cannot be duplicated
            if key == 'help':
                continue

            try:
                short = '-' + shorts[key]
            except KeyError:
                short = ''

            if default is True:
                action = 'store_false'
            elif default is False:
                action = 'store_true'
            else:
                action = 'store'

            # add the option
            parse.add_option(short, '--%s' % key, action=action, default=default)

        return parse"
2072,"def run(self, argv):
        """"""
        Parses the inputted options and executes the method.
        
        :param      argv | [<str>, ..]
        """"""
        (opts, args) = self.parser().parse_args(argv)
        func_args = args[args.index(self.__name__) + 1:]
        func_kwds = opts.__dict__

        return self.__call__(*func_args, **func_kwds)"
2073,"def register(self, obj, autogenerate=False):
        """"""
        Registers the inputted object to this scope.
        
        :param      obj | <module> || <function> || <climethod>
        """"""
        scope = self._scope

        # register a module
        if type(obj).__name__ == 'module':
            for key, value in vars(obj).items():
                # register a climethod
                if isinstance(value, climethod):
                    value.interface = self
                    scope[key] = value

                # register a function
                elif inspect.isfunction(value) and autogenerate:
                    meth = climethod(value)
                    meth.interface = self
                    scope[key] = meth

        # register a climethod
        elif isinstance(obj, climethod):
            obj.interface = self
            scope[obj.__name__] = obj

        # register a function
        elif inspect.isfunction(obj) and autogenerate:
            meth = climethod(obj)
            meth.interface = self
            scope[meth.__name__] = meth"
2074,"def clone(cls, srcpath, destpath, encoding='utf-8'):
        """"""Clone an existing repository to a new bare repository.""""""
        cmd = [GIT, 'clone', '--quiet', '--bare', srcpath, destpath]
        subprocess.check_call(cmd)
        return cls(destpath, encoding)"
2075,"def create(cls, path, encoding='utf-8'):
        """"""Create a new bare repository""""""
        cmd = [GIT, 'init', '--quiet', '--bare', path]
        subprocess.check_call(cmd)
        return cls(path, encoding)"
2076,"def get_as_dict(self):
        u""""""
            Exports self as ordinary dict(), replacing recursively all instances of ElasticDict() to dict()
        :rtype: dict()
        """"""
        def convert(val):
            if isinstance(val, tuple):
                return tuple(convert(v) for v in val)
            elif isinstance(val, list):
                return [convert(v) for v in val]
            elif isinstance(val, (dict, ElasticDict)):
                return {k: convert(v) for k, v in val.iteritems()}
            else:
                return val

        return convert(self.__dict__)"
2077,"def create_from(value):
        u""""""
            Create an instance of ElasticDict() where all nested dict()'s are replaced to ElasticDict()
        :rtype: ElasticDict (if value is dict()), else type(value)
        """"""
        def convert(val):
            if isinstance(val, tuple):
                return tuple(convert(v) for v in val)
            elif isinstance(val, list):
                return [convert(v) for v in val]
            elif isinstance(val, (dict, ElasticDict)):
                return ElasticDict({k: convert(v) for k, v in val.iteritems()})
            else:
                return val

        return convert(value)"
2078,"def cache(self, dependency: Dependency, value):
        """"""
        Store an instance of dependency in the cache.
        Does nothing if dependency is NOT a threadlocal
        or a singleton.  

        :param dependency: The ``Dependency`` to cache
        :param value: The value to cache for dependency

        :type dependency: Dependency
        """"""
        if dependency.threadlocal:
            setattr(self._local, dependency.name, value)
        elif dependency.singleton:
            self._singleton[dependency.name] = value"
2079,"def cached(self, dependency):
        """"""
        Get a cached instance of dependency.

        :param dependency: The ``Dependency`` to retrievie value for
        :type dependency: ``Dependency``
        :return: The cached value        
        """"""
        if dependency.threadlocal:
            return getattr(self._local, dependency.name, None)
        elif dependency.singleton:
            return self._singleton.get(dependency.name)"
2080,"def _set(self, name, factory, singleton=False, threadlocal=False):
        """"""
        Add a dependency factory to the registry

        :param name: Name of dependency
        :param factory: function/callable that returns dependency
        :param singleton: When True, makes the dependency a singleton.
            Factory will only be called on first use, subsequent 
            uses receive a cached value.
        :param threadlocal: When True, register dependency as a threadlocal singleton,
            Same functionality as ``singleton`` except :class:`Threading.local` is used
            to cache return values.
        """"""
        name = name or factory.__name__
        factory._giveme_registered_name = name
        dep = Dependency(name, factory, singleton, threadlocal)
        self._registry[name] = dep"
2081,"def get(self, name: str):
        """"""
        Get an instance of dependency,
        this can be either a cached instance
        or a new one (in which case the factory is called)
        """"""
        dep = None
        try:
            dep = self._registry[name]
        except KeyError:
            raise DependencyNotFoundError(name) from None
        value = self.cached(dep)
        if value is None:
            value = dep.factory()
            self.cache(dep, value)
        return value"
2082,"def register(self, function=None, *, singleton=False, threadlocal=False, name=None):
        """"""
        Add an object to the injector's registry.

        Can be used as a decorator like so:
        
        >>> @injector.register
        ... def my_dependency(): ...

        or a plain function call by passing in a callable
        injector.register(my_dependency)

        :param function: The function or callable to add to the registry
        :param name: Set the name of the dependency. Defaults to the name of `function`
        :param singleton: When True, register dependency as a singleton, this
            means that `function` is called on first use and its 
            return value cached for subsequent uses. Defaults to False
        :param threadlocal: When True, register dependency as a threadlocal singleton,
            Same functionality as ``singleton`` except :class:`Threading.local` is used
            to cache return values.
        :type function: callable
        :type singleton: bool
        :type threadlocal: bool
        :type name: string
        """"""
        def decorator(function=None):
            self._set(name, function, singleton, threadlocal)
            return function
        if function:
            return decorator(function)
        return decorator"
2083,"def inject(self, function=None, **names):
        """"""
        Inject dependencies into `funtion`'s arguments when called.

        >>> @injector.inject
        ... def use_dependency(dependency_name):
                ...
        >>> use_dependency()

        The `Injector` will look for registered dependencies
        matching named arguments and automatically pass
        them to the given function when it's called.

        :param function: The function to inject into
        :type function: callable
        :param \**names: in the form of ``argument='name'`` to override
            the default behavior which matches dependency names with argument
            names.
        """"""
        def decorator(function):
            @wraps(function)
            def wrapper(*args, **kwargs):
                sig = signature(function)
                params = sig.parameters

                bound = sig.bind_partial(*args, **kwargs)
                bound.apply_defaults()

                injected_kwargs = {}
                for key, value in params.items():
                    if key not in bound.arguments:
                        name = names.get(key)
                        if name:
                            # Raise error when dep named explicitly
                            # and missing
                            injected_kwargs[key] = self.get(name)
                        else:
                            try:
                                injected_kwargs[key] = self.get(key)
                            except DependencyNotFoundError as e:
                                warnings.warn(
                                    ambigious_not_found_msg.format(key),
                                    DependencyNotFoundWarning
                                )
                            
                injected_kwargs.update(bound.kwargs)
                return function(*bound.args, **injected_kwargs)
            return wrapper
        if function:
            return decorator(function)
        return decorator"
2084,"def resolve(self, dependency):
        """"""
        Resolve dependency as instance attribute 
        of given class.

        >>> class Users:
        ...     db = injector.resolve(user_db)
        ...
        ...     def get_by_id(self, user_id):
        ...         return self.db.get(user_id)

                
        When the attribute is first accessed, it 
        will be resolved from the corresponding 
        dependency function
        """"""        
        if isinstance(dependency, str):
            name = dependency
        else:
            name = dependency._giveme_registered_name
            
        return DeferredProperty(
            partial(self.get, name)
        )"
2085,"def _fetch_itemslist(self, current_item):
        """""" Get a all available apis
        """"""
        if current_item.is_root:
            html = requests.get(self.base_url).text
            soup = BeautifulSoup(html, 'html.parser')
            for item_html in soup.select("".row .col-md-6""):
                try:
                    label = item_html.select_one(""h2"").text
                except Exception:
                    continue
                yield API(label, blob=item_html)
        else:
            # parameter = current_item.parent
            # data = requests.get(parameter.url)
            for resource in current_item.json[""resource""]:
                label = u""{}, {}"".format(resource[""title""], resource[""summary""])
                yield SMHIDataset(label, blob=resource)"
2086,"def _fetch_data(self, dataset, query={}, include_inactive_stations=False):
        """""" Should yield dataset rows
        """"""
        data = []
        parameter = dataset
        station_dim = dataset.dimensions[""station""]
        all_stations = station_dim.allowed_values
        # Step 1: Prepare query
        if ""station"" not in query:
            if include_inactive_stations:
                # Get all stations
                query[""station""] = list(all_stations)
            else:
                # Get only active stations
                query[""station""] = list(station_dim.active_stations())
        else:
            if not isinstance(query[""station""], list):
                query[""station""] = [query[""station""]]
            # Make sure that the queried stations actually exist
            query[""station""] = [ all_stations.get_by_label(x) for x in query[""station""]]

        if ""period"" not in query:
            # TODO: I'd prepare to do dataset.get(""period"").allowed_values here
            query[""period""] = PERIODS

        elif not isinstance(query[""period""], list):
            query[""period""] = [query[""period""]]

        for period in query[""period""]:
            if period not in PERIODS:
                msg = u""{} is not an allowed period"".format(period)
                raise Exception(msg)


        # Step 3: Get data
        n_queries = len(query[""station""]) * len(query[""period""])
        counter = 0
        print(""Fetching data with {} queries."".format(n_queries))
        for station in query[""station""]:
            for period in query[""period""]:
                url = dataset.url\
                    .replace("".json"", ""/station/{}/period/{}/data.csv""\
                        .format(station.key, period))
                print(""/GET {} "".format(url))
                r = requests.get(url)

                if r.status_code == 200:
                    raw_data = DataCsv().from_string(r.content).to_dictlist()

                    # TODO: This is a very hard coded parse function
                    # Expects fixed start row and number of cols
                    for row in raw_data:
                        #timepoint = datetime.strptime(timepoint_str, ""%Y-%m-%d %H:%M:%S"")
                        value_col = parameter.id.split("","")[0]
                        value = float(row[value_col])

                        row[""parameter""] = parameter.id
                        row[""station""] = station.label
                        row[""station_key""] = station.key
                        row[""period""] = period

                        row.pop(value_col,None)

                        datapoint = Result(value, row)

                        yield datapoint

                elif r.status_code == 404:
                    print(""Warning no data at {}"".format(url))
                else:
                    raise Exception(""Connection error for {}"".format(url))"
2087,"def _get_example_csv(self):
        """"""For dimension parsing
        """"""
        station_key = self.json[""station""][0][""key""]
        period = ""corrected-archive""
        url = self.url\
                  .replace("".json"", ""/station/{}/period/{}/data.csv""\
                  .format(station_key, period))

        r = requests.get(url)
        if r.status_code == 200:
            return DataCsv().from_string(r.content)
        else:
            raise Exception(""Error connecting to api"")"
2088,"def batch(iterable, length):
    """"""
    Returns a series of iterators across the inputted iterable method,
    broken into chunks based on the inputted length.
    
    :param      iterable | <iterable>  | (list, tuple, set, etc.)
                length   | <int> 
    
    :credit    http://en.sharejs.com/python/14362
    
    :return     <generator>
    
    :usage      |>>> import projex.iters
                |>>> for batch in projex.iters.batch(range(100), 10):
                |...    print list(batch)
                |[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
                |[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
                |[20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
                |[30, 31, 32, 33, 34, 35, 36, 37, 38, 39]
                |[40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
                |[50, 51, 52, 53, 54, 55, 56, 57, 58, 59]
                |[60, 61, 62, 63, 64, 65, 66, 67, 68, 69]
                |[70, 71, 72, 73, 74, 75, 76, 77, 78, 79]
                |[80, 81, 82, 83, 84, 85, 86, 87, 88, 89]
                |[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
    """"""
    source_iter = iter(iterable)
    while True:
        batch_iter = itertools.islice(source_iter, length)
        yield itertools.chain([batch_iter.next()], batch_iter)"
2089,"def group(iterable):
    """"""
    Creates a min/max grouping for the inputted list of numbers.  This
    will shrink a list into the group sets that are available.
    
    :param      iterable | <iterable> | (list, tuple, set, etc.)
    
    :return     <generator> [(<int> min, <int> max), ..]
    """"""
    numbers = sorted(list(set(iterable)))
    for _, grouper in itertools.groupby(numbers, key=lambda i, c=itertools.count(): i - next(c)):
        subset = list(grouper)
        yield subset[0], subset[-1]"
2090,"def plural(formatter, value, name, option, format):
    """"""Chooses different textension for locale-specific pluralization rules.

    Spec: `{:[p[lural]][(locale)]:msgstr0|msgstr1|...}`

    Example::

       >>> smart.format(u'There {num:is an item|are {} items}.', num=1}
       There is an item.
       >>> smart.format(u'There {num:is an item|are {} items}.', num=10}
       There are 10 items.

    """"""
    # Extract the plural words from the format string.
    words = format.split('|')
    # This extension requires at least two plural words.
    if not name and len(words) == 1:
        return
    # This extension only formats numbers.
    try:
        number = decimal.Decimal(value)
    except (ValueError, decimal.InvalidOperation):
        return
    # Get the locale.
    locale = Locale.parse(option) if option else formatter.locale
    # Select word based on the plural tag index.
    index = get_plural_tag_index(number, locale)
    return formatter.format(words[index], value)"
2091,"def get_choice(value):
    """"""Gets a key to choose a choice from any value.""""""
    if value is None:
        return 'null'
    for attr in ['__name__', 'name']:
        if hasattr(value, attr):
            return getattr(value, attr)
    return str(value)"
2092,"def choose(formatter, value, name, option, format):
    """"""Adds simple logic to format strings.

    Spec: `{:c[hoose](choice1|choice2|...):word1|word2|...[|default]}`

    Example::

       >>> smart.format(u'{num:choose(1|2|3):one|two|three|other}, num=1)
       u'one'
       >>> smart.format(u'{num:choose(1|2|3):one|two|three|other}, num=4)
       u'other'

    """"""
    if not option:
        return
    words = format.split('|')
    num_words = len(words)
    if num_words < 2:
        return
    choices = option.split('|')
    num_choices = len(choices)
    # If the words has 1 more item than the choices, the last word will be
    # used as a default choice.
    if num_words not in (num_choices, num_choices + 1):
        n = num_choices
        raise ValueError('specify %d or %d choices' % (n, n + 1))
    choice = get_choice(value)
    try:
        index = choices.index(choice)
    except ValueError:
        if num_words == num_choices:
            raise ValueError('no default choice supplied')
        index = -1
    return formatter.format(words[index], value)"
2093,"def list_(formatter, value, name, option, format):
    """"""Repeats the items of an array.

    Spec: `{:[l[ist]:]item|spacer[|final_spacer[|two_spacer]]}`

    Example::

       >>> fruits = [u'apple', u'banana', u'coconut']
       >>> smart.format(u'{fruits:list:{}|, |, and | and }', fruits=fruits)
       u'apple, banana, and coconut'
       >>> smart.format(u'{fruits:list:{}|, |, and | and }', fruits=fruits[:2])
       u'apple and banana'

    """"""
    if not format:
        return
    if not hasattr(value, '__getitem__') or isinstance(value, string_types):
        return
    words = format.split(u'|', 4)
    num_words = len(words)
    if num_words < 2:
        # Require at least two words for item format and spacer.
        return
    num_items = len(value)
    item_format = words[0]
    # NOTE: SmartFormat.NET treats a not nested item format as the format
    # string to format each items.  For example, `x` will be treated as `{:x}`.
    # But the original tells us this behavior has been deprecated so that
    # should be removed.  So SmartFormat for Python doesn't implement the
    # behavior.
    spacer = u'' if num_words < 2 else words[1]
    final_spacer = spacer if num_words < 3 else words[2]
    two_spacer = final_spacer if num_words < 4 else words[3]
    buf = io.StringIO()
    for x, item in enumerate(value):
        if x == 0:
            pass
        elif x < num_items - 1:
            buf.write(spacer)
        elif x == 1:
            buf.write(two_spacer)
        else:
            buf.write(final_spacer)
        buf.write(formatter.format(item_format, item, index=x))
    return buf.getvalue()"
2094,"def add_seconds(datetime_like_object, n, return_date=False):
    """"""
    Returns a time that n seconds after a time.

    :param datetimestr: a datetime object or a datetime str
    :param n: number of seconds, value can be negative

    **中文文档**

    返回给定日期N秒之后的时间。
    """"""
    a_datetime = parser.parse_datetime(datetime_like_object)
    a_datetime = a_datetime + timedelta(seconds=n)
    if return_date:  # pragma: no cover
        return a_datetime.date()
    else:
        return a_datetime"
2095,"def add_months(datetime_like_object, n, return_date=False):
    """"""
    Returns a time that n months after a time.

    Notice: for example, the date that one month after 2015-01-31 supposed
    to be 2015-02-31. But there's no 31th in Feb, so we fix that value to
    2015-02-28.

    :param datetimestr: a datetime object or a datetime str
    :param n: number of months, value can be negative
    :param return_date: returns a date object instead of datetime

    **中文文档**

    返回给定日期N月之后的时间。
    """"""
    a_datetime = parser.parse_datetime(datetime_like_object)
    month_from_ordinary = a_datetime.year * 12 + a_datetime.month
    month_from_ordinary += n
    year, month = divmod(month_from_ordinary, 12)

    # try assign year, month, day
    try:
        a_datetime = datetime(
            year, month, a_datetime.day,
            a_datetime.hour, a_datetime.minute, a_datetime.second,
            a_datetime.microsecond, tzinfo=a_datetime.tzinfo,
        )
    # 肯定是由于新的月份的日子不够, 所以肯定是月底,
    # 那么直接跳到下一个月的第一天, 再回退一天
    except ValueError:
        month_from_ordinary += 1
        year, month = divmod(month_from_ordinary, 12)
        a_datetime = datetime(
            year, month, 1,
            a_datetime.hour, a_datetime.minute, a_datetime.second,
            a_datetime.microsecond, tzinfo=a_datetime.tzinfo,
        )
        a_datetime = add_days(a_datetime, -1)

    if return_date:  # pragma: no cover
        return a_datetime.date()
    else:
        return a_datetime"
2096,"def add_years(datetime_like_object, n, return_date=False):
    """"""
    Returns a time that n years after a time.

    :param datetimestr: a datetime object or a datetime str
    :param n: number of years, value can be negative
    :param return_date: returns a date object instead of datetime

    **中文文档**

    返回给定日期N年之后的时间。
    """"""
    a_datetime = parser.parse_datetime(datetime_like_object)

    # try assign year, month, day
    try:
        a_datetime = datetime(
            a_datetime.year + n, a_datetime.month, a_datetime.day,
            a_datetime.hour, a_datetime.minute, a_datetime.second,
            a_datetime.microsecond, tzinfo=a_datetime.tzinfo,
        )
    except ValueError:  # Must be xxxx-02-29
        a_datetime = datetime(
            a_datetime.year + n, 2, 28,
            a_datetime.hour, a_datetime.minute,
            a_datetime.second, a_datetime.microsecond)

    if return_date:  # pragma: no cover
        return a_datetime.date()
    else:
        return a_datetime"
2097,"def _floor_to(dt, hour, minute, second):
    """"""
    Route the given datetime to the latest time with the hour, minute, second
    before it.
    """"""
    new_dt = dt.replace(hour=hour, minute=minute, second=second)
    if new_dt <= dt:
        return new_dt
    else:
        return new_dt - timedelta(days=1)"
2098,"def _round_to(dt, hour, minute, second):
    """"""
    Route the given datetime to the latest time with the hour, minute, second
    before it.
    """"""
    new_dt = dt.replace(hour=hour, minute=minute, second=second)
    if new_dt == dt:
        return new_dt
    elif new_dt < dt:
        before = new_dt
        after = new_dt + timedelta(days=1)
    elif new_dt > dt:
        before = new_dt - timedelta(days=1)
        after = new_dt

    d1 = dt - before
    d2 = after - dt

    if d1 < d2:
        return before
    elif d1 > d2:
        return after
    else:
        return before"
2099,"def round_to(dt, hour, minute, second, mode=""round""):
    """"""
    Round the given datetime to specified hour, minute and second.

    :param mode: 'floor' or 'ceiling'

    .. versionadded:: 0.0.5

        message


    **中文文档**

    将给定时间对齐到最近的一个指定了小时, 分钟, 秒的时间上。
    """"""
    mode = mode.lower()
    if mode not in _round_to_options:
        raise ValueError(
            ""'mode' has to be one of %r!"" % list(_round_to_options.keys()))
    return _round_to_options[mode](dt, hour, minute, second)"
2100,"def _log(self, content):
        """"""
        Write a string to the log
        """"""
        self._buffer += content
        if self._auto_flush:
            self.flush()"
2101,"def reset(self):
        """"""
        Erase the log and reset the timestamp
        """"""
        self._buffer = ''
        self._chars_flushed = 0
        self._game_start_timestamp = datetime.datetime.now()"
2102,"def logpath(self):
        """"""
        Return the logfile path and filename as a string.

        The file with name self.logpath() is written to on flush().

        The filename contains the log's timestamp and the names of players in the game.
        The logpath changes when reset() or _set_players() are called, as they change the
        timestamp and the players, respectively.
        """"""
        name = '{}-{}.catan'.format(self.timestamp_str(),
                                    '-'.join([p.name for p in self._players]))
        path = os.path.join(self._log_dir, name)
        if not os.path.exists(self._log_dir):
            os.mkdir(self._log_dir)
        return path"
2103,"def flush(self):
        """"""
        Append the latest updates to file, or optionally to stdout instead. See the constructor
        for logging options.
        """"""
        latest = self._latest()
        self._chars_flushed += len(latest)
        if self._use_stdout:
            file = sys.stdout
        else:
            file = open(self.logpath(), 'a')

        print(latest, file=file, flush=True, end='')

        if not self._use_stdout:
            file.close()"
2104,"def log_game_start(self, players, terrain, numbers, ports):
        """"""
        Begin a game.

        Erase the log, set the timestamp, set the players, and write the log header.

        The robber is assumed to start on the desert (or off-board).

        :param players: iterable of catan.game.Player objects
        :param terrain: list of 19 catan.board.Terrain objects.
        :param numbers: list of 19 catan.board.HexNumber objects.
        :param ports: list of catan.board.Port objects.
        """"""
        self.reset()
        self._set_players(players)
        self._logln('{} v{}'.format(__name__, __version__))
        self._logln('timestamp: {0}'.format(self.timestamp_str()))
        self._log_players(players)
        self._log_board_terrain(terrain)
        self._log_board_numbers(numbers)
        self._log_board_ports(ports)
        self._logln('...CATAN!')"
2105,"def log_player_roll(self, player, roll):
        """"""
        :param player: catan.game.Player
        :param roll: integer or string, the sum of the dice
        """"""
        self._logln('{0} rolls {1}{2}'.format(player.color, roll, ' ...DEUCES!' if int(roll) == 2 else ''))"
2106,"def log_player_buys_road(self, player, location):
        """"""
        :param player: catan.game.Player
        :param location: string, see hexgrid.location()
        """"""
        self._logln('{0} buys road, builds at {1}'.format(
            player.color,
            location
        ))"
2107,"def log_player_buys_settlement(self, player, location):
        """"""
        :param player: catan.game.Player
        :param location: string, see hexgrid.location()
        """"""
        self._logln('{0} buys settlement, builds at {1}'.format(
            player.color,
            location
        ))"
2108,"def log_player_buys_city(self, player, location):
        """"""
        :param player: catan.game.Player
        :param location: string, see hexgrid.location()
        """"""
        self._logln('{0} buys city, builds at {1}'.format(
            player.color,
            location
        ))"
2109,"def log_player_trades_with_port(self, player, to_port, port, to_player):
        """"""
        :param player: catan.game.Player
        :param to_port: list of tuples, [(int, game.board.Terrain), (int, game.board.Terrain)]
        :param port: catan.board.Port
        :param to_player: list of tuples, [(int, game.board.Terrain), (int, game.board.Terrain)]
        """"""
        self._log('{0} trades '.format(player.color))

        # to_port items
        self._log('[')
        for i, (num, res) in enumerate(to_port):
            if i > 0:
                self._log(', ')
            self._log('{0} {1}'.format(num, res.value))
        self._log(']')

        self._log(' to port {0} for '.format(port.type.value))

        # to_player items
        self._log('[')
        for i, (num, res) in enumerate(to_player):
            if i > 0:
                self._log(', ')
            self._log('{0} {1}'.format(num, res.value))
        self._log(']')

        self._log('\n')"
2110,"def log_player_trades_with_other_player(self, player, to_other, other, to_player):
        """"""
        :param player: catan.game.Player
        :param to_other: list of tuples, [(int, game.board.Terrain), (int, game.board.Terrain)]
        :param other: catan.board.Player
        :param to_player: list of tuples, [(int, game.board.Terrain), (int, game.board.Terrain)]
        """"""
        self._log('{0} trades '.format(player.color))

        # to_other items
        self._log('[')
        for i, (num, res) in enumerate(to_other):
            if i > 0:
                self._log(', ')
            self._log('{0} {1}'.format(num, res.value))
        self._log(']')

        self._log(' to player {0} for '.format(other.color))

        # to_player items
        self._log('[')
        for i, (num, res) in enumerate(to_player):
            if i > 0:
                self._log(', ')
            self._log('{0} {1}'.format(num, res.value))
        self._log(']')

        self._log('\n')"
2111,"def log_player_plays_knight(self, player, location, victim):
        """"""
        :param player: catan.game.Player
        :param location: string, see hexgrid.location()
        :param victim: catan.game.Player
        """"""
        self._logln('{0} plays knight'.format(player.color))
        self.log_player_moves_robber_and_steals(player, location, victim)"
2112,"def log_player_plays_road_builder(self, player, location1, location2):
        """"""
        :param player: catan.game.Player
        :param location1: string, see hexgrid.location()
        :param location2: string, see hexgrid.location()
        """"""
        self._logln('{0} plays road builder, builds at {1} and {2}'.format(
            player.color,
            location1,
            location2
        ))"
2113,"def log_player_plays_year_of_plenty(self, player, resource1, resource2):
        """"""
        :param player: catan.game.Player
        :param resource1: catan.board.Terrain
        :param resource2: catan.board.Terrain
        """"""
        self._logln('{0} plays year of plenty, takes {1} and {2}'.format(
            player.color,
            resource1.value,
            resource2.value
        ))"
2114,"def log_player_plays_monopoly(self, player, resource):
        """"""
        :param player: catan.game.Player
        :param resource: catan.board.Terrain
        """"""
        self._logln('{0} plays monopoly on {1}'.format(
            player.color,
            resource.value
        ))"
2115,"def log_player_ends_turn(self, player):
        """"""
        :param player: catan.game.Player
        """"""
        seconds_delta = (datetime.datetime.now() - self._latest_timestamp).total_seconds()
        self._logln('{0} ends turn after {1}s'.format(player.color, round(seconds_delta)))
        self._latest_timestamp = datetime.datetime.now()"
2116,"def _log_board_terrain(self, terrain):
        """"""
        Tiles are logged counterclockwise beginning from the top-left.
        See module hexgrid (https://github.com/rosshamish/hexgrid) for the tile layout.

        :param terrain: list of catan.board.Terrain objects
        """"""
        self._logln('terrain: {0}'.format(' '.join(t.value for t in terrain)))"
2117,"def _log_board_numbers(self, numbers):
        """"""
        Numbers are logged counterclockwise beginning from the top-left.
        See module hexgrid (https://github.com/rosshamish/hexgrid) for the tile layout.

        :param numbers: list of catan.board.HexNumber objects.
        """"""
        self._logln('numbers: {0}'.format(' '.join(str(n.value) for n in numbers)))"
2118,"def _log_board_ports(self, ports):
        """"""
        A board with no ports is allowed.

        In the logfile, ports must be sorted
        - ascending by tile identifier (primary)
        - alphabetical by edge direction (secondary)

        :param ports: list of catan.board.Port objects
        """"""
        ports = sorted(ports, key=lambda port: (port.tile_id, port.direction))
        self._logln('ports: {0}'.format(' '.join('{}({} {})'.format(p.type.value, p.tile_id, p.direction)
                                                for p in ports)))"
2119,"def _log_players(self, players):
        """"""
        :param players: list of catan.game.Player objects
        """"""
        self._logln('players: {0}'.format(len(players)))
        for p in self._players:
            self._logln('name: {0}, color: {1}, seat: {2}'.format(p.name, p.color, p.seat))"
2120,"def _set_players(self, _players):
        """"""
        Players will always be set in seat order (1,2,3,4)
        """"""
        self._players = list()
        _players = list(_players)
        _players.sort(key=lambda p: p.seat)
        for p in _players:
            self._players.append(p)"
2121,"def _SetGuide(self, guideName):
    """"""
    Select guide corresponding to guideName

    Parameters
    ----------
      guideName : string
        Name of guide to use.

    Note
    ----------
    Supported guide names are: EPGUIDES
    """"""
    if(guideName == epguides.EPGuidesLookup.GUIDE_NAME):
      self._guide = epguides.EPGuidesLookup()
    else:
      raise Exception(""[RENAMER] Unknown guide set for TVRenamer selection: Got {}, Expected {}"".format(guideName, epguides.EPGuidesLookup.GUIDE_NAME))"
2122,"def _GetUniqueFileShowNames(self, tvFileList):
    """"""
    Return a list containing all unique show names from tvfile.TVFile object
    list.

    Parameters
    ----------
      tvFileList : list
        List of tvfile.TVFile objects.

    Returns
    ----------
      set
        The set of show names from the tvfile.TVFile list.
    """"""
    showNameList = [tvFile.fileInfo.showName for tvFile in tvFileList]
    return(set(showNameList))"
2123,"def _GetShowID(self, stringSearch, origStringSearch = None):
    """"""
    Search for given string as an existing entry in the database file name
    table or, if no match is found, as a show name from the TV guide.

    If an exact match is not found in the database the user can accept
    or decline the best match from the TV guide or can provide an alternate
    match to lookup.

    Parameters
    ----------
      stringSearch : string
        String to look up in database or guide.

      origStringSearch : string [optional: default = None]
        Original search string, used by recusive function calls.

    Returns
    ----------
      tvfile.ShowInfo or None
        If no show id could be found this returns None, otherwise
        it returns a tvfile.ShowInfo object containing show name
        and show id.
    """"""
    showInfo = tvfile.ShowInfo()

    if origStringSearch is None:
      goodlogging.Log.Info(""RENAMER"", ""Looking up show ID for: {0}"".format(stringSearch))
      origStringSearch = stringSearch

    goodlogging.Log.IncreaseIndent()

    showInfo.showID = self._db.SearchFileNameTable(stringSearch)

    if showInfo.showID is None:
      goodlogging.Log.Info(""RENAMER"", ""No show ID match found for '{0}' in database"".format(stringSearch))
      showNameList = self._guide.ShowNameLookUp(stringSearch)

      if self._skipUserInput is True:
        if len(showNameList) == 1:
          showName = showNameList[0]
          goodlogging.Log.Info(""RENAMER"", ""Automatic selection of showname: {0}"".format(showName))
        else:
          showName = None
          goodlogging.Log.Info(""RENAMER"", ""Show skipped - could not make automatic selection of showname"")
      else:
        showName = util.UserAcceptance(showNameList)

      if showName in showNameList:
        libEntry = self._db.SearchTVLibrary(showName = showName)

        if libEntry is None:
          if self._skipUserInput is True:
            response = 'y'
          else:
            goodlogging.Log.Info(""RENAMER"", ""No show by this name found in TV library database. Is this a new show for the database?"")
            response = goodlogging.Log.Input(""RENAMER"", ""Enter 'y' (yes), 'n' (no) or 'ls' (list existing shows): "")
            response = util.ValidUserResponse(response, ('y', 'n', 'ls'))

            if response.lower() == 'ls':
              dbLibList = self._db.SearchTVLibrary()
              if dbLibList is None:
                goodlogging.Log.Info(""RENAMER"", ""TV library is empty"")
                response = 'y'
              else:
                dbShowNameList = [i[1] for i in dbLibList]
                dbShowNameStr = ', '.join(dbShowNameList)
                goodlogging.Log.Info(""RENAMER"", ""Existing shows in database are: {0}"".format(dbShowNameStr))
                response = goodlogging.Log.Input(""RENAMER"", ""Is this a new show? [y/n]: "")
                response = util.ValidUserResponse(response, ('y', 'n'))
          if response.lower() == 'y':
            showInfo.showID = self._db.AddShowToTVLibrary(showName)
            showInfo.showName = showName
          else:
            try:
              dbShowNameList
            except NameError:
              dbLibList = self._db.SearchTVLibrary()
              if dbLibList is None:
                goodlogging.Log.Info(""RENAMER"", ""No show ID found - TV library is empty"")
                return None
              dbShowNameList = [i[1] for i in dbLibList]

            while showInfo.showID is None:
              matchShowList = util.GetBestMatch(showName, dbShowNameList)
              showName = util.UserAcceptance(matchShowList)
              if showName is None:
                goodlogging.Log.Info(""RENAMER"", ""No show ID found - could not match to existing show"")
                return None
              elif showName in matchShowList:
                showInfo.showID = self._db.SearchTVLibrary(showName = showName)[0][0]
                showInfo.showName = showName

        else:
          showInfo.showID = libEntry[0][0]

        self._db.AddToFileNameTable(origStringSearch, showInfo.showID)

        goodlogging.Log.DecreaseIndent()
        return showInfo
      elif showName is None:
        goodlogging.Log.DecreaseIndent()
        return None
      else:
        goodlogging.Log.DecreaseIndent()
        return self._GetShowID(showName, origStringSearch)
    else:
      goodlogging.Log.Info(""RENAMER"", ""Match found: show ID = {0}"".format(showInfo.showID))
      if origStringSearch != stringSearch:
        self._db.AddToFileNameTable(origStringSearch, showInfo.showID)
      goodlogging.Log.DecreaseIndent()
      return showInfo"
2124,"def _GetShowInfo(self, stringSearch):
    """"""
    Calls GetShowID and does post processing checks on result.

    Parameters
    ----------
      stringSearch : string
        String to look up in database or guide.

    Returns
    ----------
      tvfile.ShowInfo or None
        If GetShowID returns None or if it returns showInfo with showID = None
        then this will return None, otherwise it will return the showInfo object.
    """"""
    goodlogging.Log.Info(""RENAMER"", ""Looking up show info for: {0}"".format(stringSearch))
    goodlogging.Log.IncreaseIndent()
    showInfo = self._GetShowID(stringSearch)
    if showInfo is None:
      goodlogging.Log.DecreaseIndent()
      return None
    elif showInfo.showID is None:
      goodlogging.Log.DecreaseIndent()
      return None
    elif showInfo.showName is None:
      showInfo.showName = self._db.SearchTVLibrary(showID = showInfo.showID)[0][1]
      goodlogging.Log.Info(""RENAMER"", ""Found show name: {0}"".format(showInfo.showName))
      goodlogging.Log.DecreaseIndent()
      return showInfo
    else:
      goodlogging.Log.DecreaseIndent()
      return showInfo"
2125,"def _MoveFileToLibrary(self, oldPath, newPath):
    """"""
    Move file from old file path to new file path. This follows certain
    conditions:

      - If file already exists at destination do rename inplace.
      - If file destination is on same file system and doesn't exist rename and move.
      - If source and destination are on different file systems do rename in-place,
        and if forceCopy is true copy to dest and move orig to archive directory.

    Parameters
    ----------
      oldPath : string
        Old file path.

      newPath : string
        New file path.

    Returns
    ----------
      boolean
        If old and new file paths are the same or if the new file path already exists
        this returns False. If file rename is skipped for any reason this returns None
        otherwise if rename completes okay it returns True.
    """"""
    if oldPath == newPath:
      return False

    goodlogging.Log.Info(""RENAMER"", ""PROCESSING FILE: {0}"".format(oldPath))

    if os.path.exists(newPath):
      goodlogging.Log.Info(""RENAMER"", ""File skipped - file aleady exists in TV library at {0}"".format(newPath))
      return False

    newDir = os.path.dirname(newPath)
    os.makedirs(newDir, exist_ok=True)

    try:
      os.rename(oldPath, newPath)
    except OSError as ex:
      if ex.errno is errno.EXDEV:
        goodlogging.Log.Info(""RENAMER"", ""Simple rename failed - source and destination exist on different file systems"")
        goodlogging.Log.Info(""RENAMER"", ""Renaming file in-place"")
        newFileName = os.path.basename(newPath)
        origFileDir = os.path.dirname(oldPath)
        renameFilePath = os.path.join(origFileDir, newFileName)
        if oldPath != renameFilePath:
          renameFilePath = util.CheckPathExists(renameFilePath)
          goodlogging.Log.Info(""RENAMER"", ""Renaming from {0} to {1}"".format(oldPath, renameFilePath))
        else:
          goodlogging.Log.Info(""RENAMER"", ""File already has the correct name ({0})"".format(newFileName))

        try:
          os.rename(oldPath, renameFilePath)
        except Exception as ex2:
          goodlogging.Log.Info(""RENAMER"", ""File rename skipped - Exception ({0}): {1}"".format(ex2.args[0], ex2.args[1]))
        else:
          if self._forceCopy is True:
            goodlogging.Log.Info(""RENAMER"", ""Copying file to new file system {0} to {1}"".format(renameFilePath, newPath))

            try:
              shutil.copy2(renameFilePath, newPath)
            except shutil.Error as ex3:
              err = ex3.args[0]
              goodlogging.Log.Info(""RENAMER"", ""File copy failed - Shutil Error: {0}"".format(err))
            else:
              util.ArchiveProcessedFile(renameFilePath, self._archiveDir)
              return True
          else:
            goodlogging.Log.Info(""RENAMER"", ""File copy skipped - copying between file systems is disabled (enabling this functionality is slow)"")
      else:
        goodlogging.Log.Info(""RENAMER"", ""File rename skipped - Exception ({0}): {1}"".format(ex.args[0], ex.args[1]))
    except Exception as ex:
      goodlogging.Log.Info(""RENAMER"", ""File rename skipped - Exception ({0}): {1}"".format(ex.args[0], ex.args[1]))
    else:
      goodlogging.Log.Info(""RENAMER"", ""RENAME COMPLETE: {0}"".format(newPath))
      return True"
2126,"def _CreateNewSeasonDir(self, seasonNum):
    """"""
    Creates a new season directory name in the form 'Season <NUM>'.

    If skipUserInput is True this will be accepted by default otherwise the
    user can choose to accept this, use the base show directory or enter
    a different name.

    Parameters
    ----------
      seasonNum : int
        Season number.

    Returns
    ----------
      string or None
        If the user accepts the generated directory name or gives a new name
        this will be returned. If it the user chooses to use the base
        directory an empty string is returned. If the user chooses to skip at
        this input stage None is returned.
    """"""
    seasonDirName = ""Season {0}"".format(seasonNum)
    goodlogging.Log.Info(""RENAMER"", ""Generated directory name: '{0}'"".format(seasonDirName))

    if self._skipUserInput is False:
      response = goodlogging.Log.Input(""RENAMER"", ""Enter 'y' to accept this directory, 'b' to use base show directory, 'x' to skip this file or enter a new directory name to use: "")
      response = util.CheckEmptyResponse(response)
    else:
      response = 'y'

    if response.lower() == 'b':
      return ''
    elif response.lower() == 'y':
      return seasonDirName
    elif response.lower() == 'x':
      return None
    else:
      return response"
2127,"def _LookUpSeasonDirectory(self, showID, showDir, seasonNum):
    """"""
    Look up season directory. First attempt to find match from database,
    otherwise search TV show directory. If no match is found in the database
    the user can choose to accept a match from the TV show directory, enter
    a new directory name to use or accept an autogenerated name.

    Parameters
    ----------
      showID : int
        Show ID number

      showDir : string
        Path to show file directory

      seasonNum : int
        Season number

    Returns
    ----------
      string
        Name of season directory to use. This can be a blank string to
        use the root show directory, an autogenerated string or a user
        given string.
    """"""
    goodlogging.Log.Info(""RENAMER"", ""Looking up season directory for show {0}"".format(showID))
    goodlogging.Log.IncreaseIndent()

    # Look up existing season folder from database
    seasonDirName = self._db.SearchSeasonDirTable(showID, seasonNum)

    if seasonDirName is not None:
      goodlogging.Log.Info(""RENAMER"", ""Found season directory match from database: {0}"".format(seasonDirName))
    else:
      # Look up existing season folder in show directory
      goodlogging.Log.Info(""RENAMER"", ""Looking up season directory (Season {0}) in {1}"".format(seasonNum, showDir))
      if os.path.isdir(showDir) is False:
        goodlogging.Log.Info(""RENAMER"", ""Show directory ({0}) is not an existing directory"".format(showDir))
        seasonDirName = self._CreateNewSeasonDir(seasonNum)
      else:
        matchDirList = []
        for dirName in os.listdir(showDir):
          subDir = os.path.join(showDir, dirName)
          if os.path.isdir(subDir):
            seasonResult = re.findall(""Season"", dirName)
            if len(seasonResult) > 0:
              numResult = re.findall(""[0-9]+"", dirName)
              numResult = set(numResult)
              if len(numResult) == 1:
                if int(numResult.pop()) == int(seasonNum):
                  matchDirList.append(dirName)

        if self._skipUserInput is True:
          if len(matchDirList) == 1:
            userAcceptance = matchDirList[0]
            goodlogging.Log.Info(""RENAMER"", ""Automatic selection of season directory: {0}"".format(seasonDirName))
          else:
            userAcceptance = None
            goodlogging.Log.Info(""RENAMER"", ""Could not make automatic selection of season directory"")
        else:
          listDirPrompt = ""enter 'ls' to list all items in show directory""
          userAcceptance = util.UserAcceptance(matchDirList, promptComment = listDirPrompt, xStrOverride = ""to create new season directory"")

        if userAcceptance in matchDirList:
          seasonDirName = userAcceptance
        elif userAcceptance is None:
          seasonDirName = self._CreateNewSeasonDir(seasonNum)
        else:
          recursiveSelectionComplete = False
          promptOnly = False
          dirLookup = userAcceptance
          while recursiveSelectionComplete is False:
            dirList = os.listdir(showDir)
            if dirLookup.lower() == 'ls':
              dirLookup = ''
              promptOnly = True
              if len(dirList) == 0:
                goodlogging.Log.Info(""RENAMER"", ""Show directory is empty"")
              else:
                goodlogging.Log.Info(""RENAMER"", ""Show directory contains: {0}"".format(', '.join(dirList)))
            else:
              matchDirList = util.GetBestMatch(dirLookup, dirList)
              response = util.UserAcceptance(matchDirList, promptComment = listDirPrompt, promptOnly = promptOnly, xStrOverride = ""to create new season directory"")
              promptOnly = False

              if response in matchDirList:
                seasonDirName = response
                recursiveSelectionComplete = True
              elif response is None:
                seasonDirName = self._CreateNewSeasonDir(seasonNum)
                recursiveSelectionComplete = True
              else:
                dirLookup = response

      # Add season directory to database
      if seasonDirName is not None:
        self._db.AddSeasonDirTable(showID, seasonNum, seasonDirName)

    goodlogging.Log.DecreaseIndent()
    return seasonDirName"
2128,"def _CreateNewShowDir(self, showName):
    """"""
    Create new directory name for show. An autogenerated choice, which is the
    showName input that has been stripped of special characters, is proposed
    which the user can accept or they can enter a new name to use. If the
    skipUserInput variable is True the autogenerated value is accepted
    by default.

    Parameters
    ----------
      showName : string
        Name of TV show

    Returns
    ----------
      string or None
        Either the autogenerated directory name, the user given directory name
        or None if the user chooses to skip at this input stage.
    """"""
    stripedDir = util.StripSpecialCharacters(showName)
    goodlogging.Log.Info(""RENAMER"", ""Suggested show directory name is: '{0}'"".format(stripedDir))

    if self._skipUserInput is False:
      response = goodlogging.Log.Input('RENAMER', ""Enter 'y' to accept this directory, 'x' to skip this show or enter a new directory to use: "")
    else:
      response = 'y'

    if response.lower() == 'x':
      return None
    elif response.lower() == 'y':
      return stripedDir
    else:
      return response"
2129,"def _GenerateLibraryPath(self, tvFile, libraryDir):
    """"""
    Creates a full path for TV file in TV library.

    This initially attempts to directly match a show directory in the database,
    if this fails it searches the library directory for the best match. The
    user can then select an existing match or can propose a new directory to
    use as the show root directory.

    The season directory is also generated and added to the show and
    library directories. This is then used by the tvFile GenerateNewFilePath
    method to create a new path for the file.

    Parameters
    ----------
      tvFile : tvfile.TVFile
        Contains show and file info.

      libraryDir : string
        Root path of TV library directory.

    Returns
    ----------
      tvfile.TVFile
        This is an updated version of the input object.
    """"""
    goodlogging.Log.Info(""RENAMER"", ""Looking up library directory in database for show: {0}"".format(tvFile.showInfo.showName))
    goodlogging.Log.IncreaseIndent()
    showID, showName, showDir = self._db.SearchTVLibrary(showName = tvFile.showInfo.showName)[0]

    if showDir is None:
      goodlogging.Log.Info(""RENAMER"", ""No directory match found in database - looking for best match in library directory: {0}"".format(libraryDir))
      dirList = os.listdir(libraryDir)
      listDir = False
      matchName = tvFile.showInfo.showName
      while showDir is None:
        if len(dirList) == 0:
          goodlogging.Log.Info(""RENAMER"", ""TV Library directory is empty"")
          response = None
        else:
          if listDir is True:
            goodlogging.Log.Info(""RENAMER"", ""TV library directory contains: {0}"".format(', '.join(dirList)))
          else:
            matchDirList = util.GetBestMatch(matchName, dirList)

          listDir = False

          if self._skipUserInput is True:
            if len(matchDirList) == 1:
              response = matchDirList[0]
              goodlogging.Log.Info(""RENAMER"", ""Automatic selection of show directory: {0}"".format(response))
            else:
              response = None
              goodlogging.Log.Info(""RENAMER"", ""Could not make automatic selection of show directory"")
          else:
            listDirPrompt = ""enter 'ls' to list all items in TV library directory""
            response = util.UserAcceptance(matchDirList, promptComment = listDirPrompt, promptOnly = listDir, xStrOverride = ""to create new show directory"")

        if response is None:
          showDir = self._CreateNewShowDir(tvFile.showInfo.showName)
          if showDir is None:
            goodlogging.Log.DecreaseIndent()
            return tvFile
        elif response.lower() == 'ls':
          listDir = True
        elif response in matchDirList:
          showDir = response
        else:
          matchName = response

      self._db.UpdateShowDirInTVLibrary(showID, showDir)

    # Add base directory to show path
    showDir = os.path.join(libraryDir, showDir)

    goodlogging.Log.DecreaseIndent()

    # Lookup and add season directory to show path
    seasonDir = self._LookUpSeasonDirectory(showID, showDir, tvFile.showInfo.seasonNum)

    if seasonDir is None:
      return tvFile
    else:
      showDir = os.path.join(showDir, seasonDir)

    # Call tvFile function to generate file name
    tvFile.GenerateNewFilePath(showDir)

    return tvFile"
2130,"def Run(self):
    """"""
    Renames all TV files from the constructor given file list.

    It follows a number of key steps:

      1) Extract a list of unique show titles from file name and lookup
         actual show names from database or TV guide.
      2) Update each file with showID and showName.
      3) Get episode name for all remaining files in valid list.
      4) Print file details and generate new file paths.
      5) Rename files.
      6) List skipped and incompatible files.
    """"""
    # ------------------------------------------------------------------------
    # Get list of unique fileInfo show names and find matching actual show
    # names from database or TV guide
    # ------------------------------------------------------------------------
    showNameMatchDict = {}
    uniqueFileShowList = self._GetUniqueFileShowNames(self._fileList)
    if len(uniqueFileShowList) > 0:
      goodlogging.Log.Seperator()

    for fileShowName in uniqueFileShowList:
      showNameMatchDict[fileShowName] = self._GetShowInfo(fileShowName)
      goodlogging.Log.NewLine()

    # ------------------------------------------------------------------------
    # Update each file with showID and showName
    # ------------------------------------------------------------------------
    incompatibleFileList = []
    validShowFileList = []

    for tvFile in self._fileList:
      if showNameMatchDict[tvFile.fileInfo.showName] is None:
        incompatibleFileList.append(tvFile)
      else:
        tvFile.showInfo.showID = showNameMatchDict[tvFile.fileInfo.showName].showID
        tvFile.showInfo.showName = showNameMatchDict[tvFile.fileInfo.showName].showName
        validShowFileList.append(tvFile)

    # ------------------------------------------------------------------------
    # Get episode name for all remaining files in valid list
    # ------------------------------------------------------------------------
    if len(validShowFileList) > 0:
      goodlogging.Log.Seperator()

    validEpisodeNameFileList = []

    goodlogging.Log.Info(""RENAMER"", ""Looking up episode names:\n"")

    for tvFile in validShowFileList:
      tvFile.showInfo.episodeName = self._guide.EpisodeNameLookUp(tvFile.showInfo.showName, tvFile.showInfo.seasonNum, tvFile.showInfo.episodeNum)

      if tvFile.showInfo.episodeName is None:
        incompatibleFileList.append(tvFile)
      else:
        validEpisodeNameFileList.append(tvFile)

      goodlogging.Log.Info(""RENAMER"", ""{0} S{1}E{2}: {3}"".format(tvFile.showInfo.showName, tvFile.showInfo.seasonNum, tvFile.showInfo.episodeNum, tvFile.showInfo.episodeName))

    goodlogging.Log.NewLine()

    # ------------------------------------------------------------------------
    # Print file details and generate new file paths
    # ------------------------------------------------------------------------
    goodlogging.Log.Seperator()

    renameFileList = []
    skippedFileList = []

    goodlogging.Log.Info(""RENAMER"", ""Generating library paths:\n"")

    if len(validEpisodeNameFileList) == 0:
      goodlogging.Log.Info(""RENAMER"", ""No compatible files were detected"")
    else:
      for tvFile in validEpisodeNameFileList:
        tvFile.Print()
        goodlogging.Log.NewLine()
        if self._inPlaceRename is False:
          tvFile = self._GenerateLibraryPath(tvFile, self._tvDir)
        else:
          tvFile.GenerateNewFilePath()

        if tvFile.fileInfo.newPath is None:
          incompatibleFileList.append(tvFile)
        elif tvFile.fileInfo.origPath != tvFile.fileInfo.newPath:
          renameFileList.append(tvFile)
        else:
          skippedFileList.append(tvFile)

        goodlogging.Log.NewLine()

      # ------------------------------------------------------------------------
      # Rename files
      # ------------------------------------------------------------------------
      goodlogging.Log.Seperator()

      goodlogging.Log.Info(""RENAMER"", ""Renamable files:\n"")

      if len(renameFileList) == 0:
        goodlogging.Log.Info(""RENAMER"", ""No renamable files were detected"")
      else:
        showName = None
        renameFileList.sort()

        for tvFile in renameFileList:
          if showName is None or showName != tvFile.showInfo.showName:
            showName = tvFile.showInfo.showName
            goodlogging.Log.Info(""RENAMER"", ""{0}"".format(showName))
          goodlogging.Log.IncreaseIndent()
          goodlogging.Log.Info(""RENAMER"", ""FROM: {0}"".format(tvFile.fileInfo.origPath))
          goodlogging.Log.Info(""RENAMER"", ""TO:   {0}"".format(tvFile.fileInfo.newPath))
          goodlogging.Log.DecreaseIndent()
          goodlogging.Log.NewLine()

        if self._skipUserInput is False:
          response = goodlogging.Log.Input('RENAMER', ""***WARNING*** CONTINUE WITH RENAME PROCESS? [y/n]: "")
          response = util.ValidUserResponse(response, ('y','n'))
        else:
          response = 'y'

        if response == 'n':
          goodlogging.Log.Info(""RENAMER"", ""Renaming process skipped"")
        elif response == 'y':
          goodlogging.Log.NewLine()
          if self._inPlaceRename is False:
            goodlogging.Log.Info(""RENAMER"", ""Adding files to TV library:\n"")
          else:
            goodlogging.Log.Info(""RENAMER"", ""Renaming files:\n"")
          for tvFile in renameFileList:
            self._MoveFileToLibrary(tvFile.fileInfo.origPath, tvFile.fileInfo.newPath)
            goodlogging.Log.NewLine()

    # ------------------------------------------------------------------------
    # List skipped files
    # ------------------------------------------------------------------------
    if len(skippedFileList) > 0:
      goodlogging.Log.Seperator()
      goodlogging.Log.Info(""RENAMER"", ""Skipped files:"")
      goodlogging.Log.IncreaseIndent()
      for tvFile in skippedFileList:
        if tvFile.fileInfo.origPath == tvFile.fileInfo.newPath:
          goodlogging.Log.Info(""RENAMER"", ""{0} (No rename required)"".format(tvFile.fileInfo.origPath))
        else:
          goodlogging.Log.Info(""RENAMER"", ""{0} (Unknown reason)"".format(tvFile.fileInfo.origPath))
      goodlogging.Log.DecreaseIndent()

    # ------------------------------------------------------------------------
    # List incompatible files
    # ------------------------------------------------------------------------
    if len(incompatibleFileList) > 0:
      goodlogging.Log.Seperator()
      goodlogging.Log.Info(""RENAMER"", ""Incompatible files:"")
      goodlogging.Log.IncreaseIndent()
      for tvFile in incompatibleFileList:
        if tvFile.showInfo.showName is None:
          goodlogging.Log.Info(""RENAMER"", ""{0} (Missing show name)"".format(tvFile.fileInfo.origPath))
        elif tvFile.showInfo.episodeName is None:
          goodlogging.Log.Info(""RENAMER"", ""{0} (Missing episode name)"".format(tvFile.fileInfo.origPath))
        elif tvFile.fileInfo.newPath is None:
          goodlogging.Log.Info(""RENAMER"", ""{0} (Failed to create new file path)"".format(tvFile.fileInfo.origPath))
        else:
          goodlogging.Log.Info(""RENAMER"", ""{0} (Unknown reason)"".format(tvFile.fileInfo.origPath))
      goodlogging.Log.DecreaseIndent()"
2131,"def get_api_publisher(self, social_user):
        """"""
            message: <str>
            image: <file> as object_attachment
            owner_id: <str>
        """"""

        def _post(owner_id=None, **kwargs):
            api = self.get_api(social_user, owner_id)
            return api.post('{}/feed'.format(owner_id or 'me'), params=kwargs)

        return _post"
2132,"def catch(ignore=[],
          was_doing=""something important"",
          helpfull_tips=""you should use a debugger"",
          gbc=None):
    """"""
    Catch, prepare and log error

    :param exc_cls: error class
    :param exc: exception
    :param tb: exception traceback
    """"""
    exc_cls, exc, tb=sys.exc_info()
    if exc_cls in ignore:
        msg='exception in ignorelist'
        gbc.say('ignoring caught:'+str(exc_cls))
        return 'exception in ignorelist'
        

    ex_message = traceback.format_exception_only(exc_cls, exc)[-1]
    ex_message = ex_message.strip()
    
    # TODO: print(ex_message)

    error_frame = tb
    while error_frame.tb_next is not None:
        error_frame = error_frame.tb_next

    file = error_frame.tb_frame.f_code.co_filename
    line = error_frame.tb_lineno
    stack = traceback.extract_tb(tb)

    formated_stack = []
    for summary in stack:
        formated_stack.append({
            'file': summary[0],
            'line': summary[1],
            'func': summary[2],
            'text': summary[3]
        })

    event = {
        'was_doing':was_doing,
        'message': ex_message,
        'errorLocation': {
            'file': file,
            'line': line,
            'full': file + ' -> ' + str(line)
        },
        'stack': formated_stack
        #,
        #'time': time.time()
    }

    try:
        #logging.info('caught:'+pformat(event))
        gbc.cry('caught:'+pformat(event))
        print('Bubble3: written error to log')
        print('Bubble3: tips for fixing this:')
        print(helpfull_tips)

    except Exception as e:
        print('Bubble3: cant log error cause of %s' % e)"
2133,"def from_name(api_url, name, dry_run=False):
        """"""
            doesn't require a token config param
            as all of our data is currently public
        """"""
        return DataSet(
            '/'.join([api_url, name]).rstrip('/'),
            token=None,
            dry_run=dry_run
        )"
2134,"def secured_clipboard(item):
    """"""This clipboard only allows 1 paste 
    """"""
    expire_clock = time.time()
    def set_text(clipboard, selectiondata, info, data):
        # expire after 15 secs
        if 15.0 >= time.time() - expire_clock:
            selectiondata.set_text(item.get_secret())
            clipboard.clear()
    def clear(clipboard, data):
        """"""Clearing of the buffer is deferred this only gets called if the 
        paste is actually triggered
        """"""
        pass
    targets = [(""STRING"", 0, 0)
              ,(""TEXT"", 0, 1)
              ,(""COMPOUND_TEXT"", 0, 2)
              ,(""UTF8_STRING"", 0, 3)]
    cp = gtk.clipboard_get()
    cp.set_with_data(targets, set_text, clear)"
2135,"def get_active_window():
    """"""Get the currently focused window
    """"""
    active_win = None
    default = wnck.screen_get_default()
    while gtk.events_pending():
        gtk.main_iteration(False)
    window_list = default.get_windows()
    if len(window_list) == 0:
        print ""No Windows Found""
    for win in window_list:
        if win.is_active():
            active_win = win.get_name()
    return active_win"
2136,"def get(self):
        """"""Get quota from Cloud Provider.""""""

        # get all network quota from Cloud Provider.
        attrs = (""networks"",
                 ""security_groups"",
                 ""floating_ips"",
                 ""routers"",
                 ""internet_gateways"")

        for attr in attrs:
            setattr(self, attr, eval(""self.get_{}()"". format(attr)))"
2137,"def join_css_class(css_class, *additional_css_classes):
    """"""
    Returns the union of one or more CSS classes as a space-separated string.
    Note that the order will not be preserved.
    """"""
    css_set = set(chain.from_iterable(
        c.split(' ') for c in [css_class, *additional_css_classes] if c))
    return ' '.join(css_set)"
2138,"def _init_middlewares(self):
        """"""Initialize hooks and middlewares
        If you have another Middleware, like BrokeMiddleware for e.x
        You can append this to middleware:
        self.middleware.append(BrokeMiddleware())
        """"""
        self.middleware = [DeserializeMiddleware()]
        self.middleware += \
            [FuncMiddleware(hook) for hook in self.before_hooks()]
        self.middleware.append(SerializeMiddleware())"
2139,"def _init_routes_and_middlewares(self):
        """"""Initialize hooks and URI routes to resources.""""""
        self._init_middlewares()
        self._init_endpoints()

        self.app = falcon.API(middleware=self.middleware)
        self.app.add_error_handler(Exception, self._error_handler)

        for version_path, endpoints in self.catalog:
            for route, resource in endpoints:
                self.app.add_route(version_path + route, resource)"
2140,"def _error_handler(self, exc, request, response, params):
        """"""Handler error""""""
        if isinstance(exc, falcon.HTTPError):
            raise exc
        LOG.exception(exc)
        raise falcon.HTTPInternalServerError('Internal server error',
                                             six.text_type(exc))"
2141,"def _get_server_cls(self, host):
        """"""Return an appropriate WSGI server class base on provided host
        :param host: The listen host for the zaqar API server.
        """"""
        server_cls = simple_server.WSGIServer
        if netutils.is_valid_ipv6(host):
            if getattr(server_cls, 'address_family') == socket.AF_INET:
                class server_cls(server_cls):
                    address_family = socket.AF_INET6
        return server_cls"
2142,"def listen(self):
        """"""Self-host using 'bind' and 'port' from the WSGI config group.""""""

        msgtmpl = (u'Serving on host %(host)s:%(port)s')
        host = CONF.wsgi.wsgi_host
        port = CONF.wsgi.wsgi_port
        LOG.info(msgtmpl,
                 {'host': host, 'port': port})
        server_cls = self._get_server_cls(host)
        httpd = simple_server.make_server(host,
                                          port,
                                          self.app,
                                          server_cls)
        httpd.serve_forever()"
2143,"def _create_map(self):
        """"""Initialize Brzozowski Algebraic Method""""""

        # at state i is represented by the regex self.B[i]
        for state_a in self.mma.states:
            self.A[state_a.stateid] = {}
            # Create a map state to state, with the transition symbols
            for arc in state_a.arcs:
                if arc.nextstate in self.A[state_a.stateid]:
                    self.A[state_a.stateid][arc.nextstate].append(self.mma.isyms.find(arc.ilabel))
                else:
                    self.A[state_a.stateid][arc.nextstate] = [self.mma.isyms.find(arc.ilabel)]
            if state_a.final:
                self.A[state_a.stateid]['string'] = ['']"
2144,"def get_promise(self):
        """"""Return the special set of promises for run_instruction.

        Run Instruction has to support multiple promises (one for
        reading data, and one for reading back the status from IR. All
        other primitives have a single promise, so fitting multiple
        into this system causes some API consistencies.

        This should be reviewed to see if a more coherent alternative
        is available.

        """"""
        if self._promise is None:
            promise = []
            if self.read:
                promise.append(TDOPromise(self._chain, 0, self.bitcount))
            else:
                promise.append(None)
            if self.read_status:
                promise.append(TDOPromise(self._chain, 0,
                                          self.dev._desc._ir_length))
            else:
                promise.append(None)
            self._promise = promise
        return self._promise"
2145,"def return_primitive(fn):
    """"""
    Decorator which wraps a single argument function to ignore any
    arguments of primitive type (simply returning them unmodified).
    """"""
    @wraps(fn)
    def wrapped_fn(x):
        if isinstance(x, PRIMITIVE_TYPES):
            return x
        return fn(x)
    return wrapped_fn"
2146,"def _get_dataset(self, dataset, name, color):
        """"""
        Encode a dataset
        """"""
        global palette
        html = ""{""
        html += '\t""label"": ""' + name + '"",'
        if color is not None:
            html += '""backgroundColor"": ""' + color + '"",\n'
        else:
            html += '""backgroundColor"": ' + palette + ',\n'
        html += '""data"": ' + self._format_list(dataset) + ',\n'
        html += ""}""
        return html"
2147,"def get(self, slug, xdata, ydatasets, label, opts, style, ctype):
        """"""
        Returns html for a chart
        """"""
        xdataset = self._format_list(xdata)
        width = ""100%""
        height = ""300px""
        if opts is not None:
            if ""width"" in opts:
                width = str(opts[""width""])
            if ""height"" in opts:
                height = str(opts[""height""])
        stylestr = '<style>#container_' + slug + \
            ' { width:' + width + ' !important; height:' + \
            height + ' !important}</style>\n'
        html = stylestr
        html += '<div id=""container_' + slug + \
            '""><canvas id=""canvas_' + slug + '""></canvas></div>\n'
        html += '<script>\n'
        html += 'var data = {\n'
        html += 'labels: ' + xdataset + ',\n'
        html += 'datasets:[\n'
        colors = None
        if ""color"" in style:
            colors = style[""color""]
        i = 0
        for dataset in ydatasets:
            name = dataset[""name""]
            data = dataset[""data""]
            html += self._get_dataset(data, name, colors)
            if i < len(ydatasets) - 1:
                html += "",""
            i += 1
        html += ']\n'
        html += '}\n'

        html += 'window.onload = function() {'
        html += 'var ctx = document.getElementById(""canvas_' + \
                slug + '"").getContext(""2d"");'
        html += 'window.myChart = new Chart(ctx, {'
        html += 'type: ""' + ctype + '"",'
        html += 'data: data,'
        html += 'options: {'
        html += 'spanGaps: false,'
        html += 'responsive: true,'
        html += 'maintainAspectRatio: false,'
        if ""legend"" in opts:
            html += 'legend: {'
            html += 'position: ""' + opts[""legend""] + '"",'
            html += '},'
        else:
            html += 'legend: {'
            html += 'display: false,'
            html += '},'
        if ""title"" in opts:
            html += 'title: {'
            html += 'display: true,'
            html += 'text: ""' + opts[""title""] + '""'
            html += '}'
        html += '}'
        html += '});'
        html += '};'
        html += '</script>\n'
        return html"
2148,"def _format_list(self, data):
        """"""
        Format a list to use in javascript
        """"""
        dataset = ""[""
        i = 0
        for el in data:
            if pd.isnull(el):
                dataset += ""null""
            else:
                dtype = type(data[i])
                if dtype == int or dtype == float:
                    dataset += str(el)
                else:
                    dataset += '""' + el + '""'
            if i < len(data) - 1:
                dataset += ', '
        dataset += ""]""
        return dataset"
2149,"def status(self, status, headers=None):
        '''
        Respond with given status and no content

        :type status: int
        :param status: status code to return

        :type headers: dict
        :param headers: dictionary of headers to add to response

        :returns: itself
        :rtype: Rule
        '''
        self.response = _Response(status, headers)
        return self"
2150,"def text(self, text, status=200, headers=None):
        '''
        Respond with given status and text content

        :type text: str
        :param text: text to return

        :type status: int
        :param status: status code to return

        :type headers: dict
        :param headers: dictionary of headers to add to response

        :returns: itself
        :rtype: Rule
        '''
        self.response = _Response(status, headers, text.encode('utf8'))
        return self"
2151,"def json(self, json_doc, status=200, headers=None):
        '''
        Respond with given status and JSON content. Will also set ``'Content-Type'`` to
        ``'applicaion/json'`` if header is not specified explicitly

        :type json_doc: dict
        :param json_doc: dictionary to respond with converting to JSON string

        :type status: int
        :param status: status code to return

        :type headers: dict
        :param headers: dictionary of headers to add to response
        '''
        headers = headers or {}
        if 'content-type' not in headers:
            headers['content-type'] = 'application/json'
        return self.text(json.dumps(json_doc), status, headers)"
2152,"def matches(self, method, path, headers, bytes=None):
        '''
        Checks if rule matches given request parameters

        :type method: str
        :param method: HTTP method, e.g. ``'GET'``, ``'POST'``, etc.
            Can take any custom string

        :type path: str
        :param path: request path including query parameters,
            e.g. ``'/users?name=John%20Doe'``

        :type bytes: bytes
        :param bytes: request body

        :returns: ``True`` if this rule matches given params
        :rtype: bool
        '''
        return self._expectation.matches(method, path, headers, bytes)"
2153,"def always(self, method, path=None, headers=None, text=None, json=None):
        '''
        Sends response every time matching parameters are found util :func:`Server.reset` is called

        :type method: str
        :param method: request method: ``'GET'``, ``'POST'``, etc. can be some custom string

        :type path: str
        :param path: request path including query parameters

        :type headers: dict
        :param headers: dictionary of headers to expect. If omitted any headers will do

        :type text: str
        :param text: request text to expect. If ommited any text will match

        :type json: dict
        :param json: request json to expect. If ommited any json will match,
            if present text param will be ignored

        :rtype: Rule
        :returns: newly created expectation rule
        '''
        rule = Rule(method, path, headers, text, json)
        return self._add_rule_to(rule, self._always_rules)"
2154,"def on(self, method, path=None, headers=None, text=None, json=None):
        '''
        Sends response to matching parameters one time and removes it from list of expectations

        :type method: str
        :param method: request method: ``'GET'``, ``'POST'``, etc. can be some custom string

        :type path: str
        :param path: request path including query parameters

        :type headers: dict
        :param headers: dictionary of headers to expect. If omitted any headers will do

        :type text: str
        :param text: request text to expect. If ommited any text will match

        :type json: dict
        :param json: request json to expect. If ommited any json will match,
            if present text param will be ignored

        :rtype: Rule
        :returns: newly created expectation rule
        '''
        rule = Rule(method, path, headers, text, json)
        return self._add_rule_to(rule, self._rules)"
2155,"def start(self):
        '''
        Starts a server on the port provided in the :class:`Server` constructor
        in a separate thread

        :rtype: Server
        :returns: server instance for chaining
        '''
        self._handler = _create_handler_class(self._rules, self._always_rules)
        self._server = HTTPServer(('', self._port), self._handler)
        self._thread = Thread(target=self._server.serve_forever, daemon=True)
        self._thread.start()
        self.running = True
        return self"
2156,"def stop(self):
        '''
        Shuts the server down and waits for server thread to join
        '''
        self._server.shutdown()
        self._server.server_close()
        self._thread.join()
        self.running = False"
2157,"def assert_no_pending(self, target_rule=None):
        '''
        Raises a :class:`PendingRequestsLeftException` error if server has target rule
        non-resolved.

        When target_rule argument is ommitted raises if server has any pending
        expectations.

        Useful in ``tearDown()`` test method to verify that test had correct expectations

        :type target_rule: Rule
        :param target_rule: will raise if this rule is left pending

        :raises: :class:`PendingRequestsLeftException`
        '''
        if target_rule:
            if target_rule in self._rules:
                raise PendingRequestsLeftException()
        elif self._rules:
            raise PendingRequestsLeftException()"
2158,"def build(path, query=None, fragment=''):
    """"""
    Generates a URL based on the inputted path and given query options and
    fragment.  The query should be a dictionary of terms that will be
    generated into the URL, while the fragment is the anchor point within the
    target path that will be navigated to.  If there are any wildcards within
    the path that are found within the query, they will be inserted into the
    path itself and removed from the query string.
    
    :example    |>>> import skyline.gui
                |>>> skyline.gui.build_url('sky://projects/%(project)s',
                |                          {'project': 'Test', 'asset': 'Bob'})
                |'sky://projects/Test/?asset=Bob'
    
    :param      path        | <str>
                query       | <dict> || None
                fragment    | <str> || None
    
    :return     <str> | url
    """"""
    url = nstr(path)

    # replace the optional arguments in the url
    keys = projex.text.findkeys(path)
    if keys:
        if query is None:
            query = {}

        opts = {}
        for key in keys:
            opts[key] = query.pop(key, '%({})s'.format(key))

        url %= opts

    # add the query
    if query:
        if type(query) is dict:
            mapped_query = {}
            for key, value in query.items():
                mapped_query[nstr(key)] = nstr(value)
            query_str = urllib.urlencode(mapped_query)
        else:
            query_str = nstr(query)

        url += '?' + query_str

    # include the fragment
    if fragment:
        url += '#' + fragment

    return url"
2159,"def parse(url):
    """"""
    Parses out the information for this url, returning its components
    expanded out to Python objects.
    
    :param      url | <str>
    
    :return     (<str> path, <dict> query, <str> fragment)
    """"""
    result = urlparse.urlparse(nstr(url))

    path = result.scheme + '://' + result.netloc
    if result.path:
        path += result.path

    query = {}

    # extract the python information from the query
    if result.query:
        url_query = urlparse.parse_qs(result.query)
        for key, value in url_query.items():
            if type(value) == list and len(value) == 1:
                value = value[0]

            query[key] = value

    return path, query, result.fragment"
2160,"def register(scheme):
    """"""
    Registers a new scheme to the urlparser.
    
    :param      schema | <str>
    """"""
    scheme = nstr(scheme)
    urlparse.uses_fragment.append(scheme)
    urlparse.uses_netloc.append(scheme)
    urlparse.uses_params.append(scheme)
    urlparse.uses_query.append(scheme)
    urlparse.uses_relative.append(scheme)"
2161,"def send(self, stats):
        ""Format stats and send to one or more Graphite hosts""
        buf = cStringIO.StringIO()
        now = int(time.time())
        num_stats = 0

        # timer stats
        pct = stats.percent
        timers = stats.timers
        for key, vals in timers.iteritems():
            if not vals:
                continue

            # compute statistics
            num = len(vals)
            vals = sorted(vals)
            vmin = vals[0]
            vmax = vals[-1]
            mean = vmin
            max_at_thresh = vmax
            if num > 1:
                idx = round((pct / 100.0) * num)
                tmp = vals[:int(idx)]
                if tmp:
                    max_at_thresh = tmp[-1]
                    mean = sum(tmp) / idx

            key = 'stats.timers.%s' % key
            buf.write('%s.mean %f %d\n' % (key, mean, now))
            buf.write('%s.upper %f %d\n' % (key, vmax, now))
            buf.write('%s.upper_%d %f %d\n' % (key, pct, max_at_thresh, now))
            buf.write('%s.lower %f %d\n' % (key, vmin, now))
            buf.write('%s.count %d %d\n' % (key, num, now))
            num_stats += 1

        # counter stats
        counts = stats.counts
        for key, val in counts.iteritems():
            buf.write('stats.%s %f %d\n' % (key, val / stats.interval, now))
            buf.write('stats_counts.%s %f %d\n' % (key, val, now))
            num_stats += 1

        # counter stats
        gauges = stats.gauges
        for key, val in gauges.iteritems():
            buf.write('stats.%s %f %d\n' % (key, val, now))
            buf.write('stats_counts.%s %f %d\n' % (key, val, now))
            num_stats += 1

        buf.write('statsd.numStats %d %d\n' % (num_stats, now))

        # TODO: add support for N retries

        for host in self._hosts:
            # flush stats to graphite
            try:
                sock = socket.create_connection(host)
                sock.sendall(buf.getvalue())
                sock.close()
            except Exception, ex:
                self.error(E_SENDFAIL % ('graphite', host, ex))"
2162,"def coerce(self, value):
        """"""Convert any value into a string value.

        Args:
            value (any): The value to coerce.

        Returns:
            str: The string representation of the value.
        """"""
        if isinstance(value, compat.basestring):

            return value

        return str(value)"
2163,"def coerce(self, value):
        """"""Convert a value into a pattern matched string value.

        All string values are matched against a regex before they are
        considered acceptable values.

        Args:
            value (any): The value to coerce.

        Raises:
            ValueError: If the value is not an acceptable value.

        Returns:
            str: The pattern matched value represented.
        """"""
        if not isinstance(value, compat.basestring):

            value = str(value)

        if not self._re.match(value):

            raise ValueError(
                ""The value {0} does not match the pattern {1}"".format(
                    value,
                    self.pattern,
                )
            )

        return value"
2164,"def get_payload(self, *args, **kwargs):
        """"""Receive all passed in args, kwargs, and combine them together with any required params""""""
        if not kwargs:
            kwargs = self.default_params
        else:
            kwargs.update(self.default_params)
        for item in args:
            if isinstance(item, dict):
                kwargs.update(item)
        if hasattr(self, 'type_params'):
            kwargs.update(self.type_params(*args, **kwargs))
        return kwargs"
2165,"async def read_frame(self) -> DataFrame:
        """"""Read a single frame from the local buffer.

        If no frames are available but the stream is still open, waits until
        more frames arrive. Otherwise, raises StreamConsumedError.

        When a stream is closed, a single `None` is added to the data frame
        Queue to wake up any waiting `read_frame` coroutines.
        """"""
        if self._data_frames.qsize() == 0 and self.closed:
            raise StreamConsumedError(self.id)
        frame = await self._data_frames.get()
        self._data_frames.task_done()
        if frame is None:
            raise StreamConsumedError(self.id)
        return frame"
2166,"def read_frame_nowait(self) -> Optional[DataFrame]:
        """"""Read a single frame from the local buffer immediately.

        If no frames are available but the stream is still open, returns None.
        Otherwise, raises StreamConsumedError.
        """"""
        try:
            frame = self._data_frames.get_nowait()
        except asyncio.QueueEmpty:
            if self.closed:
                raise StreamConsumedError(self.id)
            return None
        self._data_frames.task_done()
        if frame is None:
            raise StreamConsumedError(self.id)
        return frame"
2167,"def plucks(obj, selector, default=None):
    """"""Safe itemgetter for structured objects.
    Happily operates on all (nested) objects that implement the item getter, 
    i.e. the `[]` operator.

    The `selector` is ~
    ``(<key>|<index>|<slice>|\*)(\.(<key>|<index>|<slice>|\*))*``.
    Parts (keys) in the selector path are separated with a dot. If the key
    looks like a number it's interpreted as such, i.e. as an index (so beware
    of numeric string keys in `dict`s).
    Python slice syntax is supported with keys like: ``2:7``, ``:5``, ``::-1``.
    A special key is ``*``, equivalent to the slice-all op ``:``. Note its
    usage does not serve functional, but annotational purpose -- feel free to
    leave it out (check the last example below).

    Examples:
        obj = {
            'users': [{
                'uid': 1234,
                'name': {
                    'first': 'John',
                    'last': 'Smith',
                }
            }, {
                'uid': 2345,
                'name': {
                    'last': 'Bono'
                }
            }]
        }

        plucks(obj, 'users.1.name')
            -> {'last': 'Bono'}

        plucks(obj, 'users.*.name.last')
            -> ['Smith', 'Bono']

        plucks(obj, 'users.name.first')
            -> ['John']


    Note: since the dot `.` is used as a separator, keys can not contain dots.
    """"""
    
    def _filter(iterable, index):
        res = []
        for obj in iterable:
            try:
                res.append(obj[index])
            except:
                pass
        return res

    def _int(val):
        try:
            return int(val)
        except:
            return None

    def _parsekey(key):
        m = re.match(r""^(?P<index>-?\d+)$"", key)
        if m:
            return int(m.group('index'))

        m = re.match(r""^(?P<start>-?\d+)?""\
                     r""(:(?P<stop>-?\d+)?(:(?P<step>-?\d+)?)?)?$"", key)
        if m:
            return slice(_int(m.group('start')),
                         _int(m.group('stop')),
                         _int(m.group('step')))

        if key == '*':
            return slice(None)

        return key

    miss = False
    for key in selector.split('.'):
        index = _parsekey(key)
        
        if miss:
            if isinstance(index, basestring):
                obj = {}
            else:
                obj = []
        
        try:
            if isinstance(index, basestring):
                if isinstance(obj, list):
                    obj = _filter(obj, index)
                else:
                    obj = obj[index]
            else:
                obj = obj[index]
            miss = False
        except:
            miss = True
    
    if miss:
        return default
    else:
        return obj"
2168,"def pluck(obj, selector, default=None, skipmissing=True):
    """"""Alternative implementation of `plucks` that accepts more complex
    selectors. It's a wrapper around `pluckable`, so a `selector` can be any
    valid Python expression comprising attribute getters (``.attr``) and item
    getters (``[1, 4:8, ""key""]``).

    Example:

        pluck(obj, ""users[2:5, 10:15].name.first"")

    equal to:

        pluckable(obj).users[2:5, 10:15].name.first.value

    """"""
    if not selector:
        return obj
    if selector[0] != '[':
        selector = '.%s' % selector
    wrapped_obj = pluckable(obj, default=default, skipmissing=skipmissing, inplace=True)
    return eval(""wrapped_obj%s.value"" % selector)"
2169,"def merge(a, b, op=None, recurse_list=False, max_depth=None):
    """"""Immutable merge ``a`` structure with ``b`` using binary operator ``op``
    on leaf nodes. All nodes at, or below, ``max_depth`` are considered to be
    leaf nodes.

    Merged structure is returned, input data structures are not modified.

    If ``recurse_list=True``, leaf lists of equal length will be merged on a
    list-element level. Lists are considered to be leaf nodes by default
    (``recurse_list=False``), and they are merged with user-provided ``op``.
    Note the difference::

        merge([1, 2], [3, 4]) ==> [1, 2, 3, 4]

        merge([1, 2], [3, 4], recurse_list=True) ==> [4, 6]

    """"""

    if op is None:
        op = operator.add

    if max_depth is not None:
        if max_depth < 1:
            return op(a, b)
        else:
            max_depth -= 1

    if isinstance(a, dict) and isinstance(b, dict):
        result = {}
        for key in set(chain(a.keys(), b.keys())):
            if key in a and key in b:
                result[key] = merge(a[key], b[key],
                                    op=op, recurse_list=recurse_list,
                                    max_depth=max_depth)
            elif key in a:
                result[key] = deepcopy(a[key])
            elif key in b:
                result[key] = deepcopy(b[key])
        return result

    elif isinstance(a, list) and isinstance(b, list):
        if recurse_list and len(a) == len(b):
            # merge subelements
            result = []
            for idx in range(len(a)):
                result.append(merge(a[idx], b[idx],
                                    op=op, recurse_list=recurse_list,
                                    max_depth=max_depth))
            return result
        else:
            # merge lists
            return op(a, b)

    # all other merge ops should be handled by ``op``.
    # default ``operator.add`` will handle addition of numeric types, but fail
    # with TypeError for incompatible types (eg. str + None, etc.)
    return op(a, b)"
2170,"def readProfile(filename):
  """"""
  input: string, name of a file containing a profile description
  output: asp.TermSet, with atoms matching the contents of the input file

  Parses a profile description, and returns
  a TermSet object.
  """"""
  p    = profile_parser.Parser()
  accu = TermSet()
  file = open(filename,'r')
  s    = file.readline()
  while s!="""":
    try:
      accu = p.parse(s,filename)
    except EOFError:
      break
    s = file.readline()

  return accu"
2171,"def _param_deprecation_warning(schema, deprecated, context):
    """"""Raises warning about using the 'old' names for some parameters.

    The new naming scheme just has two underscores on each end of the word for consistency
    """"""
    for i in deprecated:
        if i in schema:
                msg = 'When matching {ctx}, parameter {word} is deprecated, use __{word}__ instead'
                msg = msg.format(ctx = context, word = i)
                warnings.warn(msg, Warning)"
2172,"def check(schema, data, trace=False):
    """"""Verify some json.

    Args:
        schema - the description of a general-case 'valid' json object.
        data - the json data to verify.

    Returns:
        bool: True if data matches the schema, False otherwise.

    Raises:
        TypeError:
            If the schema is of an unknown data type.
        ValueError:
            If the schema contains a string with an invalid value.
            If the schema attempts to reference a non-existent named schema.

    """"""
    if trace == True:
        trace = 1
    else:
        trace = None
    return _check(schema, data, trace=trace)"
2173,"def has_perm(self, user, perm, obj=None, *args, **kwargs):
        """"""Test user permissions for a single action and object.

        :param user: The user to test.
        :type user: ``User``
        :param perm: The action to test.
        :type perm: ``str``
        :param obj: The object path to test.
        :type obj: ``tutelary.engine.Object``
        :returns: ``bool`` -- is the action permitted?
        """"""
        try:
            if not self._obj_ok(obj):
                if hasattr(obj, 'get_permissions_object'):
                    obj = obj.get_permissions_object(perm)
                else:
                    raise InvalidPermissionObjectException
            return user.permset_tree.allow(Action(perm), obj)
        except ObjectDoesNotExist:
            return False"
2174,"def permitted_actions(self, user, obj=None):
        """"""Determine list of permitted actions for an object or object
        pattern.

        :param user: The user to test.
        :type user: ``User``
        :param obj: A function mapping from action names to object
                    paths to test.
        :type obj: callable
        :returns: ``list(tutelary.engine.Action)`` -- permitted actions.

        """"""
        try:
            if not self._obj_ok(obj):
                raise InvalidPermissionObjectException
            return user.permset_tree.permitted_actions(obj)
        except ObjectDoesNotExist:
            return []"
2175,"def validate(self,options):
        """"""
        Validate the options or exit()
        """"""
        if not options.port:
            self.parser.error(""'port' is required"")
        if options.port == options.monitor_port:
            self.parser.error(""'port' and 'monitor-port' must not be the same."")
        if options.buffer_size <= 0:
            self.parser.error(""'buffer_size' must be > 0."")
        try:
            codecs.getencoder(options.char_encoding)
        except LookupError:
            self.parser.error(""invalid 'char-encoding' %s"" % options.char_encoding)

        if not options.host:
           options.host = socket.gethostname()"
2176,"def list(self, name, platform='', genre=''):
        """""" The name argument is required for this method as per the API
        server specification. This method also provides the platform and genre
        optional arguments as filters.
        """"""
        data_list = self.db.get_data(self.list_path, name=name,
                                     platform=platform, genre=genre)
        data_list = data_list.get('Data') or {}
        games = data_list.get('Game') or []
        return [self._build_item(**i) for i in games]"
2177,"def list(self):
        """""" No argument is required for this method as per the API server
        specification.
        """"""
        data_list = self.db.get_data(self.list_path)
        data_list = data_list.get('Data') or {}
        platforms = (data_list.get('Platforms') or {}).get('Platform') or []
        return [self._build_item(**i) for i in platforms]"
2178,"def games(self, platform):
        """""" It returns a list of games given the platform *alias* (usually is
        the game name separated by ""-"" instead of white spaces).
        """"""
        platform = platform.lower()
        data_list = self.db.get_data(self.games_path, platform=platform)
        data_list = data_list.get('Data') or {}
        return [Game(self.db.game, **i) for i in data_list.get('Game') or {}]"
2179,"def remove_none_dict_values(obj):
    """"""
    Remove None values from dict.
    """"""
    if isinstance(obj, (list, tuple, set)):
        return type(obj)(remove_none_dict_values(x) for x in obj)
    elif isinstance(obj, dict):
        return type(obj)((k, remove_none_dict_values(v))
                         for k, v in obj.items()
                         if v is not None)
    else:
        return obj"
2180,"def update_history(cloud_hero):
    """"""
    Send each command to the /history endpoint.
    """"""
    user_command = ' '.join(sys.argv)
    timestamp = int(time.time())
    command = (user_command, timestamp)
    cloud_hero.send_history([command])"
2181,"def get_scenfit(instance, OS, FP, FC, EP):
  '''returns the scenfit of data and model described by the
  ``TermSet`` object [instance].
  '''
  sem = [sign_cons_prg, bwd_prop_prg]
  if OS : sem.append(one_state_prg)
  if FP : sem.append(fwd_prop_prg)
  if FC : sem.append(founded_prg)
  if EP : sem.append(elem_path_prg)


  inst     = instance.to_file()
  prg      = sem + scenfit + [inst]
  coptions = '--opt-strategy=5'
  solver   = GringoClasp(clasp_options=coptions)
  solution = solver.run(prg,collapseTerms=True,collapseAtoms=False)
  opt      = solution[0].score[0]

  os.unlink(inst)
  return opt"
2182,"def get_scenfit_labelings(instance,nm, OS, FP, FC, EP):
  '''
  returns a list of atmost [nm] ``TermSet`` representing scenfit labelings
  to the system described by the ``TermSet`` object [instance].
  '''
  sem = [sign_cons_prg, bwd_prop_prg]
  if OS : sem.append(one_state_prg)
  if FP : sem.append(fwd_prop_prg)
  if FC : sem.append(founded_prg)
  if EP : sem.append(elem_path_prg)

  inst     = instance.to_file()
  prg      = sem + scenfit + [inst]
  coptions = '--opt-strategy=5'
  solver   = GringoClasp(clasp_options=coptions)
  solution = solver.run(prg,collapseTerms=True,collapseAtoms=False)

  opt      = solution[0].score[0]

  prg      = prg + [show_labels_prg, show_err_prg]
  coptions = str(nm)+' --project --opt-strategy=5 --opt-mode=optN --opt-bound='+str(opt)
  solver2  = GringoClasp(clasp_options=coptions)
  models   = solver2.run(prg,collapseTerms=True,collapseAtoms=False)

  os.unlink(inst)
  return models"
2183,"def get_opt_add_remove_edges_greedy(instance):
  '''
   only apply with elementary path consistency notion
  '''
  sem        = [sign_cons_prg, elem_path_prg, fwd_prop_prg, bwd_prop_prg]
  inst       = instance.to_file()
  prg        = [ inst, remove_edges_prg,
                 min_repairs_prg, show_rep_prg
               ] + sem + scenfit
  coptions   = '1 --project --opt-strategy=5 --opt-mode=optN --quiet=1'
  solver     = GringoClasp(clasp_options=coptions)
  models     = solver.run(prg, collapseTerms=True, collapseAtoms=False)

  bscenfit   = models[0].score[0]
  brepscore  = models[0].score[1]

  #print('model:   ',models[0])
  #print('bscenfit:   ',bscenfit)
  #print('brepscore:  ',brepscore)


  strt_edges = TermSet()
  fedges     = [(strt_edges, bscenfit, brepscore)]
  tedges     = []
  dedges     = []
  coptions   = '0 --project --opt-strategy=5 --opt-mode=optN --quiet=1'
  solver     = GringoClasp(clasp_options=coptions)

  while fedges:
#    sys.stdout.flush()
#    print (""TODO: "",len(fedges))
    (oedges, oscenfit, orepscore) = fedges.pop()

#    print('(oedges,oscenfit, orepscore):',(oedges,oscenfit, orepscore))
#    print('len(oedges):',len(oedges))

    # extend till no better solution can be found
    end       = True # assume this time its the end
    f_oedges  = TermSet(oedges).to_file()
    prg       = [ inst, f_oedges, remove_edges_prg, best_one_edge_prg,
                  min_repairs_prg, show_rep_prg
                ] + sem + scenfit
    models    = solver.run(prg, collapseTerms=True, collapseAtoms=False)
    nscenfit  = models[0].score[0]
    nrepscore = models[0].score[1]+2*(len(oedges))

#    print('nscenfit:   ',nscenfit)
#    print('nrepscore:  ',nrepscore)

    if (nscenfit < oscenfit) or nrepscore < orepscore: # better score or more that 1 scenfit
#      print('maybe better solution:')
#      print('#models: ',len(models))

      for m in models:
        #print('MMM   ',models)
        nend = TermSet()
        for a in m :
          if a.pred() == 'rep' :
            if a.arg(0)[0:7]=='addeddy' :
#              print('new addeddy to',a.arg(0)[8:-1])
              nend  = String2TermSet('edge_end('+(a.arg(0)[8:-1])+')')

              # search starts of the addeddy
#              print('search best edge starts')
              f_end  = TermSet(nend).to_file()

              prg    = [ inst, f_oedges, remove_edges_prg, f_end, best_edge_start_prg,
                         min_repairs_prg, show_rep_prg
                       ] + sem + scenfit
              starts = solver.run(prg, collapseTerms=True, collapseAtoms=False)
              os.unlink(f_end)
#              print(starts)
              for s in starts:
                n2scenfit  = s.score[0]
                n2repscore = s.score[1]+2*(len(oedges))
#                print('n2scenfit:   ', n2scenfit)
#                print('n2repscore:  ', n2repscore)

                if (n2scenfit < oscenfit) or n2repscore < orepscore: # better score or more that 1 scenfit
#                  print('better solution:')
                  if (n2scenfit<bscenfit):
                    bscenfit  = n2scenfit # update bscenfit
                    brepscore = n2repscore
                  if (n2scenfit == bscenfit) :
                    if (n2repscore<brepscore) : brepscore = n2repscore

                  nedge = TermSet()
                  for a in s :
                    if a.pred() == 'rep' :
                      if a.arg(0)[0:7]=='addedge' :
#                        print('new edge ',a.arg(0)[8:-1])
                        nedge = String2TermSet('obs_elabel('+(a.arg(0)[8:-1])+')')
                        end   = False

                  nedges = oedges.union(nedge)
                  if (nedges,n2scenfit,n2repscore) not in fedges and nedges not in dedges:
                    fedges.append((nedges,n2scenfit,n2repscore))
                    dedges.append(nedges)

    if end :
      if (oedges,oscenfit,orepscore) not in tedges and oscenfit == bscenfit and orepscore == brepscore:
#        print('LAST tedges append',oedges)
        tedges.append((oedges,oscenfit,orepscore))

    # end while
    os.unlink(f_oedges)

  # take only the results with the best scenfit
  redges=[]
  for (tedges,tscenfit,trepairs) in tedges:
    if tscenfit == bscenfit: redges.append((tedges,trepairs))

  os.unlink(inst)
  return (bscenfit,redges)"
2184,"def get_opt_repairs_add_remove_edges_greedy(instance,nm, edges):
  '''
   only apply with elementary path consistency notion
  '''

  sem      = [sign_cons_prg, elem_path_prg, fwd_prop_prg, bwd_prop_prg]
  inst     = instance.to_file()
  f_edges  = TermSet(edges).to_file()
  prg      = [ inst, f_edges, remove_edges_prg,
               min_repairs_prg, show_rep_prg,
             ] + sem + scenfit
  coptions = str(nm)+' --project --opt-strategy=5 --opt-mode=optN --quiet=1'
  solver   = GringoClasp(clasp_options=coptions)
  models   = solver.run(prg, collapseTerms=True, collapseAtoms=False)
  #print(models)
  #nscenfit  = models[0].score[0]
  #nrepscore = models[0].score[1]
  #print('scenfit:   ', nscenfit)
  #print('repscore:  ', nrepscore)

  os.unlink(f_edges)
  os.unlink(inst)
  return models"
2185,"def validate_implementation_for_auto_decode_and_soupify(func):
    """"""
    Validate that :func:`auto_decode_and_soupify` is applicable to this
    function. If not applicable, a ``NotImplmentedError`` will be raised.
    """"""
    arg_spec = inspect.getargspec(func)
    for arg in [""response"", ""html"", ""soup""]:
        if arg not in arg_spec.args:
            raise NotImplementedError(
                (""{func} method has to take the keyword syntax input: ""
                 ""{arg}"").format(func=func, arg=arg)
            )"
2186,"def auto_decode_and_soupify(encoding=None, errors=decoder.ErrorsHandle.strict):
    """"""
    This decorator assume that there are three argument in keyword syntax:

    - ``response``: ``requests.Response`` or ``scrapy.http.Reponse``
    - ``html``: html string
    - ``soup``: ``bs4.BeautifulSoup``

    1. if ``soup`` is not available, it will automatically be generated from
        ``html``.
    2. if ``html`` is not available, it will automatically be generated from
        ``response``.

    Usage::

        @auto_decode_and_soupify()
        def parse(response, html, soup):
            ...

    **中文文档**

    此装饰器会自动检测函数中名为 ``response``, ``html``, ``soup`` 的参数, 并在
    ``html``, ``soup`` 未给出的情况下, 自动生成所期望的值. 被此装饰器装饰的函数必须
    要有以上提到的三个参数. 并且在使用时, 必须使用keyword的形式进行输入.
    """"""

    def deco(func):
        func_hash = hash(func)
        if not _auto_decode_and_soupify_implementation_ok_mapper \
                .get(func_hash, False):
            validate_implementation_for_auto_decode_and_soupify(func)
            _auto_decode_and_soupify_implementation_ok_mapper[func_hash] = True

        def wrapper(*args, **kwargs):
            try:
                response = kwargs.get(""response"")
                html = kwargs.get(""html"")
                soup = kwargs.get(""soup"")
            except KeyError as e:
                raise NotImplementedError(
                    (""{func} method has to take the keyword syntax input: ""
                     ""{e}"").format(func=func, e=e)
                )

            if html is None:
                binary = access_binary(response)
                try:
                    html = decoder.decode(
                        binary=binary,
                        url=response.url,
                        encoding=encoding,
                        errors=errors,
                    )
                except Exception as e:  # pragma: no cover
                    raise DecodeError(str(e))
                kwargs[""html""] = html

            if soup is None:
                soup = soupify(html)
                kwargs[""soup""] = soup

            return func(*args, **kwargs)

        return wrapper

    return deco"
2187,"def check(a, b):
    """"""
    Checks to see if the two values are equal to each other.
    
    :param      a | <str>
                b | <str>
    
    :return     <bool>
    """"""
    aencrypt = encrypt(a)
    bencrypt = encrypt(b)

    return a == b or a == bencrypt or aencrypt == b"
2188,"def decodeBase64(text, encoding='utf-8'):
    """"""
    Decodes a base 64 string.
    
    :param      text | <str>
                encoding | <str>
    
    :return     <str>
    """"""
    text = projex.text.toBytes(text, encoding)
    return projex.text.toUnicode(base64.b64decode(text), encoding)"
2189,"def decrypt(text, key=None):
    """"""
    Decrypts the inputted text using the inputted key.
    
    :param      text    | <str>
                key     | <str>
    
    :return     <str>
    """"""
    if key is None:
        key = ENCRYPT_KEY

    bits = len(key)
    text = base64.b64decode(text)
    iv = text[:16]
    cipher = AES.new(key, AES.MODE_CBC, iv)
    return unpad(cipher.decrypt(text[16:]))"
2190,"def decryptfile(filename, key=None, outfile=None, chunk=64 * 1024):
    """"""
    Decrypts a file using AES (CBC mode) with the given key.  If no
    file is supplied, then the inputted file will be modified in place.
    The chunk value will be the size with which the function uses to
    read and encrypt the file.  Larger chunks can be faster for some files
    and machines.  The chunk MUST be divisible by 16.
    
    :param      text    | <str>
                key     | <str>
                outfile | <str> || None
                chunk   | <int>
    """"""
    if key is None:
        key = ENCRYPT_KEY

    if not outfile:
        outfile = os.path.splitext(filename)[0]

    with open(filename, 'rb') as input:
        origsize = struct.unpack('<Q', input.read(struct.calcsize('Q')))[0]
        iv = input.read(16)
        cipher = AES.new(key, AES.MODE_CBC, iv)

        with open(outfile, 'wb') as output:
            while True:
                data = input.read(chunk)
                if len(data) == 0:
                    break

                data = cipher.decrypt(data)
                data = unpad(data)
                output.write(data)
                output.truncate(origsize)"
2191,"def encodeBase64(text, encoding='utf-8'):
    """"""
    Decodes a base 64 string.
    
    :param      text | <str>
                encoding | <str>
    
    :return     <str>
    """"""
    text = projex.text.toBytes(text, encoding)
    return base64.b64encode(text)"
2192,"def encrypt(text, key=None):
    """"""
    Encrypts the inputted text using the AES cipher.  If the PyCrypto
    module is not included, this will simply encode the inputted text to
    base64 format.
    
    :param      text    | <str>
                key     | <str>
    
    :return     <str>
    """"""
    if key is None:
        key = ENCRYPT_KEY

    bits = len(key)
    text = pad(text, bits)
    iv = Random.new().read(16)
    cipher = AES.new(key, AES.MODE_CBC, iv)
    return base64.b64encode(iv + cipher.encrypt(text))"
2193,"def encryptfile(filename, key=None, outfile=None, chunk=64 * 1024):
    """"""
    Encrypts a file using AES (CBC mode) with the given key.  If no
    file is supplied, then the inputted file will be modified in place.
    The chunk value will be the size with which the function uses to
    read and encrypt the file.  Larger chunks can be faster for some files
    and machines.  The chunk MUST be divisible by 16.
    
    :param      text    | <str>
                key     | <str>
                outfile | <str> || None
                chunk   | <int>
    """"""
    if key is None:
        key = ENCRYPT_KEY

    if not outfile:
        outfile = filename + '.enc'

    iv = Random.new().read(16)
    cipher = AES.new(key, AES.MODE_CBC, iv)
    filesize = os.path.getsize(filename)

    with open(filename, 'rb') as input:
        with open(outfile, 'wb') as output:
            output.write(struct.pack('<Q', filesize))
            output.write(iv)

            while True:
                data = input.read(chunk)
                if len(data) == 0:
                    break

                data = pad(data, len(key))
                output.write(cipher.encrypt(data))"
2194,"def generateKey(password, bits=32):
    """"""
    Generates a new encryption key based on the inputted password.
    
    :param      password    | <str>
                bits        | <int>  | 16 or 32 bits
    
    :return     <str>
    """"""
    if bits == 32:
        hasher = hashlib.sha256
    elif bits == 16:
        hasher = hashlib.md5
    else:
        raise StandardError('Invalid hash type')

    return hasher(password).digest()"
2195,"def generateToken(bits=32):
    """"""
    Generates a random token based on the given parameters.
    
    :return     <str>
    """"""
    if bits == 64:
        hasher = hashlib.sha256
    elif bits == 32:
        hasher = hashlib.md5
    else:
        raise StandardError('Unknown bit level.')
    return hasher(nstr(random.getrandbits(256))).hexdigest()"
2196,"def pad(text, bits=32):
    """"""
    Pads the inputted text to ensure it fits the proper block length
    for encryption.
    
    :param      text | <str>
                bits | <int>
    
    :return     <str>
    """"""
    return text + (bits - len(text) % bits) * chr(bits - len(text) % bits)"
2197,"def Client(version=__version__, resource=None, provider=None, **kwargs):
    """"""Initialize client object based on given version.

    :params version: version of CAL, define at setup.cfg
    :params resource: resource type
                     (network, compute, object_storage, block_storage)
    :params provider: provider object
    :params cloud_config: cloud auth config
    :params **kwargs: specific args for resource
    :return: class Client

    HOW-TO:
    The simplest way to create a client instance is initialization::

        >> from calplus import client
        >> calplus = client.Client(version='1.0.0',
                               resource='compute',
                               provider=provider_object,
                               some_needed_args_for_ComputeClient)
    """"""

    versions = _CLIENTS.keys()

    if version not in versions:
        raise exceptions.UnsupportedVersion(
            'Unknown client version or subject'
        )

    if provider is None:
        raise exceptions.ProviderNotDefined(
            'Not define Provider for Client'
        )

    support_types = CONF.providers.driver_mapper.keys()

    if provider.type not in support_types:
        raise exceptions.ProviderTypeNotFound(
            'Unknow provider.'
        )

    resources = _CLIENTS[version].keys()

    if not resource:
        raise exceptions.ResourceNotDefined(
            'Not define Resource, choose one: compute, network,\
            object_storage, block_storage.'
        )

    elif resource.lower() not in resources:
        raise exceptions.ResourceNotFound(
            'Unknow resource: compute, network,\
                        object_storage, block_storage.'
        )

    LOG.info('Instantiating {} client ({})' . format(resource, version))

    return _CLIENTS[version][resource](
        provider.type, provider.config, **kwargs)"
2198,"def accession(self):
        """"""
        Parse accession number from commonly supported formats.

        If the defline does not match one of the following formats, the entire
        description (sans leading caret) will be returned.

        * >gi|572257426|ref|XP_006607122.1|
        * >gnl|Tcas|XP_008191512.1
        * >lcl|PdomMRNAr1.2-10981.1
        """"""
        accession = None
        if self.defline.startswith('>gi|'):
            match = re.match('>gi\|\d+\|[^\|]+\|([^\|\n ]+)', self.defline)
            if match:
                accession = match.group(1)
        elif self.defline.startswith('>gnl|'):
            match = re.match('>gnl\|[^\|]+\|([^\|\n ]+)', self.defline)
            if match:
                accession = match.group(1)
        elif self.defline.startswith('>lcl|'):
            match = re.match('>lcl\|([^\|\n ]+)', self.defline)
            if match:
                accession = match.group(1)
        return accession"
2199,"def format_seq(self, outstream=None, linewidth=70):
        """"""
        Print a sequence in a readable format.

        :param outstream: if `None`, formatted sequence is returned as a
                          string; otherwise, it is treated as a file-like
                          object and the formatted sequence is printed to the
                          outstream
        :param linewidth: width for wrapping sequences over multiple lines; set
                          to 0 for no wrapping
        """"""
        if linewidth == 0 or len(self.seq) <= linewidth:
            if outstream is None:
                return self.seq
            else:
                print(self.seq, file=outstream)
                return

        i = 0
        seq = ''
        while i < len(self.seq):
            if outstream is None:
                seq += self.seq[i:i+linewidth] + '\n'
            else:
                print(self.seq[i:i+linewidth], file=outstream)
            i += linewidth
        if outstream is None:
            return seq"
2200,"def get_validator(filter_data):
    """"""
    ask every matcher whether it can serve such filter data

    :param filter_data:
    :return:
    """"""
    for matcher_type, m in matchers.items():
        if hasattr(m, 'can_handle') and m.can_handle(filter_data):
            filter_data = m.handle(filter_data)

    return filter_data"
2201,"def run():
    """"""Run the examples""""""

    # NOTE(kiennt): Until now, this example isn't finished yet,
    #               because we don't have any completed driver

    # Get a network client with openstack driver.

    network_client = client.Client(version=_VERSION,
                        resource=_RESOURCES[0], provider=_PROVIDER)
    # net = network_client.create('daikk', '10.0.0.0/24')
    # list_subnet = network_client.list()
    # network_client.show(list_subnet[0].get(""id""))
    network_client.delete(""4b983028-0f8c-4b63-b10c-6e8420bb7903"")"
2202,"def sort(self, attr):
        """"""Sort the ratings based on an attribute""""""
        self.entries = Sorter(self.entries, self.category, attr).sort_entries()
        return self"
2203,"def get_title(self):
        """"""Title is either the chart header for a cable ratings page or above
        the opening description for a broadcast ratings page.
        """"""
        if self.category == 'cable':
            strings = get_strings(self.soup, 'strong')
        else:
            strings = get_strings(self.soup, 'b')

        if len(strings) == 0:
            strings = get_strings(self.soup, 'strong')

        if len(strings) >= 1 and self.category == 'cable':
            return strings[0]
        elif len(strings) > 0 and 'Fast' in strings[-1]:
            return strings[0]

        return ''.join(strings)"
2204,"def get_json(self):
        """"""Serialize ratings object as JSON-formatted string""""""
        ratings_dict = {
            'category': self.category,
            'date': self.date,
            'day': self.weekday,
            'next week': self.next_week,
            'last week': self.last_week,
            'entries': self.entries,
            'url': self.url
        }
        return to_json(ratings_dict)"
2205,"def _get_url_params(self, shorten=True):
        """"""Returns a list of each parameter to be used for the url format.""""""
        cable = True if self.category == 'cable' else False
        url_date = convert_month(self.date, shorten=shorten, cable=cable)

        return [
            BASE_URL,
            self.weekday.lower(),
            self.category + '-ratings',
            url_date.replace(' ', '-')
        ]"
2206,"def _match_show(self, show):
        """"""Match a query for a specific show/list of shows""""""
        if self.show:
            return match_list(self.show, show)
        else:
            return True"
2207,"def _match_net(self, net):
        """"""Match a query for a specific network/list of networks""""""
        if self.network:
            return match_list(self.network, net)
        else:
            return True"
2208,"def _verify_page(self):
        """"""Verify the ratings page matches the correct date""""""
        title_date = self._get_date_in_title().lower()
        split_date = self.date.lower().split()
        split_date[0] = split_date[0][:3]
        return all(term in title_date for term in split_date)"
2209,"def _get_ratings_page(self):
        """"""Do a limited search for the correct url.""""""
        # Use current posted date to build url
        self._build_url()
        soup = get_soup(self.url)
        if soup:
            return soup

        # Try building url again with unshortened month
        self._build_url(shorten=False)
        soup = get_soup(self.url)
        if soup:
            return soup

        # If not page is found, use search
        return SearchDaily(self.category, date=self.date).fetch_result()"
2210,"def _build_url(self, shorten=True):
        """"""Build the url for a cable ratings page""""""
        self.url = URL_FORMAT.format(*self._get_url_params(shorten=shorten))"
2211,"def fetch_entries(self):
        """"""Fetch data and parse it to build a list of cable entries.""""""
        data = []
        for row in self.get_rows():
            # Stop fetching data if limit has been met
            if exceeded_limit(self.limit, len(data)):
                break

            entry = row.find_all('td')
            entry_dict = {}

            show = entry[0].string
            net = entry[1].string
            if not self._match_query(show, net):
                continue

            entry_dict['show'] = show
            entry_dict['net'] = net
            entry_dict['time'] = entry[2].string

            if ',' in entry[3].string:
                entry_dict['viewers'] = entry[3].string.replace(',', '.')
            else:
                entry_dict['viewers'] = '0.' + entry[3].string
            entry_dict['rating'] = entry[4].string

            # Add data to create cable entry
            data.append(Entry(**entry_dict))

        return data"
2212,"def _build_url(self, shorten=True):
        """"""Build the url for a broadcast ratings page""""""
        url_order = self._get_url_params(shorten=shorten)

        # For fast ratings, switch weekday and category in url
        if self.category != 'final':
            url_order[1], url_order[2] = url_order[2], url_order[1]
        self.url = URL_FORMAT.format(*url_order)"
2213,"def get_rows(self):
        """"""Get the rows from a broadcast ratings chart""""""
        table = self.soup.find_all('tr')[1:-3]
        return [row for row in table if row.contents[3].string]"
2214,"def fetch_entries(self):
        """"""Fetch data and parse it to build a list of broadcast entries.""""""
        current_time = ''

        data = []
        for row in self.get_rows():
            # Stop fetching data if limit has been met
            if exceeded_limit(self.limit, len(data)):
                break

            entry = row.find_all('td')
            entry_dict = {}

            show_time = entry[0].string
            if show_time and show_time != current_time:
                current_time = show_time
            if not show_time:
                show_time = current_time
            entry_dict['time'] = show_time

            show_string = entry[1].string.split('(')
            show = show_string[0][:-1]
            net = self._get_net(show_string)
            if not self._match_query(show, net):
                continue

            entry_dict['show'] = show
            entry_dict['net'] = net
            entry_dict['viewers'] = entry[3].string.strip('*')
            entry_dict['rating'], entry_dict['share'] = self._get_rating(entry)

            # Add data to initialize broadcast entry
            data.append(Entry(**entry_dict))

        return data"
2215,"def get_averages(self):
        """"""Get the broadcast network averages for that day.

        Returns a dictionary:
        key: network name
        value: sub-dictionary with 'viewers', 'rating', and 'share' as keys
        """"""
        networks = [unescape_html(n.string) for n in self.soup.find_all('td', width='77')]
        table = self.soup.find_all('td', style=re.compile('^font'))

        # Each element is a list split as [rating, share]
        rateshares = [r.string.split('/') for r in table[:5] if r.string]
        viewers = [v.string for v in table[5:] if v.string]
        averages = {}

        # Load the averages dict
        for index, network in enumerate(networks):
            viewer = convert_float(unescape_html(viewers[index]))
            rating = convert_float(unescape_html(rateshares[index][0]))
            share = convert_float(unescape_html(rateshares[index][1]))
            averages[network] = {'viewer': viewer, 'rating': rating, 'share': share}

        return averages"
2216,"def _get_net(self, entry):
        """"""Get the network for a specific row""""""
        try:
            net = entry[1]
            return net[net.find('(')+1:net.find(')')]
        except IndexError:
            return None"
2217,"def _get_rating(self, entry):
        """"""Get the rating and share for a specific row""""""
        r_info = ''
        for string in entry[2].strings:
            r_info += string
        rating, share = r_info.split('/')
        return (rating, share.strip('*'))"
2218,"def _visit(self, L, marked, tempmarked):
        """"""
        Sort features topologically.

        This recursive function uses depth-first search to find an ordering of
        the features in the feature graph that is sorted both topologically and
        with respect to genome coordinates.

        Implementation based on Wikipedia's description of the algorithm in
        Cormen's *Introduction to Algorithms*.
        http://en.wikipedia.org/wiki/Topological_sorting#Algorithms

        There are potentially many valid topological sorts of a feature graph,
        but only one that is also sorted with respect to genome coordinates
        (excluding different orderings of, for example, exons and CDS features
        with the same coordinates). Iterating through feature children in
        reversed order (in this functions' inner-most loop) seems to be the key
        to sorting with respect to genome coordinates.
        """"""
        assert not self.is_pseudo
        if self in tempmarked:
            raise Exception('feature graph is cyclic')
        if self not in marked:
            tempmarked[self] = True
            features = list()
            if self.siblings is not None and self.is_toplevel:
                features.extend(reversed(self.siblings))
            if self.children is not None:
                features.extend(reversed(self.children))
            if len(features) > 0:
                for feature in features:
                    feature._visit(L, marked, tempmarked)
            marked[self] = True
            del tempmarked[self]
            L.insert(0, self)"
2219,"def add_child(self, child, rangecheck=False):
        """"""Add a child feature to this feature.""""""
        assert self.seqid == child.seqid, \
            (
                'seqid mismatch for feature {} ({} vs {})'.format(
                    self.fid, self.seqid, child.seqid
                )
            )
        if rangecheck is True:
            assert self._strand == child._strand, \
                ('child of feature {} has a different strand'.format(self.fid))
            assert self._range.contains(child._range), \
                (
                    'child of feature {} is not contained within its span '
                    '({}-{})'.format(self.fid, child.start, child.end)
                )
        if self.children is None:
            self.children = list()
        self.children.append(child)
        self.children.sort()"
2220,"def pseudoify(self):
        """"""
        Derive a pseudo-feature parent from the given multi-feature.

        The provided multi-feature does not need to be the representative. The
        newly created pseudo-feature has the same seqid as the provided multi-
        feature, and spans its entire range. Otherwise, the pseudo-feature is
        empty. It is used only for convenience in sorting.
        """"""
        assert self.is_toplevel
        assert self.is_multi
        assert len(self.multi_rep.siblings) > 0
        rep = self.multi_rep

        start = min([s.start for s in rep.siblings + [rep]])
        end = max([s.end for s in rep.siblings + [rep]])

        parent = Feature(None)
        parent._pseudo = True
        parent._seqid = self._seqid
        parent.set_coord(start, end)
        parent._strand = self._strand
        for sibling in rep.siblings + [rep]:
            parent.add_child(sibling, rangecheck=True)
        parent.children = sorted(parent.children)
        rep.siblings = sorted(rep.siblings)

        return parent"
2221,"def slug(self):
        """"""
        A concise slug for this feature.

        Unlike the internal representation, which is 0-based half-open, the
        slug is a 1-based closed interval (a la GFF3).
        """"""
        return '{:s}@{:s}[{:d}, {:d}]'.format(self.type, self.seqid,
                                              self.start + 1, self.end)"
2222,"def add_sibling(self, sibling):
        """"""
        Designate this a multi-feature representative and add a co-feature.

        Some features exist discontinuously on the sequence, and therefore
        cannot be declared with a single GFF3 entry (which can encode only a
        single interval). The canonical encoding for these types of features is
        called a multi-feature, in which a single feature is declared on
        multiple lines with multiple entries all sharing the same feature type
        and ID attribute. This is commonly done with coding sequence (CDS)
        features.

        In this package, each multi-feature has a single ""representative""
        feature object, and all other objects/entries associated with that
        multi-feature are attached to it as ""siblings"".

        Invoking this method will designate the calling feature as the
        multi-feature representative and add the argument as a sibling.
        """"""
        assert self.is_pseudo is False
        if self.siblings is None:
            self.siblings = list()
            self.multi_rep = self
        sibling.multi_rep = self
        self.siblings.append(sibling)"
2223,"def source(self, newsource):
        """"""When modifying source, also update children with matching source.""""""
        oldsource = self.source
        for feature in self:
            if feature.source == oldsource:
                feature._source = newsource"
2224,"def type(self, newtype):
        """"""If the feature is a multifeature, update all entries.""""""
        self._type = newtype
        if self.is_multi:
            for sibling in self.multi_rep.siblings:
                sibling._type = newtype"
2225,"def transform(self, offset, newseqid=None):
        """"""Transform the feature's coordinates by the given offset.""""""
        for feature in self:
            feature._range.transform(offset)
            if newseqid is not None:
                feature.seqid = newseqid"
2226,"def add_attribute(self, attrkey, attrvalue, append=False, oldvalue=None):
        """"""
        Add an attribute to this feature.

        Feature attributes are stored as nested dictionaries.

        Each feature can only have one ID, so ID attribute mapping is 'string'
        to 'string'. All other attributes can have multiple values, so mapping
        is 'string' to 'dict of strings'.

        By default, adding an attribute that already exists will cause the old
        value to be overwritten. If the `append` option is true, the new
        attribute value will not overwrite the old value, but will be appended
        as a second value. (Note: ID attributes can have only 1 value.)

        If the `oldvalue` option is set, the new value will replace the old
        value. This is necessary for updating an attribute that has multiple
        values without completely overwriting all old values. (Note: The
        `append` option is ignored when `oldvalue` is set.)
        """"""
        # Handle ID/Parent relationships
        if attrkey == 'ID':
            if self.children is not None:
                oldid = self.get_attribute('ID')
                for child in self.children:
                    child.add_attribute('Parent', attrvalue,
                                        oldvalue=oldid)
            self._attrs[attrkey] = attrvalue
            if self.is_multi:
                self.multi_rep._attrs[attrkey] = attrvalue
                for sibling in self.multi_rep.siblings:
                    sibling._attrs[attrkey] = attrvalue
            return

        # Handle all other attribute types
        if oldvalue is not None:
            if attrkey in self._attrs:
                assert oldvalue in self._attrs[attrkey]
                del self._attrs[attrkey][oldvalue]
        if attrkey not in self._attrs or append is False:
            self._attrs[attrkey] = dict()
        self._attrs[attrkey][attrvalue] = True"
2227,"def get_attribute(self, attrkey, as_string=False, as_list=False):
        """"""
        Get the value of an attribute.

        By default, returns a string for ID and attributes with a single value,
        and a list of strings for attributes with multiple values. The
        `as_string` and `as_list` options can be used to force the function to
        return values as a string (comma-separated in case of multiple values)
        or a list.
        """"""
        assert not as_string or not as_list
        if attrkey not in self._attrs:
            return None
        if attrkey == 'ID':
            return self._attrs[attrkey]
        attrvalues = list(self._attrs[attrkey])
        attrvalues.sort()
        if len(attrvalues) == 1 and not as_list:
            return attrvalues[0]
        elif as_string:
            return ','.join(attrvalues)
        return attrvalues"
2228,"def parse_attributes(self, attrstring):
        """"""
        Parse an attribute string.

        Given a string with semicolon-separated key-value pairs, populate a
        dictionary with the given attributes.
        """"""
        if attrstring in [None, '', '.']:
            return dict()

        attributes = dict()
        keyvaluepairs = attrstring.split(';')
        for kvp in keyvaluepairs:
            if kvp == '':
                continue
            key, value = kvp.split('=')
            if key == 'ID':
                assert ',' not in value
                attributes[key] = value
                continue
            values = value.split(',')
            valdict = dict((val, True) for val in values)
            attributes[key] = valdict
        return attributes"
2229,"def attribute_crawl(self, key):
        """"""
        Grab all attribute values associated with the given feature.

        Traverse the given feature (and all of its descendants) to find all
        values associated with the given attribute key.

        >>> import tag
        >>> reader = tag.GFF3Reader(tag.pkgdata('otau-no-seqreg.gff3'))
        >>> features = tag.select.features(reader)
        >>> for feature in features:
        ...     names = feature.attribute_crawl('Name')
        ...     print(sorted(list(names)))
        ['Ot01g00060', 'XM_003074019.1', 'XP_003074065.1']
        ['Ot01g00070', 'XM_003074020.1', 'XP_003074066.1']
        ['Ot01g00080', 'XM_003074021.1', 'XP_003074067.1']
        ['Ot01g00090', 'XM_003074022.1', 'XP_003074068.1']
        ['Ot01g00100', 'XM_003074023.1', 'XP_003074069.1']
        ['Ot01g00110', 'XM_003074024.1', 'XP_003074070.1']
        """"""
        union = set()
        for feature in self:
            values = feature.get_attribute(key, as_list=True)
            if values is not None:
                union.update(set(values))
        return union"
2230,"def ncbi_geneid(self):
        """"""
        Retrieve this feature's NCBI GeneID if it's present.

        NCBI GFF3 files contain gene IDs encoded in **Dbxref** attributes
        (example: `Dbxref=GeneID:103504972`). This function locates and returns
        the GeneID if present, or returns `None` otherwise.
        """"""
        values = self.get_attribute('Dbxref', as_list=True)
        if values is None:
            return None
        for value in values:
            if value.startswith('GeneID:'):
                key, geneid = value.split(':')
                return geneid
        return None"
2231,"def cdslen(self):
        """"""
        Translated length of this feature.

        Undefined for non-mRNA features.
        """"""
        if self.type != 'mRNA':
            return None

        return sum([len(c) for c in self.children if c.type == 'CDS'])"
2232,"def parse_querystring(msg):
    'parse a querystring into keys and values'
    for part in msg.querystring.strip().lstrip('?').split('&'):
        key, value = part.split('=')
        yield key, value"
2233,"def AddClusterTags(r, tags, dry_run=False):
    """"""
    Adds tags to the cluster.

    @type tags: list of str
    @param tags: tags to add to the cluster
    @type dry_run: bool
    @param dry_run: whether to perform a dry run

    @rtype: int
    @return: job id
    """"""

    query = {
        ""dry-run"": dry_run,
        ""tag"": tags,
    }

    return r.request(""put"", ""/2/tags"", query=query)"
2234,"def DeleteClusterTags(r, tags, dry_run=False):
    """"""
    Deletes tags from the cluster.

    @type tags: list of str
    @param tags: tags to delete
    @type dry_run: bool
    @param dry_run: whether to perform a dry run
    """"""

    query = {
        ""dry-run"": dry_run,
        ""tag"": tags,
    }

    return r.request(""delete"", ""/2/tags"", query=query)"
2235,"def GetInstances(r, bulk=False):
    """"""
    Gets information about instances on the cluster.

    @type bulk: bool
    @param bulk: whether to return all information about all instances

    @rtype: list of dict or list of str
    @return: if bulk is True, info about the instances, else a list of instances
    """"""

    if bulk:
        return r.request(""get"", ""/2/instances"", query={""bulk"": 1})
    else:
        instances = r.request(""get"", ""/2/instances"")
        return r.applier(itemgetters(""id""), instances)"
2236,"def GetInstanceInfo(r, instance, static=None):
    """"""
    Gets information about an instance.

    @type instance: string
    @param instance: Instance name
    @rtype: string
    @return: Job ID
    """"""

    if static is None:
        return r.request(""get"", ""/2/instances/%s/info"" % instance)
    else:
        return r.request(""get"", ""/2/instances/%s/info"" % instance,
                         query={""static"": static})"
2237,"def CreateInstance(r, mode, name, disk_template, disks, nics,
                   **kwargs):
    """"""
    Creates a new instance.

    More details for parameters can be found in the RAPI documentation.

    @type mode: string
    @param mode: Instance creation mode
    @type name: string
    @param name: Hostname of the instance to create
    @type disk_template: string
    @param disk_template: Disk template for instance (e.g. plain, diskless,
                                                file, or drbd)
    @type disks: list of dicts
    @param disks: List of disk definitions
    @type nics: list of dicts
    @param nics: List of NIC definitions
    @type dry_run: bool
    @keyword dry_run: whether to perform a dry run
    @type no_install: bool
    @keyword no_install: whether to create without installing OS(true=don't install)

    @rtype: int
    @return: job id
    """"""

    if INST_CREATE_REQV1 not in r.features:
        raise GanetiApiError(""Cannot create Ganeti 2.1-style instances"")

    query = {}

    if kwargs.get(""dry_run""):
        query[""dry-run""] = 1
    if kwargs.get(""no_install""):
        query[""no-install""] = 1

    # Make a version 1 request.
    body = {
        _REQ_DATA_VERSION_FIELD: 1,
        ""mode"": mode,
        ""name"": name,
        ""disk_template"": disk_template,
        ""disks"": disks,
        ""nics"": nics,
    }

    conflicts = set(kwargs.iterkeys()) & set(body.iterkeys())
    if conflicts:
        raise GanetiApiError(""Required fields can not be specified as""
                             "" keywords: %s"" % "", "".join(conflicts))

    kwargs.pop(""dry_run"", None)
    body.update(kwargs)

    return r.request(""post"", ""/2/instances"", query=query, content=body)"
2238,"def DeleteInstance(r, instance, dry_run=False):
    """"""
    Deletes an instance.

    @type instance: str
    @param instance: the instance to delete

    @rtype: int
    @return: job id
    """"""

    return r.request(""delete"", ""/2/instances/%s"" % instance,
                     query={""dry-run"": dry_run})"
2239,"def ActivateInstanceDisks(r, instance, ignore_size=False):
    """"""
    Activates an instance's disks.

    @type instance: string
    @param instance: Instance name
    @type ignore_size: bool
    @param ignore_size: Whether to ignore recorded size
    @return: job id
    """"""

    return r.request(""put"", ""/2/instances/%s/activate-disks"" % instance,
                     query={""ignore_size"": ignore_size})"
2240,"def RecreateInstanceDisks(r, instance, disks=None, nodes=None):
    """"""Recreate an instance's disks.

    @type instance: string
    @param instance: Instance name
    @type disks: list of int
    @param disks: List of disk indexes
    @type nodes: list of string
    @param nodes: New instance nodes, if relocation is desired
    @rtype: string
    @return: job id
    """"""

    body = {}

    if disks is not None:
        body[""disks""] = disks
    if nodes is not None:
        body[""nodes""] = nodes

    return r.request(""post"", ""/2/instances/%s/recreate-disks"" % instance,
                     content=body)"
2241,"def GrowInstanceDisk(r, instance, disk, amount, wait_for_sync=False):
    """"""
    Grows a disk of an instance.

    More details for parameters can be found in the RAPI documentation.

    @type instance: string
    @param instance: Instance name
    @type disk: integer
    @param disk: Disk index
    @type amount: integer
    @param amount: Grow disk by this amount (MiB)
    @type wait_for_sync: bool
    @param wait_for_sync: Wait for disk to synchronize
    @rtype: int
    @return: job id
    """"""

    body = {
        ""amount"": amount,
        ""wait_for_sync"": wait_for_sync,
    }

    return r.request(""post"", ""/2/instances/%s/disk/%s/grow"" %
                             (instance, disk), content=body)"
2242,"def AddInstanceTags(r, instance, tags, dry_run=False):
    """"""
    Adds tags to an instance.

    @type instance: str
    @param instance: instance to add tags to
    @type tags: list of str
    @param tags: tags to add to the instance
    @type dry_run: bool
    @param dry_run: whether to perform a dry run

    @rtype: int
    @return: job id
    """"""

    query = {
        ""tag"": tags,
        ""dry-run"": dry_run,
    }

    return r.request(""put"", ""/2/instances/%s/tags"" % instance, query=query)"
2243,"def DeleteInstanceTags(r, instance, tags, dry_run=False):
    """"""
    Deletes tags from an instance.

    @type instance: str
    @param instance: instance to delete tags from
    @type tags: list of str
    @param tags: tags to delete
    @type dry_run: bool
    @param dry_run: whether to perform a dry run
    """"""

    query = {
        ""tag"": tags,
        ""dry-run"": dry_run,
    }

    return r.request(""delete"", ""/2/instances/%s/tags"" % instance, query=query)"
2244,"def RebootInstance(r, instance, reboot_type=None, ignore_secondaries=False,
                   dry_run=False):
    """"""
    Reboots an instance.

    @type instance: str
    @param instance: instance to rebot
    @type reboot_type: str
    @param reboot_type: one of: hard, soft, full
    @type ignore_secondaries: bool
    @param ignore_secondaries: if True, ignores errors for the secondary node
            while re-assembling disks (in hard-reboot mode only)
    @type dry_run: bool
    @param dry_run: whether to perform a dry run
    """"""

    query = {
        ""ignore_secondaries"": ignore_secondaries,
        ""dry-run"": dry_run,
    }

    if reboot_type:
        if reboot_type not in (""hard"", ""soft"", ""full""):
            raise GanetiApiError(""reboot_type must be one of 'hard',""
                                 "" 'soft', or 'full'"")
        query[""type""] = reboot_type

    return r.request(""post"", ""/2/instances/%s/reboot"" % instance, query=query)"
2245,"def ShutdownInstance(r, instance, dry_run=False, no_remember=False,
                     timeout=120):
    """"""
    Shuts down an instance.

    @type instance: str
    @param instance: the instance to shut down
    @type dry_run: bool
    @param dry_run: whether to perform a dry run
    @type no_remember: bool
    @param no_remember: if true, will not record the state change
    @rtype: string
    @return: job id
    """"""

    query = {
        ""dry-run"": dry_run,
        ""no-remember"": no_remember,
    }

    content = {
        ""timeout"": timeout,
    }

    return r.request(""put"", ""/2/instances/%s/shutdown"" % instance,
                     query=query, content=content)"
2246,"def StartupInstance(r, instance, dry_run=False, no_remember=False):
    """"""
    Starts up an instance.

    @type instance: str
    @param instance: the instance to start up
    @type dry_run: bool
    @param dry_run: whether to perform a dry run
    @type no_remember: bool
    @param no_remember: if true, will not record the state change
    @rtype: string
    @return: job id
    """"""

    query = {
        ""dry-run"": dry_run,
        ""no-remember"": no_remember,
    }

    return r.request(""put"", ""/2/instances/%s/startup"" % instance, query=query)"
2247,"def ReinstallInstance(r, instance, os=None, no_startup=False, osparams=None):
    """"""
    Reinstalls an instance.

    @type instance: str
    @param instance: The instance to reinstall
    @type os: str or None
    @param os: The operating system to reinstall. If None, the instance's
            current operating system will be installed again
    @type no_startup: bool
    @param no_startup: Whether to start the instance automatically
    """"""

    if INST_REINSTALL_REQV1 in r.features:
        body = {
            ""start"": not no_startup,
        }
        if os is not None:
            body[""os""] = os
        if osparams is not None:
            body[""osparams""] = osparams
        return r.request(""post"", ""/2/instances/%s/reinstall"" % instance,
                         content=body)

    # Use old request format
    if osparams:
        raise GanetiApiError(""Server does not support specifying OS""
                             "" parameters for instance reinstallation"")

    query = {
        ""nostartup"": no_startup,
    }

    if os:
        query[""os""] = os

    return r.request(""post"", ""/2/instances/%s/reinstall"" % instance,
                     query=query)"
2248,"def ReplaceInstanceDisks(r, instance, disks=None, mode=REPLACE_DISK_AUTO,
                         remote_node=None, iallocator=None, dry_run=False):
    """"""
    Replaces disks on an instance.

    @type instance: str
    @param instance: instance whose disks to replace
    @type disks: list of ints
    @param disks: Indexes of disks to replace
    @type mode: str
    @param mode: replacement mode to use (defaults to replace_auto)
    @type remote_node: str or None
    @param remote_node: new secondary node to use (for use with
            replace_new_secondary mode)
    @type iallocator: str or None
    @param iallocator: instance allocator plugin to use (for use with
                                         replace_auto mode)
    @type dry_run: bool
    @param dry_run: whether to perform a dry run

    @rtype: int
    @return: job id
    """"""

    if mode not in REPLACE_DISK:
        raise GanetiApiError(""Invalid mode %r not one of %r"" % (mode,
                                                                REPLACE_DISK))

    query = {
        ""mode"": mode,
        ""dry-run"": dry_run,
    }

    if disks:
        query[""disks""] = "","".join(str(idx) for idx in disks)

    if remote_node:
        query[""remote_node""] = remote_node

    if iallocator:
        query[""iallocator""] = iallocator

    return r.request(""post"", ""/2/instances/%s/replace-disks"" % instance,
                     query=query)"
2249,"def ExportInstance(r, instance, mode, destination, shutdown=None,
                   remove_instance=None, x509_key_name=None,
                   destination_x509_ca=None):
    """"""
    Exports an instance.

    @type instance: string
    @param instance: Instance name
    @type mode: string
    @param mode: Export mode
    @rtype: string
    @return: Job ID
    """"""

    body = {
        ""destination"": destination,
        ""mode"": mode,
    }

    if shutdown is not None:
        body[""shutdown""] = shutdown

    if remove_instance is not None:
        body[""remove_instance""] = remove_instance

    if x509_key_name is not None:
        body[""x509_key_name""] = x509_key_name

    if destination_x509_ca is not None:
        body[""destination_x509_ca""] = destination_x509_ca

    return r.request(""put"", ""/2/instances/%s/export"" % instance, content=body)"
2250,"def MigrateInstance(r, instance, mode=None, cleanup=None):
    """"""
    Migrates an instance.

    @type instance: string
    @param instance: Instance name
    @type mode: string
    @param mode: Migration mode
    @type cleanup: bool
    @param cleanup: Whether to clean up a previously failed migration
    """"""

    body = {}

    if mode is not None:
        body[""mode""] = mode

    if cleanup is not None:
        body[""cleanup""] = cleanup

    return r.request(""put"", ""/2/instances/%s/migrate"" % instance,
                     content=body)"
2251,"def FailoverInstance(r, instance, iallocator=None, ignore_consistency=False,
                     target_node=None):
    """"""Does a failover of an instance.

    @type instance: string
    @param instance: Instance name
    @type iallocator: string
    @param iallocator: Iallocator for deciding the target node for
        shared-storage instances
    @type ignore_consistency: bool
    @param ignore_consistency: Whether to ignore disk consistency
    @type target_node: string
    @param target_node: Target node for shared-storage instances
    @rtype: string
    @return: job id
    """"""

    body = {
        ""ignore_consistency"": ignore_consistency,
    }

    if iallocator is not None:
        body[""iallocator""] = iallocator
    if target_node is not None:
        body[""target_node""] = target_node


    return r.request(""put"", ""/2/instances/%s/failover"" % instance,
                     content=body)"
2252,"def RenameInstance(r, instance, new_name, ip_check, name_check=None):
    """"""
    Changes the name of an instance.

    @type instance: string
    @param instance: Instance name
    @type new_name: string
    @param new_name: New instance name
    @type ip_check: bool
    @param ip_check: Whether to ensure instance's IP address is inactive
    @type name_check: bool
    @param name_check: Whether to ensure instance's name is resolvable
    """"""

    body = {
        ""ip_check"": ip_check,
        ""new_name"": new_name,
    }

    if name_check is not None:
        body[""name_check""] = name_check

    return r.request(""put"", ""/2/instances/%s/rename"" % instance, content=body)"
2253,"def WaitForJobChange(r, job_id, fields, prev_job_info, prev_log_serial):
    """"""
    Waits for job changes.

    @type job_id: int
    @param job_id: Job ID for which to wait
    """"""

    body = {
        ""fields"": fields,
        ""previous_job_info"": prev_job_info,
        ""previous_log_serial"": prev_log_serial,
    }

    return r.request(""get"", ""/2/jobs/%s/wait"" % job_id, content=body)"
2254,"def CancelJob(r, job_id, dry_run=False):
    """"""
    Cancels a job.

    @type job_id: int
    @param job_id: id of the job to delete
    @type dry_run: bool
    @param dry_run: whether to perform a dry run
    """"""

    return r.request(""delete"", ""/2/jobs/%s"" % job_id,
                             query={""dry-run"": dry_run})"
2255,"def GetNodes(r, bulk=False):
    """"""
    Gets all nodes in the cluster.

    @type bulk: bool
    @param bulk: whether to return all information about all instances

    @rtype: list of dict or str
    @return: if bulk is true, info about nodes in the cluster,
            else list of nodes in the cluster
    """"""

    if bulk:
        return r.request(""get"", ""/2/nodes"", query={""bulk"": 1})
    else:
        nodes = r.request(""get"", ""/2/nodes"")
        return r.applier(itemgetters(""id""), nodes)"
2256,"def EvacuateNode(r, node, iallocator=None, remote_node=None, dry_run=False,
                 early_release=False, mode=None, accept_old=False):
    """"""
    Evacuates instances from a Ganeti node.

    @type node: str
    @param node: node to evacuate
    @type iallocator: str or None
    @param iallocator: instance allocator to use
    @type remote_node: str
    @param remote_node: node to evaucate to
    @type dry_run: bool
    @param dry_run: whether to perform a dry run
    @type early_release: bool
    @param early_release: whether to enable parallelization
    @type accept_old: bool
    @param accept_old: Whether caller is ready to accept old-style
        (pre-2.5) results

    @rtype: string, or a list for pre-2.5 results
    @return: Job ID or, if C{accept_old} is set and server is pre-2.5,
        list of (job ID, instance name, new secondary node); if dry_run
        was specified, then the actual move jobs were not submitted and
        the job IDs will be C{None}

    @raises GanetiApiError: if an iallocator and remote_node are both
            specified
    """"""

    if iallocator and remote_node:
        raise GanetiApiError(""Only one of iallocator or remote_node can""
                             "" be used"")

    query = {
        ""dry-run"": dry_run,
    }

    if iallocator:
        query[""iallocator""] = iallocator
    if remote_node:
        query[""remote_node""] = remote_node

    if NODE_EVAC_RES1 in r.features:
        # Server supports body parameters
        body = {
            ""early_release"": early_release,
        }

        if iallocator is not None:
            body[""iallocator""] = iallocator
        if remote_node is not None:
            body[""remote_node""] = remote_node
        if mode is not None:
            body[""mode""] = mode
    else:
        # Pre-2.5 request format
        body = None

        if not accept_old:
            raise GanetiApiError(""Server is version 2.4 or earlier and""
                                 "" caller does not accept old-style""
                                 "" results (parameter accept_old)"")

        # Pre-2.5 servers can only evacuate secondaries
        if mode is not None and mode != NODE_EVAC_SEC:
            raise GanetiApiError(""Server can only evacuate secondary instances"")

        if iallocator is not None:
            query[""iallocator""] = iallocator
        if remote_node is not None:
            query[""remote_node""] = remote_node
        if query:
            query[""early_release""] = 1

    return r.request(""post"", ""/2/nodes/%s/evacuate"" % node, query=query,
                     content=body)"
2257,"def MigrateNode(r, node, mode=None, dry_run=False, iallocator=None,
                target_node=None):
    """"""
    Migrates all primary instances from a node.

    @type node: str
    @param node: node to migrate
    @type mode: string
    @param mode: if passed, it will overwrite the live migration type,
            otherwise the hypervisor default will be used
    @type dry_run: bool
    @param dry_run: whether to perform a dry run
    @type iallocator: string
    @param iallocator: instance allocator to use
    @type target_node: string
    @param target_node: Target node for shared-storage instances

    @rtype: int
    @return: job id
    """"""

    query = {
        ""dry-run"": dry_run,
    }

    if NODE_MIGRATE_REQV1 in r.features:
        body = {}

        if mode is not None:
            body[""mode""] = mode
        if iallocator is not None:
            body[""iallocator""] = iallocator
        if target_node is not None:
            body[""target_node""] = target_node

    else:
        # Use old request format
        if target_node is not None:
            raise GanetiApiError(""Server does not support specifying""
                                 "" target node for node migration"")

        body = None

        if mode is not None:
            query[""mode""] = mode

    return r.request(""post"", ""/2/nodes/%s/migrate"" % node, query=query,
                     content=body)"
2258,"def SetNodeRole(r, node, role, force=False, auto_promote=False):
    """"""
    Sets the role for a node.

    @type node: str
    @param node: the node whose role to set
    @type role: str
    @param role: the role to set for the node
    @type force: bool
    @param force: whether to force the role change
    @type auto_promote: bool
    @param auto_promote: Whether node(s) should be promoted to master
        candidate if necessary

    @rtype: int
    @return: job id
    """"""

    query = {
        ""force"": force,
        ""auto_promote"": auto_promote,
    }

    return r.request(""put"", ""/2/nodes/%s/role"" % node, query=query,
                     content=role)"
2259,"def PowercycleNode(r, node, force=False):
    """"""
    Powercycles a node.

    @type node: string
    @param node: Node name
    @type force: bool
    @param force: Whether to force the operation
    @rtype: string
    @return: job id
    """"""

    query = {
        ""force"": force,
    }

    return r.request(""post"", ""/2/nodes/%s/powercycle"" % node, query=query)"
2260,"def GetNodeStorageUnits(r, node, storage_type, output_fields):
    """"""
    Gets the storage units for a node.

    @type node: str
    @param node: the node whose storage units to return
    @type storage_type: str
    @param storage_type: storage type whose units to return
    @type output_fields: str
    @param output_fields: storage type fields to return

    @rtype: int
    @return: job id where results can be retrieved
    """"""

    query = {
        ""storage_type"": storage_type,
        ""output_fields"": output_fields,
    }

    return r.request(""get"", ""/2/nodes/%s/storage"" % node, query=query)"
2261,"def ModifyNodeStorageUnits(r, node, storage_type, name, allocatable=None):
    """"""
    Modifies parameters of storage units on the node.

    @type node: str
    @param node: node whose storage units to modify
    @type storage_type: str
    @param storage_type: storage type whose units to modify
    @type name: str
    @param name: name of the storage unit
    @type allocatable: bool or None
    @param allocatable: Whether to set the ""allocatable"" flag on the storage
                                            unit (None=no modification, True=set, False=unset)

    @rtype: int
    @return: job id
    """"""

    query = {
        ""storage_type"": storage_type,
        ""name"": name,
    }

    if allocatable is not None:
        query[""allocatable""] = allocatable

    return r.request(""put"", ""/2/nodes/%s/storage/modify"" % node, query=query)"
2262,"def RepairNodeStorageUnits(r, node, storage_type, name):
    """"""
    Repairs a storage unit on the node.

    @type node: str
    @param node: node whose storage units to repair
    @type storage_type: str
    @param storage_type: storage type to repair
    @type name: str
    @param name: name of the storage unit to repair

    @rtype: int
    @return: job id
    """"""

    query = {
        ""storage_type"": storage_type,
        ""name"": name,
    }

    return r.request(""put"", ""/2/nodes/%s/storage/repair"" % node, query=query)"
2263,"def AddNodeTags(r, node, tags, dry_run=False):
    """"""
    Adds tags to a node.

    @type node: str
    @param node: node to add tags to
    @type tags: list of str
    @param tags: tags to add to the node
    @type dry_run: bool
    @param dry_run: whether to perform a dry run

    @rtype: int
    @return: job id
    """"""

    query = {
        ""tag"": tags,
        ""dry-run"": dry_run,
    }

    return r.request(""put"", ""/2/nodes/%s/tags"" % node, query=query,
                     content=tags)"
2264,"def DeleteNodeTags(r, node, tags, dry_run=False):
    """"""
    Delete tags from a node.

    @type node: str
    @param node: node to remove tags from
    @type tags: list of str
    @param tags: tags to remove from the node
    @type dry_run: bool
    @param dry_run: whether to perform a dry run

    @rtype: int
    @return: job id
    """"""

    query = {
        ""tag"": tags,
        ""dry-run"": dry_run,
    }

    return r.request(""delete"", ""/2/nodes/%s/tags"" % node, query=query)"
2265,"def GetGroups(r, bulk=False):
    """"""
    Gets all node groups in the cluster.

    @type bulk: bool
    @param bulk: whether to return all information about the groups

    @rtype: list of dict or str
    @return: if bulk is true, a list of dictionaries with info about all node
            groups in the cluster, else a list of names of those node groups
    """"""

    if bulk:
        return r.request(""get"", ""/2/groups"", query={""bulk"": 1})
    else:
        groups = r.request(""get"", ""/2/groups"")
        return r.applier(itemgetters(""name""), groups)"
2266,"def CreateGroup(r, name, alloc_policy=None, dry_run=False):
    """"""
    Creates a new node group.

    @type name: str
    @param name: the name of node group to create
    @type alloc_policy: str
    @param alloc_policy: the desired allocation policy for the group, if any
    @type dry_run: bool
    @param dry_run: whether to peform a dry run

    @rtype: int
    @return: job id
    """"""

    query = {
        ""dry-run"": dry_run,
    }

    body = {
        ""name"": name,
        ""alloc_policy"": alloc_policy
    }

    return r.request(""post"", ""/2/groups"", query=query, content=body)"
2267,"def DeleteGroup(r, group, dry_run=False):
    """"""
    Deletes a node group.

    @type group: str
    @param group: the node group to delete
    @type dry_run: bool
    @param dry_run: whether to peform a dry run

    @rtype: int
    @return: job id
    """"""

    query = {
        ""dry-run"": dry_run,
    }

    return r.request(""delete"", ""/2/groups/%s"" % group, query=query)"
2268,"def RenameGroup(r, group, new_name):
    """"""
    Changes the name of a node group.

    @type group: string
    @param group: Node group name
    @type new_name: string
    @param new_name: New node group name

    @rtype: int
    @return: job id
    """"""

    body = {
        ""new_name"": new_name,
    }

    return r.request(""put"", ""/2/groups/%s/rename"" % group, content=body)"
2269,"def AssignGroupNodes(r, group, nodes, force=False, dry_run=False):
    """"""
    Assigns nodes to a group.

    @type group: string
    @param group: Node gropu name
    @type nodes: list of strings
    @param nodes: List of nodes to assign to the group

    @rtype: int
    @return: job id

    """"""

    query = {
        ""force"": force,
        ""dry-run"": dry_run,
    }

    body = {
        ""nodes"": nodes,
    }

    return r.request(""put"", ""/2/groups/%s/assign-nodes"" % group, query=query,
                     content=body)"
2270,"def AddGroupTags(r, group, tags, dry_run=False):
    """"""
    Adds tags to a node group.

    @type group: str
    @param group: group to add tags to
    @type tags: list of string
    @param tags: tags to add to the group
    @type dry_run: bool
    @param dry_run: whether to perform a dry run

    @rtype: string
    @return: job id
    """"""

    query = {
        ""dry-run"": dry_run,
        ""tag"": tags,
    }

    return r.request(""put"", ""/2/groups/%s/tags"" % group, query=query)"
2271,"def DeleteGroupTags(r, group, tags, dry_run=False):
    """"""
    Deletes tags from a node group.

    @type group: str
    @param group: group to delete tags from
    @type tags: list of string
    @param tags: tags to delete
    @type dry_run: bool
    @param dry_run: whether to perform a dry run
    @rtype: string
    @return: job id
    """"""

    query = {
        ""dry-run"": dry_run,
        ""tag"": tags,
    }

    return r.request(""delete"", ""/2/groups/%s/tags"" % group, query=query)"
2272,"def Query(r, what, fields, qfilter=None):
    """"""
    Retrieves information about resources.

    @type what: string
    @param what: Resource name, one of L{constants.QR_VIA_RAPI}
    @type fields: list of string
    @param fields: Requested fields
    @type qfilter: None or list
    @param qfilter: Query filter

    @rtype: string
    @return: job id
    """"""

    body = {
        ""fields"": fields,
    }

    if qfilter is not None:
        body[""qfilter""] = body[""filter""] = qfilter

    return r.request(""put"", ""/2/query/%s"" % what, content=body)"
2273,"def QueryFields(r, what, fields=None):
    """"""
    Retrieves available fields for a resource.

    @type what: string
    @param what: Resource name, one of L{constants.QR_VIA_RAPI}
    @type fields: list of string
    @param fields: Requested fields

    @rtype: string
    @return: job id
    """"""

    query = {}

    if fields is not None:
        query[""fields""] = "","".join(fields)

    return r.request(""get"", ""/2/query/%s/fields"" % what, query=query)"
2274,"def createalphabet(alphabetinput=None):
    """"""
    Creates a sample alphabet containing printable ASCII characters
    """"""
    if alphabetinput and os.path.isfile(alphabetinput):
        return _load_alphabet(alphabetinput)
    elif alphabetinput:
        alpha = []
        setlist = alphabetinput.split(',')
        for alphaset in setlist:
            a = int(alphaset.split('-')[0])
            b = int(alphaset.split('-')[1])
            for i in range(a, b):
                alpha.append(str(unichr(i)))
        return alpha
    alpha = []
    for i in range(32, 127):
        alpha.append(str(unichr(i)))
    return alpha"
2275,"def _instant_search(self):
        """"""Determine possible keys after a push or pop
        """"""
        _keys = []
        for k,v in self.searchables.iteritems():
            if self.string in v:
                _keys.append(k)
        self.candidates.append(_keys)"
2276,"def best_guess(self):
        """"""Return the gnomekeyring position of the closest matching
        """"""
        best_guess_ever = (0, 0) # (key, string)
        points = defaultdict(float)
        points[0] = 0
        if len(self.string) > 0:
            for key in self.candidate_keys:
                guess = self.searchables[key]
                if guess == self.string:
                    points[key] += 100
                    break
                # skip, entry longer then guess
                if len(self.string) > len(guess):
                    continue
                # begins with
                if guess.startswith(self.string):
                    points[key] += 1
                # contained in
                if self.string in guess:
                    points[key] += 1
                # percentage of user search string in best guess
                if points[key] > 0:
                    points[key] += float(len(self.string))/len(guess)
        for k,v in points.iteritems():
            if points[best_guess_ever[0]] < points[k]:
                best_guess_ever = (k, self.searchables[k])
        return best_guess_ever"
2277,"def find_html_files(self, destination):
        """"""
        Finds all html files in the given destination.
        """"""
        for root, dirs, files in os.walk(destination):
            for f in files:
                if f.endswith('.html'):
                    yield os.path.join(root, f)"
2278,"def minify_file(self, target):
        """"""
        Minifies the target html file.
        """"""
        html = open(target, 'rb').read()
        enc = chardet.detect(html)['encoding']
        with codecs.open(target, 'r+', enc) as f:
            result = htmlmin.minify(f.read(), **self.options)
            f.seek(0)
            f.write(result)
            f.truncate()"
2279,"def on_after_build_all(self, builder, **extra):
        """"""
        after-build-all lektor event
        """"""
        # NOTE(vesuvium): compatibility for lektor 2.X and 3.X
        try:
            is_enabled = self.is_enabled(builder.build_flags)
        except AttributeError:
            is_enabled = self.is_enabled(builder.extra_flags)

        if not is_enabled:
            return

        reporter.report_generic('Starting HTML minification')
        for htmlfile in self.find_html_files(builder.destination_path):
            self.minify_file(htmlfile)
        reporter.report_generic('HTML minification finished')"
2280,"def InterpretWaveform(raw, integersOnly=False, headersOnly=False, noTimeArray=False):
        """"""
        Take the raw binary from a file saved from the LeCroy, read from a file using 
        the 2 lines:
        with open(filename, ""rb"") as file:
        raw = file.read()
        And extracts various properties of the saved time trace.
        
        Parameters
        ----------
        raw : bytes
            Bytes object containing the binary contents of the saved raw/trc file
        integersOnly : bool, optional
            If True, only returns the unprocessed integers (read from the ADC) 
            rather than the signal in volts. Defaults to False. 
        headersOnly : bool, optional
            If True, only returns the file header. Defaults to False. 
        noTimeArray : bool, optional
            If true returns timeStart, timeStop and timeStep and doesn't create the time array

        Returns
        -------
        WAVEDESC : dict
            dictionary containing some properties of the time trace and oscilloscope
            settings extracted from the header file.
        x : ndarray / tuple
            The array of time values recorded by the oscilloscope or,
            if noTimeArray is True, returns a tuplef of (timeStart, timeStop, timeStep)
        y : ndarray
            The array of voltage values recorded by the oscilloscope
        integers : ndarray
            The array of raw integers recorded from the ADC and stored in the binary file
        MissingData : bool
            bool stating if any data was missing


        """"""
        MissingData = False
        from struct import unpack
        
        if raw[0:1] != b'#':
                cmd = raw.split(b',')[0]  # ""C1:WF ALL"" or similar
                wave = raw[len(cmd)+1:]   # Remove the above command text (and trailing
        else:
                wave = raw

        del raw

#        if wave[0:1] != b'#':
#                warnings.warn('Waveform format not as expected, time trace may be missing data')
#                MissingData = True
                
        n = int(wave[1:2])          # number of digits in length of data
        N = int(wave[2:2+n])      # number describing length of data

        if wave.endswith(b'\n'):
                wave = wave[:-1]

        wave = wave[2+n:]

#        if N != len(wave):
#                warnings.warn('Length of waveform not as expected, time trace may be missing data')
#                MissingData = True
                
        # Code to parse WAVEDESC generated by parsing template, returned from scope query ""TEMPLATE?""
        # Note that this is not well tested and will not handle unusual settings
        WAVEDESC = dict()
        WAVEDESC['DESCRIPTOR_NAME'] = wave[0:16].strip(b'\x00')
        WAVEDESC['TEMPLATE_NAME'] = wave[16:32].strip(b'\x00')
        WAVEDESC['COMM_TYPE'] = {0: 'byte',1: 'word'}[unpack(b""<H"", wave[32:34])[0]]
        WAVEDESC['COMM_ORDER'] = {0: 'HIFIRST',1: 'LOFIRST'}[unpack(""<H"", wave[34:36])[0]]
        WAVEDESC['WAVE_DESCRIPTOR'] = unpack('<l', wave[36:40])[0]
        WAVEDESC['USER_TEXT'] = unpack('<l', wave[40:44])[0]
        WAVEDESC['RES_DESC1'] = unpack('<l', wave[44:48])[0]
        WAVEDESC['TRIGTIME_ARRAY'] = unpack('<l', wave[48:52])[0]
        WAVEDESC['RIS_TIME_ARRAY'] = unpack('<l', wave[52:56])[0]
        WAVEDESC['RES_ARRAY1'] = unpack('<l', wave[56:60])[0]
        WAVEDESC['WAVE_ARRAY_1'] = unpack('<l', wave[60:64])[0]
        WAVEDESC['WAVE_ARRAY_2'] = unpack('<l', wave[64:68])[0]
        WAVEDESC['RES_ARRAY2'] = unpack('<l', wave[68:72])[0]
        WAVEDESC['RES_ARRAY3'] = unpack('<l', wave[72:76])[0]
        WAVEDESC['INSTRUMENT_NAME'] = wave[76:92].strip(b'\x00')
        WAVEDESC['INSTRUMENT_NUMBER'] = unpack('<l', wave[92:96])[0]
        WAVEDESC['TRACE_LABEL'] = wave[96:112].strip(b'\x00')
        WAVEDESC['RESERVED1'] = unpack('<h', wave[112:114])[0]
        WAVEDESC['RESERVED2'] = unpack('<h', wave[114:116])[0]
        WAVEDESC['WAVE_ARRAY_COUNT'] = unpack('<l', wave[116:120])[0]
        WAVEDESC['PNTS_PER_SCREEN'] = unpack('<l', wave[120:124])[0]
        WAVEDESC['FIRST_VALID_PNT'] = unpack('<l', wave[124:128])[0]
        WAVEDESC['LAST_VALID_PNT'] = unpack('<l', wave[128:132])[0]
        WAVEDESC['FIRST_POINT'] = unpack('<l', wave[132:136])[0]
        WAVEDESC['SPARSING_FACTOR'] = unpack('<l', wave[136:140])[0]
        WAVEDESC['SEGMENT_INDEX'] = unpack('<l', wave[140:144])[0]
        WAVEDESC['SUBARRAY_COUNT'] = unpack('<l', wave[144:148])[0]
        WAVEDESC['SWEEPS_PER_ACQ'] = unpack('<l', wave[148:152])[0]
        WAVEDESC['POINTS_PER_PAIR'] = unpack('<h', wave[152:154])[0]
        WAVEDESC['PAIR_OFFSET'] = unpack('<h', wave[154:156])[0]
        WAVEDESC['VERTICAL_GAIN'] = unpack('<f', wave[156:160])[0]
        WAVEDESC['VERTICAL_OFFSET'] = unpack('<f', wave[160:164])[0]
        WAVEDESC['MAX_VALUE'] = unpack('<f', wave[164:168])[0]
        WAVEDESC['MIN_VALUE'] = unpack('<f', wave[168:172])[0]
        WAVEDESC['NOMINAL_BITS'] = unpack('<h', wave[172:174])[0]
        WAVEDESC['NOM_SUBARRAY_COUNT'] = unpack('<h', wave[174:176])[0]
        WAVEDESC['HORIZ_INTERVAL'] = unpack('<f', wave[176:180])[0]
        WAVEDESC['HORIZ_OFFSET'] = unpack('<d', wave[180:188])[0]
        WAVEDESC['PIXEL_OFFSET'] = unpack('<d', wave[188:196])[0]
        WAVEDESC['VERTUNIT'] = wave[196:244].strip(b'\x00')
        WAVEDESC['HORUNIT'] = wave[244:292].strip(b'\x00')
        WAVEDESC['HORIZ_UNCERTAINTY'] = unpack('<f', wave[292:296])[0]
        WAVEDESC['TRIGGER_TIME'] = wave[296:312] # Format time_stamp not implemented
        WAVEDESC['ACQ_DURATION'] = unpack('<f', wave[312:316])[0]
        WAVEDESC['RECORD_TYPE'] = {0: 'single_sweep',1: 'interleaved',2: 'histogram',3: 'graph',4: 'filter_coefficient',5: 'complex',6: 'extrema',7: 'sequence_obsolete',8: 'centered_RIS',9: 'peak_detect'}[unpack(""<H"", wave[316:318])[0]]
        WAVEDESC['PROCESSING_DONE'] = {0: 'no_processing',1: 'fir_filter',2: 'interpolated',3: 'sparsed',4: 'autoscaled',5: 'no_result',6: 'rolling',7: 'cumulative'}[unpack(""<H"", wave[318:320])[0]]
        WAVEDESC['RESERVED5'] = unpack('<h', wave[320:322])[0]
        WAVEDESC['RIS_SWEEPS'] = unpack('<h', wave[322:324])[0]
        WAVEDESC['TIMEBASE'] = {0: '1_ps/div',1: '2_ps/div',2: '5_ps/div',3: '10_ps/div',4: '20_ps/div',5: '50_ps/div',6: '100_ps/div',7: '200_ps/div',8: '500_ps/div',9: '1_ns/div',10: '2_ns/div',11: '5_ns/div',12: '10_ns/div',13: '20_ns/div',14: '50_ns/div',15: '100_ns/div',16: '200_ns/div',17: '500_ns/div',18: '1_us/div',19: '2_us/div',20: '5_us/div',21: '10_us/div',22: '20_us/div',23: '50_us/div',24: '100_us/div',25: '200_us/div',26: '500_us/div',27: '1_ms/div',28: '2_ms/div',29: '5_ms/div',30: '10_ms/div',31: '20_ms/div',32: '50_ms/div',33: '100_ms/div',34: '200_ms/div',35: '500_ms/div',36: '1_s/div',37: '2_s/div',38: '5_s/div',39: '10_s/div',40: '20_s/div',41: '50_s/div',42: '100_s/div',43: '200_s/div',44: '500_s/div',45: '1_ks/div',46: '2_ks/div',47: '5_ks/div',100: 'EXTERNAL'}[unpack(""<H"", wave[324:326])[0]]
        WAVEDESC['VERT_COUPLING'] = {0: 'DC_50_Ohms',1: 'ground',2: 'DC_1MOhm',3: 'ground',4: 'AC_1MOhm'}[unpack(""<H"", wave[326:328])[0]]
        WAVEDESC['PROBE_ATT'] = unpack('<f', wave[328:332])[0]
        WAVEDESC['FIXED_VERT_GAIN'] = {0: '1_uV/div',1: '2_uV/div',2: '5_uV/div',3: '10_uV/div',4: '20_uV/div',5: '50_uV/div',6: '100_uV/div',7: '200_uV/div',8: '500_uV/div',9: '1_mV/div',10: '2_mV/div',11: '5_mV/div',12: '10_mV/div',13: '20_mV/div',14: '50_mV/div',15: '100_mV/div',16: '200_mV/div',17: '500_mV/div',18: '1_V/div',19: '2_V/div',20: '5_V/div',21: '10_V/div',22: '20_V/div',23: '50_V/div',24: '100_V/div',25: '200_V/div',26: '500_V/div',27: '1_kV/div'}[unpack(""<H"", wave[332:334])[0]]
        WAVEDESC['BANDWIDTH_LIMIT'] = {0: 'off',1: 'on'}[unpack(""<H"", wave[334:336])[0]]
        WAVEDESC['VERTICAL_VERNIER'] = unpack('<f', wave[336:340])[0]
        WAVEDESC['ACQ_VERT_OFFSET'] = unpack('<f', wave[340:344])[0]
        WAVEDESC['WAVE_SOURCE'] = {0: 'CHANNEL_1',1: 'CHANNEL_2',2: 'CHANNEL_3',3: 'CHANNEL_4',9: 'UNKNOWN'}[unpack(""<H"", wave[344:346])[0]]

        if len(wave[346:]) != WAVEDESC['WAVE_ARRAY_1']:
                warnings.warn('Binary data not the expected length, time trace may be missing data')
                MissingData = True

        if headersOnly:
                return WAVEDESC, MissingData
        else:
                from numpy import fromstring, int16, arange
                if MissingData != True:
                        integers = fromstring(wave[346:], dtype=int16)
                else:
                        integers = fromstring(wave[346:][:-1], dtype=int16)
                        
                if integersOnly:
                        return (WAVEDESC, integers, MissingData)
                elif noTimeArray:
                        y = integers * WAVEDESC['VERTICAL_GAIN'] - WAVEDESC['VERTICAL_OFFSET']
                        x = arange(len(integers)) * WAVEDESC['HORIZ_INTERVAL'] + WAVEDESC['HORIZ_OFFSET']
                        timeStart = x[0]
                        timeStop = x[-1] 
                        timeStep = x[1]-x[0]
                        return (WAVEDESC, (timeStart, timeStop, timeStep), y, integers, MissingData)
                        
                else:
                        y = integers * WAVEDESC['VERTICAL_GAIN'] - WAVEDESC['VERTICAL_OFFSET'] 
                        x = arange(len(integers)) * WAVEDESC['HORIZ_INTERVAL'] + WAVEDESC['HORIZ_OFFSET']
                        return (WAVEDESC, x, y, integers, MissingData)"
2281,"def raw(self, channel=1):
                """"""
                Reads the raw input from the oscilloscope.
                
                Parameters
                ----------
                channel : int
                    channel number of read
                
                Returns
                -------
                rawData : bytes
                    raw binary data read from the oscilloscope
                """"""
                self.waitOPC()
                self.write('COMM_FORMAT DEF9,WORD,BIN')
                self.write('C%u:WAVEFORM?' % channel)
                return self.read_raw()"
2282,"def features(entrystream, type=None, traverse=False):
    """"""
    Pull features out of the specified entry stream.

    :param entrystream: a stream of entries
    :param type: retrieve only features of the specified type; set to
                 :code:`None` to retrieve all features
    :param traverse: by default, only top-level features are selected; set
                     to :code:`True` to search each feature graph for the
                     specified feature type
    """"""
    for feature in entry_type_filter(entrystream, tag.Feature):
        if traverse:
            if type is None:
                message = 'cannot traverse without a specific feature type'
                raise ValueError(message)
            if type == feature.type:
                yield feature
            else:
                for subfeature in feature:
                    if type == subfeature.type:
                        yield subfeature
        else:
            if not type or type == feature.type:
                yield feature"
2283,"def window(featurestream, seqid, start=None, end=None, strict=True):
    """"""
    Pull features out of the designated genomic interval.

    This function uses 0-based half-open intervals, not the 1-based closed
    intervals used by GFF3.

    :param featurestream: a stream of feature entries
    :param seqid: ID of the sequence from which to select features
    :param start: start of the genomic interval
    :param end: end of the genomic interval
    :param strict: when set to :code:`True`, only features completely contained
                   within the interval are selected; when set to :code:`False`,
                   any feature overlapping the interval is selected
    """"""
    region = None
    if start and end:
        region = tag.Range(start, end)

    for feature in featurestream:
        if feature.seqid != seqid:
            continue
        if region:
            if strict:
                if region.contains(feature._range):
                    yield feature
            else:
                if region.overlap(feature._range):
                    yield feature
        else:
            yield feature"
2284,"def directives(entrystream, type=None):
    """"""
    Pull directives out of the specified entry stream.

    :param entrystream: a stream of entries
    :param type: retrieve only directives of the specified type; set to
                 :code:`None` to retrieve all directives
    """"""
    for directive in entry_type_filter(entrystream, tag.Directive):
        if not type or type == directive.type:
            yield directive"
2285,"def validate_driver(f):
    """"""Check driver on""""""

    def check_driver(request):
        drivers = get_all_driver()
        drivers = filter(drivers, request)

        if drivers:
            return f(request, drivers)
        else:
            raise Exception('Driver is not found')

    return check_driver"
2286,"def cli(ctx, stage, port):
    """"""Web interface(experimental).""""""
    if not ctx.bubble:
        ctx.say_yellow('There is no bubble present, will not listen')
        raise click.Abort()
    gbc = ctx.gbc
    WEB = None
    if stage in STAGES:
        STAGE = ctx.cfg.CFG[stage]
        if 'SERVER'  in STAGE:
            SERVER=STAGE.SERVER
            if 'WEB' in SERVER:
                WEB=SERVER.WEB

    if not WEB:
        ctx.say_red('There is no SERVER.WEB in stage:' + stage)
        ctx.say_yellow('please check configuration in ' +
                       ctx.home + '/config/config.yaml')
        raise click.Abort()

    web_server = get_server(gbc, WEB, ctx.home)

    try:
        # TODO: bg &
        # src_listening = web_server.start_web(ctx=gbc,
        web_server.start_web(ctx=gbc,
                             port=port,
                             stage=stage)
    except Exception as e:
        ctx.say_red(
            'cannot start web server e ' + WEB)
        ctx.say_red(str(e))
        raise click.Abort('cannot listen')"
2287,"def get_plural_tag_index(number, locale):
    """"""Gets the plural tag index of a number on the plural rule of a locale::

       >>> get_plural_tag_index(1, 'en_US')
       0
       >>> get_plural_tag_index(2, 'en_US')
       1
       >>> get_plural_tag_index(100, 'en_US')
       1

    """"""
    locale = Locale.parse(locale)
    plural_rule = locale.plural_form
    used_tags = plural_rule.tags | set([_fallback_tag])
    tag, index = plural_rule(number), 0
    for _tag in _plural_tags:
        if _tag == tag:
            return index
        if _tag in used_tags:
            index += 1"
2288,"def strings_to_(strings: Iterable[str], f: Callable) -> Iterable[Any]:
    """"""
    Convert a list of strings to a list of certain form, specified by *f*.

    :param strings: a list of string
    :param f: a function that converts your string
    :return: type undefined, but specified by `to_type`

    .. doctest::

        >>> strings_to_(['0.333', '0.667', '0.250'], float)
        [0.333, 0.667, 0.25]
    """"""
    if not all_string_like(strings):
        raise TypeError('All have to be strings!')
    # ``type(strs)`` is the container of *strs*.
    return type(strings)(map(f, strings))"
2289,"def strings_to_integers(strings: Iterable[str]) -> Iterable[int]:
    """"""
    Convert a list of strings to a list of integers.

    :param strings: a list of string
    :return: a list of converted integers

    .. doctest::

        >>> strings_to_integers(['1', '1.0', '-0.2'])
        [1, 1, 0]
    """"""
    return strings_to_(strings, lambda x: int(float(x)))"
2290,"def string_to_double_precision_float(s: str) -> float:
    """"""
    Double precision float in Fortran file will have form 'x.ydz' or 'x.yDz', this cannot be convert directly to float
    by Python ``float`` function, so I wrote this function to help conversion. For example,

    :param s: a string denoting a double precision number
    :return: a Python floating point number

    .. doctest::

        >>> string_to_double_precision_float('1d-82')
        1e-82
        >>> string_to_double_precision_float('1.0D-82')
        1e-82
        >>> string_to_double_precision_float('0.8D234')
        8e+233
        >>> string_to_double_precision_float('.8d234')
        8e+233
    """"""
    first, second, exponential = re.match(
        ""(-?\d*)\.?(-?\d*)d(-?\d+)"", s, re.IGNORECASE).groups()
    return float(first + '.' + second + 'e' + exponential)"
2291,"def string_to_general_float(s: str) -> float:
    """"""
    Convert a string to corresponding single or double precision scientific number.

    :param s: a string could be '0.1', '1e-5', '1.0D-5', or any other validated number
    :return: a float or raise an error

    .. doctest::

        >>> string_to_general_float('1.0D-5')
        1e-05
        >>> string_to_general_float('1Dx')
        Traceback (most recent call last):
            ...
        ValueError: The string '1Dx' does not corresponds to a double precision number!
        >>> string_to_general_float('.8d234')
        8e+233
        >>> string_to_general_float('0.1')
        0.1
    """"""
    if 'D' in s.upper():  # Possible double precision number
        try:
            return string_to_double_precision_float(s)
        except ValueError:
            raise ValueError(
                ""The string '{0}' does not corresponds to a double precision number!"".format(s))
    else:
        return float(s)"
2292,"def match_one_string(pattern: str, s: str, *args):
    """"""
    Make sure you know only none or one string will be matched! If you are not sure, use `match_one_pattern` instead.

    :param pattern:
    :param s:
    :param args:
    :return:

    .. doctest::

        >>> p = ""\d+""
        >>> s = ""abc 123 def""
        >>> match_one_string(p, s, int)
        123
        >>> print(match_one_string(p, ""abc""))
        Pattern ""\d+"" not found, or more than one found in string abc!
        None
        >>> print(match_one_string(p, ""abc 123 def 456""))
        Pattern ""\d+"" not found, or more than one found in string abc 123 def 456!
        None
    """"""
    try:
        # `match` is either an empty list or a list of string.
        match, = re.findall(pattern, s)
        if len(args) == 0:  # If no wrapper argument is given, return directly the matched string
            return match
        elif len(args) == 1:  # If wrapper argument is given, i.e., not empty, then apply wrapper to the match
            wrapper, = args
            return wrapper(match)
        else:
            raise TypeError(
                'Multiple wrappers are given! Only one should be given!')
    except ValueError:
        print(""Pattern \""{0}\"" not found, or more than one found in string {1}!"".format(
            pattern, s))"
2293,"def match_one_pattern(pattern: str, s: str, *args: Optional[Callable], **flags):
    """"""
    Find a pattern in a certain string. If found and a wrapper is given, then return the wrapped matched-string; if no
    wrapper is given, return the pure matched string. If no match is found, return None.

    :param pattern: a pattern, can be a string or a regular expression
    :param s: a string
    :param args: at most 1 argument can be given
    :param flags: the same flags as ``re.findall``'s
    :return:

    .. doctest::

        >>> p = ""\d+""
        >>> s = ""abc 123 def 456""
        >>> match_one_pattern(p, s)
        ['123', '456']
        >>> match_one_pattern(p, s, int)
        [123, 456]
        >>> match_one_pattern(p, ""abc 123 def"")
        ['123']
        >>> print(match_one_pattern('s', 'abc'))
        Pattern ""s"" not found in string abc!
        None
        >>> match_one_pattern('s', 'Ssa', flags=re.IGNORECASE)
        ['S', 's']
    """"""
    match: Optional[List[str]] = re.findall(pattern, s,
                                            **flags)  # `match` is either an empty list or a list of strings.
    if match:
        if len(args) == 0:  # If no wrapper argument is given, return directly the matched string
            return match
        elif len(args) == 1:  # If wrapper argument is given, i.e., not empty, then apply wrapper to the match
            wrapper, = args
            return [wrapper(m) for m in match]
        else:
            raise TypeError(
                'Multiple wrappers are given! Only one should be given!')
    else:  # If no match is found
        print(""Pattern \""{0}\"" not found in string {1}!"".format(pattern, s))
        return None"
2294,"def all_string_like(iterable: Iterable[object]) -> bool:
    """"""
    If any element of an iterable is not a string, return `True`.

    :param iterable: Can be a set, a tuple, a list, etc.
    :return: Whether any element of an iterable is not a string.

    .. doctest::

        >>> all_string_like(['a', 'b', 'c', 3])
        False
        >>> all_string_like(('a', 'b', 'c', 'd'))
        True
    """"""
    return all(is_string_like(_) for _ in iterable)"
2295,"def source_filename(self, docname: str, srcdir: str):
        """""" Get the full filename to referenced image """"""

        docpath = Path(srcdir, docname)
        parent = docpath.parent
        imgpath = parent.joinpath(self.filename)

        # Does this exist?
        if not imgpath.exists():
            msg = f'Image does not exist at ""{imgpath}""'
            raise SphinxError(msg)

        return imgpath"
2296,"def env_updated(self,
                    kb_app,
                    sphinx_app: Sphinx,
                    sphinx_env: BuildEnvironment,
                    resource
                    ):
        """""" Make images and enter them in Sphinx's output writer """"""

        docname = resource.docname
        srcdir = sphinx_app.env.srcdir
        source_imgpath = self.source_filename(docname, srcdir)

        # Copy the image to the Sphinx build directory
        build_dir = sphinx_app.outdir
        docpath = Path(docname)
        parent = docpath.parent
        target_imgpath = str(Path(build_dir, parent, self.filename))

        # Does the target dir exist yet in the build dir? Probably not. If
        # not, make it
        target_dir = Path(build_dir, parent)
        if not target_dir.exists():
            target_dir.mkdir(parents=True, exist_ok=True)

        shutil.copy(source_imgpath, target_imgpath)"
2297,"def catalog(self, table='', column=''):
        """"""Lookup the values available for querying.""""""
        lookup_table = self.lookup_table
        if lookup_table is not None:
            if table:
                if column:
                    column = column.upper()
                    return lookup_table[table][column]
                return lookup_table[table]
            # Show what methods are available.
            return self.lookup_methods
        return None"
2298,"def _resolve_call(self, table, column='', value='', **kwargs):
        """"""Internal method to resolve the API wrapper call.""""""
        if not column:
            return self.catalog(table)
        elif not value:
            return self.catalog(table, column)
        # We have all the table, column, and value, and now need to
        # ensure they're all strings and uppercase.
        column = column.upper()
        value = str(value).upper()
        data = self.call_api(table, column, value, **kwargs)
        if isinstance(data, dict):
            # Data is actually the first value.
            data = data.values()[0]
        return data"
2299,"def call_api(self, table, column, value, **kwargs):
        """"""Exposed method to connect and query the EPA's API.""""""
        try:
            output_format = kwargs.pop('output_format')
        except KeyError:
            output_format = self.output_format
        url_list = [self.base_url, table, column,
                    quote(value), 'rows']
        rows_count = self._number_of_rows(**kwargs)
        url_list.append(rows_count)
        url_string = '/'.join(url_list)
        xml_data = urlopen(url_string).read()
        data = self._format_data(output_format, xml_data)
        return data"
2300,"def _number_of_rows(self, start=0, count=100, **kwargs):
        """"""Internal method to format the number of rows the EPA API returns.""""""
        first = str(start)
        last = str(start + count)
        string_format = ':'.join([first, last])
        return string_format"
2301,"def get_reference(self, rtype: str, label: str):
        """""" Return reference filed under rtype/label

         The references are organized by field/label, e.g. category/cat1.
         This lets us use a shorthand notation to go the resource, e.g.
         ref:category:cat1 instead of folder1/folder2/cat1.
         """"""

        # We are doing this instead of dictionary access in case we change
        # the storage later to a multidict thingy for optimization.

        reftype = self.data.get(rtype)
        if reftype:
            # The reftype might be ""python"" or ""sphinx"" or something else
            # from an Intersphinx registry, not something internal to
            # Kaybee.
            return reftype[label]"
2302,"def add_reference(self, reftype: str, label: str, target):
        """""" Add reference object in references under rtype/label=target """"""

        # The self.data[reftype] dict springs into being during the
        # register_references event handler at startup, which looks in the
        # kb registry for all registered reference names.
        self.data[reftype][label] = target"
2303,"def resource_references(self, resource) -> Mapping[str, List[Any]]:
        """""" Resolve and return reference resources pointed to by object

         Fields in resource.props can flag that they are references by
         using the references type. This method scans the model,
         finds any fields that are references, and returns the
         reference resources pointed to by those references.

         Note that we shouldn't get to the point of dangling references.
         Our custom Sphinx event should raise a references error
         during the build process (though maybe it is just a warning?)

         """"""

        references = dict()
        for reference_label in resource.props.references:
            references[reference_label] = []

            # Iterate over each value on this field, e.g.
            # tags: tag1, tag2, tag3
            for target_label in resource.props.references.get(reference_label):
                # Ask the site to get the object
                target = self.get_reference(reference_label, target_label)
                references[reference_label].append(target)

        return references"
2304,"def start(self, retry_limit=None):
        """"""
        Try to connect to Twitter's streaming API.

        :param retry_limit: The maximum number of retries in case of failures. Default is None (unlimited)
        :raises :class:`~tweepy.error.TweepyError`: If there's some critical API error
        """"""
        # Run tweepy stream
        wrapper_listener = TweepyWrapperListener(listener=self.listener)
        stream = tweepy.Stream(auth=self.client.tweepy_api.auth, listener=wrapper_listener)

        retry_counter = 0
        while retry_limit is None or retry_counter <= retry_limit:
            try:
                retry_counter += 1
                if not self.client.config.get('user_stream'):
                    logging.info('Listening to public stream')
                    stream.filter(follow=self.filter.follow, track=self.filter.track)
                else:
                    if self.filter.follow:
                        logging.warning('Follow filters won\'t be used in user stream')

                    logging.info('Listening to user stream')
                    stream.userstream(track=self.filter.track)
            except AttributeError as e:
                # Known Tweepy's issue https://github.com/tweepy/tweepy/issues/576
                if ""'NoneType' object has no attribute 'strip'"" in str(e):
                    pass
                else:
                    raise"
2305,"def mappingBasedGrouping(protToPeps):
    """"""Performs protein grouping based only on protein to peptide mappings.

    :param protToPeps: dict, for each protein (=key) contains a set of
        associated peptides (=value). For Example {protein: {peptide, ...}, ...}

    #TODO: REFACTORING!!!

    returns a ProteinInference object
    """"""
    inference = ProteinInference(protToPeps)
    pepToProts = inference.pepToProts

    proteinClusters = _findProteinClusters(protToPeps, pepToProts)
    proteins = {}
    for clusterId, proteinCluster in enumerate(proteinClusters, 1):
        clusterProtToPeps = {p: protToPeps[p] for p in proteinCluster}

        #Find sameset proteins, define unique and non unique sameset proteins
        #NOTE: already unique proteins could be excluded to find sameset proteins
        samesetProteins = _findSamesetProteins(clusterProtToPeps)
        mergedProtToPeps = _mergeProteinEntries(samesetProteins,
                                                clusterProtToPeps)
        mergedPepToProts = _invertMapping(mergedProtToPeps)
        uniqueProteins = _findUniqueMappingValues(mergedPepToProts)
        remainingProteins = set(mergedProtToPeps).difference(uniqueProteins)

        # Remove subset proteins and check if remaining proteins become unique
        subsetProteinInfo = _findSubsetProteins(remainingProteins,
                                                mergedProtToPeps,
                                                mergedPepToProts)
        subsetProteins = [p for p, _ in subsetProteinInfo]
        subsetRemovedProtToPeps = _reducedProtToPeps(mergedProtToPeps,
                                                     subsetProteins)
        subsetRemovedPepToProts = _invertMapping(subsetRemovedProtToPeps)
        uniqueSubsetRemoved = _findUniqueMappingValues(subsetRemovedPepToProts)
        remainingProteins = remainingProteins.difference(subsetProteins)
        remainingProteins = remainingProteins.difference(uniqueSubsetRemoved)

        # Find redundant proteins #
        subsumableProteins = _findRedundantProteins(subsetRemovedProtToPeps,
                                                    subsetRemovedPepToProts)
        remainingNonRedundant = remainingProteins.difference(subsumableProteins)
        groupInitiatingProteins = uniqueSubsetRemoved.union(remainingNonRedundant)

        # - Generate protein groups and assign proteins to groups - #
        #Generate protein groups
        clusterGroupIds = set()
        for protein in groupInitiatingProteins:
            proteinIds = AUX.toList(protein)

            groupId = inference.addProteinGroup(proteinIds[0])
            inference.addLeadingToGroups(proteinIds, groupId)
            clusterGroupIds.add(groupId)

        #Add redundant proteins here (must be subsumable I guess)
        for protein in subsumableProteins:
            proteinIds = AUX.toList(protein)

            connectedProteins = _mappingGetValueSet(
                mergedPepToProts, mergedProtToPeps[protein]
            )
            flatConnectedProteins = _flattenMergedProteins(connectedProteins)
            groupIds = _mappingGetValueSet(
                inference._proteinToGroupIds, flatConnectedProteins
            )
            inference.addSubsumableToGroups(proteinIds, groupIds)
            assert len(groupIds) > 1

        #Add subgroup proteins to the respective groups
        #NOTE: proteins that are only a subset of subsumable proteins are not
        #to be added as subset proteins to a group but as subsumable proteins.
        for protein, supersetProteins in subsetProteinInfo:
            proteinIds = AUX.toList(protein)

            #If the protein is a subset of at least one protein, that is not a
            #subsumable protein, then it should be added to the group as subset.
            leadingSuperProteins = supersetProteins.intersection(
                                                    groupInitiatingProteins)
            if leadingSuperProteins:
                flatSupersetProteins = _flattenMergedProteins(
                                                    leadingSuperProteins)
                superGroupIds = _mappingGetValueSet(
                    inference._proteinToGroupIds, flatSupersetProteins
                )
                inference.addSubsetToGroups(proteinIds, superGroupIds)
            #However, if all its super proteins are subsumable, the protein
            #itself is a subsumable protein.
            else:
                flatSupersetProteins = _flattenMergedProteins(supersetProteins)
                superGroupIds = _mappingGetValueSet(
                    inference._proteinToGroupIds, flatSupersetProteins
                )
                inference.addSubsumableToGroups(proteinIds, superGroupIds)
                subsumableProteins.update(proteinIds)
            assert superGroupIds

        # - Define peptide properties - #
        groupToPeps = dict()
        allSubsumablePeps = set()
        for groupId in clusterGroupIds:
            group = inference.groups[groupId]
            if group.subsumableProteins:
                subsumablePeptides = _mappingGetValueSet(
                    protToPeps, group.subsumableProteins
                )
                allSubsumablePeps.update(subsumablePeptides)

            groupPeptides = _mappingGetValueSet(protToPeps, group.proteins)
            groupToPeps[groupId] = groupPeptides
        pepToGroups = _invertMapping(groupToPeps)

        #Get unique peptides from peptide to protein mapping
        uniquePeptides = _findUniqueMappingKeys(mergedPepToProts)
        #Shared peptides have a groupPeptideCount > 1
        nonSharedPeptides = _findUniqueMappingKeys(pepToGroups)
        sharedPeptides = set(pepToGroups).difference(nonSharedPeptides)
        #Subsumable peptides are peptides from subsumable proteins that
        #are not shared peptides of multiple groups
        subsumablePeptides = allSubsumablePeps.difference(sharedPeptides)
        #groupUniquePeptides are the remaining ones (not shared with subsumable
        #proteins, groupPeptideCount == 1, not unique peptides)
        groupUniquePeptides = nonSharedPeptides.difference(subsumablePeptides)
        groupUniquePeptides = groupUniquePeptides.difference(uniquePeptides)

        inference._uniquePeptides.update(uniquePeptides)
        inference._groupUniquePeptides.update(groupUniquePeptides)
        inference._groupSubsumablePeptides.update(subsumablePeptides)
        inference._sharedPeptides.update(sharedPeptides)

        # - Generate protein entries and add them to the inference object - #
        subsetProteinInfoDict = dict(subsetProteinInfo)
        for protein, peptides in viewitems(mergedProtToPeps):
            _uniquePeptides = peptides.intersection(uniquePeptides)
            _groupUniquePeptides = peptides.intersection(groupUniquePeptides)
            _subsumablePeptides = peptides.intersection(subsumablePeptides)
            _sharedPeptides = peptides.intersection(sharedPeptides)
            proteinIds = AUX.toList(protein)
            for proteinId in proteinIds:
                proteinEntry = Protein(proteinId, peptides)
                if protein in groupInitiatingProteins:
                    proteinEntry.isLeading = True
                elif protein in subsumableProteins:
                    proteinEntry.isSubsumable = True
                if protein in subsetProteins:
                    superset = subsetProteinInfoDict[protein]
                    proteinEntry.isSubset = _flattenMergedProteins(superset)
                if len(proteinIds) > 1:
                    proteinEntry.isSameset = set(proteinIds)
                inference.proteins[proteinId] = proteinEntry

                #Add peptides to protein entry
                proteinEntry.uniquePeptides = _uniquePeptides
                proteinEntry.groupUniquePeptides = _groupUniquePeptides
                proteinEntry.groupSubsumablePeptides = _subsumablePeptides
                proteinEntry.sharedPeptides = _sharedPeptides

        # - Save cluster information - #
        for proteinId in proteinCluster:
            inference._proteinToClusterId[proteinId] = clusterId
        inference.clusters[clusterId] = clusterGroupIds

    allProteins = set()
    for proteinGroup in viewvalues(inference.groups):
        allProteins.update(proteinGroup.proteins)
        allProteins.update(proteinGroup.subsumableProteins)
    assert len(allProteins) == len(protToPeps)
    return inference"
2306,"def _findProteinClusters(protToPeps, pepToProts):
    """"""Find protein clusters in the specified protein to peptide mappings.

    A protein cluster is a group of proteins that are somehow directly or
    indirectly connected by shared peptides.

    :param protToPeps: dict, for each protein (=key) contains a set of
        associated peptides (=value). For Example {protein: {peptide, ...}, ...}
    :param pepToProts: dict, for each peptide (=key) contains a set of parent
        proteins (=value). For Example {peptide: {protein, ...}, ...}
    :returns: a list of protein clusters, each cluster is a set of proteins
    """"""
    clusters = list()
    resolvingProteins = set(protToPeps)
    while resolvingProteins:
        protein = resolvingProteins.pop()
        proteinCluster = set([protein])

        peptides = set(protToPeps[protein])
        parsedPeptides = set()

        while len(peptides) != len(parsedPeptides):
            for peptide in peptides:
                proteinCluster.update(pepToProts[peptide])
            parsedPeptides.update(peptides)

            for protein in proteinCluster:
                peptides.update(protToPeps[protein])
        clusters.append(proteinCluster)
        resolvingProteins = resolvingProteins.difference(proteinCluster)
    return clusters"
2307,"def _findSamesetProteins(protToPeps, proteins=None):
    """"""Find proteins that are mapped to an identical set of peptides.

    :param protToPeps: dict, for each protein (=key) contains a set of
        associated peptides (=value). For Example {protein: {peptide, ...}, ...}
    :param proteins: iterable, proteins that are tested for having equal
        evidence. If not specified all proteins are tested
    :returns: a list of sorted protein tuples that share equal peptide evidence
    """"""
    proteins = viewkeys(protToPeps) if proteins is None else proteins

    equalEvidence = ddict(set)
    for protein in proteins:
        peptides = protToPeps[protein]
        equalEvidence[tuple(sorted(peptides))].add(protein)
    equalProteins = list()
    for proteins in viewvalues(equalEvidence):
        if len(proteins) > 1:
            equalProteins.append(tuple(sorted(proteins)))
    return equalProteins"
2308,"def _findSubsetProteins(proteins, protToPeps, pepToProts):
    """"""Find proteins which peptides are a sub-set, but not a same-set to other
    proteins.

    :param proteins: iterable, proteins that are tested for being a subset
    :param pepToProts: dict, for each peptide (=key) contains a set of parent
        proteins (=value). For Example {peptide: {protein, ...}, ...}
    :param protToPeps: dict, for each protein (=key) contains a set of
        associated peptides (=value). For Example {protein: {peptide, ...}, ...}
    :returns: a list of pairs of protein and their superset proteins.
        [(protein, {superset protein, ...}), ...]
    """"""
    proteinsEqual = lambda prot1, prot2: protToPeps[prot1] == protToPeps[prot2]

    subGroups = list()
    for protein in proteins:
        peptideCounts = Counter()
        for peptide in protToPeps[protein]:
            proteins = pepToProts[peptide]
            peptideCounts.update(proteins)
        peptideCount = peptideCounts.pop(protein)

        superGroups = set()
        for sharingProtein, sharedPeptides in peptideCounts.most_common():
            if peptideCount == sharedPeptides:
                if not proteinsEqual(protein, sharingProtein):
                    superGroups.add(sharingProtein)
            else:
                break
        if superGroups:
            subGroups.append((protein, superGroups))
    return subGroups"
2309,"def _findRedundantProteins(protToPeps, pepToProts, proteins=None):
    """"""Returns a set of proteins with redundant peptide evidence.

    After removing the redundant proteins from the ""protToPeps"" and ""pepToProts""
    mapping, all remaining proteins have at least one unique peptide. The
    remaining proteins are a ""minimal"" set of proteins that are able to explain
    all peptides. However, this is not guaranteed to be the optimal solution
    with the least number of proteins. In addition it is possible that multiple
    solutions with the same number of ""minimal"" proteins exist.

    Procedure for finding the redundant proteins:
    1.  Generate a list of proteins that do not contain any unique peptides, a
        unique peptide has exactly one protein entry in ""pepToProts"".
    2.  Proteins are first sorted in ascending order of the number of peptides.
        Proteins with an equal number of peptides are sorted in descending order
            of their sorted peptide frequencies (= proteins per peptide).
        If two proteins are still equal, they are sorted alpha numerical in
        descending order according to their protein names. For example in the
        case of a tie between proteins ""A"" and ""B"", protein ""B"" would be
        removed.
    3.  Parse this list of sorted non unique proteins;
        If all its peptides have a frequency value of greater 1;
        mark the protein as redundant; remove its peptides from the peptide
        frequency count, continue with the next entry.
    4.  Return the set of proteins marked as redundant.

    :param pepToProts: dict, for each peptide (=key) contains a set of parent
        proteins (=value). For Example {peptide: {protein, ...}, ...}
    :param protToPeps: dict, for each protein (=key) contains a set of
        associated peptides (=value). For Example {protein: {peptide, ...}, ...}
    :param proteins: iterable, proteins that are tested for being redundant. If
        None all proteins in ""protToPeps"" are parsed.
    :returns: a set of redundant proteins, i.e. proteins that are not necessary
        to explain all peptides
    """"""
    if proteins is None:
        proteins = viewkeys(protToPeps)

    pepFrequency = _getValueCounts(pepToProts)
    protPepCounts = _getValueCounts(protToPeps)

    getCount = operator.itemgetter(1)
    getProt = operator.itemgetter(0)

    #TODO: quick and dirty solution
    #NOTE: add a test for merged proteins
    proteinTuples = list()
    for protein in proteins:
        if isinstance(protein, tuple):
            proteinTuples.append(protein)
        else:
            proteinTuples.append(tuple([protein]))

    sort = list()
    for protein in sorted(proteinTuples, reverse=True):
        if len(protein) == 1:
            protein = protein[0]

        protPepFreq = [pepFrequency[pep] for pep in protToPeps[protein]]
        if min(protPepFreq) > 1:
            sortValue = (len(protPepFreq)*-1, sorted(protPepFreq, reverse=True))
            sort.append((protein, sortValue))
    sortedProteins = map(getProt, sorted(sort, key=getCount, reverse=True))

    redundantProteins = set()
    for protein in sortedProteins:
        for pep in protToPeps[protein]:
            if pepFrequency[pep] <= 1:
                break
        else:
            protPepFrequency = Counter(protToPeps[protein])
            pepFrequency.subtract(protPepFrequency)
            redundantProteins.add(protein)
    return redundantProteins"
2310,"def _mergeProteinEntries(proteinLists, protToPeps):
    """"""Returns a new ""protToPeps"" dictionary with entries merged that are
    present in proteinLists.

    NOTE:
        The key of the merged entry is a tuple of the sorted protein keys. This
        behaviour might change in the future; the tuple might be replaced by
        simply one of the protein entries which is then representative for all.

    :param proteinLists: a list of protein groups that will be merged
        [{protein, ...}, ...]
    :param protToPeps: dict, for each protein (=key) contains a set of
        associated peptides (=value). For Example {protein: {peptide, ...}, ...}
    :returns: dict, {protein: set([peptid, ...])}
    """"""
    mergedProtToPeps = dict(protToPeps)
    for proteins in proteinLists:
        for protein in proteins:
            peptides = mergedProtToPeps.pop(protein)
        mergedProtein = tuple(sorted(proteins))
        mergedProtToPeps[mergedProtein] = peptides
    return mergedProtToPeps"
2311,"def _reducedProtToPeps(protToPeps, proteins):
    """"""Returns a new, reduced ""protToPeps"" dictionary that does not contain
    entries present in ""proteins"".

    :param protToPeps: dict, for each protein (=key) contains a set of
        associated peptides (=value). For Example {protein: {peptide, ...}, ...}
    :param proteins: a list of proteinSet
    :returns: dict, protToPeps not containing entries from ""proteins""
    """"""
    return {k: v for k, v in viewitems(protToPeps) if k not in proteins}"
2312,"def _findUniqueMappingValues(mapping):
    """"""Find mapping entries that are unique for one key (value length of 1).

    .. Note:
        This function can be used to find unique proteins by providing a
        peptide to protein mapping.

    :param mapping: dict, for each key contains a set of entries
    :returns: a set of unique mapping values
    """"""
    uniqueMappingValues = set()
    for entries in viewvalues(mapping):
        if len(entries) == 1:
            uniqueMappingValues.update(entries)
    return uniqueMappingValues"
2313,"def _findUniqueMappingKeys(mapping):
    """"""Find mapping keys that only have one entry (value length of 1.

    :param mapping: dict, for each key contains a set of entries
    :returns: a set of unique mapping keys
    """"""

    uniqueMappingKeys = set()
    for key, entries in viewitems(mapping):
        if len(entries) == 1:
            uniqueMappingKeys.add(key)
    return uniqueMappingKeys"
2314,"def _invertMapping(mapping):
    """"""Converts a protein to peptide or peptide to protein mapping.

    :param mapping: dict, for each key contains a set of entries

    :returns: an inverted mapping that each entry of the values points to a set
        of initial keys.
    """"""
    invertedMapping = ddict(set)
    for key, values in viewitems(mapping):
        for value in values:
            invertedMapping[value].add(key)
    return invertedMapping"
2315,"def _getValueCounts(mapping):
    """"""Returns a counter object; contains for each key of the mapping the counts
    of the respective value element (= set length).

    :param mapping: dict, for each key contains a set of entries.
    :returns: a counter
    """"""
    return Counter({k: len(v) for k, v in viewitems(mapping)})"
2316,"def _mappingGetValueSet(mapping, keys):
    """"""Return a combined set of values from the mapping.

    :param mapping: dict, for each key contains a set of entries

    returns a set of combined entries
    """"""
    setUnion = set()
    for k in keys:
        setUnion = setUnion.union(mapping[k])
    return setUnion"
2317,"def _flattenMergedProteins(proteins):
    """"""Return a set where merged protein entries in proteins are flattened.

    :param proteins: an iterable of proteins, can contain merged protein entries
        in the form of tuple([protein1, protein2]).
    returns a set of protein entries, where all entries are strings
    """"""
    proteinSet = set()
    for protein in proteins:
        if isinstance(protein, tuple):
            proteinSet.update(protein)
        else:
            proteinSet.add(protein)
    return proteinSet"
2318,"def getGroups(self, proteinId):
        """"""Return a list of protein groups a protein is associated with.""""""
        return [self.groups[gId] for gId in self._proteinToGroupIds[proteinId]]"
2319,"def addProteinGroup(self, groupRepresentative):
        """"""Adds a new protein group and returns the groupId.

        The groupId is defined using an internal counter, which is incremented
        every time a protein group is added. The groupRepresentative is added
        as a leading protein.

        :param groupRepresentative: the protein group representing protein
        :returns: the protein groups groupId
        """"""
        groupId = self._getNextGroupId()
        self.groups[groupId] = ProteinGroup(groupId, groupRepresentative)
        self.addLeadingToGroups(groupRepresentative, groupId)
        return groupId"
2320,"def addLeadingToGroups(self, proteinIds, groupIds):
        """"""Add one or multiple leading proteins to one or multiple protein
        groups.

        :param proteinIds: a proteinId or a list of proteinIds, a proteinId
            must be a string.
        :param groupIds: a groupId or a list of groupIds, a groupId
            must be a string.
        """"""
        for groupId in AUX.toList(groupIds):
            self.groups[groupId].addLeadingProteins(proteinIds)
            self._addProteinIdsToGroupMapping(proteinIds, groupId)"
2321,"def addSubsetToGroups(self, proteinIds, groupIds):
        """"""Add one or multiple subset proteins to one or multiple protein
        groups.

        :param proteinIds: a proteinId or a list of proteinIds, a proteinId
            must be a string.
        :param groupIds: a groupId or a list of groupIds, a groupId
            must be a string.
        """"""
        for groupId in AUX.toList(groupIds):
            self.groups[groupId].addSubsetProteins(proteinIds)
            self._addProteinIdsToGroupMapping(proteinIds, groupId)"
2322,"def addSubsumableToGroups(self, proteinIds, groupIds):
        """"""Add one or multiple subsumable proteins to one or multiple protein
        groups.

        :param proteinIds: a proteinId or a list of proteinIds, a proteinId
            must be a string.
        :param groupIds: a groupId or a list of groupIds, a groupId
            must be a string.
        """"""
        for groupId in AUX.toList(groupIds):
            self.groups[groupId].addSubsumableProteins(proteinIds)
            self._addProteinIdsToGroupMapping(proteinIds, groupId)"
2323,"def _addProteinIdsToGroupMapping(self, proteinIds, groupId):
        """"""Add a groupId to one or multiple entries of the internal
        proteinToGroupId mapping.

        :param proteinIds: a proteinId or a list of proteinIds, a proteinId
            must be a string.
        :param groupId: str, a groupId
        """"""
        for proteinId in AUX.toList(proteinIds):
            self._proteinToGroupIds[proteinId].add(groupId)"
2324,"def _addProteins(self, proteinIds, containerNames):
        """"""Add one or multiple proteinIds to the respective container.

        :param proteinIds: a proteinId or a list of proteinIds, a proteinId
            must be a string.
        :param containerNames: list, entries must be one or multiple of
            'leading', 'subset', 'subsumableProteins' or 'proteins'
        :param addToProteins: bool, if True the proteinIds are added to the
        """"""
        proteinIds = AUX.toList(proteinIds)
        for containerName in containerNames:
            proteinContainer = getattr(self, containerName)
            proteinContainer.update(proteinIds)"
2325,"def satisfies(self, other):
        """"""Check if the capabilities of a primitive are enough to satisfy a requirement.

        Should be called on a Requirement that is acting as a
        capability of a primitive. This method returning true means
        that the capability advertised here is enough to handle
        representing the data described by the Requirement passed in
        as 'other'.

        Here is a chart showing what satisfies what.

             other
              A C 0 1
           |Y N N N N
        s A|Y Y Y Y Y
        e C|Y - Y Y Y
        l 0|Y * * Y N
        f 1|Y * * N Y

        ' ' = No Care
        A = arbitrary
        C = Constant
        0 = ZERO
        1 = ONE

        Y = YES
        N = NO
        - = Could satisfy with multiple instances
        * = Not yet determined behavior. Used for bitbanging controllers.

        """"""
        if other.isnocare:
            return True
        if self.isnocare:
            return False
        if self.arbitrary:
            return True
        if self.constant and not other.arbitrary:
            return True
        if self.value is other.value and not other.arbitrary\
           and not other.constant:
            return True
        return False"
2326,"def _list(self, foldername=""INBOX"", reverse=False, since=None):
        """"""Do structured list output.

        Sorts the list by date, possibly reversed, filtered from 'since'.

        The returned list is: foldername, message key, message object
        """"""
        folder = self.folder \
            if foldername == ""INBOX"" \
            else self._getfolder(foldername)

        def sortcmp(d):
            try:
                return d[1].date
            except:
                return -1

        lst = folder.items() if not since else folder.items_since(since)
        sorted_lst = sorted(lst, key=sortcmp, reverse=1 if reverse else 0)
        itemlist = [(folder, key, msg) for key,msg in sorted_lst]
        return itemlist"
2327,"def ls(self, foldername=""INBOX"", reverse=False, since=None, grep=None, field=None, stream=sys.stdout):
        """"""Do standard text list of the folder to the stream.

        'foldername' is the folder to list.. INBOX by default.

        'since' allows the listing to be date filtered since that
        date. It should be a float, a time since epoch.
        
        'grep' allows text matching on the whole record

        'field' allows only 1 field to be output
        """"""
        if foldername == """":
            foldername = ""INBOX""

        msg_list = self._list(foldername, reverse, since)
        for folder, mk, m in msg_list:
            try:
                # I am very unsure about this defaulting of foldername
                output_items = (
                    ""%s%s%s"" % (folder.folder or foldername or ""INBOX"", SEPERATOR, mk),
                    m.date,
                    m.get_from()[0:50] if m.get_from() else """", 
                    m.get_flags(),
                    re.sub(""\n"", """", m.get_subject() or """")
                    )

                output_string = ""% -20s % 20s % 50s  [%s]  %s"" % output_items
                if not grep or (grep and grep in output_string):
                    if field:
                        print(output_items[int(field)], file=stream)
                    else:
                        print(output_string, file=stream)
            except IOError as e:
                if e.errno == errno.EPIPE:
                    # Broken pipe we can ignore
                    return
                self.logger.exception(""whoops!"")
            except Exception as e:
                self.logger.exception(""whoops!"")"
2328,"def lisp(self, foldername=""INBOX"", reverse=False, since=None, stream=sys.stdout):
        """"""Do JSON list of the folder to the stream.

        'since' allows the listing to be date filtered since that
        date. It should be a float, a time since epoch.
        """"""
        def fromval(hdr):
            if hdr:
                return parseaddr(hdr)

        for folder, mk, m in self._list(foldername, reverse, since):
            try:
                print(json.dumps({
                        'folder': folder.folder or foldername or ""INBOX"",
                        'key': ""%s%s%s"" % (folder.folder or foldername or ""INBOX"", SEPERATOR, mk),
                        'date':  str(m.date),
                        ""flags"": m.get_flags(),
                        'from': fromval(m.get_from()),
                        'subject': re.sub(""\n|\'|\"""", _escape, m.get_subject() or """")
                        }), file=stream)
            except IOError as e:
                if e.errno == errno.EPIPE:
                    # Broken pipe we can ignore
                    return
                self.logger.exception(""whoops!"")
            except Exception as e:
                self.logger.exception(""whoops!"")"
2329,"def lsfolders(self, stream=sys.stdout):
        """"""List the subfolders""""""
        for f in self.folder.folders():
            print(f.folder.strip("".""), file=stream)"
2330,"def _get(self, msgid):
        """"""Yields the message header against each part from the message.""""""
        foldername, msgkey = msgid.split(SEPERATOR)
        folder = self.folder if foldername == ""INBOX"" else self._getfolder(foldername)
        # Now look up the message
        msg = folder[msgkey]
        msg.is_seen = True
        hdr = list(msg.items())
        for p in msg.walk():
            yield hdr,p
        return"
2331,"def gettext(self, msgid, stream=sys.stdout, splitter=""--text follows this line--\n""):
        """"""Get the first text part we can find and print it as a message.

        This is a simple cowpath, most of the time you want the first plain part.

        'msgid' is the message to be used
        'stream' is printed to with the header, splitter, first-textpart
        'splitter' is text used to split the header from the body, Emacs uses this
        """"""
        for hdr,part in self._get(msgid):
            if part.get_content_type() == ""text/plain"":
                for name,val in hdr:
                    # Use the subtype, since we're printing just that - tidy it up first
                    if name.lower() == ""content-type"":
                        val = part[""content-type""]
                    val = "" "".join([l.strip() for l in val.split(""\n"")])
                    print(""%s: %s"" % (name,val), file=stream)
                print(splitter, file=stream)
                payload = part.get_payload(decode=True)
                # There seems to be a problem with the parser not doing charsets for parts
                chartype = part.get_charset() \
                    or _get_charset(part.get(""Content-Type"", """")) \
                    or ""us-ascii""
                print(payload.decode(chartype), file=stream)
                break"
2332,"def getrawpart(self, msgid, stream=sys.stdout):
        """"""Get the first part from the message and print it raw.
        """"""
        for hdr, part in self._get(msgid):
            pl = part.get_payload(decode=True)
            if pl != None:
                print(pl, file=stream)
                break"
2333,"def getrawpartid(self, msgid, partid, stream=sys.stdout):
        """"""Get a specific part from the message and print it raw.
        """"""
        parts = [part for hdr,part in self._get(msgid)]
        part = parts[int(partid)]
        pl = part.get_payload(decode=True)
        if pl != None:
            print(pl, file=stream)"
2334,"def getraw(self, msgid, stream=sys.stdout):
        """"""Get the whole message and print it.
        """"""
        foldername, msgkey = msgid.split(SEPERATOR)
        folder = self.folder if foldername == ""INBOX"" else self._getfolder(foldername)
        msg = folder[msgkey]
        print(msg.content)"
2335,"def getstruct(self, msgid, as_json=False, stream=sys.stdout):
        """"""Get and print the whole message.

        as_json indicates whether to print the part list as JSON or not.
        """"""
        parts = [part.get_content_type() for hdr, part in self._get(msgid)]
        if as_json:
            print(json.dumps(parts), file=stream)
        else:
            for c in parts:
                print(c, file=stream)"
2336,"def _extract_alphabet(self, grammar):
        """"""
        Extract an alphabet from the given grammar.
        """"""
        alphabet = set([])
        for terminal in grammar.Terminals:
            alphabet |= set([x for x in terminal])
        self.alphabet = list(alphabet)"
2337,"def _mpda(self, re_grammar, splitstring=0):
        """"""
        Args:
            re_grammar (list): A list of grammar rules
            splitstring (bool): A boolean for enabling or disabling
                            the splitting of symbols using a space
        Returns:
            PDA: The generated PDA
        """"""
        cnfgrammar = CNFGenerator(re_grammar)

        if not self.alphabet:
            self._extract_alphabet(cnfgrammar)

        cnftopda = CnfPda(self.alphabet)
        productions = {}
        nonterminals = []
        nonterminals.append(cnfgrammar.init_symbol)
        for key in list(cnfgrammar.grammar_nonterminals):
            if key != cnfgrammar.init_symbol:
                nonterminals.append(key)
        for key in list(cnfgrammar.grammar_nonterminals):
            j = 0
            productions[key] = {}
            # print 'testing '+key
            for pair in cnfgrammar.grammar_rules:
                cnf_form = list(pair)
                if cnf_form[0] == key:
                    productions[key][j] = {}
                    if isinstance(cnf_form[1], type(())):
                        #            print list(p[1])
                        productions[key][j]['b0'] = list(cnf_form[1])[0]
                        productions[key][j]['b1'] = list(cnf_form[1])[1]
                    else:
                        #           print p[1]
                        productions[key][j]['a'] = cnf_form[1]
                    j = j + 1
        return cnftopda.initialize(
            nonterminals, productions, list(
                cnfgrammar.grammar_terminals), splitstring)"
2338,"def yyparse(self, cfgfile, splitstring=0):
        """"""
        Args:
            cfgfile (str): The path for the file containing the CFG rules
            splitstring (bool): A boolean for enabling or disabling
                            the splitting of symbols using a space
        Returns:
            PDA: The generated PDA
        """"""
        re_grammar = self._read_file(cfgfile)
        mma = self._mpda(re_grammar, splitstring)
        return mma"
2339,"def natural(a, b):
    """"""
    Sorts the inputted items by their natural order, trying to extract a \
    number from them to sort by.
    
    :param      a       <str>
                b       <str>
    
    :return     <int> 1 || 0 || -1
    
    :usage      |>>> from projex import sorting
                |>>> a = [ 'test1', 'test2', 'test10', 'test20', 'test09' ]
                |>>> a.sort()
                |>>> print a
                |['test09', 'test1', 'test10', 'test2', 'test20']
                |>>> a.sort( sorting.natural )
                |>>> print a
                |['test1', 'test2', 'test09', 'test10', 'test20']
    """"""
    stra = nstr(a).lower()
    strb = nstr(b).lower()

    # test to see if the two are identical
    if stra == strb:
        return 0

    # look up all the pairs of items
    aresults = EXPR_NATURAL.findall(stra)
    bresults = EXPR_NATURAL.findall(strb)

    # make sure we have the same number of results
    bcount = len(bresults)
    for i in range(len(aresults)):
        # make sure we don't exceed the number of elements in b
        if bcount <= i:
            break

        atext, anum = aresults[i]
        btext, bnum = bresults[i]

        # compare the text components
        if atext != btext:
            return cmp(atext, btext)

        if not anum:
            anum = 0
        if not bnum:
            bnum = 0

        # compare the numeric components
        anum = int(anum)
        bnum = int(bnum)
        if anum != bnum:
            return cmp(anum, bnum)

    # b has less characters than a, so should sort before
    return 1"
2340,"def versional(a, b):
    """"""
    Sorts the inputted items by their natural order, trying to extract a \
    number from them to sort by.
    
    :param      a       <str>
                b       <str>
    
    :return     <int> 1 || 0 || -1
    
    :usage      |>>> from projex import sorting
                |>>> a = [ 'test-1.1.2', 'test-1.02', 'test-1.2', 'test-1.18' ]
                |>>> a.sort()
                |>>> print a
                |['test-1.02', 'test-1.1.2', 'test-1.18', 'test-1.2']
                |>>> a.sort( sorting.natural )
                |>>> print a
                |['test-1.1.2', 'test-1.02', 'test-1.2', 'test-1.18']
                |>>> a.sort( sorting.versional )
                |>>> print a
                |['test-1.1.2', 'test-1.02', 'test-1.18', 'test-1.2']
    """"""
    stra = nstr(a).lower()
    strb = nstr(b).lower()

    # look up all the pairs of items
    aresults = EXPR_VERSIONAL.findall(stra)
    bresults = EXPR_VERSIONAL.findall(strb)

    # make sure we have the same number of results
    bcount = len(bresults)
    for i in range(len(aresults)):
        # make sure we don't exceed the number of elements in b
        if bcount <= i:
            break

        atext, anum = aresults[i]
        btext, bnum = bresults[i]

        # compare the text components
        if atext != btext:
            return cmp(atext, btext)

        if not anum:
            anum = 0
        if not bnum:
            bnum = 0

        # compare the numeric components
        if atext == '.':
            anum = int(float('.' + anum) * 10000)
            bnum = int(float('.' + bnum) * 10000)
        else:
            anum = int(anum)
            bnum = int(bnum)

        if anum != bnum:
            return cmp(anum, bnum)

    # b has less characters than a, so should sort before
    return 1"
2341,"def action(self, column=None, value=None, **kwargs):
        """"""
        The underlying GICS table provides codes and descriptions
        identifying the current status or disposition of a grant project.

        >>> GICS().action('action_code', 'A')
        """"""
        return self._resolve_call('GIC_ACTION', column, value, **kwargs)"
2342,"def applicant(self, column=None, value=None, **kwargs):
        """"""
        Find the applicant information for a grant.

        >>> GICS().applicant('zip_code', 94105)
        """"""
        return self._resolve_call('GIC_APPLICANT', column, value, **kwargs)"
2343,"def assistance(self, column=None, value=None, **kwargs):
        """"""
        Provides the Catalog of Federal Domestic Assistance (CFDA) codes and
        names.
        """"""
        return self._resolve_call('GIC_ASST_PGM', column, value, **kwargs)"
2344,"def authority(self, column=None, value=None, **kwargs):
        """"""Provides codes and associated authorizing statutes.""""""
        return self._resolve_call('GIC_AUTHORITY', column, value, **kwargs)"
2345,"def construction(self, column=None, value=None, **kwargs):
        """"""
        Identifies monetary, descriptive, and milestone information for
        Wastewater Treatment construction grants.

        >>> GICS().construction('complete_percent', 91)
        """"""
        return self._resolve_call('GIC_CONSTRUCTION', column, value, **kwargs)"
2346,"def eligible_cost(self, column=None, value=None, **kwargs):
        """"""
        The assistance dollar amounts by eligible cost category.

        >>> GICS().eligible_cost('amount', 100000)
        """"""
        return self._resolve_call('GIC_ELIGIBLE_COST', column, value, **kwargs)"
2347,"def grant(self, column=None, value=None, **kwargs):
        """"""
        Provides various award, project, and grant personnel information.

        >>> GICS().grant('project_city_name', 'San Francisco')
        """"""
        return self._resolve_call('GIC_GRANT', column, value, **kwargs)"
2348,"def grant_assistance(self, column=None, value=None, **kwargs):
        """"""Many-to-many table connecting grants and assistance.""""""
        return self._resolve_call('GIC_GRANT_ASST_PGM', column, value, **kwargs)"
2349,"def grant_authority(self, column=None, value=None, **kwargs):
        """"""Many-to-many table connecting grants and authority.""""""
        return self._resolve_call('GIC_GRANT_AUTH', column, value, **kwargs)"
2350,"def lab_office(self, column=None, value=None, **kwargs):
        """"""Abbreviations, names, and locations of labratories and offices.""""""
        return self._resolve_call('GIC_LAB_OFFICE', column, value, **kwargs)"
2351,"def milestone(self, column=None, value=None, **kwargs):
        """"""
        Status codes and related dates of certain grants,

        >>> GICS().milestone('milestone_date', '16-MAR-01')
        """"""
        return self._resolve_call('GIC_MILESTONE', column, value, **kwargs)"
2352,"def record_type(self, column=None, value=None, **kwargs):
        """"""
        Codes and descriptions indicating whether an award is for a new
        project or for the continuation of a currently funded one.

        >>> GICS().record_type('record_type_code', 'A')
        """"""
        return self._resolve_call('GIC_RECORD_TYPE', column, value, **kwargs)"
2353,"def srf_cap(self, column=None, value=None, **kwargs):
        """"""
        Fiscal dollar amounts for State Revolving Fund Capitalization
        Grants.

        >>> GICS().srf_cap('grant_number', '340001900')
        """"""
        return self._resolve_call('GIC_SRF_CAP', column, value, **kwargs)"
2354,"def status(self, column=None, value=None, **kwargs):
        """"""
        Provides codes and descriptions of project milestones.

        >>> GICS().status('status_code', 'AF')
        """"""
        return self._resolve_call('GIC_STATUS', column, value, **kwargs)"
2355,"def recClearTag(element):
    """"""Applies maspy.xml.clearTag() to the tag attribute of the ""element"" and
    recursively to all child elements.

    :param element: an :instance:`xml.etree.Element`
    """"""
    children = element.getchildren()
    if len(children) > 0:
        for child in children:
            recClearTag(child)
    element.tag = clearTag(element.tag)"
2356,"def recRemoveTreeFormating(element):
    """"""Removes whitespace characters, which are leftovers from previous xml
    formatting.

    :param element: an instance of lxml.etree._Element

    str.strip() is applied to the ""text"" and the ""tail"" attribute of the
    element and recursively to all child elements.
    """"""
    children = element.getchildren()
    if len(children) > 0:
        for child in children:
            recRemoveTreeFormating(child)
    if element.text is not None:
        if len(element.text.strip()) == 0:
            element.text = None
        else:
            element.text = element.text.strip()
    if element.tail is not None:
        if len(element.tail.strip()) == 0:
            element.tail = None
        else:
            element.tail = element.tail.strip()"
2357,"def recCopyElement(oldelement):
    """"""Generates a copy of an xml element and recursively of all
    child elements.

    :param oldelement: an instance of lxml.etree._Element

    :returns: a copy of the ""oldelement""

    .. warning::
        doesn't copy ``.text`` or ``.tail`` of xml elements
    """"""
    newelement = ETREE.Element(oldelement.tag, oldelement.attrib)
    if len(oldelement.getchildren()) > 0:
        for childelement in oldelement.getchildren():
            newelement.append(recCopyElement(childelement))
    return newelement"
2358,"def cvParamFromDict(attributes):
    """"""Python representation of a mzML cvParam = tuple(accession, value,
    unitAccession).

    :param attributes: #TODO: docstring

    :returns: #TODO: docstring
    """"""
    keys = ['accession', 'value', 'unitAccession']
    return tuple(attributes[key] if key in attributes else None for key in keys)"
2359,"def userParamFromDict(attributes):
    """"""Python representation of a mzML userParam = tuple(name, value,
    unitAccession, type)

    :param attributes: #TODO: docstring

    :returns: #TODO: docstring
    """"""
    keys = ['name', 'value', 'unitAccession', 'type']
    return tuple(attributes[key] if key in attributes else None for key in keys)"
2360,"def getParam(xmlelement):
    """"""Converts an mzML xml element to a param tuple.

    :param xmlelement: #TODO docstring

    :returns: a param tuple or False if the xmlelement is not a parameter
        ('userParam', 'cvParam' or 'referenceableParamGroupRef')
    """"""
    elementTag = clearTag(xmlelement.tag)
    if elementTag in ['userParam', 'cvParam', 'referenceableParamGroupRef']:
        if elementTag == 'cvParam':
            param = cvParamFromDict(xmlelement.attrib)
        elif elementTag == 'userParam':
            param = userParamFromDict(xmlelement.attrib)
        else:
            param = refParamGroupFromDict(xmlelement.attrib)
    else:
        param = False
    return param"
2361,"def extractParams(xmlelement):
    """""" #TODO docstring

    :param xmlelement: #TODO docstring

    :returns: #TODO docstring
    """"""
    params = list()
    children = list()
    for child in xmlelement.getchildren():
        param = getParam(child)
        if param:
            params.append(param)
        else:
            children.append(child)
    return params, children"
2362,"def xmlAddParams(parentelement, params):
    """"""Generates new mzML parameter xml elements and adds them to the
    'parentelement' as xml children elements.

    :param parentelement: :class:`xml.etree.Element`, an mzML element
    :param params: a list of mzML parameter tuples ('cvParam', 'userParam' or
        'referencableParamGroup')
    """"""
    if not params:
        return None
    for param in params:
        if len(param) == 3:
            cvAttrib = {'cvRef': param[0].split(':')[0], 'accession': param[0],
                        'name':oboTranslator.getNameWithId(param[0])
                        }
            if param[1]:
                cvAttrib.update({'value': param[1]})
            else:
                cvAttrib.update({'value': ''})
            if param[2]:
                unitName = oboTranslator.getNameWithId(param[2])
                cvAttrib.update({'unitAccession': param[2],
                                 'unitCvRef': param[2].split(':')[0],
                                 'unitName': unitName
                                 })
            paramElement = ETREE.Element('cvParam', **cvAttrib)
        elif len(param) == 4:
            userAttrib = {'name': param[0]}
            if param[1]:
                userAttrib.update({'value': param[1]})
            else:
                userAttrib.update({'value': ''})
            if param[2]:
                userAttrib.update({'unitAccession': param[2],
                                   'unitCvRef': param[2].split(':')[0]
                                   })
            if param[3]:
                userAttrib.update({'type': param[3]})
            paramElement = ETREE.Element('userParam', **userAttrib)
        elif param[0] == 'ref':
            refAttrib = {'ref': param[1]}
            paramElement = ETREE.Element('referenceableParamGroupRef',
                                         **refAttrib
                                         )
        parentelement.append(paramElement)"
2363,"def interpretBitEncoding(bitEncoding):
    """"""Returns a floattype string and a numpy array type.

    :param bitEncoding: Must be either '64' or '32'

    :returns: (floattype, numpyType)
    """"""
    if bitEncoding == '64':
        floattype = 'd' # 64-bit
        numpyType = numpy.float64
    elif bitEncoding == '32':
        floattype = 'f' # 32-bit
        numpyType = numpy.float32
    else:
        errorText = ''.join(['bitEncoding \'', bitEncoding, '\' not defined. ',
                             'Must be \'64\' or \'32\''
                             ])
        raise TypeError(errorText)
    return (floattype, numpyType)"
2364,"def decodeBinaryData(binaryData, arrayLength, bitEncoding, compression):
    """"""Function to decode a mzML byte array into a numpy array. This is the
    inverse function of :func:`encodeBinaryData`. Concept inherited from
    :func:`pymzml.spec.Spectrum._decode` of the python library `pymzML
    <https://pymzml.github.io/>`_.

    :param binaryData: #TODO: docstring
    :param arrayLength: #TODO: docstring
    :param binEncoding: #TODO: docstring
    :param compression: #TODO: docstring

    :returns: #TODO: docstring
    """"""
    #TODO: should raise an error if a wrong compression is specified
    bitEncodedData = binaryData.encode(""utf-8"")
    bitDecodedData = B64DEC(bitEncodedData)
    floattype, numpyType = interpretBitEncoding(bitEncoding)

    if compression == 'zlib':
        decompressedData = zlib.decompress(bitDecodedData)
    else:
        decompressedData = bitDecodedData

    fmt = '{endian}{arraylength}{floattype}'.format(endian='<',
                                                    arraylength=arrayLength,
                                                    floattype=floattype
                                                    )
    dataArray = numpy.array(UNPACK(fmt, decompressedData), dtype=numpyType)
    return dataArray"
2365,"def encodeBinaryData(dataArray, bitEncoding, compression):
    """"""Function to encode a ``numpy.array`` into a mzML byte array. This is the
    inverse function of :func:`decodeBinaryData`.

    :param dataArray: #TODO: docstring
    :param bitEncoding: #TODO: docstring
    :param compression: #TODO: docstring

    :returns: #TODO: docstring
    """"""
    #TODO: should raise an error if a wrong compression is specified
    arrayLength = len(dataArray)
    floattype, __ = interpretBitEncoding(bitEncoding)
    fmt = '{endian}{arraylength}{floattype}'.format(endian='<',
                                                    arraylength=arrayLength,
                                                    floattype=floattype
                                                    )
    packedData = PACK(fmt, *dataArray)

    if compression == 'zlib':
        compressedData = zlib.compress(packedData)
    else:
        compressedData = packedData

    encodedData = B64ENC(compressedData)
    return encodedData, arrayLength"
2366,"def findBinaryDataType(params):
    """""" #TODO: docstring
    from: http://www.peptideatlas.org/tmp/mzML1.1.0.html#binaryDataArray
    a binaryDataArray ""MUST supply a *child* term of MS:1000518
    (binary data type) only once""

    :param params: #TODO: docstring

    :returns: #TODO: docstring
    """"""
    binaryDataType = None
    cvParam = None
    for param in params:
        if param[0] in binaryDataArrayTypes:
            binaryDataType = binaryDataArrayTypes[param[0]]
            cvParam = param
            break
    return binaryDataType, cvParam"
2367,"def extractBinaries(binaryDataArrayList, arrayLength):
    """""" #TODO: docstring

    :param binaryDataArrayList: #TODO: docstring
    :param arrayLength: #TODO: docstring

    :returns: #TODO: docstring
    """"""
    extractedArrays = dict()
    arrayInfo = dict()
    for binaryData in binaryDataArrayList:
        if findParam(binaryData['params'], 'MS:1000523') is not None:
            bitEncoding = '64'
        else:
            bitEncoding = '32'
        if findParam(binaryData['params'], 'MS:1000574') is not None:
            compression = 'zlib'
        else:
            compression = None
        dataType, dataTypeParam = findBinaryDataType(binaryData['params'])
        if binaryData['binary']:
            extractedArrays[dataType] = decodeBinaryData(binaryData['binary'],
                                                         arrayLength,
                                                         bitEncoding,
                                                         compression
                                                         )
        else:
            __, numpyType = interpretBitEncoding(bitEncoding)
            extractedArrays[dataType] = numpy.array([], dtype=numpyType)

        binaryData['binary'] = None
        arrayInfo[dataType] = {'dataProcessingRef': None,
                               'params': binaryData['params']
                               }
        if 'dataProcessingRef' in binaryData:
            arrayInfo[dataType]['dataProcessingRef'] = \
                binaryData['dataProcessingRef']
    return extractedArrays, arrayInfo"
2368,"def sublistReader(xmlelement):
    """""" #TODO: docstring """"""
    #Note: actually I'm not 100% sure how this function behaves
    elements = list()
    params, children = extractParams(xmlelement)
    for child in children:
        currElement = dict()
        currElement.update(child.attrib)
        childparams, subchildren = extractParams(child)
        if childparams:
            currElement['params'] = childparams
        for subchild in subchildren:
            subchildTag = clearTag(subchild.tag)
            if 'List' in subchildTag:
                listelements, listparams = sublistReader(subchild)
                simplelist = [listelement['params'] for listelement in listelements]
                currElement[subchildTag] = simplelist
            else:
                subchildparams, _ = extractParams(subchild)
                currElement[subchildTag] = subchildparams
                if subchildTag == 'binary' and subchild.text:
                    currElement[subchildTag] = subchild.text.strip()
        elements.append(currElement)
    return elements, params"
2369,"def next(self):
        """""" #TODO: docstring

        :returns: #TODO: docstring
        """"""
        try:
            self.event, self.element = next(self.iterator)
            self.elementTag = clearTag(self.element.tag)
        except StopIteration:
            clearParsedElements(self.element)
            raise StopIteration
        return self.event, self.element, self.elementTag"
2370,"def loadMetadata(self):
        """""" #TODO: docstring """"""
        #TODO: change that spectra dont have to be iterated to extract metadata
        #node
        if self._parsed:
            raise TypeError('Mzml file already parsed.')
        [None for _ in self._parseMzml()]
        self._parsed = True"
2371,"def parseSpectra(self):
        """""" #TODO: docstring

        :returns: #TODO: docstring
        """"""
        #Note: the spectra need to be iterated completely to save the
        #metadataNode
        if self._parsed:
            raise TypeError('Mzml file already parsed.')
        self._parsed = True
        return self._parseMzml()"
2372,"def _parseMzml(self):
        """""" #TODO: docstring """"""
        #TODO: this is already pretty nested, reduce that eg by using a function
        #   processRunNode
        for event, element, elementTag in self:
            if elementTag == 'mzML':
                metadataNode = ETREE.Element(self.elementTag,
                                             self.element.attrib
                                             )
                _, _, targetTag = next(self)
                break

        while targetTag != 'mzML':
            if targetTag == 'run':
                runNode = ETREE.Element('run', self.element.attrib)
                next(self)
                while self.event != 'end' or self.elementTag != 'run':
                    if self.elementTag == 'spectrumList':
                        #Add spectrumListNode
                        specListAttrib = {'defaultDataProcessingRef':
                                          self.element.attrib['defaultDataProcessingRef']
                                          }
                        specListNode = ETREE.Element('spectrumList', specListAttrib)
                        runNode.append(specListNode)
                        #Parse and yield spectrum xml elements
                        while self.event != 'end' or self.elementTag != 'spectrumList':
                            if self.event == 'end' and self.elementTag == 'spectrum':
                                yield self.element
                                clearParsedElements(self.element)
                            next(self)
                    elif self.elementTag == 'chromatogramList':
                        #Add chromatogramListNode
                        chromListAttrib = {'defaultDataProcessingRef':
                                           self.element.attrib['defaultDataProcessingRef']
                                           }
                        chromListNode = ETREE.Element('chromatogramList',
                                                      chromListAttrib
                                                      )
                        runNode.append(chromListNode)
                        #Parse and store chromatogram xml elements
                        while self.event != 'end' or self.elementTag != 'chromatogramList':
                            if self.event == 'end' and self.elementTag == 'chromatogram':
                                self.chromatogramList.append(self.element)
                                #Alternatively also the chromatogram xml
                                #elements could be yielded:
                                #   yield self.element
                                #   clearParsedElements(self.element)
                            next(self)
                    else:
                        runNode.append(self.element)
                    next(self)
                metadataNode.append(runNode)
                break
            else:
                while self.event != 'end' or self.elementTag != targetTag:
                    next(self)
                metadataNode.append(self.element)
            _, _, targetTag = next(self)
        recClearTag(metadataNode)
        recRemoveTreeFormating(metadataNode)
        self.metadataNode = recCopyElement(metadataNode)
        self.openfile.close()"
2373,"def calc_partition_function(mass, omega_array, temperature_array):
    """"""
    Calculates the partition function of your system at each point in time.

    Parameters
    ----------
    mass : float
        The mass of the particle in kg
    omega_array : array
        array which represents omega at every point in your time trace
        and should therefore have the same length as the Hamiltonian
    temperature_array : array
        array which represents the temperature at every point in your time trace
        and should therefore have the same length as the Hamiltonian

    Returns:
    -------
    Partition function : array
        The Partition Function at every point in time over a given trap-frequency and temperature change.
    """"""
    Kappa_t= mass*omega_array**2    
    return _np.sqrt(4*_np.pi**2*_scipy.constants.Boltzmann**2*temperature_array**2/(mass*Kappa_t))"
2374,"def calc_entropy(phase_space_density_array):
    """"""
    Calculates the entropy of your system at each point in time 
    for your given phase space density evolution in time.
    
    Parameters
    ----------
    phase_space_density_array : array
        array which represents the phase space density at every point in time

    Returns:
    -------
    entropy : array
        The entropy of the particle at every point in time via the phase space density method.
    
    """"""
    entropy = -_scipy.constants.Boltzmann*_np.log(phase_space_density_array)
    return entropy"
2375,"def calc_hamiltonian(self, mass, omega_array):
        """"""
        Calculates the standard (pot+kin) Hamiltonian of your system.
        
        Parameters
        ----------
        mass : float
            The mass of the particle in kg
        omega_array : array
            array which represents omega at every point in your time trace
            and should therefore have the same length as self.position_data
        
        Requirements
        ------------
        self.position_data : array
            Already filtered for the degree of freedom of intrest and converted into meters. 

        Returns
        -------
        Hamiltonian : array
            The calculated Hamiltonian
        """"""
        Kappa_t= mass*omega_array**2
        self.E_pot = 0.5*Kappa_t*self.position_data**2
        self.E_kin = 0.5*mass*(_np.insert(_np.diff(self.position_data), 0, (self.position_data[1]-self.position_data[0]))*self.SampleFreq)**2
        self.Hamiltonian = self.E_pot + self.E_kin
        return self.Hamiltonian"
2376,"def calc_phase_space_density(self, mass, omega_array, temperature_array):
        """"""
        Calculates the partition function of your system at each point in time.
    
        Parameters
        ----------
        mass : float
            The mass of the particle in kg
        omega_array : array
            array which represents omega at every point in your time trace
            and should therefore have the same length as the Hamiltonian
        temperature_array : array
            array which represents the temperature at every point in your time trace
            and should therefore have the same length as the Hamiltonian
        
        Requirements
        ------------
        self.position_data : array
            Already filtered for the degree of freedom of intrest and converted into meters. 

        Returns:
        -------
        Phasespace-density : array
            The Partition Function at every point in time over a given trap-frequency and temperature change.
        """"""

        return self.calc_hamiltonian(mass, omega_array)/calc_partition_function(mass, omega_array,temperature_array)"
2377,"def extract_thermodynamic_quantities(self,temperature_array):
        """"""
        Calculates the thermodynamic quantities of your system at each point in time.
        Calculated Quantities: self.Q (heat),self.W (work), self.Delta_E_kin, self.Delta_E_pot
        self.Delta_E (change of Hamiltonian),
    
        Parameters
        ----------
        temperature_array : array
            array which represents the temperature at every point in your time trace
            and should therefore have the same length as the Hamiltonian
        
        Requirements
        ------------
        execute calc_hamiltonian on the DataObject first

        Returns:
        -------
        Q : array
            The heat exchanged by the particle at every point in time over a given trap-frequency and temperature change.
        W : array
            The work ""done""  by the particle at every point in time over a given trap-frequency and temperature change.
        """"""
        beta = 1/(_scipy.constants.Boltzmann*temperature_array)
        self.Q = self.Hamiltonian*(_np.insert(_np.diff(beta),0,beta[1]-beta[0])*self.SampleFreq)
        self.W = self.Hamiltonian-self.Q
        self.Delta_E_kin = _np.diff(self.E_kin)*self.SampleFreq
        self.Delta_E_pot = _np.diff(self.E_pot)*self.SampleFreq
        self.Delta_E = _np.diff(self.Hamiltonian)*self.SampleFreq
        
        return self.Q, self.W"
2378,"def calc_mean_and_variance_of_variances(self, NumberOfOscillations):
        """"""
        Calculates the mean and variance of a set of varainces. 
        This set is obtained by splitting the timetrace into chunks 
        of points with a length of NumberOfOscillations oscillations.  

        Parameters
        ----------
        NumberOfOscillations : int
            The number of oscillations each chunk of the timetrace 
            used to calculate the variance should contain.

        Returns
        -------
        Mean : float
        Variance : float
        """"""
        SplittedArraySize = int(self.SampleFreq/self.FTrap.n) * NumberOfOscillations
        VoltageArraySize = len(self.voltage)
        SnippetsVariances = _np.var(self.voltage[:VoltageArraySize-_np.mod(VoltageArraySize,SplittedArraySize)].reshape(-1,SplittedArraySize),axis=1)

        return _np.mean(SnippetsVariances), _np.var(SnippetsVariances)"
2379,"def register_template_directory(kb_app: kb,
                                sphinx_app: Sphinx,
                                sphinx_env: BuildEnvironment,
                                docnames=List[str],
                                ):
    """""" Add this resource's templates dir to template paths """"""

    template_bridge = sphinx_app.builder.templates

    actions = ResourceAction.get_callbacks(kb_app)

    for action in actions:
        f = os.path.dirname(inspect.getfile(action))
        template_bridge.loaders.append(SphinxFileSystemLoader(f))"
2380,"def add_directives(kb_app: kb,
                   sphinx_app: Sphinx,
                   sphinx_env: BuildEnvironment,
                   docnames=List[str],
                   ):
    """""" For each resource type, register a new Sphinx directive """"""

    for k, v in list(kb_app.config.resources.items()):
        sphinx_app.add_directive(k, ResourceDirective)"
2381,"def stamp_title(kb_app: kb,
                sphinx_app: Sphinx,
                doctree: doctree):
    """""" Walk the tree and extra RST title into resource.title """"""

    # First, find out which resource this is. Won't be easy.
    resources = sphinx_app.env.resources
    confdir = sphinx_app.confdir
    source = PurePath(doctree.attributes['source'])

    # Get the relative path inside the docs dir, without .rst, then
    # get the resource
    docname = str(source.relative_to(confdir)).split('.rst')[0]
    resource = resources.get(docname)

    if resource:
        # Stamp the title on the resource
        title = get_rst_title(doctree)
        resource.title = title"
2382,"def init_app(self, app, config_prefix=""PYBANKID""):
        """"""Initialize the `app` for use with this :class:`~PyBankID`. This is
        called automatically if `app` is passed to :meth:`~PyBankID.__init__`.

        The app is configured according to the configuration variables
        ``PREFIX_CERT_PATH``, ``PREFIX_KEY_PATH`` and ``PREFIX_TEST_SERVER``,
         where ""PREFIX"" defaults to ""PYBANKID"".

        :param flask.Flask app: the application to configure for use with
           this :class:`~PyBankID`
        :param str config_prefix: determines the set of configuration
           variables used to configure this :class:`~PyBankID`.

        """"""
        if ""pybankid"" not in app.extensions:
            app.extensions[""pybankid""] = {}

        if config_prefix in app.extensions[""pybankid""]:
            raise Exception('duplicate config_prefix ""{0}""'.format(config_prefix))

        app.config.setdefault(self._config_key(""CERT_PATH""), """")
        app.config.setdefault(self._config_key(""KEY_PATH""), """")
        app.config.setdefault(self._config_key(""TEST_SERVER""), False)

        # Adding the three url endpoints.
        app.add_url_rule(
            ""/authenticate/<personal_number>"", view_func=self._authenticate
        )
        app.add_url_rule(""/sign/<personal_number>"", view_func=self._sign)
        app.add_url_rule(""/collect/<order_ref>"", view_func=self._collect)

        if hasattr(app, ""teardown_appcontext""):
            app.teardown_appcontext(self.teardown)
        else:
            app.teardown_request(self.teardown)"
2383,"def client(self):
        """"""The automatically created :py:class:`bankid.client.BankIDClient` object.

        :return: The BankID client.
        :rtype: :py:class:`bankid.jsonclient.BankIDJSONClient`

        """"""
        ctx = stack.top
        attr_name = self._config_key(""client"")
        if ctx is not None:
            if not hasattr(ctx, attr_name):
                setattr(
                    ctx,
                    attr_name,
                    BankIDClient(
                        (
                            current_app.config.get(self._config_key(""CERT_PATH"")),
                            current_app.config.get(self._config_key(""KEY_PATH"")),
                        ),
                        current_app.config.get(self._config_key(""TEST_SERVER"")),
                    ),
                )
            return getattr(ctx, attr_name)"
2384,"def handle_exception(error):
        """"""Simple method for handling exceptions raised by `PyBankID`.

        :param flask_pybankid.FlaskPyBankIDError error: The exception to handle.
        :return: The exception represented as a dictionary.
        :rtype: dict

        """"""
        response = jsonify(error.to_dict())
        response.status_code = error.status_code
        return response"
2385,"def create_from_pybankid_exception(cls, exception):
        """"""Class method for initiating from a `PyBankID` exception.

        :param bankid.exceptions.BankIDError exception:
        :return: The wrapped exception.
        :rtype: :py:class:`~FlaskPyBankIDError`

        """"""
        return cls(
            ""{0}: {1}"".format(exception.__class__.__name__, str(exception)),
            _exception_class_to_status_code.get(exception.__class__),
        )"
2386,"def to_dict(self):
        """"""Create a dict representation of this exception.

        :return: The dictionary representation.
        :rtype: dict

        """"""
        rv = dict(self.payload or ())
        rv[""message""] = self.message
        return rv"
2387,"def integers(num, minimum, maximum, base=10):
    # TODO: Ensure numbers within bounds
    """"""Random integers within specified interval.

    The integer generator generates truly random integers in the specified
    interval.

    Parameters
    ----------
    num : int, bounds=[1, 1E4]
          Total number of integers in returned array.
    minimum : int, bounds=[-1E9, 1E9]
              Minimum value (inclusive) of returned integers.
    maximum : int, bounds=[-1E9, 1E9]
              Maximum value (inclusive) of returned integers.
    base: int, values=[2, 8, 10, 16], default=10
          Base used to print numbers in array, the default is decimal
          representation (base=10).

    Returns
    -------
    integers : array
               A 1D numpy array containing integers between the specified
               bounds.

    Examples
    --------
    Generate an array of 10 integers with values between -100 and 100,
    inclusive:

    >>> integers(10, -100, 100)

    A coin toss, where heads=1 and tails=0, with multiple flips (flips should
    be an odd number):

    >>> sum(integers(5, 0, 1))

    """"""
    function = 'integers'

    num, minimum, maximum = list(map(int, [num, minimum, maximum]))

    # INPUT ERROR CHECKING
    # Check input values are within range
    if (1 <= num <= 10 ** 4) is False:
        print('ERROR: %s is out of range' % num)
        return
    if (-10 ** 9 <= minimum <= 10 ** 9) is False:
        print('ERROR: %s is out of range' % minimum)
        return
    if (-10 ** 9 <= maximum <= 10 ** 9) is False:
        print('ERROR: %s is out of range' % maximum)
        return
    if maximum < minimum:
        print('ERROR: %s is less than %s' % (maximum, minimum))
        return

    base = int(base)
    if base not in [2, 8, 10, 16]:
        raise Exception('Base not in range!')

    opts = {'num': num,
            'min': minimum,
            'max': maximum,
            'col': 1,
            'base': base,
            'format': 'plain',
            'rnd': 'new'}
    integers = get_http(RANDOM_URL, function, opts)
    integers_arr = str_to_arr(integers)
    return integers_arr"
2388,"def sequence(minimum, maximum):
    """"""Randomize a sequence of integers.""""""
    function = 'sequences'
    opts = {'min': minimum,
            'max': maximum,
            'col': 1,
            'format': 'plain',
            'rnd': 'new'}
    deal = get_http(RANDOM_URL, function, opts)
    deal_arr = str_to_arr(deal)
    return deal_arr"
2389,"def string(num, length, digits=False, upper=True, lower=True, unique=False):
    """"""Random strings.""""""
    function = 'strings'
    # Convert arguments to random.org style
    # for a discussion on the method see: http://bit.ly/TKGkOF
    digits = convert(digits)
    upper = convert(upper)
    lower = convert(lower)
    unique = convert(unique)

    opts = {'num': num,
            'len': length,
            'digits': digits,
            'upperalpha': upper,
            'loweralpha': lower,
            'format': 'plain',
            'rnd': 'new'}
    seq = get_http(RANDOM_URL, function, opts)
    seq = seq.strip().split('\n')  # convert to list
    # seq_arr = str_to_arr(seq)
    return seq"
2390,"def quota(ip=None):
    """"""Check your quota.""""""
    # TODO: Add arbitrary user defined IP check
    url = 'http://www.random.org/quota/?format=plain'
    data = urlopen(url)
    credit = int(data.read().strip())
    if data.code == 200:
        return credit
    else:
        return ""ERROR: Server responded with code %s"" % data.code"
2391,"def get_http(base_url, function, opts):
    """"""HTTP request generator.""""""
    url = (os.path.join(base_url, function) + '/?' + urlencode(opts))
    data = urlopen(url)

    if data.code != 200:
        raise ValueError(""Random.rg returned server code: "" + str(data.code))
    return data.read()"
2392,"def read(*p):
    """"""Build a file path from paths and return the contents.""""""
    with open(os.path.join(*p), 'r') as fi:
        return fi.read()"
2393,"def execute(self, processProtocol, command, env={},
                path=None, uid=None, gid=None, usePTY=0, childFDs=None):
        """"""Form a command and start a process in the desired environment.
        """"""
        raise NotImplementedError()"
2394,"def run(self, command, env={}, path=None,
            uid=None, gid=None, usePTY=0, childFDs=None):
        """"""Execute a command and return the results of the completed run.
        """"""
        deferred = defer.Deferred()
        processProtocol = _SummaryProcessProtocol(deferred)
        d = defer.maybeDeferred(self.execute, processProtocol, command, env,
                                path, uid, gid, usePTY, childFDs)
        d.addErrback(deferred.errback)
        return deferred"
2395,"def getOutput(self, command, env={}, path=None,
                  uid=None, gid=None, usePTY=0, childFDs=None):
        """"""Execute a command and get the output of the finished process.
        """"""
        deferred = defer.Deferred()
        processProtocol = _SummaryProcessProtocol(deferred)
        self.execute(processProtocol, command, env,
                     path, uid, gid, usePTY, childFDs)
        @deferred.addCallback
        def getStdOut(tuple_):
            stdout, _stderr, _returnCode = tuple_
            return stdout
        return deferred"
2396,"def getExitCode(self, command, env={}, path=None, uid=None, gid=None,
                    usePTY=0, childFDs=None):
        """"""Execute a command and get the return code of the finished process.
        """"""
        deferred = defer.Deferred()
        processProtocol = _SummaryProcessProtocol(deferred)
        self.execute(processProtocol, command, env, path, uid, gid,
                     usePTY, childFDs)
        @deferred.addCallback
        def getStdOut(tuple_):
            _stdout, _stderr, exitCode = tuple_
            return exitCode
        return deferred"
2397,"def validate_task(original_task):
    """"""
    Validates task and adds default values for missing options using the
    following steps.

    1. If there is no input list specified or if it is None, the input spec is
       assumed to be ['*'].

    2. If there are not outputs specified, or if the output spec is None or an
       empty list, the output spec is assumed to be ['*'].

    3. If the input or output spec is not iterable, they are converted into
       single element tuples. If they are any iterable, they are converted into
       tuples.

    4. The task['fn'] option must be callable.

    5. If number of outputs is more than one, task['fn'] must be a generator
       function.

    6. Generator functions are not supported for output spec of '*'.

    Returns new task with updated options
    """"""
    task = original_task._asdict()

    # Default values for inputs and outputs
    if 'inputs' not in task or task['inputs'] is None:
        task['inputs'] = ['*']

    # Outputs list cannot be empty
    if ('outputs' not in task or
        task['outputs'] is None or
            len(task['outputs']) == 0):
        task['outputs'] = ['*']

    # Convert to tuples (even for single values)
    if not hasattr(task['inputs'], '__iter__') or isinstance(task['inputs'], str):
        task['inputs'] = (task['inputs'],)
    else:
        task['inputs'] = tuple(task['inputs'])

    if not hasattr(task['outputs'], '__iter__') or isinstance(task['outputs'], str):
        task['outputs'] = (task['outputs'],)
    else:
        task['outputs'] = tuple(task['outputs'])

    if not callable(task['fn']):
        raise TypeError('Task function must be a callable object')

    if (len(task['outputs']) > 1 and
            not inspect.isgeneratorfunction(task['fn'])):
        raise TypeError('Multiple outputs are only supported with \
                        generator functions')

    if inspect.isgeneratorfunction(task['fn']):
        if task['outputs'][0] == '*':
            raise TypeError('Generator functions cannot be used for tasks with \
                             output specification ""*""')
    return Task(**task)"
2398,"def run_task(task, workspace):
    """"""
    Runs the task and updates the workspace with results.

    Parameters
    ----------
    task - dict
        Task Description

    Examples:
    {'task': task_func, 'inputs': ['a', 'b'], 'outputs': 'c'}
    {'task': task_func, 'inputs': '*', 'outputs': '*'}
    {'task': task_func, 'inputs': ['*','a'], 'outputs': 'b'}

    Returns a new workspace with results
    """"""
    data = copy.copy(workspace)

    task = validate_task(task)

    # Prepare input to task
    inputs = [input_parser(key, data) for key in task.inputs]

    if inspect.isgeneratorfunction(task.fn):
        # Multiple output task
        # Assuming number of outputs are equal to number of return values
        data.update(zip(task.outputs, task.fn(*inputs)))
    else:
        # Single output task
        results = task.fn(*inputs)
        if task.outputs[0] != '*':
            results = {task.outputs[0]: results}
        elif not isinstance(results, dict):
            raise TypeError('Result should be a dict for output type *')
        data.update(results)

    return data"
2399,"def run_hook(name, workspace, hooks):
    """"""Runs all hooks added under the give name.

    Parameters
    ----------
    name - str
        Name of the hook to invoke

    workspace - dict
        Workspace that the hook functions operate on

    hooks - dict of lists
        Mapping with hook names and callback functions
    """"""

    data = copy.copy(workspace)
    for hook_listener in hooks.get(name, []):
        # Hook functions may mutate the data and returns nothing
        hook_listener(data)
    return data"
2400,"def add_task(self, fn, inputs=None, outputs=None):
        """"""
        Adds a task to the workflow.

        Returns self to facilitate chaining method calls
        """"""
        # self.tasks.append({'task': task, 'inputs': inputs, 'outputs': outputs})
        self.tasks.append(Task(fn, inputs, outputs))
        return self"
2401,"def add_hook(self, name, function):
        """"""
        Adds a function to be called for hook of a given name.

        The function gets entire workspace as input and
        does not return anything.

        Example:
        def hook_fcn(workspace):
            pass
        """"""
        if not callable(function):
            return ValueError('Hook function should be callable')
        if name not in self.hooks:
            self.hooks[name] = []
        self.hooks[name].append(function)
        return self"
2402,"def dns(self):
        """"""DNS details.""""""
        dns = {
            'elb': self.dns_elb(),
            'elb_region': self.dns_elb_region(),
            'global': self.dns_global(),
            'region': self.dns_region(),
            'instance': self.dns_instance(),
        }

        return dns"
2403,"def s3_app_bucket(self, include_region=False):
        """"""Generate s3 application bucket name.

        Args:
            include_region (bool): Include region in the name generation.
        """"""
        if include_region:
            s3_app_bucket = self.format['s3_app_region_bucket'].format(**self.data)
        else:
            s3_app_bucket = self.format['s3_app_bucket'].format(**self.data)
        return s3_app_bucket"
2404,"def shared_s3_app_bucket(self, include_region=False):
        """"""Generate shared s3 application bucket name.

        Args:
            include_region (bool): Include region in the name generation.
        """"""
        if include_region:
            shared_s3_app_bucket = self.format['shared_s3_app_region_bucket'].format(**self.data)
        else:
            shared_s3_app_bucket = self.format['shared_s3_app_bucket'].format(**self.data)
        return shared_s3_app_bucket"
2405,"def iam(self):
        """"""Generate iam details.""""""
        iam = {
            'group': self.format['iam_group'].format(**self.data),
            'lambda_role': self.format['iam_lambda_role'].format(**self.data),
            'policy': self.format['iam_policy'].format(**self.data),
            'profile': self.format['iam_profile'].format(**self.data),
            'role': self.format['iam_role'].format(**self.data),
            'user': self.format['iam_user'].format(**self.data),
            'base': self.format['iam_base'].format(**self.data),
        }

        return iam"
2406,"def archaius(self):
        """"""Generate archaius bucket path.""""""
        bucket = self.format['s3_bucket'].format(**self.data)
        path = self.format['s3_bucket_path'].format(**self.data)
        archaius_name = self.format['s3_archaius_name'].format(**self.data)
        archaius = {'s3': archaius_name, 'bucket': bucket, 'path': path}

        return archaius"
2407,"def jenkins(self):
        """"""Generate jenkins job details.""""""
        job_name = self.format['jenkins_job_name'].format(**self.data)
        job = {'name': job_name}

        return job"
2408,"def gitlab(self):
        """"""Generate gitlab details.""""""
        main_name = self.format['git_repo'].format(**self.data)
        qe_name = self.format['git_repo_qe'].format(**self.data)
        config_name = self.format['git_repo_configs'].format(**self.data)

        git = {
            'config': config_name,
            'main': main_name,
            'qe': qe_name,
        }

        return git"
2409,"def render(plain,
           urlHandler=None,
           templatePaths=None,
           options=None,
           defaultTag='div',
           wikiStyle='basic'):
    """"""
    Renders the inputted plain text wiki information into HTML rich text.
    
    :param      plain       |  <str> | \
                               Include some additional documentation
                urlHandler  |  <UlrHandler> || None
    
    :return     <str> html
    """"""
    if not plain:
        return ''

    __style = WIKI_STYLES.styles.get(wikiStyle, WIKI_STYLES.styles['basic'])

    # process the wiki text with the mako template system
    if not urlHandler:
        urlHandler = UrlHandler.current()

    # render the text out from mako template
    plain = projex.makotext.render(plain,
                                   options=options,
                                   templatePaths=templatePaths,
                                   silent=True)

    # generate wiki doc info
    lines = re.split('\n\r|\r\n|\n|\r', plain)
    curr_section = ''
    curr_section_level = 0
    html = []
    skip = []
    nowiki_stack = []
    nowiki_mode = 'pre'
    code_stack = []
    table_stack = []
    list_stack = []
    section_stack = []
    toc_data = []
    align_div = ''
    list_indent = None
    ignore_list_stack = False

    # add the default tag
    html.append(__style['wiki_open'].format(tag=defaultTag))

    for i, line in enumerate(lines):
        ignore_list_stack = False
        sline = line.strip()

        #----------------------------------------------------------------------
        #                           INDENTATION CHECKS
        #----------------------------------------------------------------------

        # check to see if we are continuing a list entry
        if list_indent:
            line_indent = len(re.match('\s*', line).group())

            if line_indent < list_indent:
                list_indent = None
                html.append(__style['list_item_close'])
            else:
                ignore_list_stack = True

                if not sline:
                    html.append(__style['spacer'])
                    continue

        if i in skip:
            continue

        #----------------------------------------------------------------------
        #                           ALIGNMENT
        #----------------------------------------------------------------------

        # check for a center option
        center = EXPR_CENTER.match(sline)
        right = EXPR_RIGHT.match(sline)
        left = EXPR_LEFT.match(sline)

        if center:
            style = center.groups()[0]
            line = center.groups()[1].strip()

            if align_div and align_div != 'center':
                html.append(__style['align_close'])
                align_div = ''

            if not align_div:
                if style == '--':
                    html.append(__style['align_center'])
                else:
                    html.append(__style['align_center_floated'])
                align_div = 'center'

            else:
                html.append(__style['newline'])

        # check for a right align option
        elif right:
            style = right.groups()[0]
            line = right.groups()[1]

            if align_div and align_div != 'right':
                html.append(__style['align_close'])
                align_div = ''

            if not align_div:
                if style == '--':
                    html.append(__style['align_right'])
                else:
                    html.append(__style['align_right_floated'])
                align_div = 'right'
            else:
                html.append(__style['newline'])

        # check for a left align option
        elif left:
            style = left.groups()[1]
            line = left.groups()[0]

            if align_div and align_div != 'left':
                html.append(__style['align_close'])
                align_div = ''

            if not align_div:
                if style == '--':
                    html.append(__style['align_left'])
                else:
                    html.append(__style['align_left_floated'])

                align_div = 'left'
            else:
                html.append(__style['newline'])

        # otherwise, clear alignment
        elif align_div:
            html.append(__style['align_close'])
            align_div = ''

        #----------------------------------------------------------------------
        #                           INDENTATION CHECKS
        #----------------------------------------------------------------------

        # make sure we're on the same level
        if curr_section and sline and (len(line) - len(line.lstrip())) < curr_section_level:
            html += section_stack
            section_stack = []

            curr_section = ''
            curr_section_level = 0

        count = i
        while sline.endswith('\\') and count + 1 < len(lines):
            sline += ' ' + lines[count + 1].strip()
            skip.append(count)
            count += 1

        #----------------------------------------------------------------------
        #                           IGNORE WIKI INFORMATION
        #----------------------------------------------------------------------

        # check to see what is wiki protected
        if sline.startswith('<nowiki'):
            mode = re.search('mode=""(\w*)""', sline)
            if mode:
                nowiki_mode = nstr(mode.group(1))
            else:
                nowiki_mode = None

            if not ignore_list_stack:
                html += list_stack
                list_stack = []

            html += table_stack
            table_stack = []

            if nowiki_mode is None:
                html.append(__style['nowiki_open'])
                nowiki_stack.append(__style['nowiki_close'])
            else:
                nowiki_stack.append('')

            continue

        elif sline == '</nowiki>':
            html += nowiki_stack
            nowiki_stack = []
            continue

        elif nowiki_stack:
            if nowiki_mode == 'safe':
                html.append(line)
            else:
                html.append(xml.sax.saxutils.escape(line))
            continue

        #----------------------------------------------------------------------
        #                           TABLES
        #----------------------------------------------------------------------

        parts = line.split(' | ')
        if len(parts) == 1:
            html += table_stack
            table_stack = []

        # replace standard items
        for key, repl in PRE_ESCAPE_REPLACE.items():
            line = line.replace(key, repl)

        # strip out nowiki lines
        nowiki_dict = {}
        count = 0
        for section in EXPR_NOWIKI.findall(line)[::2]:
            nowiki_dict['nowiki_%i' % count] = section
            newtext = '%%(nowiki_%i)s' % count
            line = line.replace('<nowiki>%s</nowiki>' % section, newtext)
            count += 1

        #----------------------------------------------------------------------
        #                           SECTIONS
        #----------------------------------------------------------------------

        # check for a div section
        section = EXPR_SECTION.match(sline)
        if section:
            html += code_stack
            code_stack = []

            name = section.group(2)
            if name != curr_section:
                html += section_stack
                section_stack = []

                if name not in SECTION_ALERTS:
                    section_stack.append(__style['section_close'])

                    display = projex.text.capitalizeWords(name)
                    mapped = SECTION_MAP.get(name, display)

                    html.append(__style['section_open'].format(name=name,
                                                               title=mapped))
                else:
                    display = projex.text.capitalizeWords(name)
                    mapped = SECTION_MAP.get(name, display)

                    section_stack.append(__style['section_alert_close'])
                    url, success = urlHandler.resolve('img:%s.png' % name)
                    html.append(__style['section_alert_open'].format(name=name,
                                                                     title=mapped))

                curr_section = name
            else:
                html.append(__style['newline'])

            sline = sline.replace(section.group(), '')
            line = line.replace(section.group(), ' ' * len(section.group()))
            curr_section_level = len(line) - len(line.lstrip())

        #----------------------------------------------------------------------
        #                           CODE
        #----------------------------------------------------------------------

        # check for code
        code = EXPR_CODE.match(sline)
        if code:
            templ = ''
            code_line = code.groups()[0]

            if not code_stack:
                lang = 'python'
                lang_search = EXPR_LANG.search(code_line)

                if lang_search:
                    lang = lang_search.groups()[0]
                    code_line = code_line.replace(lang_search.group(), '')

                templ = __style['code_open'].format(lang=lang)
                code_stack.append(__style['code_close'])

            escaped = xml.sax.saxutils.escape(code_line)

            if not ignore_list_stack:
                html += list_stack
                list_stack = []

            html += table_stack
            table_stack = []

            html.append(templ + escaped)
            continue

        # exit out of the code mode
        else:
            html += code_stack
            code_stack = []

        #----------------------------------------------------------------------

        # make sure we have no html data in the line
        if not sline:
            html.append(__style['paragraph_close'])
            html.append(__style['paragraph_open'])
            continue

        # check for horizontal rules
        if EXPR_HR.match(sline):
            style = ''
            html.append(__style['hr'].format(style=style))
            continue

        #----------------------------------------------------------------------
        #                           HEADERS
        #----------------------------------------------------------------------

        # check for headers
        header = EXPR_HEADER.match(sline)
        if header:
            hopen, title, hclose = header.groups()
            hopencount = len(hopen)
            title = title.strip()

            if hopencount == len(hclose):
                name = projex.text.underscore(title)
                add = __style['header'].format(name=name,
                                               title=title,
                                               size=len(hopen))
                spacing = '#' * hopencount
                opts = (spacing, name, title)
                toc_data.append('%s. [[#%s|%s]]' % opts)

                if not ignore_list_stack:
                    html += list_stack
                    list_stack = []

                html += table_stack
                table_stack = []

                html.append(add)
                continue

        line = xml.sax.saxutils.escape(line)

        for key, repl in POST_ESCAPE_REPLACE.items():
            line = line.replace(key, repl)

        #----------------------------------------------------------------------
        #                           CLASS TYPES
        #----------------------------------------------------------------------

        # resolve any class links
        for result in EXPR_CLASS_LINK.findall(line):
            opts = result.split()
            for o, cls in enumerate(opts):
                # ignore base classes, need modules
                if '.' not in cls:
                    continue

                url, success = urlHandler.resolveClass(cls)
                if success:
                    opts[o] = __style['link_class'].format(url=url,
                                                           text=cls.split('.')[-1])

            info = __style['span_class'].format(crumbs=' '.join(opts))
            line = line.replace('&lt;' + result + '&gt;', info)

        #----------------------------------------------------------------------
        #                           GENERAL FORMATTING
        #----------------------------------------------------------------------

        # replace formatting options
        for section in EXPR_UNDERLINE.findall(line)[::2]:
            text = __style['underline'].format(text=section)
            line = line.replace(""___%s___"" % section, text)

        for section in EXPR_INLINE_CODE.findall(line)[::2]:
            text = __style['inline_code'].format(text=section)
            line = line.replace(""`%s`"" % section, text)

        for section in EXPR_STRIKEOUT.findall(line)[::2]:
            text = __style['strikeout'].format(text=section)
            line = line.replace(""---%s---"" % section, text)

        for section in EXPR_BOLD.findall(line)[::2]:
            text = __style['bold'].format(text=section)
            line = line.replace(""'''%s'''"" % section, text)

        for section in EXPR_ITALIC.findall(line)[::2]:
            text = __style['italic'].format(text=section)
            line = line.replace(""''%s''"" % section, text)

        #----------------------------------------------------------------------
        #                           IMAGES
        #----------------------------------------------------------------------

        # resolve any images
        for grp, url in EXPR_IMG.findall(line):
            urlsplit = url.split('|')
            last_word = re.findall('\w+', urlsplit[0])[-1]

            if len(urlsplit) == 1:
                urlsplit.append('')

            url, _ = urlHandler.resolveImage(urlsplit[0])
            line = line.replace(grp, __style['img'].format(url=url,
                                                           style=urlsplit[1],
                                                           title=last_word))

        #----------------------------------------------------------------------
        #                           COLORS
        #----------------------------------------------------------------------

        # resolve any colors
        for grp, coloring in EXPR_COLOR.findall(line):
            splt = coloring.split('|')
            if len(splt) == 1:
                splt.append('')

            line = line.replace(grp, __style['color'].format(color=splt[0],
                                                             text=splt[1]))

        #----------------------------------------------------------------------
        #                           SPANS
        #----------------------------------------------------------------------

        # resolve any spans
        for grp, coloring in EXPR_SPAN.findall(line):
            splt = coloring.split('|')
            if len(splt) == 1:
                splt.append('')

            templ = '<span style=""%s"">%s</span>' % (splt[0], splt[1])
            line = line.replace(grp, __style['span'].format(style=splt[0],
                                                            text=splt[1]))

        #----------------------------------------------------------------------
        #                           LINKS
        #----------------------------------------------------------------------

        # resolve any external urls
        for result in EXPR_EXTLINK.findall(line):
            grp = result[0]
            url = result[1]

            urlsplit = url.split()
            if len(urlsplit) == 1:
                urlsplit.append(urlsplit[0])

            url = urlsplit[0]
            urltext = ' '.join(urlsplit[1:])

            line = line.replace(grp, __style['link_ext'].format(url=url, text=urltext))

        # resolve any internal urls
        for grp, url in EXPR_INTLINK.findall(line):
            urlsplit = url.split('|')
            if len(urlsplit) == 1:
                last_word = re.findall('\w+', urlsplit[0])[-1]
                urlsplit.append(last_word)

            url = urlsplit[0]
            title = '|'.join(urlsplit[1:])
            found = True

            tagsplit = url.split('#')
            if len(tagsplit) == 1:
                url = url
                tag = ''
            else:
                url = tagsplit[0]
                tag = '#'.join(tagsplit[1:])

            # make sure the url exists
            if url:
                url, exists = urlHandler.resolve(url)
                if not exists:
                    found = False

            # join together the resolved url and the tag
            if tag:
                url = url + '#' + tag

            # generate the link
            if found:
                templ = __style['link_found'].format(url=url, text=title)
            else:
                templ = __style['link_not_found'].format(url=url, text=title)

            line = line.replace(grp, templ)

        #----------------------------------------------------------------------
        #                           LISTS
        #----------------------------------------------------------------------

        # process lists
        results = EXPR_LIST.match(line)
        if results:
            level, linetext = results.groups()
            level_count = len(level)
            level_type = 'unordered' if level[-1] == '*' else 'ordered'

            while level_count > len(list_stack):
                html.append(__style[level_type + '_list_open'])
                list_stack.append(__style[level_type + '_list_close'])

            while len(list_stack) > level_count:
                html.append(list_stack[-1])
                list_stack = list_stack[:-1]

            space_line = line.replace(level + '.', ' ' * (len(level) + 1))
            list_indent = len(re.match('\s*', space_line).group())

            html.append(__style['list_item_open'])
            html.append(linetext)

            continue

        elif not ignore_list_stack:
            html += list_stack
            list_stack = []

        #----------------------------------------------------------------------
        #                           TABLES
        #----------------------------------------------------------------------

        parts = line.split(' | ')
        if len(parts) > 1:
            if not table_stack:
                table_stack.append(__style['table_close'])
                html.append(__style['table_open'])

            cell_type = 'td'
            styles = ''

            cells = []
            for part in parts:
                results = EXPR_TABLE_CELL.search(part)

                if not results:
                    cells.append(__style['table_cell'].format(tag='td',
                                                              style='',
                                                              text=part.strip()))

                else:
                    grp, cell_type, styles = results.groups()

                    if not styles:
                        styles = ''
                    else:
                        styles = styles.strip('[]')

                    part = part.replace(grp, '').strip()
                    opts = (cell_type, styles, part, cell_type)

                    cells.append(__style['table_cell'].format(tag=cell_type,
                                                              style=styles,
                                                              text=part))

            line = __style['table_row'].format(text=''.join(cells))

            html.append((line % nowiki_dict))

        else:
            html += table_stack
            table_stack = []

            html.append(line % nowiki_dict)

    if align_div:
        html.append(__style['align_close'])

    if list_indent:
        html.append(__style['list_item_close'])

    html += table_stack
    html += list_stack
    html += code_stack
    html += nowiki_stack
    html += section_stack

    html.append(__style['wiki_close'].format(tag=defaultTag))
    html_txt = '\n'.join(html)

    # resolve any table of contents
    for toc, options in EXPR_TOC.findall(html_txt):
        toc_wiki = '\n\t'.join(toc_data)
        toc_html = __style['toc_open']
        toc_html += render(toc_wiki, urlHandler, templatePaths, options, 'div', wikiStyle)
        toc_html += __style['toc_close']

        html_txt = html_txt.replace(toc, toc_html)

    # replace \[ and \] options
    html_txt = html_txt.replace('\[', '[').replace('\]', ']')

    return html_txt"
2410,"def get_value_matched_by_regex(field_name, regex_matches, string):
    """"""Ensure value stored in regex group exists.""""""
    try:
        value = regex_matches.group(field_name)
        if value is not None:
            return value
    except IndexError:
        pass

    raise MissingFieldError(string, field_name)"
2411,"def positive_int(val):
    """"""Parse `val` into a positive integer.""""""
    if isinstance(val, float):
        raise ValueError('""{}"" must not be a float'.format(val))
    val = int(val)
    if val >= 0:
        return val
    raise ValueError('""{}"" must be positive'.format(val))"
2412,"def strictly_positive_int_or_none(val):
    """"""Parse `val` into either `None` or a strictly positive integer.""""""
    val = positive_int_or_none(val)
    if val is None or val > 0:
        return val
    raise ValueError('""{}"" must be strictly positive'.format(val))"
2413,"def oboTermParser(filepath):
    """"""Read a obo file and yield '[Term]' entries.

    :param filepath: file path of the .obo file

    :yields: lists containing all lines from a obo '[Term]' entry. Lines are not
        processed and still contain the newline character.
    """"""
    with io.open(filepath) as openfile:
        lineIter = iter([i.rstrip() for i in openfile.readlines()])

    #Iterate through lines until the first obo ""[Term]"" is encountered
    try:
        line = next(lineIter)
        while line != '[Term]':
            line = next(lineIter)
        header = line #Remove
        entryLines = list()
    except StopIteration:
        errorText = 'File does not contain obo ""[Term]"" entries.'
        raise maspy.errors.FileFormatError(errorText)

    for line in lineIter:
        #Skip empty lines between entries
        if not line:
            continue
        if line == '[Term]':
            yield entryLines
            header = line #Remove
            entryLines = list()
        else:
            entryLines.append(line)

    #Yield last entry
    if entryLines:
        yield entryLines"
2414,"def _attributeLinesToDict(attributeLines):
    """"""Converts a list of obo 'Term' lines to a dictionary.

    :param attributeLines: a list of obo 'Term' lines. Each line contains a key
        and a value part which are separated by a ':'.

    :return: a dictionary containing the attributes of an obo 'Term' entry.

    NOTE: Some attributes can occur multiple times in one single term, for 
          example 'is_a' or 'relationship'. However, currently only the last
          occurence is stored.
    """"""
    attributes = dict()
    for line in attributeLines:
        attributeId, attributeValue = line.split(':', 1)
        attributes[attributeId.strip()] = attributeValue.strip()
    return attributes"
2415,"def _termIsObsolete(oboTerm):
    """"""Determine wheter an obo 'Term' entry is marked as obsolete.

    :param oboTerm: a dictionary as return by
        :func:`maspy.ontology._attributeLinesToDict()`

    :return: bool
    """"""
    isObsolete = False
    if u'is_obsolete' in oboTerm:
        if oboTerm[u'is_obsolete'].lower() == u'true':
            isObsolete = True
    return isObsolete"
2416,"def load(self, filepath):
        """"""Import '[Term]' entries from an .obo file.""""""
        for attributeLines in oboTermParser(filepath):
            oboTerm = _attributeLinesToDict(attributeLines)
            if oboTerm['id'] not in self.oboTerms:
                self.oboTerms[oboTerm['id']] = oboTerm            
            else:
                oldOboTerm = self.oboTerms[oboTerm['id']]
                oldTermIsObsolete = _termIsObsolete(oldOboTerm)
                newTermIsObsolete = _termIsObsolete(oboTerm)
                if oldTermIsObsolete and not newTermIsObsolete:
                    self.oboTerms[oboTerm['id']] = oboTerm
                else:
                    #At least one of two terms with identical id must be obsolete
                    assert oldTermIsObsolete or newTermIsObsolete"
2417,"def discover_handler_classes(handlers_package):
    """"""
    Looks for handler classes within handler path module.

    Currently it's not looking deep into nested module.

    :param handlers_package: module path to handlers
    :type handlers_package: string
    :return: list of handler classes
    """"""
    if handlers_package is None:
        return

    # Add working directory into PYTHONPATH to import developer packages
    sys.path.insert(0, os.getcwd())

    package = import_module(handlers_package)

    # Continue searching for module if package is not a module
    if hasattr(package, '__path__'):
        for _, modname, _ in pkgutil.iter_modules(package.__path__):
            import_module('{package}.{module}'.format(package=package.__name__, module=modname))

    return registered_handlers"
2418,"def request(self, method, path, query=None, content=None):
        """"""
        Sends an HTTP request.

        This constructs a full URL, encodes and decodes HTTP bodies, and
        handles invalid responses in a pythonic way.

        @type method: string
        @param method: HTTP method to use
        @type path: string
        @param path: HTTP URL path
        @type query: list of two-tuples
        @param query: query arguments to pass to urllib.urlencode
        @type content: str or None
        @param content: HTTP body content

        @rtype: object
        @return: JSON-Decoded response

        @raises GanetiApiError: If an invalid response is returned
        """"""

        if not path.startswith(""/""):
            raise ClientError(""Implementation error: Called with bad path %s""
                              % path)

        body = None

        if content is not None:
            data = self._json_encoder.encode(content)
            body = StringProducer(data)

        url = self._base_url + path

        if query:
            prepare_query(query)
            params = urlencode(query, doseq=True)
            url += ""?%s"" % params

        log.msg(""Sending request to %s %s %s"" % (url, self.headers, body),
                system=""Gentleman"")

        d = self._agent.request(method, url, headers=self.headers,
                                bodyProducer=body)

        protocol = JsonResponseProtocol(d)

        @d.addErrback
        def connectionFailed(failure):
            failure.trap(ConnectionRefusedError)
            raise GanetiApiError(""Connection refused!"")

        @d.addCallback
        def cb(response):
            if response.code != 200:
                raise NotOkayError(code=response.code)
            response.deliverBody(protocol)

        return protocol.getData()"
2419,"def start(self):
        """"""
        Confirm that we may access the target cluster.
        """"""

        version = yield self.request(""get"", ""/version"")

        if version != 2:
            raise GanetiApiError(""Can't work with Ganeti RAPI version %d"" %
                                 version)

        log.msg(""Accessing Ganeti RAPI, version %d"" % version,
                system=""Gentleman"")
        self.version = version

        try:
            features = yield self.request(""get"", ""/2/features"")
        except NotOkayError, noe:
            if noe.code == 404:
                # Okay, let's calm down, this is totally reasonable. Certain
                # older Ganeti RAPIs don't have a list of features.
                features = []
            else:
                # No, wait, panic was the correct thing to do.
                raise

        log.msg(""RAPI features: %r"" % (features,), system=""Gentleman"")
        self.features = features"
2420,"def get_multi_word_keywords(features):
        """"""This returns an OrderedDict containing the multi word keywords in order of length.
        This is so the tokenizer will match the longer matches before the shorter matches
        """"""
        keys = {
            'is not': Token(TokenTypes.NOT_EQUAL, 'is not'),
        }
        return OrderedDict(sorted(list(keys.items()), key=lambda t: len(t[0]), reverse=True))"
2421,"def inside_try(func, options={}):
    """""" decorator to silence exceptions, for logging
        we want a ""safe"" fail of the functions """"""
    if six.PY2:
        name = func.func_name
    else:
        name = func.__name__

    @wraps(func)
    def silenceit(*args, **kwargs):
        """""" the function func to be silenced is wrapped inside a
        try catch and returned, exceptions are logged
        exceptions are returned in an error dict
        takes all kinds of arguments and passes to the original func
        """"""
        excpt = None
        try:
            return func(*args, **kwargs)
        # pylint: disable=W0703
        # inside_try.silenceit: Catching too general exception Exception
        # that's the idea!
        except Exception as excpt:
            # first tell the object in charge
            if 'ctx' in kwargs:
                ctx = kwargs['ctx']
            else:
                # otherwise tell object defined in options
                # if we can be sure there is a context
                ctx = get_try_option(None, 'ctx')

            if not ctx:
                # tell a new object
                ctx = Bubble('Inside Try')
                # ctx.set_verbose(100); #todo: move to magic

            head = name + ': silenced function inside_try:Error:'
            if get_try_option(ctx, 'count_it'):
                ctx.gbc.cry(head + 'counting')
            if get_try_option(ctx, 'print_it'):
                ctx.gbc.cry(head + 'printing:' + str(excpt))
            if get_try_option(ctx, 'print_args'):
                ctx.gbc.cry(head + 'printing ak:' + str(excpt))
                ctx.gbc.cry('args', stuff=args)
                ctx.gbc.cry('kwargs', stuff=kwargs)
            if get_try_option(ctx, 'inspect_it'):
                ctx.gbc.cry(head + 'inspecting:', stuff=excpt)
                for s in inspect.stack():
                    ctx.gbc.cry(head + ':stack:', stuff=s)
            if get_try_option(ctx, 'log_it'):
                ctx.gbc.cry(head + 'logging')
                for s in inspect.stack():
                    ctx.gbc.cry(head + ':stack:', stuff=s)
            if get_try_option(ctx, 'reraise_it'):
                ctx.gbc.cry(head + 'reraising')
                raise excpt
            # always return error
            return {'error': str(excpt),
                    'silenced': name,
                    'args': args,
                    'kwargs': kwargs}
    return silenceit"
2422,"def start(self):
        """"""
        Start the server and run forever.
        """"""
        Server().start(self.options,self.handler_function, self.__class__.component_type)"
2423,"def collect(basepath, exclude=None, processPlugins=True):
    """"""
    Collects all the packages associated with the inputted filepath.
    
    :param      module | <module>
    
    :return     ([<str> pkg, ..], [(<str> path, <str> relpath), ..] data)
    """"""
    if exclude is None:
        exclude = ['.py', '.pyc', '.pyo', '.css', '.exe']

    imports = []
    datas = []

    # walk the folder structure looking for all packages and data files
    basename = os.path.basename(basepath)
    basepath = os.path.abspath(basepath)
    baselen = len(basepath) - len(basename)

    plugfiles = []

    for root, folders, files in os.walk(basepath):
        if '.svn' in root or '.git' in root:
            continue

        # mark the plugins file for load
        plugdata = None
        if processPlugins and '__plugins__.py' in files:
            filename = os.path.join(root, '__plugins__.py')
            package = projex.packageFromPath(filename) + '.__plugins__'
            pkgpath = projex.packageRootPath(filename)

            if pkgpath not in sys.path:
                sys.path.insert(0, pkgpath)

            # import the plugins module
            __import__(package)
            pkg = sys.modules[package]

            recurse = getattr(pkg, '__recurse__', False)
            plugdata = {'recurse': recurse,
                        'packages': [],
                        'path': root}

            plugfiles.append(plugdata)

        # look for any recursion plugins
        else:
            for data in plugfiles:
                if data['recurse'] and root.startswith(data['path']):
                    plugdata = data
                    break

        if plugdata is not None:
            packages = plugdata['packages']

            # include package plugins
            for folder in folders:
                pkgpath = os.path.join(root, folder, '__init__.py')
                if os.path.exists(pkgpath):
                    packages.append(projex.packageFromPath(pkgpath))

        for file_ in files:
            module, ext = os.path.splitext(file_)

            # look for python modules
            if ext == '.py':
                package_path = projex.packageFromPath(os.path.join(root, file_))
                if not package_path:
                    continue

                if module != '__init__':
                    package_path += '.' + module

                imports.append(package_path)

                # test to see if this is a plugin file
                if plugdata is not None and module not in ('__init__',
                                                           '__plugins__'):
                    plugdata['packages'].append(package_path)

            # look for data
            elif ext not in exclude:
                src = os.path.join(root, file_)
                targ = os.path.join(root[baselen:])
                datas.append((src, targ))

    # save the plugin information
    for plugdata in plugfiles:
        fname = os.path.join(plugdata['path'], '__plugins__.py')
        packages = plugdata['packages']

        plugs = ',\n'.join(map(lambda x: ""r'{0}'"".format(x), packages))
        data = [
            '__recurse__ = {0}'.format(plugdata['recurse']),
            '__toc__ = [{0}]'.format(plugs)
        ]

        # write the data to the system
        f = open(fname, 'w')
        f.write('\n'.join(data))
        f.close()

    return imports, datas"
2424,"def get_reverse(self):
        """"""By default, Cable entries are sorted by rating and Broadcast ratings are
        sorted by time.
        By default, float attributes are sorted from highest to lowest and non-float
        attributes are sorted alphabetically (show, net) or chronologically (time).
        """"""
        if self.sort in FLOAT_ATTRIBUTES:
            return True
        elif self.sort in NONFLOAT_ATTRIBUTES:
            return False
        else:
            raise InvalidSortError(self.sort)"
2425,"def sort_func(self, entry):
        """"""Return the key attribute to determine how data is sorted.
        Time will need to be converted to 24 hour time.
        In instances when float attributes will have an 'n/a' string, return 0.
        """"""
        key = entry[self.sort]

        if self.sort in FLOAT_ATTRIBUTES and not isinstance(key, float):
            return 0  # If value is 'n/a' string
        elif self.sort == 'time':
            return convert_time(key)
        elif self.sort == 'date':
            return convert_date(key)

        return key"
2426,"def sort_entries(self):
        """"""Get whether reverse is True or False. Return the sorted data.""""""
        return sorted(self.data, key=self.sort_func, reverse=self.get_reverse())"
2427,"def visible_fields(self):
        """"""
        Returns the reduced set of visible fields to output from the form.

        This method respects the provided ``fields`` configuration _and_ exlcudes
        all fields from the ``exclude`` configuration.

        If no ``fields`` where provided when configuring this fieldset, all visible
        fields minus the excluded fields will be returned.

        :return: List of bound field instances or empty tuple.
        """"""

        form_visible_fields = self.form.visible_fields()

        if self.render_fields:
            fields = self.render_fields
        else:
            fields = [field.name for field in form_visible_fields]

        filtered_fields = [field for field in fields if field not in self.exclude_fields]
        return [field for field in form_visible_fields if field.name in filtered_fields]"
2428,"def get_fieldsets(self, fieldsets=None):
        """"""
        This method returns a generator which yields fieldset instances.

        The method uses the optional fieldsets argument to generate fieldsets for.
        If no fieldsets argument is passed, the class property ``fieldsets`` is used.

        When generating the fieldsets, the method ensures that at least one fielset
        will be the primary fieldset which is responsible for rendering the non field
        errors and hidden fields.

        :param fieldsets: Alternative set of fieldset kwargs. If passed this set is
                          prevered of the ``fieldsets`` property of the form.
        :return: generator which yields fieldset instances.
        """"""
        fieldsets = fieldsets or self.fieldsets

        if not fieldsets:
            raise StopIteration

        # Search for primary marker in at least one of the fieldset kwargs.
        has_primary = any(fieldset.get('primary') for fieldset in fieldsets)

        for fieldset_kwargs in fieldsets:
            fieldset_kwargs = copy.deepcopy(fieldset_kwargs)
            fieldset_kwargs['form'] = self

            if not has_primary:
                fieldset_kwargs['primary'] = True
                has_primary = True

            yield self.get_fieldset(**fieldset_kwargs)"
2429,"def generate_binding_credentials(self, binding):
        """"""Generate binding credentials
        
        This function will permit to define the configuration to
        connect to the instance.
        Those credentials will be stored on a secret and exposed to a a Pod.
        
        We should at least returns the 'username' and 'password'.
        
        Args:
            binding (AtlasServiceBinding.Binding): A binding
            
        Returns:
            dict: All credentials and secrets.
            
        Raises:
            ErrClusterConfig: Connection string to the cluster is not available.
        """"""
        uri = self.clusters.get(binding.instance.get_cluster(), None)
        
        if not uri:
            raise ErrClusterConfig(binding.instance.get_cluster())
        
        # partial credentials
        creds = {""username"" : self.generate_binding_username(binding),
                ""password"" : pwgen(32, symbols=False),
                ""database"" : binding.instance.get_dbname()}
        
        # uri
        uri = uri % (
            creds[""username""],
            creds[""password""],
            creds[""database""])
        
        creds[""uri""] = uri
        
        # return creds
        return creds"
2430,"def generate_binding_permissions(self, binding, permissions):
        """"""Generate Users pemissions on the database
        
        Defining roles to the database for the users.
        We can pass extra information into parameters of the binding if needed (see binding.parameters).
        
        Args:
            binding (AtlasServiceBinding.Binding): A binding
            permissions (atlasapi.specs.DatabaseUsersPermissionsSpecs): Permissions for Atlas
        
        Returns:
            atlasapi.specs.DatabaseUsersPermissionsSpecs: Permissions for the new user
        """"""
        permissions.add_roles(binding.instance.get_dbname(),
                              [RoleSpecs.dbAdmin,
                               RoleSpecs.readWrite])
        return permissions"
2431,"def get_chunks(Array, Chunksize):
    """"""Generator that yields chunks of size ChunkSize""""""
    for i in range(0, len(Array), Chunksize):
        yield Array[i:i + Chunksize]"
2432,"def read_data_from_bin_file(fileName):
    """"""
    Loads the binary data stored in the a binary file and extracts the 
    data for each channel that was saved, along with the sample rate and length
    of the data array.

    Parameters
    ----------
    fileContent : bytes 
        bytes object containing the data from a .bin file exported from
        the saleae data logger.
    
    Returns
    -------
    ChannelData : list
        List containing a list which contains the data from each channel
    LenOf1Channel : int
        The length of the data in each channel
    NumOfChannels : int
        The number of channels saved
    SampleTime : float
        The time between samples (in seconds)
    SampleRate : float
        The sample rate (in Hz)
    """"""
    with open(fileName, mode='rb') as file: # b is important -> binary
        fileContent = file.read()

    (ChannelData, LenOf1Channel,
     NumOfChannels, SampleTime) = read_data_from_bytes(fileContent)
    
    return ChannelData, LenOf1Channel, NumOfChannels, SampleTime"
2433,"def read_data_from_bytes(fileContent):
    """"""
    Takes the binary data stored in the binary string provided and extracts the 
    data for each channel that was saved, along with the sample rate and length
    of the data array.

    Parameters
    ----------
    fileContent : bytes 
        bytes object containing the data from a .bin file exported from
        the saleae data logger.
    
    Returns
    -------
    ChannelData : list
        List containing a list which contains the data from each channel
    LenOf1Channel : int
        The length of the data in each channel
    NumOfChannels : int
        The number of channels saved
    SampleTime : float
        The time between samples (in seconds)
    SampleRate : float
        The sample rate (in Hz)
    """"""
    TotalDataLen = struct.unpack('Q', fileContent[:8])[0] # Unsigned long long 
    NumOfChannels = struct.unpack('I', fileContent[8:12])[0] # unsigned Long
    SampleTime = struct.unpack('d', fileContent[12:20])[0]

    AllChannelData = struct.unpack(""f"" * ((len(fileContent) -20) // 4), fileContent[20:])
    #  ignore the heading bytes (= 20)
    # The remaining part forms the body, to know the number of bytes in the body do an integer division by 4 (since 4 bytes = 32 bits = sizeof(float)

    LenOf1Channel = int(TotalDataLen/NumOfChannels)

    ChannelData = list(get_chunks(AllChannelData, LenOf1Channel))
    
    return ChannelData, LenOf1Channel, NumOfChannels, SampleTime"
2434,"def interpret_waveform(fileContent, RelativeChannelNo):
    """"""
    Extracts the data for just 1 channel and computes the corresponding
    time array (in seconds) starting from 0.
    
    Important Note: RelativeChannelNo is NOT the channel number on the Saleae data logger 
    it is the relative number of the channel that was saved. E.g. if you 
    save channels 3, 7 and 10, the corresponding RelativeChannelNos would
    be 0, 1 and 2.
    
    Parameters
    ----------
    fileContent : bytes 
        bytes object containing the data from a .bin file exported from
        the saleae data logger.
    RelativeChannelNo : int
        The relative order/position of the channel number in the saved
        binary file. See Important Note above!

    Returns
    -------    
    time : ndarray
        A generated time array corresponding to the data list
    Data : list
        The data from the relative channel requested
    SampleTime : float
        The time between samples (in seconds)
    """"""
    (ChannelData, LenOf1Channel,
     NumOfChannels, SampleTime) = read_data_from_bytes(fileContent)

    if RelativeChannelNo > NumOfChannels-1:
        raise ValueError(""There are {} channels saved, you attempted to read relative channel number {}. Pick a relative channel number between {} and {}"".format(NumOfChannels, RelativeChannelNo, 0, NumOfChannels-1))
    
    data = ChannelData[RelativeChannelNo]

    del(ChannelData)

    time = _np.arange(0, SampleTime*LenOf1Channel, SampleTime)

    return (0,SampleTime*LenOf1Channel,SampleTime), data"
2435,"def getApi():
    """"""Get Api for /health
    
    Returns:
        Blueprint: section for healt check
    """"""
    api = Blueprint('health', __name__, url_prefix='/')

    @api.route('health', methods=['GET'])
    def health():
        '''Health check'''
        return jsonify({ ""status"" : True})

    return api"
2436,"def get_coord_box(centre_x, centre_y, distance):
    """"""Get the square boundary coordinates for a given centre and distance""""""
    """"""Todo: return coordinates inside a circle, rather than a square""""""
    return {
        'top_left': (centre_x - distance, centre_y + distance),
        'top_right': (centre_x + distance, centre_y + distance),
        'bottom_left': (centre_x - distance, centre_y - distance),
        'bottom_right': (centre_x + distance, centre_y - distance),
    }"
2437,"def fleet_ttb(unit_type, quantity, factories, is_techno=False, is_dict=False, stasis_enabled=False):
    """"""
    Calculate the time taken to construct a given fleet

    """"""

    unit_weights = {
        UNIT_SCOUT: 1,
        UNIT_DESTROYER: 13,
        UNIT_BOMBER: 10,
        UNIT_CRUISER: 85,
        UNIT_STARBASE: 1,
    }

    govt_weight = 80 if is_dict else 100
    prod_weight = 85 if is_techno else 100

    weighted_qty = unit_weights[unit_type] * quantity
    ttb = (weighted_qty * govt_weight * prod_weight) * (2 * factories)

    # TTB is 66% longer with stasis enabled
    return ttb + (ttb * 0.66) if stasis_enabled else ttb"
2438,"def parse_fasta(data):  # pragma: no cover
    """"""
    Load sequences in Fasta format.

    This generator function yields a Sequence object for each sequence record
    in a GFF3 file. Implementation stolen shamelessly from
    http://stackoverflow.com/a/7655072/459780.
    """"""
    name, seq = None, []
    for line in data:
        line = line.rstrip()
        if line.startswith('>'):
            if name:
                yield Sequence(name, ''.join(seq))
            name, seq = line, []
        else:
            seq.append(line)
    if name:
        yield Sequence(name, ''.join(seq))"
2439,"def _resolve_features(self):
        """"""Resolve Parent/ID relationships and yield all top-level features.""""""

        for parentid in self.featsbyparent:
            parent = self.featsbyid[parentid]
            for child in self.featsbyparent[parentid]:
                parent.add_child(child, rangecheck=self.strict)

        # Replace top-level multi-feature reps with a pseudo-feature
        for n, record in enumerate(self.records):
            if not isinstance(record, Feature):
                continue
            if not record.is_multi:
                continue
            assert record.multi_rep == record
            newrep = sorted(record.siblings + [record])[0]
            if newrep != record:
                for sib in sorted(record.siblings + [record]):
                    sib.multi_rep = newrep
                    if sib != newrep:
                        newrep.add_sibling(sib)
                record.siblings = None
            parent = newrep.pseudoify()
            self.records[n] = parent

        if not self.assumesorted:
            for seqid in self.inferred_regions:
                if seqid not in self.declared_regions:
                    seqrange = self.inferred_regions[seqid]
                    srstring = '##sequence-region {:s} {:d} {:d}'.format(
                        seqid, seqrange.start + 1, seqrange.end
                    )
                    seqregion = Directive(srstring)
                    self.records.append(seqregion)

        for record in sorted(self.records):
            yield record
        self._reset()"
2440,"def _reset(self):
        """"""Clear internal data structure.""""""
        self.records = list()
        self.featsbyid = dict()
        self.featsbyparent = dict()
        self.countsbytype = dict()"
2441,"def get_by_label(self, label):
        """""" Return the first item with a specific label,
        or None.
        """"""
        return next((x for x in self if x.label == label), None)"
2442,"def getGenericAnswers(self, name, instruction, prompts):
        """"""Called when the server requests keyboard interactive authentication
        """"""
        responses = []
        for prompt, _echo in prompts:
            password = self.getPassword(prompt)
            responses.append(password)

        return defer.succeed(responses)"
2443,"def pairwise(iterable):
    """"""
    Generate consecutive pairs of elements from the given iterable.
    """"""
    iterator = iter(iterable)
    try:
        first = next(iterator)
    except StopIteration:
        return
    for element in iterator:
        yield first, element
        first = element"
2444,"def pick_cert_for_twisted(netloc, possible):
    """"""
    Pick the right client key/certificate to use for the given server and
    return it in the form Twisted wants.

    :param NetLocation netloc: The location of the server to consider.
    :param dict[TLSCredentials] possible: The available credentials from which
        to choose.

    :return: A two-tuple.  If no credentials were found, the elements are
        ``None`` and ``[]``.  Otherwise, the first element is a
        ``twisted.internet.ssl.PrivateCertificate`` instance representing the
        client certificate to use and the second element is a ``tuple`` of
        ``twisted.internet.ssl.Certificate`` instances representing the rest
        of the chain necessary to validate the client certificate.
    """"""
    try:
        creds = possible[netloc]
    except KeyError:
        return (None, ())

    key = ssl.KeyPair.load(creds.key.as_bytes(), FILETYPE_PEM)
    return (
        ssl.PrivateCertificate.load(
            creds.chain.certificates[0].as_bytes(), key, FILETYPE_PEM,
        ),
        tuple(
            ssl.Certificate.load(cert.as_bytes(), FILETYPE_PEM)
            for cert
            in creds.chain.certificates[1:]
        ),
    )"
2445,"def pick_trust_for_twisted(netloc, possible):
    """"""
    Pick the right ""trust roots"" (certificate authority certificates) for the
    given server and return it in the form Twisted wants.

    Kubernetes certificates are often self-signed or otherwise exist outside
    of the typical certificate authority cartel system common for normal
    websites.  This function tries to find the right authority to use.

    :param NetLocation netloc: The location of the server to consider.
    :param dict[pem.Certificate] possible: The available certificate authority
        certificates from which to choose.

    :return: A provider of ``twisted.internet.interfaces.IOpenSSLTrustRoot``
    if there is a known certificate authority certificate for the given
    server.  Otherwise, ``None``.
    """"""
    try:
        trust_cert = possible[netloc]
    except KeyError:
        return None

    cert = ssl.Certificate.load(trust_cert.as_bytes(), FILETYPE_PEM)
    return ssl.trustRootFromCertificates([cert])"
2446,"def https_policy_from_config(config):
    """"""
    Create an ``IPolicyForHTTPS`` which can authenticate a Kubernetes API
    server.

    :param KubeConfig config: A Kubernetes configuration containing an active
        context identifying a cluster.  The resulting ``IPolicyForHTTPS`` will
        authenticate the API server for that cluster.

    :return IPolicyForHTTPS: A TLS context which requires server certificates
        signed by the certificate authority certificate associated with the
        active context's cluster.
    """"""
    server = config.cluster[""server""]
    base_url = URL.fromText(native_string_to_unicode(server))

    ca_certs = pem.parse(config.cluster[""certificate-authority""].bytes())
    if not ca_certs:
        raise ValueError(""No certificate authority certificate found."")
    ca_cert = ca_certs[0]

    try:
        # Validate the certificate so we have early failures for garbage data.
        ssl.Certificate.load(ca_cert.as_bytes(), FILETYPE_PEM)
    except OpenSSLError as e:
        raise ValueError(
            ""Invalid certificate authority certificate found."",
            str(e),
        )

    netloc = NetLocation(host=base_url.host, port=base_url.port)
    policy = ClientCertificatePolicyForHTTPS(
        credentials={},
        trust_roots={
            netloc: ca_cert,
        },
    )
    return policy"
2447,"def authenticate_with_certificate_chain(reactor, base_url, client_chain, client_key, ca_cert):
    """"""
    Create an ``IAgent`` which can issue authenticated requests to a
    particular Kubernetes server using a client certificate.

    :param reactor: The reactor with which to configure the resulting agent.

    :param twisted.python.url.URL base_url: The base location of the
        Kubernetes API.

    :param list[pem.Certificate] client_chain: The client certificate (and
        chain, if applicable) to use.

    :param pem.Key client_key: The private key to use with the client
        certificate.

    :param pem.Certificate ca_cert: The certificate authority to respect when
        verifying the Kubernetes server certificate.

    :return IAgent: An agent which will authenticate itself to a particular
        Kubernetes server and which will verify that server or refuse to
        interact with it.
    """"""
    if base_url.scheme != u""https"":
        raise ValueError(
            ""authenticate_with_certificate() makes sense for HTTPS, not {!r}"".format(
                base_url.scheme
            ),
        )

    netloc = NetLocation(host=base_url.host, port=base_url.port)
    policy = ClientCertificatePolicyForHTTPS(
        credentials={
            netloc: TLSCredentials(
                chain=Chain(certificates=Certificates(client_chain)),
                key=client_key,
            ),
        },
        trust_roots={
            netloc: ca_cert,
        },
    )
    return Agent(reactor, contextFactory=policy)"
2448,"def authenticate_with_certificate(reactor, base_url, client_cert, client_key, ca_cert):
    """"""
    See ``authenticate_with_certificate_chain``.

    :param pem.Certificate client_cert: The client certificate to use.
    """"""
    return authenticate_with_certificate_chain(
        reactor, base_url, [client_cert], client_key, ca_cert,
    )"
2449,"def authenticate_with_serviceaccount(reactor, **kw):
    """"""
    Create an ``IAgent`` which can issue authenticated requests to a
    particular Kubernetes server using a service account token.

    :param reactor: The reactor with which to configure the resulting agent.

    :param bytes path: The location of the service account directory.  The
        default should work fine for normal use within a container.

    :return IAgent: An agent which will authenticate itself to a particular
        Kubernetes server and which will verify that server or refuse to
        interact with it.
    """"""
    config = KubeConfig.from_service_account(**kw)
    policy = https_policy_from_config(config)
    token = config.user[""token""]
    agent = HeaderInjectingAgent(
        _to_inject=Headers({u""authorization"": [u""Bearer {}"".format(token)]}),
        _agent=Agent(reactor, contextFactory=policy),
    )
    return agent"
2450,"def first_time_setup(self):
        """"""First time running Open Sesame? 
        
        Create keyring and an auto-unlock key in default keyring. Make sure
        these things don't already exist.
        """"""
        if not self._auto_unlock_key_position():
            pw  = password.create_passwords()[0]
            attrs = {'application': self.keyring}
            gkr.item_create_sync(self.default_keyring
                                ,gkr.ITEM_GENERIC_SECRET
                                ,self.keyring
                                ,attrs
                                ,pw
                                ,True)
        found_pos = self._auto_unlock_key_position()
        item_info = gkr.item_get_info_sync(self.default_keyring, found_pos)
        gkr.create_sync(self.keyring, item_info.get_secret())"
2451,"def _auto_unlock_key_position(self):
        """"""Find the open sesame password in the default keyring
        """"""
        found_pos = None
        default_keyring_ids = gkr.list_item_ids_sync(self.default_keyring)
        for pos in default_keyring_ids:
            item_attrs = gkr.item_get_attributes_sync(self.default_keyring, pos)
            app = 'application'
            if item_attrs.has_key(app) and item_attrs[app] == ""opensesame"":
                found_pos = pos
                break
        return found_pos"
2452,"def get_position_searchable(self):
        """"""Return dict of the position and corrasponding searchable str
        """"""
        ids = gkr.list_item_ids_sync(self.keyring)
        position_searchable = {}
        for i in ids:
            item_attrs = gkr.item_get_attributes_sync(self.keyring, i)
            position_searchable[i] = item_attrs['searchable'] 
        return position_searchable"
2453,"def _match_exists(self, searchable):
        """"""Make sure the searchable description doesn't already exist
        """"""
        position_searchable = self.get_position_searchable()
        for pos,val in position_searchable.iteritems():
            if val == searchable:
                return pos
        return False"
2454,"def save_password(self, password, **attrs):
        """"""Save the new password, save the old password with the date prepended
        """"""
        pos_of_match = self._match_exists(attrs['searchable'])
        if pos_of_match:
            old_password = self.get_password(pos_of_match).get_secret()
            gkr.item_delete_sync(self.keyring, pos_of_match)
            desc = str(int(time.time())) + ""_"" + attrs['searchable']
            gkr.item_create_sync(self.keyring
                                ,gkr.ITEM_GENERIC_SECRET
                                ,desc
                                ,{}
                                ,old_password
                                ,True)
        desc = attrs['searchable']
        pos = gkr.item_create_sync(self.keyring
                                   ,gkr.ITEM_GENERIC_SECRET
                                   ,desc
                                   ,attrs
                                   ,password
                                   ,True)
        return pos"
2455,"def get_descriptor_for_idcode(idcode):
    """"""Use this method to find bsdl descriptions for devices.
    The caching on this method drastically lower the execution
    time when there are a lot of bsdl files and more than one
    device. May move it into a metaclass to make it more
    transparent.""""""
    idcode = idcode&0x0fffffff
    id_str = ""XXXX""+bin(idcode)[2:].zfill(28)

    descr_file_path = _check_cache_for_idcode(id_str)
    if descr_file_path:
        with open(descr_file_path, 'r') as f:
            dat = json.load(f)
        if dat.get(""_file_version"",-1) == JTAGDeviceDescription.version:
            return JTAGDeviceDescription(dat.get('idcode'),
                                         dat.get('name'),
                                         dat.get('ir_length'),
                                         dat.get('instruction_opcodes'),
                                         dat.get('registers'),
                                         dat.get('instruction_register_map'))

    print(""    Device detected (""+id_str+""). Fetching missing descriptor..."")
    sid = get_sid(id_str)
    details = get_details(sid)
    attribs = decode_bsdl(sid)

    #VERIFYING PARSED DATA FROM 2 SOURCES. MESSY BUT USEFUL.
    instruction_length = 0
    if attribs.get('INSTRUCTION_LENGTH') ==\
       details.get('INSTRUCTION_LENGTH'):
        instruction_length = attribs.get('INSTRUCTION_LENGTH')
    elif attribs.get('INSTRUCTION_LENGTH') and\
       details.get('INSTRUCTION_LENGTH'):
        raise Exception(""INSTRUCTION_LENGTH can not be determined"")
    elif attribs.get('INSTRUCTION_LENGTH'):
        instruction_length = attribs.get('INSTRUCTION_LENGTH')
    else:
        instruction_length = details.get('INSTRUCTION_LENGTH')

    for instruction_name in details.get('instructions'):
        if instruction_name not in\
           attribs.get('INSTRUCTION_OPCODE',[]):
            raise Exception(""INSTRUCTION_OPCODE sources do not match"")

    #print(attribs['IDCODE_REGISTER'])
    descr = JTAGDeviceDescription(attribs['IDCODE_REGISTER'].upper(),
                                  details['name'], instruction_length,
                                  attribs['INSTRUCTION_OPCODE'],
                                  attribs['REGISTERS'],
                                  attribs['INSTRUCTION_TO_REGISTER'])

    #CACHE DESCR AS FILE!
    if not os.path.isdir(base_descr_dir):
        os.makedirs(base_descr_dir)
    descr_file_path = os.path.join(base_descr_dir,
                                   attribs['IDCODE_REGISTER']\
                                   .upper()+'.json')
    with open(descr_file_path, 'w') as f:
        json.dump(descr._dump(), f)

    return descr"
2456,"def parse_url(self):
        """"""Parse a git/ssh/http(s) url.""""""
        url = urlparse(self.url).path

        # handle git
        url = url.split('.git')[0]

        if ':' in url:
            url = url.split(':')[1]

        # Ony capture last two list items
        try:
            project, repo = url.split('/')[-2:]
        except ValueError:
            raise ParserError('""{}"" is not a valid repository URL.'.format(self.url))

        return project, repo"
2457,"def _fetch_dimensions(self, dataset):
        """""" Iterate through semesters, counties and municipalities.
        """"""
        yield Dimension(u""school"")
        yield Dimension(u""year"",
                        datatype=""year"")
        yield Dimension(u""semester"",
                        datatype=""academic_term"",
                        dialect=""swedish"")  # HT/VT
        yield Dimension(u""municipality"",
                        datatype=""year"",
                        domain=""sweden/municipalities"")"
2458,"def _merge_configs(configs):
    """"""
    Merge one or more ``KubeConfig`` objects.

    :param list[KubeConfig] configs: The configurations to merge.

    :return KubeConfig: A single configuration object with the merged
        configuration.
    """"""
    result = {
        u""contexts"": [],
        u""users"": [],
        u""clusters"": [],
        u""current-context"": None,
    }
    for config in configs:
        for k in {u""contexts"", u""users"", u""clusters""}:
            try:
                values = config.doc[k]
            except KeyError:
                pass
            else:
                result[k].extend(values)

        if result[u""current-context""] is None:
            try:
                result[u""current-context""] = config.doc[u""current-context""]
            except KeyError:
                pass

    return KubeConfig(result)"
2459,"def _merge_configs_from_env(kubeconfigs):
    """"""
    Merge configuration files from a ``KUBECONFIG`` environment variable.

    :param bytes kubeconfigs: A value like the one given to ``KUBECONFIG`` to
        specify multiple configuration files.

    :return KubeConfig: A configuration object which has merged all of the
        configuration from the specified configuration files.  Merging is
        performed according to
        https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/#merging-kubeconfig-files
    """"""
    paths = list(
        FilePath(p)
        for p
        in kubeconfigs.split(pathsep)
        if p
    )
    config = _merge_configs(list(
        KubeConfig.from_file(p.path)
        for p
        in paths
    ))
    return config"
2460,"def network_kubernetes_from_context(
        reactor, context=None, path=None, environ=None,
        default_config_path=FilePath(expanduser(u""~/.kube/config"")),
):
    """"""
    Create a new ``IKubernetes`` provider based on a kube config file.

    :param reactor: A Twisted reactor which will be used for I/O and
        scheduling.

    :param unicode context: The name of the kube config context from which to
        load configuration details.  Or, ``None`` to respect the current
        context setting from the configuration.

    :param FilePath path: The location of the kube config file to use.

    :param dict environ: A environment direction in which to look up
        ``KUBECONFIG``.  If ``None``, the real process environment will be
        inspected.  This is used only if ``path`` is ``None``.

    :return IKubernetes: The Kubernetes service described by the named
        context.
    """"""
    if path is None:
        if environ is None:
            from os import environ
        try:
            kubeconfigs = environ[u""KUBECONFIG""]
        except KeyError:
            config = KubeConfig.from_file(default_config_path.path)
        else:
            config = _merge_configs_from_env(kubeconfigs)
    else:
        config = KubeConfig.from_file(path.path)

    if context is None:
        context = config.doc[u""current-context""]

    context = config.contexts[context]
    cluster = config.clusters[context[u""cluster""]]
    user = config.users[context[u""user""]]

    if isinstance(cluster[u""server""], bytes):
        base_url = URL.fromText(cluster[u""server""].decode(""ascii""))
    else:
        base_url = URL.fromText(cluster[u""server""])
    [ca_cert] = parse(cluster[u""certificate-authority""].bytes())

    client_chain = parse(user[u""client-certificate""].bytes())
    [client_key] = parse(user[u""client-key""].bytes())

    agent = authenticate_with_certificate_chain(
        reactor, base_url, client_chain, client_key, ca_cert,
    )

    return network_kubernetes(
        base_url=base_url,
        agent=agent,
    )"
2461,"def collection_location(obj):
    """"""
    Get the URL for the collection of objects like ``obj``.

    :param obj: Either a type representing a Kubernetes object kind or an
        instance of such a type.

    :return tuple[unicode]: Some path segments to stick on to a base URL to
        construct the location of the collection of objects like the one
        given.
    """"""
    # TODO kind is not part of IObjectLoader and we should really be loading
    # apiVersion off of this object too.
    kind = obj.kind
    apiVersion = obj.apiVersion

    prefix = version_to_segments[apiVersion]

    collection = kind.lower() + u""s""

    if IObject.providedBy(obj):
        # Actual objects *could* have a namespace...
        namespace = obj.metadata.namespace
    else:
        # Types representing a kind couldn't possible.
        namespace = None

    if namespace is None:
        # If there's no namespace, look in the un-namespaced area.
        return prefix + (collection,)

    # If there is, great, look there.
    return prefix + (u""namespaces"", namespace, collection)"
2462,"def enter_new_scope(ctx):
    """"""
    we inside new scope with it onw
    :param ctx:
    :return:
    """"""
    ctx = ctx.clone()
    ctx.waiting_for = ctx.compiled_story().children_matcher()
    return ctx"
2463,"async def execute(ctx):
    """"""
    execute story part at the current context
    and make one step further

    :param ctx:
    :return:
    """"""
    tail_depth = len(ctx.stack()) - 1

    story_part = ctx.get_current_story_part()
    logger.debug('# going to call: {}'.format(story_part.__name__))
    waiting_for = story_part(ctx.message)
    if inspect.iscoroutinefunction(story_part):
        waiting_for = await waiting_for
    logger.debug('# got result {}'.format(waiting_for))

    # story part could run callable story and return its context
    if isinstance(waiting_for, story_context.StoryContext):
        # for such cases is very important to know `tail_depth`
        # because story context from callable story already has
        # few stack items above our tail
        ctx = waiting_for.clone()
        ctx.waiting_for = callable.WaitForReturn()
    else:
        ctx = ctx.clone()
        ctx.waiting_for = waiting_for

    tail_data = ctx.message['session']['stack'][tail_depth]['data']
    tail_step = ctx.message['session']['stack'][tail_depth]['step']
    if ctx.is_waiting_for_input():
        if isinstance(ctx.waiting_for, callable.EndOfStory):
            if isinstance(ctx.waiting_for.data, dict):
                new_data = {**ctx.get_user_data(), **ctx.waiting_for.data}
            else:
                new_data = ctx.waiting_for.data
            ctx.message = {
                **ctx.message,
                'session': {
                    **ctx.message['session'],
                    'data': new_data,
                },
            }
            tail_step += 1
        elif isinstance(ctx.waiting_for, loop.ScopeMatcher):
            # jumping in a loop
            tail_data = matchers.serialize(ctx.waiting_for)
        elif isinstance(ctx.waiting_for, loop.BreakLoop):
            tail_step += 1
        else:
            tail_data = matchers.serialize(
                matchers.get_validator(ctx.waiting_for)
            )
            tail_step += 1

    ctx.message = modify_stack_in_message(ctx.message,
                                          lambda stack: stack[:tail_depth] +
                                                        [{
                                                            'data': tail_data,
                                                            'step': tail_step,
                                                            'topic': stack[tail_depth]['topic'],
                                                        }] +
                                                        stack[tail_depth + 1:])
    logger.debug('# mutated ctx after execute')
    logger.debug(ctx)
    return ctx"
2464,"def iterate_storyline(ctx):
    """"""
    iterate the last storyline from the last visited story part

    :param ctx:
    :return:
    """"""
    logger.debug('# start iterate')
    compiled_story = ctx.compiled_story()
    if not compiled_story:
        return

    for step in range(ctx.current_step(),
                      len(compiled_story.story_line)):
        ctx = ctx.clone()
        tail = ctx.stack_tail()
        ctx.message = modify_stack_in_message(ctx.message,
                                              lambda stack: stack[:-1] + [{
                                                  'data': tail['data'],
                                                  'step': step,
                                                  'topic': tail['topic'],
                                              }])

        logger.debug('# [{}] iterate'.format(step))
        logger.debug(ctx)

        ctx = yield ctx"
2465,"def scope_in(ctx):
    """"""
    - build new scope on the top of stack
    - and current scope will wait for it result

    :param ctx:
    :return:
    """"""
    logger.debug('# scope_in')
    logger.debug(ctx)
    ctx = ctx.clone()

    compiled_story = None
    if not ctx.is_empty_stack():
        compiled_story = ctx.get_child_story()
        logger.debug('# child')
        logger.debug(compiled_story)
        # we match child story loop once by message
        # what should prevent multiple matching by the same message
        ctx.matched = True
        ctx.message = modify_stack_in_message(ctx.message,
                                              lambda stack: stack[:-1] + [{
                                                  'data': matchers.serialize(callable.WaitForReturn()),
                                                  'step': stack[-1]['step'],
                                                  'topic': stack[-1]['topic']
                                              }])

    try:
        if not compiled_story and ctx.is_scope_level_part():
            compiled_story = ctx.get_current_story_part()
    except story_context.MissedStoryPart:
        pass

    if not compiled_story:
        compiled_story = ctx.compiled_story()

    logger.debug('# [>] going deeper')
    ctx.message = modify_stack_in_message(ctx.message,
                                          lambda stack: stack + [
                                              stack_utils.build_empty_stack_item(compiled_story.topic)])
    logger.debug(ctx)
    return ctx"
2466,"def scope_out(ctx):
    """"""
    drop last stack item if:
     - we have reach the end of stack
     - and don't wait any input

    :param ctx:
    :return:
    """"""
    logger.debug('# scope_out')
    logger.debug(ctx)
    # we reach the end of story line
    # so we could collapse previous scope and related stack item
    if ctx.is_tail_of_story() and ctx.could_scope_out():
        logger.debug('# [<] return')
        ctx = ctx.clone()
        ctx.message['session']['stack'] = ctx.message['session']['stack'][:-1]
        if not ctx.is_empty_stack() and \
                (ctx.is_scope_level_part() or \
                         ctx.is_breaking_a_loop()):
            # isinstance(ctx.get_current_story_part(), loop.StoriesLoopNode) and \
            # isinstance(ctx.waiting_for, callable.EndOfStory) or \
            ctx.message = modify_stack_in_message(ctx.message,
                                                  lambda stack: stack[:-1] + [{
                                                      'data': stack[-1]['data'],
                                                      'step': stack[-1]['step'] + 1,
                                                      'topic': stack[-1]['topic'],
                                                  }])
            if ctx.is_breaking_a_loop() and not ctx.is_scope_level():
                ctx.waiting_for = None

        logger.debug(ctx)

    return ctx"
2467,"def str2date(self, date_str):
        """"""
        Parse date from string.

        If there's no template matches your string, Please go
        https://github.com/MacHu-GWU/rolex-project/issues
        submit your datetime string. I 'll update templates ASAP.

        This method is faster than :meth:`dateutil.parser.parse`.

        :param date_str: a string represent a date
        :type date_str: str
        :return: a date object

        **中文文档**

        从string解析date。首先尝试默认模板, 如果失败了, 则尝试所有的模板。
        一旦尝试成功, 就将当前成功的模板保存为默认模板。这样做在当你待解析的
        字符串非常多, 且模式单一时, 只有第一次尝试耗时较多, 之后就非常快了。
        该方法要快过 :meth:`dateutil.parser.parse` 方法。
        """"""
        # try default date template
        try:
            a_datetime = datetime.strptime(
                date_str, self._default_date_template)
            return a_datetime.date()
        except:
            pass

        # try every date templates
        for template in date_template_list:
            try:
                a_datetime = datetime.strptime(date_str, template)
                self._default_date_template = template
                return a_datetime.date()
            except:
                pass

        # raise error
        raise ValueError(""Unable to parse date from: %r!"" % date_str)"
2468,"def _str2datetime(self, datetime_str):
        """"""
        Parse datetime from string.

        If there's no template matches your string, Please go
        https://github.com/MacHu-GWU/rolex-project/issues
        submit your datetime string. I 'll update templates ASAP.

        This method is faster than :meth:`dateutil.parser.parse`.

        :param datetime_str: a string represent a datetime
        :type datetime_str: str
        :return: a datetime object

        **中文文档**

        从string解析datetime。首先尝试默认模板, 如果失败了, 则尝试所有的模板。
        一旦尝试成功, 就将当前成功的模板保存为默认模板。这样做在当你待解析的
        字符串非常多, 且模式单一时, 只有第一次尝试耗时较多, 之后就非常快了。
        该方法要快过 :meth:`dateutil.parser.parse` 方法。

        为了防止模板库失败的情况, 程序设定在失败后自动一直启用
        :meth:`dateutil.parser.parse` 进行解析。你可以调用 :meth:`Parser.reset()`
        方法恢复默认设定。
        """"""
        # try default datetime template
        try:
            a_datetime = datetime.strptime(
                datetime_str, self._default_datetime_template)
            return a_datetime
        except:
            pass

        # try every datetime templates
        for template in datetime_template_list:
            try:
                a_datetime = datetime.strptime(datetime_str, template)
                self._default_datetime_template = template
                return a_datetime
            except:
                pass

        # raise error
        a_datetime = parse(datetime_str)
        self.str2datetime = parse

        return a_datetime"
2469,"def parse_date(self, value):
        """"""
        A lazy method to parse anything to date.

        If input data type is:

        - string: parse date from it
        - integer: use from ordinal
        - datetime: use date part
        - date: just return it
        """"""
        if isinstance(value, sixmini.string_types):
            return self.str2date(value)
        elif value is None:
            raise TypeError(""Unable to parse date from %r"" % value)
        elif isinstance(value, sixmini.integer_types):
            return date.fromordinal(value)
        elif isinstance(value, datetime):
            return value.date()
        elif isinstance(value, date):
            return value
        else:
            raise ValueError(""Unable to parse date from %r"" % value)"
2470,"def parse_datetime(self, value):
        """"""
        A lazy method to parse anything to datetime.

        If input data type is:

        - string: parse datetime from it
        - integer: use from ordinal
        - date: use date part and set hour, minute, second to zero
        - datetime: just return it
        """"""
        if isinstance(value, sixmini.string_types):
            return self.str2datetime(value)
        elif value is None:
            raise TypeError(""Unable to parse datetime from %r"" % value)
        elif isinstance(value, sixmini.integer_types):
            return from_utctimestamp(value)
        elif isinstance(value, float):
            return from_utctimestamp(value)
        elif isinstance(value, datetime):
            return value
        elif isinstance(value, date):
            return datetime(value.year, value.month, value.day)
        else:
            raise ValueError(""Unable to parse datetime from %r"" % value)"
2471,"def define(self):
        """"""If DFA is empty, create a sink state""""""
        if len(self.states) == 0:
            for char in self.alphabet:
                self.add_arc(0, 0, char)
                self[0].final = False"
2472,"def add_state(self):
        """"""Adds a new state""""""
        sid = len(self.states)
        self.states.append(DFAState(sid))
        return sid"
2473,"def add_arc(self, src, dst, char):
        """"""Adds a new Arc
        Args:
            src (int): The source state identifier
            dst (int): The destination state identifier
            char (str): The character for the transition
        Returns:
            None
        """"""
        # assert type(src) == type(int()) and type(dst) == type(int()), \
        #     ""State type should be integer.""
        # assert char in self.I
        #
        #print self.states
        #print src
        for s_idx in [src, dst]:
            if s_idx >= len(self.states):
                for i in range(len(self.states), s_idx + 1):
                    self.states.append(DFAState(i))
        for arc in self.states[src].arcs:
            if arc.ilabel == self.isyms.__getitem__(char) or char == EPSILON:
                self.nfa = True
                break
        self.states[src].arcs.append(
            DFAArc(src, dst, self.isyms.__getitem__(char)))"
2474,"def complement(self, alphabet):
        """"""
        Returns the complement of DFA
        Args:
            alphabet (list): The input alphabet
        Returns:
            None
        """"""
        states = sorted(self.states, key=attrgetter('initial'), reverse=True)
        for state in states:
            if state.final:
                state.final = False
            else:
                state.final = True"
2475,"def init_from_acceptor(self, acceptor):
        """"""
        Adds a sink state
        Args:
            alphabet (list): The input alphabet
        Returns:
            None
        """"""
        self.states = copy.deepcopy(acceptor.states)
        self.alphabet = copy.deepcopy(acceptor.alphabet)
        self.osyms = copy.deepcopy(acceptor.osyms)
        self.isyms = copy.deepcopy(acceptor.isyms)"
2476,"def load(self, txt_fst_file_name):
        """"""
        Save the transducer in the text file format of OpenFST.
        The format is specified as follows:
            arc format: src dest ilabel olabel [weight]
            final state format: state [weight]
        lines may occur in any order except initial state must be first line
        Args:
            txt_fst_file_name (str): The input file
        Returns:
            None
        """"""
        with open(txt_fst_file_name, 'r') as input_filename:
            for line in input_filename:
                line = line.strip()
                split_line = line.split()
                if len(split_line) == 1:
                    self[int(split_line[0])].final = True
                else:
                    self.add_arc(int(split_line[0]), int(split_line[1]),
                                 split_line[2].decode('hex'))"
2477,"def intersect(self, other):
        """"""Constructs an unminimized DFA recognizing
        the intersection of the languages of two given DFAs.
        Args:
            other (DFA): The other DFA that will be used
                         for the intersect operation
        Returns:
        Returns:
            DFA: The resulting DFA
        """"""
        operation = bool.__and__
        self.cross_product(other, operation)
        return  self"
2478,"def symmetric_difference(self, other):
        """"""Constructs an unminimized DFA recognizing
        the symmetric difference of the languages of two given DFAs.
        Args:
            other (DFA): The other DFA that will be used
                         for the symmetric difference operation
        Returns:
            DFA: The resulting DFA
        """"""
        operation = bool.__xor__
        self.cross_product(other, operation)
        return  self"
2479,"def union(self, other):
        """"""Constructs an unminimized DFA recognizing the union of the languages of two given DFAs.
        Args:
            other (DFA): The other DFA that will be used
                         for the union operation
        Returns:
            DFA: The resulting DFA
        """"""
        operation = bool.__or__
        self.cross_product(other, operation)
        return self"
2480,"def _epsilon_closure(self, state):
        """"""
        Returns the \epsilon-closure for the state given as input.
        """"""
        closure = set([state.stateid])
        stack = [state]
        while True:
            if not stack:
                break
            s = stack.pop()
            for arc in s:
                if self.isyms.find(arc.ilabel) != EPSILON or \
                        arc.nextstate in closure:
                    continue
                closure.add(arc.nextstate)
                stack.append(self.states[arc.nextstate])
        return closure"
2481,"def determinize(self):
        """"""
        Transforms a Non Deterministic DFA into a Deterministic
        Args:
            None
        Returns:
            DFA: The resulting DFA

        Creating an equivalent DFA is done using the standard algorithm.
        A nice description can be found in the book:
        Harry R. Lewis and Christos H. Papadimitriou. 1998.
        E
        print target_dfa_statelements of the Theory of Computation.
        """"""

        # Compute the \epsilon-closure for all states and save it in a diagram
        epsilon_closure = {}
        for state in self.states:
            sid = state.stateid
            epsilon_closure[sid] = self._epsilon_closure(state)

        # Get a transition diagram to speed up computations
        trans_table = {}
        for state in self.states:
            trans_table[state.stateid] = defaultdict(set)
            for arc in state:
                char = self.isyms.find(arc.ilabel)
                trans_table[state.stateid][char].add(arc.nextstate)

        # is_final function:
        # Given a set of nfa states representing a dfa_state return 1 if the
        # corresponding DFA state is a final state, i.e. if any of the
        # corresponding NFA states are final.
        is_final = lambda nfa_states, dfa_state: True \
            if sum([ int(nfa_states[x].final) for x in dfa_state ]) >= 1 \
            else False

        # Precomputation is over, start executing the conversion algorithm
        state_idx = 1
        nfa_states = copy.deepcopy(self.states)
        self.states = []
        # Initialize the new DFA state list
        self.add_state()
        new_initial = epsilon_closure[nfa_states[0].stateid]
        self.states[0].final = is_final(nfa_states, new_initial)

        dfa_state_idx_map = { frozenset(new_initial) : 0 }
        stack = [new_initial]
        while True:
            # Iterate until all added DFA states are processed.
            if not stack:
                break
            # This is a set of states from the NFA
            src_dfa_state = stack.pop()
            src_dfa_state_idx = dfa_state_idx_map[frozenset(src_dfa_state)]
            for char in self.alphabet:
                # Compute the set of target states
                target_dfa_state = set([])
                for nfa_state in src_dfa_state:
                    next_states = \
                        set([y for x in trans_table[nfa_state][char] \
                             for y in epsilon_closure[x] ])
                    target_dfa_state.update(next_states)
                # If the computed state set is not part of our new DFA add it,
                # along with the transition for the current character.
                if frozenset(target_dfa_state) not in dfa_state_idx_map:
                    self.add_state()
                    dfa_state_idx_map[frozenset(target_dfa_state)] = state_idx
                    self.states[state_idx].final = is_final(nfa_states,
                                                            target_dfa_state)
                    state_idx += 1
                    stack.append(target_dfa_state)

                dst_state_idx = dfa_state_idx_map[frozenset(target_dfa_state)]
                self.add_arc(src_dfa_state_idx, dst_state_idx, char)
        return self"
2482,"def invert(self):
        """"""Inverts the DFA final states""""""
        for state in self.states:
            if state.final:
                state.final = False
            else:
                state.final = True"
2483,"def hopcroft(self):
        """"""
        Performs the Hopcroft minimization algorithm
        Args:
            None
        Returns:
            DFA: The minimized input DFA
        """"""

        def _getset(testset, partition):
            """"""
            Checks if a set is in a partition
            Args:
                testset (set): The examined set
                partition (list): A list of sets
            Returns:
                bool: A value indicating if it is a member or not
            """"""
            for part in partition:
                if set(testset) == set(part):
                    return True
            return None

        def _create_transitions_representation(graph):
            """"""
            In order to speedup the transition iteration using
            the alphabet, the function creates an index
            Args:
                graph (DFA): The input dfa
                state (DFA state): The examined state
            Returns:
                dict: The generated transition map
            """"""
            return {x.stateid:{self.isyms.find(arc.ilabel): arc.nextstate \
                               for arc in x} for x in graph.states}

        def _create_reverse_transitions_representation(graph):
            """"""
            In order to speedup the transition iteration using
            the alphabet, the function creates an index
            Args:
                graph (DFA): The input dfa
                state (DFA state): The examined state
            Returns:
                dict: The generated transition map
            """"""
            return {x.stateid: {self.isyms.find(arc.ilabel): arc.nextstate \
                                for arc in x} for x in graph.states}

        def _reverse_to_source(target, group1):
            """"""
            Args:
                target (dict): A table containing the reverse transitions for each state
                group1 (list): A group of states
            Return:
                Set: A set of states for which there is a transition with the states of the group
            """"""
            new_group = []
            for dst in group1:
                new_group += target[dst]
            return set(new_group)

        def _get_group_from_state(groups, sid):
            """"""
            Args:
                sid (int): The state identifier
            Return:
                int: The group identifier that the state belongs
            """"""
            for index, selectgroup in enumerate(groups):
                if sid in selectgroup:
                    return index

        def _delta(graph, cur_state, char):
            """"""
            Function describing the transitions
            Args:
                graph (DFA): The DFA states
                cur_state (DFA state): The DFA current state
                char (str):: The char that will be used for the transition
            Return:
                DFA Node: The next state
            """"""
            for arc in cur_state.arcs:
                if graph.isyms.find(arc.ilabel) == char:
                    return graph[arc.nextstate]

        def _partition_group(bookeeping, group):
            """"""
            Args:
                group (list):  A group of states
            Return:
                tuple: A set of two groups
            """"""
            for (group1, group2) in bookeeping:
                if group & group1 != set() and not group.issubset(group1):
                    new_g1 = group & group1
                    new_g2 = group - group1
                    return (new_g1, new_g2)
                if group & group2 != set() and not group.issubset(group2):
                    new_g1 = group & group2
                    new_g2 = group - group2
                    return (new_g1, new_g2)
            assert False, ""Unmatched group partition""

        def _object_set_to_state_list(objectset):
            """"""
            Args:
                objectset (list): A list of all the DFA states (as objects)
            Return:
                list: A list of all the DFA states (as identifiers)
            """"""
            return [state.stateid for state in objectset]

        def _get_accepted(graph):
            """"""
            Find the accepted states
            Args:
                graph (DFA): The DFA states
            Return:
                list: Returns the list of the accepted states
            """"""
            return [state for state in graph \
                    if  state.final != TropicalWeight(float('inf'))]

        graph = self

        # Find Q
        set_q = set(_object_set_to_state_list(graph.states))
        # We will work with states addresses here instead of states stateid for
        # more convenience
        set_f = set(_object_set_to_state_list(_get_accepted(graph)))
        # Perform P := {F, Q-F}
        set_nf = set_q.copy() - set_f.copy()
        groups = [set_f.copy(), set_nf.copy()]
        bookeeping = [(set_f, set_nf)]

        done = False
        while not done:
            done = True
            new_groups = []
            for selectgroup in groups:
                # _check for each letter if it splits the current group
                for character in self.alphabet:
                    # print 'Testing symbol: ', c
                    target = defaultdict(list)
                    target_states = defaultdict(int)
                    new_g = [set(selectgroup)]
                    for sid in selectgroup:
                        # _check if all transitions using c are going in a state
                        # in the same group. If they are going on a different
                        # group then split
                        deststate = _delta(graph, graph[sid], character)
                        destgroup = _get_group_from_state(groups,
                            deststate.stateid)
                        target[destgroup].append(sid)
                        target_states[destgroup] = deststate.stateid
                    if len(target) > 1:

                        inv_target_states = {
                            v: k for k, v in target_states.iteritems()}
                        new_g = [set(selectedstate) for selectedstate in target.values()]
                        done = False
                        # Get all the partitions of destgroups
                        queue = [set([x for x in target_states.values()])]
                        while queue:
                            top = queue.pop(0)
                            (group1, group2) = _partition_group(bookeeping, top)
                            ng1 = _reverse_to_source(
                                target, [inv_target_states[x] for x in group1])
                            ng2 = _reverse_to_source(
                                target, [inv_target_states[x] for x in group2])

                            bookeeping.append((ng1, ng2))

                            if len(group1) > 1:
                                queue.append(group1)
                            if len(group2) > 1:
                                queue.append(group2)
                        break
                new_groups += new_g

            # End of iteration for the k-equivalence
            # Assign new groups and check if any change occured
            groups = new_groups

        # Make a copy of the old states, and prepare the
        # automaton to host the minimum states

        oldstates = copy.deepcopy(self.states)
        self.states = []
        self.define()

        def findpart(stateid, partitions):
            """"""Searches for the groupt that the state identifier
            belongs to.
            Args:
                stateid (int): The state identifier
                partitions (list): The list of the groups
            Returns:
                set: The group that the stateid belongs to.
            """"""
            for group in partitions:
                if stateid in group:
                    return frozenset(group)
            return frozenset(set(            ))

        def add_state_if_not_exists(group, statesmap, final):
            """"""
            Adds a new state in the final dfa. It initialy checks if
            the group of states is already registered to the automaton.
            If it is registered, the state identifier is returned, or
            else, a new state is added.
            Args:
                group (frozenset):  The group that the state identifier belongs
                statesmap (dict):   A dictionary that maintains the state
                                    identifiers for each forzenset
                final (bool):       A value indicating if the current state is
                                    final
            Returns:
                int: The new state identifier
            """"""
            if group not in statesmap:
                sid = self.add_state()
                self[sid].final = final
                statesmap[group] = sid
            return statesmap[group]

        statesmap = {}
        self.states = []
        group = findpart(0, groups)
        sid = add_state_if_not_exists(frozenset(list(group)), statesmap,
                                      oldstates[0].final)
        self[sid].initial = True
        for group in groups:
            if len(group) == 0:
                continue
            sid = add_state_if_not_exists(frozenset(group), statesmap,
                                          oldstates[list(group)[0]].final)
            state = next(iter(group))
            for arc in oldstates[state]:
                dst_group = findpart(arc.nextstate, groups)
                dst_sid = add_state_if_not_exists(
                    dst_group, statesmap, oldstates[arc.nextstate].final)
                self.add_arc(sid, dst_sid, graph.isyms.find(arc.ilabel))"
2484,"def cross_product(self, dfa_2, accept_method):
        """"""A generalized cross-product constructor over two DFAs.
        The third argument is a binary boolean function f; a state (q1, q2) in the final
        DFA accepts if f(A[q1],A[q2]), where A indicates the acceptance-value of the state.
        Args:
            dfa_2: The second dfa
            accept_method: The boolean action
        Returns:
            None
        """"""
        dfa_1states = copy.deepcopy(self.states)
        dfa_2states = dfa_2.states
        self.states = []
        states = {}


        def _create_transitions_representation(graph, state):
            """"""
            In order to speedup the transition iteration using
            the alphabet, the function creates an index
            Args:
                graph (DFA): The input dfa
                state (DFA state): The examined state
            Returns:
                dict: The generated transition map
            """"""
            return {self.isyms.find(arc.ilabel): graph[arc.nextstate] for arc in state}


        def _add_state_if_nonexistent(state_a, state_b):
            """"""
            Adds a new state in the final dfa, which is the
            combination of the input states. The initial and final
            flag is also placed on the new state. If the state already
            exists, its identifier is being returned.
            Args:
                state_a: The fist state identifier
                state_b: The second state identifier
            Returns:
                int: The new state identifier
            """"""
            if (state_a.stateid, state_b.stateid) not in states:
                states[(state_a.stateid, state_b.stateid)] \
                    = self.add_state()
                self[states[(state_a.stateid, state_b.stateid)]].initial \
                    = state_a.initial and state_b.initial
                self[states[(state_a.stateid, state_b.stateid)]].final \
                    = accept_method(state_a.final, state_b.final)
            return states[(state_a.stateid, state_b.stateid)]

        for state1, state2 in product(dfa_1states, dfa_2states):
            sid1 = _add_state_if_nonexistent(state1, state2)
            transitions_s1 = _create_transitions_representation(dfa_1states, state1)
            transitions_s2 = _create_transitions_representation(dfa_2states, state2)
            for char in self.alphabet:
                sid2 = _add_state_if_nonexistent(
                    transitions_s1[char], transitions_s2[char])
                self.add_arc(sid1, sid2, char)"
2485,"def as_list(self):
        """"""
        returns a list version of the object, based on it's attributes
        """"""
        if hasattr(self, 'cust_list'):
            return self.cust_list
        if hasattr(self, 'attr_check'):
            self.attr_check()
        cls_bltns = set(dir(self.__class__))
        ret = [a for a in dir(self) if a not in cls_bltns and getattr(self, a)]
        return ret"
2486,"def as_dict(self):
        """"""
        returns an dict version of the object, based on it's attributes
        """"""
        if hasattr(self, 'cust_dict'):
            return self.cust_dict
        if hasattr(self, 'attr_check'):
            self.attr_check()
        cls_bltns = set(dir(self.__class__))
        return {a: getattr(self, a) for a in dir(self) if a not in cls_bltns}"
2487,"def as_odict(self):
        """"""
        returns an odict version of the object, based on it's attributes
        """"""
        if hasattr(self, 'cust_odict'):
            return self.cust_odict
        if hasattr(self, 'attr_check'):
            self.attr_check()
        odc = odict()
        for attr in self.attrorder:
            odc[attr] = getattr(self, attr)
        return odc"
2488,"def fetch_and_parse(url, bodyLines):
    """"""Takes a url, and returns a dictionary of data with 'bodyLines' lines""""""

    pageHtml = fetch_page(url)
    return parse(url, pageHtml, bodyLines)"
2489,"def find(pos, user):
        '''
        Get a valid CashDiary for today from the given POS, it will return:
            - None: if no CashDiary is available today and older one was already closed
            - New CashDiary: if no CashDiary is available today but there is an older one which it was opened
            - Existing CashDiary: if a CashDiary is available today (open or close)
        '''

        # Get checkpoint
        ck = dateparse.parse_time(getattr(settings, ""CASHDIARY_CLOSES_AT"", '03:00'))
        year = timezone.now().year
        month = timezone.now().month
        day = timezone.now().day
        hour = ck.hour
        minute = ck.minute
        second = ck.second
        checkpoint = timezone.datetime(year, month, day, hour, minute, second)

        # Get
        cashdiary = CashDiary.objects.filter(pos=pos, opened_date__gte=checkpoint).order_by(""-opened_date"").first()
        if not cashdiary:
            # No cashdiary found for today, check older one
            oldercashdiary = CashDiary.objects.filter(pos=pos, opened_date__lt=checkpoint).order_by(""-opened_date"").first()
            if oldercashdiary:
                if oldercashdiary.closed_user:
                    cashdiary = None
                else:
                    # Older cashdiary is not closed, we have to close it and open a new one
                    amount_cash = oldercashdiary.amount_cash()
                    amount_cards = oldercashdiary.amount_cards()
                    # The older cashdiary is still opened, we have to close it and create a new one
                    oldercashdiary.closed_cash = amount_cash
                    oldercashdiary.closed_cards = amount_cards
                    oldercashdiary.closed_user = user
                    oldercashdiary.closed_date = timezone.now()
                    oldercashdiary.save()
                    # Open new cashdiary
                    cashdiary = CashDiary()
                    cashdiary.pos = pos
                    cashdiary.opened_cash = amount_cash
                    cashdiary.opened_cards = amount_cards
                    cashdiary.opened_user = user
                    cashdiary.opened_date = timezone.now()
                    cashdiary.save()
            else:
                # initial new cashdiary
                cashdiary = CashDiary()
                cashdiary.pos = pos
                cashdiary.opened_cash = Decimal('0')
                cashdiary.opened_cards = Decimal('0')
                cashdiary.opened_user = user
                cashdiary.opened_date = timezone.now()
                cashdiary.save()

        # Return the found CashDiary
        return cashdiary"
2490,"def copy_rec(source, dest):
    """"""Copy files between diferent directories.

    Copy one or more files to an existing directory. This function is
    recursive, if the source is a directory, all its subdirectories are created
    in the destination. Existing files in destination are overwrited without
    any warning.

    Args:
        source (str): File or directory name.
        dest (str): Directory name.

    Raises:
        FileNotFoundError: Destination directory doesn't exist.
    """"""

    if os.path.isdir(source):
        for child in os.listdir(source):
            new_dest = os.path.join(dest, child)
            os.makedirs(new_dest, exist_ok=True)
            copy_rec(os.path.join(source, child), new_dest)

    elif os.path.isfile(source):
        logging.info(' Copy ""{}"" to ""{}""'.format(source, dest))
        shutil.copy(source, dest)

    else:
        logging.info(' Ignoring ""{}""'.format(source))"
2491,"def build(self):
        """"""
        Builds this object into the desired output information.
        """"""
        signed = bool(self.options() & Builder.Options.Signed)

        # remove previous build information
        buildpath = self.buildPath()
        if not buildpath:
            raise errors.InvalidBuildPath(buildpath)

        # setup the environment
        for key, value in self.environment().items():
            log.info('SET {0}={1}'.format(key, value))
            os.environ[key] = value

        if os.path.exists(buildpath):
            shutil.rmtree(buildpath)

        # generate the build path for the installer
        os.makedirs(buildpath)

        # create the output path
        outpath = self.outputPath()
        if not os.path.exists(outpath):
            os.makedirs(outpath)

        # copy license information
        src = self.licenseFile()
        if src and os.path.exists(src):
            targ = os.path.join(buildpath, 'license.txt')
            shutil.copyfile(src, targ)

        # generate revision information
        if self.options() & Builder.Options.GenerateRevision:
            self.generateRevision()

        # generate documentation information
        if self.options() & Builder.Options.GenerateDocs:
            self.generateDocumentation(buildpath)

        # generate setup file
        if self.options() & Builder.Options.GenerateSetupFile:
            setuppath = os.path.join(self.sourcePath(), '..')
            egg = (self.options() & Builder.Options.GenerateEgg) != 0
            self.generateSetupFile(setuppath, egg=egg)

        # generate executable information
        if self.options() & Builder.Options.GenerateExecutable:
            if not self.generateExecutable(signed=signed):
                return

        # generate zipfile information
        if self.options() & Builder.Options.GenerateZipFile:
            self.generateZipFile(self.outputPath())

        # generate installer information
        if self.options() & Builder.Options.GenerateInstaller:
            self.generateInstaller(buildpath, signed=signed)"
2492,"def generateExecutable(self, outpath='.', signed=False):
        """"""
        Generates the executable for this builder in the output path.
        
        :param      outpath | <str>
        """"""
        if not (self.runtime() or self.specfile()):
            return True

        if not self.distributionPath():
            return True

        if os.path.exists(self.distributionPath()):
            shutil.rmtree(self.distributionPath())

        if os.path.isfile(self.sourcePath()):
            basepath = os.path.normpath(os.path.dirname(self.sourcePath()))
        else:
            basepath = os.path.normpath(self.sourcePath())

        # store the plugin table of contents
        self.generatePlugins(basepath)

        # generate the specfile if necessary
        specfile = self.specfile()
        # generate the spec file options
        opts = {
            'name': self.name(),
            'exname': self.executableName(),
            'product': self.productName(),
            'runtime': self.runtime(),
            'srcpath': self.sourcePath(),
            'buildpath': self.buildPath(),
            'hookpaths': ',\n'.join(wrap_str(self.hookPaths())),
            'hiddenimports': ',\n'.join(wrap_str(self.hiddenImports())),
            'distpath': self.distributionPath(),
            'platform': sys.platform,
            'excludes': ',\n'.join(wrap_str(self.executableExcludes()))
        }

        if not specfile:
            datasets = []
            for typ, data in self.executableData():
                if typ == 'tree':
                    args = {
                        'path': data[0],
                        'prefix': data[1],
                        'excludes': ','.join(wrap_str(data[2]))
                    }

                    datasets.append(templ.SPECTREE.format(**args))

                else:
                    args = {}
                    args.update(data)
                    args.setdefault('type', typ)
                    datasets.append(templ.SPECDATA.format(**args))

            opts['datasets'] = '\n'.join(datasets)

            opts.update(self._executableOptions)

            if self.executableCliName():
                opts['cliname'] = self.executableCliName()
                opts['collect'] = templ.SPECFILE_CLI.format(**opts)
            else:
                opts['collect'] = templ.SPECFILE_COLLECT.format(**opts)

            if opts['onefile']:
                data = templ.SPECFILE_ONEFILE.format(**opts)
            else:
                data = templ.SPECFILE.format(**opts)

            # generate the spec file for building
            specfile = os.path.join(self.buildPath(), self.name() + '.spec')
            f = open(specfile, 'w')
            f.write(data)
            f.close()

        cmd = os.path.expandvars(self.executableOption('cmd'))
        success = cmdexec(cmd.format(spec=specfile)) == 0
        if signed:
            binfile = os.path.join(opts['distpath'],
                                   opts['product'],
                                   opts['exname'] + '.exe')
            self.sign(binfile)

        return success"
2493,"def generateRevision(self):
        """"""
        Generates the revision file for this builder.
        """"""
        revpath = self.sourcePath()
        if not os.path.exists(revpath):
            return

        # determine the revision location
        revfile = os.path.join(revpath, self.revisionFilename())
        mode = ''
        # test for svn revision
        try:
            args = ['svn', 'info', revpath]
            proc = subprocess.Popen(args, stdout=subprocess.PIPE)
            mode = 'svn'
        except WindowsError:
            try:
                args = ['git', 'rev-parse', 'HEAD', revpath]
                proc = subprocess.Popen(args, stdout=subprocess.PIPE)
                mode = 'git'
            except WindowsError:
                return

        # process SVN revision
        rev = None

        if mode == 'svn':
            for line in proc.stdout:
                data = re.match('^Revision: (\d+)', line)
                if data:
                    rev = int(data.group(1))
                    break

        if rev is not None:
            try:
                f = open(revfile, 'w')
                f.write('__revision__ = {0}\n'.format(rev))
                f.close()
            except IOError:
                pass"
2494,"def generateInstaller(self, outpath='.', signed=False):
        """"""
        Generates the installer for this builder.
        
        :param      outpath | <str>
        """"""
        log.info('Generating Installer....')

        # generate the options for the installer
        opts = {
            'name': self.name(),
            'exname': self.executableName(),
            'version': self.version(),
            'company': self.company(),
            'language': self.language(),
            'license': self.license(),
            'platform': sys.platform,
            'product': self.productName(),
            'outpath': self.outputPath(),
            'instpath': self.installPath(),
            'instname': self.installName(),
            'buildpath': self.buildPath(),
            'srcpath': self.sourcePath(),
            'nsis_exe': os.environ['NSIS_EXE'],
            'signed': '',
            'signcmd': ''
        }

        basetempl = ''
        if self.runtime() and os.path.exists(self.distributionPath()):
            opts['compilepath'] = os.path.join(self.distributionPath(), self.executableName())
            basetempl = templ.NSISAPP

        elif os.path.isfile(self.sourcePath()):
            opts['compilepath'] = self.sourcePath()
            opts['install'] = templ.NSISMODULE.format(**opts)
            basetempl = templ.NSISLIB

        else:
            opts['compilepath'] = self.sourcePath()
            opts['install'] = templ.NSISPACKAGE.format(**opts)
            basetempl = templ.NSISLIB

        # sign the uninstaller
        if signed and self.signcmd():
            cmd = self.signcmd().format(filename='', cert=self.certificate())
            cmd = os.path.expandvars(cmd)
            cmd = cmd.replace('""""', '')

            opts['signed'] = '!define SIGNED'
            opts['signcmd'] = cmd

        opts.update(self._installerOptions)

        # expand the plugin paths
        pre_section_plugins = []
        post_section_plugins = []
        install_plugins = []
        uninstall_plugins = []

        for filename in self.installerOption('pre_section_plugins', []):
            with open(filename, 'r') as f:
                pre_section_plugins.append(f.read().format(**opts))

        for filename in self.installerOption('post_section_plugins', []):
            with open(filename, 'r') as f:
                post_section_plugins.append(f.read().format(**opts))

        for filename in self.installerOption('install_section_plugins', []):
            with open(filename, 'r') as f:
                install_plugins.append(f.read().format(**opts))

        for filename in self.installerOption('uninstall_section_plugins', []):
            with open(filename, 'r') as f:
                uninstall_plugins.append(f.read().formst(**opts))

        opts['install_plugins'] = '\n'.join(install_plugins)
        opts['uninstall_plugins'] = '\n'.join(uninstall_plugins)
        opts['pre_section_plugins'] = '\n'.join(pre_section_plugins)
        opts['post_section_plugins'] = '\n'.join(post_section_plugins)
        opts['choose_directory'] = templ.NSISCHOOSEDIRECTORY if opts['choose_dir'] else ''

        req_license = self._installerOptions.pop('require_license_approval', False)
        if req_license:
            opts['require_license_approval'] = templ.NSISLICENSERADIO
        else:
            opts['require_license_approval'] = ''

        outfile = os.path.join(os.path.abspath(outpath), 'autogen.nsi')
        opts['__file__'] = outfile

        # update the additional directories
        addtl = []
        for directory, source in self._installDirectories.items():
            directory = os.path.expandvars(directory.format(**opts))
            directory = os.path.normpath(directory)

            if source:
                source = os.path.expandvars(source.format(**opts))
                source = os.path.abspath(source)

                addtl.append('    SetOutPath ""{0}""'.format(directory))
                addtl.append('    File /nonfatal /r ""{0}""'.format(source))
            else:
                addtl.append('    CreateDirectory ""{0}""'.format(directory))

        opts['addtl_commands'] = '\n'.join(addtl)
        data = basetempl.format(**opts)

        # create the output file
        f = open(outfile, 'w')
        f.write(data)
        f.close()

        installerfile = os.path.join(self.outputPath(), self.installName())
        installerfile += '-{0}.exe'.format(sys.platform)

        # run the installer
        cmd = os.path.expandvars(self.installerOption('cmd'))
        success = cmdexec(cmd.format(script=outfile))

        # sign the installer
        if signed:
            self.sign(installerfile)

        log.info('Executing installer...')
        cmdexec(installerfile)"
2495,"def generateSetupFile(self, outpath='.', egg=False):
        """"""
        Generates the setup file for this builder.
        """"""
        outpath = os.path.abspath(outpath)
        outfile = os.path.join(outpath, 'setup.py')

        opts = {
            'name': self.name(),
            'distname': self.distributionName(),
            'version': self.version(),
            'author': self.author(),
            'author_email': self.authorEmail(),
            'keywords': self.keywords(),
            'license': self.license(),
            'brief': self.brief(),
            'description': self.description(),
            'url': self.companyUrl()
        }

        wrap_dict = lambda x: map(lambda k: ""r'{0}': [{1}]"".format(k[0],
                                                                   ',\n'.join(wrap_str(k[1]))),
                                  x.items())

        opts['dependencies'] = ',\n'.join(wrap_str(self.dependencies()))
        opts['classifiers'] = ',\n'.join(wrap_str(self.classifiers()))

        if os.path.isfile(self.sourcePath()):
            basepath = os.path.normpath(os.path.dirname(self.sourcePath()))
        else:
            basepath = os.path.normpath(self.sourcePath())

        self.generatePlugins(basepath)

        exts = set()
        for root, folders, files in os.walk(basepath):
            for file_ in files:
                _, ext = os.path.splitext(file_)
                if ext not in ('.py', '.pyc', '.pyo'):
                    exts.add('*' + ext)

        exts = list(exts)
        text = templ.SETUPFILE.format(**opts)

        # generate the file
        if not os.path.exists(outfile):
            f = open(outfile, 'w')
            f.write(text)
            f.close()

        # generate the manifest file
        manfile = os.path.join(outpath, 'MANIFEST.in')
        if not os.path.exists(manfile):
            f = open(manfile, 'w')
            f.write('include *.md *.txt *.ini *.cfg *.rst\n')
            f.write('recursive-include {0} {1}\n'.format(self.name(), ' '.join(exts)))
            f.close()

        # generate the egg
        if egg:
            cmd = 'cd {0} && $PYTHON setup.py bdist_egg'.format(outpath)
            cmd = os.path.expandvars(cmd)
            cmdexec(cmd)"
2496,"def generateZipFile(self, outpath='.'):
        """"""
        Generates the zip file for this builder.
        """"""
        fname = self.installName() + '.zip'
        outfile = os.path.abspath(os.path.join(outpath, fname))

        # clears out the exiting archive
        if os.path.exists(outfile):
            try:
                os.remove(outfile)
            except OSError:
                log.warning('Could not remove zipfile: %s', outfile)
                return False

        # generate the zip file
        zfile = zipfile.ZipFile(outfile, 'w')

        # zip up all relavent fields from the code base
        if os.path.isfile(self.sourcePath()):
            zfile.write(self.sourcePath(), os.path.basename(self.sourcePath()))
        else:
            basepath = os.path.abspath(os.path.join(self.sourcePath(), '..'))
            baselen = len(basepath) + 1
            for root, folders, filenames in os.walk(basepath):
                # ignore hidden folders
                if '.svn' in root or '.git' in root:
                    continue

                # ignore setuptools build info
                part = root[baselen:].split(os.path.sep)[0]
                if part in ('build', 'dist') or part.endswith('.egg-info'):
                    continue

                # include files
                for filename in filenames:
                    ext = os.path.splitext(filename)[1]
                    if ext in self.ignoreFileTypes():
                        continue

                    arcroot = root[baselen:].replace('\\', '/')
                    arcname = os.path.join(arcroot, filename)
                    log.info('Archiving %s...', arcname)
                    zfile.write(os.path.join(root, filename), arcname)

        zfile.close()
        return True"
2497,"def installName(self):
        """"""
        Returns the name for the installer this builder will generate.
        
        :return     <str>
        """"""
        opts = {'name': self.name(), 'version': self.version()}
        if self.revision():
            opts['revision'] = '.{0}'.format(self.revision())
        else:
            opts['revision'] = ''

        if self._installName:
            return self._installName.format(**opts)
        else:
            return '{name}-{version}{revision}'.format(**opts)"
2498,"def licenseFile(self):
        """"""
        Returns the license file for this builder.
        
        :return     <str>
        """"""
        if self._licenseFile:
            return self._licenseFile
        elif self._license:
            f = projex.resources.find('licenses/{0}.txt'.format(self.license()))
            return f
        else:
            return ''"
2499,"def loadXml(self, xdata, filepath=''):
        """"""
        Loads properties from the xml data.
        
        :param      xdata | <xml.etree.ElementTree.Element>
        """"""
        # build options
        opts = {'platform': sys.platform}

        mkpath = lambda x: _mkpath(filepath, x, **opts)

        # lookup environment variables
        xenv = xdata.find('environment')
        if xenv is not None:
            env = {}
            log.info('loading environment...')
            for xkey in xenv:
                text = xkey.text
                if text:
                    env[xkey.tag] = os.path.expandvars(text)
                else:
                    env[xkey.tag] = ''

            self.setEnvironment(env)

        # lookup general settings
        xsettings = xdata.find('settings')
        if xsettings is not None:
            for xsetting in xsettings:
                key = xsetting.tag
                val = xsetting.text
                attr = '_' + key
                if hasattr(self, attr):
                    setattr(self, attr, val)

        # lookup options
        xoptions = xdata.find('options')
        if xoptions is not None:
            options = 0
            for xopt in xoptions:
                key = xopt.tag
                value = xopt.text

                if value.lower() == 'true':
                    try:
                        options |= Builder.Options[key]
                    except KeyError:
                        continue

            self._options = options

        # lookup path options
        xpaths = xdata.find('paths')
        if xpaths is not None:
            for xpath in xpaths:
                key = xpath.tag
                path = xpath.text

                if key.endswith('Paths'):
                    path = map(mkpath, path.split(';'))
                else:
                    path = mkpath(path)

                setattr(self, '_' + key, path)

        # lookup executable options
        xexe = xdata.find('executable')
        if xexe is not None:
            exe_tags = {'runtime': '_runtime',
                        'exe': '_executableName',
                        'cli': '_executableCliName',
                        'product': '_productName'}

            for tag, prop in exe_tags.items():
                xtag = xexe.find(tag)
                if xtag is not None:
                    value = xtag.text
                    if value.startswith('.'):
                        value = mkpath(value)

                    setattr(self, prop, value)

            # load exclude options
            xexcludes = xexe.find('excludes')
            if xexcludes is not None:
                excludes = []
                for xexclude in xexcludes:
                    excludes.append(xexclude.text)
                self.setExecutableExcludes(excludes)

            # load build data
            xexedata = xexe.find('data')
            if xexedata is not None:
                data = []
                for xentry in xexedata:
                    if xentry.tag == 'tree':
                        path = xentry.get('path', '')
                        if path:
                            path = mkpath(path)
                        else:
                            path = self.sourcePath()

                        prefix = xentry.get('prefix', os.path.basename(path))
                        excludes = xentry.get('excludes', '').split(';')

                        if excludes:
                            data.append(('tree', (path, prefix, excludes)))
                    else:
                        for xitem in xentry:
                            data.append((xentry.tag, xitem.attrs))

                self.setExecutableData(data)

            # load hidden imports
            xhiddenimports = xexe.find('hiddenimports')
            if xhiddenimports is not None:
                imports = []
                for ximport in xhiddenimports:
                    imports.append(ximport.text)
                self.setHiddenImports(imports)

            # load options
            xopts = xexe.find('options')
            if xopts is not None:
                for xopt in xopts:
                    if xopt.text.startswith('.'):
                        value = mkpath(xopt.text)
                    else:
                        value = xopt.text
                    self._executableOptions[xopt.tag] = value

        # lookup installer options
        xinstall = xdata.find('installer')
        if xinstall is not None:
            install_tags = {'name': '_installName'}

            for tag, prop in install_tags.items():
                xtag = xinstall.find(tag)
                if xtag is not None:
                    value = xtag.text
                    if value.startswith('.'):
                        value = mkpath(value)
                    setattr(self, prop, value)

            xopts = xinstall.find('options')
            if xopts is not None:
                for xopt in xopts:
                    if xopt.text.startswith('.'):
                        value = mkpath(xopt.text)
                    else:
                        value = xopt.text

                    self._installerOptions[xopt.tag] = value

            xdirectories = xinstall.find('additional_directories')
            if xdirectories is not None:
                for xdir in xdirectories:
                    self._installDirectories[xdir.get('path')] = xdir.get('source', '')"
2500,"def loadYaml(self, ydata, filepath=''):
        """"""
        Loads properties from the yaml data.
        
        :param      ydata | <dict>
        """"""
        # build options
        opts = {'platform': sys.platform}

        mkpath = lambda x: _mkpath(filepath, x, **opts)

        # lookup environment variables
        env = {}
        for key, text in ydata.get('environment', {}).items():
            if text:
                env[key] = os.path.expandvars(text)
            else:
                env[key] = ''

        self.setEnvironment(env)

        # lookup general settings
        for key, val in ydata.get('settings', {}).items():
            attr = '_' + key
            if hasattr(self, attr):
                setattr(self, attr, val)

        # lookup options
        yoptions = ydata.get('options')
        if yoptions is not None:
            options = 0
            for key, value in yoptions.items():
                if value:
                    try:
                        options |= Builder.Options[key]
                    except KeyError:
                        continue

            self._options = options

        # lookup path options
        for key, path in ydata.get('paths', {}).items():
            if key.endswith('Paths'):
                path = map(mkpath, path.split(';'))
            else:
                path = mkpath(path)

            setattr(self, '_' + key, path)

        # lookup executable options
        yexe = ydata.get('executable')
        if yexe is not None:
            exe_tags = {'runtime': '_runtime',
                        'exe': '_executableName',
                        'cli': '_executableCliName',
                        'product': '_productName'}

            for tag, prop in exe_tags.items():
                if tag in yexe:
                    value = yexe.pop(tag)
                    if value.startswith('.'):
                        value = mkpath(value)

                    setattr(self, prop, value)

            # load exclude options
            self.setExecutableExcludes(yexe.get('excludes', []))

            # load build data
            yexedata = yexe.get('data', {})
            if yexedata:
                data = []
                for key, value in yexedata.items():
                    if key == 'tree':
                        path = value.get('path', '')
                        if path:
                            path = mkpath(path)
                        else:
                            path = self.sourcePath()

                        prefix = value.get('prefix', os.path.basename(path))
                        excludes = value.get('excludes', '').split(';')

                        if excludes:
                            data.append(('tree', (path, prefix, excludes)))

                    else:
                        for item in value:
                            data.append((key, item))

                self.setExecutableData(data)

            # load hidden imports
            self.setHiddenImports(yexe.get('hiddenimports', []))

            # load options
            for key, value in yexe.get('options', {}).items():
                value = nstr(value)
                if value.startswith('.'):
                    value = mkpath(value)
                self._executableOptions[key] = value

        # lookup installer options
        yinstall = ydata.get('installer')
        if yinstall is not None:
            install_tags = {'name': '_installName'}

            for tag, prop in install_tags.items():
                if tag in yinstall:
                    value = yinstall.pop(tag, None)
                    if value.startswith('.'):
                        value = mkpath(value)
                    setattr(self, prop, value)

            for key, value in yinstall.get('options', {}).items():
                if type(value) in (unicode, str) and value.startswith('.'):
                    value = mkpath(value)

                self._installerOptions[key] = value

            for path in yinstall.get('additional_directories', []):
                self._installDirectories[path.get('path', '')] = path.get('source', '')"
2501,"def sign(self, filename):
        """"""
        Signs the filename with the certificate associated with this builder.
        
        :param      filename | <str>
        
        :return     <bool> | success
        """"""
        sign = self.signcmd()
        certificate = self.certificate()
        if not sign:
            log.error('No signcmd defined.')
            return False
        elif not certificate and '{cert}' in sign:
            log.error('No sign certificated defined.')
            return False

        log.info('Signing {0}...'.format(filename))
        sign = os.path.expandvars(sign)
        filename = os.path.expandvars(filename)
        cert = os.path.expandvars(certificate)

        # let the previous process finish fully, or we might get some file errors
        time.sleep(2)
        return cmdexec(sign.format(filename=filename, cert=cert)) == 0"
2502,"def plugin(name, module=''):
        """"""
        Returns the plugin for the given name.  By default, the
        base Builder instance will be returned.
        
        :param      name | <str>
        """"""
        if module:
            mod = projex.importfile(module)
            if mod:
                return getattr(mod, nstr(name), None)

        return Builder._plugins.get(nstr(name))"
2503,"def register(plugin, name=None):
        """"""
        Registers the given builder as a plugin to the system.
        
        :param      plugin | <subclass of PackageBuilder>
                    name   | <str> || None
        """"""
        if name is None:
            name = plugin.__name__

        Builder._plugins[nstr(name)] = plugin"
2504,"def fromXml(cls, xdata, filepath=''):
        """"""
        Generates a new builder from the given xml data and then
        loads its information.
        
        :param      xdata | <xml.etree.ElementTree.Element>
        
        :return     <Builder> || None
        """"""
        builder = cls()
        builder.loadXml(xdata, filepath=filepath)
        return builder"
2505,"def fromYaml(cls, ydata, filepath=''):
        """"""
        Generates a new builder from the given yaml data and then
        loads its information.
        
        :param      ydata | <dict>
        
        :return     <Builder> || None
        """"""
        builder = cls()
        builder.loadYaml(ydata, filepath=filepath)
        return builder"
2506,"def fromFile(filename):
        """"""
        Parses the inputted xml file information and generates a builder
        for it.
        
        :param      filename | <str>
        
        :return     <Builder> || None
        """"""
        xdata = None
        ydata = None

        # try parsing an XML file
        try:
            xdata = ElementTree.parse(filename).getroot()
        except StandardError:
            xdata = None

        if xdata is None:
            # try parsing a yaml file
            if yaml:
                with open(filename, 'r') as f:
                    text = f.read()

                try:
                    ydata = yaml.load(text)
                except StandardError:
                    return None
            else:
                log.warning('Could not process yaml builder!')

        # load a yaml definition
        if type(ydata) == dict:
            typ = ydata.get('type')
            module = ydata.get('module')
            builder = Builder.plugin(typ, module)
            if builder:
                return builder.fromYaml(ydata, os.path.dirname(filename))
            else:
                log.warning('Could not find builder: {0}'.format(typ))

        # load an xml definition
        elif xdata is not None:
            typ = xdata.get('type')
            module = xdata.get('module')
            builder = Builder.plugin(typ, module)
            if builder:
                return builder.fromXml(xdata, os.path.dirname(filename))
            else:
                log.warning('Could not find builder: {0}'.format(typ))

        return None"
2507,"def fromXml(cls, xdata, filepath=''):
        """"""
        Generates a new builder from the given xml data and then
        loads its information.
        
        :param      xdata | <xml.etree.ElementTree.Element>
        
        :return     <Builder> || None
        """"""
        module = None
        pkg_data = xdata.find('package')
        if pkg_data is not None:
            path = pkg_data.find('path').text
            name = pkg_data.find('name').text

            if filepath:
                path = os.path.join(filepath, path)

            path = os.path.abspath(path)
            sys.path.insert(0, path)
            sys.modules.pop(name, None)

            try:
                __import__(name)
                module = sys.modules[name]
            except (ImportError, KeyError):
                return None
        else:
            return None

        # generate the builder
        builder = cls(module)
        builder.loadXml(xdata, filepath=filepath)
        return builder"
2508,"def fromYaml(cls, ydata, filepath=''):
        """"""
        Generates a new builder from the given xml data and then
        loads its information.
        
        :param      ydata | <xml.etree.ElementTree.Element>
        
        :return     <Builder> || None
        """"""
        module = None
        pkg_data = ydata.get('package')
        if pkg_data is not None:
            path = pkg_data.get('path', '')
            name = pkg_data.get('name', '')

            if filepath:
                path = os.path.join(filepath, path)

            path = os.path.abspath(path)
            sys.path.insert(0, path)
            sys.modules.pop(name, None)

            try:
                __import__(name)
                module = sys.modules[name]
            except (ImportError, KeyError):
                return None
        else:
            return None

        # generate the builder
        builder = cls(module)
        builder.loadYaml(ydata, filepath=filepath)
        return builder"
2509,"def to_object(item):
        """"""
        Convert a dictionary to an object (recursive).
        """"""
        def convert(item): 
            if isinstance(item, dict):
                return IterableObject({k: convert(v) for k, v in item.items()})
            if isinstance(item, list):
                def yield_convert(item):
                    for index, value in enumerate(item):
                        yield convert(value)
                return list(yield_convert(item))
            else:
                return item

        return convert(item)"
2510,"def to_dict(item):
        """"""
        Convert an object to a dictionary (recursive).
        """"""
        def convert(item):
            if isinstance(item, IterableObject):
                if isinstance(item.source, dict):
                    return {k: convert(v.source) if hasattr(v, 'source') else convert(v) for k, v in item}
                else:
                    return convert(item.source)
            elif isinstance(item, dict):
                return {k: convert(v) for k, v in item.items()}
            elif isinstance(item, list):
                def yield_convert(item):
                    for index, value in enumerate(item):
                        yield convert(value)
                return list(yield_convert(item))
            else:
                return item

        return convert(item)"
2511,"def step_undefined_step_snippet_should_exist_for(context, step):
    """"""
    Checks if an undefined-step snippet is provided for a step
    in behave command output (last command).

    EXAMPLE:
        Then an undefined-step snippet should exist for ""Given an undefined step""
    """"""
    undefined_step_snippet = make_undefined_step_snippet(step)
    context.execute_steps(u'''\
Then the command output should contain:
    """"""
    {undefined_step_snippet}
    """"""
    '''.format(undefined_step_snippet=text_indent(undefined_step_snippet, 4)))"
2512,"def step_undefined_step_snippet_should_not_exist_for(context, step):
    """"""
    Checks if an undefined-step snippet is provided for a step
    in behave command output (last command).
    """"""
    undefined_step_snippet = make_undefined_step_snippet(step)
    context.execute_steps(u'''\
Then the command output should not contain:
    """"""
    {undefined_step_snippet}
    """"""
    '''.format(undefined_step_snippet=text_indent(undefined_step_snippet, 4)))"
2513,"def step_undefined_step_snippets_should_exist_for_table(context):
    """"""
    Checks if undefined-step snippets are provided.

    EXAMPLE:
        Then undefined-step snippets should exist for:
            | Step |
            | When an undefined step is used |
            | Then another undefined step is used |
    """"""
    assert context.table, ""REQUIRES: table""
    for row in context.table.rows:
        step = row[""Step""]
        step_undefined_step_snippet_should_exist_for(context, step)"
2514,"def step_undefined_step_snippets_should_not_exist_for_table(context):
    """"""
    Checks if undefined-step snippets are not provided.

    EXAMPLE:
        Then undefined-step snippets should not exist for:
            | Step |
            | When an known step is used |
            | Then another known step is used |
    """"""
    assert context.table, ""REQUIRES: table""
    for row in context.table.rows:
        step = row[""Step""]
        step_undefined_step_snippet_should_not_exist_for(context, step)"
2515,"async def create_connection(
    host,
    port,
    *,
    loop=None,
    secure=True,
    ssl_context=None,
    **kwargs,
):
    """"""Open an HTTP/2 connection to the specified host/port.
    """"""
    loop = loop or asyncio.get_event_loop()

    secure = True if port == 443 else secure
    connection = HTTP2ClientConnection(host, loop=loop, secure=secure)
    if not isinstance(ssl_context, SSLContext):
        ssl_context = default_ssl_context()

    await loop.create_connection(
        lambda: connection,
        host=host,
        port=port,
        ssl=ssl_context,
    )

    return connection"
2516,"def mixin (cls):
    """"""
    A decorator which adds event methods to a class giving it the ability to
    bind to and trigger events

    :param cls: the class to add the event logic to
    :type cls: class
    :return: the modified class
    :rtype: class
    """"""
    cls._events = {}
    cls.bind = Pyevent.bind.__func__
    cls.unbind = Pyevent.unbind.__func__
    cls.trigger = Pyevent.trigger.__func__
    return cls"
2517,"def bind (self, event, callback):
        """"""
        Bind an event to a call function and ensure that it is called for the
        specified event
        :param event: the event that should trigger the callback
        :type event: str
        :param callback: the function that should be called
        :rtype callback: function
        """"""
        if self._events.has_key(event):
            self._events[event].append(callback)
        else:
            self._events[event] = [callback]"
2518,"def unbind (self, event, callback):
        """"""
        Unbind the callback from the event and ensure that it is never called
        :param event: the event that should be unbound
        :type event: str
        :param callback: the function that should be unbound
        :rtype callback: function
        """"""
        if self._events.has_key(event) and len(self._events[event]) > 0:
            for _callback in self._events[event]:
                if _callback == callback:
                    self._events[event].remove(callback)
                if len(self._events[event]) == 0:
                    del self._events[event]"
2519,"def trigger (self, event, *args, **kwargs):
        """"""
        Cause the callbacks associated with the event to be called
        :param event: the event that occurred
        :type event: str
        :param data: optional data to pass to the callback
        :type data: anything that should be passed to the callback
        """"""
        if self._events.has_key(event):
            for _callback in self._events[event]:
                try:
                    _callback(args, kwargs)
                except TypeError:
                    _callback()"
2520,"def get_wordlist(lang, wl_dir, po_path):
        #print(""Looking for Wordlist in:\nlang {}\nwl_dir {}\npo_path {}"".format(lang, wl_dir, po_path))
        po_path = os.path.abspath(po_path)

        """"""
        If wl_dir is given, there may be a file called ""<lang>.txt"". If this is
        the case, this should be the wordlist we are looking for.
        """"""
        if wl_dir is not None:
            wl_path = os.path.join(wl_dir, lang + '.txt')
            if os.path.isfile(wl_path):
                return wl_path

        """"""
        If wl_dir is not given, the wordlist should live in a file named
        ""wordlist.txt"" either in the locales_dir for the default language or in
        the same directory as the .po-files
        """"""
        if po_path.endswith(""po""):
            # translated language
            po_dir = os.path.dirname(po_path)
            for f in os.scandir(po_dir):
                if f.name == ""wordlist.txt"":
                    #print(""found wordlist in"", f.path)
                    return f.path
            #print(""Checked po-dir, None Found"")

            """"""
            If no file was found so far, the po-files seem to lie in
            <lang>/LC_MESSAGES, and the wordlist should be in the directory
            above.
            """"""
            if os.path.basename(po_dir) == ""LC_MESSAGES"":
                for f in os.scandir(os.path.join(po_dir, "".."")):
                    if f.name == ""wordlist.txt"":
                        #print(""found wordlist in"", f.path)
                        return f.path
            #print(""Checked LC_MESSAGES-dir. none found"")
        #print(""Checked lang-specific files"")

        if os.path.isdir(po_path):
            # default language
            for f in os.scandir(po_path):
                if f.name == ""wordlist.txt"":
                    #print(""found wordlist in"", f.path)
                    return f.path
        #print(""If this shows up, no wordlist was found"")
        return None"
2521,"def _read_options(paths,fname_def=None):
    """"""Builds a configuration reader function""""""
    def reader_func(fname=fname_def, sect=None, sett=None, default=None):
        """"""Reads the configuration for trump""""""

        cur_dir = os.path.dirname(os.path.realpath(__file__))
        config_dir = os.path.join(cur_dir, *paths)

        config_files = [(f[:-4], f)
                        for f in os.listdir(config_dir) if f[-4:] == "".cfg""]
        sample_files = [(f[:-11], f)
                        for f in os.listdir(config_dir) if f[-11:] == "".cfg_sample""]

        if fname:
            config_files = [f for f in config_files if f[0] == fname]
            sample_files = [f for f in sample_files if f[0] == fname]


        config_files = dict(config_files)
        sample_files = dict(sample_files)

        cfg_files = sample_files
        for fn, f in config_files.iteritems():
            cfg_files[fn] = f

        sample_files_exposed = []

        confg = {}

        for src, fil in cfg_files.iteritems():
            confg[src] = {}
            cfpr = ConfigParser.ConfigParser()
            cfpr.read(os.path.join(config_dir, fil))
            for sec in cfpr.sections():
                confg[src][sec] = dict(cfpr.items(sec))

            if "".cfg_sample"" in fil:
                sample_files_exposed.append(fil)


        if len(sample_files_exposed) > 0:
            msg = "", "".join(sample_files_exposed)
            body = ""{} sample configuration files have been exposed. "" \
                  ""Rename *.cfg_sample to *.cfg, and populate the "" \
                  ""correct settings in the config and settings "" \
                  ""directories to avoid this warning.""
            msg = body.format(msg)
            warnings.warn(msg)

        keys = []

        if fname:
            keys.append(fname)
            if sect:
                keys.append(sect)
                if sett:
                    keys.append(sett)
        try:
            return get_from_nested(keys, confg)
        except KeyError:
            if default is not None:
                return default
            else:
                raise

    return reader_func"
2522,"def returnLabelStateMassDifferences(peptide, labelDescriptor, labelState=None,
                                    sequence=None):
    """"""Calculates the mass difference for alternative possible label states of a
    given peptide. See also :class:`LabelDescriptor`, :func:`returnLabelState()`


    :param peptide: Peptide to calculate alternative label states
    :param labelDescriptor: :class:`LabelDescriptor` describes the label setup
        of an experiment
    :param labelState: label state of the peptide, if None it is calculated by
        :func:`returnLabelState()`
    :param sequence: unmodified amino acid sequence of the ""peptide"", if None
        it is generated by :func:`maspy.peptidemethods.removeModifications()`

    :returns: {alternativeLabelSate: massDifference, ...} or {} if the peptide
        label state is -1.

    .. note:: The massDifference plus the peptide mass is the expected mass of
        an alternatively labeled peptide
    """"""
    if labelState is None:
        labelState = returnLabelState(peptide, labelDescriptor)
    if sequence is None:
        sequence = maspy.peptidemethods.removeModifications(peptide)

    if labelState < 0:
        # special case for mixed label... #
        return dict()

    # define type and number of labels of the peptide
    labelModNumbers = dict()
    _positions = expectedLabelPosition(peptide,
                                       labelDescriptor.labels[labelState],
                                       sequence=sequence)
    for labelStateModList in viewvalues(_positions):
        for labelMod in labelStateModList:
            labelModNumbers.setdefault(labelMod, int())
            labelModNumbers[labelMod] += 1

    # calculate the combined labels mass of the peptide
    labelMass = int()
    for labelMod, modCounts in viewitems(labelModNumbers):
        labelMass += maspy.constants.aaModMass[labelMod] * modCounts

    # calculate mass differences to all other possible label states
    labelStateMassDifferences = dict()
    for possibleLabelState in viewkeys(labelDescriptor.labels):
        if possibleLabelState == labelState:
            continue

        labelModNumbers = dict()
        _positions = expectedLabelPosition(peptide,
                                           labelDescriptor.labels[possibleLabelState],
                                           sequence=sequence)
        for labelStateModList in viewvalues(_positions):
            for labelMod in labelStateModList:
                labelModNumbers.setdefault(labelMod, int())
                labelModNumbers[labelMod] += 1

        possibleLabelMass = int()
        for labelMod, modCounts in viewitems(labelModNumbers):
            possibleLabelMass += maspy.constants.aaModMass[labelMod] * modCounts

        possibleLabelMassDifference = possibleLabelMass - labelMass
        labelStateMassDifferences[possibleLabelState] = possibleLabelMassDifference
    return labelStateMassDifferences"
2523,"def returnLabelState(peptide, labelDescriptor, labelSymbols=None,
                     labelAminoacids=None):
    """"""Calculates the label state of a given peptide for the label setup
    described in labelDescriptor

    :param peptide: peptide which label state should be calcualted
    :param labelDescriptor: :class:`LabelDescriptor`, describes the label setup
        of an experiment.
    :param labelSymbols: modifications that show a label, as returned by
        :func:`modSymbolsFromLabelInfo`.
    :param labelAminoacids: amino acids that can bear a label, as returned by
        :func:`modAminoacidsFromLabelInfo`.

    :returns: integer that shows the label state:
        >=0: predicted label state of the peptide
         -1: peptide sequence can't bear any labelState modifications
         -2: peptide modifications don't fit to any predicted labelState
         -3: peptide modifications fit to a predicted labelState, but not all
             predicted labelStates are distinguishable
    """"""
    if labelSymbols is None:
        labelSymbols = modSymbolsFromLabelInfo(labelDescriptor)
    if labelAminoacids is None:
        labelAminoacids = modAminoacidsFromLabelInfo(labelDescriptor)

    sequence = maspy.peptidemethods.removeModifications(peptide)
    modPositions = maspy.peptidemethods.returnModPositions(peptide,
                                                           indexStart=0,
                                                           removeModString=False)

    labelState = None
    #No amino acids in sequence which can bear a label modification
    #Note: at the moment presence of excluding modifications are ignored
    _validator = lambda seq, aa: (True if seq.find(aa) == -1 else False)
    if all([_validator(sequence, aa) for aa in labelAminoacids]):
        #No terminal label modifications specified by labelDescriptor
        if 'nTerm' not in labelAminoacids and 'cTerm' not in labelAminoacids:
            labelState = -1

    # Check if the peptide mofidifcations fit to any predicted label state
    if labelState is None:
        peptideLabelPositions = dict()
        for labelSymbol in labelSymbols:
            if labelSymbol in viewkeys(modPositions):
                for sequencePosition in modPositions[labelSymbol]:
                    peptideLabelPositions.setdefault(sequencePosition, list())
                    peptideLabelPositions[sequencePosition].append(labelSymbol)
        for sequencePosition in list(viewkeys(peptideLabelPositions)):
            peptideLabelPositions[sequencePosition] = \
                sorted(peptideLabelPositions[sequencePosition])

        predictedLabelStates = dict()
        for predictedLabelState, labelStateInfo in viewitems(labelDescriptor.labels):
            expectedLabelMods = expectedLabelPosition(peptide, labelStateInfo,
                                                      sequence=sequence,
                                                      modPositions=modPositions)
            predictedLabelStates[predictedLabelState] = expectedLabelMods
            if peptideLabelPositions == expectedLabelMods:
                #If another expectedLabel state has already been matched, then
                #there is an ambiguity between label states ...
                labelState = predictedLabelState

    if labelState is None:
        # Peptide mofidifcations don't fit to any predicted label state
        labelState = -2
    elif labelState != -1:
        # Check if all predicted label states are distinguishable
        _comb = set(itertools.combinations(range(len(predictedLabelStates)), 2))
        for state1, state2 in _comb:
            if predictedLabelStates[state1] == predictedLabelStates[state2]:
                labelState = -3
                break

    return labelState"
2524,"def modSymbolsFromLabelInfo(labelDescriptor):
    """"""Returns a set of all modiciation symbols which were used in the
    labelDescriptor

    :param labelDescriptor: :class:`LabelDescriptor` describes the label setup
        of an experiment

    :returns: #TODO: docstring
    """"""
    modSymbols = set()
    for labelStateEntry in viewvalues(labelDescriptor.labels):
        for labelPositionEntry in viewvalues(labelStateEntry['aminoAcidLabels']):
            for modSymbol in aux.toList(labelPositionEntry):
                if modSymbol != '':
                    modSymbols.add(modSymbol)
    return modSymbols"
2525,"def modAminoacidsFromLabelInfo(labelDescriptor):
    """"""Returns a set of all amino acids and termini which can bear a label, as
    described in ""labelDescriptor"".

    :param labelDescriptor: :class:`LabelDescriptor` describes the label setup
        of an experiment

    :returns: #TODO: docstring
    """"""
    modAminoacids = set()
    for labelStateEntry in viewvalues(labelDescriptor.labels):
        for labelPositionEntry in viewkeys(labelStateEntry['aminoAcidLabels']):
            for modAminoacid in aux.toList(labelPositionEntry):
                if modAminoacid != '':
                    modAminoacids.add(modAminoacid)
    return modAminoacids"
2526,"def expectedLabelPosition(peptide, labelStateInfo, sequence=None,
                          modPositions=None):
    """"""Returns a modification description of a certain label state of a peptide.

    :param peptide: Peptide sequence used to calculat the expected label state
        modifications
    :param labelStateInfo: An entry of :attr:`LabelDescriptor.labels` that
        describes a label state
    :param sequence: unmodified amino acid sequence of :var:`peptide`, if None
        it is generated by :func:`maspy.peptidemethods.removeModifications()`
    :param modPositions: dictionary describing the modification state of
        ""peptide"", if None it is generated by
        :func:`maspy.peptidemethods.returnModPositions()`

    :returns: {sequence position: sorted list of expected label modifications
                  on that position, ...
               }
    """"""
    if modPositions is None:
        modPositions = maspy.peptidemethods.returnModPositions(peptide,
                                                               indexStart=0
                                                               )
    if sequence is None:
        sequence = maspy.peptidemethods.removeModifications(peptide)

    currLabelMods = dict()
    for labelPosition, labelSymbols in viewitems(labelStateInfo['aminoAcidLabels']):
        labelSymbols = aux.toList(labelSymbols)
        if labelSymbols == ['']:
            pass
        elif labelPosition == 'nTerm':
            currLabelMods.setdefault(0, list())
            currLabelMods[0].extend(labelSymbols)
        else:
            for sequencePosition in aux.findAllSubstrings(sequence,
                                                          labelPosition):
                currLabelMods.setdefault(sequencePosition, list())
                currLabelMods[sequencePosition].extend(labelSymbols)

    if labelStateInfo['excludingModifications'] is not None:
        for excludingMod, excludedLabelSymbol in viewitems(labelStateInfo['excludingModifications']):
            if excludingMod not in modPositions:
                continue
            for excludingModPos in modPositions[excludingMod]:
                if excludingModPos not in currLabelMods:
                    continue
                if excludedLabelSymbol not in currLabelMods[excludingModPos]:
                    continue
                if len(currLabelMods[excludingModPos]) == 1:
                    del(currLabelMods[excludingModPos])
                else:
                    excludedModIndex = currLabelMods[excludingModPos].index(excludedLabelSymbol)
                    currLabelMods[excludingModPos].pop(excludedModIndex)

    for sequencePosition in list(viewkeys(currLabelMods)):
        currLabelMods[sequencePosition] = sorted(currLabelMods[sequencePosition])
    return currLabelMods"
2527,"def addLabel(self, aminoAcidLabels, excludingModifications=None):
        """"""Adds a new labelstate.

        :param aminoAcidsLabels: Describes which amino acids can bear which
            labels. Possible keys are the amino acids in one letter code and
            'nTerm', 'cTerm'. Possible values are the modifications ids from
            :attr:`maspy.constants.aaModMass` as strings or a list of strings.
            An example for one expected label at the n-terminus and two expected
                labels at each Lysine:
                ``{'nTerm': 'u:188', 'K': ['u:188', 'u:188']}``
        :param excludingModifications: optional, A Dectionary that describes
            which modifications can prevent the addition of labels. Keys and
            values have to be the modifications ids from
            :attr:`maspy.constants.aaModMass`. The key specifies the
            modification that prevents the label modification specified by the
            value. For example for each modification 'u:1' that is present at an
            amino acid or terminus of a peptide the number of expected labels at
            this position is reduced by one: ``{'u:1':'u:188'}``

        """"""
        if excludingModifications is not None:
            self.excludingModifictions = True

        labelEntry = {'aminoAcidLabels': aminoAcidLabels,
                      'excludingModifications': excludingModifications
                      }
        self.labels[self._labelCounter] = labelEntry
        self._labelCounter += 1"
2528,"def get_gen_slice(ctx=Bubble(), iterable=[], amount=-1, index=-1):
    """"""very crude way of slicing a generator""""""
    ctx.gbc.say('get_gen_slice', stuff=iterable, verbosity=10)

    i = -1
    # TODO
    # i = 0 #NATURAL INDEX, this will break all features with exports and -p

    if amount > 0:
        if index < 0:
            index = 0
    else:
        for item in iterable:
            i += 1
            item[buts('index')] = i
            ctx.gbc.say('Get gen NO slice:item %d' % i, verbosity=100)
            ctx.gbc.say('Get gen NO slice:a:%d i:%d' %
                        (amount, index), verbosity=100)
            ctx.gbc.say('Get gen NO slice:item', stuff=item, verbosity=1000)
            yield item

    until = index + amount
    if six.PY2:
        sli = xrange(index, until)
    else:
        sli = range(index, until)

    ctx.gbc.say('Get gen slice:range %s' % str(sli), verbosity=1000)

    # TODO: iterable should be empty if not slicing
    # if valid slice ...
    for item in iterable:
        i += 1
        if i in sli:
            ctx.gbc.say('Get gen slice:item %d' % i, verbosity=100)
            ctx.gbc.say('Get gen slice:a:%d i:%d' %
                        (amount, index), verbosity=100)
            ctx.gbc.say('Get gen slice:item', stuff=item, verbosity=1000)
            item[buts('index')] = i
            yield item
        elif i > until:
            break
        else:
            pass"
2529,"def deploy_schema_to_db(self, mode='safe', files_deployment=None, vcs_ref=None, vcs_link=None,
                            issue_ref=None, issue_link=None, compare_table_scripts_as_int=False,
                            config_path=None, config_dict=None, config_object=None, source_code_path=None,
                            auto_commit=False):
        """"""
        Deploys schema
        :param files_deployment: if specific script to be deployed, only find them
        :param mode:
        :param vcs_ref:
        :param vcs_link:
        :param issue_ref:
        :param issue_link:
        :param compare_table_scripts_as_int:
        :param config_path:
        :param config_dict:
        :param config_object:
        :param source_code_path:
        :param auto_commit:
        :return: dictionary of the following format:
            {
                code: 0 if all fine, otherwise something else,
                message: message on the output
                function_scripts_requested: list of function files requested for deployment
                function_scripts_deployed: list of function files deployed
                type_scripts_requested: list of type files requested for deployment
                type_scripts_deployed: list of type files deployed
                view_scripts_requested: list of view files requested for deployment
                view_scripts_deployed: list of view files deployed
                trigger_scripts_requested: list of trigger files requested for deployment
                trigger_scripts_deployed: list of trigger files deployed
                table_scripts_requested: list of table files requested for deployment
                table_scripts_deployed: list of table files deployed
                requested_files_count: count of requested files to deploy
                deployed_files_count: count of deployed files
            }
        :rtype: dict
        """"""

        return_value = {}
        if files_deployment:
            return_value['function_scripts_requested'] = files_deployment
            return_value['type_scripts_requested'] = []
            return_value['view_scripts_requested'] = []
            return_value['trigger_scripts_requested'] = []
            return_value['table_scripts_requested'] = []

        if auto_commit:
            if mode == 'safe' and files_deployment:
                self._logger.debug(""Auto commit mode is on. Be careful."")
            else:
                self._logger.error(""Auto commit deployment can only be done with file ""
                                   ""deployments and in safe mode for security reasons"")
                raise ValueError(""Auto commit deployment can only be done with file ""
                                 ""deployments and in safe mode for security reasons"")

        # set source code path if exists
        self._source_code_path = self._source_code_path or source_code_path

        # set configuration if either of config_path, config_dict, config_object are set.
        # Otherwise use configuration from class initialisation
        if config_object:
            self._config = config_object
        elif config_path or config_dict:
            self._config = pgpm.lib.utils.config.SchemaConfiguration(config_path, config_dict, self._source_code_path)

        # Check if in git repo
        if not vcs_ref:
            if pgpm.lib.utils.vcs.is_git_directory(self._source_code_path):
                vcs_ref = pgpm.lib.utils.vcs.get_git_revision_hash(self._source_code_path)
                self._logger.debug('commit reference to be deployed is {0}'.format(vcs_ref))
            else:
                self._logger.debug('Folder is not a known vcs repository')

        self._logger.debug('Configuration of package {0} of version {1} loaded successfully.'
                           .format(self._config.name, self._config.version.raw))  # TODO: change to to_string once discussed
        # .format(self._config.name, self._config.version.to_string()))

        # Get scripts
        type_scripts_dict = self._get_scripts(self._config.types_path, files_deployment,
                                              ""types"", self._source_code_path)
        if not files_deployment:
            return_value['type_scripts_requested'] = [key for key in type_scripts_dict]

        function_scripts_dict = self._get_scripts(self._config.functions_path, files_deployment,
                                                  ""functions"", self._source_code_path)
        if not files_deployment:
            return_value['function_scripts_requested'] = [key for key in function_scripts_dict]

        view_scripts_dict = self._get_scripts(self._config.views_path, files_deployment,
                                              ""views"", self._source_code_path)
        if not files_deployment:
            return_value['view_scripts_requested'] = [key for key in view_scripts_dict]

        trigger_scripts_dict = self._get_scripts(self._config.triggers_path, files_deployment,
                                                 ""triggers"", self._source_code_path)
        if not files_deployment:
            return_value['trigger_scripts_requested'] = [key for key in trigger_scripts_dict]

        # before with table scripts only file name was an identifier. Now whole relative path the file
        # (relative to config.json)
        # table_scripts_dict_denormalised = self._get_scripts(self._config.tables_path, files_deployment,
        #                                                     ""tables"", self._source_code_path)
        # table_scripts_dict = {os.path.split(k)[1]: v for k, v in table_scripts_dict_denormalised.items()}
        table_scripts_dict = self._get_scripts(self._config.tables_path, files_deployment,
                                               ""tables"", self._source_code_path)
        if not files_deployment:
            return_value['table_scripts_requested'] = [key for key in table_scripts_dict]

        if self._conn.closed:
            self._conn = psycopg2.connect(self._connection_string, connection_factory=pgpm.lib.utils.db.MegaConnection)
        cur = self._conn.cursor()

        # be cautious, dangerous thing
        if auto_commit:
            self._conn.autocommit = True

        # Check if DB is pgpm enabled
        if not pgpm.lib.utils.db.SqlScriptsHelper.schema_exists(cur, self._pgpm_schema_name):
            self._logger.error('Can\'t deploy schemas to DB where pgpm was not installed. '
                               'First install pgpm by running pgpm install')
            self._conn.close()
            sys.exit(1)

        # check installed version of _pgpm schema.
        pgpm_v_db_tuple = pgpm.lib.utils.db.SqlScriptsHelper.get_pgpm_db_version(cur, self._pgpm_schema_name)
        pgpm_v_db = distutils.version.StrictVersion(""."".join(pgpm_v_db_tuple))
        pgpm_v_script = distutils.version.StrictVersion(pgpm.lib.version.__version__)
        if pgpm_v_script > pgpm_v_db:
            self._logger.error('{0} schema version is outdated. Please run pgpm install --upgrade first.'
                               .format(self._pgpm_schema_name))
            self._conn.close()
            sys.exit(1)
        elif pgpm_v_script < pgpm_v_db:
            self._logger.error('Deployment script\'s version is lower than the version of {0} schema '
                               'installed in DB. Update pgpm script first.'.format(self._pgpm_schema_name))
            self._conn.close()
            sys.exit(1)

        # Resolve dependencies
        list_of_deps_ids = []
        if self._config.dependencies:
            _is_deps_resolved, list_of_deps_ids, _list_of_unresolved_deps = \
                self._resolve_dependencies(cur, self._config.dependencies)
            if not _is_deps_resolved:
                self._logger.error('There are unresolved dependencies. Deploy the following package(s) and try again:')
                for unresolved_pkg in _list_of_unresolved_deps:
                    self._logger.error('{0}'.format(unresolved_pkg))
                self._conn.close()
                sys.exit(1)

        # Prepare and execute preamble
        _deployment_script_preamble = pkgutil.get_data('pgpm', 'lib/db_scripts/deploy_prepare_config.sql')
        self._logger.debug('Executing a preamble to deployment statement')
        cur.execute(_deployment_script_preamble)

        # Get schema name from project configuration
        schema_name = ''
        if self._config.scope == pgpm.lib.utils.config.SchemaConfiguration.SCHEMA_SCOPE:
            if self._config.subclass == 'versioned':
                schema_name = '{0}_{1}'.format(self._config.name, self._config.version.raw)

                self._logger.debug('Schema {0} will be updated'.format(schema_name))
            elif self._config.subclass == 'basic':
                schema_name = '{0}'.format(self._config.name)
                if not files_deployment:
                    self._logger.debug('Schema {0} will be created/replaced'.format(schema_name))
                else:
                    self._logger.debug('Schema {0} will be updated'.format(schema_name))

        # Create schema or update it if exists (if not in production mode) and set search path
        if files_deployment:  # if specific scripts to be deployed
            if self._config.scope == pgpm.lib.utils.config.SchemaConfiguration.SCHEMA_SCOPE:
                if not pgpm.lib.utils.db.SqlScriptsHelper.schema_exists(cur, schema_name):
                    self._logger.error('Can\'t deploy scripts to schema {0}. Schema doesn\'t exist in database'
                                       .format(schema_name))
                    self._conn.close()
                    sys.exit(1)
                else:
                    pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, schema_name)
                    self._logger.debug('Search_path was changed to schema {0}'.format(schema_name))
        else:
            if self._config.scope == pgpm.lib.utils.config.SchemaConfiguration.SCHEMA_SCOPE:
                if not pgpm.lib.utils.db.SqlScriptsHelper.schema_exists(cur, schema_name):
                    pgpm.lib.utils.db.SqlScriptsHelper.create_db_schema(cur, schema_name)
                elif mode == 'safe':
                    self._logger.error('Schema already exists. It won\'t be overriden in safe mode. '
                                       'Rerun your script with ""-m moderate"", ""-m overwrite"" or ""-m unsafe"" flags')
                    self._conn.close()
                    sys.exit(1)
                elif mode == 'moderate':
                    old_schema_exists = True
                    old_schema_rev = 0
                    while old_schema_exists:
                        old_schema_exists = pgpm.lib.utils.db.SqlScriptsHelper.schema_exists(
                            cur, schema_name + '_' + str(old_schema_rev))
                        if old_schema_exists:
                            old_schema_rev += 1
                    old_schema_name = schema_name + '_' + str(old_schema_rev)
                    self._logger.debug('Schema already exists. It will be renamed to {0} in moderate mode. Renaming...'
                                       .format(old_schema_name))
                    _rename_schema_script = ""ALTER SCHEMA {0} RENAME TO {1};\n"".format(schema_name, old_schema_name)
                    cur.execute(_rename_schema_script)
                    # Add metadata to pgpm schema
                    pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, self._pgpm_schema_name)
                    cur.callproc('_set_revision_package'.format(self._pgpm_schema_name),
                                 [self._config.name,
                                  self._config.subclass,
                                  old_schema_rev,
                                  self._config.version.major,
                                  self._config.version.minor,
                                  self._config.version.patch,
                                  self._config.version.pre])
                    self._logger.debug('Schema {0} was renamed to {1}. Meta info was added to {2} schema'
                                       .format(schema_name, old_schema_name, self._pgpm_schema_name))
                    pgpm.lib.utils.db.SqlScriptsHelper.create_db_schema(cur, schema_name)
                elif mode == 'unsafe':
                    _drop_schema_script = ""DROP SCHEMA {0} CASCADE;\n"".format(schema_name)
                    cur.execute(_drop_schema_script)
                    self._logger.debug('Dropping old schema {0}'.format(schema_name))
                    pgpm.lib.utils.db.SqlScriptsHelper.create_db_schema(cur, schema_name)

        if self._config.scope == pgpm.lib.utils.config.SchemaConfiguration.SCHEMA_SCOPE:
            pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, schema_name)

        # Reordering and executing types
        return_value['type_scripts_deployed'] = []
        if len(type_scripts_dict) > 0:
            types_script = '\n'.join([''.join(value) for key, value in type_scripts_dict.items()])
            type_drop_scripts, type_ordered_scripts, type_unordered_scripts = self._reorder_types(types_script)
            if type_drop_scripts:
                for statement in type_drop_scripts:
                    if statement:
                        cur.execute(statement)
            if type_ordered_scripts:
                for statement in type_ordered_scripts:
                    if statement:
                        cur.execute(statement)
            if type_unordered_scripts:
                for statement in type_unordered_scripts:
                    if statement:
                        cur.execute(statement)
            self._logger.debug('Types loaded to schema {0}'.format(schema_name))
            return_value['type_scripts_deployed'] = [key for key in type_scripts_dict]
        else:
            self._logger.debug('No type scripts to deploy')

        # Executing Table DDL scripts
        executed_table_scripts = []
        return_value['table_scripts_deployed'] = []
        if len(table_scripts_dict) > 0:
            if compare_table_scripts_as_int:
                sorted_table_scripts_dict = collections.OrderedDict(sorted(table_scripts_dict.items(),
                                                                           key=lambda t: int(t[0].rsplit('.', 1)[0])))
            else:
                sorted_table_scripts_dict = collections.OrderedDict(sorted(table_scripts_dict.items(),
                                                                           key=lambda t: t[0].rsplit('.', 1)[0]))

            self._logger.debug('Running Table DDL scripts')
            for key, value in sorted_table_scripts_dict.items():
                pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, self._pgpm_schema_name)
                cur.callproc('_is_table_ddl_executed'.format(self._pgpm_schema_name), [
                    key,
                    self._config.name,
                    self._config.subclass,
                    self._config.version.major,
                    self._config.version.minor,
                    self._config.version.patch,
                    self._config.version.pre
                ])
                is_table_executed = cur.fetchone()[0]
                if self._config.scope == pgpm.lib.utils.config.SchemaConfiguration.SCHEMA_SCOPE:
                    pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, schema_name)
                elif self._config.scope == pgpm.lib.utils.config.SchemaConfiguration.DATABASE_SCOPE:
                    cur.execute(""SET search_path TO DEFAULT ;"")
                if (not is_table_executed) or (mode == 'unsafe'):
                    # if auto commit mode than every statement is called separately.
                    # this is done this way as auto commit is normally used when non transaction statements are called
                    # then this is needed to avoid ""cannot be executed from a function or multi-command string"" errors
                    if auto_commit:
                        for statement in sqlparse.split(value):
                            if statement:
                                cur.execute(statement)
                    else:
                        cur.execute(value)
                    self._logger.debug(value)
                    self._logger.debug('{0} executed for schema {1}'.format(key, schema_name))
                    executed_table_scripts.append(key)
                    return_value['table_scripts_deployed'].append(key)
                else:
                    self._logger.debug('{0} is not executed for schema {1} as it has already been executed before. '
                                       .format(key, schema_name))
        else:
            self._logger.debug('No Table DDL scripts to execute')

        # Executing functions
        return_value['function_scripts_deployed'] = []
        if len(function_scripts_dict) > 0:
            self._logger.debug('Running functions definitions scripts')
            for key, value in function_scripts_dict.items():
                # if auto commit mode than every statement is called separately.
                # this is done this way as auto commit is normally used when non transaction statements are called
                # then this is needed to avoid ""cannot be executed from a function or multi-command string"" errors
                if auto_commit:
                    for statement in sqlparse.split(value):
                        if statement:
                            cur.execute(statement)
                else:
                    cur.execute(value)
                return_value['function_scripts_deployed'].append(key)
            self._logger.debug('Functions loaded to schema {0}'.format(schema_name))
        else:
            self._logger.debug('No function scripts to deploy')

        # Executing views
        return_value['view_scripts_deployed'] = []
        if len(view_scripts_dict) > 0:
            self._logger.debug('Running views definitions scripts')
            for key, value in view_scripts_dict.items():
                # if auto commit mode than every statement is called separately.
                # this is done this way as auto commit is normally used when non transaction statements are called
                # then this is needed to avoid ""cannot be executed from a function or multi-command string"" errors
                if auto_commit:
                    for statement in sqlparse.split(value):
                        if statement:
                            cur.execute(statement)
                else:
                    cur.execute(value)
                return_value['view_scripts_deployed'].append(key)
            self._logger.debug('Views loaded to schema {0}'.format(schema_name))
        else:
            self._logger.debug('No view scripts to deploy')

        # Executing triggers
        return_value['trigger_scripts_deployed'] = []
        if len(trigger_scripts_dict) > 0:
            self._logger.debug('Running trigger definitions scripts')
            for key, value in trigger_scripts_dict.items():
                # if auto commit mode than every statement is called separately.
                # this is done this way as auto commit is normally used when non transaction statements are called
                # then this is needed to avoid ""cannot be executed from a function or multi-command string"" errors
                if auto_commit:
                    for statement in sqlparse.split(value):
                        if statement:
                            cur.execute(statement)
                else:
                    cur.execute(value)
                return_value['trigger_scripts_deployed'].append(key)
            self._logger.debug('Triggers loaded to schema {0}'.format(schema_name))
        else:
            self._logger.debug('No trigger scripts to deploy')

        # alter schema privileges if needed
        if (not files_deployment) and mode != 'overwrite' \
                and self._config.scope == pgpm.lib.utils.config.SchemaConfiguration.SCHEMA_SCOPE:
            pgpm.lib.utils.db.SqlScriptsHelper.revoke_all(cur, schema_name, 'public')
            if self._config.usage_roles:
                pgpm.lib.utils.db.SqlScriptsHelper.grant_usage_privileges(
                    cur, schema_name, ', '.join(self._config.usage_roles))
                self._logger.debug('User(s) {0} was (were) granted usage permissions on schema {1}.'
                                   .format("", "".join(self._config.usage_roles), schema_name))
            if self._config.owner_role:
                pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, self._pgpm_schema_name)
                cur.callproc('_alter_schema_owner', [schema_name, self._config.owner_role])
                self._logger.debug('Ownership of schema {0} and all its objects was changed and granted to user {1}.'
                                   .format(schema_name, self._config.owner_role))

        # Add metadata to pgpm schema
        pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, self._pgpm_schema_name)
        cur.callproc('_upsert_package_info'.format(self._pgpm_schema_name),
                     [self._config.name,
                      self._config.subclass,
                      self._config.version.major,
                      self._config.version.minor,
                      self._config.version.patch,
                      self._config.version.pre,
                      self._config.version.metadata,
                      self._config.description,
                      self._config.license,
                      list_of_deps_ids,
                      vcs_ref,
                      vcs_link,
                      issue_ref,
                      issue_link])
        self._logger.debug('Meta info about deployment was added to schema {0}'
                           .format(self._pgpm_schema_name))
        pgpm_package_id = cur.fetchone()[0]
        if len(table_scripts_dict) > 0:
            for key in executed_table_scripts:
                cur.callproc('_log_table_evolution'.format(self._pgpm_schema_name), [key, pgpm_package_id])

        # Commit transaction
        self._conn.commit()

        self._conn.close()

        deployed_files_count = len(return_value['function_scripts_deployed']) + \
                               len(return_value['type_scripts_deployed']) + \
                               len(return_value['view_scripts_deployed']) + \
                               len(return_value['trigger_scripts_deployed']) + \
                               len(return_value['table_scripts_deployed'])

        requested_files_count = len(return_value['function_scripts_requested']) + \
                                len(return_value['type_scripts_requested']) + \
                                len(return_value['view_scripts_requested']) + \
                                len(return_value['trigger_scripts_requested']) + \
                                len(return_value['table_scripts_requested'])

        return_value['deployed_files_count'] = deployed_files_count
        return_value['requested_files_count'] = requested_files_count
        if deployed_files_count == requested_files_count:
            return_value['code'] = self.DEPLOYMENT_OUTPUT_CODE_OK
            return_value['message'] = 'OK'
        else:
            return_value['code'] = self.DEPLOYMENT_OUTPUT_CODE_NOT_ALL_DEPLOYED
            return_value['message'] = 'Not all requested files were deployed'
        return return_value"
2530,"def _get_scripts(self, scripts_path_rel, files_deployment, script_type, project_path):
        """"""
        Gets scripts from specified folders
        """"""

        scripts_dict = {}
        if scripts_path_rel:

            self._logger.debug('Getting scripts with {0} definitions'.format(script_type))
            scripts_dict = pgpm.lib.utils.misc.collect_scripts_from_sources(scripts_path_rel, files_deployment,
                                                                            project_path, False, self._logger)
            if len(scripts_dict) == 0:
                self._logger.debug('No {0} definitions were found in {1} folder'.format(script_type, scripts_path_rel))
        else:
            self._logger.debug('No {0} folder was specified'.format(script_type))

        return scripts_dict"
2531,"def _resolve_dependencies(self, cur, dependencies):
        """"""
        Function checks if dependant packages are installed in DB
        """"""
        list_of_deps_ids = []
        _list_of_deps_unresolved = []
        _is_deps_resolved = True
        for k, v in dependencies.items():
            pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, self._pgpm_schema_name)
            cur.execute(""SELECT _find_schema('{0}', '{1}')""
                        .format(k, v))
            pgpm_v_ext = tuple(cur.fetchone()[0][1:-1].split(','))
            try:
                list_of_deps_ids.append(int(pgpm_v_ext[0]))
            except:
                pass
            if not pgpm_v_ext[0]:
                _is_deps_resolved = False
                _list_of_deps_unresolved.append(""{0}: {1}"".format(k, v))

        return _is_deps_resolved, list_of_deps_ids, _list_of_deps_unresolved"
2532,"def _reorder_types(self, types_script):
        """"""
        Takes type scripts and reorders them to avoid Type doesn't exist exception
        """"""
        self._logger.debug('Running types definitions scripts')
        self._logger.debug('Reordering types definitions scripts to avoid ""type does not exist"" exceptions')
        _type_statements = sqlparse.split(types_script)
        # TODO: move up to classes
        _type_statements_dict = {}  # dictionary that store statements with type and order.
        type_unordered_scripts = []  # scripts to execute without order
        type_drop_scripts = []  # drop scripts to execute first
        for _type_statement in _type_statements:
            _type_statement_parsed = sqlparse.parse(_type_statement)
            if len(_type_statement_parsed) > 0:  # can be empty parsed object so need to check
                # we need only type declarations to be ordered
                if _type_statement_parsed[0].get_type() == 'CREATE':
                    _type_body_r = r'\bcreate\s+\b(?:type|domain)\s+\b(\w+\.\w+|\w+)\b'
                    _type_name = re.compile(_type_body_r, flags=re.IGNORECASE).findall(_type_statement)[0]
                    _type_statements_dict[str(_type_name)] = \
                        {'script': _type_statement, 'deps': []}
                elif _type_statement_parsed[0].get_type() == 'DROP':
                    type_drop_scripts.append(_type_statement)
                else:
                    type_unordered_scripts.append(_type_statement)
        # now let's add dependant types to dictionary with types
        # _type_statements_list = []  # list of statements to be ordered
        for _type_key in _type_statements_dict.keys():
            for _type_key_sub, _type_value in _type_statements_dict.items():
                if _type_key != _type_key_sub:
                    if pgpm.lib.utils.misc.find_whole_word(_type_key)(_type_value['script']):
                        _type_value['deps'].append(_type_key)
        # now let's add order to type scripts and put them ordered to list
        _deps_unresolved = True
        _type_script_order = 0
        _type_names = []
        type_ordered_scripts = []  # ordered list with scripts to execute
        while _deps_unresolved:
            for k, v in _type_statements_dict.items():
                if not v['deps']:
                    _type_names.append(k)
                    v['order'] = _type_script_order
                    _type_script_order += 1
                    if not v['script'] in type_ordered_scripts:
                        type_ordered_scripts.append(v['script'])
                else:
                    _dep_exists = True
                    for _dep in v['deps']:
                        if _dep not in _type_names:
                            _dep_exists = False
                    if _dep_exists:
                        _type_names.append(k)
                        v['order'] = _type_script_order
                        _type_script_order += 1
                        if not v['script'] in type_ordered_scripts:
                            type_ordered_scripts.append(v['script'])
                    else:
                        v['order'] = -1
            _deps_unresolved = False
            for k, v in _type_statements_dict.items():
                if v['order'] == -1:
                    _deps_unresolved = True
        return type_drop_scripts, type_ordered_scripts, type_unordered_scripts"
2533,"def find_table_links(self):
        """"""
        When given a url, this function will find all the available table names
        for that EPA dataset.
        """"""
        html = urlopen(self.model_url).read()
        doc = lh.fromstring(html)
        href_list = [area.attrib['href'] for area in doc.cssselect('map area')]
        tables = self._inception_table_links(href_list)
        return tables"
2534,"def _inception_table_links(self, href_list):
        """"""
        Sometimes the EPA likes to nest their models and tables -- model within
        a model within a model -- so this internal method tries to clear all
        that up.
        """"""
        tables = set()
        for link in href_list:
            if not link.startswith('http://'):
                link = self.agency_url + link
            html = urlopen(link).read()
            doc = lh.fromstring(html)
            area = doc.cssselect('map area')
            if area:
                # Then this is a model containing models.
                tables.update((a.attrib['href'] for a in area))
            else:
                # The link is a table without additional models.
                tables.update(link)
        return tables"
2535,"def find_definition_urls(self, set_of_links):
        """"""Find the available definition URLs for the columns in a table.""""""
        definition_dict = {}
        re_link_name = re.compile('.*p_table_name=(\w+)&p_topic.*')
        for link in set_of_links:
            if link.startswith('http://'):
                table_dict = {}
                html = urlopen(link).read()
                doc = lh.fromstring(html)
                unordered_list = doc.cssselect('#main ul')[-1]
                for li in unordered_list.iterchildren():
                    a = li.find('a')
                    table_dict.update({a.text: a.attrib['href']})
                link_name = re_link_name.sub(r'\1', link).upper()
                definition_dict.update({link_name: table_dict})
        return definition_dict"
2536,"def create_agency(self):
        """"""Create an agency text file of definitions.""""""
        agency = self.agency
        links = self.find_table_links()
        definition_dict = self.find_definition_urls(links)
        with open(agency + '.txt', 'w') as f:
            f.write(str(definition_dict))"
2537,"def loop_through_agency(self):
        """"""Loop through an agency to grab the definitions for its tables.""""""
        agency = self.agency
        with open(agency + '.txt') as f:
            data = eval(f.read())
        for table in data:
            for column in data[table]:
                value_link = data[table][column]
                data[table][column] = self.grab_definition(value_link)
        data = json.dumps(data)
        with open(agency + '_values.json', 'w') as f:
            f.write(str(data))"
2538,"def grab_definition(self, url):
        """"""
        Grab the column definition of a table from the EPA using a combination
        of regular expressions and lxml.
        """"""
        re_description = re.compile('Description:(.+?\\n)')
        re_table_name = re.compile(""(\w+ Table.+)"")
        if url.startswith('//'):
            url = 'http:' + url
        elif url.startswith('/'):
            url = 'http://www.epa.gov' + url
        try:
            html = urlopen(url).read()
            doc = lh.fromstring(html)
            main = doc.cssselect('#main')[0]
            text = main.text_content()
            definition = re_description.search(text).group(1).strip()
        except (AttributeError, IndexError, TypeError, HTTPError):
            print url
        else:
            value = re_table_name.sub('', definition)
            return value
        return url"
2539,"def add_arc(self, src, dst, char):
        """"""Adds a new Arc
        Args:
            src (int): The source state identifier
            dst (int): The destination state identifier
            char (str): The character for the transition
        Returns:
            None
        """"""
        if src not in self.automaton.states():
            self.add_state()
        arc = fst.Arc(self.isyms[char], self.osyms[char],  fst.Weight.One(self.automaton.weight_type()), dst)
        self.automaton.add_arc(src, arc)"
2540,"def fixminimized(self, alphabet):
        """"""
        After pyfst minimization,
        all unused arcs are removed,
        and all sink states are removed.
        However this may break compatibility.
        Args:
            alphabet (list): The input alphabet
        Returns:
            None
        """"""

        insymbols = fst.SymbolTable()
        outsymbols = fst.SymbolTable()
        num = 1
        for char in self.alphabet:
            self.isyms.__setitem__(char, num)
            self.osyms.__setitem__(char, num)
            insymbols.add_symbol(char, num)
            outsymbols.add_symbol(char, num)
            num = num + 1
        self.automaton.set_input_symbols(insymbols)
        self.automaton.set_output_symbols(outsymbols)
        endstate = self.add_state()
        for state in self.states:
            for char in alphabet:
                found = 0
                for arc in state.arcs:
                    if self.isyms.find(arc.ilabel) == char:
                        found = 1
                        break
                if found == 0:
                    self.add_arc(state.stateid, endstate, char)
        self[endstate].final = False

        for char in alphabet:
            self.add_arc(endstate, endstate, char)"
2541,"def complement(self, alphabet):
        """"""
        Returns the complement of DFA
        Args:
            alphabet (list): The input alphabet
        Returns:
            None
        """"""
        self._addsink(alphabet)
        for state in self.automaton.states():
            if self.automaton.final(state) == fst.Weight.One(self.automaton.weight_type()):
                self.automaton.set_final(state, fst.Weight.Zero(self.automaton.weight_type()))
            else:
                self.automaton.set_final(state, fst.Weight.One(self.automaton.weight_type()))"
2542,"def init_from_acceptor_bycopying(self, acceptor):
        """"""
        Adds a sink state
        Args:
            alphabet (list): The input alphabet
        Returns:
            None
        """"""
        for state in acceptor.states:
            for arc in state.arcs:
                self.add_arc(state.stateid, arc.nextstate, acceptor.isyms.find(arc.ilabel))
            if state.final:
                print state.stateid,' is final'
                self[state.stateid].final = True;"
2543,"def intersect(self, other):
        """"""Constructs an unminimized DFA recognizing
        the intersection of the languages of two given DFAs.
        Args:
            other (DFA): The other DFA that will be used
                         for the intersect operation
        Returns:
        Returns:
            DFA: The resulting DFA
        """"""
        self.automaton = fst.intersect(self.automaton, other.automaton)
        return  self"
2544,"def main(*argv, 
          filesystem=None, 
          do_exit=True,
          stdout=None,
          stderr=None):
    """"""Main method for the cli.

    We allow the filesystem to be overridden for test purposes.""""""
    try:
        mdcli = MdCLI()
        mdcli.filesystem = filesystem
        mdcli.stdout = stdout or sys.stdout
        mdcli.stderr = stderr or sys.stderr
        retval = mdcli.main(*argv, loop=LOOP_NEVER)
        if do_exit:
            sys.exit(retval)
        else:
            return retval
    except KeyboardInterrupt:
        pass"
2545,"def get_optparser(self):
        """"""Override to allow specification of the maildir""""""
        p = Cmdln.get_optparser(self)
        p.add_option(
            ""-M"",
            ""--maildir"",
            action=""store"",
            dest=""maildir""
            )
        p.add_option(
            ""-V"",
            ""--verbose"",
            action=""store_true"",
            dest=""verbose""
            )
        return p"
2546,"def do_lsfolders(self, subcmd, opts):
        """"""${cmd_name}: list the sub folders of the maildir.

        ${cmd_usage}
        """"""
        client = MdClient(self.maildir, filesystem=self.filesystem)
        client.lsfolders(stream=self.stdout)"
2547,"def do_ls(self, subcmd, opts, folder=""""):
        """"""${cmd_name}: list messages in the specified folder

        ${cmd_usage}
        ${cmd_option_list}
        SINCE can be used with epoch times, for example: 

          md ls -s $(date '+%s')
        """"""
        client = MdClient(self.maildir, filesystem=self.filesystem)
        client.ls(
            foldername = folder, 
            stream = self.stdout, 
            reverse = getattr(opts, ""reverse"", False),
            grep = getattr(opts, ""grep"", None),
            field = getattr(opts, ""field"", None),
            since = float(getattr(opts, ""since"", -1))
            )"
2548,"def do_lisp(self, subcmd, opts, folder=""""):
        """"""${cmd_name}: list messages in the specified folder in JSON format

        ${cmd_usage}
        """"""
        client = MdClient(self.maildir, filesystem=self.filesystem)
        client.lisp(
            foldername=folder,
            stream=self.stdout, 
            reverse=getattr(opts, ""reverse"", False),
            since=float(getattr(opts, ""since"", -1))
            )"
2549,"def do_make(self, subcmd, opts, path):
        """"""${cmd_name}: make a maildir at the specified path.

        ${cmd_usage}

        If the path is relative then create under MAILDIR
        else create at the absolute location.
        """"""
        # Do we need to make this "".path"" if it's relative?
        d = path if path[0] == ""/"" else joinpath(self.maildir, ""."" + path)
        os.makedirs(joinpath(d, ""cur""))
        os.makedirs(joinpath(d, ""new""))
        os.makedirs(joinpath(d, ""tmp""))
        os.makedirs(joinpath(d, ""store""))"
2550,"def do_rm(self, subcmd, opts, message):
        """"""${cmd_name}: remove the specified message

        ${cmd_usage}
        """"""
        maildir = self.maildir
        client = MdClient(maildir, filesystem=self.filesystem)
        try:
            client.remove(message)
        except KeyError:
            return 1"
2551,"def do_mv(self, subcmd, opts, message, folder):
        """"""${cmd_name}: move the specified message to the specified folder

        ${cmd_usage}
        """"""
        client = MdClient(self.maildir, filesystem=self.filesystem)
        client.move(message, folder)"
2552,"def do_text(self, subcmd, opts, message):
        """"""${cmd_name}: get the best text part of the specified message

        ${cmd_usage}
        """"""
        client = MdClient(self.maildir, filesystem=self.filesystem)
        client.gettext(message, self.stdout)"
2553,"def do_raw(self, subcmd, opts, message):
        """"""${cmd_name}: dump the complete raw message

        ${cmd_usage}
        """"""
        client = MdClient(self.maildir)
        client.getraw(message, self.stdout)"
2554,"def do_rawpart(self, subcmd, opts, message):
        """"""${cmd_name}: dump a part from the specified message

        ${cmd_usage}
        ${cmd_option_list}
        """"""
        client = MdClient(self.maildir, filesystem=self.filesystem)
        partid = getattr(opts, ""part"", None)
        if not partid:
            client.getrawpart(message, self.stdout)
        else:
            client.getrawpartid(message, partid, self.stdout)"
2555,"def do_struct(self, subcmd, opts, message):
        """"""${cmd_name}: get the structure of the specified message

        ${cmd_usage}
        ${cmd_option_list}
        """"""
        client = MdClient(self.maildir, filesystem=self.filesystem)
        as_json = getattr(opts, ""json"", False)
        client.getstruct(message, as_json=as_json, stream=self.stdout)"
2556,"def do_file(self, subcmd, opts, message):
        """"""${cmd_name}: download the whole file of the message.
        
        ${cmd_usage}
        """"""
        client = MdClient(self.maildir, filesystem=self.filesystem)
        client.get(message, self.stdout)"
2557,"def do_pull(self, subcmd, opts, remote_maildir):
        """"""${cmd_name}: pull the remote maildir into the local maildir.

        ${cmd_usage}
        ${cmd_option_list}

        The REMOTE_MAILDIR is a url which specifies where the dir
        is. A few different forms are supported:

          ssh://user@hostname/path   is a remote directory at path, accessed via ssh
          file://path                is a local maildir directory at path
        """"""
        import mdlib.pull 
        m = re.match(
            ""(?P<protocol>[a-z]+)://(?P<urlpart>.*)"",
            remote_maildir
            )
        if not m:
            print(""md pull: the remote maildir url was unrecognized"", file=self.stderr)
            return

        local_maildir = self.maildir
        noop = getattr(opts, ""noop"", False) or False
        verbose = getattr(self.options, ""verbose"", False) or False
        filterfile = getattr(opts, ""filter"", None) or None

        try:
            filterfd = open(filterfile)
        except:
            filterfd = None
            # Some error loading the filterfile
            if verbose:
                print(""md pull: could not load filter file"", file=self.stderr)

        data = m.groupdict()
        if data.get(""protocol"") == ""ssh"":
            m = re.match(
                ""(?P<user>[a-zA-Z0-9-]+@)*(?P<hostname>[a-zA-Z0-9.-]+)(?P<path>[a-zA-Z0-9./-]+)"",
                data.get(""urlpart"")
                )
            if not m:
                print(""md pull: %s was not a remote maildir"" % remote_maildir, file=self.stderr)
                return
            data = m.groupdict()
            host = data.get(""hostname"", None) \
                if not data.get(""user"", None) \
                else ""%s@%s"" % (data.get(""user""), data.get(""hostname""))
            remote_maildir = data.get(""path"")
            mdlib.pull.sshpull(host, remote_maildir, local_maildir, noop, verbose, filterfd)
        elif data.get(""protocol"") == ""file"":
            maildir = data.get(""urlpart"")
            mdlib.pull.filepull(maildir, local_maildir, noop, verbose, filterfd)
        else:
            print(""md pull: %s not a recognized protocol"" % protocol, file=self.stderr)

        # Finally try and close the filterfd
        if filterfd:
            try:
                filterfd.close()
            except:
                if verbose:
                    print(""md pull: couldn't close open filter file"", file=self.stderr)"
2558,"def do_newfilter(self, subcmd, opts):
        """"""${cmd_name}: make a filterfile and spit it to stdout.
        """"""
        from mdlib.filterprocessor import RULES
        print(RULES, file=self.stdout)"
2559,"def do_storecheck(self, subcmd, opts):
        """"""${cmd_name}: checks the store for files that may not be in the maildirs.
        """"""
        from os.path import basename
        from os.path import dirname
        from os.path import exists as existspath
        from os.path import islink
        from os.path import join as joinpath
        maildir = self.maildir
        cur = joinpath(maildir, ""cur"")
        new = joinpath(maildir, ""new"")
        store = joinpath(maildir, ""store"")
        
        found_list = []
        # Loop through the folders checking that everything maps back to the store
        for scandir in [cur, new]:
            for f in os.listdir(scandir):
                filename = joinpath(scandir, f)
                try:
                    assert islink(filename)
                    store_location = os.readlink(filename)
                    assert existspath(store_location) and dirname(store_location) == store
                except AssertionError:
                    print(""%s was not a link into the store"" % (
                            ""/"".join([
                                    filename.split(""/"")[-2],
                                    filename.split(""/"")[-1]
                                    ])
                            ), 
                          file=self.stdout)
                else:
                    found_list.append(basename(store_location))

        for storefile in os.listdir(store):
            if storefile not in found_list:
                print(
                    ""%s found in store but not folders"" % joinpath(""store"", storefile), 
                    file=self.stdout
                    )"
2560,"def form(context, form, **kwargs):
    """"""
    The `form` template tag will render a tape-form enabled form using the template
    provided by `get_layout_template` method of the form using the context generated
    by `get_layout_context` method of the form.

    Usage::

        {% load tapeforms %}
        {% form my_form %}

    You can override the used layout template using the keyword argument `using`::

        {% load tapeforms %}
        {% form my_form using='other_form_layout_template.html' %}

    :param form: The Django form to render.
    :return: Rendered form (errors + hidden fields + fields) as HTML.
    """"""

    if not isinstance(form, (forms.BaseForm, TapeformFieldset)):
        raise template.TemplateSyntaxError(
            'Provided form should be a `Form` instance, actual type: {0}'.format(
                form.__class__.__name__))

    return render_to_string(
        form.get_layout_template(kwargs.get('using', None)),
        form.get_layout_context(),
    )"
2561,"def formfield(context, bound_field, **kwargs):
    """"""
    The `formfield` template tag will render a form field of a tape-form enabled form
    using the template provided by `get_field_template` method of the form together with
    the context generated by `get_field_context` method of the form.

    Usage::

        {% load tapeforms %}
        {% formfield my_form.my_field %}

    You can override the used field template using the keyword argument `using`::

        {% load tapeforms %}
        {% formfield my_form.my_field using='other_field_template.html' %}

    :param bound_field: The `BoundField` from a Django form to render.
    :return: Rendered field (label + widget + other stuff) as HTML.
    """"""

    if not isinstance(bound_field, forms.BoundField):
        raise template.TemplateSyntaxError(
            'Provided field should be a `BoundField` instance, actual type: {0}'.format(
                bound_field.__class__.__name__))

    return render_to_string(
        bound_field.form.get_field_template(bound_field, kwargs.get('using', None)),
        bound_field.form.get_field_context(bound_field),
    )"
2562,"def wrap_as_node(self, func):
        'wrap a function as a node'
        name = self.get_name(func)

        @wraps(func)
        def wrapped(*args, **kwargs):
            'wrapped version of func'
            message = self.get_message_from_call(*args, **kwargs)
            self.logger.info('calling ""%s"" with %r', name, message)
            result = func(message)

            # functions can return multiple values (""emit"" multiple times)
            # by yielding instead of returning. Handle this case by making
            # a list of the results and processing them all after the
            # generator successfully exits. If we were to process them as
            # they came out of the generator, we might get a partially
            # processed input sent down the graph. This may be possible in
            # the future via a flag.
            if isinstance(result, GeneratorType):
                results = [
                    self.wrap_result(name, item)
                    for item in result
                    if item is not NoResult
                ]
                self.logger.debug(
                    '%s returned generator yielding %d items', func, len(results)
                )

                [self.route(name, item) for item in results]
                return tuple(results)

            # the case of a direct return is simpler. wrap, route, and
            # return the value.
            else:
                if result is NoResult:
                    return result

                result = self.wrap_result(name, result)
                self.logger.debug(
                    '%s returned single value %s', func, result
                )
                self.route(name, result)
                return result

        return wrapped"
2563,"def node(self, fields, subscribe_to=None, entry_point=False, ignore=None,
             **wrapper_options):
        '''\
        Decorate a function to make it a node.

        .. note::
           decorating as a node changes the function signature. Nodes should
           accept a single argument, which will be a
           :py:class:`emit.message.Message`. Nodes can be called directly by
           providing a dictionary argument or a set of keyword arguments. Other
           uses will raise a ``TypeError``.

        :param fields: fields that this function returns
        :type fields: ordered iterable of :py:class:`str`
        :param subscribe_to: functions in the graph to subscribe to. These
                             indicators can be regular expressions.
        :type subscribe_to: :py:class:`str` or iterable of :py:class:`str`
        :param ignore: functions in the graph to ignore (also uses regular
                       expressions.) Useful for ignoring specific functions in
                       a broad regex.
        :type ignore: :py:class:`str` or iterable of :py:class:`str`
        :param entry_point: Set to ``True`` to mark this as an entry point -
                            that is, this function will be called when the
                            router is called directly.
        :type entry_point: :py:class:`bool`

        In addition to all of the above, you can define a ``wrap_node``
        function on a subclass of Router, which will need to receive node and
        an options dictionary. Any extra options passed to node will be passed
        down to the options dictionary. See
        :py:class:`emit.router.CeleryRouter.wrap_node` as an example.

        :returns: decorated and wrapped function, or decorator if called directly
        '''
        def outer(func):
            'outer level function'
            # create a wrapper function
            self.logger.debug('wrapping %s', func)
            wrapped = self.wrap_as_node(func)

            if hasattr(self, 'wrap_node'):
                self.logger.debug('wrapping node ""%s"" in custom wrapper', wrapped)
                wrapped = self.wrap_node(wrapped, wrapper_options)

            # register the task in the graph
            name = self.get_name(func)
            self.register(
                name, wrapped, fields, subscribe_to, entry_point, ignore
            )

            return wrapped

        return outer"
2564,"def resolve_node_modules(self):
        'import the modules specified in init'
        if not self.resolved_node_modules:
            try:
                self.resolved_node_modules = [
                    importlib.import_module(mod, self.node_package)
                    for mod in self.node_modules
                ]
            except ImportError:
                self.resolved_node_modules = []
                raise

        return self.resolved_node_modules"
2565,"def get_message_from_call(self, *args, **kwargs):
        '''\
        Get message object from a call.

        :raises: :py:exc:`TypeError` (if the format is not what we expect)

        This is where arguments to nodes are turned into Messages. Arguments
        are parsed in the following order:

         - A single positional argument (a :py:class:`dict`)
         - No positional arguments and a number of keyword arguments
        '''
        if len(args) == 1 and isinstance(args[0], dict):
            # then it's a message
            self.logger.debug('called with arg dictionary')
            result = args[0]
        elif len(args) == 0 and kwargs != {}:
            # then it's a set of kwargs
            self.logger.debug('called with kwargs')
            result = kwargs
        else:
            # it's neither, and we don't handle that
            self.logger.error(
                'get_message_from_call could not handle ""%r"", ""%r""',
                args, kwargs
            )
            raise TypeError('Pass either keyword arguments or a dictionary argument')

        return self.message_class(result)"
2566,"def register(self, name, func, fields, subscribe_to, entry_point, ignore):
        '''
        Register a named function in the graph

        :param name: name to register
        :type name: :py:class:`str`
        :param func: function to remember and call
        :type func: callable

        ``fields``, ``subscribe_to`` and ``entry_point`` are the same as in
        :py:meth:`Router.node`.
        '''
        self.fields[name] = fields
        self.functions[name] = func

        self.register_route(subscribe_to, name)

        if ignore:
            self.register_ignore(ignore, name)

        if entry_point:
            self.add_entry_point(name)

        self.logger.info('registered %s', name)"
2567,"def add_entry_point(self, destination):
        '''\
        Add an entry point

        :param destination: node to route to initially
        :type destination: str
        '''
        self.routes.setdefault('__entry_point', set()).add(destination)
        return self.routes['__entry_point']"
2568,"def register_route(self, origins, destination):
        '''
        Add routes to the routing dictionary

        :param origins: a number of origins to register
        :type origins: :py:class:`str` or iterable of :py:class:`str` or None
        :param destination: where the origins should point to
        :type destination: :py:class:`str`

        Routing dictionary takes the following form::

            {'node_a': set(['node_b', 'node_c']),
             'node_b': set(['node_d'])}

        '''
        self.names.add(destination)
        self.logger.debug('added ""%s"" to names', destination)

        origins = origins or []  # remove None
        if not isinstance(origins, list):
            origins = [origins]

        self.regexes.setdefault(destination, [re.compile(origin) for origin in origins])

        self.regenerate_routes()
        return self.regexes[destination]"
2569,"def register_ignore(self, origins, destination):
        '''
        Add routes to the ignore dictionary

        :param origins: a number of origins to register
        :type origins: :py:class:`str` or iterable of :py:class:`str`
        :param destination: where the origins should point to
        :type destination: :py:class:`str`

        Ignore dictionary takes the following form::

            {'node_a': set(['node_b', 'node_c']),
             'node_b': set(['node_d'])}

        '''
        if not isinstance(origins, list):
            origins = [origins]

        self.ignore_regexes.setdefault(destination, [re.compile(origin) for origin in origins])
        self.regenerate_routes()

        return self.ignore_regexes[destination]"
2570,"def regenerate_routes(self):
        'regenerate the routes after a new route is added'
        for destination, origins in self.regexes.items():
            # we want only the names that match the destination regexes.
            resolved = [
                name for name in self.names
                if name is not destination
                and any(origin.search(name) for origin in origins)
            ]

            ignores = self.ignore_regexes.get(destination, [])
            for origin in resolved:
                destinations = self.routes.setdefault(origin, set())

                if any(ignore.search(origin) for ignore in ignores):
                    self.logger.info('ignoring route ""%s"" -> ""%s""', origin, destination)
                    try:
                        destinations.remove(destination)
                        self.logger.debug('removed ""%s"" -> ""%s""', origin, destination)
                    except KeyError:
                        pass

                    continue

                if destination not in destinations:
                    self.logger.info('added route ""%s"" -> ""%s""', origin, destination)

                destinations.add(destination)"
2571,"def route(self, origin, message):
        '''\
        Using the routing dictionary, dispatch a message to all subscribers

        :param origin: name of the origin node
        :type origin: :py:class:`str`
        :param message: message to dispatch
        :type message: :py:class:`emit.message.Message` or subclass
        '''
        # side-effect: we have to know all the routes before we can route. But
        # we can't resolve them while the object is initializing, so we have to
        # do it just in time to route.
        self.resolve_node_modules()

        if not self.routing_enabled:
            return

        subs = self.routes.get(origin, set())

        for destination in subs:
            self.logger.debug('routing ""%s"" -> ""%s""', origin, destination)
            self.dispatch(origin, destination, message)"
2572,"def dispatch(self, origin, destination, message):
        '''\
        dispatch a message to a named function

        :param destination: destination to dispatch to
        :type destination: :py:class:`str`
        :param message: message to dispatch
        :type message: :py:class:`emit.message.Message` or subclass
        '''
        func = self.functions[destination]
        self.logger.debug('calling %r directly', func)
        return func(_origin=origin, **message)"
2573,"def wrap_result(self, name, result):
        '''
        Wrap a result from a function with it's stated fields

        :param name: fields to look up
        :type name: :py:class:`str`
        :param result: return value from function. Will be converted to tuple.
        :type result: anything

        :raises: :py:exc:`ValueError` if name has no associated fields

        :returns: :py:class:`dict`
        '''
        if not isinstance(result, tuple):
            result = tuple([result])

        try:
            return dict(zip(self.fields[name], result))
        except KeyError:
            msg = '""%s"" has no associated fields'
            self.logger.exception(msg, name)
            raise ValueError(msg % name)"
2574,"def get_name(self, func):
        '''
        Get the name to reference a function by

        :param func: function to get the name of
        :type func: callable
        '''
        if hasattr(func, 'name'):
            return func.name

        return '%s.%s' % (
            func.__module__,
            func.__name__
        )"
2575,"def coerce(self, value):
        """"""Convert text values into boolean values.

        True values are (case insensitive): 'yes', 'true', '1'. False values
        are (case insensitive): 'no', 'false', '0'.

        Args:
            value (str or bool): The value to coerce.

        Raises:
            TypeError: If the value is not a bool or string.
            ValueError: If the value is not bool or an acceptable value.

        Returns:
            bool: The True/False value represented.
        """"""
        if isinstance(value, bool):

            return value

        if not hasattr(value, 'lower'):

            raise TypeError('Value is not bool or string.')

        if value.lower() in ('yes', 'true', '1'):

            return True

        if value.lower() in ('no', 'false', '0'):

            return False

        raise ValueError('Could not coerce {0} to a bool.'.format(value))"
2576,"def main():
    """"""
    Testing function for PDA - DFA Diff Operation
    """"""
    if len(argv) < 2:
        print 'Usage: '
        print '         Get A String              %s CFG_fileA FST_fileB' % argv[0]
        return

    alphabet = createalphabet()

    cfgtopda = CfgPDA(alphabet)
    print '* Parsing Grammar:',
    mma = cfgtopda.yyparse(argv[1])
    print 'OK'

    flex_a = Flexparser(alphabet)
    print '* Parsing Regex:',
    mmb = flex_a.yyparse(argv[2])
    print mmb
    print 'OK'
    print '* Minimize Automaton:',
    mmb.minimize()
    print 'OK'
    print mmb
    print '* Diff:',
    ops = PdaDiff(mma, mmb, alphabet)
    mmc = ops.diff()
    print 'OK'
    print '* Get String:',
    print ops.get_string()"
2577,"def _delta(self, graph, cur_state, char):
        """"""
        Args:
            graph (Fst Acceptor): The DFA
            cur_state (Fst State): The current State
            char (Char): The input character
        Returns:
            (Fst State): The destination state
        """"""
        for arc in cur_state.arcs:
            if graph.isyms.find(arc.ilabel) == char:
                return graph[arc.nextstate]
        return None"
2578,"def _intesect(self):
        """"""The intesection of a PDA and a DFA""""""
        p1automaton = self.mma
        p2automaton = self.mmb
        p3automaton = PDA(self.alphabet)
        self._break_terms()
        p1counter = 0
        p3counter = 0
        p2states = list(p2automaton.states)
        print 'PDA States: ' + repr(p1automaton.n)
        print 'DFA States: ' + repr(len(list(p2states)))
        ignorechars = p1automaton.nonterminals+ [0] + ['@closing']
        del(ignorechars[ignorechars.index('S')])
        while p1counter < p1automaton.n + 1:
            p1state = p1automaton.s[p1counter]
            p2counter = 0
            while p2counter < len(list(p2states)):
                p2state = p2states[p2counter]
                tempstate = PDAState()
                tempstate.id = (p1state.id, p2state.stateid)
                tempstate.sym = p1state.sym
                tempstate.type = p1state.type
                tempstate.trans = {}
                found = 0
                for char in self.alphabet:
                    if char in ignorechars:
                        continue
                    # DFA has single destination from a state
                    p2dest = self._delta(p2automaton, p2state, char)
                    # PDA may have multiple destinations from a state
                    # print p1state.trans
                    if p2dest is not None:
                        for potential in p1state.trans:
                            if char in p1state.trans[potential]:
                                found = 1
                                p1dest = potential
                                if (p1dest,
                                        p2dest.stateid) not in tempstate.trans:
                                    tempstate.trans[
                                        (p1dest, p2dest.stateid)] = []
                                    # print 'Appending A Transition to
                                    # ('+`p1dest`+','+`p2dest.stateid`+') for
                                    # input '+`char`
                                tempstate.trans[
                                    (p1dest, p2dest.stateid)].append(char)

                                # THEN THE NONTERMINALS + 0 3 transitions
                                # print p1state.trans
                                #               print p1automaton.nonterminals
                if found == 0 and  p1state.type == 3 and len(p1state.trans) >0:
                    assert 1==1,'Check Failed: A READ state with transitions' \
                                ' did not participate in the cross product'
                if p2dest is not None:
                    for nonterm in p1automaton.nonterminals + \
                            [0] + ['@closing']:
                        for potential in p1state.trans:
                            if nonterm in p1state.trans[potential]:
                                p1dest = potential
                                if (p1dest,
                                        p2state.stateid) not in tempstate.trans:
                                    tempstate.trans[
                                        (p1dest, p2state.stateid)] = []
                                # print 'Appending B Transition to
                                # ('+`p1dest`+','+`p2state.stateid`+') for
                                # input '+`nonterm`
                                tempstate.trans[
                                    (p1dest, p2state.stateid)].append(nonterm)
                p3automaton.s[p3counter] = tempstate
                p3counter = p3counter + 1
                p2counter = p2counter + 1
            p1counter = p1counter + 1
        # print 'Total States Appended '+`len(p3automaton.input_string)`
        p3automaton.n = p3counter - 1

        p3automaton.accepted = []
        for state in p2automaton.states:
            if state.final != TropicalWeight(float('inf')):
                p3automaton.accepted.append(state.stateid)
        return p3automaton"
2579,"def diff(self):
        """"""The Difference between a PDA and a DFA""""""
        self.mmb.complement(self.alphabet)
        self.mmb.minimize()
        print 'start intersection'
        self.mmc = self._intesect()
        print 'end intersection'
        return self.mmc"
2580,"def get_string(self):
        """"""
        Returns a string from the Diff resutl.
        Depending on the method, either the string will
        be generated directly from the PDA using the state
        removal method, or the PDA will be first translated to
        a CFG and then a string will be generated from the CFG
        Args:
             None
        Returns:
            A string from the Diff
        """"""
        return_string = None
        if not self.mmc:
            return """"
        method = 'PDASTRING'
        if method == 'PDASTRING':
            stringgen = PdaString()
            print '* Reduce PDA using DFA BFS (remove unreachable states):'
            newpda = self.mmc.s
            handle = IntersectionHandling()
            newpda = handle.get(newpda, self.mmc.accepted)
            reduce_b = ReducePDA()
            newpda = reduce_b.get(newpda)
            #simply = SimplifyStateIDs()
            #newpda, biggestid, newaccepted = simply.get(
            #    newpda, self.mmc.accepted)
            print ""- Total PDA states after reduction are "" + repr(len(newpda))
            return_string = stringgen.init(newpda, self.mmc.accepted)
            if return_string is not None:
                return_string = return_string[0]
        elif method == 'PDACFGSTRING':

            optimized = 1
            dt1 = datetime.datetime.fromtimestamp(time.time())
            print '* Initiating PDA simplification'
            print ' - Total PDA states are ' + repr(len(self.mmc.s))
            handle = IntersectionHandling()
            newpda = handle.get(self.mmc.s, self.mmc.accepted)
            newpda = self.mmc.s
            simply = SimplifyStateIDs()
            newpda, biggestid, newaccepted = simply.get(
                newpda, self.mmc.accepted)
            print ' - Total PDA states after id clearence are ' + repr(len(newpda))
            replace = ReadReplace(newpda, biggestid)
            newpda = replace.replace_read()
            print ' - Total PDA states after read elimination are ' + repr(len(newpda))
            maxstate = replace.nextstate() - 1
            print '* Reduce PDA using DFA BFS (remove unreachable states):'
            reduce_b = ReducePDA()
            newpda = reduce_b.get(newpda)
            print ""- Total PDA states after reduction are "" + repr(len(newpda))

            dt2 = datetime.datetime.fromtimestamp(time.time())
            rdelta = dateutil.relativedelta.relativedelta(dt2, dt1)
            print ""* PDA was simplyfied in %d days, %d hours, %d minutes and %d seconds"" % (
                rdelta.days, rdelta.hours, rdelta.minutes, rdelta.seconds)
            dt1 = datetime.datetime.fromtimestamp(time.time())
            print '* Initiating CNF from PDA generation'
            cnfgenerator = PdaCnf(newpda, newaccepted)
            dt2 = datetime.datetime.fromtimestamp(time.time())
            rdelta = dateutil.relativedelta.relativedelta(dt2, dt1)
            print ""* CNF was generated in %d days, %d hours, %d minutes and %d seconds"" % (
                rdelta.days, rdelta.hours, rdelta.minutes, rdelta.seconds)
            dt1 = datetime.datetime.fromtimestamp(time.time())
            print '* Initiating string from CFG generation'
            grammar = cnfgenerator.get_rules(optimized)
            print ' - Total grammar rules are ' + repr(len(grammar))
            gen = CFGGenerator(CNFGenerator(grammar),
                               optimized=optimized,
                               splitstring=0,
                               maxstate=maxstate)
            return_string = gen.generate()
            dt2 = datetime.datetime.fromtimestamp(time.time())
            rdelta = dateutil.relativedelta.relativedelta(dt2, dt1)
            print ""* A string was generated in %d days, %d hours, %d minutes and %d seconds"" % (
                rdelta.days, rdelta.hours, rdelta.minutes, rdelta.seconds)

            print return_string
        else:
            return_string = None
        return return_string"
2581,"def refresh_devices(self):
        '''Queries hub for list of devices, and creates new device objects'''
        try:
            response = self.api.get(""/api/v2/devices"", {'properties':'all'})
            for device_data in response['DeviceList']:
                self.devices.append(Device(device_data, self))
        except APIError as e:
            print(""API error: "")
            for key,value in e.data.iteritems:
                print(str(key) + "": "" + str(value))"
2582,"def refresh_details(self):
        '''Query hub and refresh all details of a device,
        but NOT status, includes grouplist not present in
        refresh_all_devices'''
        try:
            return self.api_iface._api_get(""/api/v2/devices/"" + str(self.device_id))
        except APIError as e:
            print(""API error: "")
            for key,value in e.data.iteritems:
                print(str(key) + "": "" + str(value))"
2583,"def send_command(self, command):
        '''Send a command to a device'''
        data = {""command"": command, ""device_id"": self.device_id}
        try:
            response = self.api_iface._api_post(""/api/v2/commands"", data)
            return Command(response, self)
        except APIError as e:
            print(""API error: "")
            for key,value in e.data.iteritems:
                print(str(key) + "": "" + str(value))"
2584,"def _update_details(self,data):
        '''Intakes dict of details, and sets necessary properties
        in device'''
        # DeviceName, IconID, HouseID, DeviceID always present
        self.device_id = data['DeviceID']
        self.device_name = data['DeviceName']
        self.properties = data"
2585,"def _update_details(self,data):
        '''Intakes dict of details, and sets necessary properties
        in command'''
        for api_name in self._properties:
            if api_name in data:
                setattr(self, ""_"" + api_name, data[api_name])
            else:
                # Only set to blank if not initialized
                try:
                    getattr(self, ""_"" + api_name)
                except AttributeError:
                    setattr(self, ""_"" + api_name, '')"
2586,"def query_status(self):
        '''Query the hub for the status of this command'''
        try:
            data = self.api_iface._api_get(self.link)
            self._update_details(data)
        except APIError as e:
            print(""API error: "")
            for key,value in e.data.iteritems:
                print(str(key) + "": "" + str(value))"
2587,"def tracks(self):
        """"""
        Tracks list context

        :return: Tracks list context
        """"""
        if self._tracks is None:
            self._tracks = TrackList(self.version, self.id)

        return self._tracks"
2588,"def list(self, ids, market=values.UNSET):
        """"""
        List albums

        :param List[str] ids: List of albums ids
        :param str market: Market locale
        :return: Page of Albums
        :rtype: AlbumPage
        """"""
        params = values.of({
            'ids': ','.join(ids),
            'market': market
        })
        response = self.version.request('GET', '/albums', params=params)
        return AlbumPage(self.version, response.json(), 'albums')"
2589,"def to_string(self):
        """"""
        stringifies version
        :return: string of version
        """"""
        if self.major == -1:
            major_str = 'x'
        else:
            major_str = self.major
        if self.minor == -1:
            minor_str = 'x'
        else:
            minor_str = self.minor
        if self.patch == -1:
            patch_str = 'x'
        else:
            patch_str = self.patch
        return '{0}_{1}_{2}'.format(major_str, minor_str, patch_str)"
2590,"def find(self, binding_id, instance):
        """"""find an instance
        
        Create a new instance and populate it with data stored if it exists.
        
        Args:
            binding_id (string): UUID of the binding
            instance (AtlasServiceInstance.Instance): instance
            
        Returns:
            AtlasServiceBinding: A binding
        """"""
        binding = AtlasServiceBinding.Binding(binding_id, instance)
        self.backend.storage.populate(binding)
        return binding"
2591,"def bind(self, binding, parameters):
        """""" Create the binding
        
        Args:
            binding (AtlasServiceBinding.Binding): Existing or New binding
            parameters (dict): Parameters for the binding
            
        Returns:
            Binding: Status
            
        Raises:
            ErrBindingAlreadyExists: If binding exists but with different parameters
        """"""
        
        if not binding.isProvisioned():
            # Update binding parameters
            binding.parameters = parameters
            
            #  Credentials
            creds = self.backend.config.generate_binding_credentials(binding)
            
            # Binding
            p = self.backend.config.generate_binding_permissions(
                binding,
                DatabaseUsersPermissionsSpecs(creds[""username""],creds[""password""])
                )
            
            try:
                self.backend.atlas.DatabaseUsers.create_a_database_user(p)
            except ErrAtlasConflict:
                # The user already exists. This is not an issue because this is possible that we
                # created it in a previous call that failed later on the broker.
                pass
            
            self.backend.storage.store(binding)
            
            # Bind done
            return Binding(BindState.SUCCESSFUL_BOUND,
                           credentials = creds)
        
        elif binding.parameters == parameters:
            if self.backend.config.isGenerateBindingCredentialsPredictible():
                # Identical and credentials generation is predictible so we can return credentials again.
                creds = self.backend.config.generate_binding_credentials(binding)
                
                return Binding(BindState.IDENTICAL_ALREADY_EXISTS,
                               credentials = creds)
            
            # Identical but credentials generation is NOT predictible. So we are breaking the spec to avoid
            # wrong data injection. In this case we trigger a conflicting parameters for the existing binding depsite
            # this is not the case.
            raise ErrBindingAlreadyExists()
        
        else:
            # Different parameters ...
            raise ErrBindingAlreadyExists()"
2592,"def unbind(self, binding):
        """""" Unbind the instance
        
        Args:
            binding (AtlasServiceBinding.Binding): Existing or New binding
        """"""
        
        username = self.backend.config.generate_binding_username(binding)
        
        try:
            self.backend.atlas.DatabaseUsers.delete_a_database_user(username)
        except ErrAtlasNotFound:
            # The user does not exist. This is not an issue because this is possible that we
            # removed it in a previous call that failed later on the broker.
            # This cover a manually deleted user case too.
            pass

        self.backend.storage.remove(binding)"
2593,"def describe(items, show_methods=True, show_properties=True):
    """"""Detecting attributes, inherits and relations

    :param items: list of objects to describe
    :param show_methods: do detection of methods
    :param show_properties: do detection of properties

    Return tuple (objects, relations, inherits)


    Where objects is list::

        [{
            'name': '<Mapper class name or table name>',
            'cols': [
                ('<Column type class name>', '<Column name>'),
                ...
            ],
            'props': ['<Property name>'],
            'methods': ['<Method name>', ...],
        }, ...]


    Relations is::

        [{
            'from': '<From mapper class name>',
            'by': '<By mapper foreign key column name>',
            'to': '<To mapper class name>',
        }, ...]


    Example usage::

        import sadisplay
        from app import models

        desc = sadisplay.describe([
            getattr(model, attr) for attr in dir(model)
        ])

        desc = sadisplay.describe([models.User, models.Group])
    """"""

    class EntryItem(object):
        """"""Class adaptor for mapped classes and tables""""""
        name = None
        methods = []
        columns = []
        inherits = None
        properties = []
        bases = tuple()

        def __init__(self, mapper=None, table=None):

            if mapper is not None:
                self.name = mapper.class_.__name__
                self.columns = mapper.columns
                self.methods = mapper.class_.__dict__.items()
                self.inherits = mapper.inherits
                self.properties = mapper.iterate_properties
                self.bases = mapper.class_.__bases__
                self.class_ = mapper.class_
                self.table_name = str(mapper.mapped_table)

            elif table is not None:
                self.name = table.name
                self.table_name = table.name
                # prepend schema if exists for foreign key matching
                if hasattr(table, ""schema"") and table.schema:
                    self.table_name = table.schema + ""."" + self.table_name
                self.columns = table.columns
            else:
                pass

        def __repr__(self):
            return '<{s.__class__.__name__} {s.name}>'.format(s=self)

        def __eq__(self, other):
            if other.inherits or self.inherits:
                return self.name == other.name
            return self.table_name == other.table_name

    objects = []
    relations = []
    inherits = []

    entries = []
    for item in items:
        try:
            mapper = class_mapper(item)
        except (exc.ArgumentError, orm.exc.UnmappedClassError):
            if isinstance(item, Table):
                entity = EntryItem(table=item)
            else:
                continue
        else:
            entity = EntryItem(mapper=mapper)

        if entity not in entries:
            entries.append(entity)

    for entry in entries:

        result_item = {
            'name': entry.name,
            'cols': [
                (c.type.__class__.__name__, c.name) for c in entry.columns
            ],
            'props': [],
            'methods': [],
        }

        if show_methods and entry.methods:

            if entry.inherits:
                base_methods = entry.inherits.class_.__dict__.keys()
            else:
                # Create the DummyClass subclass of mapper bases
                # for detecting mapper own methods
                suffix = '%s' % str(uuid.uuid4())
                params = {
                    '__tablename__': 'dummy_table_%s' % suffix,
                    'dummy_id_col': Column(Integer, primary_key=True)
                }

                DummyClass = type('Dummy%s' % suffix, entry.bases, params)

                base_methods = DummyClass.__dict__.keys()

            # Filter mapper methods
            for name, func in entry.methods:
                if name[0] != '_' and name not in base_methods:
                    if isinstance(func, types.FunctionType):
                        result_item['methods'].append(name)

        if show_properties and entry.properties:
            for item in entry.properties:
                if not isinstance(item, ColumnProperty):
                    result_item['props'].append(item.key)

        # ordering
        for key in ('methods', 'props'):
            result_item[key].sort()

        objects.append(result_item)

        # Detect relations by ForeignKey
        for col in entry.columns:
            for fk in col.foreign_keys:
                table = fk.column.table
                for m in entries:
                    try:
                        if str(table) == str(m.table_name):
                            relations.append({
                                'from': entry.name,
                                'by': col.name,
                                'to': m.name,
                            })
                    except AttributeError:
                        pass

        if entry.inherits:

            inh = {
                'child': entry.name,
                'parent': EntryItem(mapper=entry.inherits).name,
            }

            inherits.append(inh)

            # Delete relation by inherits
            for i, rel in enumerate(relations):
                if inh['child'] == rel['from'] and inh['parent'] == rel['to']:
                    relations.pop(i)

    return objects, relations, inherits"
2594,"def extension(names):
    """"""Makes a function to be an extension.""""""
    for name in names:
        if not NAME_PATTERN.match(name):
            raise ValueError('invalid extension name: %s' % name)
    def decorator(f, names=names):
        return Extension(f, names=names)
    return decorator"
2595,"def register(self, extensions):
        """"""Registers extensions.""""""
        for ext in reversed(extensions):
            for name in ext.names:
                try:
                    self._extensions[name].appendleft(ext)
                except KeyError:
                    self._extensions[name] = deque([ext])"
2596,"def eval_extensions(self, value, name, option, format):
        """"""Evaluates extensions in the registry.  If some extension handles the
        format string, it returns a string.  Otherwise, returns ``None``.
        """"""
        try:
            exts = self._extensions[name]
        except KeyError:
            raise ValueError('no suitable extension: %s' % name)
        for ext in exts:
            rv = ext(self, value, name, option, format)
            if rv is not None:
                return rv"
2597,"def matchToFeatures(fiContainer, specContainer, specfiles=None, fMassKey='mz',
                    sMassKey='obsMz', isotopeErrorList=(0),
                    precursorTolerance=5, toleranceUnit='ppm',
                    rtExpansionUp=0.10, rtExpansionDown=0.05, matchCharge=True,
                    scoreKey='pep', largerBetter=False):
    """"""Annotate :class:`Fi <maspy.core.Fi>` (Feature items) by matching
    :class:`Si <maspy.core.Si>` (Spectrum items) or :class:`Sii
    <maspy.core.Sii>` (Spectrum identification items).

    :param fiContainer: :class:`maspy.core.FeatureContainer`, contains ``Fi``.
    :param specContainer: :class:`maspy.core.MsrunContainer` or
        :class:`maspy.core.SiiContainer`, contains ``Si`` or ``Sii``.
    :param specfiles: filenames of ms-run files, if specified consider only
        items from those files
    :type specfiles: str, list or None
    :param fMassKey: mass attribute key in :attr:`Fi.__dict__`
    :param sMassKey: mass attribute key in :attr:`Si.__dict__` or
        :attr:`Sii.__dict__` (eg 'obsMz', 'excMz')
    :param isotopeErrorList: allowed isotope errors relative to the spectrum
        mass, for example ""0"" or ""1"". If no feature has been matched with
        isotope error 0, the spectrum mass is increased by the mass difference
        of carbon isotopes 12 and 13 and matched again. The different isotope
        error values are tested in the specified order therefore ""0"" should
        normally be the first value of the list.
    :type isotopeErrorList: list or tuple of int
    :param precursorTolerance: the largest allowed mass deviation of ``Si`` or
        ``Sii`` relative to ``Fi``
    :param toleranceUnit: defines how the ``precursorTolerance`` is applied to
        the mass value of ``Fi``. ``""ppm"": mass * (1 +/- tolerance*1E-6)`` or
        ``""da"": mass +/- value``
    :param rtExpansionUp: relative upper expansion of ``Fi`` retention time
        area. ``limitHigh = Fi.rtHigh + (Fi.rtHigh - Fi.rtLow) * rtExpansionUp``
    :param rtExpansionDown: relative lower expansion of ``Fi`` retention time
        area. ``limitLow = Fi.rtLow - (Fi.rtHigh - Fi.rtLow) * rtExpansionDown``
    :param matchCharge: bool, True if ``Fi`` and ``Si`` or ``Sii`` must have the
        same ``charge`` state to be matched.
    :param scoreKey: ``Sii`` attribute name used for scoring the identification
        reliability
    :param largerBetter: bool, True if higher score value means a better
        identification reliability

    .. note:
        Concerning the feature retention area expansion. If ``Si`` or ``Sii`` is
        matched to multiple ``Fi`` the rt expansion is removed and the matching
        is repeated.

    .. note:
        If the ``specContainer`` is a ``SiiContainer`` then matched ``Fi`` are
        annotated with :attr:`Sii.peptide`, if multiple ``Sii`` are matched to
        ``Fi`` the one with the best score is used.

    #TODO: this function is nested pretty badly and should maybe be rewritten
    #TODO: replace tolerance unit ""ppm"" by tolerance mode ""relative"" and change
        repsective calculations
    """"""
    isotopeErrorList = aux.toList(isotopeErrorList)

    if specContainer.__class__.__name__ == 'MsrunContainer':
        listKeySpecIds = 'siIds'
    else:
        listKeySpecIds = 'siiIds'
    specContainerSpecfiles = [_ for _ in viewkeys(specContainer.info)]

    if specfiles is not None:
        specfiles = aux.toList(specfiles)
    else:
        specfiles = [_ for _ in viewkeys(fiContainer.info)]
    specfiles = list(set(specfiles).intersection(set(specContainerSpecfiles)))

    for specfile in specfiles:
        multiMatchCounter = int()
        isotopeErrorMatchCounter = int()
        specArrays = specContainer.getArrays([sMassKey, 'rt', 'charge',
                                              'msLevel'], specfiles=specfile
                                              )
        featureArrays = fiContainer.getArrays(['rtHigh', 'rtLow', 'charge',
                                               fMassKey], specfiles=specfile,
                                               sort=fMassKey
                                              )
        featureArrays['rtHighExpanded'] = (featureArrays['rtHigh'] +
                                           (featureArrays['rtHigh'] -
                                            featureArrays['rtLow']) *
                                           rtExpansionUp
                                           )
        featureArrays['rtLowExpanded'] = (featureArrays['rtLow'] -
                                          (featureArrays['rtHigh'] -
                                           featureArrays['rtLow']) *
                                          rtExpansionDown
                                          )

        specFeatureDict = dict() ## key = scanNr, value = set(featureKeys)
        featureSpecDict = dict() ## key = featureKey, value = set(scanNrs)

        for specPos, specId in enumerate(specArrays['id']):
            specZ = specArrays['charge'][specPos]
            if specZ is None:
                continue
            specMass = specArrays[sMassKey][specPos]
            specRt = specArrays['rt'][specPos]

            matchComplete = False
            isotopeErrorPos = 0

            while not matchComplete:
                isotopeError = isotopeErrorList[isotopeErrorPos]

                # calculate mass limits for each isotope error
                if toleranceUnit.lower() == 'ppm':
                    specMassHigh = ((specMass + isotopeError * 1.003355 / specZ)
                                    * (1 + precursorTolerance*1E-6)
                                    )
                    specMassLow = ((specMass + isotopeError * 1.003355 / specZ)
                                   * (1 - precursorTolerance*1E-6)
                                   )
                elif toleranceUnit.lower() == 'da':
                    specMassHigh = ((specMass + isotopeError * 1.003355 / specZ)
                                    + precursorTolerance
                                    )
                    specMassLow  = ((specMass + isotopeError * 1.003355 / specZ)
                                    - precursorTolerance
                                    )

                posL = bisect.bisect_left(featureArrays[fMassKey],
                                          specMassLow
                                          )
                posR = bisect.bisect_right(featureArrays[fMassKey],
                                           specMassHigh
                                           )

                if matchCharge:
                    chargeMask = (featureArrays['charge'][posL:posR] == specZ)

                fRtHighKey = 'rtHighExpanded'
                fRtLowKey = 'rtLowExpanded'
                for fRtHighKey, fRtLowKey in [('rtHighExpanded',
                                               'rtLowExpanded'),
                                              ('rtHigh', 'rtLow')
                                              ]:
                    rtMask = ((featureArrays[fRtLowKey][posL:posR] <= specRt) &
                              (featureArrays[fRtHighKey][posL:posR] >= specRt)
                              )
                    if matchCharge:
                        matchedFeatureIds = featureArrays['id'][posL:posR][rtMask & chargeMask]
                    else:
                        matchedFeatureIds = featureArrays['id'][posL:posR][rtMask]

                    if len(matchedFeatureIds) <= 1:
                        break

                # if exactly one feature has been matched,
                if len(matchedFeatureIds) > 0:
                    if len(matchedFeatureIds) == 1:
                        matchComplete = True
                        if isotopeErrorList[isotopeErrorPos] != 0:
                            isotopeErrorMatchCounter += 1
                    else:
                        #Stop if Spectrum can be matched to multiple features
                        multiMatchCounter += 1
                        break

                isotopeErrorPos += 1
                if isotopeErrorPos >= len(isotopeErrorList):
                    #Stop if all allowed isotope errors have been tested
                    break

            if matchComplete:
                for featureId in matchedFeatureIds:
                    getattr(fiContainer.container[specfile][featureId],
                            listKeySpecIds
                            ).append(specId)
                    fiContainer.container[specfile][featureId].isMatched = True
                    specFeatureDict[specId] = featureId
                    featureSpecDict[featureId] = specId

        stats = dict()
        stats['totalFeatures'] = len(featureArrays['id'])
        stats['matchedFeatures'] = len(featureSpecDict)
        stats['relMatchedFeatures'] = round(100*stats['matchedFeatures']/stats['totalFeatures'], 1)
        stats['totalSpectra'] = len(specArrays['id'][(specArrays['msLevel'] != 1)])
        stats['matchedSpectra'] = len(specFeatureDict)
        stats['relMatchedSpectra'] = round(100*stats['matchedSpectra']/stats['totalSpectra'], 1)

        print('------', specfile, '------')
        print('Annotated features:\t\t\t', stats['matchedFeatures'], '/', stats['totalFeatures'], '=', stats['relMatchedFeatures'], '%')
        print('Spectra matched to features:\t\t', stats['matchedSpectra'], '/', stats['totalSpectra'], '=', stats['relMatchedSpectra'], '%')
        if multiMatchCounter != 0:
                print('Discarded because of multiple matches:\t', multiMatchCounter)
        if isotopeErrorMatchCounter != 0:
                print('Isotope error matched spectra:\t\t', isotopeErrorMatchCounter)

        #annotate feature with sii information (peptide, sequence, score)
        if isinstance(specContainer, maspy.core.SiiContainer):
            for featureId in viewkeys(featureSpecDict):
                matches = list()
                for specId in fiContainer.container[specfile][featureId].siiIds:
                    _sii = specContainer.getValidItem(specfile, specId)
                    score = getattr(_sii, scoreKey)
                    peptide = _sii.peptide
                    sequence = _sii.sequence
                    matches.append([score, peptide, sequence])
                matches.sort(reverse=largerBetter)

                fiContainer.container[specfile][featureId].isAnnotated = True
                fiContainer.container[specfile][featureId].score = matches[0][0]
                fiContainer.container[specfile][featureId].peptide = matches[0][1]
                fiContainer.container[specfile][featureId].sequence = matches[0][2]"
2598,"def rtCalibration(fiContainer, allowedRtDev=60, allowedMzDev=2.5,
                  reference=None, specfiles=None, showPlots=False,
                  plotDir=None, minIntensity=1e5):
    """"""Performs a retention time calibration between :class:`FeatureItem` of multiple specfiles.

    :ivar fiContainer: Perform alignment on :class:`FeatureItem` in :attr:`FeatureContainer.specfiles`
    :ivar allowedRtDev: maxium retention time difference of two features in two runs to be matched
    :ivar allowedMzDev: maxium relative m/z difference (in ppm) of two features in two runs to be matched
    :ivar showPlots: boolean, True if a plot should be generated which shows to results of the calibration
    :ivar plotDir: if not None and showPlots is True, the plots are saved to
        this location.
    :ivar reference: Can be used to specifically specify a reference specfile
    :ivar specfiles: Limit alignment to those specfiles in the fiContainer
    :ivar minIntensity: consider only features with an intensity above this value
    """"""
    #TODO: long function, maybe split into subfunctions
    specfiles = [_ for _ in viewkeys(fiContainer.info)] if specfiles is None else specfiles
    matchCharge = True

    refMzKey = 'mz'
    mzKey = 'mz'

    if reference is not None:
        if reference in specfiles:
            specfiles = [reference] + list(set(specfiles).difference(set([reference])))
        else:
            print('Specified reference specfile not present, using reference: ', specfiles[0])

    for featureItem in fiContainer.getItems(specfiles=specfiles):
        if not hasattr(featureItem, 'obsRt'):
            setattr(featureItem, 'obsRt', featureItem.rt)

    referenceArrays = None
    for specfile in specfiles:
        featureArrays = fiContainer.getArrays(['rt', 'charge', 'mz', 'intensity'],
                                              specfiles=specfile, sort='rt'
                                              )
        if minIntensity is not None:
            intensityMask = (featureArrays['intensity'] > minIntensity)
            for key in list(viewkeys(featureArrays)):
                featureArrays[key] = featureArrays[key][intensityMask]

        if referenceArrays is None:
            referenceArrays = featureArrays
            if showPlots:
                print('Reference: '+specfile)
            continue

        rtPosList = list()
        rtDevList = list()
        mzDevRelList = list()
        mzDevAbsList = list()

        for featurePos in range(len(featureArrays[mzKey])):
            currRt = featureArrays['rt'][featurePos]
            currMz = featureArrays[mzKey][featurePos]
            currZ = featureArrays['charge'][featurePos]
            mzLimitUp = currMz*(1+allowedMzDev*1E-6)
            mzLimitLow = currMz*(1-allowedMzDev*1E-6)
            rtLimitUp = currRt+allowedRtDev
            rtLimitLow = currRt-allowedRtDev

            posL = bisect.bisect_left(referenceArrays['rt'], rtLimitLow)
            posU = bisect.bisect_right(referenceArrays['rt'], rtLimitUp)

            refMask = (referenceArrays[refMzKey][posL:posU] <= mzLimitUp) & (referenceArrays[refMzKey][posL:posU] >= mzLimitLow)
            if matchCharge:
                refMask = refMask & (referenceArrays['charge'][posL:posU] == currZ)

            currMzDev = abs(referenceArrays[refMzKey][posL:posU][refMask] - currMz)
            bestHitMask = currMzDev.argsort()
            for refRt, refMz in zip(referenceArrays['rt'][posL:posU][refMask][bestHitMask],
                                    referenceArrays[refMzKey][posL:posU][refMask][bestHitMask]):
                rtPosList.append(currRt)
                rtDevList.append(currRt - refRt)
                mzDevRelList.append((1 - currMz / refMz)*1E6)
                mzDevAbsList.append(currMz - refMz)
                break

        rtPosList = numpy.array(rtPosList)
        rtDevList = numpy.array(rtDevList)

        splineInitialKnots = int(max(rtPosList) - min(rtPosList))
        dataFit = aux.DataFit(rtDevList, rtPosList)
        dataFit.splineInitialKnots = splineInitialKnots
        dataFit.splineTerminalExpansion = 0.2
        dataFit.processInput(dataAveraging='median', windowSize=10)
        dataFit.generateSplines()

        if showPlots:
            corrDevArr = rtDevList - dataFit.corrArray(rtPosList)
            timePoints = [min(rtPosList) + x for x in range(int(max(rtPosList)-min(rtPosList)))]
            corrValues  = dataFit.corrArray(timePoints)
            fig, ax = plt.subplots(3, 2, sharex=False, sharey=False, figsize=(20, 18))
            fig.suptitle(specfile)
            ax[0][0].hist(rtDevList, bins=100, color='grey', alpha=0.5, label='observed')
            ax[0][0].hist(corrDevArr, bins=100, color='red', alpha=0.5, label='corrected')
            ax[0][0].set_title('Retention time deviation')
            ax[0][0].legend()
            ax[0][0].set_xlim(allowedRtDev*-1, allowedRtDev)
            ax[0][1].hist(mzDevRelList, bins=100, color='grey')
            ax[0][1].set_title('Mz deviation [ppm]')
            ax[1][0].scatter(rtPosList, rtDevList, color='grey', alpha=0.1, label='observed')
            ax[1][0].plot(timePoints,corrValues, color='red', alpha=0.5, label='correction function')
            ax[1][0].set_title('Retention time deviation over time')
            ax[1][0].legend()
            ax[1][0].set_ylim(allowedRtDev*-1, allowedRtDev)
            ax[1][1].scatter(rtPosList, mzDevRelList, color='grey', alpha=0.1)
            ax[1][1].set_title('Mz deviation over time')
            ax[1][1].set_ylim(allowedMzDev*-1, allowedMzDev)
            ax[2][0].scatter(rtPosList, corrDevArr, color='grey', alpha=0.1)
            ax[2][0].set_title('Aligned retention time deviation over time')
            ax[2][0].set_ylim(allowedRtDev*-1, allowedRtDev)
            if plotDir is not None:
                plotloc = aux.joinpath(plotDir, specfile+'.rtAlign.png')
                fig.savefig(plotloc)
            else:
                fig.show()

        featureArrays = fiContainer.getArrays(['rt'], specfiles=specfile, sort='rt')
        featureArrays['corrRt'] = featureArrays['rt'] - dataFit.corrArray(featureArrays['rt'])
        for featureId, corrRt, rt in zip(featureArrays['id'], featureArrays['corrRt'], featureArrays['rt']):
            fiContainer.container[specfile][featureId].rt = corrRt"
2599,"def GetShowDetails(self):
    """"""
    Extract show name, season number and episode number from file name.

    Supports formats S<NUM>E<NUM> or <NUM>x<NUM> for season and episode numbers
    where letters are case insensitive and number can be one or more digits. It
    expects season number to be unique however it can handle either single or
    multipart episodes (consecutive values only).

    All information preceeding season number is used for the show name lookup. This
    string is forced to lowercase and stripped of special characters

    Returns
    ----------
      boolean
        False if an incompatible file name is found, otherwise return True.
    """"""

    fileName = os.path.splitext(os.path.basename(self.fileInfo.origPath))[0]

    # Episode Number
    episodeNumSubstring = set(re.findall(""(?<=[0-9])[xXeE][0-9]+(?:[xXeE_.-][0-9]+)*"", fileName))

    if len(episodeNumSubstring) != 1:
      goodlogging.Log.Info(""TVFILE"", ""Incompatible filename no episode match detected: {0}"".format(self.fileInfo.origPath))
      return False

    episodeNumSet = set(re.findall(""(?<=[xXeE_.-])[0-9]+"", episodeNumSubstring.pop()))

    episodeNumList = [int(i) for i in episodeNumSet]
    episodeNumList.sort()

    episodeNum = ""{0}"".format(episodeNumList[0])
    if len(episodeNumList) > 1:
      episodeNumReference = episodeNumList[0]
      for episodeNumIter in episodeNumList[1:]:
        if episodeNumIter == (episodeNumReference+1):
          strNum = ""{0}"".format(episodeNumIter)
          if len(strNum) == 1:
            strNum = ""0{0}"".format(strNum)

          self.showInfo.multiPartEpisodeNumbers.append(strNum)
          episodeNumReference = episodeNumIter
        else:
          break

    if len(episodeNum) == 1:
      episodeNum = ""0{0}"".format(episodeNum)

    self.showInfo.episodeNum = episodeNum

    # Season Number
    seasonNumSet = set(re.findall(""[sS]([0-9]+)"", fileName))
    preceedingS = True

    if len(seasonNumSet) == 1:
      seasonNum = seasonNumSet.pop()
    else:
      seasonNumSet = set(re.findall(""([0-9]+)[xX](?:[0-9]+[xX])*"", fileName))
      preceedingS = False

      if len(seasonNumSet) == 1:
        seasonNum = seasonNumSet.pop()
      else:
        goodlogging.Log.Info(""TVFILE"", ""Incompatible filename no season match detected: {0}"".format(self.fileInfo.origPath))
        return False

    if len(seasonNum) == 1:
      seasonNum = ""0{0}"".format(seasonNum)

    self.showInfo.seasonNum = seasonNum

    # Show Name
    if preceedingS is True:
      showNameList = re.findall(""(.+?)\s*[_.-]*\s*[sS][0-9]+[xXeE][0-9]+.*"", fileName)
    else:
      showNameList = re.findall(""(.+?)\s*[_.-]*\s*[0-9]+[xXeE][0-9]+.*"", fileName)

    if len(showNameList) == 1:
      showName = util.StripSpecialCharacters(showNameList[0].lower(), stripAll=True)
    else:
      goodlogging.Log.Info(""TVFILE"", ""Incompatible filename no show name detected: {0}"".format(self.fileInfo.origPath))
      return False

    self.fileInfo.showName = showName
    return True"
2600,"def GenerateNewFileName(self):
    """"""
    Create new file name from show name, season number, episode number
    and episode name in format ShowName.S<NUM>.E<NUM>.EpisodeName.

    Returns
    ----------
      string
        New file name in format ShowName.S<NUM>.E<NUM>.EpisodeName.
    """"""
    if self.showInfo.showName is not None and self.showInfo.seasonNum is not None and \
       self.showInfo.episodeNum is not None and self.showInfo.episodeName is not None:
      ext = os.path.splitext(self.fileInfo.origPath)[1]
      newFileName = ""{0}.S{1}E{2}"".format(self.showInfo.showName, self.showInfo.seasonNum, \
                                            self.showInfo.episodeNum)

      for episodeNum in self.showInfo.multiPartEpisodeNumbers:
        newFileName = newFileName + ""_{0}"".format(episodeNum)

      newFileName = newFileName + "".{0}{1}"".format(self.showInfo.episodeName, ext)
      newFileName = util.StripSpecialCharacters(newFileName)
      return newFileName"
2601,"def GenerateNewFilePath(self, fileDir = None):
    """"""
    Create new file path. If a fileDir is provided it will be used otherwise
    the original file path is used. Updates file info object with new path.

    Parameters
    ----------
      fileDir : string [optional : default = None]
        Optional file directory
    """"""
    newFileName = self.GenerateNewFileName()
    if newFileName is not None:
      if fileDir is None:
        fileDir = os.path.dirname(self.fileInfo.origPath)
      self.fileInfo.newPath = os.path.join(fileDir, newFileName)"
2602,"def Print(self):
    """""" Print contents of showInfo and FileInfo object """"""
    goodlogging.Log.Info(""TVFILE"", ""TV File details are:"")
    goodlogging.Log.IncreaseIndent()
    goodlogging.Log.Info(""TVFILE"", ""Original File Path      = {0}"".format(self.fileInfo.origPath))
    if self.showInfo.showName is not None:
      goodlogging.Log.Info(""TVFILE"", ""Show Name (from guide)  = {0}"".format(self.showInfo.showName))
    elif self.fileInfo.showName is not None:
      goodlogging.Log.Info(""TVFILE"", ""Show Name (from file)   = {0}"".format(self.fileInfo.showName))
    if self.showInfo.seasonNum is not None and self.showInfo.episodeNum is not None:
      goodlogging.Log.Info(""TVFILE"", ""Season & Episode        = S{0}E{1}"".format(self.showInfo.seasonNum, self.showInfo.episodeNum))
    if self.showInfo.episodeName is not None:
      goodlogging.Log.Info(""TVFILE"", ""Episode Name:           = {0}"".format(self.showInfo.episodeName))
    if self.fileInfo.newPath is not None:
      goodlogging.Log.Info(""TVFILE"", ""New File Path           = {0}"".format(self.fileInfo.newPath))
    goodlogging.Log.DecreaseIndent()"
2603,"def connectProcess(connection, processProtocol, commandLine='', env={},
                   usePTY=None, childFDs=None, *args, **kwargs):
    """"""Opens a SSHSession channel and connects a ProcessProtocol to it

    @param connection: the SSH Connection to open the session channel on
    @param processProtocol: the ProcessProtocol instance to connect to the process
    @param commandLine: the command line to execute the process
    @param env: optional environment variables to set for the process
    @param usePTY: if set, request a PTY for the process
    @param childFDs: custom child file descriptors for the process
    """"""
    processOpenDeferred = defer.Deferred()
    process = SSHProcess(processProtocol, commandLine, env, usePTY, childFDs,
                         *args, **kwargs)
    process.processOpen = processOpenDeferred.callback
    process.openFailed = processOpenDeferred.errback

    connection.openChannel(process)
    return processOpenDeferred"
2604,"def get_api_publisher(self, social_user):
        """"""
            owner_id - VK user or group
            from_group - 1 by group, 0 by user
            message - text
            attachments - comma separated links or VK resources ID's
            and other https://vk.com/dev.php?method=wall.post
        """"""

        def _post(**kwargs):
            api = self.get_api(social_user)
            response = api.wall.post(**kwargs)
            return response

        return _post"
2605,"def get_api_publisher(self, social_user):
        """"""
            files: {'file0':<file>}
            message: 'mess'
        """"""

        def _post(**kwargs):
            api = self.get_api(social_user)
            author = {
                'group_id': kwargs.get('group_id'),
                'user_id': kwargs.get('user_id'),
            }
            server_data = api.photos.getWallUploadServer(**author)
            attachments = []

            for _file in kwargs['files']:
                upload_data = requests.post(
                    server_data['upload_url'], files={""photo"": _file}).json()
                upload_data.update(author)
                photos_data = api.photos.saveWallPhoto(**upload_data)
                attachments.append('photo{owner_id}_{id}'.format(**photos_data[0]))

            del kwargs['files']
            kwargs['attachments'] = ','.join(attachments)
            response = api.wall.post(**kwargs)

            server_data.update(response)
            return server_data

        return _post"
2606,"def call_builder_init(cls, kb_app, sphinx_app: Sphinx):
        """""" On builder init event, commit registry and do callbacks """"""

        # Find and commit docs project plugins
        conf_dir = sphinx_app.confdir
        plugins_dir = sphinx_app.config.kaybee_settings.plugins_dir
        full_plugins_dir = os.path.join(conf_dir, plugins_dir)

        if os.path.exists(full_plugins_dir):
            sys.path.insert(0, conf_dir)
            plugin_package = importlib.import_module(plugins_dir)
            importscan.scan(plugin_package)
        else:
            logger.info(f'## Kaybee: No plugin dir at {plugins_dir}')

        dectate.commit(kb_app)
        for callback in cls.get_callbacks(kb_app, SphinxEvent.BI):
            callback(kb_app, sphinx_app)"
2607,"def call_purge_doc(cls, kb_app, sphinx_app: Sphinx,
                       sphinx_env: BuildEnvironment,
                       docname: str):
        """""" On env-purge-doc, do callbacks """"""

        for callback in EventAction.get_callbacks(kb_app, SphinxEvent.EPD):
            callback(kb_app, sphinx_app, sphinx_env, docname)"
2608,"def call_env_before_read_docs(cls, kb_app, sphinx_app: Sphinx,
                                  sphinx_env: BuildEnvironment,
                                  docnames: List[str]):
        """""" On env-read-docs, do callbacks""""""

        for callback in EventAction.get_callbacks(kb_app,
                                                  SphinxEvent.EBRD):
            callback(kb_app, sphinx_app, sphinx_env, docnames)"
2609,"def call_env_doctree_read(cls, kb_app, sphinx_app: Sphinx,
                              doctree: doctree):
        """""" On doctree-read, do callbacks""""""

        for callback in EventAction.get_callbacks(kb_app,
                                                  SphinxEvent.DREAD):
            callback(kb_app, sphinx_app, doctree)"
2610,"def call_doctree_resolved(cls, kb_app, sphinx_app: Sphinx,
                              doctree: doctree,
                              fromdocname: str):
        """""" On doctree-resolved, do callbacks""""""

        for callback in EventAction.get_callbacks(kb_app,
                                                  SphinxEvent.DRES):
            callback(kb_app, sphinx_app, doctree, fromdocname)"
2611,"def call_env_updated(cls, kb_app,
                         sphinx_app: Sphinx,
                         sphinx_env: BuildEnvironment):

        """""" On the env-updated event, do callbacks """"""
        for callback in EventAction.get_callbacks(kb_app, SphinxEvent.EU):
            callback(kb_app, sphinx_app, sphinx_env)"
2612,"def call_html_collect_pages(cls, kb_app, sphinx_app: Sphinx):
        """""" On html-collect-pages, do callbacks""""""

        EventAction.get_callbacks(kb_app,
                                  SphinxEvent.HCP)
        for callback in EventAction.get_callbacks(kb_app,
                                                  SphinxEvent.HCP):
            yield callback(kb_app, sphinx_app)"
2613,"def call_env_check_consistency(cls, kb_app, builder: StandaloneHTMLBuilder,
                                   sphinx_env: BuildEnvironment):
        """""" On env-check-consistency, do callbacks""""""

        for callback in EventAction.get_callbacks(kb_app,
                                                  SphinxEvent.ECC):
            callback(kb_app, builder, sphinx_env)"
2614,"def call_missing_reference(cls, kb_app, sphinx_app: Sphinx,
                               sphinx_env: BuildEnvironment,
                               node,
                               contnode,
                               ):
        """""" On doctree-resolved, do callbacks""""""

        for callback in EventAction.get_callbacks(kb_app,
                                                  SphinxEvent.MR):
            return callback(kb_app, sphinx_app, sphinx_env, node, contnode)"
2615,"def call_html_page_context(cls, kb_app, sphinx_app: Sphinx,
                               pagename: str,
                               templatename: str,
                               context,
                               doctree: doctree
                               ):
        """""" On doctree-resolved, do callbacks""""""

        # We need to let one, and only one, callback return the name of
        # the template. Detect multiple and raise an exception.
        new_templatename = None

        for callback in EventAction.get_callbacks(kb_app,
                                                  SphinxEvent.HPC):
            # The protocol: the one controlling callback will return a value
            # with a dictionary of {'templatename': 'sometemplate'}
            result = callback(kb_app, sphinx_app, pagename, templatename,
                              context,
                              doctree)
            if result and isinstance(result,
                                     dict) and 'templatename' in result:
                if new_templatename is not None:
                    raise AssertionError('Multiple handlers returning')
                new_templatename = result['templatename']

        return new_templatename"
2616,"def get_layout_template(self, template_name=None):
        """"""
        Returns the layout template to use when rendering the form to HTML.

        Preference of template selection:

        1. Provided method argument `template_name`
        2. Form class property `layout_template`
        3. Globally defined default template from `defaults.LAYOUT_DEFAULT_TEMPLATE`

        :param template_name: Optional template to use instead of other configurations.
        :return: Template name to use when rendering the form.
        """"""
        if template_name:
            return template_name

        if self.layout_template:
            return self.layout_template

        return defaults.LAYOUT_DEFAULT_TEMPLATE"
2617,"def get_layout_context(self):
        """"""
        Returns the context which is used when rendering the form to HTML.

        The generated template context will contain the following variables:

        * form: `Form` instance
        * errors: `ErrorList` instance with non field errors and hidden field errors
        * hidden_fields: All hidden fields to render.
        * visible_fields: All visible fields to render.

        :return: Template context for form rendering.
        """"""
        errors = self.non_field_errors()
        for field in self.hidden_fields():
            errors.extend(field.errors)

        return {
            'form': self,
            'errors': errors,
            'hidden_fields': self.hidden_fields(),
            'visible_fields': self.visible_fields(),
        }"
2618,"def full_clean(self, *args, **kwargs):
        """"""
        The full_clean method is hijacked to apply special treatment to invalid
        field inputs. For example adding extra options/classes to widgets.
        """"""
        super().full_clean(*args, **kwargs)
        for field in self.errors:
            if field != NON_FIELD_ERRORS:
                self.apply_widget_invalid_options(field)"
2619,"def get_field_template(self, bound_field, template_name=None):
        """"""
        Returns the field template to use when rendering a form field to HTML.

        Preference of template selection:

        1. Provided method argument `template_name`
        2. Template from `field_template_overrides` selected by field name
        3. Template from `field_template_overrides` selected by field class
        4. Form class property `field_template`
        5. Globally defined default template from `defaults.LAYOUT_FIELD_TEMPLATE`

        :param bound_field: `BoundField` instance to select a template for.
        :param template_name: Optional template to use instead of other configurations.
        :return: Template name to use when rendering the form field.
        """"""
        if template_name:
            return template_name

        templates = self.field_template_overrides or {}

        template_name = templates.get(bound_field.name, None)
        if template_name:
            return template_name

        template_name = templates.get(bound_field.field.__class__, None)
        if template_name:
            return template_name

        if self.field_template:
            return self.field_template

        return defaults.FIELD_DEFAULT_TEMPLATE"
2620,"def get_field_label_css_class(self, bound_field):
        """"""
        Returns the optional label CSS class to use when rendering a field template.

        By default, returns the Form class property `field_label_css_class`. If the
        field has errors and the Form class property `field_label_invalid_css_class`
        is defined, its value is appended to the CSS class.

        :param bound_field: `BoundField` instance to return CSS class for.
        :return: A CSS class string or `None`
        """"""
        class_name = self.field_label_css_class

        if bound_field.errors and self.field_label_invalid_css_class:
            class_name = join_css_class(
                class_name, self.field_label_invalid_css_class)

        return class_name or None"
2621,"def get_field_context(self, bound_field):
        """"""
        Returns the context which is used when rendering a form field to HTML.

        The generated template context will contain the following variables:

        * form: `Form` instance
        * field: `BoundField` instance of the field
        * field_id: Field ID to use in `<label for="".."">`
        * field_name: Name of the form field to render
        * errors: `ErrorList` instance with errors of the field
        * required: Boolean flag to signal if the field is required or not
        * label: The label text of the field
        * label_css_class: The optional label CSS class, might be `None`
        * help_text: Optional help text for the form field. Might be `None`
        * container_css_class: The CSS class for the field container.
        * widget_class_name: Lowercased version of the widget class name (e.g. 'textinput')
        * widget_input_type: `input_type` property of the widget instance,
          falls back to `widget_class_name` if not available.

        :return: Template context for field rendering.
        """"""
        widget = bound_field.field.widget
        widget_class_name = widget.__class__.__name__.lower()

        # Check if we have an overwritten id in widget attrs,
        # if not use auto_id of bound field.
        field_id = widget.attrs.get('id') or bound_field.auto_id
        if field_id:
            field_id = widget.id_for_label(field_id)

        return {
            'form': self,
            'field': bound_field,
            'field_id': field_id,
            'field_name': bound_field.name,
            'errors': bound_field.errors,
            'required': bound_field.field.required,
            'label': bound_field.label,
            'label_css_class': self.get_field_label_css_class(bound_field),
            'help_text': mark_safe(bound_field.help_text) if bound_field.help_text else None,
            'container_css_class': self.get_field_container_css_class(bound_field),
            'widget_class_name': widget_class_name,
            'widget_input_type': getattr(widget, 'input_type', None) or widget_class_name
        }"
2622,"def apply_widget_options(self, field_name):
        """"""
        Applies additional widget options like changing the input type of DateInput
        and TimeInput to ""date"" / ""time"" to enable Browser date pickers or other
        attributes/properties.
        """"""
        widget = self.fields[field_name].widget

        if isinstance(widget, forms.DateInput):
            widget.input_type = 'date'

        if isinstance(widget, forms.TimeInput):
            widget.input_type = 'time'

        if isinstance(widget, forms.SplitDateTimeWidget):
            widget.widgets[0].input_type = 'date'
            widget.widgets[1].input_type = 'time'"
2623,"def apply_widget_template(self, field_name):
        """"""
        Applies widget template overrides if available.

        The method uses the `get_widget_template` method to determine if the widget
        template should be exchanged. If a template is available, the template_name
        property of the widget instance is updated.

        :param field_name: A field name of the form.
        """"""
        field = self.fields[field_name]
        template_name = self.get_widget_template(field_name, field)

        if template_name:
            field.widget.template_name = template_name"
2624,"def get_widget_template(self, field_name, field):
        """"""
        Returns the optional widget template to use when rendering the widget
        for a form field.

        Preference of template selection:
            1. Template from `widget_template_overrides` selected by field name
            2. Template from `widget_template_overrides` selected by widget class

        By default, returns `None` which means ""use Django's default widget template"".

        :param field_name: The field name to select a widget template for.
        :param field: `Field` instance to return a widget template.
        :return: Template name to use when rendering the widget or `None`
        """"""
        templates = self.widget_template_overrides or {}

        template_name = templates.get(field_name, None)
        if template_name:
            return template_name

        template_name = templates.get(field.widget.__class__, None)
        if template_name:
            return template_name

        return None"
2625,"def apply_widget_css_class(self, field_name):
        """"""
        Applies CSS classes to widgets if available.

        The method uses the `get_widget_css_class` method to determine if the widget
        CSS class should be changed. If a CSS class is returned, it is appended to
        the current value of the class property of the widget instance.

        :param field_name: A field name of the form.
        """"""
        field = self.fields[field_name]
        class_name = self.get_widget_css_class(field_name, field)

        if class_name:
            field.widget.attrs['class'] = join_css_class(
                field.widget.attrs.get('class', None), class_name)"
2626,"def apply_widget_invalid_options(self, field_name):
        """"""
        Applies additional widget options for an invalid field.

        This method is called when there is some error on a field to apply
        additional options on its widget. It does the following:

        * Sets the aria-invalid property of the widget for accessibility.
        * Adds an invalid CSS class, which is determined by the returned value
          of `get_widget_invalid_css_class` method. If a CSS class is returned,
          it is appended to the current value of the class property of the widget.

        :param field_name: A field name of the form.
        """"""
        field = self.fields[field_name]
        class_name = self.get_widget_invalid_css_class(field_name, field)

        if class_name:
            field.widget.attrs['class'] = join_css_class(
                field.widget.attrs.get('class', None), class_name)

        field.widget.attrs['aria-invalid'] = 'true'"
2627,"def use_quandl_data(self, authtoken):
        """"""
        Use quandl data to build conversion table
        """"""
        dfs = {}
        st = self.start.strftime(""%Y-%m-%d"")
        at = authtoken
        for pair in self.pairs:
            symbol = """".join(pair)
            qsym = ""CURRFX/{}"".format(symbol)
            dfs[symbol] = qdl.get(qsym,authtoken=at, trim_start=st)['Rate']
            
        self.build_conversion_table(dfs)"
2628,"def use_trump_data(self, symbols):
        """"""
        Use trump data to build conversion table
        
        symbols : 
            list of symbols:
                will attempt to use units to build the conversion table,
                strings represent symbol names.
        """"""
        dfs = {sym.units : sym.df[sym.name] for sym in symbols}
               
        self.build_conversion_table(dfs)"
2629,"def build_conversion_table(self, dataframes):
        """"""
        Build conversion table from a dictionary of dataframes
        """"""
        self.data = pd.DataFrame(dataframes)
        tmp_pairs = [s.split(""/"") for s in self.data.columns]
        self.data.columns = pd.MultiIndex.from_tuples(tmp_pairs)"
2630,"def match_tweet(self, tweet, user_stream):
        """"""
        Check if a tweet matches the defined criteria

        :param tweet: The tweet in question
        :type tweet: :class:`~responsebot.models.Tweet`
        :return: True if matched, False otherwise
        """"""
        if user_stream:
            if len(self.track) > 0:
                return self.is_tweet_match_track(tweet)

            return True

        return self.is_tweet_match_track(tweet) or self.is_tweet_match_follow(tweet)"
2631,"def find(self, _id, instance = None):
        """""" Find
        
        Args:
            _id (str): instance id or binding Id
            
        Keyword Arguments:
            instance (AtlasServiceInstance.Instance): Existing instance
            
        Returns:
            AtlasServiceInstance.Instance or AtlasServiceBinding.Binding: An instance or binding. 
        """"""
        
        if instance is None:
            # We are looking for an instance
            return self.service_instance.find(_id)
        else:
            # We are looking for a binding
            return self.service_binding.find(_id, instance)"
2632,"def create(self, instance, parameters, existing=True):
        """"""Create an instance
        
        Args:
            instance (AtlasServiceInstance.Instance): Existing or New instance
            parameters (dict): Parameters for the instance
            
        Keyword Arguments:
            existing (bool): True (use an existing cluster), False (create a new cluster)
        
        Returns:
            ProvisionedServiceSpec: Status
        """"""
        return self.service_instance.create(instance, parameters, existing)"
2633,"def index(self, req, drivers):
        """"""List all network
        List all of netowrks on some special cloud
        with:
        :Param  req
        :Type   object Request
        """"""
        result = []
        for driver in drivers:
            result.append(driver.list_network(req.params))
        data = {
                'action': ""index"",
                'controller': ""network"",
                'cloud': req.environ['calplus.cloud'],
                'result': result
        }
        return data"
2634,"def delete(self, req, driver):
        """"""Delete a network
        Delete a specific netowrk with id on special cloud
        with:
        :Param  req
        :Type   object Request
        """"""
        response = driver.delete_network(req.params, id)
        data = {
            'action': ""delete"",
            'controller': ""network"",
            'id': id,
            'cloud': req.environ['calplus.cloud'],
            'response': response
        }
        return data"
2635,"def update(self, req, driver):
        """"""Update a network
        Update a specific netowrk with id on special cloud
        with:
        :Param  req
        :Type   object Request
        """"""
        response = driver.update_network(req.params, id)
        data = {
            'action': ""update"",
            'controller': ""network"",
            'id': id,
            'cloud': req.environ['calplus.cloud'],
            'response': response
        }
        return data"
2636,"def create(self, req, driver):
        """"""Create a network
        Create a new netowrk on special cloud
        with:
        :Param  req
        :Type   object Request
        """"""
        response = driver.create_network(req.params)
        data = {
            'action': ""create"",
            'controller': ""network"",
            'cloud': req.environ['calplus.cloud'],
            'response': response
        }
        return data"
2637,"def get(self, req, driver):
        """"""Get info of a network
        Get info of a specific netowrk with id on special cloud
        with:
        :Param  req
        :Type   object Request
        """"""
        response = driver.get_network(req.params, id)
        data = {
            'action': ""get"",
            'controller': ""network"",
            'id': id,
            'cloud': req.environ['calplus.cloud'],
            'response': response
        }
        return data"
2638,"def attach_igw(self, req, driver):
        """"""Attach network to Internet gateway
        :Param  req
        :Type   object Request
        """"""
        igw = driver.get_igw(req.params)
        if igw is None:
            igw = driver.create_igw(req.params)
        response = driver.attach_igw(req.params, igw)
        data = {
            'action': 'attach_igw',
            'controller': 'network',
            'id': id,
            'cloud': req.environ['calplus.cloud'],
            'response': response
        }
        return data"
2639,"def dettach_igw(self, req, driver):
        """"""Dettach network from Internet gateway
        :Param  req
        :Type   object Request
        """"""
        response = driver.dettach_igw(req.params)
        data = {
            'action': 'attach_igw',
            'controller': 'network',
            'id': id,
            'cloud': req.environ['calplus.cloud'],
            'response': response
        }
        return data"
2640,"def attach_vpngw(self, req, id, driver):
        """"""Attach network to VPN gateway
        :Param  req
        :Type   object Request
        """"""
        vpngw = driver.get_vnpgw(req.params, id)
        if vpngw is None:
            vpngw = driver.create_vpngw(req.params, id)
        response = driver.attach_vpngw(req.params, vpngw)
        data = {
            'action': 'attach_igw',
            'controller': 'network',
            'id': id,
            'cloud': req.environ['calplus.cloud'],
            'response': response
        }
        return data"
2641,"def connectMSExchange(server):
    """"""
    Creates a connection for the inputted server to a Microsoft Exchange server.

    :param      server | <smtplib.SMTP>
    
    :usage      |>>> import smtplib
                |>>> import projex.notify
                |>>> smtp = smtplib.SMTP('mail.server.com')
                |>>> projex.notify.connectMSExchange(smtp)
    
    :return     (<bool> success, <str> reason)
    """"""
    if not sspi:
        return False, 'No sspi module found.'

    # send the SMTP EHLO command
    code, response = server.ehlo()
    if code != SMTP_EHLO_OKAY:
        return False, 'Server did not respond to EHLO command.'

    sspi_client = sspi.ClientAuth('NTLM')

    # generate NTLM Type 1 message
    sec_buffer = None
    err, sec_buffer = sspi_client.authorize(sec_buffer)
    # noinspection PyShadowingBuiltins
    buffer = sec_buffer[0].Buffer
    ntlm_message = base64.encodestring(buffer).replace('\n', '')

    # send NTLM Type 1 message -- Authentication Request
    code, response = server.docmd('AUTH', 'NTLM ' + ntlm_message)

    # verify the NTLM Type 2 response -- Challenge Message
    if code != SMTP_AUTH_CHALLENGE:
        msg = 'Server did not respond as expected to NTLM negotiate message'
        return False, msg

    # generate NTLM Type 3 message
    err, sec_buffer = sspi_client.authorize(base64.decodestring(response))
    # noinspection PyShadowingBuiltins
    buffer = sec_buffer[0].Buffer
    ntlm_message = base64.encodestring(buffer).replace('\n', '')

    # send the NTLM Type 3 message -- Response Message
    code, response = server.docmd('', ntlm_message)
    if code != SMTP_AUTH_OKAY:
        return False, response

    return True, ''"
2642,"def sendEmail(sender,
              recipients,
              subject,
              body,
              attachments=None,
              cc=None,
              bcc=None,
              contentType='text/html',
              server=None,
              useMSExchange=None,
              encoding='utf-8',
              raiseErrors=False):
    """"""
    Sends an email from the inputted email address to the
    list of given recipients with the inputted subject and
    body.  This will also attach the inputted list of
    attachments to the email.  The server value will default 
    to mail.<sender_domain> and you can use a ':' to specify 
    a port for the server.
    
    :param      sender          <str>
    :param      recipients      <list> [ <str>, .. ]
    :param      subject         <str>
    :param      body            <str>
    :param      attachments     <list> [ <str>, .. ]
    :param      cc              <list> [ <str>, .. ]
    :param      bcc             <list> [ <str>, .. ]
    :param      contentType     <str>
    :param      server          <str>
    
    :return     <bool> success
    """"""
    if attachments is None:
        attachments = []
    if cc is None:
        cc = []
    if bcc is None:
        bcc = []

    if server is None:
        server = NOTIFY_SERVER
    if useMSExchange is None:
        useMSExchange = NOTIFY_SERVER_MSX

    # normalize the data
    sender = nstr(sender)
    recipients = map(nstr, recipients)

    # make sure we have valid information
    if not isEmail(sender):
        err = errors.NotifyError('%s is not a valid email address' % sender)
        logger.error(err)
        return False

    # make sure there are recipients
    if not recipients:
        err = errors.NotifyError('No recipients were supplied.')
        logger.error(err)
        return False

    # build the server domain
    if not server:
        err = errors.NotifyError('No email server specified')
        logger.error(err)
        return False

    # create the email
    msg = MIMEMultipart(_subtype='related')
    msg['Subject'] = projex.text.toUtf8(subject)
    msg['From'] = sender
    msg['To'] = ','.join(recipients)
    msg['Cc'] = ','.join([nstr(addr) for addr in cc if isEmail(addr)])
    msg['Bcc'] = ','.join([nstr(addr) for addr in bcc if isEmail(addr)])
    msg['Date'] = nstr(datetime.datetime.now())
    msg['Content-type'] = 'Multipart/mixed'

    msg.preamble = 'This is a multi-part message in MIME format.'
    msg.epilogue = ''

    # build the body
    bodyhtml = projex.text.toUtf8(body)
    eattach = []

    # include inline images
    filepaths = re.findall('<img\s+src=""(file:///[^""]+)""[^/>]*/?>', bodyhtml)
    for filepath in filepaths:
        filename = filepath.replace('file:///', '')
        if os.path.exists(filename) and filename not in attachments:
            # replace with the attachment id
            cid = 'cid:%s' % os.path.basename(filename)
            bodyhtml = bodyhtml.replace(filename, cid)

            # add the image to the attachments
            fp = open(nstr(filename), 'rb')
            msgImage = MIMEImage(fp.read())
            fp.close()

            # add the msg image to the msg
            content_id = '<%s>' % os.path.basename(filename)
            inline_link = 'inline; filename=""%s""' % os.path.basename(filename)
            msgImage.add_header('Content-ID', content_id)
            msgImage.add_header('Content-Disposition', inline_link)

            eattach.append(msgImage)
            attachments.append(filename)

    # create the body text
    msgText = MIMEText(bodyhtml, contentType, encoding)
    msgText['Content-type'] = contentType

    # include attachments
    for attach in attachments:
        fp = open(nstr(attach), 'rb')
        txt = MIMEBase('application', 'octet-stream')
        txt.set_payload(fp.read())
        fp.close()

        encode_base64(txt)
        attachment = 'attachment; filename=""%s""' % os.path.basename(attach)
        txt.add_header('Content-Disposition', attachment)
        eattach.append(txt)

    eattach.insert(0, msgText)

    # add the attachments to the message
    for attach in eattach:
        msg.attach(attach)

    # create the connection to the email server
    try:
        smtp_server = smtplib.SMTP(nstr(server))
    except socket.gaierror, err:
        logger.error(err)
        if raiseErrors:
            raise
        return False
    except Exception, err:
        logger.error(err)
        if raiseErrors:
            raise
        return False

    # connect to a microsoft exchange server if specified
    if useMSExchange:
        success, response = connectMSExchange(smtp_server)
        if not success:
            logger.debug('Could not connect to MS Exchange: ' + response)

    try:
        smtp_server.sendmail(sender, recipients, msg.as_string())
        smtp_server.close()
    except Exception, err:
        logger.error(err)
        if raiseErrors:
            raise
        return False

    return True"
2643,"def sendJabber(sender,
               password,
               receivers,
               body,
               senderDomain=NOTIFY_IM_DOMAIN_SENDER,
               receiverDomain=NOTIFY_IM_DOMAIN_RECEIVER):
    """"""
    Sends an instant message to the inputted receivers from the
    given user.  The senderDomain is an override to be used 
    when no domain is supplied, same for the receiverDomain.
    
    :param      sender          <str>
    :param      password        <str>
    :param      receivers       <list> [ <str>, .. ]
    :param      body            <str>
    :param      senderDomain    <str>   
    :param      receiverDomain  <str>
    
    :return     <bool> success
    """"""
    import xmpp

    # make sure there is a proper domain as part of the sender 
    if '@' not in sender:
        sender += '@' + senderDomain

    # create a jabber user connection
    user = xmpp.protocol.JID(sender)

    # create a connection to an xmpp client
    client = xmpp.Client(user.getDomain(), debug=[])
    connection = client.connect(secure=0, use_srv=False)
    if not connection:
        text = 'Could not create a connection to xmpp (%s)' % sender
        err = errors.NotifyError(text)
        logger.error(err)
        return False

    # authenticate the session
    auth = client.auth(user.getNode(), password, user.getResource())
    if not auth:
        text = 'Jabber not authenticated: (%s, %s)' % (sender, password)
        err = errors.NotifyError(text)
        logger.error(err)
        return False

    count = 0

    # send the message to the inputted receivers
    for receiver in receivers:
        if '@' not in receiver:
            receiver += '@' + receiverDomain

        # create the message
        msg = xmpp.protocol.Message(receiver, body)

        # create the html message
        html_http = {'xmlns': 'http://jabber.org/protocol/xhtml-im'}
        html_node = xmpp.Node('html', html_http)
        enc_msg = body.encode('utf-8')
        xml = '<body xmlns=""http://www.w3.org/1999/xhtml"">%s</body>' % enc_msg
        html_node.addChild(node=xmpp.simplexml.XML2Node(xml))

        msg.addChild(node=html_node)

        client.send(msg)
        count += 1

    return count > 0"
2644,"def set_entries(self, entries: List[Tuple[str, str]], titles, resources):
        """""" Provide the template the data for the toc entries """"""

        self.entries = []
        for flag, pagename in entries:
            title = titles[pagename].children[0]
            resource = resources.get(pagename, None)
            if resource and hasattr(resource,
                                    'is_published') and not \
                    resource.is_published:
                continue
            # Even if there is no resource for this tocentry, we can
            # use the toctree info
            self.entries.append(dict(
                title=title, href=pagename, resource=resource
            ))

        self.result_count = len(self.entries)"
2645,"def render(self, builder, context, sphinx_app: Sphinx):
        """""" Given a Sphinx builder and context with site in it,
         generate HTML """"""

        context['sphinx_app'] = sphinx_app
        context['toctree'] = self

        html = builder.templates.render(self.template + '.html', context)
        return html"
2646,"def associate_public_ip(self, instance_id, public_ip_id, private_ip=None):
        """"""Associate a external IP""""""
        return self.driver.associate_public_ip(
            instance_id, public_ip_id, private_ip)"
2647,"def deprecatedmethod(classname='', info=''):
    """"""
    Defines a particular method as being deprecated - the 
    method will exist for backwards compatibility, but will 
    contain information as to how update code to become 
    compatible with the current system.
                
    Code that is deprecated will only be supported through the 
    end of a minor release cycle and will be cleaned during a 
    major release upgrade.
    
    :usage      |from projex.decorators import deprecated
                |
                |class A(object):
                |   @deprecatedmethod('A', 'Use A.printout instead')
                |   def format( self ):
                |       print 'test'
                |
                |   def printout( self ):
                :       print 'new test'
    """"""

    def decorated(func):
        @wraps(func)
        def wrapped(*args, **kwds):
            frame = last_frame = None
            try:
                frame = inspect.currentframe()
                last_frame = frame.f_back
                fname = last_frame.f_code.co_filename
                func_file = func.func_code.co_filename

                opts = {
                    'func': func.__name__,
                    'line': last_frame.f_lineno,
                    'file': fname,
                    'class': classname,
                    'info': info,
                    'package': projex.packageFromPath(func_file)
                }

                msg = 'Deprecated method called from %(file)s, line %(line)d.' \
                      '\n  %(package)s.%(class)s.%(func)s is deprecated.' \
                      '  %(info)s' % opts

                logger.warning(errors.DeprecatedMethodWarning(msg))

            finally:
                del frame
                del last_frame

            return func(*args, **kwds)

        wrapped.__name__ = func.__name__

        wrapped.__doc__ = ':warning  This method is deprecated!  %s\n\n' % info
        if func.__doc__:
            wrapped.__doc__ += func.__doc__

        wrapped.__dict__.update(func.__dict__)
        wrapped.__dict__['func_type'] = 'deprecated method'

        return wrapped

    return decorated"
2648,"def profiler(sorting=('tottime',), stripDirs=True,
             limit=20, path='', autoclean=True):
    """"""
    Creates a profile wrapper around a method to time out 
    all the  operations that it runs through.  For more 
    information, look into the hotshot Profile documentation 
    online for the built-in Python package.
    
    :param      sorting     <tuple> ( <key>, .. )
    :param      stripDirs   <bool>
    :param      limit       <int>
    :param      path        <str>
    :param      autoclean   <bool>
    
    :usage      |from projex.decorators import profiler
                |
                |class A:
                |   @profiler() # must be called as a method
                |   def increment(amount, count = 1):
                |       return amount + count
                |
                |a = A()
                |a.increment(10)
                |
    """"""

    def decorated(func):
        """""" Wrapper function to handle the profiling options. """"""
        # create a call to the wrapping
        @wraps(func)
        def wrapped(*args, **kwds):
            """""" Inner method for calling the profiler method. """"""
            # define the profile name
            filename = os.path.join(path, '%s.prof' % func.__name__)

            # create a profiler for the method to run through
            prof = hotshot.Profile(filename)
            results = prof.runcall(func, *args, **kwds)
            prof.close()

            # log the information about it
            stats = hotshot.stats.load(filename)

            if stripDirs:
                stats.strip_dirs()

            # we don't want to know about the arguments for this method
            stats.sort_stats(*sorting)
            stats.print_stats(limit)

            # remove the file if desired
            if autoclean:
                os.remove(filename)

            return results

        return wrapped

    return decorated"
2649,"def retrymethod(count, sleep=0):
    """"""
    Defines a decorator method to wrap a method with a retry mechanism.  The
    wrapped method will be attempt to be called the given number of times based
    on the count value, waiting the number of seconds defined by the sleep
    parameter.  If the throw option is defined, then the given error will
    be thrown after the final attempt fails.
    
    :param      count | <int>
                sleep | <int> | msecs
    """"""

    def decorated(func):
        @wraps(func)
        def wrapped(*args, **kwds):
            # do the retry options
            for i in range(count - 1):
                try:
                    return func(*args, **kwds)
                except StandardError:
                    pass

                if sleep:
                    time.sleep(sleep)

            # run as standard
            return func(*args, **kwds)

        return wrapped

    return decorated"
2650,"def launch_server(message_handler, options):
    """"""
    Launch a message server
    :param handler_function: The handler function to execute for each message
    :param options: Application options for TCP, etc.
    """"""
    logger = logging.getLogger(__name__)
 #   if (options.debug):
 #       logger.setLevel(logging.DEBUG)

#    if not options.monitor_port:
#        logger.warning(
#            ""Monitoring not enabled. No monitor-port option defined."")
#    else:
#        threading.Thread(target=launch_monitor_server, args=(options.host, options.monitor_port, logger)).start()

    # Create the server, binding to specified host on configured port

#   logger.info(
#        'Starting server on host %s port %d Python version %s.%s.%s' % ((options.host, options.port) + sys.version_info[:3]))
#    server = ThreadedTCPServer((options.host, options.port),

    # Activate the server; this will keep running until you
    # interrupt the program with Ctrl-C
    try:
        while True:
            logger.debug('waiting for more data')
            if not message_handler.handle():
                break
        logger.warning(""I/O stream closed from client"")

    except KeyboardInterrupt:
        logger.info(""I/O stream closed from client exiting..."")
        os._exit(142)

    except:
        logger.exception(""Error encountered handling message"")"
2651,"def validate(self, options):
        """"""
        Validate the options or exit()
        """"""
        try:
            codecs.getencoder(options.char_encoding)
        except LookupError:
            self.parser.error(""invalid 'char-encoding' %s"" % options.char_encoding)"
2652,"def parse_code(url):
    """"""
    Parse the code parameter from the a URL

    :param str url: URL to parse
    :return: code query parameter
    :rtype: str
    """"""
    result = urlparse(url)
    query = parse_qs(result.query)
    return query['code']"
2653,"def user_token(scopes, client_id=None, client_secret=None, redirect_uri=None):
    """"""
    Generate a user access token

    :param List[str] scopes: Scopes to get
    :param str client_id: Spotify Client ID
    :param str client_secret: Spotify Client secret
    :param str redirect_uri: Spotify redirect URI
    :return: Generated access token
    :rtype: User
    """"""
    webbrowser.open_new(authorize_url(client_id=client_id, redirect_uri=redirect_uri, scopes=scopes))
    code = parse_code(raw_input('Enter the URL that you were redirected to: '))
    return User(code, client_id=client_id, client_secret=client_secret, redirect_uri=redirect_uri)"
2654,"def consume_file(self, infile):
        """"""Load the specified GFF3 file into memory.""""""
        reader = tag.reader.GFF3Reader(infilename=infile)
        self.consume(reader)"
2655,"def consume_seqreg(self, seqreg):
        """"""Load a :code:`##sequence-region` directive into memory.""""""
        if not isinstance(seqreg, tag.directive.Directive) or \
                seqreg.type != 'sequence-region':
            raise ValueError('expected ##sequence-region directive')
        if seqreg.seqid in self.declared_regions:
            msg = 'duplicate sequence region ""{}""'.format(seqreg.seqid)
            raise ValueError(msg)
        self.declared_regions[seqreg.seqid] = seqreg.range.copy()"
2656,"def consume_feature(self, feature):
        """"""Load a :code:`Feature` object into memory.""""""
        if not isinstance(feature, tag.feature.Feature):
            raise ValueError('expected Feature object')
        self[feature.seqid][feature.start:feature.end] = feature
        if feature.seqid not in self.inferred_regions:
            self.inferred_regions[feature.seqid] = feature._range.copy()
        newrange = self.inferred_regions[feature.seqid].merge(feature._range)
        self.inferred_regions[feature.seqid].start = newrange.start
        self.inferred_regions[feature.seqid].end = newrange.end"
2657,"def consume(self, entrystream):
        """"""
        Load a stream of entries into memory.

        Only Feature objects and sequence-region directives are loaded, all
        other entries are discarded.
        """"""
        for entry in entrystream:
            if isinstance(entry, tag.directive.Directive) and \
                    entry.type == 'sequence-region':
                self.consume_seqreg(entry)
            elif isinstance(entry, tag.feature.Feature):
                self.consume_feature(entry)"
2658,"def query(self, seqid, start, end, strict=True):
        """"""
        Query the index for features in the specified range.

        :param seqid: ID of the sequence to query
        :param start: start of the query interval
        :param end: end of the query interval
        :param strict: indicates whether query is strict containment or overlap
                       (:code:`True` and :code:`False`, respectively)
        """"""
        return sorted([
            intvl.data for intvl in self[seqid].search(start, end, strict)
        ])"
2659,"def cli(ctx, stage):
    """"""Show the functions that are available, bubble system and custom.""""""
    if not ctx.bubble:
        ctx.say_yellow(
            'There is no bubble present, will not show any transformer functions')
        raise click.Abort()
    rule_functions = get_registered_rule_functions()
    ctx.gbc.say('before loading functions:' + str(len(rule_functions)))
    load_rule_functions(ctx)
    ctx.gbc.say('after loading functions:' + str(len(rule_functions)))
    ctx.gbc.say('rule_functions:', stuff=rule_functions, verbosity=10)
    rule_functions.set_parent(ctx.gbc)
    for f in rule_functions:
        ctx.say('fun: ' + f, verbosity=1)
    ctx.gbc.say('funs: ', stuff=rule_functions.get_rule_functions(), verbosity=100)

    return True"
2660,"def to_utctimestamp(a_datetime):
    """"""
    Calculate number of seconds from UTC 1970-01-01 00:00:00.

    When:

    - dt doesn't have tzinfo: assume it's a utc time.
    - dt has tzinfo: use tzinfo.

    WARNING, if your datetime object doens't have ``tzinfo``, make sure
    it's a UTC time, but **NOT a LOCAL TIME**.

    **中文文档**

    计算时间戳, 若:

    - 不带tzinfo: 则默认为是UTC time。
    - 带tzinfo: 则使用tzinfo。
    """"""
    if a_datetime.tzinfo is None:
        delta = a_datetime - datetime(1970, 1, 1)
    else:
        delta = a_datetime - datetime(1970, 1, 1, tzinfo=utc)
    return delta.total_seconds()"
2661,"def to_utc(a_datetime, keep_utc_tzinfo=False):
    """"""
    Convert a time awared datetime to utc datetime.

    :param a_datetime: a timezone awared datetime. (If not, then just returns)
    :param keep_utc_tzinfo: whether to retain the utc time zone information.

    **中文文档**

    将一个带时区的时间转化成UTC时间。而对于UTC时间而言, 有没有时区信息都无所谓了。
    """"""
    if a_datetime.tzinfo:
        utc_datetime = a_datetime.astimezone(utc)  # convert to utc time
        if keep_utc_tzinfo is False:
            utc_datetime = utc_datetime.replace(tzinfo=None)
        return utc_datetime
    else:
        return a_datetime"
2662,"def utc_to_tz(utc_datetime, tzinfo, keep_tzinfo=False):
    """"""
    Convert a UTC datetime to a time awared local time

    :param utc_datetime:
    :param tzinfo:
    :param keep_tzinfo:
    """"""
    tz_awared_datetime = utc_datetime.replace(tzinfo=utc).astimezone(tzinfo)
    if keep_tzinfo is False:
        tz_awared_datetime = tz_awared_datetime.replace(tzinfo=None)
    return tz_awared_datetime"
2663,"def repr_data_size(size_in_bytes, precision=2):  # pragma: no cover
    """"""Return human readable string represent of a file size. Doesn""t support
    size greater than 1EB.

    For example:

    - 100 bytes => 100 B
    - 100,000 bytes => 97.66 KB
    - 100,000,000 bytes => 95.37 MB
    - 100,000,000,000 bytes => 93.13 GB
    - 100,000,000,000,000 bytes => 90.95 TB
    - 100,000,000,000,000,000 bytes => 88.82 PB
    ...

    Magnitude of data::

        1000         kB    kilobyte
        1000 ** 2    MB    megabyte
        1000 ** 3    GB    gigabyte
        1000 ** 4    TB    terabyte
        1000 ** 5    PB    petabyte
        1000 ** 6    EB    exabyte
        1000 ** 7    ZB    zettabyte
        1000 ** 8    YB    yottabyte
    """"""
    if size_in_bytes < 1024:
        return ""%s B"" % size_in_bytes

    magnitude_of_data = [""B"", ""KB"", ""MB"", ""GB"", ""TB"", ""PB"", ""EB"", ""ZB"", ""YB""]
    index = 0
    while 1:
        index += 1
        size_in_bytes, mod = divmod(size_in_bytes, 1024)
        if size_in_bytes < 1024:
            break
    template = ""{0:.%sf} {1}"" % precision
    s = template.format(size_in_bytes + mod / 1024.0, magnitude_of_data[index])
    return s"
2664,"def update_slots(self, event):
        """"""
        :type lex_input_event: LexInputEvent
        :return: None
        """"""
        if isinstance(event, LexInputEvent):
            event_slots = event.currentIntent.slots
        elif isinstance(event, basestring) or isinstance(event, unicode) or isinstance(event, str):
            event_slots = deepcopy(json.loads(event)['currentIntent']['slots'])
        else:
            event_slots = deepcopy(event['currentIntent']['slots'])

        for key, val in event_slots.items():
            if key not in self.dialogAction.slots._schema.fields:
                field = Field(key, types.StringType())
                self.dialogAction.slots._schema.append_field(field)
            self.dialogAction.slots[key] = val"
2665,"def render_toctrees(kb_app: kb, sphinx_app: Sphinx, doctree: doctree,
                    fromdocname: str):
    """""" Look in doctrees for toctree and replace with custom render """"""

    # Only do any of this if toctree support is turned on in KaybeeSettings.
    # By default, this is off.
    settings: KaybeeSettings = sphinx_app.config.kaybee_settings
    if not settings.articles.use_toctree:
        return

    # Setup a template and context
    builder: StandaloneHTMLBuilder = sphinx_app.builder
    env: BuildEnvironment = sphinx_app.env

    # Toctree support. First, get the registered toctree class, if any
    registered_toctree = ToctreeAction.get_for_context(kb_app)
    for node in doctree.traverse(toctree):
        if node.attributes['hidden']:
            continue
        custom_toctree = registered_toctree(fromdocname)
        context = builder.globalcontext.copy()
        context['sphinx_app'] = sphinx_app

        # Get the toctree entries. We only handle one level of depth for
        # now. To go further, we need to recurse like sphinx's
        # adapters.toctree._toctree_add_classes function
        entries = node.attributes['entries']

        # The challenge here is that some items in a toctree
        # might not be resources in our ""database"". So we have
        # to ask Sphinx to get us the titles.
        custom_toctree.set_entries(entries, env.titles,
                                   sphinx_app.env.resources)
        output = custom_toctree.render(builder, context, sphinx_app)

        # Put the output into the node contents
        listing = [nodes.raw('', output, format='html')]
        node.replace_self(listing)"
2666,"def stamp_excerpt(kb_app: kb,
                  sphinx_app: Sphinx,
                  doctree: doctree):
    """""" Walk the tree and extract excert into resource.excerpt """"""

    # First, find out which resource this is. Won't be easy.
    resources = sphinx_app.env.resources
    confdir = sphinx_app.confdir
    source = PurePath(doctree.attributes['source'])

    # Get the relative path inside the docs dir, without .rst, then
    # get the resource
    docname = str(source.relative_to(confdir)).split('.rst')[0]
    resource = resources.get(docname)

    if resource:
        # Stamp the excerpt on the resource
        excerpt = getattr(resource.props, 'excerpt', False)
        auto_excerpt = getattr(resource.props, 'auto_excerpt', False)
        if excerpt:
            resource.excerpt = excerpt
        elif not auto_excerpt:
            resource.excerpt = None
        else:
            # Extract the excerpt based on the number of paragraphs
            # in auto_excerpt
            resource.excerpt = get_rst_excerpt(doctree, auto_excerpt)"
2667,"def bitfieldify(buff, count):
    """"""Extract a bitarray out of a bytes array.

    Some hardware devices read from the LSB to the MSB, but the bit types available prefer to put pad bits on the LSB side, completely changing the data.

    This function takes in bytes and the number of bits to extract
    starting from the LSB, and produces a bitarray of those bits.

    """"""
    databits = bitarray()
    databits.frombytes(buff)
    return databits[len(databits)-count:]"
2668,"def build_byte_align_buff(bits):
    """"""Pad the left side of a bitarray with 0s to align its length with byte boundaries.

    Args:
        bits: A bitarray to be padded and aligned.

    Returns:
        A newly aligned bitarray.
    """"""
    bitmod = len(bits)%8
    if bitmod == 0:
        rdiff = bitarray()
    else:
        #KEEP bitarray
        rdiff = bitarray(8-bitmod)
        rdiff.setall(False)
    return rdiff+bits"
2669,"def create(self, name, cidr, **kwargs):
        """"""This function will create a user network.
        Within OpenStack, it will create a network and a subnet
        Within AWS, it will create a VPC and a subnet

        :param name: string
        :param cidr: string E.x: ""10.0.0.0/24""
        :param kwargs: dict
        :return: dict
        """"""
        return self.driver.create(name, cidr, **kwargs)"
2670,"def find_whole_word(w):
    """"""
    Scan through string looking for a location where this word produces a match,
    and return a corresponding MatchObject instance.
    Return None if no position in the string matches the pattern;
    note that this is different from finding a zero-length match at some point in the string.
    """"""
    return re.compile(r'\b({0})\b'.format(w), flags=re.IGNORECASE).search"
2671,"def collect_scripts_from_sources(script_paths, files_deployment,  project_path='.', is_package=False, logger=None):
    """"""
    Collects postgres scripts from source files
    :param script_paths: list of strings or a string with a relative path to the directory containing files with scripts
    :param files_deployment: list of files that need to be harvested. Scripts from there will only be taken
    if the path to the file is in script_paths
    :param project_path: path to the project source code
    :param is_package: are files packaged with pip egg
    :param logger: pass the logger object if needed
    :return:
    """"""
    logger = logger or logging.getLogger(__name__)
    scripts_dict = {}
    if script_paths:
        if not isinstance(script_paths, list):  # can be list of paths or a string, anyways converted to list
            script_paths = [script_paths]
        if is_package:
            for script_path in script_paths:
                for file_info in pkg_resources.resource_listdir('pgpm', script_path):
                    file_content = pkg_resources.resource_string('pgpm', '{0}/{1}'.format(script_path, file_info))\
                        .decode('utf-8')
                    if file_content:
                        scripts_dict[file_info] = file_content
                        logger.debug('File {0}/{1} collected.'.format(script_path, file_info))
                    else:
                        logger.debug('File {0}/{1} not collected as it\'s empty.'.format(script_path, file_info))
        else:
            if files_deployment:  # if specific script to be deployed, only find them
                for list_file_name in files_deployment:
                    list_file_full_path = os.path.join(project_path, list_file_name)
                    if os.path.isfile(list_file_full_path):
                        for i in range(len(script_paths)):
                            if script_paths[i] in list_file_full_path:
                                file_content = io.open(list_file_full_path, 'r', -1, 'utf-8-sig', 'ignore').read()
                                if file_content:
                                    scripts_dict[list_file_name] = file_content
                                    logger.debug('File {0} collected.'.format(list_file_full_path))
                                else:
                                    logger.debug('File {0} not collected as it\'s empty.'.format(list_file_full_path))
                    else:
                        logger.debug('File {0} is not found in any of {1} folders, please specify a correct path'
                                       .format(list_file_full_path, script_paths))
            else:
                for script_path in script_paths:
                    for subdir, dirs, files in os.walk(script_path):
                        files = sorted(files)
                        for file_info in files:
                            if file_info != settings.CONFIG_FILE_NAME and file_info[0] != '.':
                                file_content = io.open(os.path.join(subdir, file_info),
                                                       'r', -1, 'utf-8-sig', 'ignore').read()
                                if file_content:
                                    scripts_dict[file_info] = file_content
                                    logger.debug('File {0} collected'.format(os.path.join(subdir, file_info)))
                                else:
                                    logger.debug('File {0} not collected as it\'s empty.'
                                                 .format(os.path.join(subdir, file_info)))
    return scripts_dict"
2672,"def parse(self, fp, headersonly=True):
        """"""Create a message structure from the data in a file.""""""
        feedparser = FeedParser(self._class)
        feedparser._set_headersonly()

        try:
            mp = mmap.mmap(fp.fileno(), 0, access=mmap.ACCESS_READ)
        except:
            mp = fp

        data = """"

        # While parsing the header we can convert to us-ascii?
        while True:
            line = mp.readline()
            data = data + line.decode(""us-ascii"")
            if line == b""\n"":
                break
        feedparser.feed(data) # mp[0:5000])
        return feedparser.close()"
2673,"def coerce(self, values):
        """"""Convert an iterable of literals to an iterable of options.

        Args:
            values (iterable or string): An iterable of raw values to convert
            into options. If the value is a string is is assumed to be a
            comma separated list and will be split before processing.

        Returns:
            iterable: An iterable of option values initialized with the raw
                values from `values`.

        Raises:
            TypeError: If `values` is not iterable or string.
            TypeError: If the underlying option raises a TypeError.
            ValueError: If the underlying option raises a ValueError.
        """"""
        if isinstance(values, compat.basestring):

            values = tuple(value.strip() for value in values.split(','))

        # Create a list of options to store each value.
        opt_iter = tuple(copy.deepcopy(self._option) for value in values)
        for opt_obj, val in compat.zip(opt_iter, values):

            opt_obj.__set__(None, val)

        return opt_iter"
2674,"def get(self, name, default=None):
        """"""Fetch an option from the dictionary.

        Args:
            name (str): The name of the option.
            default: The value to return if the name is missing.

        Returns:
            any: The value stored by the option.

        This method resolves the option to its value rather than returning
        the option object itself. Use the 'options()' method or this object's
        iter to get the raw options.
        """"""
        option = self._options.get(name, None)
        if option is None:

            return default

        return option.__get__(self)"
2675,"def set(self, name, value):
        """"""Set an option value.

        Args:
            name (str): The name of the option.
            value: The value to set the option to.

        Raises:
            AttributeError: If the name is not registered.
            TypeError: If the value is not a string or appropriate native type.
            ValueError: If the value is a string but cannot be coerced.
        """"""
        if name not in self._options:

            raise AttributeError(""Option {0} does not exist."".format(name))

        return self._options[name].__set__(self, value)"
2676,"def register(self, name, option):
        """"""Register a new option with the namespace.

        Args:
            name (str): The name to register the option under.
            option (option.Option): The option object to register.

        Raises:
            TypeError: If the option is not an option.Option object.
            ValueError: If the name is already registered.
        """"""
        if name in self._options:

            raise ValueError(""Option {0} already exists."".format(name))

        if not isinstance(option, opt.Option):

            raise TypeError(""Options must be of type Option."")

        self._options[name] = option"
2677,"def set(self, name, value):
        """"""Set an option value.

        Args:
            name (str): The name of the option.
            value: The value to set the option to.

        Raises:
            TypeError: If the value is not a string or appropriate native type.
            ValueError: If the value is a string but cannot be coerced.

        If the name is not registered a new option will be created using the
        option generator.
        """"""
        if name not in self._options:

            self.register(name, self._generator())

        return self._options[name].__set__(self, value)"
2678,"def cli(ctx, amount, index, query, stage):
    """"""Pull data from Source Service Client""""""

    if not ctx.bubble:
        ctx.say_yellow('There is no bubble present, will not pull')
        raise click.Abort()
    STAGE = None
    SRC = None

    if stage in STAGES and stage in ctx.cfg.CFG:
        STAGE = ctx.cfg.CFG[stage]

    if not STAGE:
        ctx.say_red('There is no STAGE in CFG:' + stage)
        ctx.say_yellow('please check configuration in ' +
                       ctx.home + '/config/config.yaml')
        raise click.Abort()

    if 'SOURCE' in STAGE:
        SRC = STAGE.SOURCE
    if not SRC:
        ctx.say_red('There is no SOURCE in stage:' + stage)
        ctx.say_yellow('please check configuration in ' +
                       ctx.home + '/config/config.yaml')
        raise click.Abort()
    gbc = ctx.GLOBALS['gbc']
    src_client = get_client(gbc, SRC.CLIENT, ctx.home)

    # TODO: client get error count?
    # make default counters
    # client.pull(amount,index,counters)
    # counter:#Good Bad Ugly: BUG, counters
    # for this the client must be able to keep stats, or update stats in the pull loop.
    # bug.counters

    try:
        sclient = src_client.BubbleClient(cfg=SRC)
        sclient.set_parent(gbc)
        sclient.set_verbose(ctx.get_verbose())
    except Exception as e:
        ctx.say_red(
            'cannot create bubble client:' + SRC.CLIENT)
        ctx.say_red(str(e))
        raise click.Abort('cannot pull')

    full_data = False
    if amount == -1 and index == -1:
        full_data = True

    try:
        if amount > 0:
            if index < 0:
                index = 0
            pb_label='Pulling %d+%d '% (index,amount)
            src_data_gen = sclient.pull(amount, index)
        else:
            if query:
                pb_label='Querying:%s' % query
                src_data_gen = [sclient.query(query)]
                full_data = False
            else:
                pb_label='Pulling all'
                src_data_gen = sclient.pull()
    except Exception as e:
        ctx.say_red('cannot pull from source client: ' + SRC.CLIENT)
        ctx.say_red(str(e))
        raise click.Abort('cannot pull')
    click.echo()

    # TODO: these actually need to be counted someway.
    # in client,
    # in storage,
    # where else?
    error_count = 0

    with click.progressbar(src_data_gen,
                           label=pb_label,
                           show_pos=True,
                           length=amount,
                           show_eta=True,
                           fill_char='◐') as progress_src_data_gen:
        pfr = bubble_lod_dump(ctx=ctx,
                          step='pulled',
                          stage=stage,
                          full_data=full_data,
                          reset=True,
                          data_gen=progress_src_data_gen)
    ctx.say('pulled [%d] objects' % pfr['total'])


    stats = {}
    stats['pulled_stat_error_count'] = error_count
    stats['pulled_stat_total_count'] = pfr['total']
    update_stats(ctx, stage, stats)

    return True"
2679,"def GetCompressedFilesInDir(fileDir, fileList, ignoreDirList, supportedFormatList = ['.rar',]):
  """"""
  Get all supported files from given directory folder. Appends to given file list.

  Parameters
  ----------
    fileDir : string
      File directory to search.

    fileList : list
      List which any file matches will be added to.

    ignoreDirList : list
      List of directories to ignore in recursive lookup (currently unused).

    supportedFormatList : list [optional : default = ['.rar',]]
      List of supported file formats to search for.
  """"""
  goodlogging.Log.Info(""EXTRACT"", ""Parsing file directory: {0}"".format(fileDir))
  if os.path.isdir(fileDir) is True:
    for globPath in glob.glob(os.path.join(fileDir, '*')):
      if os.path.splitext(globPath)[1] in supportedFormatList:
        fileList.append(globPath)"
2680,"def MultipartArchiving(firstPartExtractList, otherPartSkippedList, archiveDir, otherPartFilePath = None):
  """"""
  Archive all parts of multi-part compressed file.

  If file has been extracted (via part1) then move all subsequent parts directly to archive directory.
  If file has not been extracted then if part >1 add to other part skipped list and only archive
  when the first part is sent for archiving.

  Parameters
  ----------
    firstPartExtractList : list
      File directory to search.

    otherPartSkippedList : list
      List which any file matches will be added to.

    archiveDir : list
      List of directories to ignore in recursive lookup (currently unused).

    otherPartFilePath : list [optional : default = None]
      List of supported file formats to search for.
  """"""
  if otherPartFilePath is None:
    for filePath in list(otherPartSkippedList):
      MultipartArchiving(firstPartExtractList, otherPartSkippedList, archiveDir, filePath)
  else:
    baseFileName = re.findall(""(.+?)[.]part.+?rar"", otherPartFilePath)[0]

    if baseFileName in firstPartExtractList:
      util.ArchiveProcessedFile(otherPartFilePath, archiveDir)
      if otherPartFilePath in otherPartSkippedList:
        otherPartSkippedList.remove(otherPartFilePath)
    elif otherPartFilePath not in otherPartSkippedList:
      otherPartSkippedList.append(otherPartFilePath)"
2681,"def DoRarExtraction(rarArchive, targetFile, dstDir):
  """"""
  RAR extraction with exception catching

  Parameters
  ----------
    rarArchive : RarFile object
      RarFile object to extract.

    targetFile : string
      Target file name.

    dstDir : string
      Target directory.

  Returns
  ----------
    boolean
      False if rar extraction failed, otherwise True.
  """"""
  try:
    rarArchive.extract(targetFile, dstDir)
  except BaseException as ex:
    goodlogging.Log.Info(""EXTRACT"", ""Extract failed - Exception: {0}"".format(ex))
    return False
  else:
    return True"
2682,"def GetRarPassword(skipUserInput):
  """"""
  Get password for rar archive from user input.

  Parameters
  ----------
    skipUserInput : boolean
      Set to skip user input.

  Returns
  ----------
    string or boolean
      If no password is given then returns False otherwise returns user
      response string.
  """"""
  goodlogging.Log.Info(""EXTRACT"", ""RAR file needs password to extract"")
  if skipUserInput is False:
    prompt = ""Enter password, 'x' to skip this file or 'exit' to quit this program: ""
    response = goodlogging.Log.Input(""EXTRACT"", prompt)
    response = util.CheckEmptyResponse(response)
  else:
    response = 'x'

  if response.lower() == 'x':
    goodlogging.Log.Info(""EXTRACT"", ""File extraction skipped without password"")
    return False
  elif response.lower() == 'exit':
    goodlogging.Log.Fatal(""EXTRACT"", ""Program terminated by user 'exit'"")
  else:
    return response"
2683,"def CheckPasswordReuse(skipUserInput):
  """"""
  Check with user for password reuse.

  Parameters
  ----------
    skipUserInput : boolean
      Set to skip user input.

  Returns
  ----------
    int
      Integer from -1 to 2 depending on user response.
  """"""
  goodlogging.Log.Info(""EXTRACT"", ""RAR files needs password to extract"")
  if skipUserInput is False:
    prompt = ""Enter 't' to reuse the last password for just this file, "" \
             ""'a' to reuse for all subsequent files, "" \
             ""'n' to enter a new password for this file "" \
             ""or 's' to enter a new password for all files: ""
    response = goodlogging.Log.Input(""EXTRACT"", prompt)
    response = util.ValidUserResponse(response, ('t','a','n','s'))
  else:
    response = 'a'

  if response.lower() == 's':
    return -1
  if response.lower() == 'n':
    return 0
  elif response.lower() == 't':
    return 1
  elif response.lower() == 'a':
    return 2"
2684,"def Extract(fileList, fileFormatList, archiveDir, skipUserInput):
  """"""
  Iterate through given file list and extract all files matching the file
  format list from each RAR file. After sucessful extraction move RAR files to
  archive directory.

  Parameters
  ----------
    fileList : list
      List of files to attempt to extract.

    fileFormatList : list
      List of file formats to extract from each RAR archive.

    archiveDir : string
      Directory to move RAR files once extract is complete.

    skipUserInput : boolean
      Set to skip any potential user input (if a single option is available
      it will be selected otherwise the user input will default to take no action).
  """"""
  goodlogging.Log.Info(""EXTRACT"", ""Extracting files from compressed archives"")
  goodlogging.Log.IncreaseIndent()
  if len(fileList) == 0:
    goodlogging.Log.Info(""EXTRACT"", ""No files to extract"")
    goodlogging.Log.DecreaseIndent()
    return None

  firstPartExtractList = []
  otherPartSkippedList = []

  lastPassword = False
  reuseLastPassword = 0
  for filePath in fileList:
    goodlogging.Log.Info(""EXTRACT"", ""{0}"".format(filePath))
    goodlogging.Log.IncreaseIndent()
    try:
      rarArchive = rarfile.RarFile(filePath)
    except ImportError:
      goodlogging.Log.Info(""EXTRACT"", ""Unable to extract - Python needs the rarfile package to be installed (see README for more details)"")
    except rarfile.NeedFirstVolume:
      goodlogging.Log.Info(""EXTRACT"", ""File skipped - this is not the first part of the RAR archive"")
      MultipartArchiving(firstPartExtractList, otherPartSkippedList, archiveDir, filePath)
    except BaseException as ex:
      goodlogging.Log.Info(""EXTRACT"", ""Unable to extract - Exception: {0}"".format(ex))
    else:
      dirPath = os.path.dirname(filePath)
      fileExtracted = False
      rarAuthentication = True

      if rarArchive.needs_password():
        if lastPassword and reuseLastPassword in (0, 1):
          reuseLastPassword = CheckPasswordReuse(skipUserInput)

        if lastPassword and reuseLastPassword in (1, 2):
          rarArchive.setpassword(lastPassword)
        else:
          rarPassword = GetRarPassword(skipUserInput)

          if rarPassword:
            rarArchive.setpassword(rarPassword)
            lastPassword = rarPassword
          else:
            rarAuthentication = False

      if rarAuthentication:
        for f in rarArchive.infolist():
          if util.FileExtensionMatch(f.filename, fileFormatList):
            goodlogging.Log.Info(""EXTRACT"", ""Extracting file: {0}"".format(f.filename))

            extractPath = os.path.join(dirPath, f.filename)
            targetPath = os.path.join(dirPath, os.path.basename(f.filename))

            if os.path.isfile(targetPath):
              goodlogging.Log.Info(""EXTRACT"", ""Extraction skipped - file already exists at target: {0}"".format(targetPath))
              fileExtracted = True
            elif os.path.isfile(extractPath):
              goodlogging.Log.Info(""EXTRACT"", ""Extraction skipped - file already exists at extract directory: {0}"".format(extractPath))
              fileExtracted = True
            else:
              fileExtracted = DoRarExtraction(rarArchive, f, dirPath)

            if os.path.isfile(extractPath) and not os.path.isfile(targetPath):
              os.rename(extractPath, targetPath)
              util.RemoveEmptyDirectoryTree(os.path.dirname(extractPath))

      if fileExtracted is True:
        util.ArchiveProcessedFile(filePath, archiveDir)

        try:
          firstPartFileName = re.findall('(.+?)[.]part1[.]rar', filePath)[0]
        except IndexError:
          pass
        else:
          firstPartExtractList.append(firstPartFileName)
          MultipartArchiving(firstPartExtractList, otherPartSkippedList, archiveDir)

    finally:
      goodlogging.Log.DecreaseIndent()
  goodlogging.Log.DecreaseIndent()"
2685,"def register(function=None, *, singleton=False, threadlocal=False, name=None):
    """"""
    :deprecated: 1.0.0
    Use :class:`giveme.injector.Injector` instead.

    Register a dependency factory in the dependency manager. The function name is the
    name of the dependency.
    This can be used as a decorator.

    Args:
        function (callable): The dependency factory function
            Not needed when used as decorator.
        singleton (``bool``, optional): If ``True`` the given function is only called once
            during the application lifetime. Injectees will receive the already created
            instance when available. Defaults to ``False``
        threadlocal (``bool``, optional): Same as singleton except the returned instance
            is available only to the thread that created it. Defaults to ``False``
        name (``str``, optional): Overridden name for the dependency.
            Defaults to the name of the registered function.
    """"""
    warnings.warn(
        (
            'Module level `register` decorator has been deprecated and will '
            'be removed in a future release. '
            'Use the Injector class instead'
        ),
        DeprecationWarning
    )

    def decorator(function):

        return manager.register(function, singleton=singleton, threadlocal=threadlocal, name=name)
    if function:
        return decorator(function)
    else:
        return decorator"
2686,"def inject(function=None, **overridden_names):
    """"""
    :deprecated: 1.0.0
    Use :class:`giveme.injector.Injector` instead.

    Inject dependencies into given function's arguments.
    By default the injector looks for keyword arguments
    matching registered dependency names.

    Example:

        @register
        def db_connection():
            return create_db_connection()

        @inject
        def save_thing(thing, db_connection=None):
            db_connection.store(thing)

    Arbitrary arguments may also be mapped to
    specific dependency names by passing them to the
    decorator as ``arg='dependency_name'``

    Example:
        @inject(db='db_connection')
        def save_thing(thing, db=None):  # `db_connection` injected as `db`

    Args:
        function (callable): The function that accepts a dependency.
            Implicitly passed when used as a decorator.
        **overridden_names: Mappings of `function` arguments to
            dependency names in the form of ``function_argument='dependency name'``
    """"""
    warnings.warn(
        (
            'Module level `inject` decorator has been deprecated and will '
            'be removed in a future release. '
            'Use the Injector class instead'
        ),
        DeprecationWarning
    )
    
    def decorator(function):        
        @wraps(function)
        def wrapper(*args, **kwargs):
            signature = inspect.signature(function)
            params = signature.parameters
            if not params:
                return function(*args, **kwargs)
            for name, param in params.items():
                if param.kind not in (param.KEYWORD_ONLY, param.POSITIONAL_OR_KEYWORD):
                    continue
                if name in kwargs:
                    # Manual override, ignore it
                    continue
                try:
                    resolved_name = overridden_names.get(name, name)
                    kwargs[name] = manager.get_value(resolved_name)
                except KeyError:
                    pass
            return function(*args, **kwargs)
        return wrapper
    if function:
        return decorator(function)
    else:
        return decorator"
2687,"def register(self, func, singleton=False, threadlocal=False, name=None):
        """"""
        Register a dependency function
        """"""
        func._giveme_singleton = singleton
        func._giveme_threadlocal = threadlocal

        if name is None:
            name = func.__name__
        self._registered[name] = func
        return func"
2688,"def get_value(self, name):
        """"""
        Get return value of a dependency factory or
        a live singleton instance.
        """"""
        factory = self._registered.get(name)
        if not factory:
            raise KeyError('Name not registered')
        if factory._giveme_singleton:
            if name in self._singletons:
                return self._singletons[name]
            self._singletons[name] = factory()
            return self._singletons[name]
        elif factory._giveme_threadlocal:
            if hasattr(self._threadlocals, name):
                return getattr(self._threadlocals, name)
            setattr(self._threadlocals, name, factory())
            return getattr(self._threadlocals, name)
        return factory()"
2689,"def execute(filelocation, args, outdir, filters=None,
            executable='msConvert.exe'):
    """"""Execute the msConvert tool on Windows operating systems.

    :param filelocation: input file path
    :param args: str() or list(), msConvert arguments for details see the
        msConvert help below.
    :param outdir: path of the output directory
    :param filters: str() or list(), specify additional parameters and filters,
        for details see the msConvert help below.
    :param executable: must specify the complete file path of the msConvert.exe
        if its location is not in the ``PATH`` environment variable.
    """"""

    procArgs = [executable, filelocation]
    procArgs.extend(aux.toList(args))
    if filters is not None:
        for arg in aux.toList(filters):
            procArgs.extend(['--filter', arg])
    procArgs.extend(['-o', outdir])

    ## run it ##
    proc = subprocess.Popen(procArgs, stderr=subprocess.PIPE)

    ## But do not wait till netstat finish, start displaying output immediately ##
    while True:
        out = proc.stderr.read(1)
        if out == '' and proc.poll() != None:
            break
        if out != '':
            sys.stdout.write(out)
            sys.stdout.flush()"
2690,"def execute(filelocation, outformat, outdir, log=False,
            executable='RawConverter.exe'):
    """"""Execute the msConvert tool on Windows operating systems.

    :param filelocation: input file path
    :param outformat: output format, must be one of the following: ms1, ms2, ms3, mgf
    :param outdir: path of the output directory
    :param log: #TODO
    :param executable: must specify the complete file path of the RawConverter.exe
        if its location is not in the ``PATH`` environment variable.

    .. note:
        Specifying the complete path to the executable is probably always
        necessary because RawConverter looks for the file ""AveragineTable.txt""
        in the working directory.
    """"""
    assert outformat in ['ms1', 'ms2', 'ms3', 'mgf']

    args = [executable, filelocation, '--'+outformat, '--out_folder', outdir,
            '--select_mono_prec']

    ## run it ##
    proc = subprocess.Popen(args, cwd=os.path.dirname(executable),
                            stderr=subprocess.PIPE)

    ## But do not wait till netstat finish, start displaying output immediately ##
    while True:
        out = proc.stderr.read(1)
        if out == '' and proc.poll() != None:
            break
        if out != '':
            sys.stdout.write(out)
            sys.stdout.flush()"
2691,"def trace(fun, *a, **k):
    """""" define a tracer for a rule function
    for log and statistic purposes """"""
    @wraps(fun)
    def tracer(*a, **k):
        ret = fun(*a, **k)
        print('trace:fun: %s\n ret=%s\n a=%s\nk%s\n' %
              (str(fun), str(ret), str(a), str(k)))
        return ret
    return tracer"
2692,"def timer(fun, *a, **k):
    """""" define a timer for a rule function
    for log and statistic purposes """"""
    @wraps(fun)
    def timer(*a, **k):
        start = arrow.now()
        ret = fun(*a, **k)
        end = arrow.now()
        print('timer:fun: %s\n start:%s,end:%s, took [%s]' % (
            str(fun), str(start), str(end), str(end - start)))
        return ret
    return timer"
2693,"def get_function(self, fun=None):
        """"""get function as RuleFunction or return a NoRuleFunction function""""""
        sfun = str(fun)
        self.say('get_function:' + sfun, verbosity=100)

        if not fun:
            return NoRuleFunction()  # dummy to execute via no_fun

        if sfun in self._rule_functions:
            return self._rule_functions[sfun]
        else:
            self.add_function(name=sfun,
                              fun=self.rule_function_not_found(fun))
            self.cry('fun(%s) not found, returning dummy' %
                     (sfun), verbosity=10)
            if sfun in self._rule_functions:
                return self._rule_functions[sfun]
            else:
                self.rule_function_not_found(fun)"
2694,"def add_function(self,
                     fun=None,
                     name=None,
                     fun_type=FUN_TYPE):
        """"""actually replace function""""""
        if not name:
            if six.PY2:
                name = fun.func_name
            else:
                name = fun.__name__

        self.say('adding fun(%s)' % name, verbosity=50)
        self.say('adding fun_type:%s' % fun_type, verbosity=50)

        if self.function_exists(name):
            self.cry('overwriting :fun(%s)' % name, verbosity=10)

        self.say('added :' + name, verbosity=10)
        self._rule_functions[name] = RuleFunction(name, fun, fun_type)
        return True"
2695,"def function_exists(self, fun):
        """""" get function's existense """"""
        res = fun in self._rule_functions
        self.say('function exists:' + str(fun) + ':' + str(res),
                 verbosity=10)
        return res"
2696,"def rule_function_not_found(self, fun=None):
        """""" any function that does not exist will be added as a
        dummy function that will gather inputs for easing into
        the possible future implementation
        """"""
        sfun = str(fun)
        self.cry('rule_function_not_found:' + sfun)

        def not_found(*a, **k):
            return(sfun + ':rule_function_not_found', k.keys())
        return not_found"
2697,"def get_elem_type(elem):
    """""" Get elem type of soup selection
        :param elem: a soup element
    """"""
    elem_type = None
    if isinstance(elem, list):
        if elem[0].get(""type"") == ""radio"":
            elem_type = ""radio""
        else:
            raise ValueError(u""Unknown element type: {}"".format(elem))

    elif elem.name == ""select"":
        elem_type = ""select""

    elif elem.name == ""input"":
        elem_type = elem.get(""type"")

    else:
        raise ValueError(u""Unknown element type: {}"".format(elem))

    # To be removed
    assert elem_type is not None

    return elem_type"
2698,"def get_option_value(elem):
    """""" Get the value attribute, or if it doesn't exist the text
        content.
        <option value=""foo"">bar</option> => ""foo""
        <option>bar</option> => ""bar""
        :param elem: a soup element
    """"""
    value = elem.get(""value"")
    if value is None:
        value = elem.text.strip()
    if value is None or value == """":
        msg = u""Error parsing value from {}."".format(elem)
        raise ValueError(msg)

    return value"
2699,"def parse_value(val):
    """""" Parse values from html
    """"""
    val = val.replace(""%"", "" "")\
        .replace("" "","""")\
        .replace("","", ""."")\
        .replace(""st"","""").strip()

    missing = [""Ejdeltagit"", ""N/A""]
    if val in missing:
        return val
    elif val == """":
        return None

    return float(val)"
2700,"def _get_html(self, url):
        """""" Get html from url
        """"""
        self.log.info(u""/GET {}"".format(url))
        r = requests.get(url)
        if hasattr(r, 'from_cache'):
            if r.from_cache:
                self.log.info(""(from cache)"")

        if r.status_code != 200:
            throw_request_err(r)

        return r.content"
2701,"def _get_json(self, url):
        """""" Get json from url
        """"""
        self.log.info(u""/GET "" + url)
        r = requests.get(url)
        if hasattr(r, 'from_cache'):
            if r.from_cache:
                self.log.info(""(from cache)"")
        if r.status_code != 200:
            throw_request_err(r)

        return r.json()"
2702,"def regions(self):
        """""" Get a list of all regions
        """"""
        regions = []
        elem = self.dimensions[""region""].elem
        for option_elem in elem.find_all(""option""):
            region = option_elem.text.strip()
            regions.append(region)

        return regions"
2703,"def _get_region_slug(self, id_or_label):
        """""" Get the regional slug to be used in url
            ""Norrbotten"" => ""Norrbottens""

            :param id_or_label: Id or label of region
        """"""
        #region = self.dimensions[""region""].get(id_or_label)
        region = id_or_label
        slug = region\
            .replace(u"" "",""-"")\
            .replace(u""ö"",""o"")\
            .replace(u""Ö"",""O"")\
            .replace(u""ä"",""a"")\
            .replace(u""å"",""a"") + ""s""

        EXCEPTIONS = {
            ""Jamtland-Harjedalens"": ""Jamtlands"",
            ""Rikets"": ""Sveriges"",
        }
        if slug in EXCEPTIONS:
            slug = EXCEPTIONS[slug]

        return slug"
2704,"def _parse_result_page(self, url, payload, only_region=False):
        """""" Get data from a result page
            :param url: url to query
            :param payload: payload to pass
            :return: a dictlist with data
        """"""
        data = []
        try:

            if only_region:
                html = self.scraper._get_html(url)
            else:
                html = self.scraper._post_html(url, payload=payload)

        except RequestException500:

            self.scraper.log.warning(u""Status code 500 on {} with {}"".format(url, payload))
            return None


        current_selection = self._get_current_selection(html)

        table = Datatable(html)
        data = []
        for row in table.data:
            region_or_unit_id, region_or_unit_label = row[""region_or_unit""]
            if region_or_unit_label in self.regions:
                row[""region""] = region_or_unit_label
                row[""unit""] = None
            else:
                row[""region""] = None
                row[""unit""] = region_or_unit_label

            value = row[""value""]

            row.pop(""value"", None)
            row.pop(""region_or_unit"", None)

            for dim in self.dimensions:
                if dim.id not in row:
                    row[dim.id] = current_selection[dim.id][1] # gets label



            data.append(Result(value, row))
        return data"
2705,"def elem_type(self):
        """""" :returns: ""select""|""radio""|""checkbox""
        """"""
        if not hasattr(self, ""_elem_type""):
            self._elem_type = get_elem_type(self.elem)
        return self._elem_type"
2706,"def default_value(self):
        """""" The default category when making a query
        """"""
        if not hasattr(self, ""_default_value""):
            if self.elem_type == ""select"":
                try:
                    # Get option marked ""selected""
                    def_value = get_option_value(self.elem.select_one(""[selected]""))
                except AttributeError:
                    # ...or if that one doesen't exist get the first option
                    def_value = get_option_value(self.elem.select_one(""option""))

            elif self.elem_type == ""checkbox"":
                def_value = self.elem.get(""value"")

            elif self.elem_type == ""radio"":
                def_value = [x for x in self.elem if x.has_attr(""checked"")][0].get(""value"")

            self._default_value = def_value

            assert def_value is not None

        return self._default_value"
2707,"def measures(self):
        """""" Get a list of the measuers of this datatable
            Measures can be ""Antal Besök inom 7 dagar"",
            ""Måluppfyllelse vårdgarantin"", etc
        """"""
        if self._measures == None:
            self._measures = get_unique([x[""measure""] for x in self.data])

        return self._measures"
2708,"def _parse_values(self):
        """""" Get values
        """"""
        data = []
        if self.has_tabs:
            def _parse_tab_text(tab):
                # Annoying html in tabs
                if tab.select_one("".visible_normal""):
                    return tab.select_one("".visible_normal"").text
                else:
                    return tab.text

            sub_table_ids = [_parse_tab_text(x) for x in self.soup.select("".table_switch li"")]
            sub_tables = self.soup.select("".dataTables_wrapper"")
            assert len(sub_tables) == len(sub_table_ids)
            assert len(sub_tables) > 0

            for measure, table in zip(sub_table_ids, sub_tables):
                if self.has_horizontal_scroll:
                    _data = self._parse_horizontal_scroll_table(table)
                    for region, col, value in _data:
                        data.append({
                            ""region_or_unit"": region,
                            ""select_period"": col, # Hardcode warning!
                            ""measure"": measure,
                            })

        else:
            if self.has_horizontal_scroll:
                raise NotImplementedError()

            if self.has_vertical_scroll:
                table = self.soup.select_one(""#DataTables_Table_0_wrapper"")
                _data = self._parse_vertical_scroll_table(table)
            else:
                table = self.soup.select("".chart.table.scrolling"")[-1]
                _data = self._parse_regular_table(table)

            for region, measure, value in _data:
                data.append({
                    ""region_or_unit"": region,
                    ""measure"": measure,
                    ""value"": value
                })

        return data"
2709,"def _parse_horizontal_scroll_table(self, table_html):
        """""" Get list of dicts from horizontally scrollable table
        """"""
        row_labels = [parse_text(x.text) for x  in table_html.select("".DTFC_LeftBodyWrapper tbody tr"")]
        row_label_ids = [None] * len(row_labels)
        cols = [parse_text(x.text) for x in table_html.select("".dataTables_scrollHead th"")]
        value_rows = table_html.select("".dataTables_scrollBody tbody tr"")

        values = []
        for row_i, value_row in enumerate(value_rows):
            row_values = [parse_value(x.text) for x in value_row.select(""td"")]
            values.append(row_values)

        sheet = Sheet(zip(row_label_ids, row_labels), cols, values)

        return sheet.long_format"
2710,"def as_dictlist(self):
        """""" Returns a dictlist with values
            [
                {
                    ""row"": ""row_a"",
                    ""col"": ""col_a"",
                    ""value"": 1,
                }
            ]
        """"""
        data = []
        for row_i, row in enumerate(self.row_index):
            for col_i, col in enumerate(self.col_index):
                value = self.values_by_row[row_i][col_i]
                data.append({
                    ""row"": row,
                    ""col"": col,
                    ""value"": value,
                    })
        return data"
2711,"def is_json_file(filename, show_warnings = False):
    """"""Check configuration file type is JSON
    Return a boolean indicating wheather the file is JSON format or not
    """"""
    try:
        config_dict = load_config(filename, file_type = ""json"")
        is_json = True
    except:
        is_json = False
    return(is_json)"
2712,"def is_yaml_file(filename, show_warnings = False):
    """"""Check configuration file type is yaml
    Return a boolean indicating wheather the file is yaml format or not
    """"""
    if is_json_file(filename):
        return(False)
    try:
        config_dict = load_config(filename, file_type = ""yaml"")
        if(type(config_dict) == str):
            is_yaml = False
        else:
            is_yaml = True
    except:
        is_yaml = False
    return(is_yaml)"
2713,"def is_ini_file(filename, show_warnings = False):
    """"""Check configuration file type is INI
    Return a boolean indicating wheather the file is INI format or not
    """"""
    try:
        config_dict = load_config(filename, file_type = ""ini"")
        if config_dict == {}:
            is_ini = False
        else:
            is_ini = True
    except:
        is_ini = False
    return(is_ini)"
2714,"def is_toml_file(filename, show_warnings = False):
    """"""Check configuration file type is TOML
    Return a boolean indicating wheather the file is TOML format or not
    """"""
    if is_yaml_file(filename):
        return(False)
    try:
        config_dict = load_config(filename, file_type = ""toml"")
        is_toml = True
    except:
        is_toml = False
    return(is_toml)"
2715,"def get_config_type(filename):
    """"""Get configuration file type:[JSON, YAML, INI, TOML]
    Return the configuration filetype: json, yaml, ini, toml or False 
    """"""
    if is_json_file(filename):
        return(""json"")
    elif is_ini_file(filename):
        return(""ini"")
    elif is_yaml_file(filename):
        return(""yaml"")
    elif is_toml_file(filename):
        return(""toml"")
    else:
        return(False)"
2716,"def load(keystorerc=None, keystore=None, copyto=None, verbose=False):
  '''decrypt and write out a keystore'''

  config = None
  if keystorerc:
    config = config_reader.read(keystorerc)
    if not config:
      print('No configuration found.', file=sys.stderr)
      sys.exit(-1)
  elif keystore:
    config = {
      'keystore': keystore,
      'files': []
    }

  if 'verbose' in config and config['verbose']:
    verbose = True

  keystore_path = None
  if 'keystore' not in config:
    print('.keystorerc needs to specify a keystore file path.', file=sys.stderr)
    sys.exit(-1)
  elif not pathlib.Path(os.path.expanduser(config['keystore'])).is_file():
    # If keystore file does not exist, nothing to load and exits
    print('keystore does not exist: {}'.format(config['keystore']), file=sys.stderr)
    sys.exit(-1)
  else:
    keystore_path = config['keystore']

  if copyto and not pathlib.Path(os.path.expanduser(copyto)).is_dir():
    print('The folder to copy to does not exist: {}'.format(copyto), file=sys.stderr)
    sys.exit(-1)

  # load and attempt to unencrypt keystore by passphrase

  encrypted_keystore = None
  try:
    with open(os.path.expanduser(keystore_path), 'rb') as keystore_file:
      encrypted_keystore = keystore_file.read()

    if verbose: print('Located encrypted keystore at {}.'.format(keystore_path))

    decrypted = False
    decrypted_keystore = None
    while not decrypted:
      try:
        passphrase = getpass.getpass('Please enter the passphrase: ')
        decrypted_keystore = simplecrypt.decrypt(passphrase, encrypted_keystore)
        decrypted = True
      except simplecrypt.DecryptionException as err:
        print('Invalid passphrase. Please try again.')
      except UnicodeDecodeError as err:
        print('Keyring cannot be decrypted.\nError: {}'.format(err), file=sys.stderr)
        sys.exit(-1)

  except OSError as err:
    print('keystore cannot be opened: {}'.format(err), file=sys.stderr)
    sys.exit(-1)

  # attempt to uncompress the keystore

  decompressed_keystore = gzip.decompress(decrypted_keystore)

  # attempt to unserialise the keystore

  try:
    keystore = json.loads(decompressed_keystore)
  except json.decoder.JSONDecodeError as err:
    print('Please contact the author about this as this is a serious problem. {}'.format(err), file=sys.stderr)
    sys.exit(-1)

  if verbose: print('Keystore decrypted successfully.')

  count = 0
  for filepath, key in keystore.items():
    expanded_filepath = os.path.expanduser(filepath)
    if copyto:
      expanded_filepath = os.path.join(copyto, os.path.basename(filepath))

    confirmed = False
    overwrite = False
    if not pathlib.Path(expanded_filepath).exists():
      confirmed = True
      overwrite = True

    while not confirmed:
      overwrite = input('File {} exists. Are you sure you want to overwrite? (y)/n: '.format(expanded_filepath))
      if overwrite == '' or overwrite == 'y' or overwrite == 'Y':
        overwrite = True
        confirmed = True
      elif overwrite == 'n' or overwrite == 'N':
        overwrite = False
        confirmed = True
      else:
        print('Please enter y or n.')
    if not overwrite:
      continue

    # key ready to be created
    if verbose: print('Writing key to {} ...'.format(expanded_filepath))
    try:
      with open(expanded_filepath, 'wb') as keyfile:
        b64_decoded = base64.decodebytes(key.encode('utf-8'))
        keyfile.write(b64_decoded)
      count += 1
    except OSError as err:
      print('File system threw an error: {}'.format(err), file=sys.stderr)
      print('Skipping {}'.format(expanded_filepath))

  if verbose: print('Keystore restored {} keys.'.format(count))"
2717,"def _collect_settings(self, apps):
        """"""
        Iterate over given apps or INSTALLED_APPS and collect the content of each's
        settings file, which is expected to be in JSON format.
        """"""
        contents = {}
        if apps:
            for app in apps:
                if app not in settings.INSTALLED_APPS:
                    raise CommandError(""Application '{0}' not in settings.INSTALLED_APPS"".format(app))
        else:
            apps = settings.INSTALLED_APPS
        for app in apps:
            module = import_module(app)
            for module_dir in module.__path__:
                json_file = os.path.abspath(os.path.join(module_dir, self.json_file))
                if os.path.isfile(json_file):
                    with open(json_file, 'r') as fp:
                        contents[app] = json.load(fp)
        return contents"
2718,"def required_unique(objects, key):
    """"""
    A pyrsistent invariant which requires all objects in the given iterable to
    have a unique key.

    :param objects: The objects to check.
    :param key: A one-argument callable to compute the key of an object.

    :return: An invariant failure if any two or more objects have the same key
        computed.  An invariant success otherwise.
    """"""
    keys = {}
    duplicate = set()
    for k in map(key, objects):
        keys[k] = keys.get(k, 0) + 1
        if keys[k] > 1:
            duplicate.add(k)
    if duplicate:
        return (False, u""Duplicate object keys: {}"".format(duplicate))
    return (True, u"""")"
2719,"def item_by_name(self, name):
        """"""
        Find an item in this collection by its name metadata.

        :param unicode name: The name of the object for which to search.

        :raise KeyError: If no object matching the given name is found.
        :return IObject: The object with the matching name.
        """"""
        for obj in self.items:
            if obj.metadata.name == name:
                return obj
        raise KeyError(name)"
2720,"def _fetch_dimensions(self, dataset):
        """""" Declaring available dimensions like this is not mandatory,
         but nice, especially if they differ from dataset to dataset.

         If you are using a built in datatype, you can specify the dialect
         you are expecting, to have values normalized. This scraper will
         look for Swedish month names (e.g. 'Januari'), but return them
         according to the Statscraper standard ('january').
        """"""
        yield Dimension(u""date"", label=""Day of the month"")
        yield Dimension(u""month"", datatype=""month"", dialect=""swedish"")
        yield Dimension(u""year"", datatype=""year"")"
2721,"def _dct_from_mro(cls: type, attr_name: str) -> dict:
    """"""""Get a merged dictionary from `cls` bases attribute `attr_name`. MRO defines importance (closest = strongest).""""""
    d = {}
    for c in reversed(cls.mro()):
        d.update(getattr(c, attr_name, {}))
    return d"
2722,"def _sorted_items(mapping: typing.Mapping) -> typing.Generator:
    """"""Given a mapping where values are iterables, yield items whose values contained references are not used as
    keys first:

    Example:
        >>> dct = {'two': ('two', 'one', 'foo'), 'one': ('hi', 'six', 'net'), 'six': ('three', 'four'), 'foo': ['bar']}
        >>> for k, v in _sorted_items(dct):
        ...     print(k, v)
        ...
        six ('three', 'four')
        foo ['bar']
        one ('hi', 'six', 'net')
        two ('two', 'one', 'foo')
    """"""
    to_yield = set(mapping)
    while to_yield:
        for key, values in mapping.items():
            if key not in to_yield or (to_yield - {key} & set(values)):  # other keys left to yield before this one
                continue
            yield key, values
            to_yield.remove(key)"
2723,"def _init_name_core(self, name: str):
        """"""Runs whenever a new instance is initialized or `sep` is set.""""""
        self.__regex = re.compile(rf'^{self._pattern}$')
        self.name = name"
2724,"def values(self) -> typing.Dict[str, str]:
        """"""The field values of this object's name as a dictionary in the form of {field: value}.""""""
        return {k: v for k, v in self._items if v is not None}"
2725,"def get_name(self, **values) -> str:
        """"""Get a new name string from this object's name values.

        :param values: Variable keyword arguments where the **key** should refer to a field on this object that will
                       use the provided **value** to build the new name.
        """"""
        if not values and self.name:
            return self.name
        if values:
            # if values are provided, solve compounds that may be affected
            for ck, cvs in _sorted_items(self.compounds):
                if ck in cvs and ck in values:  # redefined compound name to outer scope e.g. fifth = (fifth, sixth)
                    continue
                comp_values = [values.pop(cv, getattr(self, cv)) for cv in cvs]
                if None not in comp_values:
                    values[ck] = ''.join(rf'{v}' for v in comp_values)
        return self._get_nice_name(**values)"
2726,"def cast_config(cls, config: typing.Mapping[str, str]) -> typing.Dict[str, str]:
        """"""Cast `config` to grouped regular expressions.""""""
        return {k: cls.cast(v, k) for k, v in config.items()}"
2727,"def appdataPath(appname):
    """"""
    Returns the generic location for storing application data in a cross
    platform way.
    
    :return     <str>
    """"""
    # determine Mac OS appdata location
    if sys.platform == 'darwin':
        # credit: MHL
        try:
            from AppKit import NSSearchPathForDirectoriesInDomains
            # NSApplicationSupportDirectory = 14
            # NSUserDomainMask = 1
            # True for expanding the tilde into a fully qualified path
            basepath = NSSearchPathForDirectoriesInDomains(14, 1, True)
            return os.path.join(basepath[0], appname)
        
        except (ImportError, AttributeError, IndexError):
            basepath = os.path.expanduser(""~/Library/Application Support"")
            return os.path.join(basepath, appname)
    
    # determine Windows OS appdata location
    elif sys.platform == 'win32':
        return os.path.join(os.environ.get('APPDATA'), appname)
    
    # determine Linux OS appdata location
    else:
        return os.path.expanduser(os.path.join('~', '.' + appname))"
2728,"def _execute_primitives(self, commands):
        """"""Run a list of executable primitives on this controller, and distribute the returned data to the associated TDOPromises.

        Args:
            commands: A list of Executable Primitives to be run in order.

        """"""
        for p in commands:
            if self._scanchain and self._scanchain._debug:
                print(""  Executing"", p)#pragma: no cover
            p.execute(self)"
2729,"def pretty_version_text():
    """"""Return pretty version text listing all plugins.""""""
    version_lines = [""dtool, version {}"".format(dtool_version)]
    version_lines.append(""\nBase:"")
    version_lines.append(""dtoolcore, version {}"".format(dtoolcore.__version__))
    version_lines.append(""dtool-cli, version {}"".format(__version__))

    # List the storage broker packages.
    version_lines.append(""\nStorage brokers:"")
    for ep in iter_entry_points(""dtool.storage_brokers""):
        package = ep.module_name.split(""."")[0]
        dyn_load_p = __import__(package)
        version = dyn_load_p.__version__
        storage_broker = ep.load()
        version_lines.append(
            ""{}, {}, version {}"".format(
                storage_broker.key,
                package.replace(""_"", ""-""),
                version))

    # List the plugin packages.
    modules = [ep.module_name for ep in iter_entry_points(""dtool.cli"")]
    packages = set([m.split(""."")[0] for m in modules])
    version_lines.append(""\nPlugins:"")
    for p in packages:
        dyn_load_p = __import__(p)
        version_lines.append(
            ""{}, version {}"".format(
                p.replace(""_"", ""-""),
                dyn_load_p.__version__))

    return ""\n"".join(version_lines)"
2730,"def dtool(debug):
    """"""Tool to work with datasets.""""""
    level = logging.WARNING
    if debug:
        level = logging.DEBUG
    logging.basicConfig(
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        level=level)"
2731,"def add_nic(self, instance_id, net_id):
        """"""Add a Network Interface Controller""""""
        #TODO: upgrade with port_id and fixed_ip in future
        self.client.servers.interface_attach(
            instance_id, None, net_id, None)
        return True"
2732,"def delete_nic(self, instance_id, port_id):
        """"""Delete a Network Interface Controller""""""
        self.client.servers.interface_detach(instance_id, port_id)
        return True"
2733,"def list_nic(self, instance_id):
        """"""List all Network Interface Controller
        """"""
        #NOTE: interfaces a list of novaclient.v2.servers.Server
        interfaces = self.client.servers.interface_list(instance_id)
        return interfaces"
2734,"def associate_public_ip(self, instance_id, public_ip_id, private_ip=None):
        """"""Associate a external IP""""""
        floating_ip = self.client.floating_ips.get(public_ip_id)
        floating_ip = floating_ip.to_dict()
        address = floating_ip.get('ip')

        self.client.servers.add_floating_ip(instance_id, address, private_ip)

        return True"
2735,"def disassociate_public_ip(self, public_ip_id):
        """"""Disassociate a external IP""""""
        floating_ip = self.client.floating_ips.get(public_ip_id)
        floating_ip = floating_ip.to_dict()
        instance_id = floating_ip.get('instance_id')
        address = floating_ip.get('ip')

        self.client.servers.remove_floating_ip(instance_id, address)

        return True"
2736,"def split(self, bitindex):
        """"""Split a promise into two promises at the provided index.

        A common operation in JTAG is reading/writing to a
        register. During the operation, the TMS pin must be low, but
        during the writing of the last bit, the TMS pin must be
        high. Requiring all reads or writes to have full arbitrary
        control over the TMS pin is unrealistic.

        Splitting a promise into two sub promises is a way to mitigate
        this issue. The final read bit is its own subpromise that can
        be associated with a different primitive than the 'rest' of
        the subpromise.

        Returns:
            Two TDOPromise instances: the 'Rest' and the 'Tail'.
            The 'Rest' is the first chunk of the original promise.
            The 'Tail' is a single bit sub promise for the final bit
              in the operation

            If the 'Rest' would have a length of 0, None is returned

        """"""
        if bitindex < 0:
            raise ValueError(""bitindex must be larger or equal to 0."")
        if bitindex > len(self):
            raise ValueError(
                ""bitindex larger than the array's size. ""
                ""Len: %s; bitindex: %s""%(len(self), bitindex))

        if bitindex == 0:
            return None, self
        if bitindex == len(self):
            return self, None

        left = TDOPromise(self._chain, self._bitstart, bitindex,
                          _parent=self)
        #Starts at 0 because offset is for incoming data from
        #associated primitive, not location in parent.
        right = TDOPromise(self._chain, 0, len(self)-bitindex,
                          _parent=self)
        self._components = []
        self._addsub(left, 0)
        self._addsub(right, bitindex)
        return left, right"
2737,"def _fulfill(self, bits, ignore_nonpromised_bits=False):
        """"""Supply the promise with the bits from its associated primitive's execution.

        The fulfillment process must walk the promise chain backwards
        until it reaches the original promise and can supply the final
        value.

        The data that comes in can either be all a bit read for every
        bit written by the associated primitive, or (if the primitive
        supports it), only the bits that are used by promises. The
        ignore_nonpromised_bits flag specifies which format the
        incoming data is in.

        Args:
            bits: A bitarray (or compatible) containing the data read from the jtag controller's TDO pin.
            ignore_nonpromised_bits: A boolean specifying if only promised bits are being returned (and thus the 2nd index of the promise must be used for slicing the incoming data).

        """"""
        if self._allsubsfulfilled():
            if not self._components:
                if ignore_nonpromised_bits:
                    self._value = bits[self._bitstartselective:
                                       self._bitstartselective +
                                       self._bitlength]
                else:
                    self._value = bits[self._bitstart:self._bitend]
            else:
                self._value = self._components[0][0]._value
                for sub, offset in self._components[1:]:
                    self._value += sub._value
            if self._parent is not None:
                self._parent._fulfill(None)"
2738,"def makesubatoffset(self, bitoffset, *, _offsetideal=None):
        """"""Create a copy of this promise with an offset, and use it as this promise's child.

        If this promise's primitive is being merged with another
        primitive, a new subpromise may be required to keep track of
        the new offset of data coming from the new primitive.


        Args:
            bitoffset: An integer offset of the data in the new primitive.
        _offsetideal: integer offset of the data if terms of bits actually used for promises. Used to calculate the start index to read if the associated primitive has arbitrary TDO control.

        Returns:
            A TDOPromise registered with this promise, and with the
            correct offset.

        """"""
        if _offsetideal is None:
            _offsetideal = bitoffset
        if bitoffset is 0:
            return self
        newpromise = TDOPromise(
            self._chain,
            self._bitstart + bitoffset,
            self._bitlength,
            _parent=self,
            bitstartselective=self._bitstartselective+_offsetideal
        )
        self._addsub(newpromise, 0)
        return newpromise"
2739,"def add(self, promise, bitoffset, *, _offsetideal=None):
        """"""Add a promise to the promise collection at an optional offset.

        Args:
            promise: A TDOPromise to add to this collection.
            bitoffset: An integer offset for this new promise in the collection.
            _offsetideal: An integer offset for this new promise in the collection if the associated primitive supports arbitrary TDO control.
        """"""
        #This Assumes that things are added in order.
        #Sorting or checking should likely be added.
        if _offsetideal is None:
            _offsetideal = bitoffset
        if isinstance(promise, TDOPromise):
            newpromise = promise.makesubatoffset(
                bitoffset, _offsetideal=_offsetideal)
            self._promises.append(newpromise)
        elif isinstance(promise, TDOPromiseCollection):
            for p in promise._promises:
                self.add(p, bitoffset, _offsetideal=_offsetideal)"
2740,"def split(self, bitindex):
        """"""Split a promise into two promises. A tail bit, and the 'rest'.

        Same operation as the one on TDOPromise, except this works
        with a collection of promises and splits the appropriate one.

        Returns:
            The 'Rest' and the 'Tail'.
            The 'Rest' is TDOPromiseCollection containing the first
              chunk of the original TDOPromiseCollection.
            The 'Tail' is a single bit sub promise for the final bit
              in the operation

            If the 'Rest' would have a length of 0, None is returned

        """"""
        if bitindex < 0:
            raise ValueError(""bitindex must be larger or equal to 0."")
        if bitindex == 0:
            return None, self

        lastend = 0
        split_promise = False
        for splitindex, p in enumerate(self._promises):
            if bitindex in range(lastend, p._bitstart):
                split_promise = False
                break
            if bitindex in range(p._bitstart, p._bitend):
                if bitindex-p._bitstart == 0:
                    split_promise = False
                else:
                    split_promise = True
                break
            lastend = p._bitend
        else:
            raise Exception(""Should be impossible"")

        processed_left = TDOPromiseCollection(self._chain)
        processed_right = TDOPromiseCollection(self._chain)

        if split_promise:
            left, right = p.split(bitindex-p._bitstart)

            for i in range(splitindex):
                processed_left.add(self._promises[i], 0)
            processed_left.add(left, 0)

            processed_right.add(right, 0)
            for tmpprim in self._promises[splitindex+1:]:
                processed_right.add(tmpprim, -bitindex)
            return processed_left, processed_right
        else:
            for i in range(splitindex):
                processed_left.add(self._promises[i], 0)

            for i in range(splitindex, len(self._promises)):
                processed_right.add(self._promises[i], -bitindex)

            return processed_left, processed_right"
2741,"def makesubatoffset(self, bitoffset, *, _offsetideal=None):
        """"""Create a copy of this PromiseCollection with an offset applied to each contained promise and register each with their parent.

        If this promise's primitive is being merged with another
        primitive, a new subpromise may be required to keep track of
        the new offset of data coming from the new primitive.

        Args:
            bitoffset: An integer offset of the data in the new primitive.
            _offsetideal: An integer offset to use if the associated primitive supports arbitrary TDO control.

        Returns:
            A new TDOPromiseCollection registered with this promise
            collection, and with the correct offset.

        """"""
        if _offsetideal is None:
            _offsetideal = bitoffset
        if bitoffset is 0:
            return self
        newpromise = TDOPromiseCollection(self._chain)
        for promise in self._promises:
            newpromise.add(promise, bitoffset, _offsetideal=_offsetideal)
        return newpromise"
2742,"def call_jira_rest(self, url, user, password, method=""GET"", data=None):
        """"""
        Make JIRA REST call
        :param data: data for rest call
        :param method: type of call: GET or POST for now
        :param url: url to call
        :param user: user for authentication
        :param password: password for authentication
        :return:
        """"""
        headers = {'content-type': 'application/json'}

        self._logger.debug('Connecting to Jira to call the following REST method {0}'.format(url))
        if method == ""GET"":
            response = requests.get(self.base_url + url, auth=requests.auth.HTTPBasicAuth(user, password))
        elif method == ""POST"":
            response = requests.post(self.base_url + url, data=json.dumps(data),
                                     auth=requests.auth.HTTPBasicAuth(user, password), headers=headers)
        else:
            raise ValueError('method argument supports GET or POST values only')
        self._logger.debug('REST call successfully finalised')
        return response.json()"
2743,"def cli(ctx, stage):
    """"""Show transformer rules""""""
    if not ctx.bubble:
        ctx.say_yellow('There is no bubble present, ' +
                       'will not show any transformer rules')
        raise click.Abort()

    path = ctx.home + '/'
    RULES = None
    ctx.say('Stage:'+stage, verbosity=10)
    if stage in STAGES:
        if stage in ctx.cfg.CFG:
            STAGE = ctx.cfg.CFG[stage]
            ctx.say('Stage found:', stuff=STAGE,verbosity=100)


        if 'TRANSFORM' in STAGE:
            TRANSFORM = STAGE.TRANSFORM
            ctx.say('Transform found:', stuff=TRANSFORM, verbosity=100)

            if 'RULES' in TRANSFORM:
                RULES = TRANSFORM.RULES
                ctx.say('Rules found:', stuff=RULES, verbosity=100)


    if not RULES:
        ctx.say_red('There is no TRANSFORM.RULES in stage:' + stage)
        ctx.say_yellow('please check configuration in ' +
                       ctx.home + '/config/config.yaml')
        raise click.Abort()

    if type(RULES) == str and RULES.endswith('.bubble'):
        ctx.say('loading rules',verbosity=10)
        rules = get_bubble(ctx, path + RULES)
        rule_type = 'bubble'
        transformer = Transformer(rules=rules,
                                  rule_type=rule_type,
                                  bubble_path=path,
                                  verbose=ctx.get_verbose())
        rules = transformer._rules.get_rules()
        ctx.say('current number of rules:' + str(len(rules)),
                verbosity=1)
        for r in rules:
            ctx.say('rule: ' + str(r), verbosity=1)

        ctx.gbc.say('rules: ', stuff=rules, verbosity=100)
    else:
        ctx.say('no rules!')

    return True"
2744,"def connectExec(connection, protocol, commandLine):
    """"""Connect a Protocol to a ssh exec session
    """"""
    deferred = connectSession(connection, protocol)
    @deferred.addCallback
    def requestSubsystem(session):
        return session.requestExec(commandLine)
    return deferred"
2745,"def connectShell(connection, protocol):
    """"""Connect a Protocol to a ssh shell session
    """"""
    deferred = connectSession(connection, protocol)
    @deferred.addCallback
    def requestSubsystem(session):
        return session.requestShell()
    return deferred"
2746,"def connectSubsystem(connection, protocol, subsystem):
    """"""Connect a Protocol to a ssh subsystem channel
    """"""
    deferred = connectSession(connection, protocol)
    @deferred.addCallback
    def requestSubsystem(session):
        return session.requestSubsystem(subsystem)
    return deferred"
2747,"def connectSession(connection, protocol, sessionFactory=None, *args, **kwargs):
    """"""Open a SSHSession channel and connect a Protocol to it

    @param connection: the SSH Connection to open the session channel on
    @param protocol: the Protocol instance to connect to the session
    @param sessionFactory: factory method to generate a SSHSession instance
    @note: :args: and :kwargs: are passed to the sessionFactory
    """"""
    factory = sessionFactory or defaultSessionFactory
    session = factory(*args, **kwargs)
    session.dataReceived = protocol.dataReceived
    session.closed = lambda: protocol.connectionLost(connectionDone)

    deferred = defer.Deferred()
    @deferred.addCallback
    def connectProtocolAndReturnSession(specificData):
        protocol.makeConnection(session)
        return session
    session.sessionOpen = deferred.callback
    session.openFailed = deferred.errback

    connection.openChannel(session)

    return deferred"
2748,"def defaultSessionFactory(env={}, usePTY=False, *args, **kwargs):
    """"""Create a SSHChannel of the given :channelType: type
    """"""
    return SSHSession(env, usePTY, *args, **kwargs)"
2749,"def requestExec(self, commandLine):
        """"""Request execution of :commandLine: and return a deferred reply.
        """"""
        data = common.NS(commandLine)
        return self.sendRequest('exec', data, wantReply=True)"
2750,"def requestSubsystem(self, subsystem):
        """"""Request a subsystem and return a deferred reply.
        """"""
        data = common.NS(subsystem)
        return self.sendRequest('subsystem', data, wantReply=True)"
2751,"def requestPty(self, term=None, rows=0, cols=0, xpixel=0, ypixel=0, modes=''):
        """"""Request allocation of a pseudo-terminal for a channel

        @param term: TERM environment variable value (e.g., vt100)
        @param columns: terminal width, characters (e.g., 80)
        @param rows: terminal height, rows (e.g., 24)
        @param width: terminal width, pixels (e.g., 640)
        @param height: terminal height, pixels (e.g., 480)
        @param modes: encoded terminal modes

        The dimension parameters are only informational.
        Zero dimension parameters are ignored. The columns/rows dimensions
        override the pixel dimensions (when nonzero). Pixel dimensions refer
        to the drawable area of the window.
        """"""
        #TODO: Needs testing!
        term = term or os.environ.get('TERM', '')
        data = packRequest_pty_req(term, (rows, cols, xpixel, ypixel), modes)
        return self.sendRequest('pty-req', data)"
2752,"def requestEnv(self, env={}):
        """"""Send requests to set the environment variables for the channel
        """"""
        for variable, value in env.items():
            data = common.NS(variable) + common.NS(value)
            self.sendRequest('env', data)"
2753,"def commandstr(command):
    """"""Convert command into string.""""""
    if command == CMD_MESSAGE_ERROR:
        msg = ""CMD_MESSAGE_ERROR""
    elif command == CMD_MESSAGE_LIST:
        msg = ""CMD_MESSAGE_LIST""
    elif command == CMD_MESSAGE_PASSWORD:
        msg = ""CMD_MESSAGE_PASSWORD""
    elif command == CMD_MESSAGE_MP3:
        msg = ""CMD_MESSAGE_MP3""
    elif command == CMD_MESSAGE_DELETE:
        msg = ""CMD_MESSAGE_DELETE""
    elif command == CMD_MESSAGE_VERSION:
        msg = ""CMD_MESSAGE_VERSION""
    elif command == CMD_MESSAGE_CDR_AVAILABLE:
        msg = ""CMD_MESSAGE_CDR_AVAILABLE""
    elif command == CMD_MESSAGE_CDR:
        msg = ""CMD_MESSAGE_CDR""
    else:
        msg = ""CMD_MESSAGE_UNKNOWN""
    return msg"
2754,"def run():
    """"""Command for reflection database objects""""""
    parser = OptionParser(
        version=__version__, description=__doc__,
    )

    parser.add_option(
        '-u', '--url', dest='url',
        help='Database URL (connection string)',
    )

    parser.add_option(
        '-r', '--render', dest='render', default='dot',
        choices=['plantuml', 'dot'],
        help='Output format - plantuml or dot',
    )

    parser.add_option(
        '-l', '--list', dest='list', action='store_true',
        help='Output database list of tables and exit',
    )

    parser.add_option(
        '-i', '--include', dest='include',
        help='List of tables to include through "",""',
    )

    parser.add_option(
        '-e', '--exclude', dest='exclude',
        help='List of tables to exlude through "",""',
    )

    (options, args) = parser.parse_args()

    if not options.url:
        print('-u/--url option required')
        exit(1)

    engine = create_engine(options.url)
    meta = MetaData()

    meta.reflect(bind=engine)

    if options.list:
        print('Database tables:')
        tables = sorted(meta.tables.keys())

        def _g(l, i):
            try:
                return tables[i]
            except IndexError:
                return ''

        for i in range(0, len(tables), 2):
            print(' {0}{1}{2}'.format(
                _g(tables, i),
                ' ' * (38 - len(_g(tables, i))),
                _g(tables, i + 1),
            ))

        exit(0)

    tables = set(meta.tables.keys())

    if options.include:
        tables &= set(map(string.strip, options.include.split(',')))

    if options.exclude:
        tables -= set(map(string.strip, options.exclude.split(',')))

    desc = describe(map(lambda x: operator.getitem(meta.tables, x), tables))
    print(getattr(render, options.render)(desc))"
2755,"def get_poll(poll_id):
    """""" Get a strawpoll.

    Example:

        poll = strawpy.get_poll('11682852')

    :param poll_id:
    :return: strawpy.Strawpoll object
    """"""
    return StrawPoll(requests.get('{api_url}/{poll_id}'.format(api_url=api_url, poll_id=poll_id)))"
2756,"def create_poll(title, options, multi=True, permissive=True, captcha=False, dupcheck='normal'):
    """""" Create a strawpoll.

    Example:

        new_poll = strawpy.create_poll('Is Python the best?', ['Yes', 'No'])

    :param title:
    :param options:
    :param multi:
    :param permissive:
    :param captcha:
    :param dupcheck:
    :return: strawpy.Strawpoll object
    """"""
    query = {
        'title': title,
        'options': options,
        'multi': multi,
        'permissive': permissive,
        'captcha': captcha,
        'dupcheck': dupcheck
    }
    return StrawPoll(requests.post('http://strawpoll.me/api/v2/polls', data=json.dumps(query)))"
2757,"def raise_status(response):
    """"""Raise an exception if the request did not return a status code of 200.

    :param response: Request response body
    """"""
    if response.status_code != 200:
        if response.status_code == 401:
            raise StrawPollException('Unauthorized', response)
        elif response.status_code == 403:
            raise StrawPollException('Forbidden', response)
        elif response.status_code == 404:
            raise StrawPollException('Not Found', response)
        else:
            response.raise_for_status()"
2758,"def refresh(self):
        """""" Refresh all class attributes.

        """"""
        strawpoll_response = requests.get('{api_url}/{poll_id}'.format(api_url=api_url, poll_id=self.id))
        raise_status(strawpoll_response)
        self.status_code = strawpoll_response.status_code
        self.response_json = strawpoll_response.json()
        self.id = self.response_json['id']
        self.title = self.response_json['title']
        self.options = self.response_json['options']
        self.votes = self.response_json['votes']
        self.captcha = self.response_json['captcha']
        self.dupcheck = self.response_json['dupcheck']
        self.url = 'https://www.strawpoll.me/{id}'.format(id=self.id)
        self.results_url = 'https://www.strawpoll.me/{id}/r'.format(id=self.id)"
2759,"def write_json_file(self, path):
        """"""
        Serialize this VariantCollection to a JSON representation and write it
        out to a text file.
        """"""
        with open(path, ""w"") as f:
            f.write(self.to_json())"
2760,"def read_json_file(cls, path):
        """"""
        Construct a VariantCollection from a JSON file.
        """"""
        with open(path, 'r') as f:
            json_string = f.read()
        return cls.from_json(json_string)"
2761,"def dumps(data, escape=False, **kwargs):
    """"""A wrapper around `json.dumps` that can handle objects that json
    module is not aware.

    This function is aware of a list of custom serializers that can be
    registered by the API user, making it possible to convert any kind
    of object to types that the json library can handle.
    """"""
    if 'sort_keys' not in kwargs:
        kwargs['sort_keys'] = True

    converted = json.dumps(data, default=_converter, **kwargs)
    if escape:
        # We're escaping the whole dumped string here cause there's no (easy)
        # way to hook into the native json library and change how they process
        # values like strings, None objects and some other ""literal"" stuff.
        #
        # Also, we're not escaping quotes here cause they're escaped by the
        # native json library already. So, we just escape basic html entities,
        # like <, > and &;
        return cgi.escape(converted)
    return converted"
2762,"def deserialize(klass, data):
    """"""Helper function to access a method that creates objects of a
    given `klass` with the received `data`.
    """"""
    handler = DESERIALIZE_REGISTRY.get(klass)
    if handler:
        return handler(data)
    raise TypeError(""There is no deserializer registered to handle ""
                    ""instances of '{}'"".format(klass.__name__))"
2763,"def _convert_from(data):
    """"""Internal function that will be hooked to the native `json.loads`

    Find the right deserializer for a given value, taking into account
    the internal deserializer registry.
    """"""
    try:
        module, klass_name = data['__class__'].rsplit('.', 1)
        klass = getattr(import_module(module), klass_name)
    except (ImportError, AttributeError, KeyError):
        # But I still haven't found what I'm looking for
        #
        # Waiting for three different exceptions here. KeyError will
        # raise if can't find the ""__class__"" entry in the json `data`
        # dictionary. ImportError happens when the module present in the
        # dotted name can't be resolved. Finally, the AttributeError
        # happens when we can find the module, but couldn't find the
        # class on it.
        return data
    return deserialize(klass, data['__value__'])"
2764,"def _converter(data):
    """"""Internal function that will be passed to the native `json.dumps`.

    This function uses the `REGISTRY` of serializers and try to convert
    a given instance to an object that json.dumps can understand.
    """"""
    handler = REGISTRY.get(data.__class__)
    if handler:
        full_name = '{}.{}'.format(
            data.__class__.__module__,
            data.__class__.__name__)
        return {
            '__class__': full_name,
            '__value__': handler(data),
        }
    raise TypeError(repr(data) + "" is not JSON serializable"")"
2765,"def start(self):
        """"""
        Try to init the main sub-components (:func:`~responsebot.utils.handler_utils.discover_handler_classes`, \
        :func:`~responsebot.utils.auth_utils.auth`, :class:`~responsebot.responsebot_stream.ResponseBotStream`, etc.)
        """"""
        logging.info('ResponseBot started')

        handler_classes = handler_utils.discover_handler_classes(self.config.get('handlers_package'))
        if len(handler_classes) == 0:
            logging.warning('No handler found. Did you forget to extend BaseTweethandler? Check --handlers-module')

        while True:
            try:
                client = auth_utils.auth(self.config)

                listener = ResponseBotListener(client=client, handler_classes=handler_classes)

                stream = ResponseBotStream(client=client, listener=listener)
                stream.start()
            except (APIQuotaError, AuthenticationError, TweepError) as e:
                self.handle_error(e)
            else:
                break"
2766,"def handle_error(self, error):
        """"""
        Try to detect repetitive errors and sleep for a while to avoid being marked as spam
        """"""
        logging.exception(""try to sleep if there are repeating errors."")
        error_desc = str(error)
        now = datetime.datetime.now()
        if error_desc not in self.error_time_log:
            self.error_time_log[error_desc] = now
            return

        time_of_last_encounter = self.error_time_log[str(error)]
        time_since_last_encounter = now - time_of_last_encounter
        if time_since_last_encounter.total_seconds() > self.config.get('min_seconds_between_errors'):
            self.error_time_log[error_desc] = now
            return

        if error_desc not in self.error_sleep_log:
            time.sleep(self.config.get('sleep_seconds_on_consecutive_errors'))
            self.error_sleep_log[error_desc] = 1
        else:
            sys.exit()"
2767,"def parse_isodate(datestr):
    """"""Parse a string that loosely fits ISO 8601 formatted date-time string
    """"""
    m = isodate_rx.search(datestr)
    assert m, 'unrecognized date format: ' + datestr
    year, month, day = m.group('year', 'month', 'day')
    hour, minute, second, fraction = m.group('hour', 'minute', 'second', 'fraction')
    tz, tzhh, tzmm = m.group('tz', 'tzhh', 'tzmm')
    dt = datetime.datetime(int(year), int(month), int(day), int(hour))
    if fraction is None:
        fraction = 0
    else:
        fraction = float('0.' + fraction)
    if minute is None:
        dt = dt.replace(minute=int(60 * fraction))
    else:
        dt = dt.replace(minute=int(minute))
        if second is None:
            dt = dt.replace(second=int(60 * fraction))
        else:
            dt = dt.replace(second=int(second), microsecond=int(1000000 * fraction))
    if tz is not None:
        if tz[0] == 'Z':
            offset = 0
        else:
            offset = datetime.timedelta(minutes=int(tzmm or 0), hours=int(tzhh))
            if tz[0] == '-':
                offset = -offset
        dt = dt.replace(tzinfo=UTCOffset(offset))
    return dt"
2768,"def ls(
        self, rev, path, recursive=False, recursive_dirs=False,
        directory=False, report=()
    ):
        """"""List directory or file

        :param rev: The revision to use.
        :param path: The path to list. May start with a '/' or not. Directories
                     may end with a '/' or not.
        :param recursive: Recursively list files in subdirectories.
        :param recursive_dirs: Used when recursive=True, also list directories.
        :param directory: If path is a directory, list path itself instead of
                          its contents.
        :param report: A list or tuple of extra attributes to return that may
                       require extra processing. Recognized values are 'size',
                       'target', 'executable', and 'commit'.

        Returns a list of dictionaries with the following keys:

        **type**
            The type of the file: 'f' for file, 'd' for directory, 'l' for
            symlink.
        **name**
            The name of the file. Not present if directory=True.
        **size**
            The size of the file. Only present for files when 'size' is in
            report.
        **target**
            The target of the symlink. Only present for symlinks when
            'target' is in report.
        **executable**
            True if the file is executable, False otherwise.    Only present
            for files when 'executable' is in report.

        Raises PathDoesNotExist if the path does not exist.

        """"""
        raise NotImplementedError"
2769,"def log(
        self, revrange=None, limit=None, firstparent=False, merges=None,
        path=None, follow=False
    ):
        """"""Get commit logs

        :param revrange: Either a single revision or a range of revisions as a
                         2-element list or tuple.
        :param int limit: Limit the number of log entries.
        :param bool firstparent: Only follow the first parent of merges.
        :param bool merges: True means only merges, False means no merges,
                            None means both merges and non-merges.
        :param str path: Only match commits containing changes on this path.
        :param bool follow: Follow file history across renames.
        :returns: log information
        :rtype: :class:`CommitLogEntry` or list of :class:`CommitLogEntry`

        If revrange is None, return a list of all log entries in reverse
        chronological order.

        If revrange is a single revision, return a single log entry.

        If revrange is a 2 element list [A,B] or tuple (A,B), return a list of log
        entries starting at B and following that branch back to A or one of its
        ancestors (not inclusive. If A is None, follow branch B back to the
        beginning of history. If B is None, list all descendants in reverse
        chronological order.

        """"""
        raise NotImplementedError"
2770,"def user_create(self, cloudflare_email, cloudflare_pass, unique_id=None):
        """"""
        Create new cloudflare user with selected email and id. Optionally also
        select unique_id which can be then used to get user information.

        :param    cloudflare_email: new user cloudflare email
        :type     cloudflare_email: str
        :param    cloudflare_pass:  new user cloudflare password
        :type     cloudflare_pass:  str
        :param    unique_id:        new user unique id
        :type     unique_id:        str (optional)

        :returns:
        :rtype:   dict
        """"""
        params = {
            'act': 'user_create',
            'cloudflare_email': cloudflare_email,
            'cloudflare_pass': cloudflare_pass
        }
        if unique_id:
            params['unique_id'] = unique_id
        return self._request(params)"
2771,"def zone_set(self, user_key, zone_name, resolve_to, subdomains):
        """"""
        Create new zone for user associated with this user_key.

        :param    user_key:   The unique 3auth string,identifying the user's
        CloudFlare Account. Generated from a user_create or user_auth
        :type     user_key:   str
        :param    zone_name:  The zone you'd like to run CNAMES through CloudFlare for, e.g. ""example.com"".
        :type     zone_name:  str
        :param    resolve_to: The CNAME that CloudFlare should ultimately
        resolve web connections to after they have been filtered
        :type     resolve_to: str
        :param    subdomains: A comma-separated string of subdomain(s) that
        CloudFlare should host, e.g. ""www,blog,forums""
        :type     subdomains: str

        :returns:
        :rtype:   dict
        """"""
        params = {
            'act': 'zone_set',
            'user_key': user_key,
            'zone_name': zone_name,
            'resolve_to': resolve_to,
            'subdomains': subdomains,
        }
        return self._request(params)"
2772,"def full_zone_set(self, user_key, zone_name):
        """"""
        Create new zone and all subdomains for user associated with this
        user_key.

        :param    user_key:   The unique 3auth string,identifying the user's
        CloudFlare Account. Generated from a user_create or user_auth
        :type     user_key:   str
        :param    zone_name:  The zone you'd like to run CNAMES through CloudFlare for, e.g. ""example.com"".
        :type     zone_name:  str

        :returns:
        :rtype:   dict
        """"""
        params = {
            'act': 'full_zone_set',
            'user_key': user_key,
            'zone_name': zone_name,
        }
        return self._request(params)"
2773,"def user_lookup(self, cloudflare_email=None, unique_id=None):
        """"""
        Lookup user data based on either his cloudflare_email or his
        unique_id.

        :param    cloudflare_email: email associated with user
        :type     cloudflare_email: str
        :param    unique_id:        unique id associated with user
        :type     unique_id:        str

        :returns:
        :rtype:   dict
        """"""
        if not cloudflare_email and not unique_id:
            raise KeyError(
                'Either cloudflare_email or unique_id must be present')

        params = {'act': 'user_lookup'}
        if cloudflare_email:
            params['cloudflare_email'] = cloudflare_email
        else:
            params['unique_id'] = unique_id

        return self._request(params)"
2774,"def user_auth(
        self,
        cloudflare_email=None,
        cloudflare_pass=None,
        unique_id=None
            ):
        """"""
        Get user_key based on either his email and password or unique_id.

        :param    cloudflare_email: email associated with user
        :type     cloudflare_email: str
        :param    cloudflare_pass: pass associated with user
        :type     cloudflare_pass: str
        :param    unique_id:        unique id associated with user
        :type     unique_id:        str

        :returns:
        :rtype:   dict
        """"""
        if not (cloudflare_email and cloudflare_pass) and not unique_id:
            raise KeyError(
                'Either cloudflare_email and cloudflare_pass or unique_id must be present')
        params = {'act': 'user_auth'}
        if cloudflare_email and cloudflare_pass:
            params['cloudflare_email'] = cloudflare_email
            params['cloudflare_pass'] = cloudflare_pass
        if unique_id:
            params['unique_id'] = unique_id

        return self._request(params)"
2775,"def zone_list(
        self,
        user_key,
        limit=100,
        offset=0,
        zone_name=None,
        sub_id=None,
        zone_status='ALL',
        sub_status='ALL',
            ):
        """"""
        List zones for a user.

        :param    user_key:  key for authentication of user
        :type     user_key:  str
        :param    limit: limit of zones shown
        :type     limit: int
        :param    offset: offset of zones to be shown
        :type     offset: int
        :param    zone_name: name of zone to lookup
        :type     zone_name: str
        :param    sub_id: subscription id of reseller (only for use by resellers)
        :type     sub_id: str
        :param    zone_status: status of zones to be shown
        :type     zone_status: str (one of: V(active), D(deleted), ALL)
        :param    sub_status: status of subscription of zones to be shown
        :type     zone_name: str (one of: V(active), CNL(cancelled), ALL )

        :returns:
        :rtype:   dict
        """"""
        if zone_status not in ['V', 'D', 'ALL']:
            raise ValueError('zone_status has to be V, D or ALL')
        if sub_status not in ['V', 'CNL', 'ALL']:
            raise ValueError('sub_status has to be V, CNL or ALL')
        params = {
            'act': 'zone_list',
            'user_key': user_key,
            'limit': limit,
            'offset': offset,
            'zone_status': zone_status,
            'sub_status': sub_status
        }
        if zone_name:
            params['zone_name'] = zone_name
        if sub_id:
            params['sub_id'] = sub_id

        return self._request(params)"
2776,"def attr_exists(self, attr):
        """"""Returns True if at least on instance of the attribute is found
        """"""
        gen = self.attr_gen(attr)
        n_instances = len(list(gen))
        if n_instances > 0:
            return True
        else:
            return False"
2777,"def datasets(self):
        """"""Method returns a list of dataset paths.

        Examples
        --------
        >>> for dataset in h5f.datasets():
                print(dataset)
        '/dataset1/data1/data'
        '/dataset1/data2/data'
        '/dataset2/data1/data'
        '/dataset2/data2/data'
        """"""
        HiisiHDF._clear_cache()
        self.visititems(HiisiHDF._is_dataset)
        return HiisiHDF.CACHE['dataset_paths']"
2778,"def groups(self):
        """"""Method returns a list of all goup paths
        
        Examples
        --------        
        >>> for group in h5f.groups():
                print(group)        
        '/'
        '/dataset1'
        '/dataset1/data1'
        '/dataset1/data2'
        """"""
        HiisiHDF._clear_cache()
        self.CACHE['group_paths'].append('/')
        self.visititems(HiisiHDF._is_group)
        return HiisiHDF.CACHE['group_paths']"
2779,"def attr_gen(self, attr):
        """"""Returns attribute generator that yields namedtuples containing
        path value pairs
        
        Parameters
        ----------
        attr : str
            Name of the search attribute

        Returns
        -------
        attr_generator : generator
            Returns a generator that yields named tuples with field names
            path and value.

        Examples
        --------
        >>> gen = h5f.attr_gen('elangle')
        >>> pair = next(gen)
        >>> print(pair.path)
        '/dataset1/where'
        >>> print(pair.value)
        0.5

        """"""
        HiisiHDF._clear_cache()
        HiisiHDF.CACHE['search_attribute'] = attr
        HiisiHDF._find_attr_paths('/', self['/']) # Check root attributes
        self.visititems(HiisiHDF._find_attr_paths)
        path_attr_gen = (PathValue(attr_path, self[attr_path].attrs.get(attr)) for attr_path in HiisiHDF.CACHE['attribute_paths'])
        return path_attr_gen"
2780,"def create_from_filedict(self, filedict):
        """"""
        Creates h5 file from dictionary containing the file structure.
        
        Filedict is a regular dictinary whose keys are hdf5 paths and whose
        values are dictinaries containing the metadata and datasets. Metadata
        is given as normal key-value -pairs and dataset arrays are given using
        'DATASET' key. Datasets must be numpy arrays.
                
        Method can also be used to append existing hdf5 file. If the file is
        opened in read only mode, method does nothing.

        Examples
        --------
        Create newfile.h5 and fill it with data and metadata

        >>> h5f = HiisiHDF('newfile.h5', 'w')
        >>> filedict = {'/':{'attr1':'A'},
                        '/dataset1/data1/data':{'DATASET':np.zeros(100), 'quantity':'emptyarray'}, 'B':'b'}
        >>> h5f.create_from_filedict(filedict)

        """"""
        if self.mode in ['r+','w', 'w-', 'x', 'a']:
            for h5path, path_content in filedict.iteritems():
                if path_content.has_key('DATASET'):
                    # If path exist, write only metadata
                    if h5path in self:
                        for key, value in path_content.iteritems():
                            if key != 'DATASET':
                                self[h5path].attrs[key] = value
                    else:
                        try:
                            group = self.create_group(os.path.dirname(h5path))
                        except ValueError:
                            group = self[os.path.dirname(h5path)]
                            pass # This pass has no effect?
                        new_dataset = group.create_dataset(os.path.basename(h5path), data=path_content['DATASET'])
                        for key, value in path_content.iteritems():
                            if key != 'DATASET':
                                new_dataset.attrs[key] = value
                else:
                    try:  
                        group = self.create_group(h5path)
                    except ValueError:
                        group = self[h5path]
                    for key, value in path_content.iteritems():
                        group.attrs[key] = value"
2781,"def search(self, attr, value, tolerance=0):
        """"""Find paths with a key value match

        Parameters
        ----------
        attr : str
            name of the attribute
        value : str or numerical value
            value of the searched attribute
        
        Keywords
        --------
        tolerance : float
            tolerance used when searching for matching numerical
            attributes. If the value of the attribute found from the file
            differs from the searched value less than the tolerance, attributes
            are considered to be the same.

        Returns
        -------
        results : list
            a list of all matching paths

        Examples
        --------

        >>> for result in h5f.search('elangle', 0.5, 0.1):
                print(result)        
        '/dataset1/where'

        >>> for result in h5f.search('quantity', 'DBZH'):
                print(result)
        '/dataset1/data2/what'
        '/dataset2/data2/what'
        '/dataset3/data2/what'
        '/dataset4/data2/what'
        '/dataset5/data2/what'
        
        """"""
        found_paths = []
        gen = self.attr_gen(attr)
        for path_attr_pair in gen:
            # if attribute is numerical use numerical_value_tolerance in
            # value comparison. If attribute is string require exact match
            if isinstance(path_attr_pair.value, str):
                type_name = 'str'
            else:
                type_name = path_attr_pair.value.dtype.name
            if 'int' in type_name or 'float' in type_name:
                if abs(path_attr_pair.value - value) <= tolerance:
                    found_paths.append(path_attr_pair.path)
            else:
                if path_attr_pair.value == value:
                    found_paths.append(path_attr_pair.path)

        return found_paths"
2782,"def _extractReporterIons(ionArrays, reporterMz, mzTolerance):
    """"""Find and a list of reporter ions and return mz and intensity values.

    Expected reporter mz values are searched in ""ionArray['mz']"" and reported if
    the observed relative deviation is less than specified by ""mzTolerance"". In
    the case of multiple matches, the one with the minimal deviation is picked.
    If no matching entries are found numpy.nan is returned for the mz value and
    an intensity of 0. The returned arrays are in the order of ""reporterMz""
    values.

    :param ionArrays: a dictionary containing two numpy arrays of equal size,
        {""i"": an array of ion intensities, ""mz"" an array of ion mz values}
    :param reporterMz: a list of reporter mz values
    :param mzTolerance: maximum allowed relative mz deviation
    :returns: {'mz': numpy.array(), 'i': numpy.array()}
    """"""
    reporterIons = {'mz': [], 'i': []}
    for reporterMzValue in reporterMz:
        limHi = reporterMzValue * (1+mzTolerance)
        limLo = reporterMzValue * (1-mzTolerance)
        loPos = bisect.bisect_left(ionArrays['mz'], limLo)
        upPos = bisect.bisect_right(ionArrays['mz'], limHi)

        matchingValues = ionArrays['mz'][loPos:upPos]
        if matchingValues.size == 0:
            reporterIons['i'].append(0)
            reporterIons['mz'].append(numpy.nan)
        elif matchingValues.size == 1:
            reporterIons['i'].append(ionArrays['i'][loPos])
            reporterIons['mz'].append(ionArrays['mz'][loPos])
        else:
            mzDeviations = numpy.abs(matchingValues-reporterMzValue)
            minDeviationPos = numpy.argmin(mzDeviations)
            bestMatchArrayPos = range(loPos, upPos)[minDeviationPos]
            reporterIons['i'].append(ionArrays['i'][bestMatchArrayPos])
            reporterIons['mz'].append(ionArrays['mz'][bestMatchArrayPos])

    reporterIons['mz'] = numpy.array(reporterIons['mz'],
                                     dtype=ionArrays['mz'].dtype
                                     )
    reporterIons['i'] = numpy.array(reporterIons['i'],
                                    dtype=ionArrays['i'].dtype
                                    )

    return reporterIons"
2783,"def _correctIsotopeImpurities(matrix, intensities):
    """"""Corrects observed reporter ion intensities for isotope impurities.

    :params matrix: a matrix (2d nested list) containing numbers, each isobaric
        channel must be present as a COLUMN. Use maspy.isobar._transposeMatrix()
        if channels are written in rows.
    :param intensities: numpy array of observed reporter ion intensities.
    :returns: a numpy array of reporter ion intensities corrected for isotope
        impurities.
    """"""
    correctedIntensities, _ = scipy.optimize.nnls(matrix, intensities)
    return correctedIntensities"
2784,"def _normalizeImpurityMatrix(matrix):
    """"""Normalize each row of the matrix that the sum of the row equals 1.

    :params matrix: a matrix (2d nested list) containing numbers, each isobaric
        channel must be present as a row.
    :returns: a matrix containing normalized values
    """"""
    newMatrix = list()
    for line in matrix:
        total = sum(line)
        if total != 0:
            newMatrix.append([i / total for i in line])
        else:
            newMatrix.append(line)
    return newMatrix"
2785,"def _padImpurityMatrix(matrix, preChannels, postChannels):
    """"""Align the values of an isotope impurity matrix and fill up with 0.

    NOTE:
        The length of the rows in the ""matrix"" must be the sum of ""preChannels""
        and ""postChannels"" + 1.

    :params matrix: a matrix (2d nested list) containing numbers, each isobaric
        channel must be present as a row.
    :params preChannels: number of matrix columns with a nominal mass shift < 0
        (-1, -2,..) in respect to the reporter ion mz value.
    :params postChannels: number of matrix columns with a nominal mass shift > 0
        (+1, +2,..) in respect to the reporter ion mz value.

    :returns: extended matrix, where the number of rows is unchanged but the
        length of each row is extend to the number of rows.
    """"""
    extendedMatrix = list()
    lastMatrixI = len(matrix)-1
    for i, line in enumerate(matrix):
        prePadding = itertools.repeat(0., i)
        postPadding = itertools.repeat(0., lastMatrixI-i)
        newLine = list(itertools.chain(prePadding, line, postPadding))
        extendedMatrix.append(newLine[preChannels:-postChannels])

    return extendedMatrix"
2786,"def _processImpurityMatrix(self):
        """"""Process the impurity matrix so that it can be used to correct
        observed reporter intensities.
        """"""
        processedMatrix = _normalizeImpurityMatrix(self.impurityMatrix)
        processedMatrix = _padImpurityMatrix(
            processedMatrix, self.matrixPreChannels, self.matrixPostChannels
            )
        processedMatrix = _transposeMatrix(processedMatrix)
        return processedMatrix"
2787,"def exception(message):
    """"""Exception method convenience wrapper.""""""

    def decorator(method):
        """"""Inner decorator so we can accept arguments.""""""

        @wraps(method)
        def wrapper(self, *args, **kwargs):
            """"""Innermost decorator wrapper - this is confusing.""""""
            if self.messages:
                kwargs['message'] = args[0] if args else kwargs.get('message', message)
            else:
                kwargs['message'] = None
            kwargs['prefix'] = self.prefix
            kwargs['statsd'] = self.statsd

            return method(self, **kwargs)

        return wrapper

    return decorator"
2788,"def to_dict(self):
        """"""Convert Exception class to a Python dictionary.""""""
        val = dict(self.payload or ())
        if self.message:
            val['message'] = self.message
        return val"
2789,"def init_app(self, app, config=None, statsd=None):
        """"""Init Flask Extension.""""""
        if config is not None:
            self.config = config
        elif self.config is None:
            self.config = app.config

        self.messages = self.config.get('EXCEPTION_MESSAGE', True)
        self.prefix = self.config.get('EXCEPTION_PREFIX', DEFAULT_PREFIX)
        self.statsd = statsd"
2790,"def program(self):
        """"""program : (newline) statement
                   | program statement
        """"""
        statements = []
        if self.cur_token.type == TokenTypes.NEW_LINE:
            self.eat(TokenTypes.NEW_LINE)
        while self.cur_token.type != TokenTypes.EOF:
            statements += [self.statement()]
        return Block(statements)"
2791,"def statement(self):
        """"""
        statement   : assign_statement
                    | expression
                    | control
                    | empty
        Feature For Loop adds:
                    | loop
        Feature Func adds:
                    | func
                    | return statement
        """"""
        if self.cur_token.type == TokenTypes.VAR:
            self.tokenizer.start_saving(self.cur_token)
            self.variable()
            peek_var = self.cur_token
            self.tokenizer.replay()
            self.eat()
            if peek_var.type == TokenTypes.ASSIGN:
                return self.assign_statement()
            else:
                return self.expression()
        elif self.cur_token.type in TokenTypes.control(self.features):
            return self.control()
        elif self.cur_token.type in TokenTypes.loop(self.features):
            return self.loop()
        elif self.cur_token.type in TokenTypes.func(self.features):
            if self.cur_token.type == TokenTypes.FUNC:
                return self.func()
            elif self.cur_token.type == TokenTypes.RETURN:
                return self.return_statement()
        self.error(""Invalid token or unfinished statement"")"
2792,"def assign_statement(self):
        """"""
        assign smt  : variable ASSIGN expression(;)
        Feature Type Array adds:
                    | variable SETITEM expression(;)
        """"""
        left = self.variable()
        op = self.cur_token
        self.eat(TokenTypes.ASSIGN)
        right = self.expression()
        smt = None
        if Features.TYPE_ARRAY in self.features and isinstance(left, GetArrayItem):
            # Remake this as a setitem.
            smt = SetArrayItem(left.left, left.right, right)
        else:
            smt = Assign(op, left, right)
        if self.cur_token.type == TokenTypes.SEMI_COLON:
            self.eat(TokenTypes.SEMI_COLON)
        return smt"
2793,"def control(self):
        """"""
        control    : 'if' ctrl_exp block ('elif' ctrl_exp block)* ('else' block)
        """"""
        self.eat(TokenTypes.IF)
        ctrl = self.expression()
        block = self.block()
        ifs = [If(ctrl, block)]
        else_block = Block()
        while self.cur_token.type == TokenTypes.ELIF:
            self.eat(TokenTypes.ELIF)
            ctrl = self.expression()
            block = self.block()
            ifs.append(If(ctrl, block))
        if self.cur_token.type == TokenTypes.ELSE:
            self.eat(TokenTypes.ELSE)
            else_block = self.block()
        return ControlBlock(ifs, else_block)"
2794,"def loop(self):
        """"""
        loop       : 'for' init; ctrl; inc block
        """"""
        self.eat(TokenTypes.FOR_LOOP)
        init = NoOp()
        if self.cur_token.type != TokenTypes.SEMI_COLON:
            init = self.assign_statement()
        else:
            self.eat(TokenTypes.SEMI_COLON)

        ctrl = NoOp()
        if self.cur_token.type != TokenTypes.SEMI_COLON:
            ctrl = self.expression()
        self.eat(TokenTypes.SEMI_COLON)

        inc = NoOp()
        if self.cur_token.type != TokenTypes.LBRACE:
            inc = self.assign_statement()

        block = self.block()
        return ForLoop(init, ctrl, inc, block)"
2795,"def func(self):
        """"""
        func       : func name(paramlist) block
        """"""
        self.eat(TokenTypes.FUNC)
        name = Var(self.cur_token)
        self.eat(TokenTypes.VAR)
        self.eat(TokenTypes.LPAREN)
        sig = self.param_list()
        self.eat(TokenTypes.RPAREN)
        block = self.block()
        return FunctionDef(name, Function(sig, block))"
2796,"def param_list(self):
        """"""
        paramlist  : var, paramlist
        paramlist  : var
        paramlist  :
        """"""
        params = []
        while self.cur_token.type == TokenTypes.VAR:
            params.append(Var(self.cur_token))
            self.eat(TokenTypes.VAR)
            if self.cur_token.type == TokenTypes.COMMA:
                self.eat(TokenTypes.COMMA)

        return FunctionSig(params)"
2797,"def arg_list(self, ending_char=TokenTypes.RPAREN):
        """"""
        arglist    : expression, arglist
        arglist    : expression
        arglist    :
        """"""
        args = []
        while not self.cur_token.type == ending_char:
            args.append(self.expression())
            if self.cur_token.type == TokenTypes.COMMA:
                self.eat(TokenTypes.COMMA)

        return args"
2798,"def array_const(self):
        """"""
        Feature Type Array adds:
        array      : [ arglist ]
        """"""
        self.eat(TokenTypes.LBRACKET)
        node = Array(self.arg_list(TokenTypes.RBRACKET))
        self.eat(TokenTypes.RBRACKET)
        return node"
2799,"def block(self):
        """"""
        block      : { (newline) statements } (newline)
        """"""
        statements = []
        self.eat(TokenTypes.LBRACE)
        if self.cur_token.type == TokenTypes.NEW_LINE:
            self.eat(TokenTypes.NEW_LINE)
        while self.cur_token.type != TokenTypes.RBRACE:
            statements.append(self.statement())
        self.eat(TokenTypes.RBRACE)
        if self.cur_token.type == TokenTypes.NEW_LINE:
            self.eat(TokenTypes.NEW_LINE)
        return Block(statements)"
2800,"def variable(self):
        """"""
        variable    : variable
        Feature Type Array adds:
        variable    : variable[expression]
        Feature Type Func adds:
        variable    : variable(arg_list)
        """"""
        var = Var(self.cur_token)
        self.eat(TokenTypes.VAR)
        if Features.TYPE_ARRAY in self.features:
            while self.cur_token.type == TokenTypes.LBRACKET:
                self.eat(TokenTypes.LBRACKET)
                # Start passed the logical ops.
                expr = self.operator_expression(level=2)
                self.eat(TokenTypes.RBRACKET)
                var = GetArrayItem(left=var, right=expr)
        if Features.FUNC in self.features:
            if self.cur_token.type == TokenTypes.LPAREN:
                self.eat(TokenTypes.LPAREN)
                args = self.arg_list()
                self.eat(TokenTypes.RPAREN)
                var = Call(var, args)
        return var"
2801,"def wrap_node(self, node, options):
        '''\
        celery registers tasks by decorating them, and so do we, so the user
        can pass a celery task and we'll wrap our code with theirs in a nice
        package celery can execute.
        '''
        if 'celery_task' in options:
            return options['celery_task'](node)

        return self.celery_task(node)"
2802,"def checkpoint(key=0, unpickler=pickle.load, pickler=pickle.dump, work_dir=gettempdir(), refresh=False):
    """"""
    A utility decorator to save intermediate results of a function. It is the
    caller's responsibility to specify a key naming scheme such that the output of
    each function call with different arguments is stored in a separate file.

    :param key: The key to store the computed intermediate output of the decorated function.

        if key is a string, it is used directly as the name.

        if key is a string.Template object, you can specify your file-naming
            convention using the standard string.Template conventions. Since string.Template
            uses named substitutions, it can handle only keyword arguments. Therfore, in addition to
            the standard Template conventions, an additional feature is provided to help with non-keyword
            arguments.

            For instance if you have a function definition as f(m, n,
            arg3='myarg3',arg4='myarg4'). Say you want your key to be:

                n followed by an _ followed by 'text' followed by arg3 followed
                by a . followed by arg4.

            Let n = 3, arg3='out', arg4='txt', then you are interested in
            getting '3_textout.txt'.

            This is written as key=Template('{1}_text$arg3.$arg4')

            The filename is first generated by substituting the kwargs, i.e
            key_id.substitute(kwargs), this would give the string
            '{1}_textout.txt' as output. This is further processed by a call to
            format with args as the argument, where the second argument is
            picked (since counting starts from 0), and we get 3_textout.txt.

        if key is a callable function, it is called with the same arguments as
            that of the function, in a special format.

            key must be of the form lambda arg, kwarg: ... your definition. arg
            is an iterable containing the un-named arguments of the function,
            and kwarg is a dictionary containing the keyword arguments.

            For instance, the above example can be written as:

            key = lambda arg, kwarg: '%d_text%s.%s'.format(arg[1], kwarg['arg3'], kwarg['arg4'])

            Or one can define a function that takes the same arguments:

            def key_namer(args, kwargs):
                return '%d_text%s.%s'.format(arg[1], kwarg['arg3'], kwarg['arg4'])

            This way you can do complex argument processing and name generation.

    :param pickler: The function that loads the saved object and returns.
    This should ideally be of the same format as the one that is computed.
    However, in certain cases, it is enough as long as it provides the
    information necessary for the caller, even if it is not exactly same as the
    object returned by the function.

    :param unpickler: The function that saves the computed object into a file.

    :param work_dir: The location where the checkpoint files are stored.

    :param do_refresh: If enabled, this will not skip, effectively disabling the
    decoration @checkpoint.

    REFRESHING: One of the intended ways to use the refresh feature is as follows:

    Say you are checkpointing a function f1, f2; have a file or a place where you define refresh variables:

    defs.py:
    -------

    REFRESH_f1 = True
    REFRESH_f2 = os.environ['F2_REFRESH']   # can set this externally

    code.py:
    -------
    @checkpoint(..., refresh=REFRESH_f1)
    def f1(...):
        your code.

    @checkpoint(..., refresh=REFRESH_f2)
    def f2(...):
        your code.

    This way, you have control on what to refresh without modifying the code,
    by setting the defs either via input or by modifying defs.py.

    """"""

    def decorator(func):
        def wrapped(*args, **kwargs):
            # If first arg is a string, use it directly.
            if isinstance(key, str):
                save_file = os.path.join(work_dir, key)
            elif isinstance(key, Template):
                save_file = os.path.join(work_dir, key.substitute(kwargs))
                save_file = save_file.format(*args)
            elif isinstance(key, types.FunctionType):
                save_file = os.path.join(work_dir, key(args, kwargs))
            else:
                logging.warn('Using 0-th argument as default.')
                save_file = os.path.join(work_dir, '{0}')
                save_file = save_file.format(args[key])

            logging.info('checkpoint@ %s' % save_file)

            # cache_file doesn't exist, run the function and save output in checkpoint.

            if isinstance(refresh, types.FunctionType):
                do_refresh = refresh()
            else:
                do_refresh = refresh

            if do_refresh or not os.path.exists(path=save_file):  # Otherwise compute it save it and return it.
                # If the program fails, don't checkpoint.
                try:
                    out = func(*args, **kwargs)
                except: # a blank raise re-raises the last exception.
                    raise
                else:  # If the program is successful, then go ahead and call the save function.
                    with open(save_file, 'wb') as f:
                        pickler(out, f)
                        return out
            # Otherwise, load the checkpoint file and send it.
            else:
                logging.info(""Checkpoint exists. Loading from: %s"" % save_file)
                with open(save_file, 'rb') as f:
                    return unpickler(f)
                    # Todo: Sending options to load/save functions.
        return wrapped

    return decorator"
2803,"def bfs(graph, start):
    """"""
    Finds the shortest string using BFS
    Args:
        graph (DFA): The DFA states
        start (DFA state): The DFA initial state
    Returns:
        str: The shortest string
    """"""
    # maintain a queue of paths
    queue = []
    visited = []
    # maintain a queue of nodes
    # push the first path into the queue
    queue.append([['', start]])
    while queue:
        # get the first path from the queue
        path = queue.pop(0)
        # get the last node from the path
        node = path[-1][1]
        if node.stateid not in visited:
            visited.append(node.stateid)
            # path found
            if node.final != TropicalWeight(float('inf')):
                return """".join([mnode[0] for mnode in path])
            # enumerate all adjacent nodes, construct a new path and push
            # it into the queue
            for arc in node.arcs:
                char = graph.isyms.find(arc.ilabel)
                next_state = graph[arc.nextstate]
                # print next_state.stateid
                if next_state.stateid not in visited:
                    new_path = list(path)
                    new_path.append([char, next_state])
                    queue.append(new_path)"
2804,"def run():
    """"""Display the arguments as a braille graph on standard output.""""""

    # We override the program name to reflect that this script must be run with
    # the python executable.
    parser = argparse.ArgumentParser(
        prog='python -m braillegraph',
        description='Print a braille bar graph of the given integers.'
    )

    # This flag sets the end string that we'll print. If we pass end=None to
    # print(), it will use its default. If we pass end='', it will suppress the
    # newline character.
    parser.add_argument('-n', '--no-newline', action='store_const',
                        dest='end', const='', default=None,
                        help='do not print the trailing newline character')

    # Add subparsers for the directions
    subparsers = parser.add_subparsers(title='directions')

    horizontal_parser = subparsers.add_parser('horizontal',
                                              help='a horizontal graph')
    horizontal_parser.set_defaults(
        func=lambda args: horizontal_graph(args.integers)
    )
    horizontal_parser.add_argument('integers', metavar='N', type=int,
                                   nargs='+', help='an integer')

    vertical_parser = subparsers.add_parser('vertical',
                                            help='a vertical graph')
    vertical_parser.set_defaults(
        func=lambda args: vertical_graph(args.integers, sep=args.sep)
    )
    vertical_parser.add_argument('integers', metavar='N', type=int, nargs='+',
                                 help='an integer')

    # The separator for groups of bars (i.e., ""lines""). If we pass None,
    # vertical_parser will use its default.
    vertical_parser.add_argument('-s', '--sep', action='store', default=None,
                                 help='separator for groups of bars')

    args = parser.parse_args()

    print(args.func(args), end=args.end)"
2805,"def _rnd_date(start, end):
    """"""Internal random date generator.
    """"""
    return date.fromordinal(random.randint(start.toordinal(), end.toordinal()))"
2806,"def rnd_date(start=date(1970, 1, 1), end=None, **kwargs):
    """"""
    Generate a random date between ``start`` to ``end``.

    :param start: Left bound
    :type start: string or datetime.date, (default date(1970, 1, 1))
    :param end: Right bound
    :type end: string or datetime.date, (default date.today())
    :return: a datetime.date object

    **中文文档**

    随机生成一个位于 ``start`` 和 ``end`` 之间的日期。
    """"""
    if end is None:
        end = date.today()
    start = parser.parse_date(start)
    end = parser.parse_date(end)
    _assert_correct_start_end(start, end)
    return _rnd_date(start, end)"
2807,"def rnd_date_array(size, start=date(1970, 1, 1), end=None, **kwargs):
    """"""
    Array or Matrix of random date generator.

    :returns: 1d or 2d array of datetime.date
    """"""
    if end is None:
        end = date.today()
    start = parser.parse_date(start)
    end = parser.parse_date(end)
    _assert_correct_start_end(start, end)
    return _randn(size, _rnd_date, start, end)"
2808,"def rnd_date_list_high_performance(size, start=date(1970, 1, 1), end=None, **kwargs):
    """"""
    Generate mass random date.

    :param size: int, number of
    :param start: date similar object, int / str / date / datetime
    :param end: date similar object, int / str / date / datetime, default today's date
    :param kwargs: args placeholder
    :return: list of datetime.date
    """"""
    if end is None:
        end = date.today()
    start_days = to_ordinal(parser.parse_datetime(start))
    end_days = to_ordinal(parser.parse_datetime(end))
    _assert_correct_start_end(start_days, end_days)
    if has_np:  # pragma: no cover
        return [
            from_ordinal(days)
            for days in np.random.randint(start_days, end_days, size)
        ]
    else:
        return [
            from_ordinal(random.randint(start_days, end_days))
            for _ in range(size)
        ]"
2809,"def rnd_datetime(start=datetime(1970, 1, 1), end=datetime.now()):
    """"""
    Generate a random datetime between ``start`` to ``end``.

    :param start: Left bound
    :type start: string or datetime.datetime, (default datetime(1970, 1, 1))
    :param end: Right bound
    :type end: string or datetime.datetime, (default datetime.now())
    :return: a datetime.datetime object

    **中文文档**

    随机生成一个位于 ``start`` 和 ``end`` 之间的时间。
    """"""
    start = parser.parse_datetime(start)
    end = parser.parse_datetime(end)
    _assert_correct_start_end(start, end)
    return _rnd_datetime(start, end)"
2810,"def rnd_datetime_array(size, start=datetime(1970, 1, 1), end=None):
    """"""
    Array or Matrix of random datetime generator.

    :returns: 1d or 2d array of datetime.date
    """"""
    if end is None:
        end = datetime.now()
    start = parser.parse_datetime(start)
    end = parser.parse_datetime(end)
    _assert_correct_start_end(start, end)
    return _randn(size, _rnd_datetime, start, end)"
2811,"def day_interval(year, month, day, milliseconds=False, return_string=False):
    """"""
    Return a start datetime and end datetime of a day.

    :param milliseconds: Minimum time resolution.
    :param return_string: If you want string instead of datetime, set True

    Usage Example::

        >>> start, end = rolex.day_interval(2014, 6, 17)
        >>> start
        datetime(2014, 6, 17, 0, 0, 0)

        >>> end
        datetime(2014, 6, 17, 23, 59, 59)
    """"""
    if milliseconds:  # pragma: no cover
        delta = timedelta(milliseconds=1)
    else:
        delta = timedelta(seconds=1)

    start = datetime(year, month, day)
    end = datetime(year, month, day) + timedelta(days=1) - delta

    if not return_string:
        return start, end
    else:
        return str(start), str(end)"
2812,"def month_interval(year, month, milliseconds=False, return_string=False):
    """"""
    Return a start datetime and end datetime of a month.

    :param milliseconds: Minimum time resolution.
    :param return_string: If you want string instead of datetime, set True

    Usage Example::

        >>> start, end = rolex.month_interval(2000, 2)
        >>> start
        datetime(2000, 2, 1, 0, 0, 0)

        >>> end
        datetime(2000, 2, 29, 23, 59, 59)
    """"""
    if milliseconds:  # pragma: no cover
        delta = timedelta(milliseconds=1)
    else:
        delta = timedelta(seconds=1)

    if month == 12:
        start = datetime(year, month, 1)
        end = datetime(year + 1, 1, 1) - delta
    else:
        start = datetime(year, month, 1)
        end = datetime(year, month + 1, 1) - delta

    if not return_string:
        return start, end
    else:
        return str(start), str(end)"
2813,"def year_interval(year, milliseconds=False, return_string=False):
    """"""
    Return a start datetime and end datetime of a year.

    :param milliseconds: Minimum time resolution.
    :param return_string: If you want string instead of datetime, set True

    Usage Example::

        >>> start, end = rolex.year_interval(2007)
        >>> start
        datetime(2007, 1, 1, 0, 0, 0)

        >>> end
        datetime(2007, 12, 31, 23, 59, 59)
    """"""
    if milliseconds:  # pragma: no cover
        delta = timedelta(milliseconds=1)
    else:
        delta = timedelta(seconds=1)

    start = datetime(year, 1, 1)
    end = datetime(year + 1, 1, 1) - delta

    if not return_string:
        return start, end
    else:
        return str(start), str(end)"
2814,"def renderfile(filename,
               options=None,
               templatePaths=None,
               default='',
               silent=False):
    """"""
    Renders a file to text using the mako template system.
    
    To learn more about mako and its usage, see [[www.makotemplates.org]]
    
    :return     <str> formatted text
    """"""
    if not mako:
        logger.debug('mako is not installed')
        return default

    if not mako:
        logger.debug('mako is not installed.')
        return default

    if templatePaths is None:
        templatePaths = []

    # use the default mako templates
    basepath = os.environ.get('MAKO_TEMPLATEPATH', '')
    if basepath:
        basetempls = basepath.split(os.path.pathsep)
    else:
        basetempls = []

    templatePaths += basetempls

    # include the root path
    templatePaths.insert(0, os.path.dirname(filename))
    templatePaths = map(lambda x: x.replace('\\', '/'), templatePaths)

    # update the default options
    scope = dict(os.environ)

    scope['projex_text'] = projex.text
    scope['date'] = date
    scope['datetime'] = datetime
    scope.update(_macros)
    scope.update(os.environ)

    if options is not None:
        scope.update(options)

    old_env_path = os.environ.get('MAKO_TEMPLATEPATH', '')
    os.environ['MAKO_TEMPLATEPATH'] = os.path.pathsep.join(templatePaths)

    logger.debug('rendering mako file: %s', filename)
    if templatePaths:
        lookup = mako.lookup.TemplateLookup(directories=templatePaths)
        templ = mako.template.Template(filename=filename, lookup=lookup)
    else:
        templ = mako.template.Template(filename=filename)

    try:
        output = templ.render(**scope)
    except StandardError:
        output = default
        if not silent:
            logger.exception('Error rendering mako text')

    os.environ['MAKO_TEMPLATEPATH'] = old_env_path

    return output"
2815,"def render(text,
           options=None,
           templatePaths=None,
           default=None,
           silent=False,
           raiseErrors=False):
    """"""
    Renders a template text to a resolved text value using the mako template
    system.
    
    Provides a much more robust template option to the projex.text system.  
    While the projex.text method can handle many simple cases with no
    dependencies, the makotext module makes use of the powerful mako template
    language.  This module provides a simple wrapper to the mako code.
    
    To learn more about mako and its usage, see [[www.makotemplates.org]]
    
    :param      text        <str>
    :param      options     <dict> { <str> key: <variant> value, .. }
    
    :return     <str> formatted text
    
    :usage      |import projex.makotext
                |options = { 'key': 10, 'name': 'eric' }
                |template = '${name.lower()}_${key}_${date.today()}.txt'
                |projex.makotext.render( template, options )
    """"""
    if not mako:
        logger.debug('mako is not installed.')
        return text if default is None else default

    if templatePaths is None:
        templatePaths = []

    # use the default mako templates
    basepath = os.environ.get('MAKO_TEMPLATEPATH', '')
    if basepath:
        basetempls = basepath.split(os.path.pathsep)
    else:
        basetempls = []

    templatePaths += basetempls

    # update the default options
    scope = dict(os.environ)

    scope['projex_text'] = projex.text
    scope['date'] = date
    scope['datetime'] = datetime
    scope.update(_macros)

    if options is not None:
        scope.update(options)

    if templatePaths:
        lookup = mako.lookup.TemplateLookup(directories=templatePaths)
        try:
            templ = mako.template.Template(text, lookup=lookup)
        except StandardError:
            output = text if default is None else default
            if not silent:
                logger.exception('Error compiling mako text')
            return output
    else:
        try:
            templ = mako.template.Template(text)
        except StandardError:
            output = text if default is None else default
            if not silent:
                logger.exception('Error compiling mako text')
            return output

    try:
        output = templ.render(**scope)
    except StandardError:
        if raiseErrors:
            raise
        output = text if default is None else default
        if not silent:
            logger.exception('Error rendering mako text')
        return output

    return output"
2816,"def collectfiles(path, filt=None):
    """"""
    Collects some files based on the given filename.
    
    :param      path | <str>
                filt | <method>
        
    :return     [(<str> name, <str> filepath), ..]
    """"""
    if not os.path.isdir(path):
        path = os.path.dirname(path)

    output = []
    for name in sorted(os.listdir(path)):
        filepath = os.path.join(path, name)
        if os.path.isfile(filepath):
            if not filt or filt(name):
                output.append((name, filepath))
    return output"
2817,"def get_milestone(self, title):
        """"""
        given the title as str, looks for an existing milestone or create a new one,
        and return the object
        """"""
        if not title:
            return GithubObject.NotSet
        if not hasattr(self, '_milestones'):
            self._milestones = {m.title: m for m in self.repo.get_milestones()}

        milestone = self._milestones.get(title)
        if not milestone:
            milestone = self.repo.create_milestone(title=title)
        return milestone"
2818,"def get_assignee(self, login):
        """"""
        given the user login, looks for a user in assignee list of the repo
        and return it if was found.
        """"""
        if not login:
            return GithubObject.NotSet
        if not hasattr(self, '_assignees'):
            self._assignees = {c.login: c for c in self.repo.get_assignees()}
        if login not in self._assignees:
            # warning
            print(""{} doesn't belong to this repo. This issue won't be assigned."".format(login))
        return self._assignees.get(login)"
2819,"def sender(self, issues):
        """"""
        push a list of issues to github
        """"""

        for issue in issues:
            state = self.get_state(issue.state)
            if issue.number:
                try:
                    gh_issue = self.repo.get_issue(issue.number)
                    original_state = gh_issue.state
                    if original_state == state:
                        action = 'Updated'
                    elif original_state == 'closed':
                        action = 'Reopened'
                    else:
                        action = 'Closed'

                    gh_issue.edit(title=issue.title,
                                  body=issue.body,
                                  labels=issue.labels,
                                  milestone=self.get_milestone(issue.milestone),
                                  assignee=self.get_assignee(issue.assignee),
                                  state=self.get_state(issue.state)
                                  )
                    print('{} #{}: {}'.format(action, gh_issue.number, gh_issue.title))
                except GithubException:
                    print('Not found #{}: {} (ignored)'.format(issue.number, issue.title))
                    continue
            else:
                gh_issue = self.repo.create_issue(title=issue.title,
                                                  body=issue.body,
                                                  labels=issue.labels,
                                                  milestone=self.get_milestone(issue.milestone),
                                                  assignee=self.get_assignee(issue.assignee))
                print('Created #{}: {}'.format(gh_issue.number, gh_issue.title))"
2820,"def define(self, key, value):
        """"""
        Defines the value for the inputted key by setting both its default and \
        value to the inputted value.
        
        :param      key   | <str>
                    value | <variant>
        """"""
        skey = nstr(key)
        self._defaults[skey] = value
        self[skey] = value"
2821,"def toXml(self, xparent):
        """"""
        Saves the settings for this dataset to the inputted parent xml.
        
        :param      xparent | <xml.etree.ElementTree.Element>
        """"""
        for key, value in self.items():
            elem = ElementTree.SubElement(xparent, 'entry')
            typ = type(elem).__name__

            elem.set('key', key)
            elem.set('type', typ)

            if typ in DataSet._xmlTypes:
                DataSet._xmlTypes[typ][0](elem, value)
            else:
                elem.set('value', nstr(value))"
2822,"def fromXml(cls, xparent):
        """"""
        Loads the settings for this dataset to the inputted parent xml.
        
        :param      xparent | <xml.etree.ElementTree.Element>
        """"""
        output = cls()

        for xentry in xparent:
            key = xentry.get('key')
            if not key:
                continue

            typ = xentry.get('type', 'str')

            if typ in DataSet._xmlTypes:
                value = DataSet._xmlTypes[typ][1](xentry)
            else:
                value = xentry.get('value', '')

            output.define(key, value)

        return output"
2823,"def registerXmlType(typ, encoder, decoder):
        """"""
        Registers a data type to encode/decode for xml settings.
        
        :param      typ     | <object>
                    encoder | <method>
                    decoder | <method>
        """"""
        DataSet._xmlTypes[nstr(typ)] = (encoder, decoder)"
2824,"def wrap_node(self, node, options):
        '''
        we have the option to construct nodes here, so we can use different
        queues for nodes without having to have different queue objects.
        '''
        job_kwargs = {
            'queue': options.get('queue', 'default'),
            'connection': options.get('connection', self.redis_connection),
            'timeout': options.get('timeout', None),
            'result_ttl': options.get('result_ttl', 500),
        }

        return job(**job_kwargs)(node)"
2825,"def writeMzml(specfile, msrunContainer, outputdir, spectrumIds=None,
              chromatogramIds=None, writeIndex=True):
    """""" #TODO: docstring

    :param specfile: #TODO docstring
    :param msrunContainer: #TODO docstring
    :param outputdir: #TODO docstring
    :param spectrumIds: #TODO docstring
    :param chromatogramIds: #TODO docstring
    """"""
    #TODO: maybe change to use aux.openSafeReplace
    outputFile = io.BytesIO()

    #TODO: perform check that specfile is present in msrunContainer and at least
    #   the metadatanode.
    metadataTree = msrunContainer.rmc[specfile]
    #Generate a list of spectrum ids that should be written to mzML
    if spectrumIds is None and specfile in msrunContainer.smic:
        keyTuple = [(int(key), key) for key in viewkeys(msrunContainer.smic[specfile])]
        spectrumIds = [key for _, key in sorted(keyTuple)]
    spectrumCounts = len(spectrumIds)
    #Generate a list of chromatogram ids that should be written to mzML
    if chromatogramIds is None and specfile in msrunContainer.cic:
        chromatogramIds = [cId for cId in viewkeys(msrunContainer.cic[specfile])]
    chromatogramCounts = len(chromatogramIds)

    spectrumIndexList = list()
    chromatogramIndexList = list()

    xmlFile = ETREE.xmlfile(outputFile, encoding='ISO-8859-1', buffered=False)
    xmlWriter = xmlFile.__enter__()
    xmlWriter.write_declaration()

    nsmap = {None: 'http://psi.hupo.org/ms/mzml',
             'xsi': 'http://www.w3.org/2001/XMLSchema-instance'
             }
    mzmlAttrib = {'{http://www.w3.org/2001/XMLSchema-instance}schemaLocation': \
                    'http://psi.hupo.org/ms/mzml http://psidev.info/files/ms/mzML/xsd/mzML1.1.0.xsd',
                  'version': '1.1.0', 'id': metadataTree.attrib['id']
                  }

    if writeIndex:
        xmlIndexedMzml = xmlWriter.element('indexedmzML', nsmap=nsmap)
        xmlIndexedMzml.__enter__()
        xmlWriter.write('\n')
    xmlMzml = xmlWriter.element('mzML', mzmlAttrib, nsmap=nsmap)
    xmlMzml.__enter__()
    xmlWriter.write('\n')

    for metadataNode in metadataTree.getchildren():
        if metadataNode.tag != 'run':
            xmlWriter.write(maspy.xml.recCopyElement(metadataNode),
                            pretty_print=True
                            )
        else:
            xmlRun = xmlWriter.element(metadataNode.tag, metadataNode.attrib)
            xmlRun.__enter__()
            xmlWriter.write('\n')
            for runChild in metadataNode.getchildren():
                if runChild.tag == 'spectrumList':
                    specDefaultProcRef = runChild.attrib['defaultDataProcessingRef']
                elif runChild.tag == 'chromatogramList':
                    chromDefaultProcRef = runChild.attrib['defaultDataProcessingRef']
                else:
                    #TODO: maybe recCopy?
                    xmlRun.append(runChild)

            #If any spectra should be written, generate the spectrumList Node.
            if spectrumCounts > 0:
                specListAttribs = {'count': str(spectrumCounts),
                                   'defaultDataProcessingRef': specDefaultProcRef
                                   }
                xmlSpectrumList = xmlWriter.element('spectrumList',
                                                    specListAttribs
                                                    )
                xmlSpectrumList.__enter__()
                xmlWriter.write('\n')

                for index, key in enumerate(spectrumIds):
                    smi = msrunContainer.smic[specfile][key]
                    sai = msrunContainer.saic[specfile][key]
                    #Store the spectrum element offset here
                    spectrumIndexList.append((outputFile.tell(),
                                              smi.attributes['id']
                                              ))

                    xmlSpectrum = xmlSpectrumFromSmi(index, smi, sai)
                    xmlWriter.write(xmlSpectrum, pretty_print=True)

                xmlSpectrumList.__exit__(None, None, None)
                xmlWriter.write('\n')

            #If any chromatograms should be written, generate the
            #chromatogramList Node.
            if chromatogramCounts > 0:
                chromListAttribs = {'count': str(chromatogramCounts),
                                    'defaultDataProcessingRef': chromDefaultProcRef
                                    }
                xmlChromatogramList = xmlWriter.element('chromatogramList',
                                                        chromListAttribs
                                                        )
                xmlChromatogramList.__enter__()
                xmlWriter.write('\n')
                for index, key in enumerate(chromatogramIds):
                    ci = msrunContainer.cic[specfile][key]
                    #Store the chromatogram element offset here
                    chromatogramIndexList.append((outputFile.tell(), ci.id))

                    xmlChromatogram = xmlChromatogramFromCi(index, ci)
                    xmlWriter.write(xmlChromatogram, pretty_print=True)
                xmlChromatogramList.__exit__(None, None, None)
                xmlWriter.write('\n')

            xmlRun.__exit__(None, None, None)
            xmlWriter.write('\n')

    #Close the mzml node
    xmlMzml.__exit__(None, None, None)
    #Optional: write the indexedMzml nodes and close the indexedMzml node
    if writeIndex:
        xmlWriter.write('\n')
        indexListOffset = outputFile.tell()
        _writeMzmlIndexList(xmlWriter, spectrumIndexList, chromatogramIndexList)
        _writeIndexListOffset(xmlWriter, indexListOffset)
        _writeMzmlChecksum(xmlWriter, outputFile)
        xmlIndexedMzml.__exit__(None, None, None)
    #Close the xml file
    xmlFile.__exit__(None, None, None)
    #Write the output mzML file
    filepath = aux.joinpath(outputdir, specfile+'.mzML')
    with open(filepath, 'wb') as openfile:
        openfile.write(outputFile.getvalue())"
2826,"def _writeMzmlIndexList(xmlWriter, spectrumIndexList, chromatogramIndexList):
    """""" #TODO: docstring

    :param xmlWriter: #TODO: docstring
    :param spectrumIndexList: #TODO: docstring
    :param chromatogramIndexList: #TODO: docstring
    """"""
    counts = 0
    if spectrumIndexList:
        counts += 1
    if chromatogramIndexList:
        counts += 1
    if counts == 0:
        return None
    #Create indexList node
    xmlIndexList = xmlWriter.element('indexList', {'count': str(counts)})
    xmlIndexList.__enter__()
    xmlWriter.write('\n')

    _writeIndexListElement(xmlWriter, 'spectrum', spectrumIndexList)
    _writeIndexListElement(xmlWriter, 'chromatogram', chromatogramIndexList)

    #Close indexList node
    xmlIndexList.__exit__(None, None, None)
    xmlWriter.write('\n')"
2827,"def _writeIndexListElement(xmlWriter, elementName, indexList):
    """""" #TODO: docstring

    :param xmlWriter: #TODO: docstring
    :param elementName: #TODO: docstring
    :param indexList: #TODO: docstring
    """"""
    if indexList:
        xmlIndex = xmlWriter.element('index', {'name': elementName})
        xmlIndex.__enter__()
        xmlWriter.write('\n')
        for offset, indexId in indexList:
            offsetElement = ETREE.Element('offset', {'idRef': indexId})
            offsetElement.text = str(offset)
            xmlWriter.write(offsetElement, pretty_print=True)
        xmlIndex.__exit__(None, None, None)
        xmlWriter.write('\n')"
2828,"def _writeMzmlChecksum(xmlWriter, outputFile):
    """""" #TODO: docstring

    :param xmlWriter: #TODO: docstring
    :param outputFile: #TODO: docstring
    """"""
    sha = hashlib.sha1(outputFile.getvalue())
    sha.update('<fileChecksum>')

    xmlChecksumElement = ETREE.Element('fileChecksum')
    xmlChecksumElement.text = sha.hexdigest()

    xmlWriter.write(xmlChecksumElement, pretty_print=True)"
2829,"def _writeIndexListOffset(xmlWriter, offset):
    """""" #TODO: docstring

    :param xmlWriter: #TODO: docstring
    :param offset: #TODO: docstring
    """"""
    xmlIndexListOffset = ETREE.Element('indexListOffset')
    xmlIndexListOffset.text = str(offset)

    xmlWriter.write(xmlIndexListOffset, pretty_print=True)"
2830,"def xmlGenScanList(scanList, scanListParams):
    """""" #TODO: docstring

    :params scanList: #TODO: docstring
    :params scanListParams: #TODO: docstring

    :returns: #TODO: docstring
    """"""
    numEntries = len(scanList)
    xmlScanList = ETREE.Element('scanList', {'count': str(numEntries)})
    maspy.xml.xmlAddParams(xmlScanList, scanListParams)
    for scan in scanList:
        #Note: no attributes supported
        xmlScan = ETREE.Element('scan', {})
        maspy.xml.xmlAddParams(xmlScan, scan['params'])

        #Generate the scanWindowList entry
        numScanWindows = len(scan['scanWindowList'])
        if numScanWindows > 0:
            xmlScanWindowList = ETREE.Element('scanWindowList',
                                              {'count': str(numScanWindows)}
                                              )
            for scanWindow in scan['scanWindowList']:
                xmlScanWindow = ETREE.Element('scanWindow')
                maspy.xml.xmlAddParams(xmlScanWindow, scanWindow)
                xmlScanWindowList.append(xmlScanWindow)
            xmlScan.append(xmlScanWindowList)

        xmlScanList.append(xmlScan)
    return xmlScanList"
2831,"def xmlGenPrecursorList(precursorList):
    """""" #TODO: docstring

    :params precursorList: #TODO: docstring

    :returns: #TODO: docstring
    """"""
    numEntries = len(precursorList)
    xmlPrecursorList = ETREE.Element('precursorList',
                                     {'count': str(numEntries)}
                                     )
    for precursor in precursorList:
        #Note: no attributes for external referencing supported
        precursorAttrib = {}
        if precursor['spectrumRef'] is not None:
            precursorAttrib.update({'spectrumRef': precursor['spectrumRef']})
        xmlPrecursor = ETREE.Element('precursor', precursorAttrib)

        #Add isolationWindow element
        if precursor['isolationWindow'] is not None:
            xmlIsolationWindow = ETREE.Element('isolationWindow')
            maspy.xml.xmlAddParams(xmlIsolationWindow,
                                   precursor['isolationWindow']
                                   )
            xmlPrecursor.append(xmlIsolationWindow)

        #Add selectedIonList element
        numSelectedIons = len(precursor['selectedIonList'])
        if numSelectedIons > 0:
            xmlSelectedIonList = ETREE.Element('selectedIonList',
                                               {'count': str(numSelectedIons)}
                                               )
            for selectedIon in precursor['selectedIonList']:
                xmlSelectedIon = ETREE.Element('selectedIon')
                maspy.xml.xmlAddParams(xmlSelectedIon, selectedIon)
                xmlSelectedIonList.append(xmlSelectedIon)
            xmlPrecursor.append(xmlSelectedIonList)

        #Add activation element
        xmlActivation = ETREE.Element('activation')
        maspy.xml.xmlAddParams(xmlActivation, precursor['activation'])
        xmlPrecursor.append(xmlActivation)


        xmlPrecursorList.append(xmlPrecursor)
    return xmlPrecursorList"
2832,"def xmlGenBinaryDataArrayList(binaryDataInfo, binaryDataDict,
                              compression='zlib', arrayTypes=None):
    """""" #TODO: docstring

    :params binaryDataInfo: #TODO: docstring
    :params binaryDataDict: #TODO: docstring
    :params compression: #TODO: docstring
    :params arrayTypes: #TODO: docstring

    :returns: #TODO: docstring
    """"""
    #Note: any other value for ""compression"" than ""zlib"" results in no
    #   compression
    #Note: Use arrayTypes parameter to specify the order of the arrays
    if arrayTypes is None:
        arrayTypes = [_ for _ in viewkeys(binaryDataInfo)]
    numEntries = len(binaryDataInfo)
    xmlBinaryDataArrayList = ETREE.Element('binaryDataArrayList',
                                           {'count': str(numEntries)}
                                           )
    for arrayType in arrayTypes:
        _, dataTypeParam = maspy.xml.findBinaryDataType(binaryDataInfo[arrayType]['params'])
        binaryData = binaryDataDict[arrayType]
        bitEncoding = '64' if binaryData.dtype.str == '<f8' else '32'
        if binaryData.size > 0:
            binaryData, arrayLength = maspy.xml.encodeBinaryData(binaryData,
                                                                 bitEncoding,
                                                                 compression
                                                                 )
        else:
            binaryData = ''
            arrayLength = 0

        # --- define binaryDataArray parameters --- #
        params = list()
        if bitEncoding == '64':
            params.append(('MS:1000523', None, None))
        else:
            params.append(('MS:1000521', None, None))
        if compression == 'zlib':
            params.append(('MS:1000574', None, None))
        else:
            params.append(('MS:1000576', None, None))
        mandatoryAccessions = ['MS:1000523', 'MS:1000521', 'MS:1000574',
                               'MS:1000576'
                               ]
        for param in binaryDataInfo[arrayType]['params']:
            if param[0] not in mandatoryAccessions:
                params.append(param)

        #Note: not all attributes supported
        binaryDataArrayAttrib = {'encodedLength': str(len(binaryData))}
        for attr in ['dataProcessingRef']:
            if binaryDataInfo[arrayType][attr] is not None:
                binaryDataArrayAttrib[attr] = binaryDataInfo[arrayType][attr]
        xmlBinaryDataArray = ETREE.Element('binaryDataArray',
                                           binaryDataArrayAttrib
                                           )
        maspy.xml.xmlAddParams(xmlBinaryDataArray, params)

        xmlBinary = ETREE.Element('binary')
        xmlBinary.text = binaryData
        xmlBinaryDataArray.append(xmlBinary)
        xmlBinaryDataArrayList.append(xmlBinaryDataArray)
    return xmlBinaryDataArrayList"
2833,"def xmlSpectrumFromSmi(index, smi, sai=None, compression='zlib'):
    """""" #TODO: docstring

    :param index: The zero-based, consecutive index of the spectrum in the
        SpectrumList. (mzML specification)
    :param smi: a SpectrumMetadataItem instance
    :param sai: a SpectrumArrayItem instance, if none is specified no
        binaryDataArrayList is written
    :param compression: #TODO: docstring

    :returns: #TODO: docstring
    """"""
    if sai is not None:
        arrayLength = [array.size for array in viewvalues(sai.arrays)]
        if len(set(arrayLength)) != 1:
            raise Exception('Unequal size for different array in sai.arrays')
        else:
            arrayLength = arrayLength[0]
    else:
        arrayLength = 0

    spectrumAttrib = {'index': str(index), 'id': smi.attributes['id'],
                      'defaultArrayLength': str(arrayLength)}

    xmlSpectrum = ETREE.Element('spectrum', **spectrumAttrib)
    maspy.xml.xmlAddParams(xmlSpectrum, smi.params)
    #Add the scanList
    if len(smi.scanList) > 0:
        xmlSpectrum.append(xmlGenScanList(smi.scanList, smi.scanListParams))
    if len(smi.precursorList) > 0:
        xmlSpectrum.append(xmlGenPrecursorList(smi.precursorList))
    if len(smi.productList) > 0:
        xmlSpectrum.append(xmlGenProductList(smi.productList))
    if sai is not None:
        xmlSpectrum.append(xmlGenBinaryDataArrayList(sai.arrayInfo,
                                                     sai.arrays,
                                                     compression=compression
                                                     ))
    return xmlSpectrum"
2834,"def xmlChromatogramFromCi(index, ci, compression='zlib'):
    """""" #TODO: docstring
    :param index: #TODO: docstring
    :param ci: #TODO: docstring
    :param compression: #TODO: docstring

    :returns: #TODO: docstring
    """"""
    arrayLength = [array.size for array in viewvalues(ci.arrays)]
    if len(set(arrayLength)) != 1:
        raise Exception('Unequal size for different array in sai.arrays')
    else:
        arrayLength = arrayLength[0]

    chromatogramAttrib = {'index': str(index), 'id': ci.id,
                          'defaultArrayLength': str(arrayLength)}
    if 'dataProcessingRef' in ci.attrib:
        chromatogramAttrib.update({'dataProcessingRef': dataProcessingRef})

    xmlChromatogram = ETREE.Element('chromatogram', **chromatogramAttrib)
    maspy.xml.xmlAddParams(xmlChromatogram, ci.params)
    #TODO: add appropriate functions for precursor and product
    if ci.product is not None:
        raise NotImplementedError()
    if ci.precursor is not None:
        raise NotImplementedError()

    #Sort the array keys, that 'rt' is always the first, necessary for example
    #   for the software ""SeeMS"" to properly display chromatograms.
    arrayTypes = set(ci.arrayInfo)
    if 'rt' in arrayTypes:
        arrayTypes.remove('rt')
        arrayTypes = ['rt'] + list(arrayTypes)
    else:
        arrayTypes = list(arrayTypes)

    xmlChromatogram.append(xmlGenBinaryDataArrayList(ci.arrayInfo,
                                                     ci.arrays,
                                                     compression=compression,
                                                     arrayTypes=arrayTypes
                                                     )
                           )
    return xmlChromatogram"
2835,"def execute(self, query, until_zero=False):
        """"""
        Execute a query
        :param query: query to execute
        :param until_zero: should query be called until returns 0
        :return:
        """"""

        if self._conn.closed:
            self._conn = psycopg2.connect(self._connection_string, connection_factory=pgpm.lib.utils.db.MegaConnection)
        cur = self._conn.cursor()

        # be cautious, dangerous thing
        self._conn.autocommit = True

        # Check if DB is pgpm enabled
        if not pgpm.lib.utils.db.SqlScriptsHelper.schema_exists(cur, self._pgpm_schema_name):
            self._logger.error('Can\'t deploy schemas to DB where pgpm was not installed. '
                               'First install pgpm by running pgpm install')
            self._conn.close()
            sys.exit(1)

        # check installed version of _pgpm schema.
        pgpm_v_db_tuple = pgpm.lib.utils.db.SqlScriptsHelper.get_pgpm_db_version(cur, self._pgpm_schema_name)
        pgpm_v_db = distutils.version.StrictVersion(""."".join(pgpm_v_db_tuple))
        pgpm_v_script = distutils.version.StrictVersion(pgpm.lib.version.__version__)
        if pgpm_v_script > pgpm_v_db:
            self._logger.error('{0} schema version is outdated. Please run pgpm install --upgrade first.'
                               .format(self._pgpm_schema_name))
            self._conn.close()
            sys.exit(1)
        elif pgpm_v_script < pgpm_v_db:
            self._logger.error('Deployment script\'s version is lower than the version of {0} schema '
                               'installed in DB. Update pgpm script first.'.format(self._pgpm_schema_name))
            self._conn.close()
            sys.exit(1)

        # Executing query
        if until_zero:
            self._logger.debug('Running query {0} until it returns 0 (but not more than 10000 times'
                               .format(query))
            proc_return_value = None
            counter = 0
            while proc_return_value != 0:
                cur.execute(query)
                proc_return_value = cur.fetchone()[0]
                counter += 1
                if counter > 9999:
                    break
        else:
            self._logger.debug('Running query {0}'.format(query))
            cur.execute(query)

        # Commit transaction
        self._conn.commit()

        self._conn.close()

        return 0"
2836,"def install_pgpm_to_db(self, user_roles, upgrade=False):
        """"""
        Installs package manager

        """"""
        if self._conn.closed:
            self._conn = psycopg2.connect(self._connection_string, connection_factory=pgpm.lib.utils.db.MegaConnection)

        cur = self._conn.cursor()

        # get pgpm functions
        functions_dict = pgpm.lib.utils.misc.collect_scripts_from_sources('lib/db_scripts/functions', False, '.', True,
                                                                        self._logger)
        triggers_dict = pgpm.lib.utils.misc.collect_scripts_from_sources('lib/db_scripts/triggers', False, '.', True,
                                                                        self._logger)

        # get current user
        cur.execute(pgpm.lib.utils.db.SqlScriptsHelper.current_user_sql)
        current_user = cur.fetchone()[0]

        # check if current user is a super user
        cur.execute(pgpm.lib.utils.db.SqlScriptsHelper.is_superuser_sql)
        is_cur_superuser = cur.fetchone()[0]
        if not is_cur_superuser:
            self._logger.debug('User {0} is not a superuser. It is recommended that you connect as superuser '
                               'when installing pgpm as some operation might need superuser rights'
                               .format(current_user))

        # Create schema if it doesn't exist
        if pgpm.lib.utils.db.SqlScriptsHelper.schema_exists(cur, self._pgpm_schema_name):

            # Executing pgpm trigger functions
            if len(triggers_dict) > 0:
                self._logger.info('Running functions definitions scripts')
                self._logger.debug(triggers_dict)
                pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, self._pgpm_schema_name)
                for key, value in triggers_dict.items():
                    cur.execute(value)
                self._logger.debug('Functions loaded to schema {0}'.format(self._pgpm_schema_name))
            else:
                self._logger.debug('No function scripts to deploy')

            # check installed version of _pgpm schema.
            pgpm_v_db_tuple = pgpm.lib.utils.db.SqlScriptsHelper.get_pgpm_db_version(cur, self._pgpm_schema_name)
            pgpm_v_db = distutils.version.StrictVersion(""."".join(pgpm_v_db_tuple))
            pgpm_v_script = distutils.version.StrictVersion(pgpm.lib.version.__version__)
            if pgpm_v_script > pgpm_v_db:
                if upgrade:
                    self._migrate_pgpm_version(cur, pgpm_v_db, pgpm_v_script, True)
                else:
                    self._migrate_pgpm_version(cur, pgpm_v_db, pgpm_v_script, False)
            elif pgpm_v_script < pgpm_v_db:
                self._logger.error('Deployment script\'s version is lower than the version of {0} schema '
                                   'installed in DB. Update pgpm script first.'.format(self._pgpm_schema_name))
                self._conn.close()
                sys.exit(1)
            else:
                self._logger.error('Can\'t install pgpm as schema {0} already exists'.format(self._pgpm_schema_name))
                self._conn.close()
                sys.exit(1)

            # Executing pgpm functions
            if len(functions_dict) > 0:
                self._logger.info('Running functions definitions scripts')
                self._logger.debug(functions_dict)
                pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, self._pgpm_schema_name)
                for key, value in functions_dict.items():
                    if value:
                        cur.execute(value)
                self._logger.debug('Functions loaded to schema {0}'.format(self._pgpm_schema_name))
            else:
                self._logger.debug('No function scripts to deploy')

        else:
            # Prepare and execute preamble
            deployment_script_preamble = pkgutil.get_data(self._main_module_name, 'lib/db_scripts/deploy_prepare_config.sql')
            self._logger.info('Executing a preamble to install statement')
            cur.execute(deployment_script_preamble)

            # Python 3.x doesn't have format for byte strings so we have to convert
            install_script = pkgutil.get_data(self._main_module_name, 'lib/db_scripts/install.tmpl.sql').decode('utf-8')
            self._logger.info('Installing package manager')
            cur.execute(install_script.format(schema_name=self._pgpm_schema_name))
            migration_files_list = sorted(pkg_resources.resource_listdir(self._main_module_name, 'lib/db_scripts/migrations/'),
                                          key=lambda filename: distutils.version.StrictVersion(filename.split('-')[0]))

            # Executing pgpm trigger functions
            if len(triggers_dict) > 0:
                self._logger.info('Running functions definitions scripts')
                self._logger.debug(triggers_dict)
                pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, self._pgpm_schema_name)
                for key, value in triggers_dict.items():
                    cur.execute(value)
                self._logger.debug('Functions loaded to schema {0}'.format(self._pgpm_schema_name))
            else:
                self._logger.debug('No function scripts to deploy')

            # Executing migration scripts after trigger functions
            # as they may contain trigger definitions that use functions from pgpm
            for file_info in migration_files_list:
                # Python 3.x doesn't have format for byte strings so we have to convert
                migration_script = pkg_resources.resource_string(self._main_module_name, 'lib/db_scripts/migrations/{0}'.format(file_info))\
                    .decode('utf-8').format(schema_name=self._pgpm_schema_name)
                self._logger.debug('Running version upgrade script {0}'.format(file_info))
                self._logger.debug(migration_script)
                cur.execute(migration_script)

            # Executing pgpm functions
            if len(functions_dict) > 0:
                self._logger.info('Running functions definitions scripts')
                self._logger.debug(functions_dict)
                pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, self._pgpm_schema_name)
                for key, value in functions_dict.items():
                    cur.execute(value)
                self._logger.debug('Functions loaded to schema {0}'.format(self._pgpm_schema_name))
            else:
                self._logger.debug('No function scripts to deploy')

            # call this function to put in a migration log that there was a migration to the last version
            # it's a hack basically due to the fact in 0.0.7-0.1.3 migration script migration info was manually inserted
            # to avoid differences we add migration info to the last version (although it wasn't really a migration)
            # to be refactored
            cur.callproc('_add_migration_info', ['0.0.7', pgpm.lib.version.__version__])

        # check if users of pgpm are specified
        pgpm.lib.utils.db.SqlScriptsHelper.revoke_all(cur, self._pgpm_schema_name, 'public')
        if not user_roles:
            self._logger.debug('No user was specified to have permisions on _pgpm schema. '
                               'This means only user that installed _pgpm will be able to deploy. '
                               'We recommend adding more users.')
        else:
            # set default privilages to users
            pgpm.lib.utils.db.SqlScriptsHelper.grant_default_usage_install_privileges(
                cur, self._pgpm_schema_name, ', '.join(user_roles))
            pgpm.lib.utils.db.SqlScriptsHelper.grant_usage_install_privileges(
                cur, self._pgpm_schema_name, ', '.join(user_roles))

        pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, self._pgpm_schema_name)
        cur.callproc('_upsert_package_info',
                     [self._pgpm_schema_name, self._pgpm_schema_subclass,
                      self._pgpm_version.major, self._pgpm_version.minor, self._pgpm_version.patch,
                      self._pgpm_version.pre, self._pgpm_version.metadata,
                      'Package manager for Postgres', 'MIT'])
        # Commit transaction
        self._conn.commit()

        self._conn.close()

        return 0"
2837,"def uninstall_pgpm_from_db(self):
        """"""
        Removes pgpm from db and all related metadata (_pgpm schema). Install packages are left as they are
        :return: 0 if successful and error otherwise
        """"""
        drop_schema_cascade_script = 'DROP SCHEMA {schema_name} CASCADE;'

        if self._conn.closed:
            self._conn = psycopg2.connect(self._connection_string, connection_factory=pgpm.lib.utils.db.MegaConnection)

        cur = self._conn.cursor()

        # get current user
        cur.execute(pgpm.lib.utils.db.SqlScriptsHelper.current_user_sql)
        current_user = cur.fetchone()[0]

        # check if current user is a super user
        cur.execute(pgpm.lib.utils.db.SqlScriptsHelper.is_superuser_sql)
        is_cur_superuser = cur.fetchone()[0]
        if not is_cur_superuser:
            self._logger.debug('User {0} is not a superuser. Only superuser can remove pgpm'
                               .format(current_user))
            sys.exit(1)

        self._logger.debug('Removing pgpm from DB by dropping schema {0}'.format(self._pgpm_schema_name))
        cur.execute(drop_schema_cascade_script.format(schema_name=self._pgpm_schema_name))

        # Commit transaction
        self._conn.commit()

        self._conn.close()

        return 0"
2838,"def _migrate_pgpm_version(self, cur, version_pgpm_db, version_pgpm_script,  migrate_or_leave):
        """"""
        Enact migration script from one version of pgpm to another (newer)
        :param cur:
        :param migrate_or_leave: True if migrating, False if exiting
        :return:
        """"""
        migrations_file_re = r'^(.*)-(.*).tmpl.sql$'
        migration_files_list = sorted(pkg_resources.resource_listdir(self._main_module_name, 'lib/db_scripts/migrations/'),
                                      key=lambda filename: distutils.version.StrictVersion(filename.split('-')[0]))
        for file_info in migration_files_list:
            versions_list = re.compile(migrations_file_re, flags=re.IGNORECASE).findall(file_info)
            version_a = distutils.version.StrictVersion(versions_list[0][0])
            version_b = distutils.version.StrictVersion(versions_list[0][1])
            if version_pgpm_script >= version_a and version_b > version_pgpm_db:
                # Python 3.x doesn't have format for byte strings so we have to convert
                migration_script = pkg_resources.resource_string(self._main_module_name, 'lib/db_scripts/migrations/{0}'.format(file_info))\
                    .decode('utf-8').format(schema_name=self._pgpm_schema_name)
                if migrate_or_leave:
                    self._logger.debug('Running version upgrade script {0}'.format(file_info))
                    self._logger.debug(migration_script)
                    cur.execute(migration_script)
                    self._conn.commit()
                    pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, self._pgpm_schema_name)
                    cur.callproc('_add_migration_info', [versions_list[0][0], versions_list[0][1]])
                    self._conn.commit()
                    self._logger.debug('Successfully finished running version upgrade script {0}'.format(file_info))

        if not migrate_or_leave:
            self._logger.error('{0} schema version is outdated. Please run pgpm install --upgrade first.'
                               .format(self._pgpm_schema_name))
            self._conn.close()
            sys.exit(1)"
2839,"def save(self, *args, **kwargs):
        if self.pk is None:
            if hasattr(self, 'product'):
                if not self.description:
                    self.description = self.product
                self.price_recommended = self.product.price_base
            elif hasattr(self, 'line_order'):
                if not self.description:
                    self.description = self.line_order.product
                self.price_recommended = self.line_order.price_base

        if hasattr(self, 'tax') and hasattr(self, 'type_tax'):
            self.tax = self.type_tax.tax

        if hasattr(self, 'product'):
            self.tax_label = self.product.product.tax.name
            if self.product.code:
                self.code = self.product.code
            else:
                self.code = self.product.product.code

        """"""
        si al guardar una linea asociada a un documento bloqueado (lock==True), duplicar el documento en una nueva versión
        """"""
        self.update_total(force_save=False)
        if 'force_save' in kwargs:
            kwargs.pop('force_save')
        return super(GenLineProduct, self).save(*args, **kwargs)"
2840,"def create_document_from_another(pk, list_lines,
                                     MODEL_SOURCE, MODEL_FINAL, MODEL_LINE_SOURCE, MODEL_LINE_FINAL,
                                     url_reverse, related_line, related_object,
                                     msg_error_relation, msg_error_not_found, unique):
        """"""
        pk: pk del documento origen
        list_lines: listado de pk de lineas de origen
        MODEL_SOURCE: modelo del documento origen
        MODEL_FINAL: model del documento final
        MODEL_LINE_SOURCE: modelo de la linea origen
        MODEL_LINE_FINAL: modelo de la linea final
        url_reverse: url del destino
        related_line: campo del modelo linea final en el que irá asignada la linea origen
        related_object: campo del modelo linea final en el que irá asignado el objeto final
        msg_error_relation: Mensaje de error indicando que las lineas ya están relacionadas
        msg_error_not_found: Mensaje de error indicando que no se encuentra el objeto origen
        unique: (True/False) Indica si puede haber más de una linea asociada a otras lineas
        """"""
        context = {}
        obj_src = MODEL_SOURCE.objects.filter(pk=pk).first()
        if list_lines and obj_src:
            # parse to int
            list_lines = [int(x) for x in list_lines]
            # list of lines objects
            if unique:
                create = not MODEL_LINE_FINAL.objects.filter(**{""{}__pk__in"".format(related_line): list_lines}).exists()
            else:
                create = True

            """"""
            si debiendo ser filas unicas no las encuentra en el modelo final, se crea el nuevo documento
            """"""
            if create:
                with transaction.atomic():
                    obj_final = MODEL_FINAL()
                    obj_final.customer = obj_src.customer
                    obj_final.date = datetime.datetime.now()
                    obj_final.billing_series = obj_src.billing_series

                    if isinstance(obj_final, SalesOrder):
                        obj_final.budget = obj_src

                    obj_final.save()

                    for lb_pk in list_lines:
                        line_src = MODEL_LINE_SOURCE.objects.filter(pk=lb_pk).first()
                        if line_src:
                            line_final = MODEL_LINE_FINAL(**{""{}_id"".format(related_object): obj_final.pk, related_line: line_src})
                            # line_final.order = obj_final
                            # line_final.line_budget = line_src
                            src_list_fields = [f.name for f in line_src._meta.get_fields()]
                            dst_list_fields = [f.name for f in line_final._meta.get_fields()]
                            if 'product' in src_list_fields and 'product' in dst_list_fields:
                                line_final.product = line_src.product
                            if 'description' in src_list_fields and 'description' in dst_list_fields:
                                line_final.description = line_src.description
                            if 'code' in src_list_fields and 'code' in dst_list_fields:
                                line_final.code = line_src.code
                            # if hasattr(line_src, 'line_order') and hasattr(line_final, 'line_order'):
                            if 'line_order' in src_list_fields and 'line_order' in dst_list_fields:
                                line_final.line_order = line_src.line_order
                            line_final.quantity = line_src.quantity
                            line_final.price_base = line_src.price_base
                            # if hasattr(line_src, 'price_recommended') and hasattr(line_final, 'price_recommended'):
                            if 'price_recommended' in src_list_fields and 'price_recommended' in dst_list_fields:
                                line_final.price_recommended = line_src.price_recommended
                            line_final.tax = line_src.tax
                            # line_final.type_tax = line_src.type_tax
                            line_final.discount = line_src.discount
                            if 'removed' in src_list_fields and 'removed' in dst_list_fields:
                                line_final.removed = line_src.removed
                            line_final.save()

                            if hasattr(line_src, 'line_basket_option_sales') and line_src.line_basket_option_sales.exists():
                                for opt_src in line_src.line_basket_option_sales.all():
                                    opt_dst = SalesLineOrderOption()
                                    opt_dst.line_order = line_final
                                    opt_dst.product_option = opt_src.product_option
                                    opt_dst.product_final = opt_src.product_final
                                    opt_dst.quantity = opt_src.quantity
                                    opt_dst.save()

                    # bloqueamos el documento origen
                    obj_src.lock = True
                    obj_src.save()

                    # context['url'] = reverse('ordersaless_details', kwargs={'pk': order.pk})
                    context['url'] = ""{}#/{}"".format(reverse(url_reverse), obj_final.pk)
                    context['obj_final'] = obj_final
            else:
                # _(""Hay lineas asignadas a pedidos"")
                context['error'] = msg_error_relation
        else:
            # _('Budget not found')
            context['error'] = msg_error_not_found

        return context"
2841,"def create_albaran_automatic(pk, list_lines):
        """"""
        creamos de forma automatica el albaran
        """"""
        line_bd = SalesLineAlbaran.objects.filter(line_order__pk__in=list_lines).values_list('line_order__pk')
        if line_bd.count() == 0 or len(list_lines) != len(line_bd[0]):
            # solo aquellas lineas de pedidos que no estan ya albarandas
            if line_bd.count() != 0:
                for x in line_bd[0]:
                    list_lines.pop(list_lines.index(x))

            GenLineProduct.create_albaran_from_order(pk, list_lines)"
2842,"def create_invoice_from_albaran(pk, list_lines):
        """"""
        la pk y list_lines son de albaranes, necesitamos la info de las lineas de pedidos
        """"""
        context = {}
        if list_lines:
            new_list_lines = [x[0] for x in SalesLineAlbaran.objects.values_list('line_order__pk').filter(
                pk__in=[int(x) for x in list_lines]
            ).exclude(invoiced=True)]
            if new_list_lines:
                lo = SalesLineOrder.objects.values_list('order__pk').filter(pk__in=new_list_lines)[:1]
                if lo and lo[0] and lo[0][0]:
                    new_pk = lo[0][0]
                    context = GenLineProduct.create_invoice_from_order(new_pk, new_list_lines)
                    if 'error' not in context or not context['error']:
                        SalesLineAlbaran.objects.filter(
                            pk__in=[int(x) for x in list_lines]
                        ).exclude(invoiced=True).update(invoiced=True)
                    return context
                else:
                    error = _('Pedido no encontrado')
            else:
                error = _('Lineas no relacionadas con pedido')
        else:
            error = _('Lineas no seleccionadas')
        context['error'] = error
        return context"
2843,"def create_invoice_from_ticket(pk, list_lines):
        """"""
        la pk y list_lines son de ticket, necesitamos la info de las lineas de pedidos
        """"""
        context = {}
        if list_lines:
            new_list_lines = [x[0] for x in SalesLineTicket.objects.values_list('line_order__pk').filter(pk__in=[int(x) for x in list_lines])]
            if new_list_lines:
                lo = SalesLineOrder.objects.values_list('order__pk').filter(pk__in=new_list_lines)[:1]
                if lo and lo[0] and lo[0][0]:
                    new_pk = lo[0][0]
                    return GenLineProduct.create_invoice_from_order(new_pk, new_list_lines)
                else:
                    error = _('Pedido no encontrado')
            else:
                error = _('Lineas no relacionadas con pedido')
        else:
            error = _('Lineas no seleccionadas')
        context['error'] = error
        return context"
2844,"def set_options(self, options):
        """"""
        options = [{
            'product_option': instance of ProductFinalOption,
            'product_final': instance of ProductFinal,
            'quantity': Float
        }, ]
        """"""
        with transaction.atomic():
            for option in options:
                opt = self.line_basket_option_sales.filter(
                    product_option=option['product_option']
                ).first()
                if opt:  # edit
                    change = False
                    if opt.quantity != option['quantity']:
                        opt.quantity = option['quantity']
                        change = True
                    if opt.product_final != option['product_final']:
                        opt.product_final = option['product_final']
                        change = True
                    if change:
                        opt.save()
                else:  # new
                    opt = SalesLineBasketOption()
                    # raise Exception(self.pk, self.__dict__, self)
                    # raise Exception(self.pk)
                    opt.line_budget = SalesLineBasket.objects.get(pk=self.pk)
                    opt.product_option = option['product_option']
                    opt.product_final = option['product_final']
                    opt.quantity = option['quantity']
                    opt.save()"
2845,"def findmodules(path, recurse=False):
    """"""
    Looks up the modules for the given path and returns a list of the
    packages.  If the recurse flag is set to True, then it will look
    through the package recursively.
    
    :param      path    | <str>
                recurse | <bool>
    
    :return     ([<str>, ..] modules, [<str>, ..] paths)
    """"""
    output = set()
    roots = set()
    for root, folders, files in os.walk(path):
        # add packages
        for folder in folders:
            pkgpath = os.path.join(root, folder, '__init__.py')
            if os.path.exists(pkgpath):
                output.add(packageFromPath(pkgpath))

        # add modules
        rootpth = packageRootPath(root)
        rootpkg = packageFromPath(root)
        roots.add(rootpth)
        for file_ in files:
            name, ext = os.path.splitext(file_)
            if ext not in ('.py', '.pyo', '.pyc'):
                continue

            if name in ('__init__', '__plugins__'):
                continue

            if rootpkg:
                output.add(rootpkg + '.' + name)
            else:
                output.add(name)

        if not recurse:
            break

    return list(output), list(roots)"
2846,"def importfile(filename):
    """"""
    Imports a module specifically from a file.
    
    :param      filename | <str>
    
    :return     <module> || None
    """"""
    pkg = packageFromPath(filename, includeModule=True)
    root = packageRootPath(filename)

    if root not in sys.path:
        sys.path.insert(0, root)

    __import__(pkg)
    return sys.modules[pkg]"
2847,"def importmodules(package_or_toc, ignore=None, recurse=False, silent=None):
    """"""
    Imports all the sub-modules of a package, a useful technique for developing
    plugins.  By default, this method will walk the directory structure looking
    for submodules and packages.  You can also specify a __toc__ attribute
    on the package to define the sub-modules that you want to import.
    
    :param      package_or_toc  | <package> || <str> filename
                ignore          | [<str>, ..] || None
                recurse         | <bool>
                silent          | <bool>
    
    :usage      |>>> import projex
                |>>> import projex.docgen
                |>>> projex.importmodules(projex.docgen)
                |[<projex.docgen.commands>, <projex.docgen.default_config>, ..]
    
    :return     [<module> || <package>, ..]
    """"""
    if package_or_toc in __IMPORTED:
        return

    __IMPORTED.add(package_or_toc)

    if silent is None:
        silent = os.environ.get('PROJEX_LOG_IMPORTS', 'False').lower() != 'true'

    toc = []
    output = []
    if ignore is None:
        ignore = []

    # import from a set toc file
    if type(package_or_toc) in (str, unicode):
        # import a toc file
        if os.path.isfile(package_or_toc):
            f = open(package_or_toc, 'r')
            toc = f.readlines()
            f.close()

        # import from a directory
        elif os.path.isdir(package_or_toc):
            toc, paths = findmodules(package_or_toc, recurse=recurse)
            for path in paths:
                if path in sys.path:
                    sys.path.remove(path)

                sys.path.insert(0, path)

        # import a module by string
        else:
            use_sub_modules = False
            if package_or_toc.endswith('.*'):
                use_sub_modules = True
                package_or_toc = package_or_toc[:-2]

            try:
                __import__(package_or_toc)
                module = sys.modules[package_or_toc]
            except ImportError as err:
                if not silent:
                    logger.error('Unable to import module: %s', package_or_toc)
                    logger.debug(traceback.print_exc())
                return []
            except KeyError:
                if not silent:
                    logger.error('Unable to find module: %s', package_or_toc)
                return []

            if use_sub_modules:
                base = os.path.dirname(module.__file__)
                for path in os.listdir(base):
                    if path.endswith('.py') and path != '__init__.py':
                        importmodules(package_or_toc + '.' + path.replace('.py', ''))
                    elif os.path.isdir(os.path.join(base, path)):
                        importmodules(package_or_toc + '.' + path)
            else:
                return importmodules(module)

    # import from a given package
    else:
        toc = getattr(package_or_toc, '__toc__', [])

        if not toc:
            toc = []
            recurse = getattr(package_or_toc, '__recurse__', False)
            try:
                paths = package_or_toc.__path__
            except AttributeError:
                try:
                    paths = [os.path.dirname(package_or_toc.__file__)]
                except AttributeError:
                    paths = []

            for path in paths:
                data = findmodules(path, recurse=recurse)
                toc += data[0]
                for sub_path in data[1]:
                    if sub_path in sys.path:
                        sys.path.remove(sub_path)

                    sys.path.insert(0, sub_path)

            setattr(package_or_toc, '__toc__', toc)

    # import using standard means (successful for when dealing with 
    for modname in sorted(toc):
        # check against a callable ignore method
        if callable(ignore) and ignore(modname):
            continue

        elif type(modname) in (list, tuple) and modname not in ignore:
            continue

        # ignore preset options
        if modname.endswith('__init__'):
            continue
        elif modname.endswith('__plugins__'):
            continue

        try:
            output.append(sys.modules[modname])
            continue
        except KeyError:
            pass

        if not silent:
            logger.debug('Importing: %s' % modname)
        try:
            mod = importlib.import_module(modname)
            sys.modules[modname] = mod
            output.append(mod)
        except ImportError, err:
            if not silent:
                logger.error('Error importing module: %s', modname)
                logger.debug(traceback.print_exc())

    return output"
2848,"def importobject(module_name, object_name):
    """"""
    Imports the object with the given name from the inputted module.
    
    :param      module_name | <str>
                object_name | <str>
    
    :usage      |>>> import projex
                |>>> modname = 'projex.envmanager'
                |>>> attr = 'EnvManager'
                |>>> EnvManager = projex.importobject(modname, attr)
    
    :return     <object> || None
    """"""
    if module_name not in sys.modules:
        try:
            __import__(module_name)
        except ImportError:
            logger.debug(traceback.print_exc())
            logger.error('Could not import module: %s', module_name)
            return None

    module = sys.modules.get(module_name)
    if not module:
        logger.warning('No module %s found.' % module_name)
        return None

    if not hasattr(module, object_name):
        logger.warning('No object %s in %s.' % (object_name, module_name))
        return None

    return getattr(module, object_name)"
2849,"def packageRootPath(path):
    """"""
    Returns the root file path that defines a Python package from the inputted
    path.
    
    :param      path | <str>
    
    :return     <str>
    """"""
    path = nstr(path)
    if os.path.isfile(path):
        path = os.path.dirname(path)

    parts = os.path.normpath(path).split(os.path.sep)
    package_parts = []

    for i in range(len(parts), 0, -1):
        filename = os.path.sep.join(parts[:i] + ['__init__.py'])

        if not os.path.isfile(filename):
            break

        package_parts.insert(0, parts[i - 1])

    if not package_parts:
        return path
    return os.path.abspath(os.path.sep.join(parts[:-len(package_parts)]))"
2850,"def packageFromPath(path, includeModule=False):
    """"""
    Determines the python package path based on the inputted path.
    
    :param      path | <str>
    
    :return     <str>
    """"""
    path = nstr(path)
    module = ''
    if os.path.isfile(path):
        path, fname = os.path.split(path)
        if fname.endswith('.py') and fname != '__init__.py':
            module = fname.split('.')[0]

    parts = os.path.normpath(path).split(os.path.sep)
    package_parts = []

    for i in range(len(parts), 0, -1):
        filename = os.path.sep.join(parts[:i] + ['__init__.py'])

        if not os.path.isfile(filename):
            break

        package_parts.insert(0, parts[i - 1])

    if includeModule and module:
        package_parts.append(module)

    return '.'.join(package_parts)"
2851,"def website(app=None, mode='home', subcontext='UserGuide'):
    """"""
    Returns the website location for projex software.
    
    :param      app  | <str> || None
                mode | <str> (home, docs, blog, dev)
    
    :return     <str>
    """"""
    base_url = WEBSITES.get(mode, '')

    if app and base_url:
        opts = {'app': app, 'base_url': base_url}
        base_url = SUBCONTEXT_MAP.get((mode, subcontext), base_url)
        base_url %= opts

    return base_url"
2852,"def _check_values(in_values):
        """""" Check if values need to be converted before they get mogrify'd
        """"""
        out_values = []
        for value in in_values:
            # if isinstance(value, (dict, list)):
            #     out_values.append(json.dumps(value))
            # else:
            out_values.append(value)

        return tuple(out_values)"
2853,"def insert(self, table, data_list, return_cols='id'):
        """"""
        Create a bulk insert statement which is much faster (~2x in tests with 10k & 100k rows and n cols)
        for inserting data then executemany()

        TODO: Is there a limit of length the query can be? If so handle it.
        """"""
        data_list = copy.deepcopy(data_list)  # Create deepcopy so the original list does not get modified
        # Make sure that `data_list` is a list
        if not isinstance(data_list, list):
            data_list = [data_list]
        # Make sure data_list has content
        if len(data_list) == 0:
            # No need to continue
            return []

        # Data in the list must be dicts (just check the first one)
        if not isinstance(data_list[0], dict):
            logger.critical(""Data must be a list of dicts"")
            # Do not return here, let the exception handle the error that will be thrown when the query runs

        # Make sure return_cols is a list
        if return_cols is None or len(return_cols) == 0 or return_cols[0] is None:
            return_cols = ''
        elif not isinstance(return_cols, list):
            return_cols = [return_cols]

        if len(return_cols) > 0:
            return_cols = 'RETURNING ' + ','.join(return_cols)

        try:
            with self.getcursor() as cur:
                query = ""INSERT INTO {table} ({fields}) VALUES {values} {return_cols}""\
                        .format(table=table,
                                fields='""{0}""'.format('"", ""'.join(data_list[0].keys())),
                                values=','.join(['%s'] * len(data_list)),
                                return_cols=return_cols,
                                )
                values = []
                for row in [tuple(v.values()) for v in data_list]:
                    values.append(_check_values(row))

                query = cur.mogrify(query, values)
                cur.execute(query)

                try:
                    return cur.fetchall()
                except Exception:
                    return None

        except Exception as e:
            logger.exception(""Error inserting data"")
            logger.debug(""Error inserting data: {data}"".format(data=data_list))
            raise e.with_traceback(sys.exc_info()[2])"
2854,"def upsert(self, table, data_list, on_conflict_fields, on_conflict_action='update',
               update_fields=None, return_cols='id'):
        """"""
        Create a bulk upsert statement which is much faster (~6x in tests with 10k & 100k rows and n cols)
        for upserting data then executemany()

        TODO: Is there a limit of length the query can be? If so handle it.
        """"""
        data_list = copy.deepcopy(data_list)  # Create deepcopy so the original list does not get modified
        # Make sure that `data_list` is a list
        if not isinstance(data_list, list):
            data_list = [data_list]
        # Make sure data_list has content
        if len(data_list) == 0:
            # No need to continue
            return []
        # Data in the list must be dicts (just check the first one)
        if not isinstance(data_list[0], dict):
            logger.critical(""Data must be a list of dicts"")
            # TODO: raise some error here rather then returning None
            return None

        # Make sure on_conflict_fields is a list
        if not isinstance(on_conflict_fields, list):
            on_conflict_fields = [on_conflict_fields]
        # Make sure on_conflict_fields has data
        if len(on_conflict_fields) == 0 or on_conflict_fields[0] is None:
            # No need to continue
            logger.critical(""Must pass in `on_conflict_fields` argument"")
            # TODO: raise some error here rather then returning None
            return None

        # Make sure return_cols is a list
        if return_cols is None or len(return_cols) == 0 or return_cols[0] is None:
            return_cols = ''
        elif not isinstance(return_cols, list):
            return_cols = [return_cols]

        if len(return_cols) > 0:
            return_cols = 'RETURNING ' + ','.join(return_cols)

        # Make sure update_fields is a list/valid
        if on_conflict_action == 'update':
            if not isinstance(update_fields, list):
                update_fields = [update_fields]
            # If noting is passed in, set `update_fields` to all (data_list-on_conflict_fields)
            if len(update_fields) == 0 or update_fields[0] is None:
                update_fields = list(set(data_list[0].keys()) - set(on_conflict_fields))
                # If update_fields is empty here that could only mean that all fields are set as conflict_fields
                if len(update_fields) == 0:
                    logger.critical(""Not all the fields can be `on_conflict_fields` when doing an update"")
                    # TODO: raise some error here rather then returning None
                    return None

            # If everything is good to go with the update fields
            fields_update_tmp = []
            for key in data_list[0].keys():
                fields_update_tmp.append('""{0}""=""excluded"".""{0}""'.format(key))
            conflict_action_sql = 'UPDATE SET {update_fields}'\
                                  .format(update_fields=', '.join(fields_update_tmp))
        else:
            # Do nothing on conflict
            conflict_action_sql = 'NOTHING'

        try:
            with self.getcursor() as cur:
                query = """"""INSERT INTO {table} ({insert_fields})
                           VALUES {values}
                           ON CONFLICT ({on_conflict_fields}) DO
                           {conflict_action_sql}
                           {return_cols}
                        """""".format(table=table,
                                   insert_fields='""{0}""'.format('"",""'.join(data_list[0].keys())),
                                   values=','.join(['%s'] * len(data_list)),
                                   on_conflict_fields=','.join(on_conflict_fields),
                                   conflict_action_sql=conflict_action_sql,
                                   return_cols=return_cols,
                                   )
                # Get all the values for each row and create a lists of lists
                values = []
                for row in [list(v.values()) for v in data_list]:
                    values.append(_check_values(row))

                query = cur.mogrify(query, values)

                cur.execute(query)

                try:
                    return cur.fetchall()
                except Exception:
                    return None

        except Exception as e:
            logger.exception(""Error upserting data"")
            logger.debug(""Error upserting data: {data}"".format(data=data_list))
            raise e.with_traceback(sys.exc_info()[2])"
2855,"def update(self, table, data_list, matched_field=None, return_cols='id'):
        """"""
        Create a bulk insert statement which is much faster (~2x in tests with 10k & 100k rows and 4 cols)
        for inserting data then executemany()

        TODO: Is there a limit of length the query can be? If so handle it.
        """"""
        data_list = copy.deepcopy(data_list)  # Create deepcopy so the original list does not get modified
        if matched_field is None:
            # Assume the id field
            logger.info(""Matched field not defined, assuming the `id` field"")
            matched_field = 'id'

        # Make sure that `data_list` is a list
        if not isinstance(data_list, list):
            data_list = [data_list]

        if len(data_list) == 0:
            # No need to continue
            return []

        # Make sure return_cols is a list
        if return_cols is None or len(return_cols) == 0 or return_cols[0] is None:
            return_cols = ''
        elif not isinstance(return_cols, list):
            return_cols = [return_cols]

        if len(return_cols) > 0:
            return_cols = 'RETURNING ' + ','.join(return_cols)

        # Data in the list must be dicts (just check the first one)
        if not isinstance(data_list[0], dict):
            logger.critical(""Data must be a list of dicts"")
            # Do not return here, let the exception handle the error that will be thrown when the query runs

        try:
            with self.getcursor() as cur:
                query_list = []
                # TODO: change to return data from the database, not just what you passed in
                return_list = []
                for row in data_list:
                    if row.get(matched_field) is None:
                        logger.debug(""Cannot update row. Missing field {field} in data {data}""
                                     .format(field=matched_field, data=row))
                        logger.error(""Cannot update row. Missing field {field} in data"".format(field=matched_field))
                        continue

                    # Pull matched_value from data to be updated and remove that key
                    matched_value = row.get(matched_field)
                    del row[matched_field]

                    query = ""UPDATE {table} SET {data} WHERE {matched_field}=%s {return_cols}""\
                            .format(table=table,
                                    data=','.join(""%s=%%s"" % u for u in row.keys()),
                                    matched_field=matched_field,
                                    return_cols=return_cols
                                    )
                    values = list(row.values())
                    values.append(matched_value)
                    values = _check_values(values)

                    query = cur.mogrify(query, values)
                    query_list.append(query)
                    return_list.append(matched_value)

                finial_query = b';'.join(query_list)
                cur.execute(finial_query)

                try:
                    return cur.fetchall()
                except Exception:
                    return None

        except Exception as e:
            logger.exception(""Error updating data"")
            logger.debug(""Error updating data: {data}"".format(data=data_list))
            raise e.with_traceback(sys.exc_info()[2])"
2856,"def clone(srcpath, destpath, vcs=None):
    """"""Clone an existing repository.

    :param str srcpath: Path to an existing repository
    :param str destpath: Desired path of new repository
    :param str vcs: Either ``git``, ``hg``, or ``svn``
    :returns VCSRepo: The newly cloned repository

    If ``vcs`` is not given, then the repository type is discovered from
    ``srcpath`` via :func:`probe`.

    """"""
    vcs = vcs or probe(srcpath)
    cls = _get_repo_class(vcs)
    return cls.clone(srcpath, destpath)"
2857,"def probe(path):
    """"""Probe a repository for its type.

    :param str path: The path of the repository
    :raises UnknownVCSType: if the repository type couldn't be inferred
    :returns str: either ``git``, ``hg``, or ``svn``

    This function employs some heuristics to guess the type of the repository.

    """"""
    import os
    from .common import UnknownVCSType
    if os.path.isdir(os.path.join(path, '.git')):
        return 'git'
    elif os.path.isdir(os.path.join(path, '.hg')):
        return 'hg'
    elif (
        os.path.isfile(os.path.join(path, 'config')) and
        os.path.isdir(os.path.join(path, 'objects')) and
        os.path.isdir(os.path.join(path, 'refs')) and
        os.path.isdir(os.path.join(path, 'branches'))
    ):
        return 'git'
    elif (
        os.path.isfile(os.path.join(path, 'format')) and
        os.path.isdir(os.path.join(path, 'conf')) and
        os.path.isdir(os.path.join(path, 'db')) and
        os.path.isdir(os.path.join(path, 'locks'))
    ):
        return 'svn'
    else:
        raise UnknownVCSType(path)"
2858,"def open(path, vcs=None):
    """"""Open an existing repository

    :param str path: The path of the repository
    :param vcs: If specified, assume the given repository type to avoid
                auto-detection. Either ``git``, ``hg``, or ``svn``.
    :raises UnknownVCSType: if the repository type couldn't be inferred

    If ``vcs`` is not specified, it is inferred via :func:`probe`.

    """"""
    import os
    assert os.path.isdir(path), path + ' is not a directory'
    vcs = vcs or probe(path)
    cls = _get_repo_class(vcs)
    return cls(path)"
2859,"def _check_attributes(self, attributes, extra=None):
        """"""Check if attributes given to the constructor can be used to
        instanciate a valid node.""""""
        extra = extra or ()
        unknown_keys = set(attributes) - set(self._possible_attributes) - set(extra)
        if unknown_keys:
            logger.warning('%s got unknown attributes: %s' %
                            (self.__class__.__name__, unknown_keys))"
2860,"def get(self, name, strict=True):
        """"""Get an attribute of the holder (read-only access).""""""
        if not isinstance(name, str) or name.startswith('_'):
            raise AttributeError(self.__class__.__name__, name)
        elif strict and name not in self._possible_attributes:
            raise AttributeError('%s is not a valid attribute of %r.' %
                                 (name, self))
        elif name in self._attributes:
            return self._attributes[name]
        else:
            raise exceptions.AttributeNotProvided(name)"
2861,"def addMonths(date, months):
    """"""
    Returns the new date based on the inputted months.
    
    :param      date   | <datetime.date>
                months | <int>
    
    :return     <datetime.date>
    """"""
    # map from Qt information
    if type(date).__name__ in ('QDate', 'QDateTime', 'QTime'):
        date = date.toPython()

    mult = months / abs(months)
    years = mult * (abs(months) / 12)
    months = mult * (abs(months) % 12)

    # calculate the new month
    month = date.month + months
    if month < 1:
        years -= 1
        month = 12 - month

    elif 12 < month:
        years += 1
        month %= 12

    # calculate the new year
    year = date.year + years

    # calculate the new day
    check = datetime.date(year, month, 1)
    days = daysInMonth(check)

    return datetime.date(year, month, min(date.day, days))"
2862,"def addYears(date, years):
    """"""
    Returns the new date based on the inputted number of years.
    
    :param      date  | <datetime.date>
                years | <int>
    
    :return     <datetime.date>
    """"""
    # map from Qt information
    if type(date).__name__ in ('QDate', 'QDateTime', 'QTime'):
        date = date.toPython()

    return datetime.date(date.year + years, date.month, date.day)"
2863,"def daysInMonth(date):
    """"""
    Returns the number of the days in the month for the given date.  This will
    take into account leap years based on the inputted date's year.
    
    :param      date | <datetime.date>
    
    :return     <int>
    """"""
    # map from Qt information
    if type(date).__name__ in ('QDate', 'QDateTime', 'QTime'):
        date = date.toPython()

    month = date.month

    # look for a leap year
    if month == 2 and not date.year % 4:
        return 29

    return DaysInMonth.get(month, -1)"
2864,"def daysInYear(date):
    """"""
    Returns the number of days in the year for the given date.
    
    :param      date | <datetime.date> || <int>
    
    :return     <int>
    """"""
    # map from Qt information
    if type(date).__name__ in ('QDate', 'QDateTime', 'QTime'):
        date = date.toPython()

    if type(date) != int:
        year = date.year
    else:
        year = date

    if not year % 4:
        return 366
    return 365"
2865,"def displayName(date, options=None, format='%b %d, %Y'):
    """"""
    Returns the display name for the inputted date, given the list of options.
    
    :param      date    | <datetime.date>
                options | <projex.dates.Names>
                format  | <str>
    
    :return     <str>
    """"""
    # map from Qt information
    if type(date).__name__ in ('QDate', 'QDateTime', 'QTime'):
        date = date.toPython()

    if isinstance(date, datetime.datetime):
        time = ' @ ' + date.strftime('%I:%M%p').strip('0M').lower()
        date = date.date()
    else:
        time = ''

    today = datetime.date.today()
    delta = date - today

    if delta.days == 0:
        return 'Today' + time
    elif delta.days == -1:
        return 'Yesterday' + time
    elif delta.days == 1:
        return 'Tomorrow' + time
    elif abs(delta.days) < 8:
        # look for different weeks
        if date.isocalendar()[1] != today.isocalendar()[1]:
            qualifier = 'Last ' if delta.days < 0 else 'Next '
        else:
            qualifier = ''

        return qualifier + date.strftime('%A') + time
    else:
        return date.strftime(format)"
2866,"def named(date, options=None):
    """"""
    Returns the best named option for the inputted date based on the inputted
    date name.
    
    :param      date    | <datetime.date>
                options | <projex.dates.Names> || None
    
    :return     <projex.dates.Names>
    """"""
    # map from Qt information
    if type(date).__name__ in ('QDate', 'QDateTime', 'QTime'):
        date = date.toPython()

    if options is None:
        options = Names.all()

    # use the date information
    if isinstance(date, datetime.datetime):
        date = date.date()

    # grab today's information
    today = datetime.date.today()
    today_month = today.month
    today_year, today_week, today_weekday = today.isocalendar()

    # grab yesterday's information
    yesterday = today + datetime.timedelta(days=-1)
    tomorrow = today + datetime.timedelta(days=1)

    # grab the date information
    date_month = date.month
    date_year, date_week, date_weekday = date.isocalendar()

    # look for today
    if today == date and Names.Today & options:
        return Names.Today

    # look for yesterday
    elif yesterday == date and Names.Yesterday & options:
        return Names.Yesterday

    # look for tomorrow
    elif tomorrow == date and Names.Tomorrow & options:
        return Names.Tomorrow

    # look for same year options
    elif today_year == date_year:
        # look for same month options
        if today_month == date_month:
            # look for this week
            if today_week == date_week and Names.ThisWeek & options:
                return Names.ThisWeek

            # look for last week 
            elif today_week == date_week + 1 and Names.LastWeek & options:
                return Names.LastWeek

            # look for next week
            elif today_week == date_week - 1 and Names.NextWeek & options:
                return Names.NextWeek

            # look for this month
            elif Names.ThisMonth & options:
                return Names.ThisMonth

        # look for last month options
        elif today_month == date_month + 1 and Names.LastMonth & options:
            return Names.LastMonth

        # look for next month options
        elif today_month == date_month - 1 and Names.NextMonth & options:
            return Names.NextMonth

        # look for this year options
        elif Names.ThisYear & options:
            return Names.ThisYear

    # look for last year options
    elif today_year == date_year + 1 and Names.LastYear & options:
        return Names.LastYear

    # look for next year options
    elif today_year == date_year - 1 and Names.NextYear & options:
        return Names.NextYear

    # look for past dates
    elif date < today and Names.Past & options:
        return Names.Past

    # look for future dates
    elif today < date and Names.Future & options:
        return Names.Future

    return Names.Sometime"
2867,"def repeating(first,
              mode=RepeatMode.Weekly,
              step=1,
              flags=0,
              startAt=None,
              repeatUntil=None,
              maximum=None):
    """"""
    Returns a list of repeating dates from the inputted start date based on the
    given mode.  If an repeatUntil date is supplied, then the results will be
    capped once the last date is reached, otherwise, the maximum number of
    results will be returned.
    
    :param      first       | <datetime.date>
                mode        | <RepeatMode>
                step        | <int> | value must be greater than 1
                flags       | <RepeatFlags>
                startAt     | <datetime.date> || None
                repeatUntil | <datetime.date> || None
                maximum     | <int> || None
    
    :return     [<datetime.date>, ..]
    """"""
    if repeatUntil is None and maximum is None:
        maximum = 100

    # calculate the dates
    step = max(1, step)
    output = []

    # create the start at information
    if startAt is not None and first < startAt:
        if mode == RepeatMode.Monthly:
            curr = datetime.date(startAt.year, startAt.month, first.day)
        elif mode == RepeatMode.Yearly:
            curr = datetime.date(startAt.year, first.month, first.day)
        else:
            curr = first
    else:
        curr = first

    if curr < first:
        curr = first

    # determine if any days are flagged
    any_days = 0
    for value in DaysOfWeek.values():
        any_days |= value

    # repeat on a daily basis
    while True:
        # increment daily
        if mode == RepeatMode.Weekly:
            # repeat for specific days
            if flags & any_days:
                start = curr + datetime.timedelta(days=1 - curr.isoweekday())
                exit_loop = False

                for i in range(7):
                    day = start + datetime.timedelta(days=i)

                    if day < first:
                        continue

                    elif repeatUntil is not None and repeatUntil < day:
                        exit_loop = True
                        break

                    flag = DaysOfWeek[day.isoweekday()]

                    # skip this day of the week when repeating
                    if not (flags & flag):
                        continue

                    if startAt is None or startAt <= day:
                        output.append(day)

                if exit_loop:
                    break

            else:
                if repeatUntil is not None and repeatUntil < curr:
                    break

                if startAt is None or startAt <= curr:
                    output.append(curr)

            curr = curr + datetime.timedelta(days=7 * step)

        # break when the end first is hit
        if repeatUntil is not None and repeatUntil < curr:
            break

        # break when the maximum is hit
        elif maximum is not None and len(output) == maximum:
            break

        # increment weekly
        elif mode == RepeatMode.Weekly:
            if startAt is None or startAt <= curr:
                output.append(curr)

            curr = curr + datetime.timedelta(days=step * 7)

        # increment monthly
        elif mode == RepeatMode.Monthly:
            if startAt is None or startAt <= curr:
                output.append(curr)

            # approximate the delta
            curr = addMonths(curr, step)

            # check to see if we're repeating on the day of the week in
            # the month, or the actual day of the month
            if (flags & RepeatFlags.DayOfTheWeek) != 0:
                shift = curr.isodayofweek() - first.isoweekday()
                curr = curr + datetime.timedelta(days=shift)

        # increment yearly
        elif mode == RepeatMode.Yearly:
            if startAt is None or startAt <= curr:
                output.append(curr)

            curr = addYears(curr, step)

    return output"
2868,"def weekdays(start, end):
    """"""
    Returns the number of weekdays between the inputted start and end dates.
    This would be the equivalent of doing (end - start) to get the number of
    calendar days between the two dates.
    
    :param      start | <datetime.date>
                end   | <datetime.date>
    
    :return     <int>
    """"""
    # don't bother calculating anything for the same inputted date
    if start == end:
        return int(start.isoweekday() not in (6, 7))
    elif end < start:
        return -weekdays(end, start)
    else:
        strt_weekday = start.isoweekday()
        end_weekday = end.isoweekday()

        # calculate in the positive direction
        if end < start:
            return -weekdays(end, start)

        # calculate from the monday after the start
        if 5 < strt_weekday:
            start = start + datetime.timedelta(days=8 - strt_weekday)

        # calculate from the friday before the end
        if 5 < end_weekday:
            end = end - datetime.timedelta(days=end_weekday - 5)

        remainder = end.isoweekday() - start.isoweekday()
        end = end - datetime.timedelta(days=remainder)

        # if the end is now before the start, then both dates fell on a weekend
        if end < start:
            return 0

        # otherwise, if the dates normalized to each other, then return the
        # remainder
        elif end == start:
            return remainder + 1

        # remove the number of weekends from the start and end dates
        days = ((end - start).days + 1)
        total_days = abs(days)
        multiplier = days / total_days
        weekends = int(round(total_days / 7.0) * 2)
        week_days = ((total_days - weekends) + remainder) * multiplier

        return week_days"
2869,"def main(args=None):
    """"""
    Entry point for the tag CLI.

    Isolated as a method so that the CLI can be called by other Python code
    (e.g. for testing), in which case the arguments are passed to the function.
    If no arguments are passed to the function, parse them from the command
    line.
    """"""
    if args is None:
        args = tag.cli.parser().parse_args()

    assert args.cmd in mains
    mainmethod = mains[args.cmd]
    mainmethod(args)"
2870,"def _build_request(request):
    """"""Build message to transfer over the socket from a request.""""""
    msg = bytes([request['cmd']])
    if 'dest' in request:
        msg += bytes([request['dest']])
    else:
        msg += b'\0'
    if 'sha' in request:
        msg += request['sha']
    else:
        for dummy in range(64):
            msg += b'0'
    logging.debug(""Request (%d): %s"", len(msg), msg)
    return msg"
2871,"def main():
    """"""Show example using the API.""""""
    __async__ = True
    logging.basicConfig(format=""%(levelname)-10s %(message)s"",
                        level=logging.DEBUG)

    if len(sys.argv) != 2:
        logging.error(""Must specify configuration file"")
        sys.exit()
    config = configparser.ConfigParser()
    config.read(sys.argv[1])

    password = config.get('default', 'password')
    if __async__:
        client = Client(config.get('default', 'host'),
                        config.getint('default', 'port'), password, _callback)
    else:
        client = Client(config.get('default', 'host'),
                        config.getint('default', 'port'),
                        password)
        status = client.messages()
        msg = status[0]
        print(msg)
        print(client.mp3(msg['sha'].encode('utf-8')))
    while True:
        continue"
2872,"def start(self):
        """"""Start thread.""""""
        if not self._thread:
            logging.info(""Starting asterisk mbox thread"")
            # Ensure signal queue is empty
            try:
                while True:
                    self.signal.get(False)
            except queue.Empty:
                pass
            self._thread = threading.Thread(target=self._loop)
            self._thread.setDaemon(True)
            self._thread.start()"
2873,"def stop(self):
        """"""Stop thread.""""""
        if self._thread:
            self.signal.put(""Stop"")
            self._thread.join()
            if self._soc:
                self._soc.shutdown()
                self._soc.close()
            self._thread = None"
2874,"def _connect(self):
        """"""Connect to server.""""""
        self._soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self._soc.connect((self._ipaddr, self._port))
        self._soc.send(_build_request({'cmd': cmd.CMD_MESSAGE_PASSWORD,
                                       'sha': self._password}))"
2875,"def _recv_msg(self):
        """"""Read a message from the server.""""""
        command = ord(recv_blocking(self._soc, 1))
        msglen = recv_blocking(self._soc, 4)
        msglen = ((msglen[0] << 24) + (msglen[1] << 16) +
                  (msglen[2] << 8) + msglen[3])
        msg = recv_blocking(self._soc, msglen)
        return command, msg"
2876,"def _loop(self):
        """"""Handle data.""""""
        request = {}
        connected = False
        while True:
            timeout = None
            sockets = [self.request_queue, self.signal]
            if not connected:
                try:
                    self._clear_request(request)
                    self._connect()
                    self._soc.send(_build_request(
                        {'cmd': cmd.CMD_MESSAGE_LIST}))
                    self._soc.send(_build_request(
                        {'cmd': cmd.CMD_MESSAGE_CDR_AVAILABLE}))
                    connected = True
                except ConnectionRefusedError:
                    timeout = 5.0
            if connected:
                sockets.append(self._soc)

            readable, _writable, _errored = select.select(
                sockets, [], [], timeout)

            if self.signal in readable:
                break

            if self._soc in readable:
                # We have incoming data
                try:
                    command, msg = self._recv_msg()
                    self._handle_msg(command, msg, request)
                except (RuntimeError, ConnectionResetError):
                    logging.warning(""Lost connection"")
                    connected = False
                    self._clear_request(request)

            if self.request_queue in readable:
                request = self.request_queue.get()
                self.request_queue.task_done()
                if not connected:
                    self._clear_request(request)
                else:
                    if (request['cmd'] == cmd.CMD_MESSAGE_LIST and
                            self._status and
                            (not self._callback or 'sync' in request)):
                        self.result_queue.put(
                            [cmd.CMD_MESSAGE_LIST, self._status])
                        request = {}
                    else:
                        self._soc.send(_build_request(request))"
2877,"def mp3(self, sha, **kwargs):
        """"""Get raw MP3 of a message.""""""
        return self._queue_msg({'cmd': cmd.CMD_MESSAGE_MP3,
                                'sha': _get_bytes(sha)}, **kwargs)"
2878,"def delete(self, sha, **kwargs):
        """"""Delete a message.""""""
        return self._queue_msg({'cmd': cmd.CMD_MESSAGE_DELETE,
                                'sha': _get_bytes(sha)}, **kwargs)"
2879,"def get_cdr(self, start=0, count=-1, **kwargs):
        """"""Request range of CDR messages""""""
        sha = encode_to_sha(""{:d},{:d}"".format(start, count))
        return self._queue_msg({'cmd': cmd.CMD_MESSAGE_CDR,
                                'sha': sha}, **kwargs)"
2880,"def path(self) -> Path:
        """"""A Path for this name object joining field names from `self.get_path_pattern_list` with this object's name""""""
        args = list(self._iter_translated_field_names(self.get_path_pattern_list()))
        args.append(self.get_name())
        return Path(*args)"
2881,"def fold(self, predicate):
        """"""Takes a predicate and applies it to each node starting from the
        leaves and making the return value propagate.""""""
        childs = {x:y.fold(predicate) for (x,y) in self._attributes.items()
                  if isinstance(y, SerializableTypedAttributesHolder)}
        return predicate(self, childs)"
2882,"def the_one(cls):
        """"""Get the single global HelpUrlExpert object.""""""
        if cls.THE_ONE is None:
            cls.THE_ONE = cls(settings.HELP_TOKENS_INI_FILE)
        return cls.THE_ONE"
2883,"def get_config_value(self, section_name, option, default_option=""default""):
        """"""
        Read a value from the configuration, with a default.

        Args:
            section_name (str): name of the section in the configuration from which
                the option should be found.
            option (str): name of the configuration option.
            default_option (str): name of the default configuration option whose
                value should be returned if the requested option is not found.

        Returns:
            str: the value from the ini file.

        """"""
        if self.config is None:
            self.config = configparser.ConfigParser()
            self.config.read(self.ini_file_name)

        if option:
            try:
                return self.config.get(section_name, option)
            except configparser.NoOptionError:
                log.debug(
                    ""Didn't find a configuration option for '%s' section and '%s' option"",
                    section_name, option,
                )

        return self.config.get(section_name, default_option)"
2884,"def url_for_token(self, token):
        """"""Find the full URL for a help token.""""""
        book_url = self.get_config_value(""pages"", token)
        book, _, url_tail = book_url.partition(':')
        book_base = settings.HELP_TOKENS_BOOKS[book]

        url = book_base

        lang = getattr(settings, ""HELP_TOKENS_LANGUAGE_CODE"", None)
        if lang is not None:
            lang = self.get_config_value(""locales"", lang)
            url += ""/"" + lang

        version = getattr(settings, ""HELP_TOKENS_VERSION"", None)
        if version is not None:
            url += ""/"" + version

        url += ""/"" + url_tail
        return url"
2885,"def load_data(Filepath, ObjectType='data', RelativeChannelNo=None, SampleFreq=None, PointsToLoad=-1, calcPSD=True, NPerSegmentPSD=1000000, NormaliseByMonitorOutput=False, silent=False):
    """"""
    Parameters
    ----------
    Filepath : string
        filepath to the file containing the data used to initialise
        and create an instance of the DataObject class
    ObjectType : string, optional
        type to load the data as, takes the value 'default' if not specified.
        Options are:
        'data' : optoanalysis.DataObject
        'thermo' : optoanalysis.thermo.ThermoObject
    RelativeChannelNo : int, optional
        If loading a .bin file produced by the Saneae datalogger, used to specify
        the channel number
        If loading a .dat file produced by the labview NI5122 daq card, used to 
        specifiy the channel number if two channels where saved, if left None with 
        .dat files it will assume that the file to load only contains one channel.
        If NormaliseByMonitorOutput is True then specifies the monitor channel for
        loading a .dat file produced by the labview NI5122 daq card.
    SampleFreq : float, optional
        If loading a .dat file produced by the labview NI5122 daq card, used to
        manually specify the sample frequency
    PointsToLoad : int, optional
        Number of first points to read. -1 means all points (i.e., the complete file)
        WORKS WITH NI5122 DATA SO FAR ONLY!!!
    calcPSD : bool, optional
        Whether to calculate the PSD upon loading the file, can take some time
        off the loading and reduce memory usage if frequency space info is not required
    NPerSegmentPSD : int, optional
        NPerSegment to pass to scipy.signal.welch to calculate the PSD
    NormaliseByMonitorOutput : bool, optional
        If True the particle signal trace will be divided by the monitor output, which is
        specified by the channel number set in the RelativeChannelNo parameter. 
        WORKS WITH NI5122 DATA SO FAR ONLY!!!

    Returns
    -------
    Data : DataObject
        An instance of the DataObject class contaning the data
        that you requested to be loaded.

    """"""
    if silent != True:
        print(""Loading data from {}"".format(Filepath))
    ObjectTypeDict = {
        'data' : DataObject,
        'thermo' : optoanalysis.thermo.ThermoObject,
        }
    try:
        Object = ObjectTypeDict[ObjectType]
    except KeyError:
        raise ValueError(""You entered {}, this is not a valid object type"".format(ObjectType))
    data = Object(Filepath, RelativeChannelNo, SampleFreq, PointsToLoad, calcPSD, NPerSegmentPSD, NormaliseByMonitorOutput)
    try:
        channel_number, run_number, repeat_number = [int(val) for val in re.findall('\d+', data.filename)]
        data.channel_number = channel_number
        data.run_number = run_number
        data.repeat_number = repeat_number
        if _does_file_exist(data.filepath.replace(data.filename, '') + ""pressure.log""):
            print(""pressure.log file exists"")
            for line in open(data.filepath.replace(data.filename, '') + ""pressure.log"", 'r'):
                run_number, repeat_number, pressure = line.split(',')[1:]
                run_number = int(run_number)
                repeat_number = int(repeat_number)
                pressure = float(pressure)
                if (run_number == data.run_number) and (repeat_number == data.repeat_number):
                    data.pmbar = pressure    
    except ValueError:
        pass
    try:
        if _does_file_exist(glob(data.filepath.replace(data.filename, '*' + data.filename[20:-4] + ' - header.dat'))[0]):
            print(""header file exists"")
            with open(glob(data.filepath.replace(data.filename, '*' + data.filepath[20:-4] + ' - header.dat'))[0], encoding='ISO-8859-1') as f:
                lines = f.readlines()
            data.pmbar = (float(lines[68][-9:-1])+float(lines[69][-9:-1]))/2
    except (ValueError, IndexError):
        pass
    return data"
2886,"def search_data_std(Channel, RunNos, RepeatNos, directoryPath='.'):
    """"""
    Lets you find multiple datasets at once assuming they have a 
    filename which contains a pattern of the form:
    CH<ChannelNo>_RUN00...<RunNo>_REPEAT00...<RepeatNo>    

    Parameters
    ----------
    Channel : int
        The channel you want to load
    RunNos : sequence
        Sequence of run numbers you want to load
    RepeatNos : sequence
        Sequence of repeat numbers you want to load
    directoryPath : string, optional
        The path to the directory housing the data
        The default is the current directory

    Returns
    -------
    Data_filepaths : list
        A list containing the filepaths to the matching files
    """"""
    files = glob('{}/*'.format(directoryPath))
    files_CorrectChannel = []
    for file_ in files:
        if 'CH{}'.format(Channel) in file_:
            files_CorrectChannel.append(file_)
    files_CorrectRunNo = []
    for RunNo in RunNos:
        files_match = _fnmatch.filter(
            files_CorrectChannel, '*RUN*0{}_*'.format(RunNo))
        for file_ in files_match:
            files_CorrectRunNo.append(file_)
    files_CorrectRepeatNo = []
    for RepeatNo in RepeatNos:
        files_match = _fnmatch.filter(
            files_CorrectRunNo, '*REPEAT*0{}.*'.format(RepeatNo))
        for file_ in files_match:
            files_CorrectRepeatNo.append(file_)
    return files_CorrectRepeatNo"
2887,"def multi_load_data(Channel, RunNos, RepeatNos, directoryPath='.', calcPSD=True, NPerSegmentPSD=1000000):
    """"""
    Lets you load multiple datasets at once assuming they have a 
    filename which contains a pattern of the form:
    CH<ChannelNo>_RUN00...<RunNo>_REPEAT00...<RepeatNo>    

    Parameters
    ----------
    Channel : int
        The channel you want to load
    RunNos : sequence
        Sequence of run numbers you want to load
    RepeatNos : sequence
        Sequence of repeat numbers you want to load
    directoryPath : string, optional
        The path to the directory housing the data
        The default is the current directory

    Returns
    -------
    Data : list
        A list containing the DataObjects that were loaded. 
    """"""
    matching_files = search_data_std(Channel=Channel, RunNos=RunNos, RepeatNos=RepeatNos, directoryPath=directoryPath)
    #data = []
    #for filepath in matching_files_:
    #    data.append(load_data(filepath, calcPSD=calcPSD, NPerSegmentPSD=NPerSegmentPSD))

    cpu_count = _cpu_count()
    workerPool = _Pool(cpu_count)
    load_data_partial = _partial(load_data, calcPSD=calcPSD, NPerSegmentPSD=NPerSegmentPSD)
    data = workerPool.map(load_data_partial, matching_files)
    workerPool.close()
    workerPool.terminate()
    workerPool.join()
       
    #with _Pool(cpu_count) as workerPool:
        #load_data_partial = _partial(load_data, calcPSD=calcPSD, NPerSegmentPSD=NPerSegmentPSD)
        #data = workerPool.map(load_data_partial, files_CorrectRepeatNo)
    return data"
2888,"def multi_load_data_custom(Channel, TraceTitle, RunNos, directoryPath='.', calcPSD=True, NPerSegmentPSD=1000000):
    """"""
    Lets you load multiple datasets named with the LeCroy's custom naming scheme at once.

    Parameters
    ----------
    Channel : int
        The channel you want to load
    TraceTitle : string
        The custom trace title of the files. 
    RunNos : sequence
        Sequence of run numbers you want to load
    RepeatNos : sequence
        Sequence of repeat numbers you want to load
    directoryPath : string, optional
        The path to the directory housing the data
        The default is the current directory

    Returns
    -------
    Data : list
        A list containing the DataObjects that were loaded. 
    """"""
#    files = glob('{}/*'.format(directoryPath))
#    files_CorrectChannel = []
#    for file_ in files:
#        if 'C{}'.format(Channel) in file_:
#           files_CorrectChannel.append(file_)
#    files_CorrectRunNo = []
#    for RunNo in RunNos:
#        files_match = _fnmatch.filter(
#            files_CorrectChannel, '*C{}'.format(Channel)+TraceTitle+str(RunNo).zfill(5)+'.*')
#        for file_ in files_match:
#            files_CorrectRunNo.append(file_)
    matching_files = search_data_custom(Channel, TraceTitle, RunNos, directoryPath)
    cpu_count = _cpu_count()
    workerPool = _Pool(cpu_count)
    # for filepath in files_CorrectRepeatNo:
    #    print(filepath)
    #    data.append(load_data(filepath))
    load_data_partial = _partial(load_data, calcPSD=calcPSD, NPerSegmentPSD=NPerSegmentPSD)
    data = workerPool.map(load_data_partial, matching_files)
    workerPool.close()
    workerPool.terminate()
    workerPool.join()
    return data"
2889,"def search_data_custom(Channel, TraceTitle, RunNos, directoryPath='.'):
    """"""
    Lets you create a list with full file paths of the files
    named with the LeCroy's custom naming scheme.

    Parameters
    ----------
    Channel : int
        The channel you want to load
    TraceTitle : string
        The custom trace title of the files. 
    RunNos : sequence
        Sequence of run numbers you want to load
    RepeatNos : sequence
        Sequence of repeat numbers you want to load
    directoryPath : string, optional
        The path to the directory housing the data
        The default is the current directory

    Returns
    -------
    Paths : list
        A list containing the full file paths of the files you were looking for. 
    """"""
    files = glob('{}/*'.format(directoryPath))
    files_CorrectChannel = []    
    for file_ in files:
        if 'C{}'.format(Channel) in file_:
            files_CorrectChannel.append(file_)
    files_CorrectRunNo = []
    for RunNo in RunNos:
        files_match = _fnmatch.filter(
            files_CorrectChannel, '*C{}'.format(Channel)+TraceTitle+str(RunNo).zfill(5)+'.*')
        for file_ in files_match:
            files_CorrectRunNo.append(file_)
    print(""loading the following files: {}"".format(files_CorrectRunNo))
    paths = files_CorrectRunNo
    return paths"
2890,"def calc_temp(Data_ref, Data):
    """"""
    Calculates the temperature of a data set relative to a reference.
    The reference is assumed to be at 300K.

    Parameters
    ----------
    Data_ref : DataObject
        Reference data set, assumed to be 300K
    Data : DataObject
        Data object to have the temperature calculated for

    Returns
    -------
    T : uncertainties.ufloat
        The temperature of the data set
    """"""
    T = 300 * ((Data.A * Data_ref.Gamma) / (Data_ref.A * Data.Gamma))
    Data.T = T
    return T"
2891,"def calc_gamma_components(Data_ref, Data):
    """"""
    Calculates the components of Gamma (Gamma0 and delta_Gamma), 
    assuming that the Data_ref is uncooled data (ideally at 3mbar
    for best fitting). It uses the fact that A_prime=A/Gamma0 should 
    be constant for a particular particle under changes in pressure
    and therefore uses the reference save to calculate A_prime (assuming
    the Gamma value found for the uncooled data is actually equal to Gamma0
    since only collisions should be causing the damping. Therefore for
    the cooled data Gamma0 should equal A/A_prime and therefore we
    can extract Gamma0 and delta_Gamma.

    A_prime = ConvFactor**2 * (2*k_B*T0/(pi*m))

    Parameters
    ----------
    Data_ref : DataObject
        Reference data set, assumed to be 300K
    Data : DataObject
        Data object to have the temperature calculated for

    Returns
    -------
    Gamma0 : uncertainties.ufloat
        Damping due to the environment
    delta_Gamma : uncertainties.ufloat
        Damping due to other effects (e.g. feedback cooling)
    
    """"""
    A_prime = Data_ref.A/Data_ref.Gamma
    Gamma0 = Data.A/A_prime
    delta_Gamma = Data.Gamma - Gamma0
    return Gamma0, delta_Gamma"
2892,"def fit_curvefit(p0, datax, datay, function, **kwargs):
    """"""
    Fits the data to a function using scipy.optimise.curve_fit

    Parameters
    ----------
    p0 : array_like
        initial parameters to use for fitting
    datax : array_like
        x data to use for fitting
    datay : array_like
        y data to use for fitting
    function : function
        funcion to be fit to the data
    kwargs 
        keyword arguments to be passed to scipy.optimise.curve_fit

    Returns
    -------
    pfit_curvefit : array
        Optimal values for the parameters so that the sum of
        the squared residuals of ydata is minimized
    perr_curvefit : array
        One standard deviation errors in the optimal values for
        the parameters
    """"""
    pfit, pcov = \
        _curve_fit(function, datax, datay, p0=p0,
                   epsfcn=0.0001, **kwargs)
    error = []
    for i in range(len(pfit)):
        try:
            error.append(_np.absolute(pcov[i][i])**0.5)
        except:
            error.append(_np.NaN)
    pfit_curvefit = pfit
    perr_curvefit = _np.array(error)
    return pfit_curvefit, perr_curvefit"
2893,"def moving_average(array, n=3):
    """"""
    Calculates the moving average of an array.

    Parameters
    ----------
    array : array
        The array to have the moving average taken of
    n : int
        The number of points of moving average to take
    
    Returns
    -------
    MovingAverageArray : array
        The n-point moving average of the input array
    """"""
    ret = _np.cumsum(array, dtype=float)
    ret[n:] = ret[n:] - ret[:-n]
    return ret[n - 1:] / n"
2894,"def take_closest(myList, myNumber):
    """"""
    Assumes myList is sorted. Returns closest value to myNumber.
    If two numbers are equally close, return the smallest number.

    Parameters
    ----------
    myList : array
        The list in which to find the closest value to myNumber
    myNumber : float
        The number to find the closest to in MyList

    Returns
    -------
    closestValue : float
        The number closest to myNumber in myList
    """"""
    pos = _bisect_left(myList, myNumber)
    if pos == 0:
        return myList[0]
    if pos == len(myList):
        return myList[-1]
    before = myList[pos - 1]
    after = myList[pos]
    if after - myNumber < myNumber - before:
        return after
    else:
        return before"
2895,"def _position_autocorrelation_fitting_eqn(t, Gamma, AngTrapFreq):
    """"""
    The value of the fitting equation:
    exp(-t*Gamma/2) * (cos(t* sqrt(Omega**2 - Gamma**2 /4)) + Gamma* sin(t* sqrt(Omega**2-Gamma**2 /4))/(2* sqrt(Omega**2 - Gamma**2 /4)))
    [eqn 4.20 taken from DOI: DOI: 10.1007/978-1-4614-6031-2]
    to be fit to the autocorrelation-exponential decay

    Parameters
    ----------
    t : float
        time 
    Gamma : float
        Big Gamma (in radians), i.e. damping 
    AngTrapFreq : float
        Angular Trapping Frequency in Radians

    Returns
    -------
    Value : float
        The value of the fitting equation
    """"""
    return _np.exp(-t*Gamma/2)* ( _np.cos(t* _np.sqrt(AngTrapFreq**2-Gamma**2/4)) + Gamma* _np.sin(t* _np.sqrt(AngTrapFreq**2-Gamma**2/4))/(2* _np.sqrt(AngTrapFreq**2-Gamma**2/4)) )"
2896,"def fit_autocorrelation(autocorrelation, time, GammaGuess, TrapFreqGuess=None, method='energy', MakeFig=True, show_fig=True):
    """"""
    Fits exponential relaxation theory to data.

    Parameters
    ----------
    autocorrelation : array
        array containing autocorrelation to be fitted
    time : array
        array containing the time of each point the autocorrelation
        was evaluated
    GammaGuess : float
        The approximate Big Gamma (in radians) to use initially
    TrapFreqGuess : float
        The approximate trapping frequency to use initially in Hz.
    method : string, optional
        To choose which autocorrelation fit is needed.
        'position' : equation 4.20 from Tongcang Li's 2013 thesis 
                     (DOI: 10.1007/978-1-4614-6031-2)
        'energy'   : proper exponential energy correlation decay
                     (DOI: 10.1103/PhysRevE.94.062151)
    MakeFig : bool, optional
        Whether to construct and return the figure object showing
        the fitting. defaults to True
    show_fig : bool, optional
        Whether to show the figure object when it has been created.
        defaults to True

    Returns
    -------
    ParamsFit - Fitted parameters:
        'variance'-method : [Gamma]
        'position'-method : [Gamma, AngularTrappingFrequency]
    ParamsFitErr - Error in fitted parameters:
        'varaince'-method : [GammaErr]
        'position'-method : [GammaErr, AngularTrappingFrequencyErr]
    fig : matplotlib.figure.Figure object
        figure object containing the plot
    ax : matplotlib.axes.Axes object
        axes with the data plotted of the:
            - initial data
            - final fit
    """"""
    datax = time
    datay = autocorrelation

    method = method.lower()
    if method == 'energy':
        p0 = _np.array([GammaGuess])

        Params_Fit, Params_Fit_Err = fit_curvefit(p0,
                                                  datax,
                                                  datay,
                                                  _energy_autocorrelation_fitting_eqn)
        autocorrelation_fit = _energy_autocorrelation_fitting_eqn(_np.arange(0,datax[-1],1e-7),
                                                                  Params_Fit[0])
    elif method == 'position':
        AngTrapFreqGuess = 2 * _np.pi * TrapFreqGuess
        p0 = _np.array([GammaGuess, AngTrapFreqGuess])
        Params_Fit, Params_Fit_Err = fit_curvefit(p0,
                                                  datax,
                                                  datay,
                                                  _position_autocorrelation_fitting_eqn)
        autocorrelation_fit = _position_autocorrelation_fitting_eqn(_np.arange(0,datax[-1],1e-7),
                                                                    Params_Fit[0],
                                                                    Params_Fit[1])
        
    if MakeFig == True:
        fig = _plt.figure(figsize=properties[""default_fig_size""])
        ax = fig.add_subplot(111)
        ax.plot(datax*1e6, datay,
                '.', color=""darkblue"", label=""Autocorrelation Data"", alpha=0.5)
        ax.plot(_np.arange(0,datax[-1],1e-7)*1e6, autocorrelation_fit,
                color=""red"", label=""fit"")
        ax.set_xlim([0,
                     30e6/Params_Fit[0]/(2*_np.pi)])
        legend = ax.legend(loc=""best"", frameon = 1)
        frame = legend.get_frame()
        frame.set_facecolor('white')
        frame.set_edgecolor('white')
        ax.set_xlabel(""time (us)"")
        ax.set_ylabel(r""$\left | \frac{\langle x(t)x(t+\tau) \rangle}{\langle x(t)x(t) \rangle} \right |$"")
        if show_fig == True:
            _plt.show()
        return Params_Fit, Params_Fit_Err, fig, ax
    else:
        return Params_Fit, Params_Fit_Err, None, None"
2897,"def PSD_fitting_eqn(A, OmegaTrap, Gamma, omega):
    """"""
    The value of the fitting equation:
    A / ((OmegaTrap**2 - omega**2)**2 + (omega * Gamma)**2)
    to be fit to the PSD

    Parameters
    ----------
    A : float
        Fitting constant A
        A = γ**2*Γ_0*(2*K_b*T_0)/(π*m)
        where:
            γ = conversionFactor
            Γ_0 = Damping factor due to environment
            π = pi
    OmegaTrap : float
        The trapping frequency in the axis of interest 
        (in angular frequency)
    Gamma : float
        The damping factor Gamma = Γ = Γ_0 + δΓ
        where:
            Γ_0 = Damping factor due to environment
            δΓ = extra damping due to feedback or other effects
    omega : float
        The angular frequency to calculate the value of the 
        fitting equation at 

    Returns
    -------
    Value : float
        The value of the fitting equation
    """"""
    return A / ((OmegaTrap**2 - omega**2)**2 + omega**2 * (Gamma)**2)"
2898,"def PSD_fitting_eqn_with_background(A, OmegaTrap, Gamma, FlatBackground, omega):
    """"""
    The value of the fitting equation:
    A / ((OmegaTrap**2 - omega**2)**2 + (omega * Gamma)**2) + FlatBackground
    to be fit to the PSD

    Parameters
    ----------
    A : float
        Fitting constant A
        A = γ**2*Γ_0*(2*K_b*T_0)/(π*m)
        where:
            γ = conversionFactor
            Γ_0 = Damping factor due to environment
            π = pi
    OmegaTrap : float
        The trapping frequency in the axis of interest 
        (in angular frequency)
    Gamma : float
        The damping factor Gamma = Γ = Γ_0 + δΓ
        where:
            Γ_0 = Damping factor due to environment
            δΓ = extra damping due to feedback or other effects
    FlatBackground : float
        Adds a constant offset to the peak to account for a flat 
        noise background
    omega : float
        The angular frequency to calculate the value of the 
        fitting equation at 

    Returns
    -------
    Value : float
        The value of the fitting equation
    """"""
    return A / ((OmegaTrap**2 - omega**2)**2 + omega**2 * (Gamma)**2) + FlatBackground"
2899,"def fit_PSD(Data, bandwidth, TrapFreqGuess, AGuess=0.1e10, GammaGuess=400, FlatBackground=None, MakeFig=True, show_fig=True):
    """"""
    Fits theory PSD to Data. Assumes highest point of PSD is the
    trapping frequency.

    Parameters
    ----------
    Data : DataObject
        data object to be fitted
    bandwidth : float
         bandwidth around trapping frequency peak to
         fit the theory PSD to
    TrapFreqGuess : float
        The approximate trapping frequency to use initially
        as the centre of the peak
    AGuess : float, optional
        The initial value of the A parameter to use in fitting
    GammaGuess : float, optional
        The initial value of the Gamma parameter to use in fitting
    FlatBackground : float, optional
        If given a number the fitting function assumes a flat 
        background to get more exact Area, which does not factor in
        noise. defaults to None, which fits a model with no flat 
        background contribution, basically no offset
    MakeFig : bool, optional
        Whether to construct and return the figure object showing
        the fitting. defaults to True
    show_fig : bool, optional
        Whether to show the figure object when it has been created.
        defaults to True

    Returns
    -------
    ParamsFit - Fitted parameters:
        [A, TrappingFrequency, Gamma, FlatBackground(optional)]
    ParamsFitErr - Error in fitted parameters:
        [AErr, TrappingFrequencyErr, GammaErr, FlatBackgroundErr(optional)]
    fig : matplotlib.figure.Figure object
        figure object containing the plot
    ax : matplotlib.axes.Axes object
        axes with the data plotted of the:
            - initial data
            - initial fit
            - final fit
    """"""
    AngFreqs = 2 * pi * Data.freqs
    Angbandwidth = 2 * pi * bandwidth
    AngTrapFreqGuess = 2 * pi * TrapFreqGuess

    ClosestToAngTrapFreqGuess = take_closest(AngFreqs, AngTrapFreqGuess)
    index_OmegaTrap = _np.where(AngFreqs == ClosestToAngTrapFreqGuess)[0][0]
    OmegaTrap = AngFreqs[index_OmegaTrap]

    f_fit_lower = take_closest(AngFreqs, OmegaTrap - Angbandwidth / 2)
    f_fit_upper = take_closest(AngFreqs, OmegaTrap + Angbandwidth / 2)

    indx_fit_lower = int(_np.where(AngFreqs == f_fit_lower)[0][0])
    indx_fit_upper = int(_np.where(AngFreqs == f_fit_upper)[0][0])

    if indx_fit_lower == indx_fit_upper:
        raise ValueError(""Bandwidth argument must be higher, region is too thin."")
    
#    print(f_fit_lower, f_fit_upper)
#    print(AngFreqs[indx_fit_lower], AngFreqs[indx_fit_upper])

    # find highest point in region about guess for trap frequency - use that
    # as guess for trap frequency and recalculate region about the trap
    # frequency
    index_OmegaTrap = _np.where(Data.PSD == max(
        Data.PSD[indx_fit_lower:indx_fit_upper]))[0][0]

    OmegaTrap = AngFreqs[index_OmegaTrap]

#    print(OmegaTrap)

    f_fit_lower = take_closest(AngFreqs, OmegaTrap - Angbandwidth / 2)
    f_fit_upper = take_closest(AngFreqs, OmegaTrap + Angbandwidth / 2)

    indx_fit_lower = int(_np.where(AngFreqs == f_fit_lower)[0][0])
    indx_fit_upper = int(_np.where(AngFreqs == f_fit_upper)[0][0])

    logPSD = 10 * _np.log10(Data.PSD) # putting PSD in dB

    def calc_theory_PSD_curve_fit(freqs, A, TrapFreq, BigGamma, FlatBackground=None):
        if FlatBackground == None:
            Theory_PSD = 10 * \
                _np.log10(PSD_fitting_eqn(A, TrapFreq, BigGamma, freqs)) # PSD in dB
        else:
            Theory_PSD = 10* \
                _np.log10(PSD_fitting_eqn_with_background(A, TrapFreq, BigGamma, FlatBackground, freqs)) # PSD in dB
        if A < 0 or TrapFreq < 0 or BigGamma < 0:
            return 1e9
        else:
            return Theory_PSD

    datax = AngFreqs[indx_fit_lower:indx_fit_upper]
    datay = logPSD[indx_fit_lower:indx_fit_upper]

    if FlatBackground == None:
        p0 = _np.array([AGuess, OmegaTrap, GammaGuess])

        Params_Fit, Params_Fit_Err = fit_curvefit(p0,
                                                  datax,
                                                  datay,
                                                  calc_theory_PSD_curve_fit)
    else:
        p0 = _np.array([AGuess, OmegaTrap, GammaGuess, FlatBackground])

        Params_Fit, Params_Fit_Err = fit_curvefit(p0,
                                                  datax,
                                                  datay,
                                                  calc_theory_PSD_curve_fit)

    if MakeFig == True:
        fig = _plt.figure(figsize=properties[""default_fig_size""])
        ax = fig.add_subplot(111)

        if FlatBackground==None:
            PSDTheory_fit_initial = 10 * _np.log10(
                PSD_fitting_eqn(p0[0], p0[1],
                                p0[2], AngFreqs))

            PSDTheory_fit = 10 * _np.log10(
                PSD_fitting_eqn(Params_Fit[0],
                                Params_Fit[1],
                                Params_Fit[2],
                                AngFreqs))
        else:
            PSDTheory_fit_initial = 10 * _np.log10(
                PSD_fitting_eqn_with_background(p0[0], p0[1],
                                                p0[2], p0[3], AngFreqs))

            PSDTheory_fit = 10 * _np.log10(
                PSD_fitting_eqn_with_background(Params_Fit[0],
                                                Params_Fit[1],
                                                Params_Fit[2],
                                                Params_Fit[3],
                                                AngFreqs))

        ax.plot(AngFreqs / (2 * pi), Data.PSD,
                color=""darkblue"", label=""Raw PSD Data"", alpha=0.5)
        ax.plot(AngFreqs / (2 * pi), 10**(PSDTheory_fit_initial / 10),
                '--', alpha=0.7, color=""purple"", label=""initial vals"")
        ax.plot(AngFreqs / (2 * pi), 10**(PSDTheory_fit / 10),
                color=""red"", label=""fitted vals"")
        ax.set_xlim([(OmegaTrap - 5 * Angbandwidth) / (2 * pi),
                     (OmegaTrap + 5 * Angbandwidth) / (2 * pi)])
        ax.plot([(OmegaTrap - Angbandwidth) / (2 * pi), (OmegaTrap - Angbandwidth) / (2 * pi)],
                [min(10**(logPSD / 10)),
                 max(10**(logPSD / 10))], '--',
                color=""grey"")
        ax.plot([(OmegaTrap + Angbandwidth) / (2 * pi), (OmegaTrap + Angbandwidth) / (2 * pi)],
                [min(10**(logPSD / 10)),
                 max(10**(logPSD / 10))], '--',
                color=""grey"")
        ax.semilogy()
        legend = ax.legend(loc=""best"", frameon = 1)
        frame = legend.get_frame()
        frame.set_facecolor('white')
        frame.set_edgecolor('white')
        ax.set_xlabel(""Frequency (Hz)"")
        ax.set_ylabel(""$S_{xx}$ ($V^2/Hz$)"")
        if show_fig == True:
            _plt.show()
        return Params_Fit, Params_Fit_Err, fig, ax
    else:
        return Params_Fit, Params_Fit_Err, None, None"
2900,"def extract_parameters(Pressure, PressureErr, A, AErr, Gamma0, Gamma0Err, method=""chang""):
    """"""
    Calculates the radius, mass and conversion factor and thier uncertainties.
    For values to be correct data must have been taken with feedback off and
    at pressures of around 1mbar (this is because the equations assume
    harmonic motion and at lower pressures the uncooled particle experiences
    anharmonic motion (due to exploring furthur outside the middle of the trap).
    When cooled the value of Gamma (the damping) is a combination of the
    enviromental damping and feedback damping and so is not the correct value
    for use in this equation (as it requires the enviromental damping).
    Environmental damping can be predicted though as A=const*Gamma0. By
    fitting to 1mbar data one can find the value of the const and therefore
    Gamma0 = A/const

    Parameters
    ----------
    Pressure : float
        Pressure in mbar when the data was taken
    PressureErr : float
        Error in the Pressure as a decimal (e.g. 15% error is 0.15) 
    A : float
        Fitting constant A
        A = γ**2*2*Γ_0*(K_b*T_0)/(π*m)
        where:
        γ = conversionFactor
        Γ_0 = Damping factor due to environment
        π = pi
    AErr : float
        Error in Fitting constant A
    Gamma0 : float
        The enviromental damping factor Gamma_0 = Γ_0
    Gamma0Err : float
        The error in the enviromental damping factor Gamma_0 = Γ_0

    Returns:
    Params : list
        [radius, mass, conversionFactor]
        The extracted parameters
    ParamsError : list
        [radiusError, massError, conversionFactorError]
        The error in the extracted parameters
    """"""
    Pressure = 100 * Pressure  # conversion to Pascals

    rho = 1800 # as quoted by Microspheres and Nanospheres  # kgm^3
    dm = 0.372e-9  # m O'Hanlon, 2003
    T0 = 300  # kelvin
    kB = Boltzmann  # m^2 kg s^-2 K-1
    eta = 18.27e-6  # Pa s, viscosity of air

    method = method.lower()
    if method == ""rashid"":
        radius = (0.619 * 9 * pi * eta * dm**2) / \
                 (_np.sqrt(2) * rho * kB * T0) * (Pressure/Gamma0)
        
    m_air = 4.81e-26 # molecular mass of air is 28.97 g/mol and Avogadro's Number 6.0221409^23
    if method == ""chang"":
        vbar = (8*kB*T0/(pi*m_air))**0.5
        radius = 16/(rho*pi*vbar)*(Pressure/Gamma0)/4 # CORRECTION FACTOR OF 4 APPLIED!!!!
    # see section 4.1.1 of Muddassar Rashid's 2016 Thesis for
    # derivation of this
    # see also page 132 of Jan Giesler's Thesis
    err_radius = radius * \
        _np.sqrt(((PressureErr * Pressure) / Pressure)
                 ** 2 + (Gamma0Err / Gamma0)**2)
    mass = rho * ((4 * pi * radius**3) / 3)
    err_mass = mass * 3 * err_radius / radius
    conversionFactor = _np.sqrt(A * mass / (4 * kB * T0 * Gamma0))
    err_conversionFactor = conversionFactor * \
        _np.sqrt((AErr / A)**2 + (err_mass / mass)
                 ** 2 + (Gamma0Err / Gamma0)**2)
    return [radius, mass, conversionFactor], [err_radius, err_mass, err_conversionFactor]"
2901,"def get_ZXY_freqs(Data, zfreq, xfreq, yfreq, bandwidth=5000):
    """"""
    Determines the exact z, x and y peak frequencies from approximate
    frequencies by finding the highest peak in the PSD ""close to"" the
    approximate peak frequency. By ""close to"" I mean within the range:
    approxFreq - bandwidth/2 to approxFreq + bandwidth/2

    Parameters
    ----------
    Data : DataObject
        DataObject containing the data for which you want to determine the
        z, x and y frequencies.
    zfreq : float
        An approximate frequency for the z peak
    xfreq : float
        An approximate frequency for the z peak
    yfreq : float
        An approximate frequency for the z peak
    bandwidth : float, optional
        The bandwidth around the approximate peak to look for the actual peak. The default value is 5000

    Returns
    -------
    trapfreqs : list
        List containing the trap frequencies in the following order (z, x, y)
    """"""
    trapfreqs = []
    for freq in [zfreq, xfreq, yfreq]:
        z_f_fit_lower = take_closest(Data.freqs, freq - bandwidth / 2)
        z_f_fit_upper = take_closest(Data.freqs, freq + bandwidth / 2)
        z_indx_fit_lower = int(_np.where(Data.freqs == z_f_fit_lower)[0][0])
        z_indx_fit_upper = int(_np.where(Data.freqs == z_f_fit_upper)[0][0])

        z_index_OmegaTrap = _np.where(Data.PSD == max(
            Data.PSD[z_indx_fit_lower:z_indx_fit_upper]))[0][0]
        # find highest point in region about guess for trap frequency
        # use that as guess for trap frequency and recalculate region
        # about the trap frequency
        z_OmegaTrap = Data.freqs[z_index_OmegaTrap]
        trapfreqs.append(z_OmegaTrap)
    return trapfreqs"
2902,"def get_ZXY_data(Data, zf, xf, yf, FractionOfSampleFreq=1,
                 zwidth=10000, xwidth=5000, ywidth=5000,
                 filterImplementation=""filtfilt"",
                 timeStart=None, timeEnd=None,
                 NPerSegmentPSD=1000000,
                 MakeFig=True, show_fig=True):
    """"""
    Given a Data object and the frequencies of the z, x and y peaks (and some
    optional parameters for the created filters) this function extracts the
    individual z, x and y signals (in volts) by creating IIR filters and filtering
    the Data.

    Parameters
    ----------
    Data : DataObject
        DataObject containing the data for which you want to extract the
        z, x and y signals.
    zf : float
        The frequency of the z peak in the PSD
    xf : float
        The frequency of the x peak in the PSD
    yf : float
        The frequency of the y peak in the PSD
    FractionOfSampleFreq : integer, optional
        The fraction of the sample frequency to sub-sample the data by.
        This sometimes needs to be done because a filter with the appropriate
        frequency response may not be generated using the sample rate at which
        the data was taken. Increasing this number means the x, y and z signals
        produced by this function will be sampled at a lower rate but a higher
        number means a higher chance that the filter produced will have a nice
        frequency response.
    zwidth : float, optional
        The width of the pass-band of the IIR filter to be generated to
        filter Z.
    xwidth : float, optional
        The width of the pass-band of the IIR filter to be generated to
        filter X.
    ywidth : float, optional
        The width of the pass-band of the IIR filter to be generated to
        filter Y.
    filterImplementation : string, optional
        filtfilt or lfilter - use scipy.filtfilt or lfilter
        default: filtfilt
    timeStart : float, optional
        Starting time for filtering
    timeEnd : float, optional
        Ending time for filtering
    show_fig : bool, optional
        If True - plot unfiltered and filtered PSD for z, x and y.
        If False - don't plot anything

    Returns
    -------
    zdata : ndarray
        Array containing the z signal in volts with time.
    xdata : ndarray
        Array containing the x signal in volts with time.
    ydata : ndarray
        Array containing the y signal in volts with time.
    timedata : ndarray
        Array containing the time data to go with the z, x, and y signal.
    """"""
    if timeStart == None:
        timeStart = Data.timeStart
    if timeEnd == None:
        timeEnd = Data.timeEnd

    time = Data.time.get_array()

    StartIndex = _np.where(time == take_closest(time, timeStart))[0][0]
    EndIndex = _np.where(time == take_closest(time, timeEnd))[0][0]

    SAMPLEFREQ = Data.SampleFreq / FractionOfSampleFreq

    if filterImplementation == ""filtfilt"":
        ApplyFilter = scipy.signal.filtfilt
    elif filterImplementation == ""lfilter"":
        ApplyFilter = scipy.signal.lfilter
    else:
        raise ValueError(""filterImplementation must be one of [filtfilt, lfilter] you entered: {}"".format(
            filterImplementation))

    input_signal = Data.voltage[StartIndex: EndIndex][0::FractionOfSampleFreq]

    bZ, aZ = make_butterworth_bandpass_b_a(zf, zwidth, SAMPLEFREQ)
    print(""filtering Z"")
    zdata = ApplyFilter(bZ, aZ, input_signal)

    if(_np.isnan(zdata).any()):
        raise ValueError(
            ""Value Error: FractionOfSampleFreq must be higher, a sufficiently small sample frequency should be used to produce a working IIR filter."")

    bX, aX = make_butterworth_bandpass_b_a(xf, xwidth, SAMPLEFREQ)
    print(""filtering X"")
    xdata = ApplyFilter(bX, aX, input_signal)

    if(_np.isnan(xdata).any()):
        raise ValueError(
            ""Value Error: FractionOfSampleFreq must be higher, a sufficiently small sample frequency should be used to produce a working IIR filter."")

    bY, aY = make_butterworth_bandpass_b_a(yf, ywidth, SAMPLEFREQ)
    print(""filtering Y"")
    ydata = ApplyFilter(bY, aY, input_signal)

    if(_np.isnan(ydata).any()):
        raise ValueError(
            ""Value Error: FractionOfSampleFreq must be higher, a sufficiently small sample frequency should be used to produce a working IIR filter."")

    if MakeFig == True:        
        f, PSD = scipy.signal.welch(
            input_signal, SAMPLEFREQ, nperseg=NPerSegmentPSD)
        f_z, PSD_z = scipy.signal.welch(zdata, SAMPLEFREQ, nperseg=NPerSegmentPSD)
        f_y, PSD_y = scipy.signal.welch(ydata, SAMPLEFREQ, nperseg=NPerSegmentPSD)
        f_x, PSD_x = scipy.signal.welch(xdata, SAMPLEFREQ, nperseg=NPerSegmentPSD)
        fig, ax = _plt.subplots(figsize=properties[""default_fig_size""])
        ax.plot(f, PSD)
        ax.plot(f_z, PSD_z, label=""z"")
        ax.plot(f_x, PSD_x, label=""x"")
        ax.plot(f_y, PSD_y, label=""y"")
        ax.legend(loc=""best"")
        ax.semilogy()
        ax.set_xlim([zf - zwidth, yf + ywidth])
    else:
        fig = None
        ax = None
    if show_fig == True:
        _plt.show()
    timedata = time[StartIndex: EndIndex][0::FractionOfSampleFreq]
    return zdata, xdata, ydata, timedata, fig, ax"
2903,"def get_ZXY_data_IFFT(Data, zf, xf, yf,
                      zwidth=10000, xwidth=5000, ywidth=5000,
                      timeStart=None, timeEnd=None,
                      show_fig=True):
    """"""
    Given a Data object and the frequencies of the z, x and y peaks (and some
    optional parameters for the created filters) this function extracts the
    individual z, x and y signals (in volts) by creating IIR filters and filtering
    the Data.

    Parameters
    ----------
    Data : DataObject
        DataObject containing the data for which you want to extract the
        z, x and y signals.
    zf : float
        The frequency of the z peak in the PSD
    xf : float
        The frequency of the x peak in the PSD
    yf : float
        The frequency of the y peak in the PSD
    zwidth : float, optional
        The width of the pass-band of the IIR filter to be generated to
        filter Z.
    xwidth : float, optional
        The width of the pass-band of the IIR filter to be generated to
        filter X.
    ywidth : float, optional
        The width of the pass-band of the IIR filter to be generated to
        filter Y.
    timeStart : float, optional
        Starting time for filtering
    timeEnd : float, optional
        Ending time for filtering
    show_fig : bool, optional
        If True - plot unfiltered and filtered PSD for z, x and y.
        If False - don't plot anything

    Returns
    -------
    zdata : ndarray
        Array containing the z signal in volts with time.
    xdata : ndarray
        Array containing the x signal in volts with time.
    ydata : ndarray
        Array containing the y signal in volts with time.
    timedata : ndarray
        Array containing the time data to go with the z, x, and y signal.
    """"""
    if timeStart == None:
        timeStart = Data.timeStart
    if timeEnd == None:
        timeEnd = Data.timeEnd

    time = Data.time.get_array()

    StartIndex = _np.where(time == take_closest(time, timeStart))[0][0]
    EndIndex = _np.where(time == take_closest(time, timeEnd))[0][0]

    SAMPLEFREQ = Data.SampleFreq

    input_signal = Data.voltage[StartIndex: EndIndex]

    zdata = IFFT_filter(input_signal, SAMPLEFREQ, zf -
                        zwidth / 2, zf + zwidth / 2)

    xdata = IFFT_filter(input_signal, SAMPLEFREQ, xf -
                        xwidth / 2, xf + xwidth / 2)

    ydata = IFFT_filter(input_signal, SAMPLEFREQ, yf -
                        ywidth / 2, yf + ywidth / 2)

    if show_fig == True:
        NPerSegment = len(Data.time)
        if NPerSegment > 1e7:
            NPerSegment = int(1e7)
        f, PSD = scipy.signal.welch(
            input_signal, SAMPLEFREQ, nperseg=NPerSegment)
        f_z, PSD_z = scipy.signal.welch(zdata, SAMPLEFREQ, nperseg=NPerSegment)
        f_y, PSD_y = scipy.signal.welch(ydata, SAMPLEFREQ, nperseg=NPerSegment)
        f_x, PSD_x = scipy.signal.welch(xdata, SAMPLEFREQ, nperseg=NPerSegment)
        _plt.plot(f, PSD)
        _plt.plot(f_z, PSD_z, label=""z"")
        _plt.plot(f_x, PSD_x, label=""x"")
        _plt.plot(f_y, PSD_y, label=""y"")
        _plt.legend(loc=""best"")
        _plt.xlim([zf - zwidth, yf + ywidth])
        _plt.xlabel('Frequency (Hz)')
        _plt.ylabel(r'$S_{xx}$ ($V^2/Hz$)')
        _plt.semilogy()
        _plt.title(""filepath = %s"" % (Data.filepath))
        _plt.show()

    timedata = time[StartIndex: EndIndex]
    return zdata, xdata, ydata, timedata"
2904,"def animate(zdata, xdata, ydata,
            conversionFactorArray, timedata,
            BoxSize,
            timeSteps=100, filename=""particle""):
    """"""
    Animates the particle's motion given the z, x and y signal (in Volts)
    and the conversion factor (to convert between V and nm).

    Parameters
    ----------
    zdata : ndarray
        Array containing the z signal in volts with time.
    xdata : ndarray
        Array containing the x signal in volts with time.
    ydata : ndarray
        Array containing the y signal in volts with time.
    conversionFactorArray : ndarray
        Array of 3 values of conversion factors for z, x and y (in units of Volts/Metre)
    timedata : ndarray
        Array containing the time data in seconds.
    BoxSize : float
        The size of the box in which to animate the particle - in nm
    timeSteps : int, optional
        Number of time steps to animate
    filename : string, optional
        filename to create the mp4 under (<filename>.mp4)

    """"""
    timePerFrame = 0.203
    print(""This will take ~ {} minutes"".format(timePerFrame * timeSteps / 60))

    convZ = conversionFactorArray[0] * 1e-9
    convX = conversionFactorArray[1] * 1e-9
    convY = conversionFactorArray[2] * 1e-9
    
    ZBoxStart = -BoxSize  # 1/conv*(_np.mean(zdata)-0.06)
    ZBoxEnd = BoxSize  # 1/conv*(_np.mean(zdata)+0.06)
    XBoxStart = -BoxSize  # 1/conv*(_np.mean(xdata)-0.06)
    XBoxEnd = BoxSize  # 1/conv*(_np.mean(xdata)+0.06)
    YBoxStart = -BoxSize  # 1/conv*(_np.mean(ydata)-0.06)
    YBoxEnd = BoxSize  # 1/conv*(_np.mean(ydata)+0.06)

    FrameInterval = 1  # how many timesteps = 1 frame in animation

    a = 20
    b = 0.6 * a
    myFPS = 7
    myBitrate = 1000000

    fig = _plt.figure(figsize=(a, b))
    ax = fig.add_subplot(111, projection='3d')
    ax.set_title(""{} us"".format(timedata[0] * 1000000))
    ax.set_xlabel('X (nm)')
    ax.set_xlim([XBoxStart, XBoxEnd])
    ax.set_ylabel('Y (nm)')
    ax.set_ylim([YBoxStart, YBoxEnd])
    ax.set_zlabel('Z (nm)')
    ax.set_zlim([ZBoxStart, ZBoxEnd])
    ax.view_init(20, -30)

    #ax.view_init(0, 0)

    def setup_plot():
        XArray = 1 / convX * xdata[0]
        YArray = 1 / convY * ydata[0]
        ZArray = 1 / convZ * zdata[0]
        scatter = ax.scatter(XArray, YArray, ZArray)
        return scatter,

    def animate(i):
        # print ""\r {}"".format(i),
        print(""Frame: {}"".format(i), end=""\r"")
        ax.clear()
        ax.view_init(20, -30)
        ax.set_title(""{} us"".format(int(timedata[i] * 1000000)))
        ax.set_xlabel('X (nm)')
        ax.set_xlim([XBoxStart, XBoxEnd])
        ax.set_ylabel('Y (nm)')
        ax.set_ylim([YBoxStart, YBoxEnd])
        ax.set_zlabel('Z (nm)')
        ax.set_zlim([ZBoxStart, ZBoxEnd])
        XArray = 1 / convX * xdata[i]
        YArray = 1 / convY * ydata[i]
        ZArray = 1 / convZ * zdata[i]
        scatter = ax.scatter(XArray, YArray, ZArray)
        ax.scatter([XArray], [0], [-ZBoxEnd], c='k', alpha=0.9)
        ax.scatter([-XBoxEnd], [YArray], [0], c='k', alpha=0.9)
        ax.scatter([0], [YBoxEnd], [ZArray], c='k', alpha=0.9)

        Xx, Yx, Zx, Xy, Yy, Zy, Xz, Yz, Zz = [], [], [], [], [], [], [], [], []

        for j in range(0, 30):

            Xlast = 1 / convX * xdata[i - j]
            Ylast = 1 / convY * ydata[i - j]
            Zlast = 1 / convZ * zdata[i - j]

            Alpha = 0.5 - 0.05 * j
            if Alpha > 0:
                ax.scatter([Xlast], [0 + j * 10],
                           [-ZBoxEnd], c='grey', alpha=Alpha)
                ax.scatter([-XBoxEnd], [Ylast], [0 - j * 10],
                           c='grey', alpha=Alpha)
                ax.scatter([0 - j * 2], [YBoxEnd],
                           [Zlast], c='grey', alpha=Alpha)

                Xx.append(Xlast)
                Yx.append(0 + j * 10)
                Zx.append(-ZBoxEnd)

                Xy.append(-XBoxEnd)
                Yy.append(Ylast)
                Zy.append(0 - j * 10)

                Xz.append(0 - j * 2)
                Yz.append(YBoxEnd)
                Zz.append(Zlast)

            if j < 15:
                XCur = 1 / convX * xdata[i - j + 1]
                YCur = 1 / convY * ydata[i - j + 1]
                ZCur = 1 / convZ * zdata[i - j + 1]
                ax.plot([Xlast, XCur], [Ylast, YCur], [Zlast, ZCur], alpha=0.4)

        ax.plot_wireframe(Xx, Yx, Zx, color='grey')
        ax.plot_wireframe(Xy, Yy, Zy, color='grey')
        ax.plot_wireframe(Xz, Yz, Zz, color='grey')

        return scatter,

    anim = _animation.FuncAnimation(fig, animate, int(
        timeSteps / FrameInterval), init_func=setup_plot, blit=True)

    _plt.rcParams['animation.ffmpeg_path'] = '/usr/bin/ffmpeg'
    mywriter = _animation.FFMpegWriter(fps=myFPS, bitrate=myBitrate)
    # , fps = myFPS, bitrate = myBitrate)
    anim.save('{}.mp4'.format(filename), writer=mywriter)
    return None"
2905,"def animate_2Dscatter(x, y, NumAnimatedPoints=50, NTrailPoints=20, 
    xlabel="""", ylabel="""",
    xlims=None, ylims=None, filename=""testAnim.mp4"", 
    bitrate=1e5, dpi=5e2, fps=30, figsize = [6, 6]):
    """"""
    Animates x and y - where x and y are 1d arrays of x and y 
    positions and it plots x[i:i+NTrailPoints] and y[i:i+NTrailPoints]
    against each other and iterates through i. 

    """"""
    fig, ax = _plt.subplots(figsize = figsize)

    alphas = _np.linspace(0.1, 1, NTrailPoints)
    rgba_colors = _np.zeros((NTrailPoints,4))
    # for red the first column needs to be one
    rgba_colors[:,0] = 1.0
    # the fourth column needs to be your alphas
    rgba_colors[:, 3] = alphas


    scatter = ax.scatter(x[0:NTrailPoints], y[0:NTrailPoints], color=rgba_colors)

    if xlims == None:
        xlims = (min(x), max(x))
    if ylims == None:
        ylims = (min(y), max(y))

    ax.set_xlim(xlims)
    ax.set_ylim(ylims)
    ax.set_xlabel(xlabel)
    ax.set_ylabel(ylabel)

    def animate(i, scatter):
        scatter.axes.clear() # clear old scatter object
        scatter = ax.scatter(x[i:i+NTrailPoints], y[i:i+NTrailPoints], color=rgba_colors, animated=True) 
        # create new scatter with updated data
        ax.set_xlim(xlims)
        ax.set_ylim(ylims)
        ax.set_xlabel(xlabel)
        ax.set_ylabel(ylabel)
        return scatter,


    ani = _animation.FuncAnimation(fig, animate, _np.arange(1, NumAnimatedPoints),
                                  interval=25, blit=True, fargs=[scatter])
    ani.save(filename, bitrate=bitrate, dpi=dpi, fps=fps)
    return None"
2906,"def IFFT_filter(Signal, SampleFreq, lowerFreq, upperFreq, PyCUDA = False):
    """"""
    Filters data using fft -> zeroing out fft bins -> ifft

    Parameters
    ----------
    Signal : ndarray
        Signal to be filtered
    SampleFreq : float
        Sample frequency of signal
    lowerFreq : float
        Lower frequency of bandpass to allow through filter
    upperFreq : float
       Upper frequency of bandpass to allow through filter
    PyCUDA : bool, optional
       If True, uses PyCUDA to accelerate the FFT and IFFT
       via using your NVIDIA-GPU
       If False, performs FFT and IFFT with conventional
       scipy.fftpack

    Returns
    -------
    FilteredData : ndarray
        Array containing the filtered data
    """"""
    if PyCUDA==True:
        Signalfft=calc_fft_with_PyCUDA(Signal)
    else:
        print(""starting fft"")
        Signalfft = scipy.fftpack.fft(Signal)
    print(""starting freq calc"")
    freqs = _np.fft.fftfreq(len(Signal)) * SampleFreq
    print(""starting bin zeroing"")
    Signalfft[_np.where(freqs < lowerFreq)] = 0
    Signalfft[_np.where(freqs > upperFreq)] = 0
    if PyCUDA==True:
        FilteredSignal = 2 * calc_ifft_with_PyCUDA(Signalfft)
    else:
        print(""starting ifft"")
        FilteredSignal = 2 * scipy.fftpack.ifft(Signalfft)
    print(""done"")
    return _np.real(FilteredSignal)"
2907,"def calc_fft_with_PyCUDA(Signal):
    """"""
    Calculates the FFT of the passed signal by using
    the scikit-cuda libary which relies on PyCUDA

    Parameters
    ----------
    Signal : ndarray
        Signal to be transformed into Fourier space

    Returns
    -------
    Signalfft : ndarray
        Array containing the signal's FFT
    """"""
    print(""starting fft"")
    Signal = Signal.astype(_np.float32)
    Signal_gpu = _gpuarray.to_gpu(Signal)
    Signalfft_gpu = _gpuarray.empty(len(Signal)//2+1,_np.complex64)
    plan = _Plan(Signal.shape,_np.float32,_np.complex64)
    _fft(Signal_gpu, Signalfft_gpu, plan)
    Signalfft = Signalfft_gpu.get() #only 2N+1 long
    Signalfft = _np.hstack((Signalfft,_np.conj(_np.flipud(Signalfft[1:len(Signal)//2]))))
    print(""fft done"")
    return Signalfft"
2908,"def calc_ifft_with_PyCUDA(Signalfft):
    """"""
    Calculates the inverse-FFT of the passed FFT-signal by 
    using the scikit-cuda libary which relies on PyCUDA

    Parameters
    ----------
    Signalfft : ndarray
        FFT-Signal to be transformed into Real space

    Returns
    -------
    Signal : ndarray
        Array containing the ifft signal
    """"""
    print(""starting ifft"")
    Signalfft = Signalfft.astype(_np.complex64)
    Signalfft_gpu = _gpuarray.to_gpu(Signalfft[0:len(Signalfft)//2+1])
    Signal_gpu = _gpuarray.empty(len(Signalfft),_np.float32)
    plan = _Plan(len(Signalfft),_np.complex64,_np.float32)
    _ifft(Signalfft_gpu, Signal_gpu, plan)
    Signal = Signal_gpu.get()/(2*len(Signalfft)) #normalising as CUDA IFFT is un-normalised
    print(""ifft done"")
    return Signal"
2909,"def butterworth_filter(Signal, SampleFreq, lowerFreq, upperFreq):
    """"""
    Filters data using by constructing a 5th order butterworth
    IIR filter and using scipy.signal.filtfilt, which does
    phase correction after implementing the filter (as IIR 
    filter apply a phase change)

    Parameters
    ----------
    Signal : ndarray
        Signal to be filtered
    SampleFreq : float
        Sample frequency of signal
    lowerFreq : float
        Lower frequency of bandpass to allow through filter
    upperFreq : float
       Upper frequency of bandpass to allow through filter

    Returns
    -------
    FilteredData : ndarray
        Array containing the filtered data
    """"""
    b, a = make_butterworth_b_a(lowerFreq, upperFreq, SampleFreq)
    FilteredSignal = scipy.signal.filtfilt(b, a, Signal)
    return _np.real(FilteredSignal)"
2910,"def make_butterworth_b_a(lowcut, highcut, SampleFreq, order=5, btype='band'):
    """"""
    Generates the b and a coefficients for a butterworth IIR filter.

    Parameters
    ----------
    lowcut : float
        frequency of lower bandpass limit
    highcut : float
        frequency of higher bandpass limit
    SampleFreq : float
        Sample frequency of filter
    order : int, optional
        order of IIR filter. Is 5 by default
    btype : string, optional
        type of filter to make e.g. (band, low, high)

    Returns
    -------
    b : ndarray
        coefficients multiplying the current and past inputs (feedforward coefficients)
    a : ndarray
        coefficients multiplying the past outputs (feedback coefficients)
    """"""
    nyq = 0.5 * SampleFreq
    low = lowcut / nyq
    high = highcut / nyq
    if btype.lower() == 'band':
        b, a = scipy.signal.butter(order, [low, high], btype = btype)
    elif btype.lower() == 'low':
        b, a = scipy.signal.butter(order, low, btype = btype)
    elif btype.lower() == 'high':
        b, a = scipy.signal.butter(order, high, btype = btype)
    else:
        raise ValueError('Filter type unknown')
    return b, a"
2911,"def make_butterworth_bandpass_b_a(CenterFreq, bandwidth, SampleFreq, order=5, btype='band'):
    """"""
    Generates the b and a coefficients for a butterworth bandpass IIR filter.

    Parameters
    ----------
    CenterFreq : float
        central frequency of bandpass
    bandwidth : float
        width of the bandpass from centre to edge
    SampleFreq : float
        Sample frequency of filter
    order : int, optional
        order of IIR filter. Is 5 by default
    btype : string, optional
        type of filter to make e.g. (band, low, high)

    Returns
    -------
    b : ndarray
        coefficients multiplying the current and past inputs (feedforward coefficients)
    a : ndarray
        coefficients multiplying the past outputs (feedback coefficients)
    """"""    
    lowcut = CenterFreq-bandwidth/2
    highcut = CenterFreq+bandwidth/2
    b, a = make_butterworth_b_a(lowcut, highcut, SampleFreq, order, btype)
    return b, a"
2912,"def IIR_filter_design(CentralFreq, bandwidth, transitionWidth, SampleFreq, GainStop=40, GainPass=0.01):
    """"""
    Function to calculate the coefficients of an IIR filter, 
    IMPORTANT NOTE: make_butterworth_bandpass_b_a and make_butterworth_b_a
    can produce IIR filters with higher sample rates and are prefereable
    due to this.

    Parameters
    ----------
    CentralFreq : float
        Central frequency of the IIR filter to be designed
    bandwidth : float
        The width of the passband to be created about the central frequency
    transitionWidth : float
        The width of the transition band between the pass-band and stop-band
    SampleFreq : float
        The sample frequency (rate) of the data to be filtered
    GainStop : float, optional
        The dB of attenuation within the stopband (i.e. outside the passband)
    GainPass : float, optional
        The dB attenuation inside the passband (ideally close to 0 for a bandpass filter)

    Returns
    -------
    b : ndarray
        coefficients multiplying the current and past inputs (feedforward coefficients)
    a : ndarray
        coefficients multiplying the past outputs (feedback coefficients)
    """"""
    NyquistFreq = SampleFreq / 2
    if (CentralFreq + bandwidth / 2 + transitionWidth > NyquistFreq):
        raise ValueError(
            ""Need a higher Sample Frequency for this Central Freq, Bandwidth and transition Width"")

    CentralFreqNormed = CentralFreq / NyquistFreq
    bandwidthNormed = bandwidth / NyquistFreq
    transitionWidthNormed = transitionWidth / NyquistFreq
    bandpass = [CentralFreqNormed - bandwidthNormed /
                2, CentralFreqNormed + bandwidthNormed / 2]
    bandstop = [CentralFreqNormed - bandwidthNormed / 2 - transitionWidthNormed,
                CentralFreqNormed + bandwidthNormed / 2 + transitionWidthNormed]
    print(bandpass, bandstop)
    b, a = scipy.signal.iirdesign(bandpass, bandstop, GainPass, GainStop)
    return b, a"
2913,"def get_freq_response(a, b, show_fig=True, SampleFreq=(2 * pi), NumOfFreqs=500, whole=False):
    """"""
    This function takes an array of coefficients and finds the frequency
    response of the filter using scipy.signal.freqz.
    show_fig sets if the response should be plotted

    Parameters
    ----------
    b : array_like
        Coefficients multiplying the x values (inputs of the filter)

    a : array_like
        Coefficients multiplying the y values (outputs of the filter)
    show_fig : bool, optional
        Verbosity of function (i.e. whether to plot frequency and phase
        response or whether to just return the values.)
        Options (Default is 1):
        False - Do not plot anything, just return values
        True - Plot Frequency and Phase response and return values
    SampleFreq : float, optional
        Sample frequency (in Hz) to simulate (used to convert frequency range
        to normalised frequency range)
    NumOfFreqs : int, optional
        Number of frequencies to use to simulate the frequency and phase
        response of the filter. Default is 500.
    Whole : bool, optional
        Sets whether to plot the whole response (0 to sample freq)
        or just to plot 0 to Nyquist (SampleFreq/2): 
        False - (default) plot 0 to Nyquist (SampleFreq/2)
        True - plot the whole response (0 to sample freq)

    Returns
    -------
    freqList : ndarray
        Array containing the frequencies at which the gain is calculated
    GainArray : ndarray
        Array containing the gain in dB of the filter when simulated
        (20*log_10(A_out/A_in))
    PhaseDiffArray : ndarray
        Array containing the phase response of the filter - phase
        difference between the input signal and output signal at
        different frequencies
    """"""
    w, h = scipy.signal.freqz(b=b, a=a, worN=NumOfFreqs, whole=whole)
    freqList = w / (pi) * SampleFreq / 2.0
    himag = _np.array([hi.imag for hi in h])
    GainArray = 20 * _np.log10(_np.abs(h))
    PhaseDiffArray = _np.unwrap(_np.arctan2(_np.imag(h), _np.real(h)))

    fig1 = _plt.figure()
    ax1 = fig1.add_subplot(111)
    ax1.plot(freqList, GainArray, '-', label=""Specified Filter"")
    ax1.set_title(""Frequency Response"")
    if SampleFreq == 2 * pi:
        ax1.set_xlabel((""$\Omega$ - Normalized frequency ""
                       ""($\pi$=Nyquist Frequency)""))
    else:
        ax1.set_xlabel(""frequency (Hz)"")
    ax1.set_ylabel(""Gain (dB)"")
    ax1.set_xlim([0, SampleFreq / 2.0])
    if show_fig == True:
        _plt.show()
    fig2 = _plt.figure()
    ax2 = fig2.add_subplot(111)
    ax2.plot(freqList, PhaseDiffArray, '-', label=""Specified Filter"")
    ax2.set_title(""Phase Response"")
    if SampleFreq == 2 * pi:
        ax2.set_xlabel((""$\Omega$ - Normalized frequency ""
                       ""($\pi$=Nyquist Frequency)""))
    else:
        ax2.set_xlabel(""frequency (Hz)"")

    ax2.set_ylabel(""Phase Difference"")
    ax2.set_xlim([0, SampleFreq / 2.0])
    if show_fig == True:
        _plt.show()
    return freqList, GainArray, PhaseDiffArray, fig1, ax1, fig2, ax2"
2914,"def multi_plot_PSD(DataArray, xlim=[0, 500], units=""kHz"", LabelArray=[], ColorArray=[], alphaArray=[], show_fig=True):
    """"""
    plot the pulse spectral density for multiple data sets on the same
    axes.

    Parameters
    ----------
    DataArray : array-like
        array of DataObject instances for which to plot the PSDs
    xlim : array-like, optional
        2 element array specifying the lower and upper x limit for which to
        plot the Power Spectral Density
    units : string
        units to use for the x axis
    LabelArray : array-like, optional
        array of labels for each data-set to be plotted
    ColorArray : array-like, optional
        array of colors for each data-set to be plotted
    show_fig : bool, optional
       If True runs plt.show() before returning figure
       if False it just returns the figure object.
       (the default is True, it shows the figure)

    Returns
    -------
    fig : matplotlib.figure.Figure object
        The figure object created
    ax : matplotlib.axes.Axes object
        The axes object created
    """"""
    unit_prefix = units[:-2] # removed the last 2 chars
    if LabelArray == []:
        LabelArray = [""DataSet {}"".format(i)
                      for i in _np.arange(0, len(DataArray), 1)]
    if ColorArray == []:
        ColorArray = _np.empty(len(DataArray))
        ColorArray = list(ColorArray)
        for i, ele in enumerate(ColorArray):
            ColorArray[i] = None    

    if alphaArray == []:
        alphaArray = _np.empty(len(DataArray))
        alphaArray = list(alphaArray)
        for i, ele in enumerate(alphaArray):
            alphaArray[i] = None    

            
    fig = _plt.figure(figsize=properties['default_fig_size'])
    ax = fig.add_subplot(111)

    for i, data in enumerate(DataArray):
        ax.semilogy(unit_conversion(data.freqs, unit_prefix), data.PSD, label=LabelArray[i], color=ColorArray[i], alpha=alphaArray[i])
            
    ax.set_xlabel(""Frequency ({})"".format(units))
    ax.set_xlim(xlim)
    ax.grid(which=""major"")
    legend = ax.legend(loc=""best"", frameon = 1)
    frame = legend.get_frame()
    frame.set_facecolor('white')
    frame.set_edgecolor('white')
    ax.set_ylabel(""PSD ($v^2/Hz$)"")

    _plt.title('filedir=%s' % (DataArray[0].filedir))

    if show_fig == True:
        _plt.show()
    return fig, ax"
2915,"def multi_plot_time(DataArray, SubSampleN=1, units='s', xlim=None, ylim=None, LabelArray=[], show_fig=True):
    """"""
    plot the time trace for multiple data sets on the same axes.

    Parameters
    ----------
    DataArray : array-like
        array of DataObject instances for which to plot the PSDs
    SubSampleN : int, optional
        Number of intervals between points to remove (to sub-sample data so
        that you effectively have lower sample rate to make plotting easier
        and quicker.
    xlim : array-like, optional
        2 element array specifying the lower and upper x limit for which to
        plot the time signal
    LabelArray : array-like, optional
        array of labels for each data-set to be plotted
    show_fig : bool, optional
       If True runs plt.show() before returning figure
       if False it just returns the figure object.
       (the default is True, it shows the figure) 

    Returns
    -------
    fig : matplotlib.figure.Figure object
        The figure object created
    ax : matplotlib.axes.Axes object
        The axes object created
    """"""
    unit_prefix = units[:-1] # removed the last char
    if LabelArray == []:
        LabelArray = [""DataSet {}"".format(i)
                      for i in _np.arange(0, len(DataArray), 1)]
    fig = _plt.figure(figsize=properties['default_fig_size'])
    ax = fig.add_subplot(111)
    
    for i, data in enumerate(DataArray):
        ax.plot(unit_conversion(data.time.get_array()[::SubSampleN], unit_prefix), data.voltage[::SubSampleN],
                alpha=0.8, label=LabelArray[i])
    ax.set_xlabel(""time (s)"")
    if xlim != None:
        ax.set_xlim(xlim)
    if ylim != None:
        ax.set_ylim(ylim)
    ax.grid(which=""major"")
    legend = ax.legend(loc=""best"", frameon = 1)
    frame = legend.get_frame()
    frame.set_facecolor('white')
    frame.set_edgecolor('white')

    ax.set_ylabel(""voltage (V)"")
    if show_fig == True:
        _plt.show()
    return fig, ax"
2916,"def multi_subplots_time(DataArray, SubSampleN=1, units='s', xlim=None, ylim=None, LabelArray=[], show_fig=True):
    """"""
    plot the time trace on multiple axes

    Parameters
    ----------
    DataArray : array-like
        array of DataObject instances for which to plot the PSDs
    SubSampleN : int, optional
        Number of intervals between points to remove (to sub-sample data so
        that you effectively have lower sample rate to make plotting easier
        and quicker.
    xlim : array-like, optional
        2 element array specifying the lower and upper x limit for which to
        plot the time signal
    LabelArray : array-like, optional
        array of labels for each data-set to be plotted
    show_fig : bool, optional
       If True runs plt.show() before returning figure
       if False it just returns the figure object.
       (the default is True, it shows the figure) 

    Returns
    -------
    fig : matplotlib.figure.Figure object
        The figure object created
    axs : list of matplotlib.axes.Axes objects
        The list of axes object created
    """"""
    unit_prefix = units[:-1] # removed the last char
    NumDataSets = len(DataArray)

    if LabelArray == []:
        LabelArray = [""DataSet {}"".format(i)
                      for i in _np.arange(0, len(DataArray), 1)]

    fig, axs = _plt.subplots(NumDataSets, 1)

    for i, data in enumerate(DataArray):
        axs[i].plot(unit_conversion(data.time.get_array()[::SubSampleN], unit_prefix), data.voltage[::SubSampleN],
                    alpha=0.8, label=LabelArray[i])
        axs[i].set_xlabel(""time ({})"".format(units))
        axs[i].grid(which=""major"")
        axs[i].legend(loc=""best"")
        axs[i].set_ylabel(""voltage (V)"")
        if xlim != None:
            axs[i].set_xlim(xlim)
        if ylim != None:
            axs[i].set_ylim(ylim)
    if show_fig == True:
        _plt.show()
    return fig, axs"
2917,"def arrange_plots_on_one_canvas(FigureAxTupleArray, title='', SubtitleArray = [], show_fig=True):
    """"""
    Arranges plots, given in an array of tuples consisting of fig and axs, 
    onto a subplot-figure consisting of 2 horizontal times the lenght of the
    passed (fig,axs)-array divided by 2 vertical subplots 

    Parameters
    ----------
    FigureAxTupleArray : array-like
        array of Tuples(fig, axs) outputted from the other plotting funtions 
        inside optoanalysis
    title : string, optional
        string for the global title of the overall combined figure 
    SubtitleArray : array-like, optional
        array of titles for each figure-set to be plotted, i.e. subplots 
    show_fig : bool, optional
       If True runs plt.show() before returning figure
       if False it just returns the figure object.
       (the default is True, it shows the figure) 

    Returns
    -------
    fig : matplotlib.figure.Figure object
        The figure object created
    axs : list of matplotlib.axes.Axes objects
        The list of axes object created
    """"""
    if SubtitleArray == []:
        SubtitleArray = [""Plot {}"".format(i)
                      for i in _np.arange(0, len(FigureAxTupleArray), 1)]
    SingleFigSize = FigureAxTupleArray[0][0].get_size_inches()
    combinedFig=_plt.figure(figsize=(2*SingleFigSize[0],_np.ceil(len(FigureAxTupleArray)/2)*SingleFigSize[1]))
    for index in range(len(FigureAxTupleArray)):
        individualPlot = FigureAxTupleArray[index]
        individualPlot[0].set_size_inches((2*SingleFigSize[0],_np.ceil(len(FigureAxTupleArray)/2)*SingleFigSize[1]))
        ax = individualPlot[1]
        ax.set_title(SubtitleArray[index])
        ax.remove()
        ax.figure = combinedFig
        ax.change_geometry(int(_np.ceil(len(FigureAxTupleArray)/2)),2,1+index)
        combinedFig.axes.append(ax)
        combinedFig.add_axes(ax)
        #_plt.close(individualPlot[0])
    combinedFig.subplots_adjust(hspace=.4)
    combinedFig.suptitle(title)
    if show_fig == True:
        _plt.show()
    return combinedFig"
2918,"def calc_PSD(Signal, SampleFreq, NPerSegment=1000000, window=""hann""):
    """"""
    Extracts the pulse spectral density (PSD) from the data.

    Parameters
    ----------
    Signal : array-like
        Array containing the signal to have the PSD calculated for
    SampleFreq : float
        Sample frequency of the signal array
    NPerSegment : int, optional
        Length of each segment used in scipy.welch
        default = 1000000
    window : str or tuple or array_like, optional
        Desired window to use. See get_window for a list of windows
        and required parameters. If window is array_like it will be
        used directly as the window and its length will be used for
        nperseg.
        default = ""hann""

    Returns
    -------
    freqs : ndarray
            Array containing the frequencies at which the PSD has been
            calculated
    PSD : ndarray
            Array containing the value of the PSD at the corresponding
            frequency value in V**2/Hz
    """"""
    freqs, PSD = scipy.signal.welch(Signal, SampleFreq,
                                    window=window, nperseg=NPerSegment)
    PSD = PSD[freqs.argsort()]
    freqs.sort()
    return freqs, PSD"
2919,"def calc_autocorrelation(Signal, FFT=False, PyCUDA=False):
    """"""
    Calculates the autocorrelation from a given Signal via using
    

    Parameters
    ----------
    Signal : array-like
        Array containing the signal to have the autocorrelation calculated for
    FFT : optional, bool
        Uses FFT to accelerate autocorrelation calculation, but assumes certain
        certain periodicity on the signal to autocorrelate. Zero-padding is added
        to account for this periodicity assumption.
    PyCUDA : bool, optional
       If True, uses PyCUDA to accelerate the FFT and IFFT
       via using your NVIDIA-GPU
       If False, performs FFT and IFFT with conventional
       scipy.fftpack

    Returns
    -------
    Autocorrelation : ndarray
            Array containing the value of the autocorrelation evaluated
            at the corresponding amount of shifted array-index.
    """"""
    if FFT==True:
        Signal_padded = scipy.fftpack.ifftshift((Signal-_np.average(Signal))/_np.std(Signal))
        n, = Signal_padded.shape
        Signal_padded = _np.r_[Signal_padded[:n//2], _np.zeros_like(Signal_padded), Signal_padded[n//2:]]
        if PyCUDA==True:
            f = calc_fft_with_PyCUDA(Signal_padded)
        else:
            f = scipy.fftpack.fft(Signal_padded)
        p = _np.absolute(f)**2
        if PyCUDA==True:
            autocorr = calc_ifft_with_PyCUDA(p)
        else:
            autocorr = scipy.fftpack.ifft(p)
        return _np.real(autocorr)[:n//2]/(_np.arange(n//2)[::-1]+n//2)
    else:
        Signal = Signal - _np.mean(Signal)
        autocorr = scipy.signal.correlate(Signal, Signal, mode='full')
        return autocorr[autocorr.size//2:]/autocorr[autocorr.size//2]"
2920,"def _GetRealImagArray(Array):
    """"""
    Returns the real and imaginary components of each element in an array and returns them in 2 resulting arrays.

    Parameters
    ----------
    Array : ndarray
        Input array

    Returns
    -------
    RealArray : ndarray
        The real components of the input array
    ImagArray : ndarray
        The imaginary components of the input array
    """"""
    ImagArray = _np.array([num.imag for num in Array])
    RealArray = _np.array([num.real for num in Array])
    return RealArray, ImagArray"
2921,"def _GetComplexConjugateArray(Array):
    """"""
    Calculates the complex conjugate of each element in an array and returns the resulting array.

    Parameters
    ----------
    Array : ndarray
        Input array

    Returns
    -------
    ConjArray : ndarray
        The complex conjugate of the input array.
    """"""
    ConjArray = _np.array([num.conj() for num in Array])
    return ConjArray"
2922,"def fm_discriminator(Signal):
    """"""
    Calculates the digital FM discriminator from a real-valued time signal.

    Parameters
    ----------
    Signal : array-like
        A real-valued time signal

    Returns
    -------
    fmDiscriminator : array-like
        The digital FM discriminator of the argument signal
    """"""
    S_analytic = _hilbert(Signal)
    S_analytic_star = _GetComplexConjugateArray(S_analytic)
    S_analytic_hat = S_analytic[1:] * S_analytic_star[:-1]
    R, I = _GetRealImagArray(S_analytic_hat)
    fmDiscriminator = _np.arctan2(I, R)
    return fmDiscriminator"
2923,"def _is_this_a_collision(ArgList):
    """"""
    Detects if a particular point is during collision after effect (i.e. a phase shift) or not.

    Parameters
    ----------
    ArgList : array_like
        Contains the following elements:
            value : float
                value of the FM discriminator
            mean_fmd : float
                the mean value of the FM discriminator
            tolerance : float
                The tolerance in percentage that it must be away from the mean value for it
                to be counted as a collision event.

    Returns
    -------
    is_this_a_collision : bool
        True if this is a collision event, false if not.
    """"""
    value, mean_fmd, tolerance = ArgList
    if not _approx_equal(mean_fmd, value, tolerance):
        return True
    else:
        return False"
2924,"def find_collisions(Signal, tolerance=50):
    """"""
    Finds collision events in the signal from the shift in phase of the signal.

    Parameters
    ----------
    Signal : array_like
        Array containing the values of the signal of interest containing a single frequency.
    tolerance : float
        Percentage tolerance, if the value of the FM Discriminator varies from the mean by this
        percentage it is counted as being during a collision event (or the aftermath of an event).

    Returns
    -------
    Collisions : ndarray
        Array of booleans, true if during a collision event, false otherwise.
    """"""
    fmd = fm_discriminator(Signal)
    mean_fmd = _np.mean(fmd)

    Collisions = [_is_this_a_collision(
        [value, mean_fmd, tolerance]) for value in fmd]

    return Collisions"
2925,"def count_collisions(Collisions):
    """"""
    Counts the number of unique collisions and gets the collision index.

    Parameters
    ----------
    Collisions : array_like
        Array of booleans, containing true if during a collision event, false otherwise.

    Returns
    -------
    CollisionCount : int
        Number of unique collisions
    CollisionIndicies : list
        Indicies of collision occurance
    """"""
    CollisionCount = 0
    CollisionIndicies = []
    lastval = True
    for i, val in enumerate(Collisions):
        if val == True and lastval == False:
            CollisionIndicies.append(i)
            CollisionCount += 1
        lastval = val
    return CollisionCount, CollisionIndicies"
2926,"def parse_orgtable(lines):
    """"""
    Parse an org-table (input as a list of strings split by newline)
    into a Pandas data frame.

    Parameters
    ----------
    lines : string
        an org-table input as a list of strings split by newline
    
    Returns
    -------
    dataframe : pandas.DataFrame
        A data frame containing the org-table's data
    """"""
    def parseline(l):
        w = l.split('|')[1:-1]
        return [wi.strip() for wi in w]
    columns = parseline(lines[0])

    data = []
    for line in lines[2:]:
        data.append(map(str, parseline(line)))
    dataframe = _pd.DataFrame(data=data, columns=columns)
    dataframe.set_index(""RunNo"")
    return dataframe"
2927,"def plot_3d_dist(Z, X, Y, N=1000, AxisOffset=0, Angle=-40, LowLim=None, HighLim=None, show_fig=True):
    """"""
    Plots Z, X and Y as a 3d scatter plot with heatmaps of each axis pair.

    Parameters
    ----------
    Z : ndarray
        Array of Z positions with time
    X : ndarray
        Array of X positions with time
    Y : ndarray
        Array of Y positions with time
    N : optional, int
        Number of time points to plot (Defaults to 1000)
    AxisOffset : optional, double
        Offset to add to each axis from the data - used to get a better view
        of the heat maps (Defaults to 0)
    LowLim : optional, double
        Lower limit of x, y and z axis
    HighLim : optional, double
        Upper limit of x, y and z axis
    show_fig : optional, bool
        Whether to show the produced figure before returning

    Returns
    -------
    fig : matplotlib.figure.Figure object
        The figure object created
    ax : matplotlib.axes.Axes object
        The subplot object created
    """"""
    angle = Angle
    fig = _plt.figure(figsize=(8, 6))
    ax = fig.add_subplot(111, projection='3d')

    y = Z[0:N]
    x = X[0:N]
    z = Y[0:N]

    ax.scatter(x, y, z, alpha=0.3)

    xlim = ax.get_xlim()
    ylim = ax.get_ylim()
    zlim = ax.get_zlim()
    if LowLim != None:
        lowLim = LowLim - AxisOffset
    else:
        lowLim = min([xlim[0], ylim[0], zlim[0]]) - AxisOffset
    if HighLim != None:
        highLim = HighLim + AxisOffset
    else:
        highLim = max([xlim[1], ylim[1], zlim[1]]) + AxisOffset
    ax.set_xlim([lowLim, highLim])
    ax.set_ylim([lowLim, highLim])
    ax.set_zlim([lowLim, highLim])
    ax.set_xlabel(""x"")
    ax.set_ylabel(""z"")
    ax.set_zlabel(""y"")
    ax.view_init(30, angle)

    h, yedges, zedges = _np.histogram2d(y, z, bins=50)
    h = h.transpose()
    normalized_map = _plt.cm.Blues(h/h.max())
    yy, zz = _np.meshgrid(yedges, zedges)
    xpos = lowLim # Plane of histogram
    xflat = _np.full_like(yy, xpos) 
    p = ax.plot_surface(xflat, yy, zz, facecolors=normalized_map, rstride=1, cstride=1, shade=False)

    h, xedges, zedges = _np.histogram2d(x, z, bins=50)
    h = h.transpose()
    normalized_map = _plt.cm.Blues(h/h.max())
    xx, zz = _np.meshgrid(xedges, zedges)
    ypos = highLim # Plane of histogram
    yflat = _np.full_like(xx, ypos) 
    p = ax.plot_surface(xx, yflat, zz, facecolors=normalized_map, rstride=1, cstride=1, shade=False)

    h, yedges, xedges = _np.histogram2d(y, x, bins=50)
    h = h.transpose()
    normalized_map = _plt.cm.Blues(h/h.max())
    yy, xx = _np.meshgrid(yedges, xedges)
    zpos = lowLim # Plane of histogram
    zflat = _np.full_like(yy, zpos) 
    p = ax.plot_surface(xx, yy, zflat, facecolors=normalized_map, rstride=1, cstride=1, shade=False)
    if show_fig == True:
        _plt.show()
    return fig, ax"
2928,"def multi_plot_3d_dist(ZXYData, N=1000, AxisOffset=0, Angle=-40, LowLim=None, HighLim=None, ColorArray=None, alphaLevel=0.3, show_fig=True):
    """"""
    Plots serveral Z, X and Y datasets as a 3d scatter plot with heatmaps of each axis pair in each dataset.

    Parameters
    ----------
    ZXYData : ndarray
        Array of arrays containing Z, X, Y data e.g. [[Z1, X1, Y1], [Z2, X2, Y2]]
    N : optional, int
        Number of time points to plot (Defaults to 1000)
    AxisOffset : optional, double
        Offset to add to each axis from the data - used to get a better view
        of the heat maps (Defaults to 0)
    LowLim : optional, double
        Lower limit of x, y and z axis
    HighLim : optional, double
        Upper limit of x, y and z axis
    show_fig : optional, bool
        Whether to show the produced figure before returning

    Returns
    -------
    fig : matplotlib.figure.Figure object
        The figure object created
    ax : matplotlib.axes.Axes object
        The subplot object created
    """"""
    if ZXYData.shape[1] != 3:
        raise ValueError(""Parameter ZXYData should be an array of length-3 arrays containing arrays of Z, X and Y data"")
    if ColorArray != None:
        if ZXYData.shape[0] != len(ColorArray):
            raise ValueError(""Parameter ColorArray should be the same lenth as ZXYData"")
    else:
        ColorArray = list(mcolours.BASE_COLORS.keys())
        #ColorArray = ['b', 'g', 'r']
        #    ColorMapArray = [_plt.cm.Blues, _plt.cm.Greens, _plt.cm.Reds]
        if ZXYData.shape[0] > len(ColorArray):
            raise NotImplementedError(""Only {} datasets can be plotted with automatic colors"".format(len(ColorArray)))
        
    angle = Angle
    fig = _plt.figure(figsize=(8, 6))
    ax = fig.add_subplot(111, projection='3d')

    for datindx, ZXY in enumerate(ZXYData):
        y = ZXY[0][0:N]
        x = ZXY[1][0:N]
        z = ZXY[2][0:N]
        ax.scatter(x, y, z, alpha=alphaLevel, color=ColorArray[datindx])
        
    xlim = ax.get_xlim()
    ylim = ax.get_ylim()
    zlim = ax.get_zlim()
    if LowLim != None:
        lowLim = LowLim - AxisOffset
    else:
        lowLim = min([xlim[0], ylim[0], zlim[0]]) - AxisOffset
    if HighLim != None:
        highLim = HighLim + AxisOffset
    else:
        highLim = max([xlim[1], ylim[1], zlim[1]]) + AxisOffset
    ax.set_xlim([lowLim, highLim])
    ax.set_ylim([lowLim, highLim])
    ax.set_zlim([lowLim, highLim])

    for datindx, ZXY in enumerate(ZXYData):
        y = ZXY[0][0:N]
        x = ZXY[1][0:N]
        z = ZXY[2][0:N]
        
        #h, yedges, zedges = _np.histogram2d(y, z, bins=50)
        #h = h.transpose()
        #normalized_map = ColorMapArray[datindx](h/h.max())
        #yy, zz = _np.meshgrid(yedges, zedges)
        xpos = lowLim # Plane of histogram
        #xflat = _np.full_like(yy, xpos) 
        #p = ax.plot_surface(xflat, yy, zz, facecolors=normalized_map, rstride=1, cstride=1, shade=False)
        xflat = _np.full_like(y, xpos) 
        ax.scatter(xflat, y, z, color=ColorArray[datindx], alpha=alphaLevel)
        
        #h, xedges, zedges = _np.histogram2d(x, z, bins=50)
        #h = h.transpose()
        #normalized_map = ColorMapArray[datindx](h/h.max())
        #xx, zz = _np.meshgrid(xedges, zedges)
        ypos = highLim # Plane of histogram
        #yflat = _np.full_like(xx, ypos) 
        #p = ax.plot_surface(xx, yflat, zz, facecolors=normalized_map, rstride=1, cstride=1, shade=False)
        yflat = _np.full_like(x, ypos) 
        ax.scatter(x, yflat, z, color=ColorArray[datindx], alpha=alphaLevel)
        
        #h, yedges, xedges = _np.histogram2d(y, x, bins=50)
        #h = h.transpose()
        #normalized_map = ColorMapArray[datindx](h/h.max())
        #yy, xx = _np.meshgrid(yedges, xedges)
        zpos = lowLim # Plane of histogram
        #zflat = _np.full_like(yy, zpos) 
        #p = ax.plot_surface(xx, yy, zflat, facecolors=normalized_map, rstride=1, cstride=1, shade=False)
        zflat = _np.full_like(y, zpos) 
        ax.scatter(x, y, zflat, color=ColorArray[datindx], alpha=alphaLevel)
    
    ax.set_xlabel(""x"")
    ax.set_ylabel(""z"")
    ax.set_zlabel(""y"")
    ax.view_init(30, angle)
    
    if show_fig == True:
        _plt.show()
    return fig, ax"
2929,"def steady_state_potential(xdata,HistBins=100):
    """""" 
    Calculates the steady state potential. Used in 
    fit_radius_from_potentials.

    Parameters
    ----------
    xdata : ndarray
        Position data for a degree of freedom
    HistBins : int
        Number of bins to use for histogram
        of xdata. Number of position points
        at which the potential is calculated.

    Returns
    -------
    position : ndarray
        positions at which potential has been 
        calculated
    potential : ndarray
        value of potential at the positions above
    
    """"""  
    import numpy as _np
    
    pops=_np.histogram(xdata,HistBins)[0]
    bins=_np.histogram(xdata,HistBins)[1]
    bins=bins[0:-1]
    bins=bins+_np.mean(_np.diff(bins))
    
    #normalise pops
    pops=pops/float(_np.sum(pops))
    
    return bins,-_np.log(pops)"
2930,"def dynamical_potential(xdata, dt, order=3):
    """"""
    Computes potential from spring function

    Parameters
    ----------
    xdata : ndarray
        Position data for a degree of freedom,
        at which to calculate potential
    dt : float
        time between measurements
    order : int
        order of polynomial to fit

    Returns
    -------
    Potential : ndarray
        valued of potential at positions in
        xdata

    """"""
    import numpy as _np
    adata = calc_acceleration(xdata, dt)
    xdata = xdata[2:] # removes first 2 values as differentiating twice means
    # we have acceleration[n] corresponds to position[n-2]
    
    z=_np.polyfit(xdata,adata,order)
    p=_np.poly1d(z)
    spring_pot=_np.polyint(p)
    return -spring_pot"
2931,"def calc_acceleration(xdata, dt):
    """"""
    Calculates the acceleration from the position
    
    Parameters
    ----------
    xdata : ndarray
        Position data
    dt : float
        time between measurements

    Returns
    -------
    acceleration : ndarray
        values of acceleration from position 
        2 to N.

    """"""
    acceleration = _np.diff(_np.diff(xdata))/dt**2
    return acceleration"
2932,"def fit_radius_from_potentials(z, SampleFreq, Damping, HistBins=100, show_fig=False):
    """"""
    Fits the dynamical potential to the Steady 
    State Potential by varying the Radius.
    
    z : ndarray
        Position data
    SampleFreq : float
        frequency at which the position data was 
        sampled
    Damping : float
        value of damping (in radians/second)
    HistBins : int
        number of values at which to evaluate 
        the steady state potential / perform
        the fitting to the dynamical potential

    Returns
    -------
    Radius : float
        Radius of the nanoparticle
    RadiusError : float
        One Standard Deviation Error in the Radius from the Fit
        (doesn't take into account possible error in damping)
    fig : matplotlib.figure.Figure object
        figure showing fitted dynamical potential and stationary potential
    ax : matplotlib.axes.Axes object
        axes for above figure

    """"""
    dt = 1/SampleFreq
    boltzmann=Boltzmann
    temp=300 # why halved??
    density=1800
    SteadyStatePotnl = list(steady_state_potential(z, HistBins=HistBins))
    yoffset=min(SteadyStatePotnl[1])
    SteadyStatePotnl[1] -= yoffset

    SpringPotnlFunc = dynamical_potential(z, dt)
    SpringPotnl = SpringPotnlFunc(z)
    kBT_Gamma = temp*boltzmann*1/Damping
    
    DynamicPotentialFunc = make_dynamical_potential_func(kBT_Gamma, density, SpringPotnlFunc)
    FitSoln = _curve_fit(DynamicPotentialFunc, SteadyStatePotnl[0], SteadyStatePotnl[1], p0 = 50)
    print(FitSoln)
    popt, pcov = FitSoln
    perr = _np.sqrt(_np.diag(pcov))
    Radius, RadiusError = popt[0], perr[0]

    mass=((4/3)*pi*((Radius*10**-9)**3))*density
    yfit=(kBT_Gamma/mass)
    Y = yfit*SpringPotnl
    
    fig, ax = _plt.subplots()
    ax.plot(SteadyStatePotnl[0], SteadyStatePotnl[1], 'bo', label=""Steady State Potential"")
    _plt.plot(z,Y, 'r-', label=""Dynamical Potential"")
    ax.legend(loc='best')
    ax.set_ylabel('U ($k_{B} T $ Joules)')
    ax.set_xlabel('Distance (mV)')
    _plt.tight_layout()
    if show_fig == True:
        _plt.show()
    return Radius*1e-9, RadiusError*1e-9, fig, ax"
2933,"def make_dynamical_potential_func(kBT_Gamma, density, SpringPotnlFunc):
    """"""
    Creates the function that calculates the potential given
    the position (in volts) and the radius of the particle. 

    Parameters
    ----------
    kBT_Gamma : float
        Value of kB*T/Gamma
    density : float
        density of the nanoparticle
    SpringPotnlFunc : function
        Function which takes the value of position (in volts)
        and returns the spring potential
    
    Returns
    -------
    PotentialFunc : function
        function that calculates the potential given
        the position (in volts) and the radius of the 
        particle.

    """"""
    def PotentialFunc(xdata, Radius):
        """"""
        calculates the potential given the position (in volts) 
        and the radius of the particle.

        Parameters
        ----------
        xdata : ndarray
            Positon data (in volts)
        Radius : float
            Radius in units of nm

        Returns
        -------
        Potential : ndarray
            Dynamical Spring Potential at positions given by xdata
        """"""
        mass = ((4/3)*pi*((Radius*10**-9)**3))*density
        yfit=(kBT_Gamma/mass)
        Y = yfit*SpringPotnlFunc(xdata)
        return Y
    return PotentialFunc"
2934,"def calc_z0_and_conv_factor_from_ratio_of_harmonics(z, z2, NA=0.999):
    """"""
    Calculates the Conversion Factor and physical amplitude of motion in nms 
    by comparison of the ratio of the heights of the z signal and 
    second harmonic of z.

    Parameters
    ----------
    z : ndarray
        array containing z signal in volts
    z2 : ndarray
        array containing second harmonic of z signal in volts
    NA : float
        NA of mirror used in experiment

    Returns
    -------
    z0 : float
        Physical average amplitude of motion in nms
    ConvFactor : float
        Conversion Factor between volts and nms
    """"""
    V1 = calc_mean_amp(z)
    V2 = calc_mean_amp(z2)
    ratio = V2/V1
    beta = 4*ratio
    laserWavelength = 1550e-9 # in m
    k0 = (2*pi)/(laserWavelength)
    WaistSize = laserWavelength/(pi*NA)
    Zr = pi*WaistSize**2/laserWavelength
    z0 = beta/(k0 - 1/Zr)
    ConvFactor = V1/z0
    T0 = 300
    return z0, ConvFactor"
2935,"def calc_mass_from_z0(z0, w0):
    """"""
    Calculates the mass of the particle using the equipartition
    from the angular frequency of the z signal and the average
    amplitude of the z signal in nms.

    Parameters
    ----------
    z0 : float
        Physical average amplitude of motion in nms
    w0 : float
        Angular Frequency of z motion

    Returns
    -------
    mass : float
        mass in kgs
    """"""
    T0 = 300
    mFromEquipartition = Boltzmann*T0/(w0**2 * z0**2)
    return mFromEquipartition"
2936,"def calc_mass_from_fit_and_conv_factor(A, Damping, ConvFactor):
    """"""
    Calculates mass from the A parameter from fitting, the damping from 
    fitting in angular units and the Conversion factor calculated from 
    comparing the ratio of the z signal and first harmonic of z.

    Parameters
    ----------
    A : float
        A factor calculated from fitting
    Damping : float
        damping in radians/second calcualted from fitting
    ConvFactor : float
        conversion factor between volts and nms

    Returns
    -------
    mass : float
        mass in kgs
    """"""
    T0 = 300
    mFromA = 2*Boltzmann*T0/(pi*A) * ConvFactor**2 * Damping
    return mFromA"
2937,"def get_time_slice(time, z, zdot=None, timeStart=None, timeEnd=None):
    """"""
    Get slice of time, z and (if provided) zdot from timeStart to timeEnd.

    Parameters
    ----------
    time : ndarray
        array of time values 
    z : ndarray
        array of z values
    zdot : ndarray, optional
        array of zdot (velocity) values.
    timeStart : float, optional
        time at which to start the slice.
        Defaults to beginnging of time trace
    timeEnd : float, optional
        time at which to end the slide.
        Defaults to end of time trace

    Returns
    -------
    time_sliced : ndarray
        array of time values from timeStart to timeEnd
    z_sliced : ndarray
        array of z values from timeStart to timeEnd
    zdot_sliced : ndarray
        array of zdot values from timeStart to timeEnd.
        None if zdot not provided

    """"""
    if timeStart == None:
        timeStart = time[0]
    if timeEnd == None:
        timeEnd = time[-1]

    StartIndex = _np.where(time == take_closest(time, timeStart))[0][0]
    EndIndex = _np.where(time == take_closest(time, timeEnd))[0][0]

    time_sliced = time[StartIndex:EndIndex]
    z_sliced = z[StartIndex:EndIndex]

    if zdot != None:
        zdot_sliced = zdot[StartIndex:EndIndex]
    else:
        zdot_sliced = None    
    
    return time_sliced, z_sliced, zdot_sliced"
2938,"def unit_conversion(array, unit_prefix, current_prefix=""""):
    """"""
    Converts an array or value to of a certain 
    unit scale to another unit scale.

    Accepted units are:
    E - exa - 1e18
    P - peta - 1e15
    T - tera - 1e12
    G - giga - 1e9
    M - mega - 1e6
    k - kilo - 1e3
    m - milli - 1e-3
    u - micro - 1e-6
    n - nano - 1e-9
    p - pico - 1e-12
    f - femto - 1e-15
    a - atto - 1e-18

    Parameters
    ----------
    array : ndarray
        Array to be converted
    unit_prefix : string
        desired unit (metric) prefix (e.g. nm would be n, ms would be m)
    current_prefix : optional, string
        current prefix of units of data (assumed to be in SI units
        by default (e.g. m or s)

    Returns
    -------
    converted_array : ndarray
        Array multiplied such as to be in the units specified
    """"""
    UnitDict = {
        'E': 1e18,
        'P': 1e15,
        'T': 1e12,
        'G': 1e9,
        'M': 1e6,
        'k': 1e3,
        '': 1,
        'm': 1e-3,
        'u': 1e-6,
        'n': 1e-9,
        'p': 1e-12,
        'f': 1e-15,
        'a': 1e-18,
    }
    try:
        Desired_units = UnitDict[unit_prefix]
    except KeyError:
        raise ValueError(""You entered {} for the unit_prefix, this is not a valid prefix"".format(unit_prefix))
    try:
        Current_units = UnitDict[current_prefix]
    except KeyError:
        raise ValueError(""You entered {} for the current_prefix, this is not a valid prefix"".format(current_prefix))
    conversion_multiplication = Current_units/Desired_units
    converted_array = array*conversion_multiplication
    return converted_array"
2939,"def extract_slices(z, freq, sample_freq, show_plot=False):
    """"""
    Iterates through z trace and pulls out slices of length period_samples
    and assigns them a phase from -180 to 180. Each slice then becomes a column
    in the 2d array that is returned. Such that the row (the first index) refers
    to phase (i.e. dat[0] are all the samples at phase = -180) and the column
    refers to the oscillation number (i.e. dat[:, 0] is the first oscillation).

    Parameters
    ----------
    z : ndarray
        trace of z motion
    freq : float
        frequency of motion
    sample_freq : float
        sample frequency of the z array
    show_plot : bool, optional (default=False)
        if true plots and shows the phase plotted against the positon
        for each oscillation built on top of each other.

    Returns
    -------
    phase : ndarray
        phase (in degrees) for each oscillation
    phase_slices : ndarray
        2d numpy array containing slices as detailed above.

    """"""
    dt = 1/sample_freq # dt between samples
    period = 1/freq # period of oscillation of motion
    period_samples = round(period/dt) # integer number of discrete samples in a period
    number_of_oscillations = int(_np.floor(len(z)/period_samples)) # number of oscillations in z trace


    phase_slices_untransposed = _np.zeros([number_of_oscillations-1, period_samples])

    phase = _np.linspace(-180, 180, period_samples) # phase assigned to samples

    if show_plot == True:
        fig, ax = _plt.subplots()

    for i in range(number_of_oscillations-1): 
        # loops through number of oscillations - 1 pulling out period_samples
        # slices and assigning them a phase from -180 to 180 degrees
        start = i*period_samples # start index of section
        end = (i+1)*period_samples # end index of section
        if show_plot == True:
            _plt.plot(phase, z[start:end]) 
        phase_slices_untransposed[i] = z[start:end] # enter z section as ith row
    
    phase_slices = phase_slices_untransposed.transpose() # swap rows and columns 

    if show_plot == True:
        _plt.show()
    return phase, phase_slices"
2940,"def histogram_phase(phase_slices, phase, histbins=200, show_plot=False):
    """"""
    histograms the phase slices such as to build a histogram of the position
    distribution at each phase value.

    Parameters
    ----------
    phase_slices : ndarray
        2d array containing slices from many oscillations at each phase
    phase : ndarray
        1d array of phases corresponding to slices
    histbins : int, optional (default=200)
        number of bins to use in histogramming data
    show_plot : bool, optional (default=False)
        if true plots and shows the heatmap of the
        phase against the positon distribution

    Returns
    -------
    counts_array : ndarray
        2d array containing the number of counts varying with
        phase and position.
    bin_edges : ndarray
        positions of bin edges

    """"""
    counts_array = _np.zeros([len(phase), histbins])

    histedges = [phase_slices.min(), phase_slices.max()]
    for i, phase_slice in enumerate(phase_slices): # for each value of phase
        counts, bin_edges = _np.histogram(phase_slice, bins=histbins, range=histedges) # histogram the position distribution at that phase
        counts_array[i] = counts
    counts_array = _np.array(counts_array)
    counts_array_transposed = _np.transpose(counts_array).astype(float)

    if show_plot == True:
        fig = _plt.figure(figsize=(12, 6))
        ax = fig.add_subplot(111)
        ax.set_title('Phase Distribution')
        ax.set_xlabel(""phase (°)"")
        ax.set_ylabel(""x"")
        _plt.imshow(counts_array_transposed, cmap='hot', interpolation='nearest', extent=[phase[0], phase[-1], histedges[0], histedges[1]])
        ax.set_aspect('auto')
        _plt.show()

    return counts_array_transposed, bin_edges"
2941,"def get_wigner(z, freq, sample_freq, histbins=200, show_plot=False):
    """"""
    Calculates an approximation to the wigner quasi-probability distribution
    by splitting the z position array into slices of the length of one period
    of the motion. This slice is then associated with phase from -180 to 180
    degrees. These slices are then histogramed in order to get a distribution
    of counts of where the particle is observed at each phase. The 2d array
    containing the counts varying with position and phase is then passed through
    the inverse radon transformation using the Simultaneous Algebraic 
    Reconstruction Technique approximation from the scikit-image package.

    Parameters
    ----------
    z : ndarray
        trace of z motion
    freq : float
        frequency of motion
    sample_freq : float
        sample frequency of the z array
    histbins : int, optional (default=200)
        number of bins to use in histogramming data for each phase
    show_plot : bool, optional (default=False)
        Whether or not to plot the phase distribution

    Returns
    -------
    iradon_output : ndarray
        2d array of size (histbins x histbins)
    bin_centres : ndarray
        positions of the bin centres

    """"""
    
    phase, phase_slices = extract_slices(z, freq, sample_freq, show_plot=False)

    counts_array, bin_edges = histogram_phase(phase_slices, phase, histbins, show_plot=show_plot)

    diff = bin_edges[1] - bin_edges[0]
    bin_centres = bin_edges[:-1] + diff

    iradon_output = _iradon_sart(counts_array, theta=phase)

    #_plt.imshow(iradon_output, extent=[bin_centres[0], bin_centres[-1], bin_centres[0], bin_centres[-1]])
    #_plt.show()

    return iradon_output, bin_centres"
2942,"def plot_wigner3d(iradon_output, bin_centres, bin_centre_units="""", cmap=_cm.cubehelix_r, view=(10, -45), figsize=(10, 10)):
    """"""
    Plots the wigner space representation as a 3D surface plot.

    Parameters
    ----------
    iradon_output : ndarray
        2d array of size (histbins x histbins)
    bin_centres : ndarray
        positions of the bin centres
    bin_centre_units : string, optional (default="""")
        Units in which the bin_centres are given
    cmap : matplotlib.cm.cmap, optional (default=cm.cubehelix_r)
        color map to use for Wigner
    view : tuple, optional (default=(10, -45))
        view angle for 3d wigner plot
    figsize : tuple, optional (default=(10, 10))
        tuple defining size of figure created

    Returns
    -------
    fig : matplotlib.figure.Figure object
        figure showing the wigner function
    ax : matplotlib.axes.Axes object
        axes containing the object

    """"""
    fig = _plt.figure(figsize=figsize)
    ax = fig.add_subplot(111, projection='3d')

    resid1 = iradon_output.sum(axis=0)
    resid2 = iradon_output.sum(axis=1)

    x = bin_centres # replace with x
    y = bin_centres # replace with p (xdot/omega)
    xpos, ypos = _np.meshgrid(x, y)
    X = xpos
    Y = ypos
    Z = iradon_output

    ax.set_xlabel(""x ({})"".format(bin_centre_units))
    ax.set_xlabel(""y ({})"".format(bin_centre_units))

    ax.scatter(_np.min(X)*_np.ones_like(y), y, resid2/_np.max(resid2)*_np.max(Z), alpha=0.7)
    ax.scatter(x, _np.max(Y)*_np.ones_like(x), resid1/_np.max(resid1)*_np.max(Z), alpha=0.7)

    # Plot the surface.
    surf = ax.plot_surface(X, Y, Z, cmap=cmap,
                           linewidth=0, antialiased=False)

    # Customize the z axis.
    #ax.set_zlim(-1.01, 1.01)
    #ax.zaxis.set_major_locator(LinearLocator(10))
    #ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))

    # Add a color bar which maps values to colors.
    fig.colorbar(surf, shrink=0.5, aspect=5)

    ax.view_init(view[0], view[1])

    return fig, ax"
2943,"def plot_wigner2d(iradon_output, bin_centres, cmap=_cm.cubehelix_r, figsize=(6, 6)):
    """"""
    Plots the wigner space representation as a 2D heatmap.

    Parameters
    ----------
    iradon_output : ndarray
        2d array of size (histbins x histbins)
    bin_centres : ndarray
        positions of the bin centres
    cmap : matplotlib.cm.cmap, optional (default=cm.cubehelix_r)
        color map to use for Wigner
    figsize : tuple, optional (default=(6, 6))
        tuple defining size of figure created

    Returns
    -------
    fig : matplotlib.figure.Figure object
        figure showing the wigner function
    ax : matplotlib.axes.Axes object
        axes containing the object

    """"""
    xx, yy = _np.meshgrid(bin_centres, bin_centres)
    resid1 = iradon_output.sum(axis=0)
    resid2 = iradon_output.sum(axis=1)
    
    wigner_marginal_seperation = 0.001
    left, width = 0.2, 0.65-0.1 # left = left side of hexbin and hist_x
    bottom, height = 0.1, 0.65-0.1 # bottom = bottom of hexbin and hist_y
    bottom_h = height + bottom + wigner_marginal_seperation
    left_h = width + left + wigner_marginal_seperation
    cbar_pos = [0.03, bottom, 0.05, 0.02+width]

    rect_wigner = [left, bottom, width, height]
    rect_histx = [left, bottom_h, width, 0.2]
    rect_histy = [left_h, bottom, 0.2, height]

    # start with a rectangular Figure
    fig = _plt.figure(figsize=figsize)

    axWigner = _plt.axes(rect_wigner)
    axHistx = _plt.axes(rect_histx)
    axHisty = _plt.axes(rect_histy)

    pcol = axWigner.pcolor(xx, yy, iradon_output, cmap=cmap)
    binwidth = bin_centres[1] - bin_centres[0]
    axHistx.bar(bin_centres, resid2, binwidth)
    axHisty.barh(bin_centres, resid1, binwidth)

    _plt.setp(axHistx.get_xticklabels(), visible=False) # sets x ticks to be invisible while keeping gridlines
    _plt.setp(axHisty.get_yticklabels(), visible=False) # sets x ticks to be invisible while keeping gridlines
    for tick in axHisty.get_xticklabels():
        tick.set_rotation(-90)


    cbaraxes = fig.add_axes(cbar_pos)  # This is the position for the colorbar
    #cbar = _plt.colorbar(axp, cax = cbaraxes)
    cbar = fig.colorbar(pcol, cax = cbaraxes, drawedges=False) #, orientation=""horizontal""
    cbar.solids.set_edgecolor(""face"")
    cbar.solids.set_rasterized(True)
    cbar.ax.set_yticklabels(cbar.ax.yaxis.get_ticklabels(), y=0, rotation=45)
    #cbar.set_label(cbarlabel, labelpad=-25, y=1.05, rotation=0)

    plotlimits = _np.max(_np.abs(bin_centres))
    axWigner.axis((-plotlimits, plotlimits, -plotlimits, plotlimits))
    axHistx.set_xlim(axWigner.get_xlim())
    axHisty.set_ylim(axWigner.get_ylim())

    return fig, axWigner, axHistx, axHisty, cbar"
2944,"def calc_reduced_chi_squared(y_observed, y_model, observation_error, number_of_fitted_parameters):
    """"""
    Calculates the reduced chi-squared, used to compare a model to observations. For example can be used to calculate how good a fit is by using fitted y values for y_model along with observed y values and error in those y values. Reduced chi-squared should be close to 1 for a good fit, lower than 1 suggests you are overestimating the measurement error (observation_error you entered is higher than the true error in the measurement). A value higher than 1 suggests either your model is a bad fit OR you are underestimating the error in the measurement (observation_error you entered is lower than the true error in the measurement). See https://en.wikipedia.org/wiki/Reduced_chi-squared_statistic for more detail.
    
    Parameters
    ----------
    y_observed : ndarray
        array of measured/observed values of some variable y which you are fitting to.
    y_model : ndarray
        array of y values predicted by your model/fit (predicted y values corresponding to y_observed)
    observation_error : float
        error in the measurements/observations of y
    number_of_fitted_parameters : float
        number of parameters in your model

    Returns
    -------
    chi2_reduced : float
        reduced chi-squared parameter
    """"""
    observed = _np.array(y_observed)
    expected = _np.array(y_model)
    if observed.shape != expected.shape:
        raise ValueError(""y_observed should have same number of elements as y_model"")
    residuals = (observed - expected)
    z = residuals / observation_error # residuals divided by known error in measurement
    chi2 = _np.sum(z**2) # chi squared value
    num_of_observations = len(observed)
    v = num_of_observations - number_of_fitted_parameters # v = number of degrees of freedom
    chi2_reduced = chi2/v
    return chi2_reduced"
2945,"def load_time_data(self, RelativeChannelNo=None, SampleFreq=None, PointsToLoad=-1, NormaliseByMonitorOutput=False):
        """"""
        Loads the time and voltage data and the wave description from the associated file.

        Parameters
        ----------
        RelativeChannelNo : int, optional
             Channel number for loading saleae data files
             If loading a .dat file produced by the labview NI5122 daq card, used to 
             specifiy the channel number if two channels where saved, if left None with 
             .dat files it will assume that the file to load only contains one channel.
             If NormaliseByMonitorOutput is True then RelativeChannelNo specifies the 
             monitor channel for loading a .dat file produced by the labview NI5122 daq card.
        SampleFreq : float, optional
             Manual selection of sample frequency for loading labview NI5122 daq files
        PointsToLoad : int, optional
             Number of first points to read. -1 means all points (i.e., the complete file)
             WORKS WITH NI5122 DATA SO FAR ONLY!!!
        NormaliseByMonitorOutput : bool, optional
             If True the particle signal trace will be divided by the monitor output, which is
             specified by the channel number set in the RelativeChannelNo parameter. 
             WORKS WITH NI5122 DATA SO FAR ONLY!!!
        """"""
        f = open(self.filepath, 'rb')
        raw = f.read()
        f.close()
        FileExtension = self.filepath.split('.')[-1]
        if FileExtension == ""raw"" or FileExtension == ""trc"":
            with _warnings.catch_warnings(): # supress missing data warning and raise a missing
                # data warning from optoanalysis with the filepath
                _warnings.simplefilter(""ignore"")
                waveDescription, timeParams, self.voltage, _, missingdata = optoanalysis.LeCroy.InterpretWaveform(raw, noTimeArray=True) 
            if missingdata:
                _warnings.warn(""Waveform not of expected length. File {} may be missing data."".format(self.filepath))
            self.SampleFreq = (1 / waveDescription[""HORIZ_INTERVAL""])
        elif FileExtension == ""bin"":
            if RelativeChannelNo == None:
                raise ValueError(""If loading a .bin file from the Saleae data logger you must enter a relative channel number to load"")
            timeParams, self.voltage = optoanalysis.Saleae.interpret_waveform(raw, RelativeChannelNo)
            self.SampleFreq = 1/timeParams[2]
        elif FileExtension == ""dat"": #for importing a file written by labview using the NI5122 daq card
            if SampleFreq == None:
                raise ValueError(""If loading a .dat file from the NI5122 daq card you must enter a SampleFreq"")
            if RelativeChannelNo == None:
                self.voltage = _np.fromfile(self.filepath, dtype='>h',count=PointsToLoad)
            elif RelativeChannelNo != None:
                filedata = _np.fromfile(self.filepath, dtype='>h',count=PointsToLoad)
                if NormaliseByMonitorOutput == True:
                    if RelativeChannelNo == 0:
                        monitorsignal = filedata[:len(filedata):2]
                        self.voltage = filedata[1:len(filedata):2]/monitorsignal
                    elif RelativeChannelNo == 1:
                        monitorsignal = filedata[1:len(filedata):2]
                        self.voltage = filedata[:len(filedata):2]/monitorsignal
                elif NormaliseByMonitorOutput == False:
                    self.voltage = filedata[RelativeChannelNo:len(filedata):2]
            timeParams = (0,(len(self.voltage)-1)/SampleFreq,1/SampleFreq)
            self.SampleFreq = 1/timeParams[2]
        elif FileExtension == ""tdms"": # for importing a file written by labview form the NI7961 FPGA with the RecordDataPC VI
            if SampleFreq == None:
                raise ValueError(""If loading a .tdms file saved from the FPGA you must enter a SampleFreq"")
            self.SampleFreq = SampleFreq
            dt = 1/self.SampleFreq
            FIFO_SIZE = 262143 # this is the maximum size of the DMA FIFO on the NI 7961 FPGA with the NI 5781 DAC card
            tdms_file = _TdmsFile(self.filepath)
            channel = tdms_file.object('Measured_Data', 'data')
            data = channel.data[FIFO_SIZE:] # dump first 1048575 points of data
            # as this is the values that had already filled the buffer
            # from before when the record code started running
            volts_per_unit = 2/(2**14)
            self.voltage = volts_per_unit*data
            timeParams = [0, (data.shape[0]-1)*dt, dt]
        elif FileExtension == 'txt': # .txt file created by LeCroy Oscilloscope
            data = []
            with open(self.filepath, 'r') as csvfile:
                reader = csv.reader(csvfile)
                for row in reader:
                    data.append(row)
            data = _np.array(data[5:]).astype(float).transpose()
            t0 = data[0][0]
            tend = data[0][-1]
            dt = data[0][1] - data[0][0]
            self.SampleFreq = 1/dt
            self.voltage = data[1]
            del(data)
            timeParams = [t0, tend, dt]
        else:
            raise ValueError(""Filetype not supported"")
        startTime, endTime, Timestep = timeParams
        self.timeStart = startTime
        self.timeEnd = endTime
        self.timeStep = Timestep
        self.time = frange(startTime, endTime+Timestep, Timestep)
        return None"
2946,"def get_time_data(self, timeStart=None, timeEnd=None):
        """"""
        Gets the time and voltage data.

        Parameters
        ----------
        timeStart : float, optional
            The time get data from.
            By default it uses the first time point
        timeEnd : float, optional
            The time to finish getting data from.
            By default it uses the last time point        

        Returns
        -------
        time : ndarray
                        array containing the value of time (in seconds) at which the
                        voltage is sampled
        voltage : ndarray
                        array containing the sampled voltages
        """"""
        if timeStart == None:
            timeStart = self.timeStart
            
        if timeEnd == None:
            timeEnd = self.timeEnd

        time = self.time.get_array()
            
        StartIndex = _np.where(time == take_closest(time, timeStart))[0][0]
        EndIndex = _np.where(time == take_closest(time, timeEnd))[0][0]

        if EndIndex == len(time) - 1:
            EndIndex = EndIndex + 1 # so that it does not remove the last element

        return time[StartIndex:EndIndex], self.voltage[StartIndex:EndIndex]"
2947,"def plot_time_data(self, timeStart=None, timeEnd=None, units='s', show_fig=True):
        """"""
        plot time data against voltage data.

        Parameters
        ----------
        timeStart : float, optional
            The time to start plotting from.
            By default it uses the first time point
        timeEnd : float, optional
            The time to finish plotting at.
            By default it uses the last time point
        units : string, optional
            units of time to plot on the x axis - defaults to s
        show_fig : bool, optional
            If True runs plt.show() before returning figure
            if False it just returns the figure object.
            (the default is True, it shows the figure)

        Returns
        -------
        fig : matplotlib.figure.Figure object
            The figure object created
        ax : matplotlib.axes.Axes object
            The subplot object created
        """"""
        unit_prefix = units[:-1] # removed the last char
        if timeStart == None:
            timeStart = self.timeStart
        if timeEnd == None:
            timeEnd = self.timeEnd

        time = self.time.get_array()

        StartIndex = _np.where(time == take_closest(time, timeStart))[0][0]
        EndIndex = _np.where(time == take_closest(time, timeEnd))[0][0]

        fig = _plt.figure(figsize=properties['default_fig_size'])
        ax = fig.add_subplot(111)
        ax.plot(unit_conversion(time[StartIndex:EndIndex], unit_prefix),
                self.voltage[StartIndex:EndIndex])
        ax.set_xlabel(""time ({})"".format(units))
        ax.set_ylabel(""voltage (V)"")
        ax.set_xlim([timeStart, timeEnd])
        if show_fig == True:
            _plt.show()
        return fig, ax"
2948,"def get_PSD(self, NPerSegment=1000000, window=""hann"", timeStart=None, timeEnd=None, override=False):
        """"""
        Extracts the power spectral density (PSD) from the data.

        Parameters
        ----------
        NPerSegment : int, optional
            Length of each segment used in scipy.welch
            default = 1000000

        window : str or tuple or array_like, optional
            Desired window to use. See get_window for a list of windows
            and required parameters. If window is array_like it will be
            used directly as the window and its length will be used for
            nperseg.
            default = ""hann""

        Returns
        -------
        freqs : ndarray
                Array containing the frequencies at which the PSD has been
                calculated
        PSD : ndarray
                Array containing the value of the PSD at the corresponding
                frequency value in V**2/Hz
        """"""
        if timeStart == None and timeEnd == None:
            freqs, PSD = calc_PSD(self.voltage, self.SampleFreq, NPerSegment=NPerSegment)
            self.PSD = PSD
            self.freqs = freqs
        else:
            if timeStart == None:
                timeStart = self.timeStart
            if timeEnd == None:
                timeEnd = self.timeEnd

            time = self.time.get_array()
                
            StartIndex = _np.where(time == take_closest(time, timeStart))[0][0]
            EndIndex = _np.where(time == take_closest(time, timeEnd))[0][0]

            if EndIndex == len(time) - 1:
                EndIndex = EndIndex + 1 # so that it does not remove the last element
            freqs, PSD = calc_PSD(self.voltage[StartIndex:EndIndex], self.SampleFreq, NPerSegment=NPerSegment)
            if override == True:
                self.freqs = freqs
                self.PSD = PSD

        return freqs, PSD"
2949,"def plot_PSD(self, xlim=None, units=""kHz"", show_fig=True, timeStart=None, timeEnd=None, *args, **kwargs):
        """"""
        plot the pulse spectral density.

        Parameters
        ----------
        xlim : array_like, optional
            The x limits of the plotted PSD [LowerLimit, UpperLimit]
            Default value is [0, SampleFreq/2]
        units : string, optional
            Units of frequency to plot on the x axis - defaults to kHz
        show_fig : bool, optional
            If True runs plt.show() before returning figure
            if False it just returns the figure object.
            (the default is True, it shows the figure)

        Returns
        -------
        fig : matplotlib.figure.Figure object
            The figure object created
        ax : matplotlib.axes.Axes object
            The subplot object created
        """"""
        #        self.get_PSD()
        if timeStart == None and timeEnd == None:
            freqs = self.freqs
            PSD = self.PSD
        else:
            freqs, PSD = self.get_PSD(timeStart=timeStart, timeEnd=timeEnd)
            
        unit_prefix = units[:-2]
        if xlim == None:
            xlim = [0, unit_conversion(self.SampleFreq/2, unit_prefix)]
        fig = _plt.figure(figsize=properties['default_fig_size'])
        ax = fig.add_subplot(111)
        ax.semilogy(unit_conversion(freqs, unit_prefix), PSD, *args, **kwargs)
        ax.set_xlabel(""Frequency ({})"".format(units))
        ax.set_xlim(xlim)
        ax.grid(which=""major"")
        ax.set_ylabel(""$S_{xx}$ ($V^2/Hz$)"")
        if show_fig == True:
            _plt.show()
        return fig, ax"
2950,"def calc_area_under_PSD(self, lowerFreq, upperFreq):
        """"""
        Sums the area under the PSD from lowerFreq to upperFreq.

        Parameters
        ----------
        lowerFreq : float
            The lower limit of frequency to sum from
        upperFreq : float
            The upper limit of frequency to sum to

        Returns
        -------
        AreaUnderPSD : float
            The area under the PSD from lowerFreq to upperFreq
        """"""
        Freq_startAreaPSD = take_closest(self.freqs, lowerFreq)
        index_startAreaPSD = int(_np.where(self.freqs == Freq_startAreaPSD)[0][0])
        Freq_endAreaPSD = take_closest(self.freqs, upperFreq)
        index_endAreaPSD = int(_np.where(self.freqs == Freq_endAreaPSD)[0][0])
        AreaUnderPSD = sum(self.PSD[index_startAreaPSD: index_endAreaPSD])
        return AreaUnderPSD"
2951,"def get_fit(self, TrapFreq, WidthOfPeakToFit, A_Initial=0.1e10, Gamma_Initial=400, silent=False, MakeFig=True, show_fig=True):
        """"""
        Function that fits to a peak to the PSD to extract the 
        frequency, A factor and Gamma (damping) factor.

        Parameters
        ----------
        TrapFreq : float
            The approximate trapping frequency to use initially
            as the centre of the peak
        WidthOfPeakToFit : float
            The width of the peak to be fitted to. This limits the
            region that the fitting function can see in order to
            stop it from fitting to the wrong peak
        A_Initial : float, optional
            The initial value of the A parameter to use in fitting
        Gamma_Initial : float, optional
            The initial value of the Gamma parameter to use in fitting
        Silent : bool, optional
            Whether to print any output when running this function
            defaults to False
        MakeFig : bool, optional
            Whether to construct and return the figure object showing
            the fitting. defaults to True
        show_fig : bool, optional
            Whether to show the figure object when it has been created.
            defaults to True

        Returns
        -------
        A : uncertainties.ufloat
            Fitting constant A
            A = γ**2*2*Γ_0*(K_b*T_0)/(π*m)
            where:
            γ = conversionFactor
            Γ_0 = Damping factor due to environment
            π = pi
        OmegaTrap : uncertainties.ufloat
            The trapping frequency in the z axis (in angular frequency)
        Gamma : uncertainties.ufloat
            The damping factor Gamma = Γ = Γ_0 + δΓ
            where:
            Γ_0 = Damping factor due to environment
            δΓ = extra damping due to feedback or other effects
        fig : matplotlib.figure.Figure object
            figure object containing the plot
        ax : matplotlib.axes.Axes object
            axes with the data plotted of the:
            - initial data
            - smoothed data
            - initial fit
            - final fit

        """"""
        if MakeFig == True:
            Params, ParamsErr, fig, ax = fit_PSD(
                self, WidthOfPeakToFit, TrapFreq, A_Initial, Gamma_Initial, MakeFig=MakeFig, show_fig=show_fig)
        else:
            Params, ParamsErr, _ , _ = fit_PSD(
                self, WidthOfPeakToFit, TrapFreq, A_Initial, Gamma_Initial, MakeFig=MakeFig, show_fig=show_fig)

        if silent == False:
            print(""\n"")
            print(""A: {} +- {}% "".format(Params[0],
                                         ParamsErr[0] / Params[0] * 100))
            print(
                ""Trap Frequency: {} +- {}% "".format(Params[1], ParamsErr[1] / Params[1] * 100))
            print(
                ""Big Gamma: {} +- {}% "".format(Params[2], ParamsErr[2] / Params[2] * 100))

        self.A = _uncertainties.ufloat(Params[0], ParamsErr[0])
        self.OmegaTrap = _uncertainties.ufloat(Params[1], ParamsErr[1])
        self.Gamma = _uncertainties.ufloat(Params[2], ParamsErr[2])

        
        if MakeFig == True:
            return self.A, self.OmegaTrap, self.Gamma, fig, ax
        else:
            return self.A, self.OmegaTrap, self.Gamma, None, None"
2952,"def get_fit_from_peak(self, lowerLimit, upperLimit, NumPointsSmoothing=1, silent=False, MakeFig=True, show_fig=True):
        """"""
        Finds approximate values for the peaks central frequency, height, 
        and FWHM by looking for the heighest peak in the frequency range defined 
        by the input arguments. It then uses the central frequency as the trapping 
        frequency, peak height to approximate the A value and the FWHM to an approximate
        the Gamma (damping) value.

        Parameters
        ----------
        lowerLimit : float
            The lower frequency limit of the range in which it looks for a peak
        upperLimit : float
            The higher frequency limit of the range in which it looks for a peak
        NumPointsSmoothing : float
            The number of points of moving-average smoothing it applies before fitting the 
            peak.
        Silent : bool, optional
            Whether it prints the values fitted or is silent.
        show_fig : bool, optional
            Whether it makes and shows the figure object or not.

        Returns
        -------
        OmegaTrap : ufloat
            Trapping frequency
        A : ufloat
            A parameter
        Gamma : ufloat
            Gamma, the damping parameter
        """"""
        lowerIndex = _np.where(self.freqs ==
            take_closest(self.freqs, lowerLimit))[0][0]
        upperIndex = _np.where(self.freqs ==
            take_closest(self.freqs, upperLimit))[0][0]

        if lowerIndex == upperIndex:
            _warnings.warn(""range is too small, returning NaN"", UserWarning)
            val = _uncertainties.ufloat(_np.NaN, _np.NaN)
            return val, val, val, val, val

        MaxPSD = max(self.PSD[lowerIndex:upperIndex])

        centralIndex = _np.where(self.PSD == MaxPSD)[0][0]
        CentralFreq = self.freqs[centralIndex]

        approx_A = MaxPSD * 1e16  # 1e16 was calibrated for a number of saves to be approximately the correct conversion factor between the height of the PSD and the A factor in the fitting

        MinPSD = min(self.PSD[lowerIndex:upperIndex])

        # need to get this on log scale
        HalfMax = MinPSD + (MaxPSD - MinPSD) / 2

        try:
            LeftSideOfPeakIndex = _np.where(self.PSD ==
                                            take_closest(self.PSD[lowerIndex:centralIndex], HalfMax))[0][0]
            LeftSideOfPeak = self.freqs[LeftSideOfPeakIndex]
        except IndexError:
            _warnings.warn(""range is too small, returning NaN"", UserWarning)
            val = _uncertainties.ufloat(_np.NaN, _np.NaN)
            return val, val, val, val, val

        try:
            RightSideOfPeakIndex = _np.where(self.PSD ==
                                             take_closest(self.PSD[centralIndex:upperIndex], HalfMax))[0][0]
            RightSideOfPeak = self.freqs[RightSideOfPeakIndex]
        except IndexError:
            _warnings.warn(""range is too small, returning NaN"", UserWarning)
            val = _uncertainties.ufloat(_np.NaN, _np.NaN)
            return val, val, val, val, val

        FWHM = RightSideOfPeak - LeftSideOfPeak

        approx_Gamma = FWHM/4
        try:
            A, OmegaTrap, Gamma, fig, ax \
                = self.get_fit(CentralFreq,
                               (upperLimit-lowerLimit)/2, 
                               A_Initial=approx_A,
                               Gamma_Initial=approx_Gamma,
                               silent=silent,
                               MakeFig=MakeFig,
                               show_fig=show_fig)
        except (TypeError, ValueError) as e: 
            _warnings.warn(""range is too small to fit, returning NaN"", UserWarning)
            val = _uncertainties.ufloat(_np.NaN, _np.NaN)
            return val, val, val, val, val
        OmegaTrap = self.OmegaTrap
        A = self.A
        Gamma = self.Gamma

        omegaArray = 2 * pi * \
            self.freqs[LeftSideOfPeakIndex:RightSideOfPeakIndex]
        PSDArray = self.PSD[LeftSideOfPeakIndex:RightSideOfPeakIndex]

        return OmegaTrap, A, Gamma, fig, ax"
2953,"def get_fit_auto(self, CentralFreq, MaxWidth=15000, MinWidth=500, WidthIntervals=500, MakeFig=True, show_fig=True, silent=False):
        """"""
        Tries a range of regions to search for peaks and runs the one with the least error
        and returns the parameters with the least errors.

        Parameters
        ----------
        CentralFreq : float
            The central frequency to use for the fittings.
        MaxWidth : float, optional
            The maximum bandwidth to use for the fitting of the peaks.
        MinWidth : float, optional
            The minimum bandwidth to use for the fitting of the peaks.
        WidthIntervals : float, optional
            The intervals to use in going between the MaxWidth and MinWidth.
        show_fig : bool, optional
            Whether to plot and show the final (best) fitting or not.

        Returns
        -------
        OmegaTrap : ufloat
            Trapping frequency
        A : ufloat
            A parameter
        Gamma : ufloat
            Gamma, the damping parameter
        fig : matplotlib.figure.Figure object
            The figure object created showing the PSD of the data 
            with the fit
        ax : matplotlib.axes.Axes object
            The axes object created showing the PSD of the data 
            with the fit

        """"""
        MinTotalSumSquaredError = _np.infty
        for Width in _np.arange(MaxWidth, MinWidth - WidthIntervals, -WidthIntervals):
            try:
                OmegaTrap, A, Gamma,_ , _ \
                    = self.get_fit_from_peak(
                        CentralFreq - Width / 2,
                        CentralFreq + Width / 2,
                        silent=True,
                        MakeFig=False,
                        show_fig=False)
            except RuntimeError:
                _warnings.warn(""Couldn't find good fit with width {}"".format(
                    Width), RuntimeWarning)
                val = _uncertainties.ufloat(_np.NaN, _np.NaN)
                OmegaTrap = val
                A = val
                Gamma = val
            TotalSumSquaredError = (
                A.std_dev / A.n)**2 + (Gamma.std_dev / Gamma.n)**2 + (OmegaTrap.std_dev / OmegaTrap.n)**2
            #print(""totalError: {}"".format(TotalSumSquaredError))
            if TotalSumSquaredError < MinTotalSumSquaredError:
                MinTotalSumSquaredError = TotalSumSquaredError
                BestWidth = Width
        if silent != True:
            print(""found best"")
        try:
            OmegaTrap, A, Gamma, fig, ax \
                = self.get_fit_from_peak(CentralFreq - BestWidth / 2,
                                         CentralFreq + BestWidth / 2,
                                         MakeFig=MakeFig,
                                         show_fig=show_fig,
                                         silent=silent)
        except UnboundLocalError:
            raise ValueError(""A best width was not found, try increasing the number of widths tried by either decreasing WidthIntervals or MinWidth or increasing MaxWidth"")
        OmegaTrap = self.OmegaTrap
        A = self.A
        Gamma = self.Gamma
        self.FTrap = OmegaTrap/(2*pi)
        return OmegaTrap, A, Gamma, fig, ax"
2954,"def calc_gamma_from_variance_autocorrelation_fit(self, NumberOfOscillations, GammaGuess=None, silent=False, MakeFig=True, show_fig=True):
        """"""
        Calculates the total damping, i.e. Gamma, by splitting the time trace
        into chunks of NumberOfOscillations oscillations and calculated the
        variance of each of these chunks. This array of varainces is then used
        for the autocorrleation. The autocorrelation is fitted with an exponential 
        relaxation function and the function returns the parameters with errors.

        Parameters
        ----------
        NumberOfOscillations : int
            The number of oscillations each chunk of the timetrace 
            used to calculate the variance should contain.
        GammaGuess : float, optional
            Inital guess for BigGamma (in radians)
        Silent : bool, optional
            Whether it prints the values fitted or is silent.
        MakeFig : bool, optional
            Whether to construct and return the figure object showing
            the fitting. defaults to True
        show_fig : bool, optional
            Whether to show the figure object when it has been created.
            defaults to True

        Returns
        -------
        Gamma : ufloat
            Big Gamma, the total damping in radians
        fig : matplotlib.figure.Figure object
            The figure object created showing the autocorrelation
            of the data with the fit
        ax : matplotlib.axes.Axes object
            The axes object created showing the autocorrelation
            of the data with the fit

        """"""
        try:
            SplittedArraySize = int(self.SampleFreq/self.FTrap.n) * NumberOfOscillations
        except KeyError:
            ValueError('You forgot to do the spectrum fit to specify self.FTrap exactly.')
        VoltageArraySize = len(self.voltage)
        SnippetsVariances = _np.var(self.voltage[:VoltageArraySize-_np.mod(VoltageArraySize,SplittedArraySize)].reshape(-1,SplittedArraySize),axis=1)
        autocorrelation = calc_autocorrelation(SnippetsVariances)
        time = _np.array(range(len(autocorrelation))) * SplittedArraySize / self.SampleFreq

        if GammaGuess==None:
            Gamma_Initial = (time[4]-time[0])/(autocorrelation[0]-autocorrelation[4])
        else:
            Gamma_Initial = GammaGuess
        
        if MakeFig == True:
            Params, ParamsErr, fig, ax = fit_autocorrelation(
                autocorrelation, time, Gamma_Initial, MakeFig=MakeFig, show_fig=show_fig)
        else:
            Params, ParamsErr, _ , _ = fit_autocorrelation(
                autocorrelation, time, Gamma_Initial, MakeFig=MakeFig, show_fig=show_fig)

        if silent == False:
            print(""\n"")
            print(
                ""Big Gamma: {} +- {}% "".format(Params[0], ParamsErr[0] / Params[0] * 100))

        Gamma = _uncertainties.ufloat(Params[0], ParamsErr[0])
        
        if MakeFig == True:
            return Gamma, fig, ax
        else:
            return Gamma, None, None"
2955,"def calc_gamma_from_energy_autocorrelation_fit(self, GammaGuess=None, silent=False, MakeFig=True, show_fig=True):
        """"""
        Calculates the total damping, i.e. Gamma, by calculating the energy each 
        point in time. This energy array is then used for the autocorrleation. 
        The autocorrelation is fitted with an exponential relaxation function and
        the function returns the parameters with errors.

        Parameters
        ----------
        GammaGuess : float, optional
            Inital guess for BigGamma (in radians)
        silent : bool, optional
            Whether it prints the values fitted or is silent.
        MakeFig : bool, optional
            Whether to construct and return the figure object showing
            the fitting. defaults to True
        show_fig : bool, optional
            Whether to show the figure object when it has been created.
            defaults to True

        Returns
        -------
        Gamma : ufloat
            Big Gamma, the total damping in radians
        fig : matplotlib.figure.Figure object
            The figure object created showing the autocorrelation
            of the data with the fit
        ax : matplotlib.axes.Axes object
            The axes object created showing the autocorrelation
            of the data with the fit

        """"""
        autocorrelation = calc_autocorrelation(self.voltage[:-1]**2*self.OmegaTrap.n**2+(_np.diff(self.voltage)*self.SampleFreq)**2)
        time = self.time.get_array()[:len(autocorrelation)]

        if GammaGuess==None:
            Gamma_Initial = (time[4]-time[0])/(autocorrelation[0]-autocorrelation[4])
        else:
            Gamma_Initial = GammaGuess
        
        if MakeFig == True:
            Params, ParamsErr, fig, ax = fit_autocorrelation(
                autocorrelation, time, Gamma_Initial, MakeFig=MakeFig, show_fig=show_fig)
        else:
            Params, ParamsErr, _ , _ = fit_autocorrelation(
                autocorrelation, time, Gamma_Initial, MakeFig=MakeFig, show_fig=show_fig)

        if silent == False:
            print(""\n"")
            print(
                ""Big Gamma: {} +- {}% "".format(Params[0], ParamsErr[0] / Params[0] * 100))

        Gamma = _uncertainties.ufloat(Params[0], ParamsErr[0])
        
        if MakeFig == True:
            return Gamma, fig, ax
        else:
            return Gamma, None, None"
2956,"def calc_gamma_from_position_autocorrelation_fit(self, GammaGuess=None, FreqTrapGuess=None, silent=False, MakeFig=True, show_fig=True):
        """"""
        Calculates the total damping, i.e. Gamma, by calculating the autocorrleation 
        of the position-time trace. The autocorrelation is fitted with an exponential 
        relaxation function derived in Tongcang Li's 2013 thesis (DOI: 10.1007/978-1-4614-6031-2)
        and the function (equation 4.20 in the thesis) returns the parameters with errors.

        Parameters
        ----------
        GammaGuess : float, optional
            Inital guess for BigGamma (in radians)
        FreqTrapGuess : float, optional
            Inital guess for the trapping Frequency in Hz
        silent : bool, optional
            Whether it prints the values fitted or is silent.
        MakeFig : bool, optional
            Whether to construct and return the figure object showing
            the fitting. defaults to True
        show_fig : bool, optional
            Whether to show the figure object when it has been created.
            defaults to True

        Returns
        -------
        Gamma : ufloat
            Big Gamma, the total damping in radians
        OmegaTrap : ufloat
            Trapping frequency in radians
        fig : matplotlib.figure.Figure object
            The figure object created showing the autocorrelation
            of the data with the fit
        ax : matplotlib.axes.Axes object
            The axes object created showing the autocorrelation
            of the data with the fit

        """"""
        autocorrelation = calc_autocorrelation(self.voltage)
        time = self.time.get_array()[:len(autocorrelation)]

        if GammaGuess==None:
            Gamma_Initial = (autocorrelation[0]-autocorrelation[int(self.SampleFreq/self.FTrap.n)])/(time[int(self.SampleFreq/self.FTrap.n)]-time[0])*2*_np.pi
        else:
            Gamma_Initial = GammaGuess

        if FreqTrapGuess==None:
            FreqTrap_Initial = self.FTrap.n
        else:
            FreqTrap_Initial = FreqTrapGuess
            
        if MakeFig == True:
            Params, ParamsErr, fig, ax = fit_autocorrelation(
                autocorrelation, time, Gamma_Initial, FreqTrap_Initial, method='position', MakeFig=MakeFig, show_fig=show_fig)
        else:
            Params, ParamsErr, _ , _ = fit_autocorrelation(
                autocorrelation, time, Gamma_Initial, FreqTrap_Initial, method='position', MakeFig=MakeFig, show_fig=show_fig)

        if silent == False:
            print(""\n"")
            print(
                ""Big Gamma: {} +- {}% "".format(Params[0], ParamsErr[0] / Params[0] * 100))
            print(
                ""Trap Frequency: {} +- {}% "".format(Params[1], ParamsErr[1] / Params[1] * 100))
            
        Gamma = _uncertainties.ufloat(Params[0], ParamsErr[0])
        OmegaTrap = _uncertainties.ufloat(Params[1], ParamsErr[1])
        
        if MakeFig == True:
            return Gamma, OmegaTrap, fig, ax
        else:
            return Gamma, OmegaTrap, None, None"
2957,"def extract_parameters(self, P_mbar, P_Error, method=""chang""):
        """"""
        Extracts the Radius, mass and Conversion factor for a particle.

        Parameters
        ----------
        P_mbar : float 
            The pressure in mbar when the data was taken.
        P_Error : float
            The error in the pressure value (as a decimal e.g. 15% = 0.15)
        
        Returns
        -------
        Radius : uncertainties.ufloat
            The radius of the particle in m
        Mass : uncertainties.ufloat
            The mass of the particle in kg
        ConvFactor : uncertainties.ufloat
            The conversion factor between volts/m

        """"""

        [R, M, ConvFactor], [RErr, MErr, ConvFactorErr] = \
            extract_parameters(P_mbar, P_Error,
                               self.A.n, self.A.std_dev,
                               self.Gamma.n, self.Gamma.std_dev,
                               method = method)
        self.Radius = _uncertainties.ufloat(R, RErr)
        self.Mass = _uncertainties.ufloat(M, MErr)
        self.ConvFactor = _uncertainties.ufloat(ConvFactor, ConvFactorErr)

        return self.Radius, self.Mass, self.ConvFactor"
2958,"def extract_ZXY_motion(self, ApproxZXYFreqs, uncertaintyInFreqs, ZXYPeakWidths, subSampleFraction=1, NPerSegmentPSD=1000000, MakeFig=True, show_fig=True):
        """"""
        Extracts the x, y and z signals (in volts) from the voltage signal. Does this by finding the highest peaks in the signal about the approximate frequencies, using the uncertaintyinfreqs parameter as the width it searches. It then uses the ZXYPeakWidths to construct bandpass IIR filters for each frequency and filtering them. If too high a sample frequency has been used to collect the data scipy may not be able to construct a filter good enough, in this case increasing the subSampleFraction may be nessesary.
        
        Parameters
        ----------
        ApproxZXYFreqs : array_like
            A sequency containing 3 elements, the approximate 
            z, x and y frequency respectively.
        uncertaintyInFreqs : float
            The uncertainty in the z, x and y frequency respectively.
        ZXYPeakWidths : array_like
            A sequency containing 3 elements, the widths of the
            z, x and y frequency peaks respectively.
        subSampleFraction : int, optional
            How much to sub-sample the data by before filtering,
            effectively reducing the sample frequency by this 
            fraction.
        NPerSegmentPSD : int, optional
            NPerSegment to pass to scipy.signal.welch to calculate the PSD
        show_fig : bool, optional
            Whether to show the figures produced of the PSD of
            the original signal along with the filtered x, y and z.

        Returns
        -------
        self.zVolts : ndarray
            The z signal in volts extracted by bandpass IIR filtering
        self.xVolts : ndarray
            The x signal in volts extracted by bandpass IIR filtering
        self.yVolts : ndarray
            The y signal in volts extracted by bandpass IIR filtering
        time : ndarray
            The array of times corresponding to the above 3 arrays
        fig : matplotlib.figure.Figure object
            figure object containing a plot of the PSD of the original 
            signal with the z, x and y filtered signals
        ax : matplotlib.axes.Axes object
            axes object corresponding to the above figure
        
        """"""
        [zf, xf, yf] = ApproxZXYFreqs
        zf, xf, yf = get_ZXY_freqs(
            self, zf, xf, yf, bandwidth=uncertaintyInFreqs)
        [zwidth, xwidth, ywidth] = ZXYPeakWidths
        self.zVolts, self.xVolts, self.yVolts, time, fig, ax = get_ZXY_data(
            self, zf, xf, yf, subSampleFraction, zwidth, xwidth, ywidth, MakeFig=MakeFig, show_fig=show_fig, NPerSegmentPSD=NPerSegmentPSD)
        return self.zVolts, self.xVolts, self.yVolts, time, fig, ax"
2959,"def filter_data(self, freq, FractionOfSampleFreq=1, PeakWidth=10000,
                    filterImplementation=""filtfilt"",
                    timeStart=None, timeEnd=None,
                    NPerSegmentPSD=1000000,
                    PyCUDA=False, MakeFig=True, show_fig=True):
        """"""
        filter out data about a central frequency with some bandwidth using an IIR filter.
    
        Parameters
        ----------
        freq : float
            The frequency of the peak of interest in the PSD
        FractionOfSampleFreq : integer, optional
            The fraction of the sample frequency to sub-sample the data by.
            This sometimes needs to be done because a filter with the appropriate
            frequency response may not be generated using the sample rate at which
            the data was taken. Increasing this number means the x, y and z signals
            produced by this function will be sampled at a lower rate but a higher
            number means a higher chance that the filter produced will have a nice
            frequency response.
        PeakWidth : float, optional
            The width of the pass-band of the IIR filter to be generated to
            filter the peak. Defaults to 10KHz
        filterImplementation : string, optional
            filtfilt or lfilter - use scipy.filtfilt or lfilter
            ifft - uses built in IFFT_filter
            default: filtfilt
        timeStart : float, optional
            Starting time for filtering. Defaults to start of time data.
        timeEnd : float, optional
            Ending time for filtering. Defaults to end of time data.
        NPerSegmentPSD : int, optional
            NPerSegment to pass to scipy.signal.welch to calculate the PSD
        PyCUDA : bool, optional
            Only important for the 'ifft'-method
            If True, uses PyCUDA to accelerate the FFT and IFFT
            via using your NVIDIA-GPU
            If False, performs FFT and IFFT with conventional
            scipy.fftpack
        MakeFig : bool, optional
            If True - generate figure showing filtered and unfiltered PSD
            Defaults to True.
        show_fig : bool, optional
            If True - plot unfiltered and filtered PSD
            Defaults to True.
    
        Returns
        -------
        timedata : ndarray
            Array containing the time data
        FiletedData : ndarray
            Array containing the filtered signal in volts with time.
        fig : matplotlib.figure.Figure object
            The figure object created showing the PSD of the filtered 
            and unfiltered signal
        ax : matplotlib.axes.Axes object
            The axes object created showing the PSD of the filtered 
            and unfiltered signal
        """"""
        if timeStart == None:
            timeStart = self.timeStart
        if timeEnd == None:
            timeEnd = self.timeEnd

        time = self.time.get_array()

        StartIndex = _np.where(time == take_closest(time, timeStart))[0][0]
        EndIndex = _np.where(time == take_closest(time, timeEnd))[0][0]

        
        input_signal = self.voltage[StartIndex: EndIndex][0::FractionOfSampleFreq]
        SAMPLEFREQ = self.SampleFreq / FractionOfSampleFreq
        if filterImplementation == ""filtfilt"" or filterImplementation == ""lfilter"":
            if filterImplementation == ""filtfilt"":
                ApplyFilter = scipy.signal.filtfilt
            elif filterImplementation == ""lfilter"":
                ApplyFilter = scipy.signal.lfilter
                
    
            b, a = make_butterworth_bandpass_b_a(freq, PeakWidth, SAMPLEFREQ)
            print(""filtering data"")
            filteredData = ApplyFilter(b, a, input_signal)
    
            if(_np.isnan(filteredData).any()):
                raise ValueError(
                    ""Value Error: FractionOfSampleFreq must be higher, a sufficiently small sample frequency should be used to produce a working IIR filter."")
        elif filterImplementation == ""ifft"":
            filteredData = IFFT_filter(input_signal, SAMPLEFREQ, freq-PeakWidth/2, freq+PeakWidth/2, PyCUDA = PyCUDA)
        else:
            raise ValueError(""filterImplementation must be one of [filtfilt, lfilter, ifft] you entered: {}"".format(filterImplementation))
    
        if MakeFig == True:
            f, PSD = scipy.signal.welch(
                input_signal, SAMPLEFREQ, nperseg=NPerSegmentPSD)
            f_filtdata, PSD_filtdata = scipy.signal.welch(filteredData, SAMPLEFREQ, nperseg=NPerSegmentPSD)
            fig, ax = _plt.subplots(figsize=properties[""default_fig_size""])
            ax.plot(f, PSD)
            ax.plot(f_filtdata, PSD_filtdata, label=""filtered data"")
            ax.legend(loc=""best"")
            ax.semilogy()
            ax.set_xlim([freq - PeakWidth, freq + PeakWidth])
        else:
            fig = None
            ax = None
        if show_fig == True:
            _plt.show()
        timedata = time[StartIndex: EndIndex][0::FractionOfSampleFreq]
        return timedata, filteredData, fig, ax"
2960,"def plot_phase_space_sns(self, freq, ConvFactor, PeakWidth=10000, FractionOfSampleFreq=1, kind=""hex"", timeStart=None, timeEnd =None, PointsOfPadding=500, units=""nm"", logscale=False, cmap=None, marginalColor=None, gridsize=200, show_fig=True, ShowPSD=False, alpha=0.5, *args, **kwargs):
        """"""
        Plots the phase space of a peak in the PSD.
        
        Parameters
        ----------
        freq : float
            The frequenecy of the peak (Trapping frequency of the dimension of interest)
        ConvFactor : float (or ufloat)
            The conversion factor between Volts and Meters
        PeakWidth : float, optional
            The width of the peak. Defaults to 10KHz
        FractionOfSampleFreq : int, optional
            The fraction of the sample freq to use to filter the data.
            Defaults to 1.
        kind : string, optional
            kind of plot to draw - pass to jointplot from seaborne
        timeStart : float, optional
            Starting time for data from which to calculate the phase space.
            Defaults to start of time data.
        timeEnd : float, optional
            Ending time for data from which to calculate the phase space.
            Defaults to start of time data.
        PointsOfPadding : float, optional
            How many points of the data at the beginning and end to disregard for plotting
            the phase space, to remove filtering artifacts. Defaults to 500.
        units : string, optional
            Units of position to plot on the axis - defaults to nm
        cmap : matplotlib.colors.ListedColormap, optional
            cmap to use for plotting the jointplot
        marginalColor : string, optional
            color to use for marginal plots
        gridsize : int, optional
            size of the grid to use with kind=""hex""
        show_fig : bool, optional
            Whether to show the figure before exiting the function
            Defaults to True.
        ShowPSD : bool, optional
            Where to show the PSD of the unfiltered and the 
            filtered signal used to make the phase space
            plot. Defaults to False.

        Returns
        -------
        fig : matplotlib.figure.Figure object
            figure object containing the phase space plot
        JP : seaborn.jointplot object
            joint plot object containing the phase space plot
        """"""
        if cmap == None:
            if logscale == True:
                cmap = properties['default_log_cmap']
            else:
                cmap = properties['default_linear_cmap']
        
        unit_prefix = units[:-1]

        _, PosArray, VelArray = self.calc_phase_space(freq, ConvFactor, PeakWidth=PeakWidth, FractionOfSampleFreq=FractionOfSampleFreq, timeStart=timeStart, timeEnd=timeEnd, PointsOfPadding=PointsOfPadding, ShowPSD=ShowPSD)

        _plt.close('all')
        
        PosArray = unit_conversion(PosArray, unit_prefix) # converts m to units required (nm by default)
        VelArray = unit_conversion(VelArray, unit_prefix) # converts m/s to units required (nm/s by default)
        
        VarPos = _np.var(PosArray)
        VarVel = _np.var(VelArray)
        MaxPos = _np.max(PosArray)
        MaxVel = _np.max(VelArray)
        if MaxPos > MaxVel / (2 * pi * freq):
            _plotlimit = MaxPos * 1.1
        else:
            _plotlimit = MaxVel / (2 * pi * freq) * 1.1

        print(""Plotting Phase Space"")

        if marginalColor == None:
            try:
                marginalColor = tuple((cmap.colors[len(cmap.colors)/2][:-1]))
            except AttributeError:
                try:
                    marginalColor = cmap(2)
                except:
                    marginalColor = properties['default_base_color']

        if kind == ""hex"":    # gridsize can only be passed if kind=""hex""
            JP1 = _sns.jointplot(_pd.Series(PosArray[1:], name=""$z$ ({}) \n filepath=%s"".format(units) % (self.filepath)),
                                 _pd.Series(VelArray / (2 * pi * freq), name=""$v_z$/$\omega$ ({})"".format(units)),
                                 stat_func=None,
                                 xlim=[-_plotlimit, _plotlimit],
                                 ylim=[-_plotlimit, _plotlimit],
                                 size=max(properties['default_fig_size']),
                                 kind=kind,
                                 marginal_kws={'hist_kws': {'log': logscale},},
                                 cmap=cmap,
                                 color=marginalColor,
                                 gridsize=gridsize,
                                 alpha=alpha,
                                 *args,
                                 **kwargs,
            )
        else:
            JP1 = _sns.jointplot(_pd.Series(PosArray[1:], name=""$z$ ({}) \n filepath=%s"".format(units) % (self.filepath)),
                                     _pd.Series(VelArray / (2 * pi * freq), name=""$v_z$/$\omega$ ({})"".format(units)),
                                 stat_func=None,
                                 xlim=[-_plotlimit, _plotlimit],
                                 ylim=[-_plotlimit, _plotlimit],
                                 size=max(properties['default_fig_size']),
                                 kind=kind,
                                 marginal_kws={'hist_kws': {'log': logscale},},
                                 cmap=cmap,
                                 color=marginalColor,
                                 alpha=alpha,                                
                                 *args,
                                 **kwargs,
            )

        fig = JP1.fig
        
        if show_fig == True:
            print(""Showing Phase Space"")
            _plt.show()
            
        return fig, JP1"
2961,"def calc_phase_space(self, freq, ConvFactor, PeakWidth=10000, FractionOfSampleFreq=1, timeStart=None, timeEnd =None, PointsOfPadding=500, ShowPSD=False):
        """"""
        Calculates the position and velocity (in m) for use in plotting the phase space distribution.

        Parameters
        ----------
        freq : float
            The frequenecy of the peak (Trapping frequency of the dimension of interest)
        ConvFactor : float (or ufloat)
            The conversion factor between Volts and Meters
        PeakWidth : float, optional
            The width of the peak. Defaults to 10KHz
        FractionOfSampleFreq : int, optional
            The fraction of the sample freq to use to filter the data.
            Defaults to 1.
        timeStart : float, optional
            Starting time for data from which to calculate the phase space.
            Defaults to start of time data.
        timeEnd : float, optional
            Ending time for data from which to calculate the phase space.
            Defaults to start of time data.
        PointsOfPadding : float, optional
            How many points of the data at the beginning and end to disregard for plotting
            the phase space, to remove filtering artifacts. Defaults to 500
        ShowPSD : bool, optional
            Where to show the PSD of the unfiltered and the filtered signal used 
            to make the phase space plot. Defaults to False.
        *args, **kwargs : optional
            args and kwargs passed to qplots.joint_plot


        Returns
        -------
        time : ndarray
            time corresponding to position and velocity
        PosArray : ndarray
            Array of position of the particle in time
        VelArray : ndarray
            Array of velocity of the particle in time
        """"""
        _, Pos, fig, ax = self.filter_data(
            freq, FractionOfSampleFreq, PeakWidth, MakeFig=ShowPSD, show_fig=ShowPSD, timeStart=timeStart, timeEnd=timeEnd)
        time = self.time.get_array()
        if timeStart != None:
            StartIndex = _np.where(time == take_closest(time, timeStart))[0][0]
        else:
            StartIndex = 0
        if timeEnd != None:
            EndIndex = _np.where(time == take_closest(time, timeEnd))[0][0]
        else:
            EndIndex = -1
            
        Pos = Pos[PointsOfPadding : -PointsOfPadding+1]
        time = time[StartIndex:EndIndex][::FractionOfSampleFreq][PointsOfPadding : -PointsOfPadding+1]
        
        if type(ConvFactor) == _uncertainties.core.Variable:
            conv = ConvFactor.n
        else:
            conv = ConvFactor
        PosArray = Pos / conv # converts V to m
        VelArray = _np.diff(PosArray) * (self.SampleFreq / FractionOfSampleFreq) # calcs velocity (in m/s) by differtiating position
        return time, PosArray, VelArray"
2962,"def get_value(self, ColumnName, RunNo):
        """"""
        Retreives the value of the collumn named ColumnName associated 
        with a particular run number.

        Parameters
        ----------
        ColumnName : string
            The name of the desired org-mode table's collumn

        RunNo : int
            The run number for which to retreive the pressure value
        
        Returns
        -------
        Value : float
            The value for the column's name and associated run number
        """"""
        Value = float(self.ORGTableData[self.ORGTableData.RunNo == '{}'.format(
            RunNo)][ColumnName])
        
        return Value"
2963,"def steady_state_potential(xdata,HistBins=100):
    """""" 
    Calculates the steady state potential.

    Parameters
    ----------
    xdata : ndarray
        Position data for a degree of freedom
    HistBins : int
        Number of bins to use for histogram
        of xdata. Number of position points
        at which the potential is calculated.

    Returns
    -------
    position : ndarray
        positions at which potential has been 
        calculated
    potential : ndarray
        value of potential at the positions above
    
    """"""  
    import numpy as np
    
    pops=np.histogram(xdata,HistBins)[0]
    bins=np.histogram(xdata,HistBins)[1]
    bins=bins[0:-1]
    bins=bins+np.mean(np.diff(bins))
    
    #normalise pops
    pops=pops/float(np.sum(pops))
    
    return bins,-np.log(pops)"
2964,"def dynamical_potential(xdata, dt, order=3):
    """"""
    Computes potential from spring function

    Parameters
    ----------
    xdata : ndarray
        Position data for a degree of freedom,
        at which to calculate potential
    dt : float
        time between measurements
    order : int
        order of polynomial to fit

    Returns
    -------
    Potential : ndarray
        valued of potential at positions in
        xdata

    """"""
    import numpy as np
    adata = CalcAcceleration(xdata, dt)
    xdata = xdata[2:] # removes first 2 values as differentiating twice means
    # we have acceleration[n] corresponds to position[n-2]
    
    z=np.polyfit(xdata,adata,order)
    p=np.poly1d(z)
    spring_pot=np.polyint(p)
    return -spring_pot"
2965,"def CalcAcceleration(xdata, dt):
    """"""
    Calculates the acceleration from the position
    
    Parameters
    ----------
    xdata : ndarray
        Position data
    dt : float
        time between measurements

    Returns
    -------
    acceleration : ndarray
        values of acceleration from position 
        2 to N.

    """"""
    acceleration = np.diff(np.diff(xdata))/dt**2
    return acceleration"
2966,"def FitRadius(z, SampleFreq, Damping, HistBins=100):
    """"""
    Fits the dynamical potential to the Steady 
    State Potential by varying the Radius.
    
    z : ndarray
        Position data
    SampleFreq : float
        frequency at which the position data was 
        sampled
    Damping : float
        value of damping (in radians/second)
    HistBins : int
        number of values at which to evaluate 
        the steady state potential / perform
        the fitting to the dynamical potential

    Returns
    -------
    Radius : float
        Radius of the nanoparticle
    RadiusError : float
        One Standard Deviation Error in the Radius from the Fit
        (doesn't take into account possible error in damping)
    """"""
    dt = 1/SampleFreq
    boltzmann=scipy.constants.Boltzmann
    temp=300 # why halved??
    density=1800
    SteadyStatePotnl = list(steady_state_potential(z, HistBins=HistBins))
    yoffset=min(SteadyStatePotnl[1])
    SteadyStatePotnl[1] -= yoffset

    SpringPotnlFunc = dynamical_potential(z, dt)
    SpringPotnl = SpringPotnlFunc(z)
    kBT_Gamma = temp*boltzmann*1/Damping
    
    #FitSoln = least_squares(GetResiduals, 50, args=(SteadyStatePotnl, SpringPotnlFunc, kBT_Gamma), full_output=True)
    #print(FitSoln)
    #RADIUS = FitSoln['x'][0]

    DynamicPotentialFunc = MakeDynamicPotentialFunc(kBT_Gamma, density, SpringPotnlFunc)
    FitSoln = curve_fit(DynamicPotentialFunc, SteadyStatePotnl[0], SteadyStatePotnl[1], p0 = 50)
    print(FitSoln)
    popt, pcov = FitSoln
    perr = np.sqrt(np.diag(pcov))
    Radius, RadiusError = popt[0], perr[0]

    mass=((4/3)*np.pi*((Radius*10**-9)**3))*density
    yfit=(kBT_Gamma/mass)
    Y = yfit*SpringPotnl
    
    fig, ax = plt.subplots()
    ax.plot(SteadyStatePotnl[0], SteadyStatePotnl[1], 'bo', label=""Steady State Potential"")
    plt.plot(z,Y, 'r-', label=""Dynamical Potential"")
    ax.legend(loc='best')
    ax.set_ylabel('U ($k_{B} T $ Joules)')
    ax.set_xlabel('Distance (mV)')
    plt.tight_layout()
    plt.show()
    return Radius, RadiusError"
2967,"def MakeDynamicPotentialFunc(kBT_Gamma, density, SpringPotnlFunc):
    """"""
    Creates the function that calculates the potential given
    the position (in volts) and the radius of the particle. 

    Parameters
    ----------
    kBT_Gamma : float
        Value of kB*T/Gamma
    density : float
        density of the nanoparticle
    SpringPotnlFunc : function
        Function which takes the value of position (in volts)
        and returns the spring potential
    
    Returns
    -------
    PotentialFunc : function
        function that calculates the potential given
        the position (in volts) and the radius of the 
        particle.

    """"""
    def PotentialFunc(xdata, Radius):
        """"""
        calculates the potential given the position (in volts) 
        and the radius of the particle.

        Parameters
        ----------
        xdata : ndarray
            Positon data (in volts)
        Radius : float
            Radius in units of nm

        Returns
        -------
        Potential : ndarray
            Dynamical Spring Potential at positions given by xdata
        """"""
        mass = ((4/3)*np.pi*((Radius*10**-9)**3))*density
        yfit=(kBT_Gamma/mass)
        Y = yfit*SpringPotnlFunc(xdata)
        return Y
    return PotentialFunc"
2968,"def finished(finished_status,
             update_interval,
             status_key,
             edit_at_key):
    """"""
    Create dict query for pymongo that getting all finished task.

    :param finished_status: int, status code that greater or equal than this
        will be considered as finished.
    :param update_interval: int, the record will be updated every x seconds.
    :param status_key: status code field key, support dot notation.
    :param edit_at_key: edit_at time field key, support dot notation.

    :return: dict, a pymongo filter.

    **中文文档**

    状态码大于某个值, 并且, 更新时间在最近一段时间以内.
    """"""
    return {
        status_key: {""$gte"": finished_status},
        edit_at_key: {
            ""$gte"": x_seconds_before_now(update_interval),
        },
    }"
2969,"def unfinished(finished_status,
               update_interval,
               status_key,
               edit_at_key):
    """"""
    Create dict query for pymongo that getting all unfinished task.

    :param finished_status: int, status code that less than this
        will be considered as unfinished.
    :param update_interval: int, the record will be updated every x seconds.
    :param status_key: status code field key, support dot notation.
    :param edit_at_key: edit_at time field key, support dot notation.

    :return: dict, a pymongo filter.


    **中文文档**

    状态码小于某个值, 或者, 现在距离更新时间已经超过一定阈值.
    """"""
    return {
        ""$or"": [
            {status_key: {""$lt"": finished_status}},
            {edit_at_key: {""$lt"": x_seconds_before_now(update_interval)}},
        ]
    }"
2970,"def getCommandLine(self):
        """"""Insert the precursor and change directory commands
        """"""
        commandLine = self.precursor + self.sep if self.precursor else ''
        commandLine += self.cd + ' ' + self.path + self.sep if self.path else ''
        commandLine += PosixCommand.getCommandLine(self)
        return commandLine"
2971,"def _policy_psets(policy_instances):
    """"""Find all permission sets making use of all of a list of policy_instances.
    The input is an array of policy instances.

    """"""
    if len(policy_instances) == 0:
        # Special case: find any permission sets that don't have
        # associated policy instances.
        return PermissionSet.objects.filter(policyinstance__isnull=True)
    else:
        return PermissionSet.objects.filter(
            policyinstance__policy__in=policy_instances).distinct()"
2972,"def _get_permission_set_tree(user):
    """"""
    Helper to return cached permission set tree from user instance if set, else
    generates and returns analyzed permission set tree. Does not cache set
    automatically, that must be done explicitely.
    """"""
    if hasattr(user, CACHED_PSET_PROPERTY_KEY):
        return getattr(user, CACHED_PSET_PROPERTY_KEY)
    if user.is_authenticated():
        try:
            return user.permissionset.first().tree()
        except AttributeError:
            raise ObjectDoesNotExist
    return PermissionSet.objects.get(anonymous_user=True).tree()"
2973,"def ensure_permission_set_tree_cached(user):
    """""" Helper to cache permission set tree on user instance """"""
    if hasattr(user, CACHED_PSET_PROPERTY_KEY):
        return
    try:
        setattr(
            user, CACHED_PSET_PROPERTY_KEY, _get_permission_set_tree(user))
    except ObjectDoesNotExist:  # No permission set
        pass"
2974,"def clear_user_policies(user):
    """"""Remove all policies assigned to a user (or the anonymous user if
    ``user`` is ``None``).

    """"""
    if user is None:
        try:
            pset = PermissionSet.objects.get(anonymous_user=True)
            pset.anonymous_user = False
            pset.save()
        except ObjectDoesNotExist:
            return
    else:
        pset = user.permissionset.first()
    if pset:
        pset.refresh()
        if user is not None:
            pset.users.remove(user)
        if pset.users.count() == 0 and not pset.anonymous_user:
            pset.delete()"
2975,"def assign_user_policies(user, *policies_roles):
    """"""Assign a sequence of policies to a user (or the anonymous user is
    ``user`` is ``None``).  (Also installed as ``assign_policies``
    method on ``User`` model.

    """"""
    clear_user_policies(user)
    pset = PermissionSet.objects.by_policies_and_roles(policies_roles)
    pset.refresh()
    if user is None:
        pset.anonymous_user = True
    else:
        pset.users.add(user)
    pset.save()
    cache.set(user_cache_key(user), None)"
2976,"def user_assigned_policies(user):
    """"""Return sequence of policies assigned to a user (or the anonymous
    user is ``user`` is ``None``).  (Also installed as
    ``assigned_policies`` method on ``User`` model.

    """"""
    key = user_cache_key(user)
    cached = cache.get(key)
    if cached is not None:
        return cached

    if user is None:
        pset = PermissionSet.objects.filter(anonymous_user=True).first()
    else:
        pset = user.permissionset.first()
    if pset is None:
        return []

    res = []
    skip_role_policies = False
    skip_role = None
    skip_role_variables = None
    for pi in pset.policyinstance_set.select_related('policy', 'role'):
        if skip_role_policies:
            if pi.role == skip_role and pi.variables == skip_role_variables:
                continue
            else:
                skip_role_policies = False
        if pi.role:
            res.append(pi.role)
            skip_role = pi.role
            skip_role_variables = pi.variables
            skip_role_policies = True
        else:
            if pi.variables != '{}':
                res.append((pi.policy, json.loads(pi.variables)))
            else:
                res.append(pi.policy)
    cache.set(key, res)
    return res"
2977,"def parsed(self):
        """"""Get the JSON dictionary object which represents the content.

        This property is cached and only parses the content once.
        """"""
        if not self._parsed:

            self._parsed = json.loads(self.content)

        return self._parsed"
2978,"def cleanup_logger(self):
        """"""Clean up logger to close out file handles.

        After this is called, writing to self.log will get logs ending up
        getting discarded.
        """"""
        self.log_handler.close()
        self.log.removeHandler(self.log_handler)"
2979,"def update_configs(self, release):
        """""" Update the fedora-atomic.git repositories for a given release """"""
        git_repo = release['git_repo']
        git_cache = release['git_cache']
        if not os.path.isdir(git_cache):
            self.call(['git', 'clone', '--mirror', git_repo, git_cache])
        else:
            self.call(['git', 'fetch', '--all', '--prune'], cwd=git_cache)
        git_dir = release['git_dir'] = os.path.join(release['tmp_dir'],
                                                    os.path.basename(git_repo))
        self.call(['git', 'clone', '-b', release['git_branch'],
                   git_cache, git_dir])

        if release['delete_repo_files']:
            for repo_file in glob.glob(os.path.join(git_dir, '*.repo')):
                self.log.info('Deleting %s' % repo_file)
                os.unlink(repo_file)"
2980,"def mock_cmd(self, release, *cmd, **kwargs):
        """"""Run a mock command in the chroot for a given release""""""
        fmt = '{mock_cmd}'
        if kwargs.get('new_chroot') is True:
            fmt +=' --new-chroot'
        fmt += ' --configdir={mock_dir}'
        return self.call(fmt.format(**release).split()
                         + list(cmd))"
2981,"def init_mock(self, release):
        """"""Initialize/update our mock chroot""""""
        root = '/var/lib/mock/%s' % release['mock']
        if not os.path.isdir(root):
            self.mock_cmd(release, '--init')
            self.log.info('mock chroot initialized')
        else:
            if release.get('mock_clean'):
                self.mock_cmd(release, '--clean')
                self.mock_cmd(release, '--init')
                self.log.info('mock chroot cleaned & initialized')
            else:
                self.mock_cmd(release, '--update')
                self.log.info('mock chroot updated')"
2982,"def generate_mock_config(self, release):
        """"""Dynamically generate our mock configuration""""""
        mock_tmpl = pkg_resources.resource_string(__name__, 'templates/mock.mako')
        mock_dir = release['mock_dir'] = os.path.join(release['tmp_dir'], 'mock')
        mock_cfg = os.path.join(release['mock_dir'], release['mock'] + '.cfg')
        os.mkdir(mock_dir)
        for cfg in ('site-defaults.cfg', 'logging.ini'):
            os.symlink('/etc/mock/%s' % cfg, os.path.join(mock_dir, cfg))
        with file(mock_cfg, 'w') as cfg:
            mock_out = Template(mock_tmpl).render(**release)
            self.log.debug('Writing %s:\n%s', mock_cfg, mock_out)
            cfg.write(mock_out)"
2983,"def mock_chroot(self, release, cmd, **kwargs):
        """"""Run a commend in the mock container for a release""""""
        return self.mock_cmd(release, '--chroot', cmd, **kwargs)"
2984,"def generate_repo_files(self, release):
        """"""Dynamically generate our yum repo configuration""""""
        repo_tmpl = pkg_resources.resource_string(__name__, 'templates/repo.mako')
        repo_file = os.path.join(release['git_dir'], '%s.repo' % release['repo'])
        with file(repo_file, 'w') as repo:
            repo_out = Template(repo_tmpl).render(**release)
            self.log.debug('Writing repo file %s:\n%s', repo_file, repo_out)
            repo.write(repo_out)
        self.log.info('Wrote repo configuration to %s', repo_file)"
2985,"def ostree_init(self, release):
        """"""Initialize the OSTree for a release""""""
        out = release['output_dir'].rstrip('/')
        base = os.path.dirname(out)
        if not os.path.isdir(base):
            self.log.info('Creating %s', base)
            os.makedirs(base, mode=0755)
        if not os.path.isdir(out):
            self.mock_chroot(release, release['ostree_init'])"
2986,"def ostree_compose(self, release):
        """"""Compose the OSTree in the mock container""""""
        start = datetime.utcnow()
        treefile = os.path.join(release['git_dir'], 'treefile.json')
        cmd = release['ostree_compose'] % treefile
        with file(treefile, 'w') as tree:
            json.dump(release['treefile'], tree)
        # Only use new_chroot for the invocation, as --clean and --new-chroot are buggy together right now
        out, err, rcode = self.mock_chroot(release, cmd, new_chroot=True)
        ref = None
        commitid = None
        for line in out.split('\n'):
            if ' => ' in line:
                # This line is the: ref => commitid line
                line = line.replace('\n', '')
                ref, _, commitid = line.partition(' => ')
        self.log.info('rpm-ostree compose complete (%s), ref %s, commitid %s',
                      datetime.utcnow() - start, ref, commitid)
        return ref, commitid"
2987,"def update_ostree_summary(self, release):
        """"""Update the ostree summary file and return a path to it""""""
        self.log.info('Updating the ostree summary for %s', release['name'])
        self.mock_chroot(release, release['ostree_summary'])
        return os.path.join(release['output_dir'], 'summary')"
2988,"def sync_in(self, release):
        """"""Sync the canonical repo to our local working directory""""""
        tree = release['canonical_dir']
        if os.path.exists(tree) and release.get('rsync_in_objs'):
            out = release['output_dir']
            if not os.path.isdir(out):
                self.log.info('Creating %s', out)
                os.makedirs(out)
            self.call(release['rsync_in_objs'])
            self.call(release['rsync_in_rest'])"
2989,"def sync_out(self, release):
        """"""Sync our tree to the canonical location""""""
        if release.get('rsync_out_objs'):
            tree = release['canonical_dir']
            if not os.path.isdir(tree):
                self.log.info('Creating %s', tree)
                os.makedirs(tree)
            self.call(release['rsync_out_objs'])
            self.call(release['rsync_out_rest'])"
2990,"def call(self, cmd, **kwargs):
        """"""A simple subprocess wrapper""""""
        if isinstance(cmd, basestring):
            cmd = cmd.split()
        self.log.info('Running %s', cmd)
        p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE, **kwargs)
        out, err = p.communicate()
        if out:
            self.log.info(out)
        if err:
            if p.returncode == 0:
                self.log.info(err)
            else:
                self.log.error(err)
        if p.returncode != 0:
            self.log.error('returncode = %d' % p.returncode)
            raise Exception
        return out, err, p.returncode"
2991,"def merge(self, other):
        """"""
        Merge this range object with another (ranges need not overlap or abut).

        :returns: a new Range object representing the interval containing both
                  ranges.
        """"""
        newstart = min(self._start, other.start)
        newend = max(self._end, other.end)
        return Range(newstart, newend)"
2992,"def intersect(self, other):
        """"""
        Determine the interval of overlap between this range and another.

        :returns: a new Range object representing the overlapping interval,
                  or `None` if the ranges do not overlap.
        """"""
        if not self.overlap(other):
            return None

        newstart = max(self._start, other.start)
        newend = min(self._end, other.end)
        return Range(newstart, newend)"
2993,"def overlap(self, other):
        """"""Determine whether this range overlaps with another.""""""
        if self._start < other.end and self._end > other.start:
            return True
        return False"
2994,"def contains(self, other):
        """"""Determine whether this range contains another.""""""
        return self._start <= other.start and self._end >= other.end"
2995,"def transform(self, offset):
        """"""
        Shift this range by the specified offset.

        Note: the resulting range must be a valid interval.
        """"""
        assert self._start + offset > 0, \
            ('offset {} invalid; resulting range [{}, {}) is '
             'undefined'.format(offset, self._start+offset, self._end+offset))
        self._start += offset
        self._end += offset"
2996,"def runningMedian(seq, M):
    """"""
     Purpose: Find the median for the points in a sliding window (odd number in size)
              as it is moved from left to right by one point at a time.
      Inputs:
            seq -- list containing items for which a running median (in a sliding window)
                   is to be calculated
              M -- number of items in window (window size) -- must be an integer > 1
      Otputs:
         medians -- list of medians with size N - M + 1
       Note:
         1. The median of a finite list of numbers is the ""center"" value when this list
            is sorted in ascending order.
         2. If M is an even number the two elements in the window that
            are close to the center are averaged to give the median (this
            is not by definition)
    """"""
    seq = iter(seq)
    s = []
    m = M // 2 #// does a truncated division like integer division in Python 2

    # Set up list s (to be sorted) and load deque with first window of seq
    s = [item for item in islice(seq,M)]
    d = deque(s)

    # Simple lambda function to handle even/odd window sizes
    median = lambda : s[m] if bool(M&1) else (s[m-1]+s[m])*0.5

    # Sort it in increasing order and extract the median (""center"" of the sorted window)
    s.sort()
    medians = [median()]

    # Now slide the window by one point to the right for each new position (each pass through
    # the loop). Stop when the item in the right end of the deque contains the last item in seq
    for item in seq:
        old = d.popleft()          # pop oldest from left
        d.append(item)             # push newest in from right
        del s[bisect_left(s, old)] # locate insertion point and then remove old
        insort(s, item)            # insert newest such that new sort is not required
        medians.append(median())
    return medians"
2997,"def runningMean(seq, N, M):
    """"""
     Purpose: Find the mean for the points in a sliding window (fixed size)
              as it is moved from left to right by one point at a time.
      Inputs:
          seq -- list containing items for which a mean (in a sliding window) is
                 to be calculated (N items)
            N -- length of sequence
            M -- number of items in sliding window
      Otputs:
        means -- list of means with size N - M + 1
    """"""
    # Load deque (d) with first window of seq
    d = deque(seq[0:M])
    means = [sum(d) / len(d)] # contains mean of first window
    # Now slide the window by one point to the right for each new position (each pass through
    # the loop). Stop when the item in the right end of the deque contains the last item in seq
    for item in islice(seq, M, N):
        old = d.popleft()            # pop oldest from left
        d.append(item)               # push newest in from right
        m = sum(d) / len(d)
        means.append(m)     # mean for current window
    return means"
2998,"def behave(cmdline, cwd=""."", **kwargs):
    """"""
    Run behave as subprocess command and return process/shell instance
    with results (collected output, returncode).
    """"""
    assert isinstance(cmdline, six.string_types)
    return run(""behave "" + cmdline, cwd=cwd, **kwargs)"
2999,"def run(cls, command, cwd=""."", **kwargs):
        """"""
        Make a subprocess call, collect its output and returncode.
        Returns CommandResult instance as ValueObject.
        """"""
        assert isinstance(command, six.string_types)
        command_result = CommandResult()
        command_result.command = command
        use_shell = cls.USE_SHELL
        if ""shell"" in kwargs:
            use_shell = kwargs.pop(""shell"")

        # -- BUILD COMMAND ARGS:
        if six.PY2 and isinstance(command, six.text_type):
            # -- PREPARE-FOR: shlex.split()
            # In PY2, shlex.split() requires bytes string (non-unicode).
            # In PY3, shlex.split() accepts unicode string.
            command = codecs.encode(command, ""utf-8"")
        cmdargs = shlex.split(command)

        # -- TRANSFORM COMMAND (optional)
        command0 = cmdargs[0]
        real_command = cls.COMMAND_MAP.get(command0, None)
        if real_command:
            cmdargs0 = real_command.split()
            cmdargs = cmdargs0 + cmdargs[1:]
        preprocessors = cls.PREPROCESSOR_MAP.get(command0)
        if preprocessors:
            cmdargs = cls.preprocess_command(preprocessors, cmdargs, command, cwd)


        # -- RUN COMMAND:
        try:
            process = subprocess.Popen(cmdargs,
                            stdout=subprocess.PIPE,
                            stderr=subprocess.PIPE,
                            universal_newlines=True,
                            shell=use_shell,
                            cwd=cwd, **kwargs)
            out, err = process.communicate()
            if six.PY2: # py3: we get unicode strings, py2 not
                default_encoding = 'UTF-8'
                out = six.text_type(out, process.stdout.encoding or default_encoding)
                err = six.text_type(err, process.stderr.encoding or default_encoding)
            process.poll()
            assert process.returncode is not None
            command_result.stdout = out
            command_result.stderr = err
            command_result.returncode = process.returncode
            if cls.DEBUG:
                print(""shell.cwd={0}"".format(kwargs.get(""cwd"", None)))
                print(""shell.command: {0}"".format("" "".join(cmdargs)))
                print(""shell.command.output:\n{0};"".format(command_result.output))
        except OSError as e:
            command_result.stderr = u""OSError: %s"" % e
            command_result.returncode = e.errno
            assert e.errno != 0

        postprocessors = cls.POSTPROCESSOR_MAP.get(command0)
        if postprocessors:
            command_result = cls.postprocess_command(postprocessors, command_result)
        return command_result"
3000,"def get_field_template(self, bound_field, template_name=None):
        """"""
        Uses a special field template for widget with multiple inputs. It only
        applies if no other template than the default one has been defined.
        """"""
        template_name = super().get_field_template(bound_field, template_name)

        if (template_name == self.field_template and
                isinstance(bound_field.field.widget, (
                    forms.RadioSelect, forms.CheckboxSelectMultiple))):
            return 'tapeforms/fields/foundation_fieldset.html'

        return template_name"
3001,"def printer(self):
        """"""Prints PDA state attributes""""""
        print "" ID "" + repr(self.id)
        if self.type == 0:
            print "" Tag: - ""
            print "" Start State - ""
        elif self.type == 1:
            print "" Push "" + repr(self.sym)
        elif self.type == 2:
            print "" Pop State "" + repr(self.sym)
        elif self.type == 3:
            print "" Read State "" + repr(self.sym)
        elif self.type == 4:
            print "" Stop State "" + repr(self.sym)
        for j in self.trans:
            if len(self.trans[j]) > 1 or (len(self.trans[j]) == 1):
                for symbol in self.trans[j]:
                    print "" On Symbol "" + repr(symbol) + "" Transition To State "" + repr(j)"
3002,"def printer(self):
        """"""Prints PDA states and their attributes""""""
        i = 0
        while i < self.n + 1:
            print ""--------- State No --------"" + repr(i)
            self.s[i].printer()
            i = i + 1"
3003,"def consume_input(self, mystr, stack=[], state=1, curchar=0, depth=0):
        """"""
        Consumes an input and validates if it is accepted
        Args:
            mystr (str): the input string to be consumes
            stack (list): the stack of symbols
            state (int): the current state of the PDA
            curchar (int): the index of the consumed character
            depth (int): the depth of the function call in the stack
        Returns:
            bool: A value indicating the correct or erroneous execution
        """"""
        mystrsplit = mystr.split(' ')
        if self.s[state].type == 1:
            stack.append(self.s[state].sym)
            if len(self.s[state].trans) > 0:
                state = self.s[state].trans[0]
                if self.parse(
                        mystr,
                        stack=stack,
                        state=state,
                        curchar=curchar,
                        depth=depth + 1) == 1:
                    return True
            return False
        if self.s[state].type == 2:
            if len(stack) == 0:
                return False
            sym = stack.pop()
            for key in self.s[state].trans:
                if sym in self.s[state].trans[key]:
                    if self.parse(
                            mystr,
                            stack=stack,
                            state=key,
                            curchar=curchar,
                            depth=depth + 1) == 1:
                        return True
            return False
        if self.s[state].type == 3:
            for key in self.s[state].trans:
                if mystrsplit[curchar] in self.s[state].trans[key]:
                    # print 'found '
                    if curchar + 1 == len(mystrsplit) \
                            and 'closing' in self.s[key].trans:
                        return True
                    elif curchar + 1 == len(mystrsplit):
                        return False

                    # print 'lets try as next state the state ' + repr(key)
                    if self.parse(
                            mystr,
                            stack=stack,
                            state=key,
                            curchar=curchar + 1,
                            depth=depth + 1) == 1:
                        return True
            return False"
3004,"def _CreateDatabase(self):
    """""" Create all database tables. """"""
    goodlogging.Log.Info(""DB"", ""Initialising new database"", verbosity=self.logVerbosity)

    with sqlite3.connect(self._dbPath) as db:
      # Configuration tables
      db.execute(""CREATE TABLE Config (""
                  ""Name TEXT UNIQUE NOT NULL, ""
                  ""Value TEXT)"")

      db.execute(""CREATE TABLE IgnoredDir (""
                  ""DirName TEXT UNIQUE NOT NULL)"")

      db.execute(""CREATE TABLE SupportedFormat (""
                  ""FileFormat TEXT UNIQUE NOT NULL)"")

      # Look-up tables
      db.execute(""CREATE TABLE TVLibrary (""
                  ""ShowID INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, ""
                  ""ShowName TEXT UNIQUE NOT NULL, ""
                  ""ShowDir TEXT UNIQUE)"")

      db.execute(""CREATE TABLE FileName (""
                  ""FileName TEXT UNIQUE NOT NULL, ""
                  ""ShowID INTEGER, ""
                  ""FOREIGN KEY (ShowID) REFERENCES ShowName(ShowID))"")

      db.execute(""CREATE TABLE SeasonDir (""
                  ""ShowID INTEGER, ""
                  ""Season INTEGER NOT NULL, ""
                  ""SeasonDir TEXT NOT NULL, ""
                  ""FOREIGN KEY (ShowID) REFERENCES ShowName(ShowID),""
                  ""CONSTRAINT SeasonDirPK PRIMARY KEY (ShowID,Season))"")

      db.commit()

    goodlogging.Log.Info(""DB"", ""Database initialisation complete"", verbosity=self.logVerbosity)"
3005,"def _ActionDatabase(self, cmd, args = None, commit = True, error = True):
    """"""
    Do action on database.

    Parameters
    ----------
      cmd : string
        SQL command.

      args : tuple [optional : default = None]
        Arguments to be passed along with the SQL command.
        e.g. cmd=""SELECT Value FROM Config WHERE Name=?"" args=(fieldName, )

      commit : boolean [optional : default = True]
        If true commit database changes after command is executed.

      error : boolean [optional : default = True]
        If False then any sqlite3.OperationalError exceptions will cause this
        function to return None, otherwise the exception will be raised.

    Returns
    ----------
      If a valid result is obtained from the database this will be returned.
      If an error occurs and the error argument is set to False then the
      return value will be None.
    """"""
    goodlogging.Log.Info(""DB"", ""Database Command: {0} {1}"".format(cmd, args), verbosity=self.logVerbosity)
    with sqlite3.connect(self._dbPath) as db:
      try:
        if args is None:
          result = db.execute(cmd)
        else:
          result = db.execute(cmd, args)
      except sqlite3.OperationalError:
        if error is True:
          raise
        return None
      else:
        if commit is True:
          db.commit()
        return result.fetchall()"
3006,"def _PurgeTable(self, tableName):
    """"""
    Deletes all rows from given table without dropping table.

    Parameters
    ----------
      tableName : string
        Name of table.
    """"""
    goodlogging.Log.Info(""DB"", ""Deleting all entries from table {0}"".format(tableName), verbosity=self.logVerbosity)
    self._ActionDatabase(""DELETE FROM {0}"".format(tableName))"
3007,"def GetConfigValue(self, fieldName):
    """"""
    Match given field name in Config table and return corresponding value.

    Parameters
    ----------
      fieldName : string
        String matching Name column in Config table.

    Returns
    ----------
      string or None
        If a match is found the corresponding entry in the Value column of the
        database table is returned, otherwise None is returned (or if multiple
        matches are found a fatal error is raised).
    """"""
    result = self._ActionDatabase(""SELECT Value FROM Config WHERE Name=?"", (fieldName, ))

    if result is None:
      return None
    elif len(result) == 0:
      return None
    elif len(result) == 1:
      goodlogging.Log.Info(""DB"", ""Found database match in config table {0}={1}"".format(fieldName, result[0][0]), verbosity=self.logVerbosity)
      return result[0][0]
    elif len(result) > 1:
      goodlogging.Log.Fatal(""DB"", ""Database corrupted - multiple matches found in config table {0}={1}"".format(fieldName, result))"
3008,"def SetConfigValue(self, fieldName, value):
    """"""
    Set value in Config table.

    If a entry already exists this is updated with the new value, otherwise
    a new entry is added.

    Parameters
    ----------
      fieldName : string
        String to be inserted or matched against Name column in Config table.

      value : string
        Entry to be inserted or updated in Value column of Config table.
    """"""
    currentConfigValue = self.GetConfigValue(fieldName)

    if currentConfigValue is None:
      goodlogging.Log.Info(""DB"", ""Adding {0}={1} to database config table"".format(fieldName, value), verbosity=self.logVerbosity)
      self._ActionDatabase(""INSERT INTO Config VALUES (?,?)"", (fieldName, value))
    else:
      goodlogging.Log.Info(""DB"", ""Updating {0} in database config table from {1} to {2}"".format(fieldName, currentConfigValue, value), verbosity=self.logVerbosity)
      self._ActionDatabase(""UPDATE Config SET Value=? WHERE Name=?"", (value, fieldName))"
3009,"def _AddToSingleColumnTable(self, tableName, columnHeading, newValue):
    """"""
    Add an entry to a table containing a single column. Checks existing
    table entries to avoid duplicate entries if the given value already
    exists in the table.

    Parameters
    ----------
      tableName : string
        Name of table to add entry to.

      columnHeading : string
        Name of column heading.

      newValue : string
        New value to add to table.
    """"""
    match = None
    currentTable = self._GetFromSingleColumnTable(tableName)

    if currentTable is not None:
      for currentValue in currentTable:
        if currentValue == newValue:
          match = True

    if match is None:
      goodlogging.Log.Info(""DB"", ""Adding {0} to {1} table"".format(newValue, tableName), verbosity=self.logVerbosity)
      self._ActionDatabase(""INSERT INTO {0} VALUES (?)"".format(tableName), (newValue, ))
    else:
      goodlogging.Log.Info(""DB"", ""{0} already exists in {1} table"".format(newValue, tableName), verbosity=self.logVerbosity)

  ############################################################################
  # _GetFromSingleColumnTable
  ############################################################################
    """"""
    Get all entries from a table containing a single column.

    Parameters
    ----------
      tableName : string
        Name of table to add entry to.

    Returns
    ----------
      list or None
        If either no table or no rows are found this returns None, otherwise a
        list of all table entries is returned.
    """""""
3010,"def AddShowToTVLibrary(self, showName):
    """"""
    Add show to TVLibrary table. If the show already exists in the table
    a fatal error is raised.

    Parameters
    ----------
      showName : string
        Show name to add to TV library table.

    Returns
    ----------
      int
        Unique show id generated for show when it is added to the table. Used
        across the database to reference this show.
    """"""
    goodlogging.Log.Info(""DB"", ""Adding {0} to TV library"".format(showName), verbosity=self.logVerbosity)

    currentShowValues = self.SearchTVLibrary(showName = showName)

    if currentShowValues is None:
      self._ActionDatabase(""INSERT INTO TVLibrary (ShowName) VALUES (?)"", (showName, ))
      showID = self._ActionDatabase(""SELECT (ShowID) FROM TVLibrary WHERE ShowName=?"", (showName, ))[0][0]
      return showID
    else:
      goodlogging.Log.Fatal(""DB"", ""An entry for {0} already exists in the TV library"".format(showName))"
3011,"def UpdateShowDirInTVLibrary(self, showID, showDir):
    """"""
    Update show directory entry for given show id in TVLibrary table.

    Parameters
    ----------
      showID : int
        Show id value.

      showDir : string
        Show directory name.
    """"""
    goodlogging.Log.Info(""DB"", ""Updating TV library for ShowID={0}: ShowDir={1}"".format(showID, showDir))
    self._ActionDatabase(""UPDATE TVLibrary SET ShowDir=? WHERE ShowID=?"", (showDir, showID))"
3012,"def SearchTVLibrary(self, showName = None, showID = None, showDir = None):
    """"""
    Search TVLibrary table.

    If none of the optonal arguments are given it looks up all entries of the
    table, otherwise it will look up entries which match the given arguments.

    Note that it only looks up based on one argument - if show directory is
    given this will be used, otherwise show id will be used if it is given,
    otherwise show name will be used.

    Parameters
    ----------
      showName : string [optional : default = None]
        Show name.

      showID : int [optional : default = None]
        Show id value.

      showDir : string [optional : default = None]
        Show directory name.

    Returns
    ----------
      list or None
        If no result is found this returns None otherwise it will return a the
        result of the SQL query as a list. In the case that the result is expected
        to be unique and multiple entries are return a fatal error will be raised.
    """"""
    unique = True
    if showName is None and showID is None and showDir is None:
      goodlogging.Log.Info(""DB"", ""Looking up all items in TV library"", verbosity=self.logVerbosity)
      queryString = ""SELECT * FROM TVLibrary""
      queryTuple = None
      unique = False
    elif showDir is not None:
      goodlogging.Log.Info(""DB"", ""Looking up from TV library where ShowDir is {0}"".format(showDir), verbosity=self.logVerbosity)
      queryString = ""SELECT * FROM TVLibrary WHERE ShowDir=?""
      queryTuple = (showDir, )
    elif showID is not None:
      goodlogging.Log.Info(""DB"", ""Looking up from TV library where ShowID is {0}"".format(showID), verbosity=self.logVerbosity)
      queryString = ""SELECT * FROM TVLibrary WHERE ShowID=?""
      queryTuple = (showID, )
    elif showName is not None:
      goodlogging.Log.Info(""DB"", ""Looking up from TV library where ShowName is {0}"".format(showName), verbosity=self.logVerbosity)
      queryString = ""SELECT * FROM TVLibrary WHERE ShowName=?""
      queryTuple = (showName, )

    result = self._ActionDatabase(queryString, queryTuple, error = False)

    if result is None:
      return None
    elif len(result) == 0:
      return None
    elif len(result) == 1:
      goodlogging.Log.Info(""DB"", ""Found match in TVLibrary: {0}"".format(result), verbosity=self.logVerbosity)
      return result
    elif len(result) > 1:
      if unique is True:
        goodlogging.Log.Fatal(""DB"", ""Database corrupted - multiple matches found in TV Library: {0}"".format(result))
      else:
        goodlogging.Log.Info(""DB"", ""Found multiple matches in TVLibrary: {0}"".format(result), verbosity=self.logVerbosity)
        return result"
3013,"def SearchFileNameTable(self, fileName):
    """"""
    Search FileName table.

    Find the show id for a given file name.

    Parameters
    ----------
      fileName : string
        File name to look up in table.

    Returns
    ----------
      int or None
        If a match is found in the database table the show id for this
        entry is returned, otherwise this returns None.
    """"""
    goodlogging.Log.Info(""DB"", ""Looking up filename string '{0}' in database"".format(fileName), verbosity=self.logVerbosity)

    queryString = ""SELECT ShowID FROM FileName WHERE FileName=?""
    queryTuple = (fileName, )

    result = self._ActionDatabase(queryString, queryTuple, error = False)

    if result is None:
      goodlogging.Log.Info(""DB"", ""No match found in database for '{0}'"".format(fileName), verbosity=self.logVerbosity)
      return None
    elif len(result) == 0:
      return None
    elif len(result) == 1:
      goodlogging.Log.Info(""DB"", ""Found file name match: {0}"".format(result), verbosity=self.logVerbosity)
      return result[0][0]
    elif len(result) > 1:
      goodlogging.Log.Fatal(""DB"", ""Database corrupted - multiple matches found in database table for: {0}"".format(result))"
3014,"def AddToFileNameTable(self, fileName, showID):
    """"""
    Add entry to FileName table. If the file name and show id combination
    already exists in the table a fatal error is raised.

    Parameters
    ----------
      fileName : string
        File name.

      showID : int
        Show id.
    """"""
    goodlogging.Log.Info(""DB"", ""Adding filename string match '{0}'={1} to database"".format(fileName, showID), verbosity=self.logVerbosity)

    currentValues = self.SearchFileNameTable(fileName)

    if currentValues is None:
      self._ActionDatabase(""INSERT INTO FileName (FileName, ShowID) VALUES (?,?)"", (fileName, showID))
    else:
      goodlogging.Log.Fatal(""DB"", ""An entry for '{0}' already exists in the FileName table"".format(fileName))"
3015,"def SearchSeasonDirTable(self, showID, seasonNum):
    """"""
    Search SeasonDir table.

    Find the season directory for a given show id and season combination.

    Parameters
    ----------
      showID : int
        Show id for given show.

      seasonNum : int
        Season number.

    Returns
    ----------
      string or None
        If no match is found this returns None, if a single match is found
        then the season directory name value is returned. If multiple matches
        are found a fatal error is raised.
    """"""
    goodlogging.Log.Info(""DB"", ""Looking up directory for ShowID={0} Season={1} in database"".format(showID, seasonNum), verbosity=self.logVerbosity)

    queryString = ""SELECT SeasonDir FROM SeasonDir WHERE ShowID=? AND Season=?""
    queryTuple = (showID, seasonNum)

    result = self._ActionDatabase(queryString, queryTuple, error = False)

    if result is None:
      goodlogging.Log.Info(""DB"", ""No match found in database"", verbosity=self.logVerbosity)
      return None
    elif len(result) == 0:
      return None
    elif len(result) == 1:
      goodlogging.Log.Info(""DB"", ""Found database match: {0}"".format(result), verbosity=self.logVerbosity)
      return result[0][0]
    elif len(result) > 1:
      goodlogging.Log.Fatal(""DB"", ""Database corrupted - multiple matches found in database table for: {0}"".format(result))"
3016,"def AddSeasonDirTable(self, showID, seasonNum, seasonDir):
    """"""
    Add entry to SeasonDir table. If a different entry for season directory
    is found for the given show id and season number combination this raises
    a fatal error.

    Parameters
    ----------
      showID : int
        Show id.

      seasonNum : int
        Season number.

      seasonDir : string
        Season directory name.
    """"""
    goodlogging.Log.Info(""DB"", ""Adding season directory ({0}) to database for ShowID={1}, Season={2}"".format(seasonDir, showID, seasonNum), verbosity=self.logVerbosity)

    currentValue = self.SearchSeasonDirTable(showID, seasonNum)

    if currentValue is None:
      self._ActionDatabase(""INSERT INTO SeasonDir (ShowID, Season, SeasonDir) VALUES (?,?,?)"", (showID, seasonNum, seasonDir))
    else:
      if currentValue == seasonDir:
        goodlogging.Log.Info(""DB"", ""A matching entry already exists in the SeasonDir table"", verbosity=self.logVerbosity)
      else:
        goodlogging.Log.Fatal(""DB"", ""A different entry already exists in the SeasonDir table"")"
3017,"def _PrintDatabaseTable(self, tableName, rowSelect = None):
    """"""
    Prints contents of database table. An optional argument (rowSelect) can be
    given which contains a list of column names and values against which to
    search, allowing a subset of the table to be printed.

    Gets database column headings using PRAGMA call. Automatically adjusts
    each column width based on the longest element that needs to be printed

    Parameters
    ----------
      tableName : int
        Name of table to print.

      rowSelect : list of tuples
        A list of column names and values against to search against.

    Returns:
      int
        The number of table rows printed.
    """"""
    goodlogging.Log.Info(""DB"", ""{0}"".format(tableName))
    goodlogging.Log.IncreaseIndent()
    tableInfo = self._ActionDatabase(""PRAGMA table_info({0})"".format(tableName))


    dbQuery = ""SELECT * FROM {0}"".format(tableName)
    dbQueryParams = []

    if rowSelect is not None:
      dbQuery = dbQuery + "" WHERE "" + ' AND '.join(['{0}=?'.format(i) for i, j in rowSelect])
      dbQueryParams = [j for i, j in rowSelect]

    tableData = self._ActionDatabase(dbQuery, dbQueryParams)
    columnCount = len(tableInfo)

    columnWidths = [0]*columnCount

    columnHeadings = []
    for count, column in enumerate(tableInfo):
      columnHeadings.append(column[1])
      columnWidths[count] = len(column[1])

    for row in tableData:
      for count, column in enumerate(row):
        if len(str(column)) > columnWidths[count]:
          columnWidths[count] = len(column)

    printStr = ""|""
    for count, column in enumerate(columnWidths):
      printStr = printStr + "" {{0[{0}]:{1}}} |"".format(count, columnWidths[count])

    goodlogging.Log.Info(""DB"", printStr.format(columnHeadings))
    goodlogging.Log.Info(""DB"", ""-""*(sum(columnWidths)+3*len(columnWidths)+1))

    for row in tableData:
      noneReplacedRow = ['-' if i is None else i for i in row]
      goodlogging.Log.Info(""DB"", printStr.format(noneReplacedRow))

    goodlogging.Log.DecreaseIndent()
    goodlogging.Log.NewLine()

    return len(tableData)"
3018,"def PrintAllTables(self):
    """""" Prints contents of every table. """"""
    goodlogging.Log.Info(""DB"", ""Database contents:\n"")
    for table in self._tableDict.keys():
      self._PrintDatabaseTable(table)"
3019,"def _UpdateDatabaseFromResponse(self, response, mode):
    """"""
    Update database table given a user input in the form
    ""TABLENAME COL1=VAL1 COL2=VAL2"".

    Either ADD or DELETE from table depending on mode argument.

    If the change succeeds the updated table is printed to stdout.

    Parameters
    ----------
      response : string
        User input.

      mode : string
        Valid values are 'ADD' or 'DEL'.

    Returns
    ----------
      None
        Will always return None. There are numerous early returns in the cases
        where the database update cannot proceed for any reason.
    """"""
    # Get tableName from user input (form TABLENAME COL1=VAL1 COL2=VAL2 etc)
    try:
      tableName, tableColumns = response.split(' ', 1)
    except ValueError:
      goodlogging.Log.Info(""DB"", ""Database update failed - failed to extract table name from response"")
      return None

    # Check user input against known table list
    if tableName not in self._tableDict.keys():
      goodlogging.Log.Info(""DB"", ""Database update failed - unkown table name: {0}"".format(tableName))
      return None

    # Build re pattern to extract column from user input (form TABLENAME COL1=VAL1 COL2=VAL2 etc)
    rowSelect = []
    for column in self._tableDict[tableName]:
      colPatternList = ['(?:{0})'.format(i) for i in self._tableDict[tableName] if i != column]
      colPatternList.append('(?:$)')
      colPatternMatch = '|'.join(colPatternList)
      matchPattern = '{0}.*?{1}=(.+?)\s*(?:{2})'.format(tableName, column, colPatternMatch)

      match = re.findall(matchPattern, response)

      # Match should be in form [(VAL1, VAL2, VAL3, etc.)]
      if len(match) == 1:
        rowSelect.append((column, match[0]))
      elif len(match) > 1:
        goodlogging.Log.Info('DB', 'Database update failed - multiple matches found for table {0} column {1}'.format(tableName, column))
        return None

    if len(rowSelect) == 0:
      goodlogging.Log.Info('DB', 'Database update failed - no row selection critera found in response')
      return None

    # Print selected rows
    rowCount = self._PrintDatabaseTable(tableName, rowSelect)

    # Do DELETE flow
    if mode.upper() == 'DEL':
      if rowCount == 0:
        goodlogging.Log.Info(""DB"", ""Database update failed - no rows found for given search critera: {0}"".format(response))
        return None

      deleteConfirmation = goodlogging.Log.Input(""DB"", ""***WARNING*** DELETE THESE ROWS FROM {0} TABLE? [y/n]: "".format(tableName))
      deleteConfirmation = util.ValidUserResponse(deleteConfirmation, ('y', 'n'))

      if deleteConfirmation.lower() == 'n':
        goodlogging.Log.Info(""DB"", ""Database table row delete cancelled"")
        return None

      # Build delete database query (form DELETE FROM TableName WHERE COL1=?, COL2=?)
      dbQuery = ""DELETE FROM {0}"".format(tableName) \
                  + "" WHERE "" \
                  + ' AND '.join(['{0}=?'.format(i) for i, j in rowSelect])
      dbQueryParams = [j for i, j in rowSelect]

      self._ActionDatabase(dbQuery, dbQueryParams)

      goodlogging.Log.Info(""DB"", ""Deleted {0} row(s) from database table {0}:"".format(rowCount, tableName))

    # Do ADD flow
    elif mode.upper() == 'ADD':
      if rowCount != 0:
        goodlogging.Log.Info(""DB"", ""Database update failed - a row already exists for the given critera: {0}"".format(response))
        return None

      # Build insert database query (form INSERT INTO TableName (COL1, COL2) VALUES (?,?))
      dbQuery = ""INSERT INTO {0} ("".format(tableName) \
                  + ', '.join(['{0}'.format(i) for i, j in rowSelect]) \
                  + "") VALUES ("" \
                  + ', '.join(['?']*len(rowSelect)) \
                  + "")""
      dbQueryParams = [j for i, j in rowSelect]

      self._ActionDatabase(dbQuery, dbQueryParams)

      goodlogging.Log.Info(""DB"", ""Added row to database table {0}:"".format(tableName))

    # Print resulting database table
    self._PrintDatabaseTable(tableName)"
3020,"def ManualUpdateTables(self):
    """"""
    Allow user to manually update the database tables.

    User options from initial prompt are:

      - 'ls' : print database contents
      - 'a' : add an row to a database table
      - 'd' : delete a single table row
      - 'p' : delete an entire table (purge)
      - 'f' : finish updates and continue
      - 'x' : finish updates and exit

    Selecting add, delete or purge will proceed to a further prompt where the
    user can enter exactly what information should be added or deleted.
    """"""
    goodlogging.Log.Info(""DB"", ""Starting manual database update:\n"")
    updateFinished = False

    # Loop until the user continues program flow or exits
    while not updateFinished:
      prompt = ""Enter 'ls' to print the database contents, "" \
                     ""'a' to add a table entry, "" \
                     ""'d' to delete a single table row, "" \
                     ""'p' to select a entire table to purge, "" \
                     ""'f' to finish or "" \
                     ""'x' to exit: ""
      response = goodlogging.Log.Input(""DM"", prompt)

      goodlogging.Log.NewLine()
      goodlogging.Log.IncreaseIndent()

      # Exit program
      if response.lower() == 'x':
        goodlogging.Log.Fatal(""DB"", ""Program exited by user response"")

      # Finish updating database
      elif response.lower() == 'f':
        updateFinished = True

      # Print database tables
      elif response.lower() == 'ls':
        self.PrintAllTables()

      # Purge a given table
      elif response.lower() == 'p':
        response = goodlogging.Log.Input(""DM"", ""Enter database table to purge or 'c' to cancel: "")

        # Go back to main update selection
        if response.lower() == 'c':
          goodlogging.Log.Info(""DB"", ""Database table purge cancelled"")

        # Purge table
        else:
          if response in self._tableDict.keys():
            self._PrintDatabaseTable(response)

            deleteConfirmation = goodlogging.Log.Input(""DB"", ""***WARNING*** DELETE ALL ROWS FROM {0} TABLE? [y/n]: "".format(response))
            deleteConfirmation = util.ValidUserResponse(deleteConfirmation, ('y', 'n'))

            if deleteConfirmation.lower() == 'n':
              goodlogging.Log.Info(""DB"", ""Database table purge cancelled"")
            else:
              self._PurgeTable(response)
              goodlogging.Log.Info(""DB"", ""{0} database table purged"".format(response))
          else:
            goodlogging.Log.Info(""DB"", ""Unknown table name ({0}) given to purge"".format(response))

      # Add new row to table
      elif response.lower() == 'a':
        addFinished = False
        while not addFinished:
          prompt = ""Enter new database row (in format TABLE COL1=VAL COL2=VAL etc) "" \
                    ""or 'c' to cancel: ""
          response = goodlogging.Log.Input(""DM"", prompt)

          # Go back to main update selection
          if response.lower() == 'c':
            goodlogging.Log.Info(""DB"", ""Database table add cancelled"")
            addFinished = True

          # Add row to table
          else:
            self._UpdateDatabaseFromResponse(response, 'ADD')

      # Delete row(s) from table
      elif response.lower() == 'd':
        deleteFinished = False
        while not deleteFinished:
          prompt = ""Enter database row to delete (in format TABLE COL1=VAL COL2=VAL etc) "" \
                    ""or 'c' to cancel: ""
          response = goodlogging.Log.Input(""DM"", prompt)

          # Go back to main update selection
          if response.lower() == 'c':
            goodlogging.Log.Info(""DB"", ""Database table row delete cancelled"")
            deleteFinished = True

          # Delete row(s) from table
          else:
            self._UpdateDatabaseFromResponse(response, 'DEL')

      # Unknown user input given
      else:
        goodlogging.Log.Info(""DB"", ""Unknown response"")

      goodlogging.Log.DecreaseIndent()
      goodlogging.Log.NewLine()

    goodlogging.Log.Info(""DB"", ""Manual database update complete."")
    self.PrintAllTables()"
3021,"def _get_minidom_tag_value(station, tag_name):
    """"""get a value from a tag (if it exists)""""""
    tag = station.getElementsByTagName(tag_name)[0].firstChild
    if tag:
        return tag.nodeValue

    return None"
3022,"def _parse(data, obj_name, attr_map):
    """"""parse xml data into a python map""""""
    parsed_xml = minidom.parseString(data)
    parsed_objects = []
    for obj in parsed_xml.getElementsByTagName(obj_name):
        parsed_obj = {}
        for (py_name, xml_name) in attr_map.items():
            parsed_obj[py_name] = _get_minidom_tag_value(obj, xml_name)
        parsed_objects.append(parsed_obj)
    return parsed_objects"
3023,"def get_all_stations(self, station_type=None):
        """"""Returns information of all stations.
        @param<optional> station_type: ['mainline', 'suburban', 'dart']
        """"""
        params = None
        if station_type and station_type in STATION_TYPE_TO_CODE_DICT:
            url = self.api_base_url + 'getAllStationsXML_WithStationType'
            params = {
                'stationType': STATION_TYPE_TO_CODE_DICT[station_type]
            }
        else:
            url = self.api_base_url + 'getAllStationsXML'

        response = requests.get(
            url, params=params, timeout=10)

        if response.status_code != 200:
            return []

        return self._parse_station_list(response.content)"
3024,"def get_all_current_trains(self, train_type=None, direction=None):
        """"""Returns all trains that are due to start in the next 10 minutes
        @param train_type: ['mainline', 'suburban', 'dart']
        """"""
        params = None
        if train_type:
            url = self.api_base_url + 'getCurrentTrainsXML_WithTrainType'
            params = {
                'TrainType': STATION_TYPE_TO_CODE_DICT[train_type]
            }
        else:
            url = self.api_base_url + 'getCurrentTrainsXML'

        response = requests.get(
            url, params=params, timeout=10)

        if response.status_code != 200:
            return []

        trains = self._parse_all_train_data(response.content)

        if direction is not None:
            return self._prune_trains(trains, direction=direction)

        return trains"
3025,"def get_station_by_name(self,
                            station_name,
                            num_minutes=None,
                            direction=None,
                            destination=None,
                            stops_at=None):
        """"""Returns all trains due to serve station `station_name`.
        @param station_code
        @param num_minutes. Only trains within this time. Between 5 and 90
        @param direction Filter by direction. Northbound or Southbound
        @param destination Filter by name of the destination stations
        @param stops_at Filber by name of one of the stops
        """"""
        url = self.api_base_url + 'getStationDataByNameXML'
        params = {
            'StationDesc': station_name
        }
        if num_minutes:
            url = url + '_withNumMins'
            params['NumMins'] = num_minutes

        response = requests.get(
            url, params=params, timeout=10)

        if response.status_code != 200:
            return []

        trains = self._parse_station_data(response.content)
        if direction is not None or destination is not None:
            return self._prune_trains(trains,
                                      direction=direction,
                                      destination=destination,
                                      stops_at=stops_at)

        return trains"
3026,"def _prune_trains(self, trains, direction=None,
                      destination=None, stops_at=None):
        """"""Only return the data matching direction and / or destination.
        If stops_at is set this may do a number of extra HTTP requests
        @param trains list of trains to filter
        @param direction Filter by train direction. Northbound or Southbound
        @param destination Filter by name of the destination stations
        @param stops_at Filber by name of one of the stops
        """"""
        pruned_data = []
        for train in trains:
            append = True
            if direction is not None and train[""direction""] != direction:
                append = False

            if destination is not None and train[""destination""] != destination:
                append = False

            if append and stops_at is not None:
                if stops_at != train['destination']:
                    stops = self.get_train_stops(train[""code""])
                    for stop in stops:
                        append = False
                        if stop[""location""] == stops_at:
                            append = True
                            break

            if append:
                pruned_data.append(train)

        return pruned_data"
3027,"def get_train_stops(self, train_code, date=None):
        """"""Get details for a train.
        @param train_code code for the trian
        @param date Date in format ""15 oct 2017"". If none use today
        """"""
        if date is None:
            date = datetime.date.today().strftime(""%d %B %Y"")

        url = self.api_base_url + 'getTrainMovementsXML'
        params = {
            'TrainId': train_code,
            'TrainDate': date
        }

        response = requests.get(
            url, params=params, timeout=10)

        if response.status_code != 200:
            return []

        return self._parse_train_movement_data(response.content)"
3028,"def fill_fields(self, **kwargs):
        """"""Fills the fields referenced by kwargs keys and fill them with
        the value""""""
        for name, value in kwargs.items():
            field = getattr(self, name)
            field.send_keys(value)"
3029,"def selector(self, fieldname):
        """"""Gets a selector for the given page element as a tuple
        (by, selector)""""""
        finder = self._finders[fieldname]
        return (finder._by, finder._selector)"
3030,"def authorize_url(client_id=None, redirect_uri=None, state=None, scopes=None, show_dialog=False, http_client=None):
    """"""
    Trigger authorization dialog

    :param str client_id: Client ID
    :param str redirect_uri: Application Redirect URI
    :param str state: Application State
    :param List[str] scopes: Scopes to request
    :param bool show_dialog: Show the dialog
    :param http_client: HTTP Client for requests
    :return str Authorize URL
    :rtype str
    """"""
    params = {
        'client_id': client_id or os.environ.get('SPOTIFY_CLIENT_ID'),
        'redirect_uri': redirect_uri or os.environ.get('SPOTIFY_REDIRECT_URI'),
        'state': state or str(uuid.uuid4()).replace('-', ''),
        'scope': ' '.join(scopes) if scopes else '',
        'show_dialog': show_dialog,
        'response_type': 'code'
    }
    query = ['{}={}'.format(k, v) for k, v in params.items()]
    return '{}?{}'.format('https://accounts.spotify.com/authorize', '&'.join(query))"
3031,"def refresh(self):
        """"""
        Refresh the access token
        """"""
        data = {
            'grant_type': 'refresh_token',
            'refresh_token': self._token.refresh_token
        }

        response = self.http_client.post(self.URL, data=data, auth=(self.client_id, self.client_secret))
        response.raise_for_status()
        self._token = Token.from_json(response.json())"
3032,"def instance_of(cls):
    """"""
    Create an invariant requiring the value is an instance of ``cls``.
    """"""
    def check(value):
        return (
            isinstance(value, cls),
            u""{value!r} is instance of {actual!s}, required {required!s}"".format(
                value=value,
                actual=fullyQualifiedName(type(value)),
                required=fullyQualifiedName(cls),
            ),
        )
    return check"
3033,"def provider_of(iface):
    """"""
    Create an invariant requiring the value provides the zope.interface
    ``iface``.
    """"""
    def check(value):
        return (
            iface.providedBy(value),
            u""{value!r} does not provide {interface!s}"".format(
                value=value,
                interface=fullyQualifiedName(iface),
            ),
        )
    return check"
3034,"def temp_dir(suffix='', prefix='tmp', parent_dir=None, make_cwd=False):
    """"""
    Create a temporary directory and optionally change the current
    working directory to it. The directory is deleted when the context
    exits.

    The temporary directory is created when entering the context
    manager, and deleted when exiting it:
    >>> import temporary
    >>> with temporary.temp_dir() as temp_dir:
    ...     assert temp_dir.is_dir()
    >>> assert not temp_dir.exists()

    This time let's make the temporary directory our working directory:
    >>> import os
    >>> with temporary.temp_dir(make_cwd=True) as temp_dir:
    ...     assert str(temp_dir) == os.getcwd()
    >>> assert not str(temp_dir) == os.getcwd()

    The suffix, prefix, and parent_dir options are passed to the
    standard ``tempfile.mkdtemp()`` function:
    >>> with temporary.temp_dir() as p:
    ...     with temporary.temp_dir(suffix='suf', prefix='pre', parent_dir=p) as d:
    ...         assert d.parent == p
    ...         assert d.name.startswith('pre')
    ...         assert d.name.endswith('suf')

    This function can also be used as a decorator, with the in_temp_dir
    alias:
    >>> @temporary.in_temp_dir()
    ... def my_function():
    ...     assert old_cwd != os.getcwd()
    ...
    >>> old_cwd = os.getcwd()
    >>> my_function()
    >>> assert old_cwd == os.getcwd()
    """"""
    prev_cwd = os.getcwd()
    parent_dir = parent_dir if parent_dir is None else str(parent_dir)
    abs_path = tempfile.mkdtemp(suffix, prefix, parent_dir)
    path = pathlib.Path(abs_path)
    try:
        if make_cwd:
            os.chdir(str(abs_path))
        yield path.resolve()
    finally:
        if make_cwd:
            os.chdir(prev_cwd)
        with temporary.util.allow_missing_file():
            shutil.rmtree(str(abs_path))"
3035,"def openSafeReplace(filepath, mode='w+b'):
    """"""Context manager to open a temporary file and replace the original file on
    closing.
    """"""
    tempfileName = None
    #Check if the filepath can be accessed and is writable before creating the
    #tempfile
    if not _isFileAccessible(filepath):
        raise IOError('File %s is not writtable' % (filepath, ))
    with tempfile.NamedTemporaryFile(delete=False, mode=mode) as tmpf:
        tempfileName = tmpf.name
        yield tmpf
    #Check if the filepath can be accessed and is writable before moving the
    #tempfile
    if not _isFileAccessible(filepath):
        raise IOError('File %s is not writtable' % (filepath, ))
    #Note: here unhandled exceptions may still occur because of race conditions,
    #messing things up.
    shutil.move(tempfileName, filepath)"
3036,"def _isFileAccessible(filepath):
    """"""Returns True if the specified filepath is writable.""""""
    directory = os.path.dirname(filepath)
    if not os.access(directory, os.W_OK):
        #Return False if directory does not exist or is not writable
        return False
    if os.path.exists(filepath):
        if not os.access(filepath, os.W_OK):
            #Return False if file is not writable
            return False
        try:
            openfile = os.open(filepath, os.O_WRONLY)
            os.close(openfile)
        except IOError:
            #Return False if file is locked
            return False
    #Return True if file is writtable
    return True"
3037,"def writeJsonZipfile(filelike, data, compress=True, mode='w', name='data'):
    """"""Serializes the objects contained in data to a JSON formated string and
    writes it to a zipfile.

    :param filelike: path to a file (str) or a file-like object
    :param data: object that should be converted to a JSON formated string.
        Objects and types in data must be supported by the json.JSONEncoder or
        have the method ``._reprJSON()`` defined.
    :param compress: bool, True to use zip file compression
    :param mode: 'w' to truncate and write a new file, or 'a' to append to an
        existing file
    :param name: the file name that will be given to the JSON output in the
        archive
    """"""
    zipcomp = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
    with zipfile.ZipFile(filelike, mode, allowZip64=True) as containerFile:
        containerFile.writestr(name, json.dumps(data, cls=MaspyJsonEncoder),
                               zipcomp
                               )"
3038,"def writeBinaryItemContainer(filelike, binaryItemContainer, compress=True):
    """"""Serializes the binaryItems contained in binaryItemContainer and writes
    them into a zipfile archive.

    Examples of binaryItem classes are :class:`maspy.core.Ci` and
    :class:`maspy.core.Sai`. A binaryItem class has to define the function
    ``_reprJSON()`` which returns a JSON formated string representation of the
    class instance. In addition it has to contain an attribute ``.arrays``, a
    dictionary which values are ``numpy.array``, that are serialized to bytes
    and written to the ``binarydata`` file of the zip archive. See
    :func:`_dumpArrayDictToFile()`

    The JSON formated string representation of the binaryItems, together with
    the metadata, necessary to restore serialized numpy arrays, is written
    to the ``metadata`` file of the archive in this form:
    ``[[serialized binaryItem, [metadata of a numpy array, ...]], ...]``

    Use the method :func:`loadBinaryItemContainer()` to restore a
    binaryItemContainer from a zipfile.

    :param filelike: path to a file (str) or a file-like object
    :param binaryItemContainer: a dictionary containing binaryItems
    :param compress: bool, True to use zip file compression
    """"""
    allMetadata = dict()
    binarydatafile = io.BytesIO()
    #Note: It would be possible to sort the items here
    for index, binaryItem in enumerate(viewvalues(binaryItemContainer)):
        metadataList = _dumpArrayDictToFile(binarydatafile, binaryItem.arrays)
        allMetadata[index] = [binaryItem._reprJSON(), metadataList]

    #TODO: Is seek here still necessary?
    binarydatafile.seek(0)

    zipcomp = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
    with zipfile.ZipFile(filelike, 'w', allowZip64=True) as containerFile:
        containerFile.writestr('metadata',
                               json.dumps(allMetadata, cls=MaspyJsonEncoder),
                               zipcomp
                               )
        containerFile.writestr('binarydata', binarydatafile.getvalue(), zipcomp)"
3039,"def _dumpArrayDictToFile(filelike, arrayDict):
    """"""Function to serialize and write ``numpy.array`` contained in a dictionary
    to a file. See also :func:`_dumpArrayToFile` and :func:`_dumpNdarrayToFile`.


    :param filelike: can be a file or a file-like object that provides the
        methods ``.write()`` and ``.tell()``.
    :param arrayDict: a dictionary which values are ``numpy.array``, that are
        serialized to bytes and written to the filelike.

    :returns: a list of metadata dictionaries
        a metadata dictionary contains information necessary to restore the
        ``numpy.arrays`` from the file and the corresponding key from the
        arrayDict as 'arrayKey'.
    """"""
    metadataList = list()
    for arrayKey in sorted(arrayDict):
        array = arrayDict[arrayKey]
        if array.ndim == 1:
            metadata = _dumpArrayToFile(filelike, array)
        else:
            metadata = _dumpNdarrayToFile(filelike, array)
        metadata['arrayKey'] = arrayKey
        metadataList.append(metadata)
    return metadataList"
3040,"def _dumpArrayToFile(filelike, array):
    """"""Serializes a 1-dimensional ``numpy.array`` to bytes, writes the bytes to
    the filelike object and returns a dictionary with metadata, necessary to
    restore the ``numpy.array`` from the file.

    :param filelike: can be a file or a file-like object that provides the
        methods ``.write()`` and ``.tell()``.
    :param array: a 1-dimensional ``numpy.array``

    :returns: a metadata dictionary ::
        {'start': start position in the file, 'end': end position in the file,
         'size': size of the array, 'dtype': numpy data type of the array
         }
    """"""
    bytedata = array.tobytes('C')
    start = filelike.tell()
    end = start + len(bytedata)
    metadata = {'start': start, 'end': end, 'size': array.size,
                'dtype': array.dtype.name
                }
    filelike.write(bytedata)
    return metadata"
3041,"def _dumpNdarrayToFile(filelike, ndarray):
    """"""Serializes an N-dimensional ``numpy.array`` to bytes, writes the bytes to
    the filelike object and returns a dictionary with metadata, necessary to
    restore the ``numpy.array`` from the file.

    :param filelike: can be a file or a file-like object that provides the
        methods ``.write()`` and ``.tell()``.
    :param ndarray: a N-dimensional ``numpy.array``

    :returns: a metadata dictionary ::
        {'start': start position in the file, 'end': end position in the file,
         'size': size of the array, 'dtype': numpy data type of the array,
         'shape': description of the array shape
         }
    """"""
    bytedata = ndarray.tobytes('C')
    start = filelike.tell()
    end = start + len(bytedata)
    metadata = {'start': start, 'end': end, 'size': ndarray.size,
                'dtype': ndarray.dtype.name, 'shape': ndarray.shape
                }
    filelike.write(bytedata)
    return metadata"
3042,"def loadBinaryItemContainer(zippedfile, jsonHook):
    """"""Imports binaryItems from a zipfile generated by
    :func:`writeBinaryItemContainer`.

    :param zipfile: can be either a path to a file (a string) or a file-like
        object
    :param jsonHook: a custom decoding function for JSON formated strings of the
        binaryItems stored in the zipfile.

    :returns: a dictionary containing binaryItems
        ``{binaryItem.id: binaryItem, ... }``
    """"""
    binaryItemContainer = dict()
    with zipfile.ZipFile(zippedfile, 'r') as containerZip:
        #Convert the zipfile data into a str object, necessary since
        #containerZip.read() returns a bytes object.
        metadataText = io.TextIOWrapper(containerZip.open('metadata'),
                                        encoding='utf-8'
                                        ).read()
        allMetadata = json.loads(metadataText, object_hook=jsonHook)
        metadataIndex = [str(_) for _ in sorted([int(i) for i in
                                                 viewkeys(allMetadata)
                                                 ])
                         ]
        binarydataFile = containerZip.open('binarydata')
        for index in metadataIndex:
            binaryItem = allMetadata[index][0]
            for binaryMetadata in allMetadata[index][1]:
                arrayKey = binaryMetadata['arrayKey']
                rawdata = binarydataFile.read(binaryMetadata['end'] -
                                              binaryMetadata['start']
                                              )
                array = _arrayFromBytes(rawdata, binaryMetadata)
                binaryItem.arrays[arrayKey] = array
            binaryItemContainer[binaryItem.id] = binaryItem
    return binaryItemContainer"
3043,"def _arrayFromBytes(dataBytes, metadata):
    """"""Generates and returns a numpy array from raw data bytes.

    :param bytes: raw data bytes as generated by ``numpy.ndarray.tobytes()``
    :param metadata: a dictionary containing the data type and optionally the
        shape parameter to reconstruct a ``numpy.array`` from the raw data
        bytes. ``{""dtype"": ""float64"", ""shape"": (2, 3)}``

    :returns: ``numpy.array``
    """"""
    array = numpy.fromstring(dataBytes, dtype=numpy.typeDict[metadata['dtype']])
    if 'shape' in metadata:
        array = array.reshape(metadata['shape'])
    return array"
3044,"def searchFileLocation(targetFileName, targetFileExtension, rootDirectory,
                       recursive=True):
    """"""Search for a filename with a specified file extension in all subfolders
    of specified rootDirectory, returns first matching instance.

    :param targetFileName: #TODO: docstring
    :type targetFileName: str
    :param rootDirectory: #TODO: docstring
    :type rootDirectory: str
    :param targetFileExtension: #TODO: docstring
    :type targetFileExtension: str
    :param recursive: bool, specify whether subdirectories should be searched

    :returns: a filepath (str) or None
    """"""
    expectedFileName = targetFileName.split('.')[0] + '.' + targetFileExtension
    targetFilePath = None

    if recursive:
        for dirpath, dirnames, filenames in os.walk(rootDirectory):
            for filename in filenames:
                if filename == expectedFileName:
                    targetFilePath = joinpath(dirpath, filename)
                    break
            if targetFilePath is not None:
                break
    else:
        for filename in os.listdir(rootDirectory):
            filePath = joinpath(rootDirectory, filename)
            if not os.path.isfile(filePath):
                continue
            if filename == expectedFileName:
                targetFilePath = filePath
                break

    return targetFilePath"
3045,"def matchingFilePaths(targetfilename, directory, targetFileExtension=None,
                      selector=None):
    """"""Search for files in all subfolders of specified directory, return
    filepaths of all matching instances.

    :param targetfilename: filename to search for, only the string before the
        last ""."" is used for filename matching. Ignored if a selector function
        is specified.
    :param directory: search directory, including all subdirectories
    :param targetFileExtension: string after the last ""."" in the filename, has
        to be identical if specified. ""."" in targetFileExtension are ignored,
        thus "".txt"" is treated equal to ""txt"".
    :param selector: a function which is called with the value of targetfilename
        and has to return True (include value) or False (discard value). If no
        selector is specified, equality to targetfilename is used.

    :returns: list of matching file paths (str)
    """"""
    targetFilePaths = list()

    targetfilename = os.path.splitext(targetfilename)[0]
    targetFileExtension = targetFileExtension.replace('.', '')
    matchExtensions = False if targetFileExtension is None else True
    if selector is None:
        selector = functools.partial(operator.eq, targetfilename)

    for dirpath, dirnames, filenames in os.walk(directory):
        for filename in filenames:
            filenameNoextension = os.path.splitext(filename)[0]

            if selector(filenameNoextension):
                if matchExtensions:
                    if not filename.endswith('.' + targetFileExtension):
                        continue
                targetFilePaths.append(joinpath(dirpath, filename))
    return targetFilePaths"
3046,"def listFiletypes(targetfilename, directory):
    """"""Looks for all occurences of a specified filename in a directory and
    returns a list of all present file extensions of this filename.

    In this cas everything after the first dot is considered to be the file
    extension: ``""filename.txt"" -> ""txt""``, ``""filename.txt.zip"" -> ""txt.zip""``

    :param targetfilename: a filename without any extensions
    :param directory: only files present in this directory are compared
        to the targetfilename

    :returns: a list of file extensions (str)
    """"""
    targetextensions = list()
    for filename in os.listdir(directory):
        if not os.path.isfile(joinpath(directory, filename)):
            continue
        splitname = filename.split('.')
        basename = splitname[0]
        extension = '.'.join(splitname[1:])
        if basename == targetfilename:
            targetextensions.append(extension)
    return targetextensions"
3047,"def findAllSubstrings(string, substring):
    """""" Returns a list of all substring starting positions in string or an empty
    list if substring is not present in string.

    :param string: a template string
    :param substring: a string, which is looked for in the ``string`` parameter.

    :returns: a list of substring starting positions in the template string
    """"""
    #TODO: solve with regex? what about '.':
    #return [m.start() for m in re.finditer('(?='+substring+')', string)]
    start = 0
    positions = []
    while True:
        start = string.find(substring, start)
        if start == -1:
            break
        positions.append(start)
        #+1 instead of +len(substring) to also find overlapping matches
        start += 1
    return positions"
3048,"def toList(variable, types=(basestring, int, float, )):
    """"""Converts a variable of type string, int, float to a list, containing the
    variable as the only element.

    :param variable: any python object
    :type variable: (str, int, float, others)

    :returns: [variable] or variable
    """"""
    if isinstance(variable, types):
        return [variable]
    else:
        return variable"
3049,"def calcDeviationLimits(value, tolerance, mode):
    """"""Returns the upper and lower deviation limits for a value and a given
    tolerance, either as relative or a absolute difference.

    :param value: can be a single value or a list of values if a list of values
        is given, the minimal value will be used to calculate the lower limit
        and the maximum value to calculate the upper limit
    :param tolerance: a number used to calculate the limits
    :param mode: either ``absolute`` or ``relative``, specifies how the
        ``tolerance`` should be applied to the ``value``.
    """"""
    values = toList(value)
    if mode == 'relative':
        lowerLimit = min(values) * (1 - tolerance)
        upperLimit = max(values) * (1 + tolerance)
    elif mode == 'absolute':
        lowerLimit = min(values) - tolerance
        upperLimit = max(values) + tolerance
    else:
        raise Exception('mode %s not specified' %(filepath, ))
    return lowerLimit, upperLimit"
3050,"def returnArrayFilters(arr1, arr2, limitsArr1, limitsArr2):
    """"""#TODO: docstring

    :param arr1: #TODO: docstring
    :param arr2: #TODO: docstring
    :param limitsArr1: #TODO: docstring
    :param limitsArr2: #TODO: docstring

    :returns: #TODO: docstring
    """"""
    posL = bisect.bisect_left(arr1, limitsArr1[0])
    posR = bisect.bisect_right(arr1, limitsArr1[1])
    matchMask = ((arr2[posL:posR] <= limitsArr2[1]) &
                 (arr2[posL:posR] >= limitsArr2[0])
                 )
    return posL, posR, matchMask"
3051,"def applyArrayFilters(array, posL, posR, matchMask):
    """"""#TODO: docstring

    :param array: #TODO: docstring
    :param posL: #TODO: docstring
    :param posR: #TODO: docstring
    :param matchMask: #TODO: docstring

    :returns: ``numpy.array``, a subset of the input ``array``.
    """"""
    return numpy.compress(matchMask, array[posL:posR], axis=0)"
3052,"def averagingData(array, windowSize=None, averagingType='median'):
    """"""#TODO: docstring

    :param array: #TODO: docstring
    :param windowSize: #TODO: docstring
    :param averagingType: ""median"" or ""mean""

    :returns: #TODO: docstring
    """"""
    assert averagingType in ['median', 'mean']
    if windowSize is None:
        windowSize = int(len(array) / 50) if int(len(array) / 50) > 100 else 100

    if averagingType == 'median':
        averagedData = runningMedian(array, windowSize)
    elif averagingType == 'mean':
        averagedData = runningMean(array, len(array), windowSize)
    return averagedData"
3053,"def returnSplineList(dependentVar, independentVar, subsetPercentage=0.4,
                     cycles=10, minKnotPoints=10, initialKnots=200,
                     splineOrder=2, terminalExpansion=0.1
                     ):
    """""" #TODO: docstring

    Note: Expects sorted arrays.

    :param dependentVar: #TODO: docstring
    :param independentVar: #TODO: docstring
    :param subsetPercentage: #TODO: docstring
    :param cycles: #TODO: docstring
    :param minKnotPoints: #TODO: docstring
    :param initialKnots: #TODO: docstring
    :param splineOrder: #TODO: docstring
    :param terminalExpansion: expand subsets on both sides

    :returns: #TODO: docstring
    """"""
    expansions = ddict(list)
    expansionArea = (independentVar[-1] - independentVar[0]) * terminalExpansion
    #adds 100 data points at both ends of the dependent and independent array
    for i in range(100):
        expansions['indUp'].append(independentVar[-1] + expansionArea/100*i)
        expansions['indDown'].append(independentVar[0] -
                                     expansionArea/100*(100-i+1)
                                     )
        expansions['depUp'].append(dependentVar[-1])
        expansions['depDown'].append(dependentVar[0])

    dependentVar = numpy.array(expansions['depDown'] + list(dependentVar) +
                               expansions['depUp'], dtype=numpy.float64
                               )
    independentVar = numpy.array(expansions['indDown'] + list(independentVar) +
                                 expansions['indUp'], dtype=numpy.float64
                                 )

    splineList = list()
    for cycle in range(cycles):
        subset = sorted(random.sample(range(len(dependentVar)),
                                      int(len(dependentVar) * subsetPercentage)
                                      )
                        )
        terminalExpansion

        dependentSubset = dependentVar[subset]
        independentSubset = independentVar[subset]

        minIndVar = independentSubset[minKnotPoints]
        maxIndVar = independentSubset[-minKnotPoints]

        knots = [float(i) * (maxIndVar-minIndVar) / initialKnots + minIndVar
                 for i in range(1, initialKnots)
                 ]
        ## remove knots with less then minKnotPoints data points  ##
        lastKnot = knots[0]
        newKnotList = [lastKnot]
        for knotPos in range(1,len(knots)):
            nextKnot = knots[knotPos]
            numHits = (len(independentSubset[(independentSubset >= lastKnot) &
                       (independentSubset <= nextKnot)])
                       )
            if numHits >= minKnotPoints:
                newKnotList.append(nextKnot)
                lastKnot = nextKnot
        knots = newKnotList

        spline = LSQUnivariateSpline(independentSubset, dependentSubset, knots,
                                     k=splineOrder)
        splineList.append(spline)
    return splineList"
3054,"def tolerantArrayMatching(referenceArray, matchArray, matchTolerance,
                          matchUnit):
    """"""#TODO: docstring
    Note: arrays must be sorted

    :param referenceArray: #TODO: docstring
    :param matchArray: #TODO: docstring
    :param matchTolerance: #TODO: docstring
    :param matchUnit: #TODO: docstring

    :returns: #TODO: docstring

    #TODO: change matchUnit to ""absolute"", ""relative"" and remove the ""*1e-6""
    """"""
    if matchUnit == 'relative':
        lowLimMatchArr = matchArray * (1 - matchTolerance)
        uppLimMatchArr = matchArray * (1 + matchTolerance)
    elif matchUnit == 'ppm':
        lowLimMatchArr = matchArray * (1 - matchTolerance*1e-6)
        uppLimMatchArr = matchArray * (1 + matchTolerance*1e-6)
    elif matchUnit == 'da':
        lowLimMatchArr = matchArray - matchTolerance
        uppLimMatchArr = matchArray + matchTolerance
    else:
        raise Exception('wrong matchUnit type specified (da or ppm): ',
                        matchUnit)

    lowerLimitMask = numpy.zeros_like(matchArray, dtype=int)
    upperLimitMask = numpy.zeros_like(matchArray, dtype=int)

    refPosLow = int()
    maxReferenceValue = referenceArray[-1]
    for matchPos, (lowerMatch, upperMatch) in enumerate(zip(lowLimMatchArr,
                                                            uppLimMatchArr
                                                            )
                                                        ):
        if lowerMatch < maxReferenceValue:
            while referenceArray[refPosLow] < lowerMatch:
                refPosLow += 1
            refPosHigh = refPosLow
            #Try except statement because this case can only happen once at the
            #end of the array
            try:
                while referenceArray[refPosHigh] <= upperMatch:
                    refPosHigh += 1
            except IndexError:
                refPosHigh = len(referenceArray) - 1
            lowerLimitMask[matchPos] = refPosLow
            upperLimitMask[matchPos] = refPosHigh
        else:
            refPosLow = len(referenceArray) - 1
            refPosHigh = len(referenceArray) - 1
            lowerLimitMask[matchPos] = refPosLow
            upperLimitMask[matchPos] = refPosHigh
            break

    matchPos += 1
    lowerLimitMask[matchPos:len(matchArray)] = refPosLow
    upperLimitMask[matchPos:len(matchArray)] = refPosHigh

    return lowerLimitMask, upperLimitMask"
3055,"def open(self, filepath, mode='w+b'):
        """"""Opens a file - will actually return a temporary file but replace the
        original file when the context is closed.
        """"""
        #Check if the filepath can be accessed and is writable before creating
        #the tempfile
        if not _isFileAccessible(filepath):
            raise IOError('File %s is not writable' % (filepath,))

        if filepath in self._files:
            with open(self._files[filepath], mode=mode) as tmpf:
                yield tmpf
        else:
            tempfilepath = None
            with tempfile.NamedTemporaryFile(delete=False, mode=mode) as tmpf:
                tempfilepath = tmpf.name
                yield tmpf
            self._files[filepath] = tempfilepath"
3056,"def default(self, obj):
        """"""
        :returns: obj._reprJSON() if it is defined, else
            json.JSONEncoder.default(obj)
        """"""
        if hasattr(obj, '_reprJSON'):
            return obj._reprJSON()
        #Let the base class default method raise the TypeError
        return json.JSONEncoder.default(self, obj)"
3057,"def processInput(self, dataAveraging=False, windowSize=None):
        """""" #TODO: docstring

        :param dataAveraging: #TODO: docstring
        :param windowSize: #TODO: docstring
        """"""
        self.dependentVar = numpy.array(self.dependentVarInput,
                                        dtype=numpy.float64
                                        )
        self.independentVar = numpy.array(self.independentVarInput,
                                          dtype=numpy.float64
                                          )

        sortMask = self.independentVar.argsort()
        self.dependentVar = self.dependentVar[sortMask]
        self.independentVar = self.independentVar[sortMask]

        if dataAveraging:
            averagedData = averagingData(self.dependentVar,
                                         windowSize=windowSize,
                                         averagingType=dataAveraging
                                         )
            averagedData = numpy.array(averagedData, dtype=numpy.float64)

            missingNumHigh = numpy.floor((self.independentVar.size
                                          - averagedData.size
                                          ) / 2
                                         )
            missingNumLow = ((self.independentVar.size - averagedData.size)
                             - missingNumHigh
                             )

            self.dependentVar = averagedData
            self.independentVar = self.independentVar[missingNumLow:
                                                      -missingNumHigh]"
3058,"def generateSplines(self):
        """"""#TODO: docstring
        """"""
        _ = returnSplineList(self.dependentVar, self.independentVar,
                             subsetPercentage=self.splineSubsetPercentage,
                             cycles=self.splineCycles,
                             minKnotPoints=self.splineMinKnotPoins,
                             initialKnots=self.splineInitialKnots,
                             splineOrder=self.splineOrder,
                             terminalExpansion=self.splineTerminalExpansion
                             )
        self.splines = _"
3059,"def corrArray(self, inputArray):
        """"""#TODO: docstring

        :param inputArray: #TODO: docstring

        :returns: #TODO docstring
        """"""
        outputArray = numpy.vstack([numpy.nan_to_num(currSpline(inputArray))
                                    for currSpline in self.splines
                                    ]).mean(axis=0)
        return outputArray"
3060,"def fixminimized(self, alphabet):
        """"""
        After pyfst minimization,
        all unused arcs are removed,
        and all sink states are removed.
        However this may break compatibility.
        Args:
            alphabet (list): The input alphabet
        Returns:
            None
        """"""
        endstate = len(list(self.states))
        for state in self.states:
            for char in alphabet:
                found = 0
                for arc in state.arcs:
                    if self.isyms.find(arc.ilabel) == char:
                        found = 1
                        break
                if found == 0:
                    self.add_arc(state.stateid, endstate, char)

        self[endstate].final = TropicalWeight(float('inf'))

        for char in alphabet:
            self.add_arc(endstate, endstate, char)"
3061,"def _path_to_str(self, path):
        """"""
        Convert a path to the string representing the path
        Args:
            path (tuple): A tuple of arcs
        Returns:
            inp (str): The path concatenated as as string
        """"""
        inp = ''
        for arc in path:
            i = self.isyms.find(arc.ilabel)
            # Ignore \epsilon transitions both on input
            if i != fst.EPSILON:
                inp += i
        return inp"
3062,"def init_from_acceptor(self, acceptor):
        """"""
        Adds a sink state
        Args:
            alphabet (list): The input alphabet
        Returns:
            None
        """"""
        states = sorted(
            acceptor.states,
            key=attrgetter('initial'),
            reverse=True)
        for state in states:
            for arc in state.arcs:
                itext = acceptor.isyms.find(arc.ilabel)
                if itext in self.alphabet:
                    self.add_arc(state.stateid, arc.nextstate, itext)
            if state.final:
                self[state.stateid].final = True
            if state.initial:
                self[state.stateid].initial = True"
3063,"def consume_input(self, inp):
        """"""
        Return True/False if the machine accepts/reject the input.
        Args:
            inp (str): input string to be consumed
        Returns:
            bool: A true or false value depending on if the DFA
                accepts the provided input
        """"""
        cur_state = sorted(
            self.states,
            key=attrgetter('initial'),
            reverse=True)[0]
        while len(inp) > 0:
            found = False
            for arc in cur_state.arcs:
                if self.isyms.find(arc.ilabel) == inp[0]:
                    cur_state = self[arc.nextstate]
                    inp = inp[1:]
                    found = True
                    break
            if not found:
                return False
        return cur_state.final != TropicalWeight(float('inf'))"
3064,"def random_strings(self, string_length=1):
        """"""
        Generate string_length random strings that belong to the automaton.
        Args:
            string_length (integer): The size of the random string
        Returns:
            str: The generated string
        """"""
        str_list = []
        for path in self.uniform_generate(string_length):
            str_list.append(self._path_to_str(path))
        return str_list"
3065,"def save(self, txt_fst_filename):
        """"""
        Save the machine in the openFST format in the file denoted by
        txt_fst_filename.
        Args:
            txt_fst_filename (str): The name of the file
        Returns:
            None
        """"""
        txt_fst = open(txt_fst_filename, 'w+')
        states = sorted(self.states, key=attrgetter('initial'), reverse=True)
        for state in states:
            for arc in state.arcs:
                itext = self.isyms.find(arc.ilabel)
                otext = self.osyms.find(arc.ilabel)
                txt_fst.write(
                    '{}\t{}\t{}\t{}\n'.format(
                        state.stateid,
                        arc.nextstate,
                        itext.encode('hex'),
                        otext.encode('hex')))
            if state.final:
                txt_fst.write('{}\n'.format(state.stateid))
        txt_fst.close()"
3066,"def load(self, txt_fst_filename):
        """"""
        Save the transducer in the text file format of OpenFST.
        The format is specified as follows:
            arc format: src dest ilabel olabel [weight]
            final state format: state [weight]
        lines may occur in any order except initial state must be first line
        Args:
            txt_fst_filename (string): The name of the file
        Returns:
            None
        """"""
        with open(txt_fst_filename, 'r') as txt_fst:
            for line in txt_fst:
                line = line.strip()
                splitted_line = line.split()
                if len(splitted_line) == 1:
                    self[int(splitted_line[0])].final = True
                else:
                    self.add_arc(int(splitted_line[0]), int(
                        splitted_line[1]), splitted_line[2].decode('hex'))"
3067,"def persistent_menu(menu):
    """"""
    more: https://developers.facebook.com/docs/messenger-platform/thread-settings/persistent-menu

    :param menu:
    :return:
    """"""
    if len(menu) > 3:
        raise Invalid('menu should not exceed 3 call to actions')

    if any(len(item['call_to_actions']) > 5 for item in menu if item['type'] == 'nested'):
        raise Invalid('call_to_actions is limited to 5 for sub-levels')

    for item in menu:
        if len(item['title']) > 30:
            raise Invalid('menu item title should not exceed 30 characters')

        if item['type'] == 'postback' and len(item['payload']) > 1000:
            raise Invalid('menu item payload should not exceed 1000 characters')"
3068,"def send_text_message(text, quick_replies):
    """"""
    more:
    https://developers.facebook.com/docs/messenger-platform/send-api-reference/text-message
     and
    https://developers.facebook.com/docs/messenger-platform/send-api-reference/quick-replies

    :param text:
    :param quick_replies:
    :return:
    """"""
    if len(text) > 640:
        raise ExceedLengthException(
            'send message text should not exceed 640 character limit',
            limit=640,
        )

    if isinstance(quick_replies, list):
        if len(quick_replies) > 10:
            raise Invalid('send message quick replies should not exceed 10 limit')

        for item in quick_replies:
            if 'content_type' not in item:
                raise Invalid('send message quick replies should have content_type')
            if item['content_type'] == 'text':
                if len(item['title']) > 20:
                    raise Invalid('send message quick replies title should not exceed 20 character limit')
                if len(item['payload']) > 1000:
                    raise Invalid('send message quick replies payload should not exceed 1000 character limit')"
3069,"def main():
    """"""Main Function""""""
    alphabet = list(string.lowercase)  # + [""<"", "">""]

    # Create an SFA for the regular expression .*<t>.*
    sfa = SFA(alphabet)

    # sfa.add_arc(0,0,SetPredicate([ i for i in alphabet if i != ""<"" ]))
    # sfa.add_arc(0,1,SetPredicate(list(""<"")))
    #
    # sfa.add_arc(1,2,SetPredicate(list(""t"")))
    # sfa.add_arc(1,0,SetPredicate([ i for i in alphabet if i != ""t"" ]))
    #
    # sfa.add_arc(2,3,SetPredicate(list("">"")))
    # sfa.add_arc(2,0,SetPredicate([ i for i in alphabet if i != "">"" ]))
    #
    # sfa.add_arc(3,3,SetPredicate(alphabet))
    #
    # sfa.states[3].final = True

    sfa.add_arc(0, 7, SetPredicate([i for i in alphabet if i != ""d"" and i != ""input_string""]))
    sfa.add_arc(1, 7, SetPredicate([i for i in alphabet if i != ""i""]))
    sfa.add_arc(2, 7, SetPredicate([i for i in alphabet if i != ""p""]))
    sfa.add_arc(3, 7, SetPredicate([i for i in alphabet if i != ""v""]))
    sfa.add_arc(5, 7, SetPredicate(list(alphabet)))
    sfa.add_arc(4, 7, SetPredicate([i for i in alphabet if i != ""a""]))
    sfa.add_arc(6, 7, SetPredicate([i for i in alphabet if i != ""n""]))
    sfa.add_arc(7, 7, SetPredicate(list(alphabet)))

    sfa.add_arc(0, 1, SetPredicate(list(""d"")))
    sfa.add_arc(1, 3, SetPredicate(list(""i"")))
    sfa.add_arc(3, 5, SetPredicate(list(""v"")))

    sfa.add_arc(0, 2, SetPredicate(list(""input_string"")))
    sfa.add_arc(2, 4, SetPredicate(list(""p"")))
    sfa.add_arc(4, 6, SetPredicate(list(""a"")))
    sfa.add_arc(6, 5, SetPredicate(list(""n"")))

    sfa.states[5].final = True

    dfa = sfa.concretize()
    # dfa.minimize()
    dfa.save('concrete_re_sfa.dfa')

    # Consume some input
    input_string = ""koukouroukou""
    print 'SFA-DFA result on {}: {} - {}'.format(input_string, sfa.consume_input(input_string),
                                                 dfa.consume_input(input_string))

    input_string = ""divspan""
    print 'SFA-DFA result on {}: {} - {}'.format(input_string, sfa.consume_input(input_string),
                                                 dfa.consume_input(input_string))

    input_string = ""div""
    print 'SFA-DFA result on {}: {} - {}'.format(input_string, sfa.consume_input(input_string),
                                                 dfa.consume_input(input_string))

    input_string = ""span""
    print 'SFA-DFA result on {}: {} - {}'.format(input_string, sfa.consume_input(input_string),
                                                 dfa.consume_input(input_string))"
3070,"def refactor(self, symbol, value):
        """"""
        Args:
            symbol:
            value:
        Returns:
            None
        """"""
        if value:
            self.pset.add(symbol)
        else:
            self.pset.remove(symbol)"
3071,"def add_state(self):
        """"""This function adds a new state""""""
        sid = len(self.states)
        self.states.append(SFAState(sid))"
3072,"def add_arc(self, src, dst, char):
        """"""
        This function adds a new arc in a SFA state
        Args:
            src (int): The source state identifier
            dst (int): The destination state identifier
            char (str): The transition symbol
        Returns:
            None
        """"""
        assert type(src) == type(int()) and type(dst) == type(int()), \
            ""State type should be integer.""
        while src >= len(self.states) or dst >= len(self.states):
            self.add_state()
        self.states[src].arcs.append(SFAArc(src, dst, char))"
3073,"def consume_input(self, inp):
        """"""
        Return True/False if the machine accepts/reject the input.
        Args:
            inp (str): input string to be consumed
        Retunrs:
            bool: A true or false value depending on if the DFA
                accepts the provided input
        """"""
        cur_state = self.states[0]
        for character in inp:
            found = False
            for arc in cur_state.arcs:
                if arc.guard.is_sat(character):
                    cur_state = self.states[arc.dst_state]
                    found = True
                    break

            if not found:
                raise RuntimeError('SFA not complete')

        return cur_state.final"
3074,"def concretize(self):
        """"""
        Transforms the SFA into a DFA
        Args:
            None
        Returns:
            DFA: The generated DFA
        """"""
        dfa = DFA(self.alphabet)
        for state in self.states:
            for arc in state.arcs:
                for char in arc.guard:
                    dfa.add_arc(arc.src_state, arc.dst_state, char)

        for i in xrange(len(self.states)):
            if self.states[i].final:
                dfa[i].final = True
        return dfa"
3075,"def _write(self, ret):
        """"""
        This function needs to correspond to this:
        https://github.com/saltstack/salt/blob/develop/salt/returners/redis_return.py#L88
        """"""
        self.redis.set('{0}:{1}'.format(ret['id'], ret['jid']), json.dumps(ret))
        self.redis.lpush('{0}:{1}'.format(ret['id'], ret['fun']), ret['jid'])
        self.redis.sadd('minions', ret['id'])
        self.redis.sadd('jids', ret['jid'])"
3076,"def _initAddons(cls, recurse=True):
        """"""
        Initializes the addons for this manager.
        """"""
        for addon_module in cls.addonModules(recurse):
            projex.importmodules(addon_module)"
3077,"def addons(cls, recurse=True):
        """"""
        Returns a dictionary containing all the available addons
        for this mixin class.  If the optional recurse flag is set to True,
        then all the base classes will be searched for the given addon as well.
        
        :param      recurse | <bool>
        
        :return     {<str> name: <variant> addon, ..}
        """"""
        cls.initAddons()
        prop = '_{0}__addons'.format(cls.__name__)
        out = {}

        # lookup base classes
        if recurse:
            for base in cls.__bases__:
                if issubclass(base, AddonManager):
                    out.update(base.addons(recurse))

        # always use the highest level for any given key
        out.update(getattr(cls, prop, {}))
        return out"
3078,"def addonModules(cls, recurse=True):
        """"""
        Returns all the modules that this addon class uses to load plugins
        from.
        
        :param      recurse | <bool>
        
        :return     [<str> || <module>, ..]
        """"""
        prop = '_{0}__addon_modules'.format(cls.__name__)
        out = set()

        # lookup base classes
        if recurse:
            for base in cls.__bases__:
                if issubclass(base, AddonManager):
                    out.update(base.addonModules(recurse))

        # always use the highest level for any given key
        out.update(getattr(cls, prop, set()))
        return out"
3079,"def byName(cls, name, recurse=True, default=None):
        """"""
        Returns the addon whose name matches the inputted name.  If
        the optional recurse flag is set to True, then all the base classes
        will be searched for the given addon as well. If no addon is found,
        the default is returned.
        
        :param      name    | <str>
                    recurse | <bool>
                    default | <variant>
        """"""
        cls.initAddons()
        prop = '_{0}__addons'.format(cls.__name__)
        try:
            return getattr(cls, prop, {})[name]
        except KeyError:
            if recurse:
                for base in cls.__bases__:
                    if issubclass(base, AddonManager):
                        return base.byName(name, recurse)
        return default"
3080,"def initAddons(cls, recurse=True):
        """"""
        Loads different addon modules for this class.  This method
        should not be overloaded in a subclass as it also manages the loaded
        state to avoid duplicate loads.  Instead, you can re-implement the
        _initAddons method for custom loading.
        
        :param      recurse | <bool>
        """"""
        key = '_{0}__addons_loaded'.format(cls.__name__)
        if getattr(cls, key, False):
            return

        cls._initAddons(recurse)
        setattr(cls, key, True)"
3081,"def registerAddon(cls, name, addon, force=False):
        """"""
        Registers the inputted addon to the class.
        
        :param      name    | <str>
                    addon   | <variant>
        """"""
        prop = '_{0}__addons'.format(cls.__name__)
        cmds = getattr(cls, prop, {})

        if name in cmds and not force:
            raise errors.AddonAlreadyExists(cls, name, addon)

        cmds[name] = addon
        try:
            if issubclass(addon, cls):
                setattr(addon, '_{0}__addonName'.format(addon.__name__), name)
        except StandardError:
            pass

        setattr(cls, prop, cmds)"
3082,"def registerAddonModule(cls, module):
        """"""
        Registers a module to use to import addon subclasses from.
        
        :param      module | <str> || <module>
        """"""
        prop = '_{0}__addon_modules'.format(cls.__name__)
        mods = getattr(cls, prop, set())
        mods.add(module)
        setattr(cls, prop, mods)"
3083,"def unregisterAddon(cls, name):
        """"""
        Unregisters the addon defined by the given name from the class.
        
        :param      name    | <str>
        """"""
        prop = '_{0}__addons'.format(cls.__name__)
        cmds = getattr(cls, prop, {})
        cmds.pop(name, None)"
3084,"def unregisterAddonModule(cls, module):
        """"""
        Unregisters the module to use to import addon subclasses from.
        
        :param      module | <str> || <module>
        """"""
        prop = '_{0}__addon_modules'.format(cls.__name__)
        mods = getattr(cls, prop, set())
        try:
            mods.remove(module)
        except KeyError:
            pass"
3085,"def emit(self, record):
        """""" 
        Throws an error based on the information that the logger reported,
        given the logging level.
        
        :param      record: <logging.LogRecord>
        """"""
        if not logging.raiseExceptions:
            return

        logger = logging.getLogger(record.name)

        # raise an exception based on the error logging
        if logger.level <= record.levelno:
            err = record.msg[0]
            if not isinstance(err, Exception):
                err = ProjexError(nstr(record.msg))

            # log the traceback info
            data = record.__dict__.copy()
            data['type'] = type(err).__name__
            msg = ERROR_MESSAGE % data
            sys.stderr.write(msg)
            raise err"
3086,"def cli(ctx, stage):
    """"""listen to push requests for src and pull requests from target (experimental)""""""

    if not ctx.bubble:
        ctx.say_yellow('There is no bubble present, will not listen')
        raise click.Abort()

    SRC = None
    if stage in STAGES:
        try:
            SRC = ctx.cfg.CFG[stage].SOURCE
        except KeyError:
            pass

    if not SRC:
        ctx.say_red('There is no SOURCE in stage:' + stage)
        ctx.say_yellow('please check configuration in ' +
                       ctx.home + '/config/config.yaml')
        raise click.Abort()

    if 'SERVER' not in SRC:
        ctx.say_red('There is no SOURCE.SERVER in stage:' + stage)
        raise click.Abort()

    src_server = get_server(SRC.SERVER, ctx.home)

    # connect storage / pipeline to target via transform
    # write state listening on port etc into
    def message_handler(**m):
        print(str(arrow.now), str(m))
        return True, 'handled'

    try:
        # TODO: bg &
        # src_listening = src_server.listen(cfg=SRC,
        src_server.listen(cfg=SRC,
                          push_handler=message_handler,
                          pull_handler=message_handler)
    except Exception as e:
        ctx.say_red(
            'cannot listen from source client bubble.clients.' + SRC.SERVER)
        ctx.say_red(str(e))
        raise click.Abort('cannot listen')"
3087,"def get_field_label_css_class(self, bound_field):
        """"""
        Returns 'form-check-label' if widget is CheckboxInput. For all other fields,
        no css class is added.
        """"""
        # If we render CheckboxInputs, Bootstrap requires a different
        # field label css class for checkboxes.
        if isinstance(bound_field.field.widget, forms.CheckboxInput):
            return 'form-check-label'

        return super().get_field_label_css_class(bound_field)"
3088,"def get_widget_css_class(self, field_name, field):
        """"""
        Returns 'form-check-input' if widget is CheckboxInput or 'form-control-file'
        if widget is FileInput. For all other fields return the default value
        from the form property (""form-control"").
        """"""
        # If we render CheckboxInputs, Bootstrap requires a different
        # widget css class for checkboxes.
        if isinstance(field.widget, forms.CheckboxInput):
            return 'form-check-input'

        # Idem for fileinput.
        if isinstance(field.widget, forms.FileInput):
            return 'form-control-file'

        return super().get_widget_css_class(field_name, field)"
3089,"def handle(self):
        """"""
        Handle a message
        :return: True if success, False otherwise
        """"""

        if self.component_type == StreamComponent.SOURCE:
            msg = self.handler_function()
            return self.__send(msg)

        logger = self.logger
        data = self.__receive()
        if data is None:
            return False
        else:
            logger.debug(""Calling %s "" % self.handler_function)
            result = self.handler_function(data.decode(self.char_encoding))
            if self.component_type == StreamComponent.PROCESSOR:
                logger.debug(""Sending p3:%s %s %s"" % (PYTHON3, result, str(type(result))))
                if not self.__send(result):
                    return False
        return True"
3090,"def realpath_with_context(path, context):
    """"""
    Convert a path into its realpath:

      * For relative path: use :attr:`context.workdir` as root directory
      * For absolute path: Pass-through without any changes.

    :param path: Filepath to convert (as string).
    :param context: Behave context object (with :attr:`context.workdir`)
    :return: Converted path.
    """"""
    if not os.path.isabs(path):
        # XXX ensure_workdir_exists(context)
        assert context.workdir
        path = os.path.join(context.workdir, os.path.normpath(path))
    return path"
3091,"def posixpath_normpath(pathname):
    """"""
    Convert path into POSIX path:

      * Normalize path
      * Replace backslash with slash

    :param pathname: Pathname (as string)
    :return: Normalized POSIX path.
    """"""
    backslash = '\\'
    pathname2 = os.path.normpath(pathname) or "".""
    if backslash in pathname2:
        pathname2 = pathname2.replace(backslash, '/')
    return pathname2"
3092,"def create_textfile_with_contents(filename, contents, encoding='utf-8'):
    """"""
    Creates a textual file with the provided contents in the workdir.
    Overwrites an existing file.
    """"""
    ensure_directory_exists(os.path.dirname(filename))
    if os.path.exists(filename):
        os.remove(filename)
    outstream = codecs.open(filename, ""w"", encoding)
    outstream.write(contents)
    if contents and not contents.endswith(""\n""):
        outstream.write(""\n"")
    outstream.flush()
    outstream.close()
    assert os.path.exists(filename), ""ENSURE file exists: %s"" % filename"
3093,"def ensure_directory_exists(dirname, context=None):
    """"""
    Ensures that a directory exits.
    If it does not exist, it is automatically created.
    """"""
    real_dirname = dirname
    if context:
        real_dirname = realpath_with_context(dirname, context)
    if not os.path.exists(real_dirname):
        os.makedirs(real_dirname)
    assert os.path.exists(real_dirname), ""ENSURE dir exists: %s"" % dirname
    assert os.path.isdir(real_dirname),  ""ENSURE isa dir: %s"" % dirname"
3094,"def p_andnode_expression(self, t):
    '''andnode_expression : LB  identlist RB '''
    self.accu.add(Term('vertex', [""and(\""""+t[2]+""\"")""]))
    t[0] = ""and(\""""+t[2]+""\"")"""
3095,"def p_identlist(self, t):
    '''identlist : IDENT
                  | NOT IDENT
                  | IDENT AND identlist
                  | NOT IDENT AND identlist              
                  '''
    if len(t)==5 : 
      #print(t[1],t[2],t[3],t[4])
      t[0] = t[1]+t[2]+t[3]+t[4]
    elif len(t)==4 : 
      #print(t[1],t[2],t[3])
      t[0] = t[1]+t[2]+t[3]
    elif len(t)==3 : 
      #print(t[1],t[2])
      t[0] = t[1]+t[2]
    elif len(t)==2 :
      #print(t[0],t[1])
      t[0]=t[1]
    else:
      print(""Syntax error at '"",str(t),""'"")"
3096,"def deserialize(self, msg):
        'deserialize output to a Python object'
        self.logger.debug('deserializing %s', msg)
        return json.loads(msg)"
3097,"def append_request_id(req, resp, resource, params):
    """"""Append request id which got from response
    header to resource.req_ids list.
    """"""
    def get_headers(resp):
        if hasattr(resp, 'headers'):
            return resp.headers
        if hasattr(resp, '_headers'):
            return resp._headers
        return None

    if(isinstance(resp, Response) or
       (get_headers(resp) is not None)):
        # Extract 'x-request-id' from headers if
        # response is a Response object.
        request_id = get_headers(resp).get('x-request-id')
    else:
        # If resp is of type string or None.
        request_id = resp

    if resource.req_ids is None:
        resource.req_ids = []

    if request_id not in resource.req_ids:
        resource.req_ids.append(request_id)"
3098,"def _sanitizer(self, obj):
        """"""Sanitizer method that will be passed to json.dumps.""""""
        if isinstance(obj, datetime.datetime):
            return obj.isoformat()
        if hasattr(obj, ""to_dict""):
            return obj.to_dict()
        return obj"
3099,"def make_uniq_for_step(ctx, ukeys, step, stage, full_data, clean_missing_after_seconds, to_uniq):
    """"""initially just a copy from UNIQ_PULL""""""

    # TODO:
    # this still seems to work ok for Storage types json/bubble,
    # for DS we need to reload de dumped step to uniqify

    if not ukeys:
        return to_uniq
    else:
        uniq_data = bubble_lod_load(ctx, step, stage)
        ctx.say('Creating uniq identifiers for [' + step + '] information', 0)

        ctx.gbc.say('uniq_data:', stuff=uniq_data, verbosity=1000)

        # TODO:make: data->keyed.items
        uniq_step_res = make_uniq(ctx=ctx,
                                  ldict=to_uniq,
                                  keyed=uniq_data,
                                  uniqstr=ukeys,
                                  tag=step,
                                  full_data=full_data,
                                  remove_missing_after_seconds=clean_missing_after_seconds)

        ctx.gbc.say('uniq_step_res:', stuff=uniq_step_res, verbosity=1000)

        to_uniq_newest = get_newest_uniq(ctx.gbc, uniq_step_res)

        # TODO: selected pulled only from slice of uniq
        # PROBLEM: slice of pull is not equal to slice of newest uniq,
        # can only select keys from newest, from slice of pulled
        # need a uid list from to_transform
        # to_transform = get_gen_slice(gbc, to_transform_newest, amount, index)
        # for now not a big problem, as with 'pump' there should be no problem
        to_uniq = to_uniq_newest
        # todo make keyed.items->data
        uniq_res_list = get_uniq_list(ctx.gbc, uniq_step_res)
        reset = True
        pfr = bubble_lod_dump(ctx=ctx,
                              step=step,
                              stage=stage,
                              full_data=full_data,
                              reset=reset,
                              data_gen=uniq_res_list)

        ctx.gbc.say('saved uniq ' + step + ' data res:',
                    stuff=pfr, verbosity=700)
        return to_uniq"
3100,"def list_nic(self, instance_id):
        """"""List all Network Interface Controller""""""
        output = self.client.describe_instances(InstanceIds=[instance_id])
        output = output.get(""Reservations"")[0].get(""Instances"")[0]
        return output.get(""NetworkInterfaces"")"
3101,"def list_ip(self, instance_id):
        """"""Add all IPs""""""
        output = self.client.describe_instances(InstanceIds=[instance_id])
        output = output.get(""Reservations"")[0].get(""Instances"")[0]
        ips = {}
        ips['PrivateIp'] = output.get(""PrivateIpAddress"")
        ips['PublicIp'] = output.get(""PublicIpAddress"")
        return ips"
3102,"def main():
    """"""
    Testing function for Flex Regular Expressions to FST DFA
    """"""
    if len(argv) < 2:
        print 'Usage: %s fst_file [optional: save_file]' % argv[0]
        return
    flex_a = Flexparser()
    mma = flex_a.yyparse(argv[1])
    mma.minimize()
    print mma
    if len(argv) == 3:
        mma.save(argv[2])"
3103,"def _read_transitions(self):
        """"""
        Read DFA transitions from flex compiled file
        Args:
            None
        Returns:
            list: The list of states and the destination for a character
        """"""
        states = []
        i = 0
        regex = re.compile('[ \t\n\r:,]+')
        found = 0  # For maintaining the state of yy_nxt declaration
        state = 0  # For maintaining the state of opening and closing tag of yy_nxt
        substate = 0  # For maintaining the state of opening and closing tag of each set in yy_nxt
        mapping = []  # For writing each set of yy_next
        cur_line = None
        with open(self.outfile) as flex_file:
            for cur_line in flex_file:
                if cur_line[0:35] == ""static yyconst flex_int16_t yy_nxt["" or cur_line[0:33] == ""static const flex_int16_t yy_nxt["":
                    found = 1
                    # print 'Found yy_next declaration'
                    continue
                if found == 1:
                    if state == 0 and cur_line[0:5] == ""    {"":
                        state = 1
                        continue
                    if state == 1 and cur_line[0:7] == ""    } ;"":
                        state = 0
                        break

                    if substate == 0 and cur_line[0:5] == ""    {"":
                        mapping = []
                        substate = 1
                        continue
                    if substate == 1:
                        if cur_line[0:6] != ""    },"":
                            cur_line = """".join(cur_line.split())
                            if cur_line == '':
                                continue
                            if cur_line[cur_line.__len__() - 1] == ',':
                                splitted_line = regex.split(
                                    cur_line[:cur_line.__len__() - 1])
                            else:
                                splitted_line = regex.split(cur_line)
                            mapping = mapping + splitted_line
                            continue
                        else:
                            cleared = []
                            for j in mapping:
                                cleared.append(int(j))
                            states.append(cleared)
                            mapping = []
                            substate = 0

        return states"
3104,"def _read_accept_states(self):
        """"""
        Read DFA accepted states from flex compiled file
        Args:
            None
        Returns:
            list: The list of accepted states
        """"""
        states = []
        i = 0
        regex = re.compile('[ \t\n\r:,]+')
        found = 0  # For maintaining the state of yy_accept declaration
        state = 0  # For maintaining the state of opening and closing tag of yy_accept
        mapping = [] # For writing each set of yy_accept
        cur_line = None
        with open(self.outfile) as flex_file:
            for cur_line in flex_file:
                if cur_line[0:37] == ""static yyconst flex_int16_t yy_accept"" or cur_line[0:35] == ""static const flex_int16_t yy_accept"":
                    found = 1
                    continue
                if found == 1:
                    # print x
                    if state == 0 and cur_line[0:5] == ""    {"":
                        mapping.append(0)  # there is always a zero there
                        state = 1
                        continue

                    if state == 1:
                        if cur_line[0:7] != ""    } ;"":
                            cur_line = """".join(cur_line.split())
                            if cur_line == '':
                                continue
                            if cur_line[cur_line.__len__() - 1] == ',':
                                splitted_line = regex.split(
                                    cur_line[:cur_line.__len__() - 1])
                            else:
                                splitted_line = regex.split(cur_line)
                            mapping = mapping + splitted_line
                            continue
                        else:
                            cleared = []
                            for j in mapping:
                                cleared.append(int(j))
                            max_value = max(cleared)
                            for i in range(0, len(cleared)):
                                if cleared[i] > 0 and cleared[
                                        i] < (max_value - 1):
                                    states.append(i)
                            return states
        return []"
3105,"def _create_states(self, states_num):
        """"""
        Args:
            states_num (int): Number of States
        Returns:
            list: An initialized list
        """"""
        states = []
        for i in range(0, states_num):
            states.append(i)
        return states"
3106,"def _add_sink_state(self, states):
        """"""
        This function adds a sing state in the total states
        Args:
            states (list): The current states
        Returns:
            None
        """"""
        cleared = []
        for i in range(0, 128):
            cleared.append(-1)
        states.append(cleared)"
3107,"def _create_delta(self):
        """"""
        This function creates the delta transition
        Args:
            startState (int): Initial state of automaton
        Results:
            int, func: A number indicating the total states, and the delta function
        """"""
        states = self._read_transitions()
        total_states = len(states)
        self._add_sink_state(states)
        nulltrans = self._read_null_transitions()

        def delta(current_state, character):
            """"""
            Sub function describing the transitions
            Args:
                current_state (str): The current state
                character (str): The input character
            Returns:
                str: The next state
            """"""
            if character != '':
                newstate = states[current_state][ord(character)]
                if newstate > 0:
                    return newstate
                else:
                    return total_states
            else:
                return nulltrans[current_state]

        return total_states + 1, delta"
3108,"def yyparse(self, lexfile):
        """"""
        Args:
            lexfile (str): Flex file to be parsed
        Returns:
            DFA: A dfa automaton
        """"""
        temp = tempfile.gettempdir()
        self.outfile = temp+'/'+''.join(
            random.choice(
                string.ascii_uppercase + string.digits) for _ in range(5)) + '_lex.yy.c'
        self._create_automaton_from_regex(lexfile)
        states_num, delta = self._create_delta()
        states = self._create_states(states_num)
        accepted_states = self._read_accept_states()
        if self.alphabet != []:
            alphabet = self.alphabet
        else:
            alphabet = createalphabet()
        mma = DFA(alphabet)
        for state in states:
            if state != 0:
                for char in alphabet:
                    nextstate = delta(state, char)
                    mma.add_arc(state - 1, nextstate - 1, char)
                if state in accepted_states:
                    mma[state - 1].final = True
        if os.path.exists(self.outfile):
            os.remove(self.outfile)
        return mma"
3109,"def set_path(ctx, path_str, value, data):
    """"""
    Sets the given key in the given dict object to the given value. If the
    given path is nested, child dicts are created as appropriate.
    Accepts either a dot-delimited path or an array of path elements as the
    `path` variable.
    """"""
    ctx.gbc.say('set_path:value:' + str(value) + ' at:' + path_str + ' in:',
                stuff=data, verbosity=1001)

    path = path_str.split('.')
    ctx.gbc.say('path:', stuff=path, verbosity=100)
    if len(path) > 1:
        destk = '.'.join(path[0:-1])
        lp = path[-1]
        ctx.gbc.say('destk:%s' % destk, verbosity=100)
        ctx.gbc.say('last:%s' % lp, verbosity=100)
        ctx.gbc.say('current keys:', stuff=data.keys(), verbosity=1001)
        if len(path) > 2:
            destk = unescape(ctx, destk)
        if destk not in data.keys():
            ctx.gbc.say('destk not in current keys:',
                        stuff=data.keys(), verbosity=1001)
            data[destk] = {}
            ctx.gbc.say('destk not added:', stuff=data, verbosity=1001)

        lp = unescape(ctx, lp)
        data[destk][lp] = value
        ctx.gbc.say('destk and val added:', stuff=data, verbosity=1001)
    else:
        path_str = unescape(ctx, path_str)
        data[path_str] = value
    ctx.gbc.say('set_path:res:', stuff=data, verbosity=1001)
    return data"
3110,"def cli(ctx, setkv, copyk, delk,showtype):
    """"""Show or change the configuration""""""

    if not ctx.bubble:
        ctx.say_yellow(
            'There is no bubble present, will not show or set the config')
        raise click.Abort()

    new_cfg = flat(ctx, ctx.cfg)
    ctx.say('current config', stuff=ctx.cfg, verbosity=10)
    ctx.say('current flat config with meta', stuff=new_cfg, verbosity=100)
    new_cfg_no_meta = {}
    meta_ends = ['_doct_as_key',
                 '_doct_level',
                 '___bts_flat_',
                 '___bts_flat_star_path_',
                 '___bts_flat_star_select_']

    lkeys = list(new_cfg.keys())
    for k in lkeys:
        addkey = True
        # ctx.say('k:'+k)
        if k.startswith('___bts_'):
            addkey = False
        for meta_end in meta_ends:
            if k.endswith(meta_end):
                addkey = False
        if addkey:
            # ctx.say('adding k:'+k)
            new_cfg_no_meta[k] = new_cfg[k]
        else:
            pass
            # ctx.say('not adding meta k:'+k)
    ctx.say('current flat config without metakeys',
            stuff=new_cfg_no_meta,
            verbosity=3)
    if not setkv and not copyk and not delk:
        ctx.say('current configuration')
        for k, v in new_cfg_no_meta.items():
            tstr=''
            if showtype:
                tstr=' type: '+TYPES[str(type(v))]
            ctx.say(' '+k+': '+str(v)+tstr)

    modified = 0
    if setkv:
        for key, value,vtype in setkv:
            ctx.say('setting k:%s,v:%s,t:%s'%(key,value,vtype))
            vtval='VALUE_NOT_SET'
            try:
                if vtype==""STRING"":
                    vtval=str(value)
                if vtype==""INTEGER"":
                    vtval=int(value)
                if vtype==""FLOAT"":
                    vtval=float(value)
                if vtype==""BOOLEAN"":
                    if value.lower() in TRUES:
                        vtval=True
                    if value.lower() in FALSES:
                        vtval=False
                    if vtval not in [True,False]:
                        ctx.cry(""boolean value must be one of (case insensitive):"",
                                stuff={'True':TRUES,'False':FALSES})
                        raise TypeError()
            except Exception as e:
                ctx.cry('cannot set k:%s,v:%s,t:%s:'%(key,value,vtype))
                raise e
            if vtval != 'VALUE_NOT_SET':
                new_cfg[str(key)] = vtval
                modified += 1
            else:
                ctx.cry('cannot set k:%s,v:%s,t:%s:typed value is not set yet'%(key,value,vtype))
    if copyk:
        for srckey, destkey in copyk:
            if srckey.endswith('.*'):
                src_val = get_flat_path(ctx, new_cfg, srckey)
                for k in src_val:
                    # TODO: use magic for sep
                    sep = '.'
                    new_cfg[str(destkey + sep + k)] = str(src_val[k])
                modified += 1
            else:
                if srckey in new_cfg:
                    new_cfg[str(destkey)] = new_cfg[srckey]
                    modified += 1

    if delk:
        if delk.endswith('.*'):
            # fix PY3: RuntimeError: dictionary changed size during iteration
            lkeys = list(new_cfg.keys())
            for k in lkeys:
                if k.startswith(delk[:-2]):
                    del(new_cfg[k])
                    modified += 1

        else:
            if delk in new_cfg:
                del(new_cfg[delk])
                modified += 1

    if modified:
        ctx.say('new flat config', stuff=new_cfg, verbosity=100)
        fat_cfg = unflat(ctx, new_cfg)
        ctx.say('new config, #changes:'+str(modified), verbosity=3)
        ctx.say('new config', stuff=fat_cfg, verbosity=30)
        fat_cfg = unflat(ctx, new_cfg)
        doct_fat_cfg = BubbleDoct(fat_cfg)
        ctx.say('new config fat doct', stuff=doct_fat_cfg, verbosity=100)
        res = put_config(ctx, YCFG=BubbleDoct(doct_fat_cfg))
        ctx.say('put config res:', stuff=res, verbosity=10)

    return True"
3111,"def coerce(self, value):
        """"""Convert text values into integer values.

        Args:
            value (str or int): The value to coerce.

        Raises:
            TypeError: If the value is not an int or string.
            ValueError: If the value is not int or an acceptable value.

        Returns:
            int: The integer value represented.
        """"""
        if isinstance(value, int) or isinstance(value, compat.long):

            return value

        return int(value)"
3112,"def has_permission(self):
        """"""Permission checking for ""normal"" Django.""""""
        objs = [None]
        if hasattr(self, 'get_perms_objects'):
            objs = self.get_perms_objects()
        else:
            if hasattr(self, 'get_object'):
                try:
                    objs = [self.get_object()]
                except Http404:
                    raise
                except:
                    pass
            if objs == [None]:
                objs = self.get_queryset()

        if (hasattr(self, 'permission_filter_queryset') and
           self.permission_filter_queryset is not False and
           self.request.method == 'GET'):
            if objs != [None]:
                self.perms_filter_queryset(objs)
            return True
        else:
            return check_perms(self.request.user,
                               self.get_permission_required(),
                               objs, self.request.method)"
3113,"def check_permissions(self, request):
        """"""Permission checking for DRF.""""""
        objs = [None]
        if hasattr(self, 'get_perms_objects'):
            objs = self.get_perms_objects()
        else:
            if hasattr(self, 'get_object'):
                try:
                    objs = [self.get_object()]
                except Http404:
                    raise
                except:
                    pass
            if objs == [None]:
                objs = self.get_queryset()
            if len(objs) == 0:
                objs = [None]

        if (hasattr(self, 'permission_filter_queryset') and
           self.permission_filter_queryset is not False and
           self.request.method == 'GET'):
            if objs != [None]:
                self.perms_filter_queryset(objs)
        else:
            has_perm = check_perms(self.request.user,
                                   self.get_permission_required(),
                                   objs, self.request.method)

            if not has_perm:
                msg = self.get_permission_denied_message(
                    default=""Permission denied.""
                )
                if isinstance(msg, Sequence):
                    msg = msg[0]
                self.permission_denied(request, message=msg)"
3114,"def _hashed_key(self):
        """""" Returns 16-digit numeric hash of the redis key """"""
        return abs(int(hashlib.md5(
            self.key_prefix.encode('utf8')
        ).hexdigest(), 16)) % (10 ** (
            self._size_mod if hasattr(self, '_size_mod') else 5))"
3115,"def expire_at(self, _time):
        """""" Sets the expiration time of :prop:key_prefix to @_time
            @_time: absolute Unix timestamp (seconds since January 1, 1970)
        """"""
        return self._client.expireat(self.key_prefix, round(_time))"
3116,"def pexpire_at(self, _time):
        """""" Sets the expiration time of :prop:key_prefix to @_time
            @_time: absolute Unix timestamp (milliseconds
                since January 1, 1970)
        """"""
        return self._client.pexpireat(self.key_prefix, round(_time))"
3117,"def _decode(self, obj):
        """""" Decodes @obj using :prop:encoding if :prop:decode_responses """"""
        if self.decode_responses and isinstance(obj, bytes):
            try:
                return obj.decode(self.encoding)
            except UnicodeDecodeError:
                return obj
        return obj"
3118,"def _loads(self, string):
        """""" If :prop:serialized is True, @string will be unserialized
            using :prop:serializer
        """"""
        if not self.serialized:
            return self._decode(string)
        if string is not None:
            try:
                return self.serializer.loads(string)
            except TypeError:
                #: catches bytes errors with the builtin json library
                return self.serializer.loads(self._decode(string))
            except pickle.UnpicklingError as e:
                #: incr and decr methods create issues when pickle serialized
                #  It's a terrible idea for a serialized instance
                #  to be performing incr and decr methods, but I think
                #  it makes sense to catch the error regardless
                decoded = self._decode(string)
                if decoded.isdigit():
                    return decoded
                raise pickle.UnpicklingError(e)"
3119,"def _dumps(self, obj):
        """""" If :prop:serialized is True, @obj will be serialized
            using :prop:serializer
        """"""
        if not self.serialized:
            return obj
        return self.serializer.dumps(obj)"
3120,"def get(self, key, default=None):
        """""" Gets @key from :prop:key_prefix, defaulting to @default """"""
        try:
            return self[key]
        except KeyError:
            return default or self._default"
3121,"def incr(self, key, by=1):
        """""" Increments @key by @by
            -> #int the value of @key after the increment """"""
        return self._client.incr(self.get_key(key), by)"
3122,"def decr(self, key, by=1):
        """""" Decrements @key by @by
            -> #int the value of @key after the decrement """"""
        return self._client.decr(self.get_key(key), by)"
3123,"def mget(self, *keys):
        """""" -> #list of values at the specified @keys """"""
        keys = list(map(self.get_key, keys))
        return list(map(self._loads, self._client.mget(*keys)))"
3124,"def update(self, data):
        """""" Set given keys to their respective values
            @data: #dict or :class:RedisMap of |{key: value}| entries to set
        """"""
        if not data:
            return
        _rk, _dumps = self.get_key, self._dumps
        data = self._client.mset({
            _rk(key): _dumps(value)
            for key, value in data.items()})"
3125,"def set_ttl(self, key, ttl):
        """""" Sets time to live for @key to @ttl seconds
            -> #bool True if the timeout was set
        """"""
        return self._client.expire(self.get_key(key), ttl)"
3126,"def set_pttl(self, key, ttl):
        """""" Sets time to live for @key to @ttl milliseconds
            -> #bool True if the timeout was set
        """"""
        return self._client.pexpire(self.get_key(key), ttl)"
3127,"def expire_at(self, key, _time):
        """""" Sets the expiration time of @key to @_time
            @_time: absolute Unix timestamp (seconds since January 1, 1970)
        """"""
        return self._client.expireat(self.get_key(key), round(_time))"
3128,"def pop(self, key):
        """""" Removes @key from the instance, returns its value """"""
        r = self[key]
        self.remove(key)
        return r"
3129,"def remove(self, *keys):
        """""" Deletes @keys from :prop:_client
            @*keys: keys to remove

            -> #int the number of keys that were removed
        """"""
        keys = list(map(self.get_key, keys))
        return self._client.delete(*keys)"
3130,"def scan(self, match=""*"", count=1000, cursor=0):
        """""" Iterates the set of keys in :prop:key_prefix in :prop:_client
            @match: #str pattern to match after the :prop:key_prefix
            @count: the user specified the amount of work that should be done
                at every call in order to retrieve elements from the collection
            @cursor: the next cursor position

            -> #tuple (#int cursor position in scan, #list of full key names)
        """"""
        cursor, data = self._client.scan(
            cursor=cursor,
            match=""{}:{}"".format(self.key_prefix, match),
            count=count)
        return (cursor, list(map(self._decode, data)))"
3131,"def iter(self, match=""*"", count=1000):
        """""" Iterates the set of keys in :prop:key_prefix in :prop:_client
            @match: #str pattern to match after the :prop:key_prefix
            @count: the user specified the amount of work that should be done
                at every call in order to retrieve elements from the collection

            -> yields redis keys within this instance
        """"""
        replace_this = self.key_prefix+"":""
        for key in self._client.scan_iter(
           match=""{}:{}"".format(self.key_prefix, match), count=count):
            yield self._decode(key).replace(replace_this, """", 1)"
3132,"def items(self):
        """""" Iterates the set of |{key: value}| entries in :prop:key_prefix of
            :prop:_client

            -> yields redis (key, value) #tuples within this instance
        """"""
        cursor = '0'
        _loads = self._loads
        _mget = self._client.mget
        while cursor != 0:
            cursor, keys = self.scan(cursor=cursor)
            if keys:
                vals = _mget(*keys)
                for i, key in enumerate(keys):
                    yield (
                        key.replace(
                            self.key_prefix+"":"", """", 1),
                        _loads(vals[i])
                    )"
3133,"def clear(self, match=""*"", count=1000):
        """""" Removes all |{key: value}| entries in :prop:key_prefix of
            :prop:_client
        """"""
        cursor = '0'
        while cursor != 0:
            cursor, keys = self.scan(cursor=cursor, match=match, count=count)
            if keys:
                self._client.delete(*keys)"
3134,"def size(self):
        """""" -> #int number of keys in this instance """"""
        return int(self._client.hget(self._bucket_key, self.key_prefix) or 0)"
3135,"def _bucket_key(self):
        """""" Returns hash bucket key for the redis key """"""
        return ""{}.size.{}"".format(
            self.prefix, (self._hashed_key//1000)
            if self._hashed_key > 1000 else self._hashed_key)"
3136,"def incr(self, key, by=1):
        """""" :see::meth:RedisMap.incr """"""
        pipe = self._client.pipeline(transaction=False)
        pipe.incr(self.get_key(key), by)
        if key not in self:
            pipe.hincrby(self._bucket_key, self.key_prefix, 1)
        result = pipe.execute()
        return result[0]"
3137,"def update(self, data):
        """""" :see::meth:RedisMap.update """"""
        result = None
        if data:
            pipe = self._client.pipeline(transaction=False)
            for k in data.keys():
                pipe.exists(self.get_key(k))
            exists = pipe.execute()
            exists = exists.count(True)
            _rk, _dumps = self.get_key, self._dumps
            data = {
                _rk(key): _dumps(value)
                for key, value in data.items()}
            pipe.mset(data)
            pipe.hincrby(self._bucket_key, self.key_prefix, len(data)-exists)
            result = pipe.execute()[0]
        return result"
3138,"def clear(self, match=""*"", count=1000):
        """""" :see:meth:RedisMap.clear """"""
        cursor = '0'
        pipe = self._client.pipeline(transaction=False)
        while cursor != 0:
            cursor, keys = self.scan(cursor=cursor, match=match, count=count)
            if keys:
                pipe.delete(*keys)
        pipe.hdel(self._bucket_key, self.key_prefix)
        pipe.execute()
        return True"
3139,"def get(self, key, default=None):
        """""" Gets @key from :prop:key_prefix, defaulting to @default """"""
        result = self._loads(self._client.get(self.get_key(key)))
        if result is not None:
            return result
        else:
            return default or self._default"
3140,"def incr(self, field, by=1):
        """""" :see::meth:RedisMap.incr """"""
        return self._client.hincrby(self.key_prefix, field, by)"
3141,"def decr(self, field, by=1):
        """""" :see::meth:RedisMap.decr """"""
        return self._client.hincrby(self.key_prefix, field, by * -1)"
3142,"def mget(self, *keys):
        """""" -> #list of values at the specified @keys """"""
        return list(map(
            self._loads, self._client.hmget(self.key_prefix, *keys)))"
3143,"def all(self):
        """""" -> #dict of all |{key: value}| entries in :prop:key_prefix of
                :prop:_client
        """"""
        return {
            self._decode(k): self._loads(v)
            for k, v in self._client.hgetall(self.key_prefix).items()
        }"
3144,"def update(self, data):
        """""" :see::meth:RedisMap.update """"""
        result = None
        if data:
            _dumps = self._dumps
            data = {
                key: _dumps(value)
                for key, value in data.items()}
            result = self._client.hmset(self.key_prefix, data)
        return result"
3145,"def scan(self, match=""*"", count=1000, cursor=0):
        """""" :see::meth:RedisMap.scan """"""
        cursor, results = self._client.hscan(
            self.key_prefix, cursor=cursor, match=match, count=count)
        return (cursor, list(map(self._decode, results)))"
3146,"def iter(self, match=""*"", count=1000):
        """""" :see::meth:RedisMap.iter """"""
        for field, value in self._client.hscan_iter(
          self.key_prefix, match=match, count=count):
            yield self._decode(field)"
3147,"def items(self, match=""*"", count=1000):
        """""" :see::meth:RedisMap.items """"""
        for field, value in self._client.hscan_iter(
          self.key_prefix, match=match, count=count):
            yield self._decode(field), self._loads(value)"
3148,"def keys(self):
        """""" :see::meth:RedisMap.keys """"""
        for field in self._client.hkeys(self.key_prefix):
            yield self._decode(field)"
3149,"def values(self):
        """""" :see::meth:RedisMap.keys """"""
        for val in self._client.hvals(self.key_prefix):
            yield self._loads(val)"
3150,"def get(self, key, default=None):
        """""" Gets @key from :prop:key_prefix, defaulting to @default """"""
        try:
            result = self._loads(self._client.hget(self.key_prefix, key))
            assert result is not None
            return result
        except (AssertionError, KeyError):
            return default or self._default"
3151,"def reverse_iter(self, start=None, stop=None, count=2000):
        """""" -> yields items of the list in reverse """"""
        cursor = '0'
        count = 1000
        start = start if start is not None else (-1 * count)
        stop = stop if stop is not None else -1
        _loads = self._loads
        while cursor:
            cursor = self._client.lrange(self.key_prefix, start, stop)
            for x in reversed(cursor or []):
                yield _loads(x)
            start -= count
            stop -= count"
3152,"def reverse(self):
        """""" In place reverses the list. Very expensive on large data sets.
            The reversed list will be persisted to the redis :prop:_client
            as well.
        """"""
        tmp_list = RedisList(
            randint(0, 100000000), prefix=self.key_prefix,
            client=self._client, serializer=self.serializer,
            serialized=self.serialized)
        cursor = '0'
        count = 1000
        start = (-1 * count)
        stop = -1
        _loads = self._loads
        while cursor:
            cursor = self._client.lrange(self.key_prefix, start, stop)
            if cursor:
                tmp_list.extend(map(_loads, reversed(cursor)))
            start -= count
            stop -= count
        self._client.rename(tmp_list.key_prefix, self.key_prefix)
        tmp_list.clear()"
3153,"def pop(self, index=None):
        """""" Removes and returns the item at @index or from the end of the list
            -> item at @index
        """"""
        if index is None:
            return self._loads(self._client.rpop(self.key_prefix))
        elif index == 0:
            return self._loads(self._client.lpop(self.key_prefix))
        else:
            _uuid = gen_rand_str(16, 24)
            r = self[index]
            self[index] = _uuid
            self.remove(_uuid)
            return r"
3154,"def extend(self, items):
        """""" Adds @items to the end of the list
            -> #int length of list after operation
        """"""
        if items:
            if self.serialized:
                items = list(map(self._dumps, items))
            self._client.rpush(self.key_prefix, *items)"
3155,"def append(self, item):
        """""" Adds @item to the end of the list
            -> #int length of list after operation
        """"""
        return self._client.rpush(self.key_prefix, self._dumps(item))"
3156,"def count(self, value):
        """""" Not recommended for use on large lists due to time
            complexity, but it works. Use with caution.

            -> #int number of occurences of @value
        """"""
        cnt = 0
        for x in self:
            if x == value:
                cnt += 1
        return cnt"
3157,"def push(self, *items):
        """""" Prepends the list with @items
            -> #int length of list after operation
        """"""
        if self.serialized:
            items = list(map(self._dumps, items))
        return self._client.lpush(self.key_prefix, *items)"
3158,"def index(self, item):
        """""" Not recommended for use on large lists due to time
            complexity, but it works

            -> #int list index of @item
        """"""
        for i, x in enumerate(self.iter()):
            if x == item:
                return i
        return None"
3159,"def insert(self, index, value):
        """""" Inserts @value before @index in the list.

            @index: list index to insert @value before
            @value: item to insert
            @where: whether to insert BEFORE|AFTER @refvalue

            -> #int new length of the list on success or -1 if refvalue is not
                in the list.
        """"""
        _uuid = gen_rand_str(24, 32)
        item_at_index = self[index]
        self[index] = _uuid
        uuid = _uuid
        _uuid = self._dumps(uuid)
        pipe = self._client.pipeline(transaction=True)  # Needs to be atomic
        pipe.linsert(
                self.key_prefix, ""BEFORE"", _uuid, self._dumps(value))
        pipe.linsert(
                self.key_prefix, ""BEFORE"", _uuid, item_at_index)
        results = pipe.execute()
        self.remove(uuid)
        return results[0]"
3160,"def remove(self, item, count=0):
        """""" Removes @item from the list for @count number of occurences """"""
        self._client.lrem(self.key_prefix, count, self._dumps(item))"
3161,"def iter(self, start=0, count=1000):
        """""" @start: #int cursor start position
            @stop: #int cursor stop position
            @count: #int buffer limit

            -> yields all of the items in the list
        """"""
        cursor = '0'
        _loads = self._loads
        stop = start + count
        while cursor:
            cursor = self._client.lrange(self.key_prefix, start, stop)
            for x in cursor or []:
                yield _loads(x)
            start += (count + 1)
            stop += (count + 1)"
3162,"def trim(self, start, end):
        """""" Trim the list, removing all values not within the slice
            between @start and @end.

            @start and @end can be negative numbers just like python slicing
            notation.

            @start: #int start position
            @end: #int end position

            -> result of :meth:redis.StrictRedis.ltrim
        """"""
        return self._client.ltrim(self.key_prefix, start, end)"
3163,"def add(self, member):
        """""" Adds @member to the set
            -> #int the number of @members that were added to the set,
                excluding pre-existing members (1 or 0)
        """"""
        return self._client.sadd(self.key_prefix, self._dumps(member))"
3164,"def update(self, members):
        """""" Adds @members to the set
            @members: a :class:RedisSet object or #set

            -> #int the number of @members that were added to the set,
                excluding pre-existing members
        """"""
        if isinstance(members, RedisSet):
            size = self.size
            return (self.unionstore(
                self.key_prefix, members.key_prefix) - size)
        if self.serialized:
            members = list(map(self._dumps, members))
        if members:
            return self._client.sadd(self.key_prefix, *members)
        return 0"
3165,"def union(self, *others):
        """""" Calculates union between sets
            @others: one or several :class:RedisSet objects or #str redis set
                keynames

            -> #set of new set members
        """"""
        others = self._typesafe_others(others)
        return set(map(
            self._loads, self._client.sunion(self.key_prefix, *others)))"
3166,"def unioniter(self, *others):
        """""" The same as :meth:union, but returns iterator instead of #set

            @others: one or several :class:RedisSet objects or #str redis set
                keynames

            -> yields members of the resulting set
        """"""
        others = self._typesafe_others(others)
        for other in self._client.sunion(self.key_prefix, *others):
            yield self._loads(other)"
3167,"def unionstore(self, destination, *others):
        """""" The same as :meth:union, but stores the result in @destination

            @destination: #str keyname or :class:RedisSet
            @others: one or several #str keynames or :class:RedisSet objects

            -> #int number of items in the resulting set
        """"""
        others = self._typesafe_others(others)
        destination = self._typesafe(destination)
        return self._client.sunionstore(destination, self.key_prefix, *others)"
3168,"def intersection(self, *others):
        """""" Calculates the intersection of all the given sets, that is, members
            which are present in all given sets.

            @others: one or several #str keynames or :class:RedisSet objects

            -> #set of resulting intersection between @others and this set
        """"""
        others = self._typesafe_others(others)
        return set(map(
            self._loads, self._client.sinter(self.key_prefix, *others)))"
3169,"def interiter(self, *others):
        """""" The same as :meth:intersection, but returns iterator instead of #set

            @others: one or several #str keynames or :class:RedisSet objects

            -> yields members of the resulting set
        """"""
        others = self._typesafe_others(others)
        for other in self._client.sinter(self.key_prefix, *others):
            yield self._loads(other)"
3170,"def interstore(self, destination, *others):
        """""" The same as :meth:intersection, but stores the resulting set
            @destination

            @destination: #str keyname or :class:RedisSet
            @others: one or several #str keynames or :class:RedisSet objects

            -> #int number of members in resulting set
        """"""
        others = self._typesafe_others(others)
        destination = self._typesafe(destination)
        return self._client.sinterstore(destination, self.key_prefix, *others)"
3171,"def difference(self, *others):
        """""" Calculates the difference between this set and @others

            @others: one or several #str keynames or :class:RedisSet objects

            -> set resulting from the difference between the first set and
                all @others.
        """"""
        others = self._typesafe_others(others)
        return set(map(
            self._loads, self._client.sdiff(self.key_prefix, *others)))"
3172,"def diffiter(self, *others):
        """""" The same as :meth:difference, but returns iterator instead of #set

            @others: one or several #str keynames or :class:RedisSet objects

            -> yields members resulting from the difference between the first
                set and all @others.
        """"""
        others = self._typesafe_others(others)
        for other in self._client.sdiff(self.key_prefix, *others):
            yield self._loads(other)"
3173,"def diffstore(self, destination, *others):
        """""" The same as :meth:difference, but stores the resulting set
            @destination

            @destination: #str keyname or :class:RedisSet
            @others: one or several #str keynames or :class:RedisSet objects

            -> #int number of members in resulting set
        """"""
        others = self._typesafe_others(others)
        destination = self._typesafe(destination)
        return self._client.sdiffstore(destination, self.key_prefix, *others)"
3174,"def move(self, member, destination):
        """""" Moves @member from this set to @destination atomically

            @member: a member of this set
            @destination: #str redis keyname or :class:RedisSet object

            -> #bool True if the member was moved
        """"""
        destination = self._typesafe(destination)
        return self._client.smove(
            self.key_prefix, destination, self._dumps(member))"
3175,"def rand(self, count=1):
        """""" Gets @count random members from the set
            @count: #int number of members to return

            -> @count set members
        """"""
        result = self._client.srandmember(self.key_prefix, count)
        return set(map(self._loads, result))"
3176,"def remove(self, *members):
        """""" Removes @members from the set
            -> #int the number of members that were removed from the set
        """"""
        if self.serialized:
            members = list(map(self._dumps, members))
        return self._client.srem(self.key_prefix, *members)"
3177,"def members(self):
        """""" -> #set of all members in the set """"""
        if self.serialized:
            return set(map(
                self._loads, self._client.smembers(self.key_prefix)))
        else:
            return set(map(
                self._decode, self._client.smembers(self.key_prefix)))"
3178,"def scan(self, match=""*"", count=1000, cursor=0):
        """""" :see::RedisMap.scan """"""
        cursor, data = self._client.sscan(
            self.key_prefix, cursor=cursor, match=match, count=count)
        return (cursor, set(map(self._loads, data)))"
3179,"def iter(self, match=""*"", count=1000):
        """""" Iterates the set members in :prop:key_prefix of :prop:_client
            @match: #str pattern to match items by
            @count: the user specified the amount of work that should be done
                at every call in order to retrieve elements from the collection

            -> yields members of the set
        """"""
        _loads = self._loads
        for m in self._client.sscan_iter(
           self.key_prefix, match=""*"", count=count):
            yield _loads(m)"
3180,"def incr(self, member, by=1):
        """""" Increments @member by @by within the sorted set """"""
        return self._client.zincrby(self.key_prefix, self._dumps(member), by)"
3181,"def decr(self, member, by=1):
        """""" Decrements @member by @by within the sorted set """"""
        return self._client.zincrby(
            self.key_prefix, self._dumps(member), by * -1)"
3182,"def add(self, *args, **kwargs):
        """""" Adds member/value pairs to the sorted set in two ways:

            To add with @args:
            ..
                pairs = [4.0, 'member1', 5.0, 'member2']
                sorted_set.add(*pairs)
                # sorted_set.add(4.0, 'member1', 5.0, 'member2')
            ..

            To add with @kwargs:
            ..
                pairs = {""member1"": 4.0, ""member2"": 5.0}
                sorted_set.add(**pairs)
                # sorted_set.add(member1=4.0, member2=5.0)
            ..
        """"""
        if args or kwargs:
            _dumps = self._dumps
            zargs = list(args)
            if args and self.serialized:
                # args format: value, key, value, key...
                zargs = [
                    _dumps(x) if (i % 2 == 1 and self.serialized) else x
                    for i, x in enumerate(args)]
            if kwargs:
                # kwargs format: key=value, key=value
                zargs += [
                    _dumps(x) if (i % 2 == 1 and self.serialized) else x
                    for y in kwargs.items() for i, x in enumerate(reversed(y))]
            return self._client.zadd(self.key_prefix, *zargs)"
3183,"def update(self, data):
        """""" Adds @data to the sorted set
            @data: #dict or dict-like object
        """"""
        if data:
            _dumps = self._dumps
            zargs = [
                _dumps(x) if (i % 2 == 1) else x
                for y in data.items()
                for i, x in enumerate(reversed(y))
            ]
            return self._client.zadd(self.key_prefix, *zargs)"
3184,"def remove(self, *members):
        """""" Removes @members from the sorted set """"""
        members = list(map(self._dumps, members))
        self._client.zrem(self.key_prefix, *members)"
3185,"def rank(self, member):
        """""" Gets the ASC rank of @member from the sorted set, that is,
            lower scores have lower ranks
        """"""
        if self.reversed:
            return self._client.zrevrank(self.key_prefix, self._dumps(member))
        return self._client.zrank(self.key_prefix, self._dumps(member))"
3186,"def count(self, min, max):
        """""" -> #int number of elements in the sorted set with a score between
                @min and @max.
        """"""
        return self._client.zcount(self.key_prefix, min, max)"
3187,"def iter(self, start=0, stop=-1, withscores=False, reverse=None):
        """""" Return a range of values from sorted set name between
            @start and @end sorted in ascending order unless @reverse or
            :prop:reversed.

            @start and @end: #int, can be negative, indicating the end of
                the range.
            @withscores: #bool indicates to return the scores along with the
                members, as a list of |(member, score)| pairs
            @reverse: #bool indicating whether to sort the results descendingly

            -> yields members or |(member, score)| #tuple pairs
        """"""
        reverse = reverse if reverse is not None else self.reversed
        _loads = self._loads
        for member in self._client.zrange(
           self.key_prefix, start=start, end=stop, withscores=withscores,
           desc=reverse, score_cast_func=self.cast):
            if withscores:
                yield (_loads(member[0]), self.cast(member[1]))
            else:
                yield _loads(member)"
3188,"def iterbyscore(self, min='-inf', max='+inf', start=None, num=None,
                    withscores=False, reverse=None):
        """""" Return a range of values from the sorted set name with scores
            between @min and @max.

            If @start and @num are specified, then return a slice
            of the range.

            @min: #int minimum score, or #str '-inf'
            @max: #int minimum score, or #str '+inf'
            @start: #int starting range position
            @num: #int number of members to fetch
            @withscores: #bool indicates to return the scores along with the
                members, as a list of |(member, score)| pairs
            @reverse: #bool indicating whether to sort the results descendingly

            -> yields members or |(member, score)| #tuple pairs
        """"""
        reverse = reverse if reverse is not None else self.reversed
        zfunc = self._client.zrangebyscore if not reverse \
            else self._client.zrevrangebyscore
        _loads = self._loads
        for member in zfunc(
           self.key_prefix, min=min, max=max, start=start, num=num,
           withscores=withscores, score_cast_func=self.cast):
            if withscores:
                yield (_loads(member[0]), self.cast(member[1]))
            else:
                yield _loads(member)"
3189,"def itemsbyscore(self, min='-inf', max='+inf', start=None, num=None,
                     reverse=None):
        """""" Return a range of |(member, score)| pairs from the sorted set name
            with scores between @min and @max.

            If @start and @num are specified, then return a slice
            of the range.

            @min: #int minimum score, or #str '-inf'
            @max: #int minimum score, or #str '+inf'
            @start: #int starting range position
            @num: #int number of members to fetch
            @reverse: #bool indicating whether to sort the results descendingly

            -> yields |(member, score)| #tuple pairs
        """"""
        reverse = reverse if reverse is not None else self.reversed
        for member in self.iterbyscore(
           min, max, start, num, withscores=True, reverse=reverse):
            yield member"
3190,"def iterscan(self, match=""*"", count=1000):
        """""" Much slower than iter(), but much more memory efficient if
            k/v's retrieved are one-offs

            @match: matches member names in the sorted set
            @count: the user specified the amount of work that should be done
                at every call in order to retrieve elements from the collection

            -> iterator of |(member, score)| pairs
        """"""
        if self.serialized:
            return map(
                lambda x: (self._loads(x[0]), self.cast(x[1])),
                self._client.zscan_iter(
                    self.key_prefix, match=match, count=count))
        else:
            return map(
                lambda x: (self._decode(x[0]), self.cast(x[1])),
                self._client.zscan_iter(
                    self.key_prefix, match=match, count=count))"
3191,"def scan(self, match=""*"", count=1000, cursor=0):
        """""" :see::meth:RedisMap.scan """"""
        if self.serialized:
            cursor, data = self._client.zscan(
                self.key_prefix, cursor=cursor, match=match, count=count)
            return (cursor, list(map(
                lambda x: (self._loads(x[0]), self.cast(x[1])), data)))
        else:
            cursor, data = self._client.zscan(
                self.key_prefix, cursor=cursor, match=match, count=count)
            return (cursor, list(map(
                lambda x: (self._decode(x[0]), self.cast(x[1])), data)))"
3192,"def recv_blocking(conn, msglen):
    """"""Recieve data until msglen bytes have been received.""""""
    msg = b''
    while len(msg) < msglen:
        maxlen = msglen-len(msg)
        if maxlen > 4096:
            maxlen = 4096
        tmpmsg = conn.recv(maxlen)
        if not tmpmsg:
            raise RuntimeError(""socket connection broken"")
        msg += tmpmsg
        logging.debug(""Msglen: %d of %d"", len(msg), msglen)
    logging.debug(""Message: %s"", msg)
    return msg"
3193,"def compare_password(expected, actual):
    """"""Compare two 64byte encoded passwords.""""""
    if expected == actual:
        return True, ""OK""
    msg = []
    ver_exp = expected[-8:].rstrip()
    ver_act = actual[-8:].rstrip()

    if expected[:-8] != actual[:-8]:
        msg.append(""Password mismatch"")
    if ver_exp != ver_act:
        msg.append(""asterisk_mbox version mismatch.  Client: '"" +
                   ver_act + ""',  Server: '"" + ver_exp + ""'"")
    return False, "". "".join(msg)"
3194,"def encode_to_sha(msg):
    """"""coerce numeric list inst sha-looking bytearray""""""
    if isinstance(msg, str):
        msg = msg.encode('utf-8')
    return (codecs.encode(msg, ""hex_codec"") + (b'00' * 32))[:64]"
3195,"def decode_from_sha(sha):
    """"""convert coerced sha back into numeric list""""""
    if isinstance(sha, str):
        sha = sha.encode('utf-8')
    return codecs.decode(re.sub(rb'(00)*$', b'', sha), ""hex_codec"")"
3196,"def put(self, item, block=True, timeout=None):
        """"""put.""""""
        super().put(item, block, timeout)
        self._putsocket.send(b'x')"
3197,"def get(self, block=True, timeout=None):
        """"""get.""""""
        try:
            item = super().get(block, timeout)
            self._getsocket.recv(1)
            return item
        except queue.Empty:
            raise queue.Empty"
3198,"def _api_path(self, item):
        """"""Get the API path for the current cursor position.""""""
        if self.base_url is None:
            raise NotImplementedError(""base_url not set"")
        path = ""/"".join([x.blob[""id""] for x in item.path])
        return ""/"".join([self.base_url, path])"
3199,"def run(self):
        """""" Run at parse time.

        When the documents are initially being scanned, this method runs
        and does two things: (a) creates an instance that is added to
        the site's widgets, and (b) leaves behind a placeholder docutils
        node that can later be processed after the docs are resolved.
        The latter needs enough information to retrieve the former.

        """"""

        this_widget = self.get_widget(self.docname)

        self.widgets[repr(this_widget)] = this_widget

        # Now add the node to the doctree
        widget_node = widget()
        ids = [repr(this_widget)]
        names = [self.name]
        attrs = dict(ids=ids, names=names)
        widget_node.update_basic_atts(attrs)
        return [widget_node]"
3200,"def register_references(kb_app: kb,
                        sphinx_app: Sphinx,
                        sphinx_env: BuildEnvironment,
                        docnames: List[str]):
    """""" Walk the registry and add sphinx directives """"""

    references: ReferencesContainer = sphinx_app.env.references

    for name, klass in kb_app.config.resources.items():
        # Name is the value in the decorator and directive, e.g.
        # @kb.resource('category') means name=category
        if getattr(klass, 'is_reference', False):
            references[name] = dict()"
3201,"def register_handlers(self, handler_classes):
        """"""
        Create handlers from discovered handler classes

        :param handler_classes: List of :class:`~responsebot.handlers.base.BaseTweetHandler`'s derived classes
        """"""
        for handler_class in handler_classes:
            self.handlers.append(handler_class(client=self.client))
            logging.info('Successfully registered {handler_class}'.format(
                handler_class=getattr(handler_class, '__name__', str(handler_class)))
            )"
3202,"def on_tweet(self, tweet):
        """"""
        Callback to receive tweet from :class:`~responsebot.responsebot_stream.ResponseBotStream`. Tries to forward the
        received tweet to registered handlers.

        :param tweet: An object containing a tweet's text and metadata
        :type tweet: :class:`~responsebot.models.Tweet`
        """"""
        logging.info(u'Received tweet: `{message}`'.format(message=tweet.text))

        for handler in self.handlers:
            if not handler.catch_self_tweets and self.is_self_tweet(tweet):
                continue

            if not handler.filter.match_tweet(tweet=tweet, user_stream=self.client.config.get('user_stream')):
                continue

            handler.on_tweet(tweet)"
3203,"def on_event(self, event):
        """"""
        Callback to receive events from :class:`~responsebot.responsebot_stream.ResponseBotStream`. Tries to forward the
        received event to registered handlers.

        :param event: The received event
        :type event: :class:`~responsebot.models.Event`
        error from a custom handler
        """"""
        if event.event not in TWITTER_NON_TWEET_EVENTS:
            logging.warning(u'Received unknown twitter event {event}'.format(event=event.event))
            return

        logging.info(u'Received event {event}'.format(event=event.event))

        for handler in self.handlers:
            handler.on_event(event)"
3204,"def get_merged_filter(self):
        """"""
        Return merged filter from list of handlers

        :return: merged filter
        :rtype: :class:`~responsebot.models.TweetFilter`
        """"""
        track = set()
        follow = set()

        for handler in self.handlers:
            track.update(handler.filter.track)
            follow.update(handler.filter.follow)

        return TweetFilter(track=list(track), follow=list(follow))"
3205,"def get_domain(url):
    """"""
    Get domain part of an url.

    For example: https://www.python.org/doc/ -> https://www.python.org
    """"""
    parse_result = urlparse(url)
    domain = ""{schema}://{netloc}"".format(
        schema=parse_result.scheme, netloc=parse_result.netloc)
    return domain"
3206,"def join_all(domain, *parts):
    """"""
    Join all url components.

    Example::

        >>> join_all(""https://www.apple.com"", ""iphone"")
        https://www.apple.com/iphone

    :param domain: Domain parts, example: https://www.python.org
    :param parts: Other parts, example: ""/doc"", ""/py27""
    :return: url
    """"""
    l = list()

    if domain.endswith(""/""):
        domain = domain[:-1]
    l.append(domain)

    for part in parts:
        for i in part.split(""/""):
            if i.strip():
                l.append(i)
    url = ""/"".join(l)
    return url"
3207,"def add_params(endpoint, params):
    """"""
    Combine query endpoint and params.

    Example::

        >>> add_params(""https://www.google.com/search"", {""q"": ""iphone""})
        https://www.google.com/search?q=iphone
    """"""
    p = PreparedRequest()
    p.prepare(url=endpoint, params=params)
    if PY2:  # pragma: no cover
        return unicode(p.url)
    else:  # pragma: no cover
        return p.url"
3208,"def neval(expression, globals=None, locals=None, **kwargs):
    """"""Evaluate *expression* using *globals* and *locals* dictionaries as
    *global* and *local* namespace.  *expression* is transformed using
    :class:`.NapiTransformer`.""""""

    try:
        import __builtin__ as builtins
    except ImportError:
        import builtins

    from ast import parse
    from ast import fix_missing_locations as fml

    try:
        transformer = kwargs['transformer']
    except KeyError:
        from napi.transformers import NapiTransformer as transformer

    #try:
    node = parse(expression, '<string>', 'eval')
    #except ImportError:
    #    builtins.eval(expression)
    #else:
    if globals is None:
        globals = builtins.globals()
    if locals is None:
        locals = {}
    trans = transformer(globals=globals, locals=locals, **kwargs)
    trans.visit(node)
    code = compile(fml(node), '<string>', 'eval')
    return builtins.eval(code, globals, locals)"
3209,"def nexec(statement, globals=None, locals=None, **kwargs):
    """"""Execute *statement* using *globals* and *locals* dictionaries as
    *global* and *local* namespace.  *statement* is transformed using
    :class:`.NapiTransformer`.""""""

    try:
        import __builtin__ as builtins
    except ImportError:
        import builtins

    from ast import parse
    from napi.transformers import NapiTransformer
    from ast import fix_missing_locations as fml
    try:
        node = parse(statement, '<string>', 'exec')
    except ImportError:#KeyError:
        exec(statement)
    else:
        if globals is None:
            globals = builtins.globals()
        if locals is None:
            locals = {}
        trans = NapiTransformer(globals=globals, locals=locals, **kwargs)
        trans.visit(node)
        code = compile(fml(node), '<string>', 'exec')
        return builtins.eval(code, globals, locals)"
3210,"def cli(ctx, oldversion):
    """"""Upgrade the current bubble, should mimic init as much as possible(experimental)""""""
    # print ctx.bubble
    path = ctx.home
    bubble_file_name = path + '/.bubble'
    config_file = path + '/config/config.yaml'

    if file_exists(bubble_file_name):
        pass
    else:
        with open(bubble_file_name, 'w') as dot_bubble:
            dot_bubble.write('bubble=' + metadata.version)
            dot_bubble.write('\nconfig=' + config_file)

        ctx.say_green('Initialised a  new bubble in [%s]' %
                      click.format_filename(bubble_file_name))

    create_dir(ctx, path + '/config/')
    create_dir(ctx, path + '/logs/')
    create_dir(ctx, path + '/export/')
    create_dir(ctx, path + '/import/')
    create_dir(ctx, path + '/remember/')
    create_dir(ctx, path + '/remember/archive')

    rules_file = path + '/config/rules.bubble'
    if file_exists(bubble_file_name):
        pass
    else:
        with open(rules_file, 'w') as rules:
            rules.write(get_example_rules_bubble())
            ctx.say_green('Created an example rules in [%s]' %
                          click.format_filename(rules_file))

    rule_functions_file = path + '/custom_rule_functions.py'
    if file_exists(rule_functions_file):
        pass
    else:
        with open(rule_functions_file, 'w') as rule_functions:
            rule_functions.write(get_example_rule_functions())
            ctx.say_green('Created an example rule_functions in [%s]' %
                          click.format_filename(rule_functions_file))

    ctx.say_green('Bubble upgraded')"
3211,"def _list_remote(store, maildir, verbose=False):
    """"""List the a maildir.

    store is an abstract representation of the source maildir. 

    maildir is the local maildir to which mail will be pulled.

    This is a generator for a reason. Because of the way ssh
    multi-mastering works a single open TCP connection allows multiple
    virtual ssh connections. So the encryption and tcp only has to be
    done once.

    If this command returned a list then the ssh list command would
    have finished and the ssh connection for each message would have
    to be made again.
    """"""
    # This command produces a list of all files in the maildir like:
    #   base-filename timestamp container-directory
    command = """"""echo {maildir}/{{cur,new}} | tr ' ' '\\n' | while read path ; do ls -1Ugo --time-style=+%s $path | sed -rne ""s|[a-zA-Z-]+[ \t]+[0-9]+[ \t]+[0-9]+[ \t]+([0-9]+)[ \t]+([0-9]+\\.[A-Za-z0-9]+)(\\.([.A-Za-z0-9-]+))*(:[2],([PRSTDF]*))*|\\2 \\1 $path|p"";done""""""
    stdout = store.cmd(command, verbose)
    lines = stdout.split(""\n"")
    for line in lines:
        parts = line.split("" "")
        if len(parts) >= 3:
            yield parts[0:3]"
3212,"def sshpull(host, maildir, localmaildir, noop=False, verbose=False, filterfile=None):
    """"""Pull a remote maildir to the local one.
    """"""
    store = _SSHStore(host, maildir)
    _pull(store, localmaildir, noop, verbose, filterfile)"
3213,"def filepull(maildir, localmaildir, noop=False, verbose=False, filterfile=None):
    """"""Pull one local maildir into another.

    The source need not be an md folder (it need not have a store). In
    this case filepull is kind of an import.
    """"""
    store = _Store(maildir)
    _pull(store, localmaildir, noop, verbose, filterfile)"
3214,"def _filter(msgdata, mailparser, mdfolder, mailfilters):
    """"""Filter msgdata by mailfilters""""""
    if mailfilters:
        for f in mailfilters:
            msg = mailparser.parse(StringIO(msgdata))
            rule = f(msg, folder=mdfolder)
            if rule:
                yield rule
    return"
3215,"def cmd(self, cmd, verbose=False):
        """"""Executes the specified command on the remote host.

        The cmd must be format safe, this means { and } must be doubled, thusly:

          echo /var/local/maildir/{{cur,new}}

        the cmd can include the format word 'maildir' to be replaced
        by self.directory. eg:

          echo {maildir}/{{cur,new}}
        """"""
        command = cmd.format(maildir=self.directory)
        if verbose:
            print(command)
        p = Popen([
                ""ssh"",
                ""-T"",
                self.host,
                command
                ], stdin=PIPE, stdout=PIPE, stderr=PIPE)
        stdout,stderr = p.communicate()
        return stdout"
3216,"def fetch_result(self):
        """"""Return a list of urls for each search result.""""""
        results = self.soup.find_all('div', {'class': 'container container-small'})
        href = None
        is_match = False

        i = 0
        while i < len(results) and not is_match:
            result = results[i]
            anchor = result.find('a', {'rel': 'bookmark'})
            is_match = self._filter_results(result, anchor)
            href = anchor['href']

            i += 1

        try:
            page = get_soup(href)
        except (Exception):
            page = None

        # Return page if search is successful
        if href and page:
            return page
        else:
            raise PageNotFoundError(PAGE_ERROR)"
3217,"def _filter_results(self, result, anchor):
        """"""Filter search results by checking category titles and dates""""""
        valid = True

        try:
            cat_tag = result.find('a', {'rel': 'category tag'}).string
            title = anchor.string.lower()
            date_tag = result.find('time').string
        except (AttributeError, TypeError):
            return False      
             
        if cat_tag != ""Daily Ratings"":
            valid = False
        if not date_in_range(self.date, date_tag, 5):
            valid = False
        if self.category == 'cable' and 'cable' not in title:
            valid = False
        elif self.category != 'cable' and 'cable' in title:
            valid = False

        return valid"
3218,"def _build_url(self):
        """"""Build url based on searching by date or by show.""""""
        url_params = [
            BASE_URL, self.category + ' ratings', self.day, self.year, self.month
        ]

        return SEARCH_URL.format(*url_params)"
3219,"def _assert_category(self, category):
        """"""Validate category argument""""""
        category = category.lower()
        valid_categories = ['cable', 'broadcast', 'final', 'tv']
        assert_msg = ""%s is not a valid category."" % (category)
        assert (category in valid_categories), assert_msg"
3220,"def _get_response(self, url, **params):
        """""" Giving a service path and optional specific arguments, returns
        the response string.
        """"""
        data = urlencode(params)
        url = ""%s?%s"" % (url, data)
        headers = {'User-Agent': self.get_random_agent()}
        request = Request(url, headers=headers, method='GET')

        def open_request(request, attempts, err=None):
            if attempts > self.request_attempts:
                raise
            attempts += 1
            try:
                with urlopen(request, timeout=self.timeout) as response:
                    return response.read()
            except HTTPError as err:
                if err.getcode() < 500:
                    raise
                print(""HTTPError occurred while trying to request the url ""
                      ""%s. %s. Trying again in %s seconds..."" % (url, err,
                                                self.seconds_between_attempts))
                time.sleep(self.seconds_between_attempts)
                return open_request(request, attempts, err)

        attempts = 0
        self.last_response = open_request(request, attempts)
        return self.last_response"
3221,"def get_response(self, path, **params):
        """""" Giving a service path and optional specific arguments, returns
        the response string.
        """"""
        url = ""%s%s"" % (self.base_url, path)
        return self._get_response(url, **params)"
3222,"def get_data(self, path, **params):
        """""" Giving a service path and optional specific arguments, returns
        the XML data from the API parsed as a dict structure.
        """"""
        xml = self.get_response(path, **params)
        try:
            return parse(xml)
        except Exception as err:
            print(path)
            print(params)
            print(err)
            raise"
3223,"def run(self, port): # pragma: no coverage
        """"""
        Run on given port. Parse standard options and start the http server.
        """"""
        tornado.options.parse_command_line()
        http_server = tornado.httpserver.HTTPServer(self)
        http_server.listen(port)
        tornado.ioloop.IOLoop.instance().start()"
3224,"def log_request(self, handler):
        """"""
        Override base method to log requests to JSON UDP collector and emit
        a metric.
        """"""
        packet = {'method': handler.request.method,
                  'uri': handler.request.uri,
                  'remote_ip': handler.request.remote_ip,
                  'status': handler.get_status(),
                  'request_time_ms': handler.request.request_time() * 1000.0,
                  'service_id': self.service_id,
                  'request_id': handler.request.headers.get(REQUEST_ID_HEADER,
                                                            'undefined')
                  }

        # handler can optionally define additional data to log
        if hasattr(handler, 'logvalues'):
            for key, value in handler.logvalues.iteritems():
                packet[key] = value

        servicelog.log(packet)

        metric = ""requests."" + str(handler.get_status())
        metrics.timing(metric, handler.request.request_time() * 1000.0)

        super(LoggingApplication, self).log_request(handler)"
3225,"def logvalue(self, key, value):
        """"""Add log entry to request log info""""""
        if not hasattr(self, 'logvalues'):
            self.logvalues = {}
        self.logvalues[key] = value"
3226,"def write_error(self, status_code, **kwargs):
        """"""Log halt_reason in service log and output error page""""""
        message = default_message = httplib.responses.get(status_code, '')
        # HTTPError exceptions may have a log_message attribute
        if 'exc_info' in kwargs:
            (_, exc, _) = kwargs['exc_info']
            if hasattr(exc, 'log_message'):
                message = str(exc.log_message) or default_message
        self.logvalue('halt_reason', message)
        title = ""{}: {}"".format(status_code, default_message)
        body = ""{}: {}"".format(status_code, message)
        self.finish(""<html><title>"" + title + ""</title>""
                    ""<body>"" + body + ""</body></html>"")"
3227,"def timeit(self, metric, func, *args, **kwargs):
        """"""Time execution of callable and emit metric then return result.""""""
        return metrics.timeit(metric, func, *args, **kwargs)"
3228,"def require_content_type(self, content_type):
        """"""Raises a 400 if request content type is not as specified.""""""
        if self.request.headers.get('content-type', '') != content_type:
            self.halt(400, 'Content type must be ' + content_type)"
3229,"def set_headers(self, headers):
        """"""Set headers""""""
        for (header, value) in headers.iteritems():
            self.set_header(header, value)"
3230,"def _ensure_request_id_header(self):
        ""Ensure request headers have a request ID. Set one if needed.""
        if REQUEST_ID_HEADER not in self.request.headers:
            self.request.headers.add(REQUEST_ID_HEADER, uuid.uuid1().hex)"
3231,"def load_parameters(self, source):
        """"""For YML, the source it the file path""""""
        with open(source) as parameters_source:
            loaded = yaml.safe_load(parameters_source.read())
            for k, v in loaded.items():
                if isinstance(v, str):
                    loaded[k] = ""'""+v+""'""
            return loaded"
3232,"def load_config(self, config_source, parameters_source):
        """"""For YML, the source it the file path""""""
        with open(config_source) as config_source:
            config_raw = config_source.read()

            parameters = {}
            """"""Parameteres from file""""""
            if os.path.isfile(parameters_source):
                params = self.load_parameters(parameters_source)
                if params is not None:
                    parameters.update(params)

            """"""Overwrite parameteres with the environment variables""""""
            env_params = {}
            env_params.update(os.environ)
            for k, v in env_params.items():
                if is_string(v):
                    env_params[k] = ""'"" + v + ""'""

            parameters.update(env_params)

            """"""Replace the parameters""""""
            final_configuration = config_raw.format(**parameters)
            final_configuration = yaml.safe_load(final_configuration)
            return final_configuration if final_configuration is not None else {}"
3233,"def load_parameters(self, source):
        """"""For JSON, the source it the file path""""""
        with open(source) as parameters_source:
            return json.loads(parameters_source.read())"
3234,"def load_config(self, config_source, parameters_source):
        """"""For JSON, the source it the file path""""""
        with open(config_source) as config_source:
            config_raw = config_source.read()
            """"""Replace the parameters""""""
            pattern = ""(%[a-zA-Z_0-9]*%)""

            self.parameters = {}
            """"""Parameteres from file""""""
            if os.path.isfile(parameters_source):
                self.parameters.update(self.load_parameters(parameters_source))

            """"""Overwrite parameteres with the environment variables""""""
            self.parameters.update(os.environ)

            replaced_config = re.sub(pattern=pattern, repl=self._replace_function, string=config_raw)
            return json.loads(replaced_config)"
3235,"def main():
    """"""Testing function for DFA _Brzozowski Operation""""""
    if len(argv) < 2:
        targetfile = 'target.y'
    else:
        targetfile = argv[1]
    print 'Parsing ruleset: ' + targetfile,
    flex_a = Flexparser()
    mma = flex_a.yyparse(targetfile)
    print 'OK'
    print 'Perform minimization on initial automaton:',
    mma.minimize()
    print 'OK'
    print 'Perform StateRemoval on minimal automaton:',
    state_removal = StateRemoval(mma)
    mma_regex = state_removal.get_regex()
    print mma_regex"
3236,"def _state_removal_init(self):
        """"""State Removal Operation Initialization""""""
        # First, we remove all multi-edges:
        for state_i in self.mma.states:
            for state_j in self.mma.states:
                if state_i.stateid == state_j.stateid:
                    self.l_transitions[
                        state_i.stateid, state_j.stateid] = self.epsilon
                else:
                    self.l_transitions[
                        state_i.stateid, state_j.stateid] = self.empty

                for arc in state_i.arcs:
                    if arc.nextstate == state_j.stateid:
                        if self.l_transitions[state_i.stateid, state_j.stateid] != self.empty:
                            self.l_transitions[state_i.stateid, state_j.stateid] \
                                += self.mma.isyms.find(arc.ilabel)
                        else:
                            self.l_transitions[state_i.stateid, state_j.stateid] = \
                                self.mma.isyms.find(arc.ilabel)"
3237,"def _state_removal_remove(self, k):
        """"""
        State Removal Remove operation
        l_transitions[i,i] += l_transitions[i,k] . star(l_transitions[k,k]) . l_transitions[k,i]
        l_transitions[j,j] += l_transitions[j,k] . star(l_transitions[k,k]) . l_transitions[k,j]
        l_transitions[i,j] += l_transitions[i,k] . star(l_transitions[k,k]) . l_transitions[k,j]
        l_transitions[j,i] += l_transitions[j,k] . star(l_transitions[k,k]) . l_transitions[k,i]
        Args:
            k (int): The node that will be removed
        Returns:
            None
        """"""
        for state_i in self.mma.states:
            for state_j in self.mma.states:
                if self.l_transitions[state_i.stateid, k] != self.empty:
                    l_ik = self.l_transitions[state_i.stateid, k]
                else:
                    l_ik = """"
                if self.l_transitions[state_j.stateid, k] != self.empty:
                    l_jk = self.l_transitions[state_j.stateid, k]
                else:
                    l_jk = """"
                if self.l_transitions[k, state_i.stateid] != self.empty:
                    l_ki = self.l_transitions[k, state_i.stateid]
                else:
                    l_ki = """"
                if self.l_transitions[k, state_j.stateid] != self.empty:
                    l_kj = self.l_transitions[k, state_j.stateid]
                else:
                    l_kj = """"

                if self.l_transitions[state_i.stateid, state_i.stateid] != self.empty:
                    self.l_transitions[state_i.stateid, state_i.stateid] += l_ik + \
                        self.star(self.l_transitions[k, k]) + l_ki
                else:
                    self.l_transitions[state_i.stateid, state_i.stateid] = l_ik + \
                        self.star(self.l_transitions[k, k]) + l_ki

                if self.l_transitions[state_j.stateid, state_j.stateid] != self.empty:
                    self.l_transitions[state_j.stateid, state_j.stateid] += l_jk + \
                        self.star(self.l_transitions[k, k]) + l_kj
                else:
                    self.l_transitions[state_j.stateid, state_j.stateid] = l_jk + \
                        self.star(self.l_transitions[k, k]) + l_kj

                if self.l_transitions[state_i.stateid, state_j.stateid] != self.empty:
                    self.l_transitions[state_i.stateid, state_j.stateid] += l_ik + \
                        self.star(self.l_transitions[k, k]) + l_kj
                else:
                    self.l_transitions[state_i.stateid, state_j.stateid] = l_ik + \
                        self.star(self.l_transitions[k, k]) + l_kj

                if self.l_transitions[state_j.stateid, state_i.stateid] != self.empty:
                    self.l_transitions[state_j.stateid, state_i.stateid] += l_jk + \
                        self.star(self.l_transitions[k, k]) + l_ki
                else:
                    self.l_transitions[state_j.stateid, state_i.stateid] = l_jk + \
                        self.star(self.l_transitions[k, k]) + l_ki"
3238,"def _state_removal_solve(self):
        """"""The State Removal Operation""""""
        initial = sorted(
            self.mma.states,
            key=attrgetter('initial'),
            reverse=True)[0].stateid
        for state_k in self.mma.states:
            if state_k.final:
                continue
            if state_k.stateid == initial:
                continue
            self._state_removal_remove(state_k.stateid)

        print self.l_transitions
        return self.l_transitions"
3239,"def cli(ctx,
        amount,
        index,
        stage,
        stepresult,
        formattype,
        select,
        where,
        order,
        outputfile,
        showkeys,
        showvalues,
        showalways,
        position):
    """"""Export from memory to format supported by tablib""""""
    if not ctx.bubble:
        msg = 'There is no bubble present, will not export'
        ctx.say_yellow(msg)
        raise click.Abort()
    path = ctx.home + '/'

    if stage not in STAGES:
        ctx.say_yellow('There is no known stage:' + stage)
        raise click.Abort()
    if stepresult not in exportables:
        ctx.say_yellow('stepresult not one of: ' + ', '.join(exportables))
        raise click.Abort()

    data_gen = bubble_lod_load(ctx, stepresult, stage)

    ctx.gbc.say('data_gen:', stuff=data_gen, verbosity=20)

    part = get_gen_slice(ctx.gbc, data_gen, amount, index)
    ctx.gbc.say('selected part:', stuff=part, verbosity=20)

    aliases = get_pairs(ctx.gbc, select, missing_colon=True)
    if position or len(aliases) == 0:
        ctx.gbc.say('adding position to selection of columns:',
                    stuff=aliases, verbosity=20)
        aliases.insert(0, {'key': buts('index'), 'val': 'BUBBLE_IDX'})
        ctx.gbc.say('added position to selection of columns:',
                    stuff=aliases, verbosity=20)

    wheres = get_pairs(ctx.gbc, where)
    # TODO: use aliases as lookup for wheres

    data = tablib.Dataset()

    data.headers = [sel['val'] for sel in aliases]
    ctx.gbc.say('select wheres:' + str(wheres), verbosity=20)
    ctx.gbc.say('select aliases:' + str(aliases), verbosity=20)
    ctx.gbc.say('select data.headers:' + str(data.headers), verbosity=20)

    not_shown = True
    try:
        for ditem in part:
            row = []
            ctx.gbc.say('curr dict', stuff=ditem, verbosity=101)

            flitem = flat(ctx, ditem)
            ctx.gbc.say('curr flat dict', stuff=flitem, verbosity=101)
            row_ok = True
            for wp in wheres:
                # TODO: negative selects: k:None, k:False,k:Zero,k:Null,k:0,k:-1,k:'',k:"""",
                # TODO: negative selects:
                # k:BUBBLE_NO_KEY,k:BUBBLE_NO_VAL,k:BUBBLE_NO_KEY_OR_NO_VAL

                wcheck_key=True
                if wp['key'] not in flitem:
                    row_ok = False
                    wcheck_key=False
                if wcheck_key and wp['val'] not in str(flitem[wp['key']]):
                    row_ok = False
            if not row_ok:
                continue

            for sel in aliases:
                if sel['key'] in flitem:
                    row.append(flitem[sel['key']])
                else:
                    # temporary to check, not use case for buts()
                    bnp = '____BTS_NO_PATH_'
                    tempv = get_flat_path(ctx, flitem, sel['key'] + '.*', bnp)
                    if tempv != bnp:
                        row.append(tempv)
                    else:
                        row.append('None')
                        # TODO maybe 'NONE', or just '' or something like:
                        # magic.export_format_none

            data.append(row)
            # todo: count keys, and show all keys in selection: i,a
            if not_shown and showkeys:
                if not showalways:
                    not_shown = False
                ks = list(flitem.keys())
                ks.sort()
                ctx.say(
                    'available dict path keys from first selected dict:', verbosity=0)
                for k in ks:
                    ctx.say('keypath: ' + k, verbosity=0)
                    if showvalues:
                        ctx.say('value: ' + str(flitem[k]) + '\n', verbosity=0)

    except Exception as excpt:
        ctx.say_red('Cannot export data', stuff=excpt)
        raise click.Abort()

    if not outputfile:
        outputfile = path + 'export/export_' + \
            stepresult + '_' + stage + '.' + formattype

    # todo: order key must be present in selection
    # add to selection before
    # and remove from result before output to format.
    if order:
        olast2 = order[-2:]
        ctx.gbc.say('order:' + order + ' last2:' + olast2, verbosity=100)
        if olast2 not in [':+', ':-']:
            data = data.sort(order, False)
        else:
            if olast2 == ':+':
                data = data.sort(order[:-2], False)
            if olast2 == ':-':
                data = data.sort(order[:-2], True)

    # Write `spreadsheet` to disk
    formatted = None
    if formattype == 'yaml':
        formatted = data.yaml
    if formattype == 'json':
        formatted = data.json
    if formattype == 'csv':
        formatted = data.csv

    # TODO:
    # if formattype == 'ldif':
    #    formatted = data.ldif

    if formattype == 'tab':
        # standard, output, whatever tablib makes of it, ascii table
        print(data)

    if formatted:
        enc_formatted = formatted.encode('utf-8')
        of_path = opath.Path(outputfile)
        of_dir = of_path.dirname()
        if not of_dir.exists():
            of_dir.makedirs_p()

        with open(outputfile, 'wb') as f:
            f.write(enc_formatted)
            ctx.say_green('exported: ' + outputfile)"
3240,"def save(self, *args, **kwargs):
        """"""
        **uid**: :code:`{jurisdiction.uid}_body:{slug}`
        """"""
        stripped_name = ' '.join(
            w for w in self.organization.name.split()
            if w not in STOPWORDS
        )

        if not self.slug:
            self.slug = uuslug(
                stripped_name,
                instance=self,
                max_length=100,
                separator='-',
                start_no=2
            )
        self.uid = '{}_body:{}'.format(
            self.jurisdiction.uid, slugify(stripped_name))

        super(Body, self).save(*args, **kwargs)"
3241,"def _set_elangles(self):
        """"""Sets the values of instance variable elangles.
        
        Method creates a dictionary containing the elangles of the pvol file.
        Elangles are ordered in acending order using uppercase letters as keys
        
        Examples
        --------
        >>> pvol = OdimPVOL('pvol.h5')
        >>> print(pvol.elangles)
        {'A': 0.5, 'C': 1.5, 'B': 0.69999999999999996, 'E': 5.0, 'D': 3.0}
        """"""
        elang_list = list(self.attr_gen('elangle'))
        try:
            elevation_angles = sorted(zip(*elang_list)[1])
            n_elangles = len(elevation_angles)
            self.elangles = dict(zip(list(string.ascii_uppercase[:n_elangles]), elevation_angles))
        except IndexError:
            self.elangles = {}"
3242,"def select_dataset(self, elangle, quantity):
        """"""
        Selects the matching dataset and returns its path.
        
        Parameters
        ----------
        elangle : str
            Upper case ascii letter defining the elevation angle
        quantity : str
            Name of the quantity e.g. DBZH, VRAD, RHOHV...
            
        Returns
        -------
        dataset : str
            Path of the matching dataset or None if no dataset is found.
            
        Examples
        --------
        Get the hdf5 path of the DBZH dataset at lowest elevation angle
        
        >>> pvol = odimPVOL('pvol.h5')
        >>> dataset = pvol.select_dataset('A', 'DBZH')
        >>> print(dataset)
        '/dataset1/data1/data'

        """"""
        elangle_path = None
        try:
            search_results = self.search('elangle', self.elangles[elangle])
        except KeyError:
            return None

        if search_results == []:
            print('Elevation angle {} is not found from file'.format(elangle))
            print('File contains elevation angles:{}'.format(self.elangles))
        else:
            elangle_path = search_results[0]
                    
        if elangle_path is not None:
            dataset_root = re.search( '^/dataset[0-9]+/', elangle_path).group(0) 
            quantity_path = None
            search_results = self.search('quantity', quantity)

            for path in search_results:
                if dataset_root in path:
                    quantity_path = path
                    break
                    
            if quantity_path is not None:
                dataset_path = re.search('^/dataset[0-9]+/data[0-9]/', quantity_path).group(0)            
                dataset_path = os.path.join(dataset_path, 'data')
                if isinstance(self[dataset_path], h5py.Dataset):
                    self.dataset = self[dataset_path].ref
                    return dataset_path"
3243,"def sector(self, start_ray, end_ray, start_distance=None, end_distance=None, units='b'):
        """"""Slices a sector from the selected dataset.
        
        Slice contains the start and end rays. If start and end rays are equal 
        one ray is returned. If the start_ray is greater than the end_ray
        slicing continues over the 359-0 border.  
        
        Parameters
        ----------
        start_ray : int
            Starting ray of of the slice first ray is 0
        end_ray : int
            End ray of the slice, last ray is 359
            
        Keywords
        --------
        start_distance : int
            Starting distance of the slice, if not defined sector starts
            form zero
        end_distance : int
            Ending distance of the slice, if not defined sector continues to
            the end last ray of the dataset
        units : str            
            Units used in distance slicing. Option 'b' means that bin number
            is used as index. Option 'm' means that meters are used and the
            slicing index is calculated using bin width.
             
            
        Returns
        -------
        sector : ndarray
            Numpy array containing the sector values
            
        Examples
        --------
        Get one ray from the selected dataset
        
        >>> pvol = odimPVOL('pvol.h5')
        >>> pvol.select_dataset('A', 'DBZH')
        >>> ray = pvol.sector(10, 10)

        Get sector from selected dataset, rays from 100 to 200
        at distances from 5 km to 10 km.
        
        >>> pvol = odimPVOL('pvol.h5')
        >>> pvol.select_dataset('A', 'DBZH')
        >>> sector = pvol.sector(100, 200, 5000, 10000)                
        """"""
        if self.dataset is None:
            raise ValueError('Dataset is not selected')

        # Validate parameter values        
        ray_max, distance_max = self.dataset.shape
        if start_ray > ray_max:
            raise ValueError('Value of start_ray is bigger than the number of rays')
        if start_ray < 0:
            raise ValueError('start_ray must be non negative')
            

            
        if start_distance is None:
            start_distance_index = 0
        else:
            if units == 'b':
                start_distance_index = start_distance
            elif units == 'm': 
                try:
                    rscale = next(self.attr_gen('rscale')).value
                except:
                    raise MissingMetadataError            
                start_distance_index = int(start_distance / rscale)
        if end_distance is None:
            end_distance_index = self.dataset.shape[1]
        else:
            if units == 'b':
                end_distance_index = end_distance           
            elif units == 'm':             
                end_distance_index = int(end_distance / rscale) 

        if end_ray is None:
            sector = self.dataset[start_ray, start_distance_index:end_distance_index]
        else:
            if start_ray <= end_ray:
                sector = self.dataset[start_ray:end_ray+1, start_distance_index:end_distance_index]
            else:
                sector1 = self.dataset[start_ray:, start_distance_index:end_distance_index]
                sector2 = self.dataset[:end_ray+1, start_distance_index:end_distance_index]
                sector = np.concatenate((sector1, sector2), axis=0)
        return sector"
3244,"def select_dataset(self, quantity):
        """"""
        Selects the matching dataset and returns its path.
        
        After the dataset has been selected, its values can be accessed trough
        dataset member variable.
        
        Parameters
        ----------
        quantity : str
            name of the quantity
            
        Examples
        --------
        Select DBZH composite        
        
        >>> comp = OdimCOMP('comp.h5')
        >>> dataset_path = comp.select_dataset('DBZH')
        >>> print(dataset_path)
        >>> '/dataset1/data1/data'
        >>> print(comp.dataset)
        [[255 255 255 ..., 255 255 255]
        [255 255 255 ..., 255 255 255]
        [255 255 255 ..., 255 255 255]
        ..., 
        [255 255 255 ..., 255 255 255]
        [255 255 255 ..., 255 255 255]
        [255 255 255 ..., 255 255 255]]
        """"""
        
        # Files with a following dataset structure.
        # Location of 'quantity' attribute: /dataset1/data1/what
        # Dataset path structure: /dataset1/data1/data
        search_results = self.search('quantity', quantity)
        try:
            quantity_path = search_results[0]
        except IndexError:
            print('Attribute quantity=\'{}\' was not found from file'.format(quantity))
            return None
        full_dataset_path = quantity_path.replace('/what', '/data')

        try:
            if isinstance(self[full_dataset_path], h5py.Dataset):
                self.dataset = self[full_dataset_path].ref
                return full_dataset_path
            else:
                self.dataset = None
                return None
        except KeyError:
            # Files with following dataset structure
            # Location of 'quantity' attribute: /dataset1/what
            # Dataset path structure: /dataset1/data1/data 
            dataset_root_path = re.search( '^/dataset[0-9]+/', quantity_path).group(0)
            dataset_paths = self.datasets()
            for ds_path in dataset_paths:
                try:
                    full_dataset_path = re.search( '^{}data[0-9]+/data'.format(dataset_root_path), ds_path).group(0)
                    break
                except:
                    pass
            if isinstance(self[full_dataset_path], h5py.Dataset):
                self.dataset = self[full_dataset_path].ref
                return full_dataset_path        
            else:
                self.dataset = None
                return None"
3245,"def request(self, url, method, body="""", headers={}, retry=True):
        """"""Execute an HTTP request and return a dict containing the response
        and the response status code.

        Keyword arguments:
        url -- The path to execute the result against, not including the API
               version or project ID, with no leading /. Required.
        method -- The HTTP method to use. Required.
        body -- A string or file object to send as the body of the request.
                Defaults to an empty string.
        headers -- HTTP Headers to send with the request. Can overwrite the
                   defaults. Defaults to {}.
        retry -- Whether exponential backoff should be employed. Defaults
                 to True.
        """"""
        if headers:
            headers = dict(list(headers.items()) + list(self.headers.items()))
        else:
            headers = self.headers

        if not sys.version_info >= (3,) and headers:
            headers = dict((k.encode('ascii') if isinstance(k, unicode) else k,
                            v.encode('ascii') if isinstance(v, unicode) else v)
                           for k, v in headers.items())

        url = self.base_url + url
        if not sys.version_info >= (3,):
            if isinstance(url, unicode):
                url = url.encode('ascii')

        r = self._doRequest(url, method, body, headers)

        retry_http_codes = [503, 504]
        if r.status_code in retry_http_codes and retry:
            tries = 5
            delay = .5
            backoff = 2
            while r.status_code in retry_http_codes and tries > 0:
                tries -= 1
                time.sleep(delay)
                delay *= backoff
                r = self._doRequest(url, method, body, headers)

        r.raise_for_status()

        result = {}
        contentType = r.headers[""Content-Type""]
        if contentType is None:
            contentType = ""text/plain""
        else:
            contentType = contentType.split("";"")[0]
        if contentType.lower() == ""application/json"":
            try:
                result[""body""] = json.loads(r.text)
            except:
                result[""body""] = r.text
        else:
            result[""body""] = r.text
        result[""status""] = r.status_code
        result[""resp""] = r
        result[""content-type""] = contentType
        return result"
3246,"def get(self, url, headers={}, retry=True):
        """"""Execute an HTTP GET request and return a dict containing the
        response and the response status code.

        Keyword arguments:
        url -- The path to execute the result against, not including the API
               version or project ID, with no leading /. Required.
        headers -- HTTP Headers to send with the request. Can overwrite the
                   defaults. Defaults to {}.
        retry -- Whether exponential backoff should be employed. Defaults
                 to True.
        """"""
        return self.request(url=url, method=""GET"", headers=headers,
                retry=retry)"
3247,"def post(self, url, body="""", headers={}, retry=True):
        """"""Execute an HTTP POST request and return a dict containing the
        response and the response status code.

        Keyword arguments:
        url -- The path to execute the result against, not including the API
               version or project ID, with no leading /. Required.
        body -- A string or file object to send as the body of the request.
                Defaults to an empty string.
        headers -- HTTP Headers to send with the request. Can overwrite the
                   defaults. Defaults to {}.
        retry -- Whether exponential backoff should be employed. Defaults
                 to True.
        """"""
        headers[""Content-Length""] = str(len(body))
        return self.request(url=url, method=""POST"", body=body, headers=headers,
                retry=retry)"
3248,"def patch(self, url, body="""", headers={}, retry=True):
        """"""Execute an HTTP PATCH request and return a dict containing the
        response and the response status code.

        Keyword arguments:
        url -- The path to execute the result against, not including the API
               version or project ID, with no leading /. Required.
        body -- A string or file object to send as the body of the request.
                Defaults to an empty string.
        headers -- HTTP Headers to send with the request. Can overwrite the
                defaults. Defaults to {}.
        retry -- Whether exponential backoff should be employed. Defaults
                 to True.
        """"""
        return self.request(url=url, method=""PATCH"", body=body, headers=headers,
                retry=retry)"
3249,"def clone(cls, srcpath, destpath):
        """"""Copy a main repository to a new location.""""""
        try:
            os.makedirs(destpath)
        except OSError as e:
            if not e.errno == errno.EEXIST:
                raise
        cmd = [SVNADMIN, 'dump', '--quiet', '.']
        dump = subprocess.Popen(
               cmd, cwd=srcpath, stdout=subprocess.PIPE,
               stderr=subprocess.PIPE,
        )
        repo = cls.create(destpath)
        repo.load(dump.stdout)
        stderr = dump.stderr.read()
        dump.stdout.close()
        dump.stderr.close()
        dump.wait()
        if dump.returncode != 0:
            raise subprocess.CalledProcessError(dump.returncode, cmd, stderr)
        return repo"
3250,"def create(cls, path):
        """"""Create a new repository""""""
        try:
            os.makedirs(path)
        except OSError as e:
            if not e.errno == errno.EEXIST:
                raise
        cmd = [SVNADMIN, 'create', path]
        subprocess.check_call(cmd)
        return cls(path)"
3251,"def proplist(self, rev, path=None):
        """"""List Subversion properties of the path""""""
        rev, prefix = self._maprev(rev)
        if path is None:
            return self._proplist(str(rev), None)
        else:
            path = type(self).cleanPath(_join(prefix, path))
            return self._proplist(str(rev), path)"
3252,"def propget(self, prop, rev, path=None):
        """"""Get Subversion property value of the path""""""
        rev, prefix = self._maprev(rev)
        if path is None:
            return self._propget(prop, str(rev), None)
        else:
            path = type(self).cleanPath(_join(prefix, path))
            return self._propget(prop, str(rev), path)"
3253,"def dump(
        self, stream, progress=None, lower=None, upper=None,
        incremental=False, deltas=False
    ):
        """"""Dump the repository to a dumpfile stream.

        :param stream: A file stream to which the dumpfile is written
        :param progress: A file stream to which progress is written
        :param lower: Must be a numeric version number
        :param upper: Must be a numeric version number

        See ``svnadmin help dump`` for details on the other arguments.

        """"""
        cmd = [SVNADMIN, 'dump', '.']
        if progress is None:
            cmd.append('-q')
        if lower is not None:
            cmd.append('-r')
            if upper is None:
                cmd.append(str(int(lower)))
            else:
                cmd.append('%d:%d' % (int(lower), int(upper)))
        if incremental:
            cmd.append('--incremental')
        if deltas:
            cmd.append('--deltas')
        p = subprocess.Popen(cmd, cwd=self.path, stdout=stream, stderr=progress)
        p.wait()
        if p.returncode != 0:
            raise subprocess.CalledProcessError(p.returncode, cmd)"
3254,"def load(
        self, stream, progress=None, ignore_uuid=False, force_uuid=False,
        use_pre_commit_hook=False, use_post_commit_hook=False, parent_dir=None
    ):
        """"""Load a dumpfile stream into the repository.

        :param stream: A file stream from which the dumpfile is read
        :param progress: A file stream to which progress is written

        See ``svnadmin help load`` for details on the other arguments.

        """"""
        cmd = [SVNADMIN, 'load', '.']
        if progress is None:
            cmd.append('-q')
        if ignore_uuid:
            cmd.append('--ignore-uuid')
        if force_uuid:
            cmd.append('--force-uuid')
        if use_pre_commit_hook:
            cmd.append('--use-pre-commit-hook')
        if use_post_commit_hook:
            cmd.append('--use-post-commit-hook')
        if parent_dir:
            cmd.extend(['--parent-dir', parent_dir])
        p = subprocess.Popen(
            cmd, cwd=self.path, stdin=stream, stdout=progress,
            stderr=subprocess.PIPE
        )
        stderr = p.stderr.read()
        p.stderr.close()
        p.wait()
        if p.returncode != 0:
            raise subprocess.CalledProcessError(p.returncode, cmd, stderr)"
3255,"def temp_file(
        content=None,
        suffix='',
        prefix='tmp',
        parent_dir=None):
    """"""
    Create a temporary file and optionally populate it with content. The file
    is deleted when the context exits.

    The temporary file is created when entering the context manager and
    deleted when exiting it.
    >>> import temporary
    >>> with temporary.temp_file() as temp_file:
    ...     assert temp_file.exists()
    >>> assert not temp_file.exists()

    The user may also supply some content for the file to be populated with:
    >>> with temporary.temp_file('hello!') as temp_file:
    ...     with temp_file.open() as f:
    ...         assert f.read() == 'hello!'

    The temporary file can be placed in a custom directory:
    >>> with temporary.temp_dir() as temp_dir:
    ...     with temporary.temp_file(parent_dir=temp_dir) as temp_file:
    ...         assert temp_file.parent == temp_dir

    If, for some reason, the user wants to delete the temporary file before
    exiting the context, that's okay too:
    >>> with temporary.temp_file() as temp_file:
    ...     temp_file.unlink()
    """"""
    binary = isinstance(content, (bytes, bytearray))
    parent_dir = parent_dir if parent_dir is None else str(parent_dir)
    fd, abs_path = tempfile.mkstemp(suffix, prefix, parent_dir, text=False)
    path = pathlib.Path(abs_path)
    try:
        try:
            if content:
                os.write(fd, content if binary else content.encode())
        finally:
            os.close(fd)
        yield path.resolve()
    finally:
        with temporary.util.allow_missing_file():
            path.unlink()"
3256,"def _emit_no_set_found(environment_name, product_name):
    """"""
    writes to std out and logs if no connection string is found for deployment
    :param environment_name:
    :param product_name:
    :return:
    """"""
    sys.stdout.write(colorama.Fore.YELLOW + 'No connections found in global config file '
                                            'in environment: {0} for product: {1}'
                     .format(environment_name, product_name) +
                     colorama.Fore.RESET)
    sys.stdout.write('\n')
    logger.warning('No connections found in environment: {0} for product: {1}'
                   .format(environment_name, product_name))"
3257,"def load_content(self):
        """"""
        Load the book content
        """"""

        # get the toc file from the root file
        rel_path = self.root_file_url.replace(os.path.basename(self.root_file_url), '')
        self.toc_file_url = rel_path + self.root_file.find(id=""ncx"")['href']
        self.toc_file_soup = bs(self.book_file.read(self.toc_file_url), 'xml')

        # get the book content from the toc file

        for n, c in cross(self.toc_file_soup.find_all('navLabel'), self.toc_file_soup.find_all('content')):
            content_soup = bs(self.book_file.read(rel_path + c.get('src')))
            self.content.append({'part_name': c.text,
                                 'source_url': c.get('src'),
                                 'content_source': content_soup,
                                 'content_source_body': content_soup.body,
                                 'content_source_text': content_soup.body.text})"
3258,"def UninstallTrump(RemoveDataTables=True, RemoveOverrides=True, RemoveFailsafes=True):
    """"""
    This script removes all tables associated with Trump.
    
    It's written for PostgreSQL, but should be very easy to adapt to other
    databases.
    """"""
    
    ts = ['_symbols', '_symbol_validity', '_symbol_tags', '_symbol_aliases', 
          '_feeds', '_feed_munging', '_feed_munging_args', '_feed_sourcing', 
          '_feed_validity', '_feed_meta', '_feed_tags', '_feed_handle', 
          '_index_kwargs', '_indicies', '_symbol_handle', '_symboldatadef']
    
    if RemoveOverrides:
        ts.append('_overrides')
        
    if RemoveFailsafes:
        ts.append('_failsafes')

    engine = create_engine(ENGINE_STR)
       
    if RemoveDataTables:
        results = engine.execute(""SELECT name FROM _symbols;"")
        datatables = [row['name'] for row in results]
        ts = ts + datatables
    
    drops = """".join(['DROP TABLE IF EXISTS ""{}"" CASCADE;'.format(t) for t in ts])
    
    engine.execute(drops)"
3259,"def digestInSilico(proteinSequence, cleavageRule='[KR]', missedCleavage=0,
                   removeNtermM=True, minLength=5, maxLength=55):
    """"""Returns a list of peptide sequences and cleavage information derived
    from an in silico digestion of a polypeptide.

    :param proteinSequence: amino acid sequence of the poly peptide to be
        digested
    :param cleavageRule: cleavage rule expressed in a regular expression, see
        :attr:`maspy.constants.expasy_rules`
    :param missedCleavage: number of allowed missed cleavage sites
    :param removeNtermM: booo, True to consider also peptides with the
        N-terminal methionine of the protein removed
    :param minLength: int, only yield peptides with length >= minLength
    :param maxLength: int, only yield peptides with length <= maxLength

    :returns: a list of resulting peptide enries. Protein positions start with
        ``1`` and end with ``len(proteinSequence``. ::

            [(peptide amino acid sequence,
              {'startPos': int, 'endPos': int, 'missedCleavage': int}
              ), ...
             ]

    .. note::
        This is a regex example for specifying N-terminal cleavage at lysine
        sites ``\\w(?=[K])``
    """"""
    passFilter = lambda startPos, endPos: (endPos - startPos >= minLength and
                                           endPos - startPos <= maxLength
                                           )
    _regexCleave = re.finditer(cleavageRule, proteinSequence)

    cleavagePosList = set(itertools.chain(map(lambda x: x.end(), _regexCleave)))
    cleavagePosList.add(len(proteinSequence))
    cleavagePosList = sorted(list(cleavagePosList))
    #Add end of protein as cleavage site if protein doesn't end with specififed
    #cleavage positions
    numCleavageSites = len(cleavagePosList)

    if missedCleavage >= numCleavageSites:
        missedCleavage = numCleavageSites -1

    digestionresults = list()
    #Generate protein n-terminal peptides after methionine removal
    if removeNtermM and proteinSequence[0] == 'M':
        for cleavagePos in range(0, missedCleavage+1):
            startPos = 1
            endPos = cleavagePosList[cleavagePos]
            if passFilter(startPos, endPos):
                sequence = proteinSequence[startPos:endPos]
                info = dict()
                info['startPos'] = startPos+1
                info['endPos'] = endPos
                info['missedCleavage'] = cleavagePos
                digestionresults.append((sequence, info))

    #Generate protein n-terminal peptides
    if cleavagePosList[0] != 0:
        for cleavagePos in range(0, missedCleavage+1):
            startPos = 0
            endPos = cleavagePosList[cleavagePos]
            if passFilter(startPos, endPos):
                sequence = proteinSequence[startPos:endPos]
                info = dict()
                info['startPos'] = startPos+1
                info['endPos'] = endPos
                info['missedCleavage'] = cleavagePos
                digestionresults.append((sequence, info))

    #Generate all remaining peptides, including the c-terminal peptides
    lastCleavagePos = 0
    while lastCleavagePos < numCleavageSites:
        for missedCleavage in range(0, missedCleavage+1):
            nextCleavagePos = lastCleavagePos + missedCleavage + 1
            if nextCleavagePos < numCleavageSites:
                startPos = cleavagePosList[lastCleavagePos]
                endPos = cleavagePosList[nextCleavagePos]
                if passFilter(startPos, endPos):
                    sequence = proteinSequence[startPos:endPos]
                    info = dict()
                    info['startPos'] = startPos+1
                    info['endPos'] = endPos
                    info['missedCleavage'] = missedCleavage
                    digestionresults.append((sequence, info))
        lastCleavagePos += 1

    return digestionresults"
3260,"def calcPeptideMass(peptide, **kwargs):
    """"""Calculate the mass of a peptide.

    :param aaMass: A dictionary with the monoisotopic masses of amino acid
        residues, by default :attr:`maspy.constants.aaMass`
    :param aaModMass: A dictionary with the monoisotopic mass changes of
        modications, by default :attr:`maspy.constants.aaModMass`
    :param elementMass: A dictionary with the masses of chemical elements, by
        default ``pyteomics.mass.nist_mass``
    :param peptide: peptide sequence, modifications have to be written in the
        format ""[modificationId]"" and ""modificationId"" has to be present in
        :attr:`maspy.constants.aaModMass`

    #TODO: change to a more efficient way of calculating the modified mass, by
    first extracting all present modifications and then looking up their masses.
    """"""
    aaMass = kwargs.get('aaMass', maspy.constants.aaMass)
    aaModMass = kwargs.get('aaModMass', maspy.constants.aaModMass)
    elementMass = kwargs.get('elementMass', pyteomics.mass.nist_mass)

    addModMass = float()
    unmodPeptide = peptide
    for modId, modMass in viewitems(aaModMass):
        modSymbol = '[' + modId + ']'
        numMod = peptide.count(modSymbol)
        if numMod > 0:
            unmodPeptide = unmodPeptide.replace(modSymbol, '')
            addModMass += modMass * numMod

    if unmodPeptide.find('[') != -1:
        print(unmodPeptide)
        raise Exception('The peptide contains modification, ' +
                        'not present in maspy.constants.aaModMass'
                        )

    unmodPeptideMass = sum(aaMass[i] for i in unmodPeptide)
    unmodPeptideMass += elementMass['H'][0][0]*2 + elementMass['O'][0][0]
    modPeptideMass = unmodPeptideMass + addModMass
    return modPeptideMass"
3261,"def removeModifications(peptide):
    """"""Removes all modifications from a peptide string and return the plain
    amino acid sequence.

    :param peptide: peptide sequence, modifications have to be written in the
        format ""[modificationName]""
    :param peptide: str

    :returns: amino acid sequence of ``peptide`` without any modifications
    """"""
    while peptide.find('[') != -1:
        peptide = peptide.split('[', 1)[0] + peptide.split(']', 1)[1]
    return peptide"
3262,"def returnModPositions(peptide, indexStart=1, removeModString='UNIMOD:'):
    """"""Determines the amino acid positions of all present modifications.

    :param peptide: peptide sequence, modifications have to be written in the
        format ""[modificationName]""
    :param indexStart: returned amino acids positions of the peptide start with
        this number (first amino acid position = indexStart)
    :param removeModString: string to remove from the returned modification name

    :return: {modificationName:[position1, position2, ...], ...}

    #TODO: adapt removeModString to the new unimod ids in
    #maspy.constants.aaModComp (""UNIMOD:X"" -> ""u:X"") -> also change unit tests.
    """"""
    unidmodPositionDict = dict()
    while peptide.find('[') != -1:
        currModification = peptide.split('[')[1].split(']')[0]
        currPosition = peptide.find('[') - 1
        if currPosition == -1: # move n-terminal modifications to first position
            currPosition = 0
        currPosition += indexStart

        peptide = peptide.replace('['+currModification+']', '', 1)

        if removeModString:
            currModification = currModification.replace(removeModString, '')
        unidmodPositionDict.setdefault(currModification,list())
        unidmodPositionDict[currModification].append(currPosition)
    return unidmodPositionDict"
3263,"def calcMhFromMz(mz, charge):
    """"""Calculate the MH+ value from mz and charge.

    :param mz: float, mass to charge ratio (Dalton / charge)
    :param charge: int, charge state

    :returns: mass to charge ratio of the mono protonated ion (charge = 1)
    """"""
    mh = (mz * charge) - (maspy.constants.atomicMassProton * (charge-1) )
    return mh"
3264,"def calcMzFromMh(mh, charge):
    """"""Calculate the mz value from MH+ and charge.

    :param mh: float, mass to charge ratio (Dalton / charge) of the mono
        protonated ion
    :param charge: int, charge state

    :returns: mass to charge ratio of the specified charge state
    """"""
    mz = (mh + (maspy.constants.atomicMassProton * (charge-1))) / charge
    return mz"
3265,"def calcMzFromMass(mass, charge):
    """"""Calculate the mz value of a peptide from its mass and charge.

    :param mass: float, exact non protonated mass
    :param charge: int, charge state

    :returns: mass to charge ratio of the specified charge state
    """"""
    mz = (mass + (maspy.constants.atomicMassProton * charge)) / charge
    return mz"
3266,"def calcMassFromMz(mz, charge):
    """"""Calculate the mass of a peptide from its mz and charge.

    :param mz: float, mass to charge ratio (Dalton / charge)
    :param charge: int, charge state

    :returns: non protonated mass (charge = 0)
    """"""
    mass = (mz - maspy.constants.atomicMassProton) * charge
    return mass"
3267,"def execute(self, processProtocol, command, env={},
                path=None, uid=None, gid=None, usePTY=0, childFDs=None):
        """"""Execute a process on the remote machine using SSH

        @param processProtocol: the ProcessProtocol instance to connect
        @param executable: the executable program to run
        @param args: the arguments to pass to the process
        @param env: environment variables to request the remote ssh server to set
        @param path: the remote path to start the remote process on
        @param uid: user id or username to connect to the ssh server with
        @param gid: this is not used for remote ssh processes
        @param usePTY: wither to request a pty for the process
        @param childFDs: file descriptors to use for stdin, stdout and stderr
        """"""

        sshCommand = (command if isinstance(command, SSHCommand)
                      else SSHCommand(command, self.precursor, path))
        commandLine = sshCommand.getCommandLine()

        # Get connection to ssh server
        connectionDeferred = self.getConnection(uid)
        # spawn the remote process
        connectionDeferred.addCallback(connectProcess, processProtocol,
                                       commandLine, env, usePTY, childFDs)
        return connectionDeferred"
3268,"def _getUserAuthObject(self, user, connection):
        """"""Get a SSHUserAuthClient object to use for authentication

        @param user: The username to authenticate for
        @param connection: The connection service to start after authentication
        """"""
        credentials = self._getCredentials(user)
        userAuthObject = AutomaticUserAuthClient(user, connection, **credentials)
        return userAuthObject"
3269,"def _verifyHostKey(self, hostKey, fingerprint):
        """"""Called when ssh transport requests us to verify a given host key.
        Return a deferred that callback if we accept the key or errback if we
        decide to reject it.
        """"""
        if fingerprint in self.knownHosts:
            return defer.succeed(True)
        return defer.fail(UnknownHostKey(hostKey, fingerprint))"
3270,"def yield_once(iterator):
    """"""
    Decorator to make an iterator returned by a method yield each result only
    once.

    >>> @yield_once
    ... def generate_list(foo):
    ...     return foo
    >>> list(generate_list([1, 2, 1]))
    [1, 2]

    :param iterator: Any method that returns an iterator
    :return:         An method returning an iterator
                     that yields every result only once at most.
    """"""
    @wraps(iterator)
    def yield_once_generator(*args, **kwargs):
        yielded = set()
        for item in iterator(*args, **kwargs):
            if item not in yielded:
                yielded.add(item)
                yield item

    return yield_once_generator"
3271,"def _to_list(var):
    """"""
    Make variable to list.

    >>> _to_list(None)
    []
    >>> _to_list('whee')
    ['whee']
    >>> _to_list([None])
    [None]
    >>> _to_list((1, 2, 3))
    [1, 2, 3]

    :param var: variable of any type
    :return:    list
    """"""
    if isinstance(var, list):
        return var
    elif var is None:
        return []
    elif isinstance(var, str) or isinstance(var, dict):
        # We dont want to make a list out of those via the default constructor
        return [var]
    else:
        try:
            return list(var)
        except TypeError:
            return [var]"
3272,"def arguments_to_lists(function):
    """"""
    Decorator for a function that converts all arguments to lists.

    :param function: target function
    :return:         target function with only lists as parameters
    """"""
    def l_function(*args, **kwargs):
        l_args = [_to_list(arg) for arg in args]
        l_kwargs = {}

        for key, value in kwargs.items():
            l_kwargs[key] = _to_list(value)
        return function(*l_args, **l_kwargs)

    return l_function"
3273,"def get_public_members(obj):
    """"""
    Retrieves a list of member-like objects (members or properties) that are
    publically exposed.

    :param obj: The object to probe.
    :return:    A list of strings.
    """"""
    return {attr: getattr(obj, attr) for attr in dir(obj)
            if not attr.startswith(""_"")
            and not hasattr(getattr(obj, attr), '__call__')}"
3274,"def generate_repr(*members):
    """"""
    Decorator that binds an auto-generated ``__repr__()`` function to a class.

    The generated ``__repr__()`` function prints in following format:
    <ClassName object(field1=1, field2='A string', field3=[1, 2, 3]) at 0xAAAA>

    Note that this decorator modifies the given class in place!

    :param members:         An iterable of member names to include into the
                            representation-string. Providing no members yields
                            to inclusion of all member variables and properties
                            in alphabetical order (except if they start with an
                            underscore).

                            To control the representation of each member, you
                            can also pass a tuple where the first element
                            contains the member to print and the second one the
                            representation function (which defaults to the
                            built-in ``repr()``). Using None as representation
                            function is the same as using ``repr()``.

                            Supported members are fields/variables, properties
                            and getter-like functions (functions that accept no
                            arguments).
    :raises ValueError:     Raised when the passed
                            (member, repr-function)-tuples have not a length of
                            2.
    :raises AttributeError: Raised when a given member/attribute was not found
                            in class.
    :raises TypeError:      Raised when a provided member is a bound method
                            that is not a getter-like function (means it must
                            accept no parameters).
    :return:                The class armed with an auto-generated __repr__
                            function.
    """"""
    def decorator(cls):
        cls.__repr__ = __repr__
        return cls

    if members:
        # Prepare members list.
        members_to_print = list(members)
        for i, member in enumerate(members_to_print):
            if isinstance(member, tuple):
                # Check tuple dimensions.
                length = len(member)
                if length == 2:
                    members_to_print[i] = (member[0],
                                           member[1] if member[1] else repr)
                else:
                    raise ValueError(""Passed tuple "" + repr(member) +
                                     "" needs to be 2-dimensional, but has "" +
                                     str(length) + "" dimensions."")
            else:
                members_to_print[i] = (member, repr)

        def __repr__(self):
            return _construct_repr_string(self, members_to_print)
    else:
        def __repr__(self):
            # Need to fetch member variables every time since they are unknown
            # until class instantation.
            members_to_print = get_public_members(self)

            member_repr_list = ((member, repr) for member in
                                sorted(members_to_print, key=str.lower))

            return _construct_repr_string(self, member_repr_list)

    return decorator"
3275,"def generate_eq(*members):
    """"""
    Decorator that generates equality and inequality operators for the
    decorated class. The given members as well as the type of self and other
    will be taken into account.

    Note that this decorator modifies the given class in place!

    :param members: A list of members to compare for equality.
    """"""
    def decorator(cls):
        def eq(self, other):
            if not isinstance(other, cls):
                return False

            return all(getattr(self, member) == getattr(other, member)
                       for member in members)

        def ne(self, other):
            return not eq(self, other)

        cls.__eq__ = eq
        cls.__ne__ = ne
        return cls

    return decorator"
3276,"def generate_ordering(*members):
    """"""
    Decorator that generates ordering operators for the decorated class based
    on the given member names. All ordering except equality functions will
    raise a TypeError when a comparison with an unrelated class is attempted.
    (Comparisons with child classes will thus work fine with the capabilities
    of the base class as python will choose the base classes comparison
    operator in that case.)

    Note that this decorator modifies the given class in place!

    :param members: A list of members to compare, ordered from high priority to
                    low. I.e. if the first member is equal the second will be
                    taken for comparison and so on. If a member is None it is
                    considered smaller than any other value except None.
    """"""
    def decorator(cls):
        def lt(self, other):
            if not isinstance(other, cls):
                raise TypeError(""Comparison with unrelated classes is ""
                                ""unsupported."")

            for member in members:
                if getattr(self, member) == getattr(other, member):
                    continue

                if (
                        getattr(self, member) is None or
                        getattr(other, member) is None):
                    return getattr(self, member) is None

                return getattr(self, member) < getattr(other, member)

            return False

        cls.__lt__ = lt
        return total_ordering(generate_eq(*members)(cls))

    return decorator"
3277,"def enforce_signature(function):
    """"""
    Enforces the signature of the function by throwing TypeError's if invalid
    arguments are provided. The return value is not checked.

    You can annotate any parameter of your function with the desired type or a
    tuple of allowed types. If you annotate the function with a value, this
    value only will be allowed (useful especially for None). Example:

    >>> @enforce_signature
    ... def test(arg: bool, another: (int, None)):
    ...     pass
    ...
    >>> test(True, 5)
    >>> test(True, None)

    Any string value for any parameter e.g. would then trigger a TypeError.

    :param function: The function to check.
    """"""
    argspec = inspect.getfullargspec(function)
    annotations = argspec.annotations
    argnames = argspec.args

    unnamed_annotations = {}
    for i, arg in enumerate(argnames):
        if arg in annotations:
            unnamed_annotations[i] = (annotations[arg], arg)

    def decorated(*args, **kwargs):
        for i, annotation in unnamed_annotations.items():
            if i < len(args):
                assert_right_type(args[i], annotation[0], annotation[1])

        for argname, argval in kwargs.items():
            if argname in annotations:
                assert_right_type(argval, annotations[argname], argname)

        return function(*args, **kwargs)

    return decorated"
3278,"def as_string(self):
        """"""Get the underlying message object as a string""""""
        if self.headers_only:
            self.msgobj = self._get_content()

        # We could just use msgobj.as_string() but this is more flexible... we might need it.
        from email.generator import Generator
        fp = StringIO()
        g = Generator(fp, maxheaderlen=60)
        g.flatten(self.msgobj)
        text = fp.getvalue()
        return text"
3279,"def iteritems(self):
        """"""Present the email headers""""""
        for n,v in self.msgobj.__dict__[""_headers""]:
            yield n.lower(), v
        return"
3280,"def _set_flag(self, flag):
        """"""Turns the specified flag on""""""
        self.folder._invalidate_cache()
        # TODO::: turn the flag off when it's already on
        def replacer(m):
            return ""%s/%s.%s%s"" % (
                joinpath(self.folder.base, self.folder.folder, ""cur""),
                m.group(""key""),
                m.group(""hostname""),
                "":2,%s"" % (
                    ""%s%s"" % (m.group(""flags""), flag) if m.group(""flags"") \
                        else flag
                    )
                )
        newfilename = self.msgpathre.sub(replacer, self.filename)
        self.filesystem.rename(self.filename, newfilename)
        self.filename = newfilename"
3281,"def _get_message(self, key, since=None):
        """"""Return the MdMessage object for the key.

        The object is either returned from the cache in the store or
        made, cached and then returned.

        If 'since' is passed in the modification time of the file is
        checked and the message is only returned if the mtime is since
        the specified time. 

        If the 'since' check fails, None is returned.

        'since' must be seconds since epoch.
        """"""
        stored = self.store[key]
        if isinstance(stored, dict):
            filename = stored[""path""]
            folder = stored[""folder""]
            if since and since > 0.0:
                st = stat(filename)
                if st.st_mtime < since:
                    return None
            stored = MdMessage(
                key, 
                filename = filename, 
                folder = folder,
                filesystem = folder.filesystem
                )
            self.store[key] = stored
        else:
            if since and since > 0.0:
                st = stat(stored.filename)
                if st.st_mtime < since:
                    return None
                
        return stored"
3282,"def _foldername(self, additionalpath=""""):
        """"""Dot decorate a folder name.""""""
        if not self._foldername_cache.get(additionalpath):
            fn = joinpath(self.base, self.folder, additionalpath) \
                if not self.is_subfolder \
                else joinpath(self.base, "".%s"" % self.folder, additionalpath)
            self._foldername_cache[additionalpath] = fn
        return self._foldername_cache[additionalpath]"
3283,"def folders(self):
        """"""Return a map of the subfolder objects for this folder.

        This is a snapshot of the folder list at the time the call was made. 
        It does not update over time.

        The map contains MdFolder objects:

          maildir.folders()[""Sent""]

        might retrieve the folder .Sent from the maildir.
        """"""
        entrys = self.filesystem.listdir(abspath(self._foldername()))
        regex = re.compile(""\\..*"")
        just_dirs = dict([(d,d) for d in entrys if regex.match(d)])

        folder = self._foldername()
        filesystem = self.filesystem

        class FolderList(object):
            def __iter__(self):
                dirs = list(just_dirs.keys())
                dirs.sort()
                dirs.reverse()
                for dn in dirs:
                    yield MdFolder(
                        dn[1:],
                        base=folder,
                        subfolder=True,
                        filesystem=filesystem
                        )
                return

            def __list__(self):
                return [dn[1:] for dn in just_dirs]

            def __contains__(self, name):
                return just_dirs.__contains__("".%s"" % name)

            def __getitem__(self, name):
                return MdFolder(
                    just_dirs["".%s"" % name][1:],
                    base=folder,
                    subfolder=True,
                    filesystem=filesystem
                    )

        f = FolderList()
        return f"
3284,"def move(self, key, folder):
        """"""Move the specified key to folder.

        folder must be an MdFolder instance. MdFolders can be obtained
        through the 'folders' method call.
        """"""
        # Basically this is a sophisticated __delitem__
        # We need the path so we can make it in the new folder
        path, host, flags = self._exists(key)
        self._invalidate_cache()

        # Now, move the message file to the new folder
        newpath = joinpath(
            folder.base, 
            folder.get_name(), 
            ""cur"",     # we should probably move it to new if it's in new
            basename(path)
            )
        self.filesystem.rename(path, newpath)
        # And update the caches in the new folder
        folder._invalidate_cache()"
3285,"def _muaprocessnew(self):
        """"""Moves all 'new' files into cur, correctly flagging""""""
        foldername = self._foldername(""new"")
        files = self.filesystem.listdir(foldername)
        for filename in files:
            if filename == """":
                continue
            curfilename = self._foldername(joinpath(""new"", filename))
            newfilename = joinpath(
                self._cur,
                ""%s:2,%s"" % (filename, """")
                )
            self.filesystem.rename(curfilename, newfilename)"
3286,"def _exists(self, key):
        """"""Find a key in a particular section

        Searches through all the files and looks for matches with a regex.
        """"""
        filecache, keycache = self._fileslist()
        msg = keycache.get(key, None)
        if msg:
            path = msg.filename
            meta = filecache[path]
            return path, meta[""hostname""], meta.get(""flags"", """")
        raise KeyError(""not found %s"" % key)"
3287,"def show_slices(data3d, contour=None, seeds=None, axis=0, slice_step=None,
                shape=None, show=True,
                flipH=False, flipV=False,
                first_slice_offset=0,
                first_slice_offset_to_see_seed_with_label=None,
                slice_number=None
                ):
    """"""
    Show slices as tiled image

    :param data3d: Input data
    :param contour: Data for contouring
    :param seeds: Seed data
    :param axis: Axis for sliceing
    :param slice_step: Show each ""slice_step""-th slice, can be float
    :param shape: tuple(vertical_tiles_number, horisontal_tiles_number), set shape of output tiled image. slice_step is
    estimated if it is not set explicitly
    :param first_slice_offset: set offset of first slice
    :param first_slice_offset_to_see_seed_with_label: find offset to see slice with seed with defined label
    :param slice_number: int, Number of showed slices. Overwrites shape and slice_step.
    """"""

    if slice_number is not None:
        slice_step = data3d.shape[axis] / slice_number
    # odhad slice_step, neni li zadan
    # slice_step estimation
    # TODO make precise estimation (use np.linspace to indexing?)
    if slice_step is None:
        if shape is None:
            slice_step = 1
        else:
            slice_step = ((data3d.shape[axis] - first_slice_offset ) / float(np.prod(shape)))



    if first_slice_offset_to_see_seed_with_label is not None:
        if seeds is not None:
            inds = np.nonzero(seeds==first_slice_offset_to_see_seed_with_label)
            # print(inds)
            # take first one with defined seed
            # ind = inds[axis][0]
            # take most used index
            ind = np.median(inds[axis])
            first_slice_offset = ind % slice_step


    data3d = _import_data(data3d, axis=axis, slice_step=slice_step, first_slice_offset=first_slice_offset)
    contour = _import_data(contour, axis=axis, slice_step=slice_step, first_slice_offset=first_slice_offset)
    seeds = _import_data(seeds, axis=axis, slice_step=slice_step, first_slice_offset=first_slice_offset)

    number_of_slices = data3d.shape[axis]
    # square image
    #     nn = int(math.ceil(number_of_slices ** 0.5))

    #     sh = [nn, nn]

    # 4:3 image
    meta_shape = shape
    if meta_shape is None:
        na = int(math.ceil(number_of_slices * 16.0 / 9.0) ** 0.5)
        nb = int(math.ceil(float(number_of_slices) / na))
        meta_shape = [nb, na]

    dsh = __get_slice(data3d, 0, axis).shape
    slimsh = [int(dsh[0] * meta_shape[0]), int(dsh[1] * meta_shape[1])]
    slim = np.zeros(slimsh, dtype=data3d.dtype)
    slco = None
    slse = None
    if seeds is not None:
        slse = np.zeros(slimsh, dtype=seeds.dtype)
    if contour is not None:
        slco = np.zeros(slimsh, dtype=contour.dtype)
    #         slse =
    #     f, axarr = plt.subplots(sh[0], sh[1])

    for i in range(0, number_of_slices):
        cont = None
        seeds2d = None
        im2d = __get_slice(data3d, i, axis, flipH=flipH, flipV=flipV)
        if contour is not None:
            cont = __get_slice(contour, i, axis, flipH=flipH, flipV=flipV)
            slco = __put_slice_in_slim(slco, cont, meta_shape, i)
        if seeds is not None:
            seeds2d = __get_slice(seeds, i, axis, flipH=flipH, flipV=flipV)
            slse = __put_slice_in_slim(slse, seeds2d, meta_shape, i)
        #         plt.axis('off')
        #         plt.subplot(sh[0], sh[1], i+1)
        #         plt.subplots_adjust(wspace=0, hspace=0)

        slim = __put_slice_in_slim(slim, im2d, meta_shape, i)
    #         show_slice(im2d, cont, seeds2d)
    show_slice(slim, slco, slse)
    if show:
        plt.show()"
3288,"def __get_slice(data, slice_number, axis=0, flipH=False, flipV=False):
    """"""

    :param data:
    :param slice_number:
    :param axis:
    :param flipV: vertical flip
    :param flipH: horizontal flip
    :return:
    """"""
    if axis == 0:
        data2d =  data[slice_number, :, :]
    elif axis == 1:
        data2d = data[:, slice_number, :]
    elif axis == 2:
        data2d = data[:, :, slice_number]
    else:
        logger.error(""axis number error"")
        print(""axis number error"")
        return None

    if flipV:
        if data2d is not None:
            data2d = data2d[-1:0:-1,:]
    if flipH:
        if data2d is not None:
            data2d = data2d[:, -1:0:-1]
    return data2d"
3289,"def __put_slice_in_slim(slim, dataim, sh, i):
    """"""
    put one small slice as a tile in a big image
    """"""
    a, b = np.unravel_index(int(i), sh)

    st0 = int(dataim.shape[0] * a)
    st1 = int(dataim.shape[1] * b)
    sp0 = int(st0 + dataim.shape[0])
    sp1 = int(st1 + dataim.shape[1])

    slim[
    st0:sp0,
    st1:sp1
    ] = dataim

    return slim"
3290,"def show_slice(data2d, contour2d=None, seeds2d=None):
    """"""

    :param data2d:
    :param contour2d:
    :param seeds2d:
    :return:
    """"""

    import copy as cp
    # Show results

    colormap = cp.copy(plt.cm.get_cmap('brg'))
    colormap._init()
    colormap._lut[:1:, 3] = 0

    plt.imshow(data2d, cmap='gray', interpolation='none')
    if contour2d is not None:
        plt.contour(contour2d, levels=[0.5, 1.5, 2.5])
    if seeds2d is not None:
        # Show results
        colormap = copy.copy(plt.cm.get_cmap('Paired'))
        # colormap = copy.copy(plt.cm.get_cmap('gist_rainbow'))
        colormap._init()

        colormap._lut[0, 3] = 0

        tmp0 = copy.copy(colormap._lut[:,0])
        tmp1 = copy.copy(colormap._lut[:,1])
        tmp2 = copy.copy(colormap._lut[:,2])

        colormap._lut[:, 0] = sigmoid(tmp0, 0.5, 5)
        colormap._lut[:, 1] = sigmoid(tmp1, 0.5, 5)
        colormap._lut[:, 2] = 0# sigmoid(tmp2, 0.5, 5)
        # seed 4
        colormap._lut[140:220:, 1] = 0.7# sigmoid(tmp2, 0.5, 5)
        colormap._lut[140:220:, 0] = 0.2# sigmoid(tmp2, 0.5, 5)
        # seed 2
        colormap._lut[40:120:, 1] = 1.# sigmoid(tmp2, 0.5, 5)
        colormap._lut[40:120:, 0] = 0.1# sigmoid(tmp2, 0.5, 5)


        # seed 2
        colormap._lut[120:150:, 0] = 1.# sigmoid(tmp2, 0.5, 5)
        colormap._lut[120:150:, 1] = 0.1# sigmoid(tmp2, 0.5, 5)

        # my colors

        # colormap._lut[1,:] = [.0,.1,.0,1]
        # colormap._lut[2,:] = [.1,.1,.0,1]
        # colormap._lut[3,:] = [.1,.1,.1,1]
        # colormap._lut[4,:] = [.3,.3,.3,1]

        plt.imshow(seeds2d, cmap=colormap, interpolation='none')"
3291,"def _import_data(data, axis, slice_step, first_slice_offset=0):
    """"""
    import ndarray or SimpleITK data
    """"""
    try:
        import SimpleITK as sitk
        if type(data) is sitk.SimpleITK.Image:
            data = sitk.GetArrayFromImage(data)
    except:
        pass

    data = __select_slices(data, axis, slice_step, first_slice_offset=first_slice_offset)
    return data"
3292,"def generate_data(shp=[16, 20, 24]):
    """""" Generating data """"""

    x = np.ones(shp)
    # inserting box
    x[4:-4, 6:-2, 1:-6] = -1
    x_noisy = x + np.random.normal(0, 0.6, size=x.shape)
    return x_noisy"
3293,"def index_to_coords(index, shape):
    '''convert index to coordinates given the shape'''
    coords = []
    for i in xrange(1, len(shape)):
        divisor = int(np.product(shape[i:]))
        value = index // divisor
        coords.append(value)
        index -= value * divisor
    coords.append(index)
    return tuple(coords)"
3294,"def slices(img, shape=[3, 4]):
    """"""
    create tiled image with multiple slices
    :param img:
    :param shape:
    :return:
    """"""
    sh = np.asarray(shape)
    i_max = np.prod(sh)
    allimg = np.zeros(img.shape[-2:] * sh)

    for i in range(0, i_max):
        # i = 0
        islice = round((img.shape[0] / float(i_max)) * i)
        #         print(islice)
        imgi = img[islice, :, :]
        coords = index_to_coords(i, sh)
        aic = np.asarray(img.shape[-2:]) * coords

        allimg[aic[0]:aic[0] + imgi.shape[-2], aic[1]:aic[1] + imgi.shape[-1]] = imgi

    #     plt.imshow(imgi)
    #     print(imgi.shape)
    #     print(img.shape)
    return allimg"
3295,"def sed2(img, contour=None, shape=[3, 4]):
    """"""
    plot tiled image of multiple slices

    :param img:
    :param contour:
    :param shape:
    :return:
    """"""
    """"""
    :param img:
    :param contour:
    :param shape:
    :return:
    """"""

    plt.imshow(slices(img, shape), cmap='gray')
    if contour is not None:
        plt.contour(slices(contour, shape))"
3296,"def set_window(self, windowC, windowW):
        """"""
        Sets visualization window
        :param windowC: window center
        :param windowW: window width
        :return:
        """"""
        if not (windowW and windowC):
            windowW = np.max(self.img) - np.min(self.img)
            windowC = (np.max(self.img) + np.min(self.img)) / 2.0

        self.imgmax = windowC + (windowW / 2)
        self.imgmin = windowC - (windowW / 2)
        self.windowC = windowC
        self.windowW = windowW"
3297,"def rotate_to_zaxis(self, new_zaxis):
        """"""
        rotate image to selected axis
        :param new_zaxis:
        :return:
        """"""

        img = self._rotate_end(self.img, self.zaxis)
        seeds = self._rotate_end(self.seeds, self.zaxis)
        contour = self._rotate_end(self.contour, self.zaxis)

        # Rotate data in depndecy on zaxispyplot
        self.img = self._rotate_start(img, new_zaxis)
        self.seeds = self._rotate_start(seeds, new_zaxis)
        self.contour = self._rotate_start(contour, new_zaxis)
        self.zaxis = new_zaxis
        # import ipdb
        # ipdb.set_trace()
        # self.actual_slice_slider.valmax = self.img.shape[2] - 1
        self.actual_slice = 0
        self.rotated_back = False

        # update slicer
        self.fig.delaxes(self.ax_actual_slice)
        self.ax_actual_slice.cla()
        del(self.actual_slice_slider)
        self.fig.add_axes(self.ax_actual_slice)
        self.actual_slice_slider = Slider(self.ax_actual_slice, 'Slice', 0,
                                          self.img.shape[2] - 1,
                                          valinit=0)
        self.actual_slice_slider.on_changed(self.sliceslider_update)
        self.update_slice()"
3298,"def __flip(self, sliceimg):
        """"""
        Flip if asked in self.flipV or self.flipH
        :param sliceimg: one image slice
        :return: flipp
        """"""
        if self.flipH:
            sliceimg = sliceimg[:, -1:0:-1]

        if self.flipV:
            sliceimg = sliceimg [-1:0:-1,:]

        return sliceimg"
3299,"def on_scroll(self, event):
        ''' mouse wheel is used for setting slider value'''
        if event.button == 'up':
            self.next_slice()
        if event.button == 'down':
            self.prev_slice()
        self.actual_slice_slider.set_val(self.actual_slice)"
3300,"def on_press(self, event):
        'on but-ton press we will see if the mouse is over us and store data'
        if event.inaxes != self.ax:
            return
        # contains, attrd = self.rect.contains(event)
        # if not contains: return
        # print('event contains', self.rect.xy)
        # x0, y0 = self.rect.xy
        self.press = [event.xdata], [event.ydata], event.button"
3301,"def on_motion(self, event):
        'on motion we will move the rect if the mouse is over us'
        if self.press is None:
            return

        if event.inaxes != self.ax:
            return
        # print(event.inaxes)

        x0, y0, btn = self.press
        x0.append(event.xdata)
        y0.append(event.ydata)"
3302,"def on_release(self, event):
        'on release we reset the press data'
        if self.press is None:
            return
        # print(self.press)
        x0, y0, btn = self.press
        if btn == 1:
            color = 'r'
        elif btn == 2:
            color = 'b'  # noqa

        # plt.axes(self.ax)
        # plt.plot(x0, y0)
        # button Mapping
        btn = self.button_map[btn]

        self.set_seeds(y0, x0, self.actual_slice, btn)
        # self.fig.canvas.draw()
        # pdb.set_trace();
        self.press = None
        self.update_slice()"
3303,"def get_seed_sub(self, label):
        """""" Return list of all seeds with specific label
        """"""
        sx, sy, sz = np.nonzero(self.seeds == label)

        return sx, sy, sz"
3304,"def find(self, instance_id):
        """""" find an instance
        
        Create a new instance and populate it with data stored if it exists.
        
        Args:
            instance_id (str): UUID of the instance
        
        Returns:
            AtlasServiceInstance.Instance: An instance
        """"""
        instance = AtlasServiceInstance.Instance(instance_id, self.backend)
        self.backend.storage.populate(instance)
        return instance"
3305,"def create(self, instance, parameters, existing):
        """""" Create the instance
        
        Args:
            instance (AtlasServiceInstance.Instance): Existing or New instance
            parameters (dict): Parameters for the instance
            existing (bool): Create an instance on an existing Atlas cluster
        
        Returns:
            ProvisionedServiceSpec: Status
            
        Raises:
            ErrInstanceAlreadyExists: If instance exists but with different parameters
            ErrClusterNotFound: Cluster does not exist
        """"""
        
        if not instance.isProvisioned():
            # Set parameters
            instance.parameters = parameters
            
            # Existing cluster
            if existing and not self.backend.atlas.Clusters.is_existing_cluster(instance.parameters[self.backend.config.PARAMETER_CLUSTER]):
                # We need to use an existing cluster that is not available !
                raise ErrClusterNotFound(instance.parameters[self.backend.config.PARAMETER_CLUSTER])
            elif not existing:
                # We need to create a new cluster
                # We should not reach this code because the AtlasBroker.provision should
                # raise an ErrPlanUnsupported before.
                raise NotImplementedError()
            
            result = self.backend.storage.store(instance)
            
            # Provision done
            return ProvisionedServiceSpec(ProvisionState.SUCCESSFUL_CREATED,
                                      """",
                                      str(result))
        
        elif instance.parameters == parameters:
            # Identical so nothing to do
            return ProvisionedServiceSpec(ProvisionState.IDENTICAL_ALREADY_EXISTS,
                                        """",
                                        ""duplicate"")
        
        else:
            # Different parameters ...
            raise ErrInstanceAlreadyExists()"
3306,"def delete(self, instance):
        """"""Delete the instance
        
        Args:
            instance (AtlasServiceInstance.Instance): an existing instance
            
        Returns:
            DeprovisionServiceSpec: Status
        """"""
        
        #TODO: Really drop the database based on a policy set in `instance.parameters`.
        #
        #      We need :
        #      - Set a policy in parameters of the instance (eg: policy-on-delete : retain|drop    => default to retain)
        #      - to check that the database name `instance.get_dbname()` is not in use by another instance (shared database)
        #      - credential on the Atlas cluster `instance.get_cluster()` to drop the database
        #
        
        self.backend.storage.remove(instance)
        
        return DeprovisionServiceSpec(False, ""done"")"
3307,"def push(self, item):
        '''Push the value item onto the heap, maintaining the heap invariant.
        If the item is not hashable, a TypeError is raised.
        '''
        hash(item)
        heapq.heappush(self._items, item)"
3308,"def format_field_by_match(self, value, match):
        """"""Formats a field by a Regex match of the format spec pattern.""""""
        groups = match.groups()
        fill, align, sign, sharp, zero, width, comma, prec, type_ = groups
        if not comma and not prec and type_ not in list('fF%'):
            return None
        if math.isnan(value) or math.isinf(value):
            return None
        locale = self.numeric_locale
        # Format number value.
        prefix = get_prefix(sign)
        if type_ == 'd':
            if prec is not None:
                raise ValueError('precision not allowed in '
                                 'integer format specifier')
            string = format_number(value, 0, prefix, locale)
        elif type_ in 'fF%':
            format_ = format_percent if type_ == '%' else format_number
            string = format_(value, int(prec or DEFAULT_PREC), prefix, locale)
        else:
            # Don't handle otherwise.
            return None
        if not comma:
            # Formatted number always contains group symbols.
            # Remove the symbols if not required.
            string = remove_group_symbols(string, locale)
        if not (fill or align or zero or width):
            return string
        # Fix a layout.
        spec = ''.join([fill or u'', align or u'>',
                        zero or u'', width or u''])
        return format(string, spec)"
3309,"def stdout_encode(u, default='utf-8'):
    """""" Encodes a given string with the proper standard out encoding
        If sys.stdout.encoding isn't specified, it this defaults to @default

        @default: default encoding

        -> #str with standard out encoding
    """"""
    # from http://stackoverflow.com/questions/3627793/best-output-type-and-
    #   encoding-practices-for-repr-functions
    encoding = sys.stdout.encoding or default
    return u.encode(encoding, ""replace"").decode(encoding, ""replace"")"
3310,"def get_terminal_width():
    """""" -> #int width of the terminal window """"""
    # http://www.brandonrubin.me/2014/03/18/python-snippet-get-terminal-width/
    command = ['tput', 'cols']
    try:
        width = int(subprocess.check_output(command))
    except OSError as e:
        print(
            ""Invalid Command '{0}': exit status ({1})"".format(
                command[0], e.errno))
    except subprocess.CalledProcessError as e:
        print(
            ""'{0}' returned non-zero exit status: ({1})"".format(
                command, e.returncode))
    else:
        return width"
3311,"def gen_rand_str(*size, use=None, keyspace=None):
    """""" Generates a random string using random module specified in @use within
        the @keyspace

        @*size: #int size range for the length of the string
        @use: the random module to use
        @keyspace: #str chars allowed in the random string
        ..
            from redis_structures.debug import gen_rand_str

            gen_rand_str()
            # -> 'PRCpAq'

            gen_rand_str(1, 2)
            # -> 'Y'

            gen_rand_str(12, keyspace=""abcdefg"")
            # -> 'gaaacffbedf'
        ..
    """"""
    keyspace = keyspace or (string.ascii_letters + string.digits)
    keyspace = [char for char in keyspace]
    use = use or np.random
    if size:
        size = size if len(size) == 2 else (size[0], size[0] + 1)
    else:
        size = (6, 7)
    return ''.join(
        use.choice(keyspace)
        for _ in range(use.randint(*size)))"
3312,"def rand_readable(*size, use=None, density=6):
    """""" Generates a random string with readable characters using
        random module specified in @use

        @*size: #int size range for the length of the string
        @use: the random module to use
        @density: how often to include a vowel, you can expect a vowel about
            once every (density) nth character
        ..
            from redis_structures.debug import rand_readable

            rand_readable()
            # -> 'hyiaqk'

            rand_readable(15, 20)
            # -> 'oqspyywvhifsaikiaoi'

            rand_readable(15, 20, density=1)
            # -> 'oeuiueioieeioeeeue'

            rand_readable(15, 20, density=15)
            # -> 'ktgjabwdqhgeanh'
        ..

    """"""
    use = use or np.random
    keyspace = [c for c in string.ascii_lowercase if c != ""l""]
    vowels = (""a"", ""e"", ""i"", ""o"", ""u"")

    def use_vowel(density): not use.randint(0, density)
    if size:
        size = size if len(size) == 2 else (size[0]-1, size[0])
    else:
        size = (6, 7)
    return ''.join(
        use.choice(vowels if use_vowel(density) else keyspace)
        for _ in range(use.randint(*size)))"
3313,"def get_parent_obj(obj):
    """""" Gets the name of the object containing @obj and returns as a string

        @obj: any python object

        -> #str parent object name or None
        ..
            from redis_structures.debug import get_parent_obj

            get_parent_obj(get_parent_obj)
            # -> <module 'redis_structures.debug' from>
        ..
    """"""
    try:
        cls = get_class_that_defined_method(obj)
        if cls and cls != obj:
            return cls
    except AttributeError:
        pass
    if hasattr(obj, '__module__') and obj.__module__:
        try:
            module = importlib.import_module(obj.__module__)
            objname = get_obj_name(obj).split(""."")
            owner = getattr(module, objname[-2])
            return getattr(owner, objname[-1])
        except Exception:
            try:
                return module
            except Exception:
                pass
    try:
        assert hasattr(obj, '__qualname__') or hasattr(obj, '__name__')
        objname = obj.__qualname__ if hasattr(obj, '__qualname__') \
            else obj.__name__
        objname = objname.split(""."")
        assert len(objname) > 1
        return locate(""."".join(objname[:-1]))
    except Exception:
        try:
            module = importlib.import_module(""."".join(objname[:-1]))
            return module
        except Exception:
            pass
    return None"
3314,"def get_obj_name(obj, full=True):
    """""" Gets the #str name of @obj

        @obj: any python object
        @full: #bool returns with parent name as well if True

        -> #str object name
        ..
            from redis_structures.debug import get_parent_obj

            get_obj_name(get_obj_name)
            # -> 'get_obj_name'

            get_obj_name(redis_structures.debug.Timer)
            # -> 'Timer'
        ..
    """"""
    has_name_attr = hasattr(obj, '__name__')
    if has_name_attr and obj.__name__ == ""<lambda>"":
        try:
            src = whitespace_sub("""", inspect.getsource(obj))\
                .replace(""\n"", ""; "").strip("" <>"")
        except OSError:
            src = obj.__name__
        return lambda_sub("""", src)
    if hasattr(obj, '__qualname__') and obj.__qualname__:
        return obj.__qualname__.split(""."")[-1]
    elif has_name_attr and obj.__name__:
        return obj.__name__.split(""."")[-1]
    elif hasattr(obj, '__class__'):
        return str(obj.__class__.__name__).strip(""<>"")
    else:
        return str(obj.__repr__())"
3315,"def format(self):
        """""" Formats the __repr__ string
            -> #str containing __repr__ output
        """"""
        _bold = bold
        if not self.pretty:
            _bold = lambda x: x
        # Attach memory address and return
        _attrs = self._format_attrs()
        self.data = ""<{}.{}({}){}>{}"".format(
            self.obj.__module__ if hasattr(self.obj, ""__module__"") \
                else ""__main__"",
            _bold(self.obj.__class__.__name__),
            _attrs,
            "":{}"".format(hex(id(self.obj))) if self.address else """",
            _break+self.supplemental if self.supplemental else """")
        return stdout_encode(self.data)"
3316,"def randstr(self):
        """""" -> #str result of :func:gen_rand_str """"""
        return gen_rand_str(
            2, 10, use=self.random, keyspace=list(self.keyspace))"
3317,"def set(self, size=1000):
        """""" Creates a random #set

            @size: #int number of random values to include in the set

            -> random #set
        """"""
        get_val = lambda: self._map_type()
        return set(get_val() for x in range(size))"
3318,"def list(self, size=1000, tree_depth=1):
        """""" Creates a random #list

            @size: #int number of random values to include in each @tree_depth
            @tree_depth: #int dict tree dimensions size, i.e.
                1=|[value1, value2]|
                2=|[[value1, value2], [value1, value2]]|

            -> random #list
        """"""
        if not tree_depth: return self._map_type()
        return list(self.deque(size, tree_depth-1) for x in range(size))"
3319,"def pretty_print(self, obj=None):
        """""" Formats and prints @obj or :prop:obj

            @obj: the object you'd like to prettify
        """"""
        print(self.pretty(obj if obj is not None else self.obj))"
3320,"def array(self):
        """""" Returns :prop:intervals as a numpy array, caches

            -> :class:numpy.array
        """"""
        if self._intervals_len:
            if self._array_len != self._intervals_len:
                if not self._array_len:
                    self._array = np.array(self.intervals) \
                        if hasattr(np, 'array') else self.intervals
                else:
                    self._array = np.concatenate((
                        self._array, self.intervals), axis=0) \
                        if hasattr(np, 'concatenate') else \
                        (self._array + self.intervals)
                self._array_len += len(self.intervals)
                self.intervals = []
            return self._array
        return []"
3321,"def reset(self):
        """""" Resets the time intervals """"""
        self._start = 0
        self._first_start = 0
        self._stop = time.perf_counter()
        self._array = None
        self._array_len = 0
        self.intervals = []
        self._intervals_len = 0"
3322,"def time(self, intervals=1, *args, _show_progress=True, _print=True,
             _collect_garbage=False, **kwargs):
        """""" Measures the execution time of :prop:_callables for @intervals

            @intervals: #int number of intervals to measure the execution time
                of the function for
            @*args: arguments to pass to the callable being timed
            @**kwargs: arguments to pass to the callable being timed
            @_show_progress: #bool whether or not to print a progress bar
            @_print: #bool whether or not to print the results of the timing
            @_collect_garbage: #bool whether or not to garbage collect
                while timing
            @_quiet: #bool whether or not to disable the print() function's
                ability to output to terminal during the timing

            -> #tuple of :class:Timer :prop:results of timing
        """"""
        self.reset()
        self.num_intervals = intervals
        for func in self.progress(self._callables):
            try:
                #: Don't ruin all timings if just one doesn't work
                t = Timer(
                    func, _precision=self.precision,
                    _parent_progressbar=self.progress)
                t.time(
                    intervals, *args, _print=False,
                    _show_progress=_show_progress,
                    _collect_garbage=_collect_garbage,
                    **kwargs)
            except Exception as e:
                print(RuntimeWarning(
                    ""{} with {}"".format(colorize(
                        ""{} failed"".format(Look.pretty_objname(
                            func, color=""yellow"")), ""yellow""), repr(e))))
            self._callable_results.append(t)
            self.progress.update()
        self.info(_print=_print)
        return self.results"
3323,"def read(filename):
    """"""
    Read a file relative to setup.py location.
    """"""
    import os
    here = os.path.dirname(os.path.abspath(__file__))
    with open(os.path.join(here, filename)) as fd:
        return fd.read()"
3324,"def find_version(filename):
    """"""
    Find package version in file.
    """"""
    import re
    content = read(filename)
    version_match = re.search(
        r""^__version__ = ['\""]([^'\""]*)['\""]"", content, re.M
    )
    if version_match:
        return version_match.group(1)
    raise RuntimeError('Unable to find version string.')"
3325,"def find_requirements(filename):
    """"""
    Find requirements in file.
    """"""
    import string
    content = read(filename)
    requirements = []
    for line in content.splitlines():
        line = line.strip()
        if line and line[:1] in string.ascii_letters:
            requirements.append(line)
    return requirements"
3326,"def generate_uuid(basedata=None):
    """""" Provides a _random_ UUID with no input, or a UUID4-format MD5 checksum of any input data provided """"""
    if basedata is None:
        return str(uuid.uuid4())
    elif isinstance(basedata, str):
        checksum = hashlib.md5(basedata).hexdigest()
        return '%8s-%4s-%4s-%4s-%12s' % (
            checksum[0:8], checksum[8:12], checksum[12:16], checksum[16:20], checksum[20:32])"
3327,"def from_unix(cls, seconds, milliseconds=0):
        """""" Produce a full |datetime.datetime| object from a Unix timestamp """"""
        base = list(time.gmtime(seconds))[0:6]
        base.append(milliseconds * 1000)  # microseconds
        return cls(*base)"
3328,"def to_unix(cls, timestamp):
        """""" Wrapper over time module to produce Unix epoch time as a float """"""
        if not isinstance(timestamp, datetime.datetime):
            raise TypeError('Time.milliseconds expects a datetime object')
        base = time.mktime(timestamp.timetuple())
        return base"
3329,"def milliseconds_offset(cls, timestamp, now=None):
        """""" Offset time (in milliseconds) from a |datetime.datetime| object to now """"""
        if isinstance(timestamp, (int, float)):
            base = timestamp
        else:
            base = cls.to_unix(timestamp)
            base += (timestamp.microsecond / 1000000)
        if now is None:
            now = time.time()
        return (now - base) * 1000"
3330,"def fixUTF8(cls, data):  # Ensure proper encoding for UA's servers...
        """""" Convert all strings to UTF-8 """"""
        for key in data:
            if isinstance(data[key], str):
                data[key] = data[key].encode('utf-8')
        return data"
3331,"def alias(cls, typemap, base, *names):
        """""" Declare an alternate (humane) name for a measurement protocol parameter """"""
        cls.parameter_alias[base] = (typemap, base)
        for i in names:
            cls.parameter_alias[i] = (typemap, base)"
3332,"def consume_options(cls, data, hittype, args):
        """""" Interpret sequential arguments related to known hittypes based on declared structures """"""
        opt_position = 0
        data['t'] = hittype  # integrate hit type parameter
        if hittype in cls.option_sequence:
            for expected_type, optname in cls.option_sequence[hittype]:
                if opt_position < len(args) and isinstance(args[opt_position], expected_type):
                    data[optname] = args[opt_position]
                opt_position += 1"
3333,"def hittime(cls, timestamp=None, age=None, milliseconds=None):
        """""" Returns an integer represeting the milliseconds offset for a given hit (relative to now) """"""
        if isinstance(timestamp, (int, float)):
            return int(Time.milliseconds_offset(Time.from_unix(timestamp, milliseconds=milliseconds)))
        if isinstance(timestamp, datetime.datetime):
            return int(Time.milliseconds_offset(timestamp))
        if isinstance(age, (int, float)):
            return int(age * 1000) + (milliseconds or 0)"
3334,"def set_timestamp(self, data):
        """""" Interpret time-related options, apply queue-time parameter as needed """"""
        if 'hittime' in data:  # an absolute timestamp
            data['qt'] = self.hittime(timestamp=data.pop('hittime', None))
        if 'hitage' in data:  # a relative age (in seconds)
            data['qt'] = self.hittime(age=data.pop('hitage', None))"
3335,"async def send(self, hittype, *args, **data):
        """""" Transmit HTTP requests to Google Analytics using the measurement protocol """"""

        if hittype not in self.valid_hittypes:
            raise KeyError('Unsupported Universal Analytics Hit Type: {0}'.format(repr(hittype)))

        self.set_timestamp(data)
        self.consume_options(data, hittype, args)

        for item in args:  # process dictionary-object arguments of transcient data
            if isinstance(item, dict):
                for key, val in self.payload(item):
                    data[key] = val

        for k, v in self.params.items():  # update only absent parameters
            if k not in data:
                data[k] = v

        data = dict(self.payload(data))

        if self.hash_client_id:
            data['cid'] = generate_uuid(data['cid'])

        # Transmit the hit to Google...
        await self.http.send(data)"
3336,"def p_null_assignment(self, t):
    '''null_assignment : IDENT EQ NULL'''
    self.accu.add(Term('obs_vlabel', [self.name,""gen(\""""+t[1]+""\"")"",""0""]))"
3337,"def p_plus_assignment(self, t):
    '''plus_assignment : IDENT EQ PLUS'''
    self.accu.add(Term('obs_vlabel', [self.name,""gen(\""""+t[1]+""\"")"",""1""]))"
3338,"def p_minus_assignment(self, t):
    '''minus_assignment : IDENT EQ MINUS'''
    self.accu.add(Term('obs_vlabel', [self.name,""gen(\""""+t[1]+""\"")"",""-1""]))"
3339,"def p_notplus_assignment(self, t):
    '''notplus_assignment : IDENT EQ NOTPLUS'''
    self.accu.add(Term('obs_vlabel', [self.name,""gen(\""""+t[1]+""\"")"",""notPlus""]))"
3340,"def p_notminus_assignment(self, t):
    '''notminus_assignment : IDENT EQ NOTMINUS'''
    self.accu.add(Term('obs_vlabel', [self.name,""gen(\""""+t[1]+""\"")"",""notMinus""]))"
3341,"def p_input_assignment(self, t):
    '''input_assignment : IDENT EQ INPUT'''
    self.accu.add(Term('input', [self.name,""gen(\""""+t[1]+""\"")""]))"
3342,"def p_min_assignment(self, t):
    '''min_assignment : IDENT EQ MIN'''
    self.accu.add(Term('ismin', [self.name,""gen(\""""+t[1]+""\"")""]))"
3343,"def p_max_assignment(self, t):
    '''max_assignment : IDENT EQ MAX'''
    self.accu.add(Term('ismax', [self.name,""gen(\""""+t[1]+""\"")""]))"
3344,"def get_service_version(self, service_id, mode='production', version='default'):
        '''
        get_service_version(self, service_id, mode='production', version='default')

        | Get a specific version details of a given service. Opereto will try to fetch the requested service version. If not found, it will return the default production version. The ""actual_version"" field of the returned JSON indicates what version of the service is returned. If the actual version is null, it means that this service does not have any version at all. To make it operational, you will have to import or upload a default version.

        :Parameters:
        * *service_id* (`string`) -- Identifier of an existing service
        * *mode* (`string`) -- development/production. Default is production
        * *version* (`string`) -- version of the service (""default"" is the default.

        :return: json service version details

        :Example:
        .. code-block:: python

           service_version = opereto_client.get_service_version(serviceId, mode='development', version='111')
        '''
        return self._call_rest_api('get', '/services/'+service_id+'/'+mode+'/'+version, error='Failed to fetch service information')"
3345,"def verify_service(self, service_id, specification=None, description=None, agent_mapping=None):
        '''
        verify_service(self, service_id, specification=None, description=None, agent_mapping=None)

        | Verifies validity of service yaml

        :Parameters:
        * *service_id* (`string`) -- Identifier of an existing service
        * *specification* (`string`) -- service specification yaml
        * *description* (`string`) -- service description written in text or markdown style
        * *agent_mapping* (`string`) -- agents mapping specification

        :return: json service version details

        :Example:
        .. code-block:: python

           spec = {
               ""type"": ""action"",
               ""cmd"": ""python -u run.py"",
               ""timeout"": 600,
               ""item_properties"": [
                    {""key"": ""key1"", ""type"": ""text"", ""value"": ""value1"", ""direction"": ""input""},
                    {""key"": ""key2"", ""type"": ""boolean"", ""value"": True, ""direction"": ""input""}
                 ]
              }
           if opereto_client.verify_service ('hello_world', specification=spec)['errors'] == []:
              result = True

        '''
        request_data = {'id': service_id}
        if specification:
            request_data['spec']=specification
        if description:
            request_data['description']=description
        if agent_mapping:
            request_data['agents']=agent_mapping
        return self._call_rest_api('post', '/services/verify', data=request_data, error='Service [%s] verification failed'%service_id)"
3346,"def modify_service(self, service_id, type):
        '''
        modify_service(self, service_id, type)

        | Modifies a service type (action, container, etc.)

        :Parameters:
        * *service_id* (`string`) -- Identifier of an existing service
        * *type* (`string`) -- service type

        :return: Service modification metadata (service id, type, modified date, versions

        :Example:
        .. code-block:: python

           service_modification_metadata = opereto_client.modify_service ('myService', 'container')
           if service_modification_metadata['type'] == 'container'
              print 'service type of {} changed to container'.format('myService')

        '''
        request_data = {'id': service_id, 'type': type}
        return self._call_rest_api('post', '/services', data=request_data, error='Failed to modify service [%s]'%service_id)"
3347,"def upload_service_version(self, service_zip_file, mode='production', service_version='default', service_id=None, **kwargs):
        '''
        upload_service_version(self, service_zip_file, mode='production', service_version='default', service_id=None, **kwargs)

        Upload a service version to Opereto

        :Parameters:
        * *service_zip_file* (`string`) -- zip file location containing service and service specification
        * *mode* (`string`) -- production/development (default is production)
        * *service_version* (`string`) -- Service version
        * *service_id* (`string`) -- Service Identifier

        :Keywords args:
        * *comment* (`string`) -- comment

        :Example:
        .. code-block:: python

           opereto_client.upload_service_version(service_zip_file=zip_action_file+'.zip', mode='production', service_version='111')

        '''
        files = {'service_file': open(service_zip_file,'rb')}
        url_suffix = '/services/upload/%s'%mode
        if mode=='production':
            url_suffix+='/'+service_version
        if service_id:
            url_suffix+='/'+service_id
        if kwargs:
            url_suffix=url_suffix+'?'+urlencode(kwargs)
        return self._call_rest_api('post', url_suffix, files=files, error='Failed to upload service version')"
3348,"def import_service_version(self, repository_json, mode='production', service_version='default', service_id=None, **kwargs):
        '''
        import_service_version(self, repository_json, mode='production', service_version='default', service_id=None, **kwargs)

        Imports a service version into Opereto from a remote repository (GIT, SVN, AWS S3, any HTTPS repository)

        :Parameters:
        * *repository_json* (`object`) -- repository_json
        :Example of repository JSON:
            .. code-block:: json

                #GIT source control
                {
                    ""repo_type"": ""git"",
                    ""url"": ""git@bitbucket.org:my_account_name/my_project.git"",
                    ""branch"": ""master"",
                    ""ot_dir"": ""mydir""
                }

                #SVN
                {
                    ""repo_type"": ""svn"",
                    ""url"": ""svn://myhost/myrepo"",
                    ""username"": ""OPTIONAL_USERNAME"",
                    ""password"": ""OPTIONAL_PASSWORD"",
                    ""ot_dir"": ""my_service_dir""
                }

                # Any HTTP based remote storage

                {
                    ""repo_type"": ""http"",
                    ""url"": ""https://www.dropbox.com/s/1234567890/MyFile.zip?dl=0"",
                    ""username"": ""OPTIONAL_PASSWORD"",
                    ""ot_dir"": ""my_service_dir""
                }

                # AWS S3 Storage

                {
                    ""repo_type"": ""s3"",
                    ""bucket"": ""my_bucket/my_service.zip"",
                    ""access_key"": ""MY_ACCESS_KEY"",
                    ""secret_key"": ""MY_SECRET_KEY"",
                    ""ot_dir"": ""my_service_dir""
                }

        * *mode* (`string`) -- production/development (default is production)
        * *service_version* (`string`) -- Service version
        * *service_id* (`string`) -- Service version


        :return: status - success/failure

        :Example:
        .. code-block:: python

            # for GIT
           repository_json = {
                ""branch"": ""master"",
                ""ot_dir"": ""microservices/hello_world"",
                ""repo_type"": ""git"",
                ""url"": ""https://github.com/myCompany/my_services.git""
            }

            opereto_client.import_service_version(repository_json, mode='production', service_version='default', service_id=self.my_service2)

        '''
        request_data = {'repository': repository_json, 'mode': mode, 'service_version': service_version, 'id': service_id}
        url_suffix = '/services'
        if kwargs:
            url_suffix=url_suffix+'?'+urlencode(kwargs)
        return self._call_rest_api('post', url_suffix, data=request_data, error='Failed to import service')"
3349,"def delete_service_version(self, service_id , service_version='default', mode='production'):
        '''
        delete_service(self, service_id, service_version='default', mode='production')

        Deletes a Service version from Opereto

        :Parameters:
        * *service_id* (`string`) -- Service identifier
        * *service_version* (`string`) -- Service version. Default is 'default'
        * *mode* (`string`) -- development/production. Default is production

        :return: success/failure

        :Example:
        .. code-block:: python

           opereto_client.delete_service('my_service_id')

        '''
        return self._call_rest_api('delete', '/services/'+service_id+'/'+mode+'/'+service_version, error='Failed to delete service')"
3350,"def verify_environment_scheme(self, environment_type, environment_topology):
        '''
        verify_environment_scheme(self, environment_type, environment_topology)

        Verifies json scheme of an environment

        :Parameters:

        * *environment_type* (`string`) -- Topology identifier
        * *environment_topology* (`object`) -- Environment json to validate

        :return: Success or errors in case the verification failed

        :Return Example:
        .. code-block:: json

            # verification failure
            {'errors': ['Topology key cluster_name is missing in environment specification'], 'agents': {}, 'success': False, 'warnings': []}

            # verification success
            {'errors': [], 'agents': {}, 'success': True, 'warnings': []}

        :Example:
        .. code-block:: python

            environment_topology =
            {
                  ""cluster_name"": ""k8s-clusbbe9"",
                  ""config_file"": {
                    ""contexts"": [
                      {
                        ""name"": ""my-context""
                      }
                    ],
                    ""clusters"": [
                      {
                        ""name"": ""k8s-clusbbe9""
                      }
                    ]
                  }
            }
            environment = opereto_client.verify_environment_scheme(environment_type = 'myTopology', environment_topology = environment_topology)

        '''
        request_data = {'topology_name': environment_type, 'topology': environment_topology}
        return self._call_rest_api('post', '/environments/verify', data=request_data, error='Failed to verify environment.')"
3351,"def verify_environment(self, environment_id):
        '''
        verify_environment(self, environment_id)

        Verifies validity of an existing environment

        :Parameters:

        * *environment_id* (`string`) -- Environment identifier

        :return: Success or errors in case the verification failed

        :Return Example:
        .. code-block:: json

            # verification failure
            {'errors': ['Topology key cluster_name is missing in environment specification'], 'agents': {}, 'success': False, 'warnings': []}

            # verification success
            {'errors': [], 'agents': {}, 'success': True, 'warnings': []}

        '''
        request_data = {'id': environment_id}
        return self._call_rest_api('post', '/environments/verify', data=request_data, error='Failed to verify environment.')"
3352,"def create_environment(self, topology_name, topology={}, id=None, **kwargs):
        '''
        create_environment(self, topology_name, topology={}, id=None, **kwargs)

        Create a new environment

        :Parameters:

        * *topology_name* (`string`) -- The topology identifier. Must be provided to create an environment.
        * *topology* (`object`) -- Topology data (must match the topology json schema)
        * *id* (`object`) -- The environment identifier. If none provided when creating environment, Opereto will automatically assign a unique identifier.

        :return: id of the created environment

        '''
        request_data = {'topology_name': topology_name,'id': id, 'topology':topology, 'add_only':True}
        request_data.update(**kwargs)
        return self._call_rest_api('post', '/environments', data=request_data, error='Failed to create environment')"
3353,"def modify_environment(self, environment_id, **kwargs):
        '''
        modify_environment(self, environment_id, **kwargs)

        Modifies an existing environment

        :Parameters:
        * *environment_id* (`string`) -- The environment identifier

        Keywords args:
        The variables to change in the environment

        :return: id of the created environment

        '''
        request_data = {'id': environment_id}
        request_data.update(**kwargs)
        return self._call_rest_api('post', '/environments', data=request_data, error='Failed to modify environment')"
3354,"def search_agents(self, start=0, limit=100, filter={}, **kwargs):
        '''
        search_agents(self, start=0, limit=100, filter={}, **kwargs)

        Search agents

        :Parameters:
        * *start* (`int`) -- start index to retrieve from. Default is 0
        * *limit* (`int`) -- maximum number of entities to retrieve. Default is 100
        * *filter* (`object`) -- free text search pattern (checks in agent data and properties)

        :return: List of search results or empty list

        :Example:
        .. code-block:: python

           filter = {'generic': 'my Agent'}
           search_result = opereto_client.search_agents(filter=filter)

        '''
        request_data = {'start': start, 'limit': limit, 'filter': filter}
        request_data.update(kwargs)
        return self._call_rest_api('post', '/search/agents', data=request_data, error='Failed to search agents')"
3355,"def modify_agent_property(self, agent_id, key, value):
        '''
        modify_agent_property(self, agent_id, key, value)

        Modifies a single single property of an agent. If the property does not exists then it is created as a custom property.

        :Parameters:
        * *agent_id* (`string`) -- Identifier of an existing agent
        * *key* (`string`) -- Key of a property to change
        * *value* (`string`) -- New Value of the property to change

        :Example:
        .. code-block:: python

           opereto_client.modify_agent_property('my_agent_id', 'agent_new_property', 'agent value')

        '''
        return self._call_rest_api('post', '/agents/'+agent_id+'/properties', data={key: value}, error='Failed to modify agent [%s] property [%s]'%(agent_id,key))"
3356,"def modify_agent_properties(self, agent_id, key_value_map={}):
        '''
        modify_agent_properties(self, agent_id, key_value_map={})

        Modify properties of an agent. If properties do not exists, they will be created

        :Parameters:
        * *agent_id* (`string`) -- Identifier of an existing agent
        * *key_value_map* (`object`) -- Key value map of properties to change
        * *value* (`string`) -- New Value of the property to change

        :Example:
        .. code-block:: python

           opereto_client.modify_agent_properties('my_agent_id', {""mykey"": ""myvalue"", ""mykey2"": ""myvalue2""})

        '''
        return self._call_rest_api('post', '/agents/'+agent_id+'/properties', data=key_value_map, error='Failed to modify agent [%s] properties'%agent_id)"
3357,"def create_agent(self, agent_id=None, **kwargs):
        '''
        create_agent(self, agent_id=None, **kwargs)

        | Creates an agent based on the identifier provided. \
        | The agent will become online when a real agent will connect using this identifier. \
        | However, in most cases, the agent entity is created automatically when a new agent connects to opereto. \

        :Parameters:
        * *agent_id* (`string`) -- Identifier of an existing agent
        :Keywords args:
        * *name* (`string`) -- Display name to show in the UI
        * *description* (`string`) -- A textual description of the agent
        * *permissions* (`object`) -- Permissions on the agent
            * *owners* (`array`) -- List of Opereto usernames that may modify and delete the agent
            * *owners* (`array`) -- List of Opereto usernames that may run services on the agent
        :return: id of the generated agent

        :Example:
        .. code-block:: python

           opereto_client = OperetoClient()
           opereto_client.create_agent(agent_id='xAgent', name='My new agent', description='A new created agent to be called from X machines')


        '''

        request_data = {'id': agent_id, 'add_only':True}
        request_data.update(**kwargs)
        return self._call_rest_api('post', '/agents'+'', data=request_data, error='Failed to create agent')"
3358,"def modify_agent(self, agent_id, **kwargs):
        '''
        modify_agent(self, agent_id, **kwargs)

        | Modifies agent information (like name)

        :Parameters:
        * *agent_id* (`string`) -- Identifier of an existing agent

         :Example:
        .. code-block:: python

           opereto_client = OperetoClient()
           opereto_client.modify_agent('agentId', name='my new name')

        '''
        request_data = {'id': agent_id}
        request_data.update(**kwargs)
        return self._call_rest_api('post', '/agents'+'', data=request_data, error='Failed to modify agent [%s]'%agent_id)"
3359,"def create_process(self, service, agent=None, title=None, mode=None, service_version=None, **kwargs):
        '''
        create_process(self, service, agent=None, title=None, mode=None, service_version=None, **kwargs)

        Registers a new process or processes

        :Parameters:
        * *service* (`string`) -- Service which process will be started
        * *agent* (`string`) -- The service identifier (e.g shell_command)
        * *title* (`string`) -- Title for the process
        * *mode* (`string`) -- production/development
        * *service_version* (`string`) -- Version of the service to execute

        :Keywords args:
        Json value map containing the process input properties

        :return: process id

        :Example:
        .. code-block:: python

           process_properties = {""my_input_param"" : ""1""}
           pid = opereto_client.create_process(service='simple_shell_command', title='Test simple shell command service', agent=opereto_client.input['opereto_agent'], **process_properties)

        '''
        if not agent:
            agent = self.input.get('opereto_agent')

        if not mode:
            mode=self.input.get('opereto_execution_mode') or 'production'
        if not service_version:
            service_version=self.input.get('opereto_service_version')

        request_data = {'service_id': service, 'agents': agent, 'mode': mode, 's_version':service_version}
        if title:
            request_data['name']=title

        if self.input.get('pid'):
            request_data['pflow_id']=self.input.get('pid')

        request_data.update(**kwargs)
        ret_data= self._call_rest_api('post', '/processes', data=request_data, error='Failed to create a new process')

        if not isinstance(ret_data, list):
            raise OperetoClientError(str(ret_data))

        pid = ret_data[0]
        message = 'New process created for service [%s] [pid = %s] '%(service, pid)
        if agent:
            message += ' [agent = %s]'%agent
        else:
            message += ' [agent = any ]'
        self.logger.info(message)
        return str(pid)"
3360,"def rerun_process(self, pid, title=None, agent=None):
        '''
        rerun_process(self, pid, title=None, agent=None)

        Reruns a process

        :Parameters:
        * *pid* (`string`) -- Process id to rerun
        * *title* (`string`) -- Title for the process
        * *agent* (`string`) -- a valid value may be one of the following: agent identifier, agent identifiers (list) : [""agent_1"", ""agent_2""..], ""all"", ""any""

        :return: process id

        '''
        request_data = {}
        if title:
            request_data['name']=title
        if agent:
            request_data['agents']=agent

        if self.input.get('pid'):
            request_data['pflow_id']=self.input.get('pid')

        ret_data= self._call_rest_api('post', '/processes/'+pid+'/rerun', data=request_data, error='Failed to create a new process')

        if not isinstance(ret_data, list):
            raise OperetoClientError(str(ret_data))

        new_pid = ret_data[0]
        message = 'Re-executing process [%s] [new process pid = %s] '%(pid, new_pid)
        self.logger.info(message)
        return str(new_pid)"
3361,"def modify_process_properties(self, key_value_map={}, pid=None):
        '''
        modify_process_properties(self, key_value_map={}, pid=None)

        Modify process output properties.
        Please note that process property key provided must be declared as an output property in the relevant service specification.

        :Parameters:
        * *key_value_map* (`object`) -- key value map with process properties to modify
        * *pid* (`string`) -- Identifier of an existing process

        :Example:
        .. code-block:: python

           process_output_properties = {""my_output_param"" : ""1""}
           pid = opereto_client.create_process(service='simple_shell_command', title='Test simple shell command service')
           opereto_client.modify_process_properties(process_output_properties, pid)

        '''
        pid = self._get_pid(pid)
        request_data={""properties"": key_value_map}
        return self._call_rest_api('post', '/processes/'+pid+'/output', data=request_data, error='Failed to output properties')"
3362,"def modify_process_property(self, key, value, pid=None):
        '''
        modify_process_property(self, key, value, pid=None)

        Modify process output property.
        Please note that the process property key provided must be declared as an output property in the relevant service specification.

        :Parameters:
        * *key* (`String`) -- key of property to modify
        * *key* (`value`) -- value of property to modify
        * *pid* (`string`) -- Identifier of an existing process

        :Example:
        .. code-block:: python

           pid = opereto_client.create_process(service='simple_shell_command', title='Test simple shell command service')
           opereto_client.modify_process_property(""my_output_param"", ""1"" , pid)

        '''
        pid = self._get_pid(pid)
        request_data={""key"" : key, ""value"": value}
        return self._call_rest_api('post', '/processes/'+pid+'/output', data=request_data, error='Failed to modify output property [%s]'%key)"
3363,"def modify_process_summary(self, pid=None, text='', append=False):
        '''
        modify_process_summary(self, pid=None, text='')

        Modifies the summary text of the process execution

        :Parameters:
        * *key* (`pid`) -- Identifier of an existing process
        * *key* (`text`) -- summary text
        * *append* (`boolean`) -- True to append to summary. False to override it.

        '''
        pid = self._get_pid(pid)

        if append:
            current_summary =  self.get_process_info(pid).get('summary') or ''
            modified_text = current_summary + '\n' + text
            text = modified_text

        request_data = {""id"": pid, ""data"": str(text)}
        return self._call_rest_api('post', '/processes/'+pid+'/summary', data=request_data, error='Failed to update process summary')"
3364,"def stop_process(self, pids, status='success'):
        '''
        stop_process(self, pids, status='success')

        Stops a running process

        :Parameters:
        * *pid* (`string`) -- Identifier of an existing process
        * *result* (`string`) -- the value the process will be terminated with. Any of the following possible values:  success , failure , error , warning , terminated

        '''
        if status not in process_result_statuses:
            raise OperetoClientError('Invalid process result [%s]'%status)
        pids = self._get_pids(pids)
        for pid in pids:
            self._call_rest_api('post', '/processes/'+pid+'/terminate/'+status, error='Failed to stop process')"
3365,"def get_process_status(self, pid=None):
        '''
        get_process_status(self, pid=None)

        Get current status of a process

        :Parameters:
        * *pid* (`string`) -- Identifier of an existing process

        '''
        pid = self._get_pid(pid)
        return self._call_rest_api('get', '/processes/'+pid+'/status', error='Failed to fetch process status')"
3366,"def get_process_flow(self, pid=None):
        '''
        get_process_flow(self, pid=None)

        Get process in flow context. The response returns a sub-tree of the whole flow containing the requested process, its direct children processes, and all ancestors.
        You can navigate within the flow backword and forward by running this call on the children or ancestors of a given process.

        :Parameters:
        * *pid* (`string`) -- Identifier of an existing process

        '''
        pid = self._get_pid(pid)
        return self._call_rest_api('get', '/processes/'+pid+'/flow', error='Failed to fetch process information')"
3367,"def get_process_rca(self, pid=None):
        '''
        get_process_rca(self, pid=None)

        Get the RCA tree of a given failed process. The RCA tree contains all failed child processes that caused the failure of the given process.

        :Parameters:
        * *pid* (`string`) -- Identifier of an existing process

        '''
        pid = self._get_pid(pid)
        return self._call_rest_api('get', '/processes/'+pid+'/rca', error='Failed to fetch process information')"
3368,"def get_process_info(self, pid=None):
        '''
        get_process_info(self, pid=None)

        Get process general information.

        :Parameters:
        * *pid* (`string`) -- Identifier of an existing process

        '''

        pid = self._get_pid(pid)
        return self._call_rest_api('get', '/processes/'+pid, error='Failed to fetch process information')"
3369,"def get_process_log(self, pid=None, start=0, limit=1000):
        '''
        get_process_log(self, pid=None, start=0, limit=1000

        Get process logs

        :Parameters:
        * *pid* (`string`) -- Identifier of an existing process
        * *pid* (`string`) -- start index to retrieve logs from
        * *pid* (`string`) -- maximum number of entities to retrieve

        :return: Process log entries

        '''
        pid = self._get_pid(pid)
        data = self._call_rest_api('get', '/processes/'+pid+'/log?start={}&limit={}'.format(start,limit), error='Failed to fetch process log')
        return data['list']"
3370,"def search_process_log(self, pid, filter={}, start=0, limit=1000):
        '''
        search_process_log(self, pid, filter={}, start=0, limit=1000)

        Search in process logs

        :Parameters:
        * *pid* (`string`) -- Identifier of an existing process
        * *start* (`int`) -- start index to retrieve from. Default is 0
        * *limit* (`int`) -- maximum number of entities to retrieve. Default is 100
        * *filter* (`object`) -- free text search pattern (checks in process log data)

        :return: Count of records found and list of search results or empty list

        :Example:
        .. code-block:: python

           filter = {'generic': 'my product param'}
           search_result = opereto_client.search_globals(filter=filter)
           if search_result['total'] > 0
              print(search_result['list'])
        '''
        pid = self._get_pid(pid)
        request_data = {'start': start, 'limit': limit, 'filter': filter}
        return self._call_rest_api('post', '/processes/' + pid + '/log/search', data=request_data,
                                    error='Failed to search in process log')"
3371,"def get_process_properties(self, pid=None, name=None):
        '''
        get_process_properties(self, pid=None, name=None)

        Get process properties (both input and output properties)

        :Parameters:
        * *pid* (`string`) -- Identifier of an existing process
        * *name* (`string`) -- optional - Property name

        '''
        pid = self._get_pid(pid)
        res = self._call_rest_api('get', '/processes/'+pid+'/properties', error='Failed to fetch process properties')
        if name:
            try:
                return res[name]
            except KeyError as e:
                raise OperetoClientError(message='Invalid property [%s]'%name, code=404)
        else:
            return res"
3372,"def wait_for(self, pids=[], status_list=process_result_statuses):
        '''
        wait_for(self, pids=[], status_list=process_result_statuses)

        Waits for a process to finish

        :Parameters:
        * *pids* (`list`) -- list of processes waiting to be finished
        * *status_list* (`list`) -- optional - List of statuses to wait for processes to finish with

        :Example:
        .. code-block:: python

           pid = opereto_client.create_process(service='simple_shell_command', title='Test simple shell command service')
           opereto_client.wait_for([pid], ['failure', 'error'])
           opereto_client.rerun_process(pid)

        '''
        results={}
        pids = self._get_pids(pids)
        for pid in pids:
            while(True):
                try:
                    stat = self._call_rest_api('get', '/processes/'+pid+'/status', error='Failed to fetch process [%s] status'%pid)
                    if stat in status_list:
                        results[pid]=stat
                        break
                    time.sleep(5)
                except requests.exceptions.RequestException as e:
                    # reinitialize session using api call decorator
                    self.session=None
                    raise e
        return results"
3373,"def wait_to_start(self, pids=[]):
        '''
        wait_to_start(self, pids=[])

        Wait for processes to start

        :Parameters:
        * *pids* (`list`) -- list of processes to wait to start

        '''
        actual_pids = self._get_pids(pids)
        return self.wait_for(pids=actual_pids, status_list=process_result_statuses+['in_process'])"
3374,"def wait_to_end(self, pids=[]):
        '''
        wait_to_end(self, pids=[])

        Wait for processes to finish

        :Parameters:
        * *pids* (`list`) -- list of processes to wait to finish

        '''
        actual_pids = self._get_pids(pids)
        return self.wait_for(pids=actual_pids, status_list=process_result_statuses)"
3375,"def get_process_runtime_cache(self, key, pid=None):
        '''
        get_process_runtime_cache(self, key, pid=None)

        Get a pre-defined run time parameter value

        :Parameters:
        * *key* (`string`) -- Identifier of the runtime cache
        * *pid* (`string`) -- Identifier of an existing process

        '''
        value = None
        pid = self._get_pid(pid)
        value = self._call_rest_api('get', '/processes/'+pid+'/cache?key=%s'%key, error='Failed to fetch process runtime cache')
        return value"
3376,"def set_process_runtime_cache(self, key, value, pid=None):
        '''
        set_process_runtime_cache(self, key, value, pid=None)

        Set a process run time parameter

        :Parameters:
        * *key* (`string`) -- parameter key
        * *key* (`value`) -- parameter value
        * *key* (`pid`) -- optional - Identifier of an existing process

        '''
        pid = self._get_pid(pid)
        self._call_rest_api('post', '/processes/'+pid+'/cache', data={'key': key, 'value': value}, error='Failed to modify process runtime cache')"
3377,"def create_product(self, product, version, build, name=None, description=None, attributes={}):
        '''
        create_product(self, product, version, build, name=None, description=None, attributes={})

        Create product

        :Parameters:
        * *product* (`string`) -- product
        * *version* (`string`) -- version
        * *build* (`string`) -- build
        * *name* (`string`) -- name
        * *description* (`string`) -- description
        * *attributes* (`object`) -- product attributes

        '''
        request_data = {'product': product, 'version': version, 'build': build}
        if name: request_data['name']=name
        if description: request_data['description']=description
        if attributes: request_data['attributes']=attributes
        ret_data= self._call_rest_api('post', '/products', data=request_data, error='Failed to create a new product')
        pid = ret_data
        message = 'New product created [pid = %s] '%pid
        self.logger.info(message)
        return str(pid)"
3378,"def modify_product(self, product_id, name=None, description=None, attributes={}):
        '''
        modify_product(self, product_id, name=None, description=None, attributes={})

        Modify an existing product

        :Parameters:
        * *product_id* (`string`) -- identifier of an existing product
        * *name* (`string`) -- name of the product
        * *description* (`string`) -- product description
        * *attributes* (`object`) -- product attributes to modify

        '''
        request_data = {'id': product_id}
        if name: request_data['name']=name
        if description: request_data['description']=description
        if attributes: request_data['attributes']=attributes
        return self._call_rest_api('post', '/products', data=request_data, error='Failed to modify a new product')"
3379,"def modify_kpi(self, kpi_id, product_id, measures=[], append=False, **kwargs):
        '''
        modify_kpi(self, kpi_id, product_id, measures=[], append=False, **kwargs)

        Creates a new kpi or modifies existing one.

      :Parameters:
        * *kpi_id* (`string`) -- The KPI identifier (unique per product)
        * *product_id* (`string`) -- The product (release candidate) identifier
        * *measures* (`list`) -- List of numeric (integers or floats) measures
        * *append* (`boolean`) -- True to append new measures to existing ones for this API. False to override previous measures

        '''
        if not isinstance(measures, list):
            measures = [measures]
        request_data = {'kpi_id': kpi_id, 'product_id': product_id, 'measures': measures, 'append': append}
        request_data.update(kwargs)
        return self._call_rest_api('post', '/kpi', data=request_data, error='Failed to modify a kpi entry')"
3380,"def create_qc(self, product_id=None, expected_result='', actual_result='', weight=100, status='success', **kwargs):
        '''
        create_qc(self, product_id=None, expected_result='', actual_result='', weight=100, status='success', **kwargs)

        Create Quality Criteria

        :Parameters:
        * *product_id* (`string`) -- The product (release candidate) identifier
        * *expected_result* (`string`) -- Text describing the expected result of this criteria
        * *actual_result* (`string`) --  Text describing the actual result of this criteria
        * *weight* (`integer`) -- Overall weight of this criteria (integer between 0-100)
        * *status* (`string`) -- pass/fail/norun

        '''
        request_data = {'product_id': product_id, 'expected': expected_result, 'actual': actual_result,'weight': weight, 'exec_status': status}
        request_data.update(**kwargs)
        return self._call_rest_api('post', '/qc', data=request_data, error='Failed to create criteria')"
3381,"def modify_qc(self, qc_id=None, **kwargs):
        '''
        modify_qc(self, qc_id=None, **kwargs)

        Modify a Quality Criteria

        :Parameters:
        * *qc_id* (`string`) -- The Quality criteria identifier

        '''
        if qc_id:
            request_data = {'id': qc_id}
            request_data.update(**kwargs)
            return self._call_rest_api('post', '/qc', data=request_data, error='Failed to modify criteria')
        else:
            return self.create_qc(**kwargs)"
3382,"def write(self):
        """"""Pull features from the instream and write them to the output.""""""
        for entry in self._instream:
            if isinstance(entry, Feature):
                for feature in entry:
                    if feature.num_children > 0 or feature.is_multi:
                        if feature.is_multi and feature != feature.multi_rep:
                            continue
                        self.feature_counts[feature.type] += 1
                        fid = '{}{}'.format(feature.type,
                                            self.feature_counts[feature.type])
                        feature.add_attribute('ID', fid)
                    else:
                        feature.drop_attribute('ID')
            if isinstance(entry, Sequence) and not self._seq_written:
                print('##FASTA', file=self.outfile)
                self._seq_written = True
            print(repr(entry), file=self.outfile)"
3383,"def datetime2yeardoy(time: Union[str, datetime.datetime]) -> Tuple[int, float]:
    """"""
    Inputs:
    T: Numpy 1-D array of datetime.datetime OR string for dateutil.parser.parse

    Outputs:
    yd: yyyyddd four digit year, 3 digit day of year (INTEGER)
    utsec: seconds from midnight utc
    """"""
    T = np.atleast_1d(time)

    utsec = np.empty_like(T, float)
    yd = np.empty_like(T, int)
    for i, t in enumerate(T):
        if isinstance(t, np.datetime64):
            t = t.astype(datetime.datetime)
        elif isinstance(t, str):
            t = parse(t)

        utsec[i] = datetime2utsec(t)
        yd[i] = t.year*1000 + int(t.strftime('%j'))

    return yd.squeeze()[()], utsec.squeeze()[()]"
3384,"def yeardoy2datetime(yeardate: int,
                     utsec: Union[float, int] = None) -> datetime.datetime:
    """"""
    Inputs:
    yd: yyyyddd four digit year, 3 digit day of year (INTEGER 7 digits)

    outputs:
    t: datetime

    http://stackoverflow.com/questions/2427555/python-question-year-and-day-of-year-to-date
    """"""
    if isinstance(yeardate, (tuple, list, np.ndarray)):
        if utsec is None:
            return np.asarray([yeardoy2datetime(y) for y in yeardate])
        elif isinstance(utsec, (tuple, list, np.ndarray)):
            return np.asarray([yeardoy2datetime(y, s) for y, s in zip(yeardate, utsec)])

    yeardate = int(yeardate)

    yd = str(yeardate)
    if len(yd) != 7:
        raise ValueError('yyyyddd expected')

    year = int(yd[:4])
    assert 0 < year < 3000, 'year not in expected format'

    dt = datetime.datetime(year, 1, 1) + datetime.timedelta(days=int(yd[4:]) - 1)
    assert isinstance(dt, datetime.datetime)

    if utsec is not None:
        dt += datetime.timedelta(seconds=utsec)

    return dt"
3385,"def date2doy(time: Union[str, datetime.datetime]) -> Tuple[int, int]:
    """"""
    < 366 for leap year too. normal year 0..364.  Leap 0..365.
    """"""

    T = np.atleast_1d(time)

    year = np.empty(T.size, dtype=int)
    doy = np.empty_like(year)

    for i, t in enumerate(T):
        yd = str(datetime2yeardoy(t)[0])

        year[i] = int(yd[:4])
        doy[i] = int(yd[4:])

    assert ((0 < doy) & (doy < 366)).all(), 'day of year must be 0 < doy < 366'

    return doy, year"
3386,"def datetime2gtd(time: Union[str, datetime.datetime, np.datetime64],
                 glon: Union[float, List[float], np.ndarray] = np.nan) -> Tuple[int, float, float]:
    """"""
    Inputs:
    time: Numpy 1-D array of datetime.datetime OR string for dateutil.parser.parse
    glon: Numpy 2-D array of geodetic longitudes (degrees)

    Outputs:
    iyd: day of year
    utsec: seconds from midnight utc
    stl: local solar time
    """"""
# %%
    T = np.atleast_1d(time)
    glon = np.asarray(glon)
    doy = np.empty_like(T, int)
    utsec = np.empty_like(T, float)
    stl = np.empty((T.size, *glon.shape))

    for i, t in enumerate(T):
        if isinstance(t, str):
            t = parse(t)
        elif isinstance(t, np.datetime64):
            t = t.astype(datetime.datetime)
        elif isinstance(t, (datetime.datetime, datetime.date)):
            pass
        else:
            raise TypeError('unknown time datatype {}'.format(type(t)))
# %% Day of year
        doy[i] = int(t.strftime('%j'))
# %% seconds since utc midnight
        utsec[i] = datetime2utsec(t)

        stl[i, ...] = utsec[i] / 3600. + glon / 15.

    return doy, utsec, stl"
3387,"def datetime2utsec(t: Union[str, datetime.date, datetime.datetime, np.datetime64]) -> float:
    """"""
    input: datetime
    output: float utc seconds since THIS DAY'S MIDNIGHT
    """"""
    if isinstance(t, (tuple, list, np.ndarray)):
        return np.asarray([datetime2utsec(T) for T in t])
    elif isinstance(t, datetime.date) and not isinstance(t, datetime.datetime):
        return 0.
    elif isinstance(t, np.datetime64):
        t = t.astype(datetime.datetime)
    elif isinstance(t, str):
        t = parse(t)

    return datetime.timedelta.total_seconds(t - datetime.datetime.combine(t.date(),
                                                                          datetime.datetime.min.time()))"
3388,"def yeardec2datetime(atime: float) -> datetime.datetime:
    """"""
    Convert atime (a float) to DT.datetime
    This is the inverse of datetime2yeardec.
    assert dt2t(t2dt(atime)) == atime

    http://stackoverflow.com/questions/19305991/convert-fractional-years-to-a-real-date-in-python
    Authored by ""unutbu"" http://stackoverflow.com/users/190597/unutbu

    In Python, go from decimal year (YYYY.YYY) to datetime,
    and from datetime to decimal year.
    """"""
# %%
    if isinstance(atime, (float, int)):  # typically a float

        year = int(atime)
        remainder = atime - year
        boy = datetime.datetime(year, 1, 1)
        eoy = datetime.datetime(year + 1, 1, 1)
        seconds = remainder * (eoy - boy).total_seconds()

        T = boy + datetime.timedelta(seconds=seconds)
        assert isinstance(T, datetime.datetime)
    elif isinstance(atime[0], float):
        return np.asarray([yeardec2datetime(t) for t in atime])
    else:
        raise TypeError('expecting float, not {}'.format(type(atime)))

    return T"
3389,"def datetime2yeardec(time: Union[str, datetime.datetime, datetime.date]) -> float:
    """"""
    Convert a datetime into a float. The integer part of the float should
    represent the year.
    Order should be preserved. If adate<bdate, then d2t(adate)<d2t(bdate)
    time distances should be preserved: If bdate-adate=ddate-cdate then
    dt2t(bdate)-dt2t(adate) = dt2t(ddate)-dt2t(cdate)
    """"""
    if isinstance(time, str):
        t = parse(time)
    elif isinstance(time, datetime.datetime):
        t = time
    elif isinstance(time, datetime.date):
        t = datetime.datetime.combine(time, datetime.datetime.min.time())
    elif isinstance(time, (tuple, list, np.ndarray)):
        return np.asarray([datetime2yeardec(t) for t in time])
    else:
        raise TypeError('unknown input type {}'.format(type(time)))

    year = t.year

    boy = datetime.datetime(year, 1, 1)
    eoy = datetime.datetime(year + 1, 1, 1)

    return year + ((t - boy).total_seconds() / ((eoy - boy).total_seconds()))"
3390,"def randomdate(year: int) -> datetime.date:
    """""" gives random date in year""""""
    if calendar.isleap(year):
        doy = random.randrange(366)
    else:
        doy = random.randrange(365)

    return datetime.date(year, 1, 1) + datetime.timedelta(days=doy)"
3391,"def init_arg_names(obj):
    """"""
    Names of arguments to __init__ method of this object's class.
    """"""
    # doing something wildly hacky by pulling out the arguments to
    # __init__ or __new__ and hoping that they match fields defined on the
    # object
    try:
        init_code = obj.__init__.__func__.__code__
    except AttributeError:
        try:
            init_code = obj.__new__.__func__.__code__
        except AttributeError:
            # if object is a namedtuple then we can return its fields
            # as the required initial args
            if hasattr(obj, ""_fields""):
                return obj._fields
            else:
                raise ValueError(""Cannot determine args to %s.__init__"" % (obj,))

    arg_names = init_code.co_varnames[:init_code.co_argcount]
    # drop self argument
    nonself_arg_names = arg_names[1:]
    return nonself_arg_names"
3392,"def function_to_serializable_representation(fn):
    """"""
    Converts a Python function into a serializable representation. Does not
    currently work for methods or functions with closure data.
    """"""
    if type(fn) not in (FunctionType, BuiltinFunctionType):
        raise ValueError(
            ""Can't serialize %s : %s, must be globally defined function"" % (
                fn, type(fn),))

    if hasattr(fn, ""__closure__"") and fn.__closure__ is not None:
        raise ValueError(""No serializable representation for closure %s"" % (fn,))

    return {""__module__"": get_module_name(fn), ""__name__"": fn.__name__}"
3393,"def dict_to_serializable_repr(x):
    """"""
    Recursively convert values of dictionary to serializable representations.
    Convert non-string keys to JSON representations and replace them in the
    dictionary with indices of unique JSON strings (e.g. __1, __2, etc..).
    """"""
    # list of JSON representations of hashable objects which were
    # used as keys in this dictionary
    serialized_key_list = []
    serialized_keys_to_names = {}
    # use the class of x rather just dict since we might want to convert
    # derived classes such as OrderedDict
    result = type(x)()
    for (k, v) in x.items():
        if not isinstance(k, string_types):
            # JSON does not support using complex types such as tuples
            # or user-defined objects with implementations of __hash__ as
            # keys in a dictionary so we must keep the serialized
            # representations of such values in a list and refer to indices
            # in that list
            serialized_key_repr = to_json(k)
            if serialized_key_repr in serialized_keys_to_names:
                k = serialized_keys_to_names[serialized_key_repr]
            else:
                k = index_to_serialized_key_name(len(serialized_key_list))
                serialized_keys_to_names[serialized_key_repr] = k
                serialized_key_list.append(serialized_key_repr)
        result[k] = to_serializable_repr(v)
    if len(serialized_key_list) > 0:
        # only include this list of serialized keys if we had any non-string
        # keys
        result[SERIALIZED_DICTIONARY_KEYS_FIELD] = serialized_key_list
    return result"
3394,"def from_serializable_dict(x):
    """"""
    Reconstruct a dictionary by recursively reconstructing all its keys and
    values.

    This is the most hackish part since we rely on key names such as
    __name__, __class__, __module__ as metadata about how to reconstruct
    an object.

    TODO: It would be cleaner to always wrap each object in a layer of type
    metadata and then have an inner dictionary which represents the flattened
    result of to_dict() for user-defined objects.
    """"""
    if ""__name__"" in x:
        return _lookup_value(x.pop(""__module__""), x.pop(""__name__""))

    non_string_key_objects = [
        from_json(serialized_key)
        for serialized_key
        in x.pop(SERIALIZED_DICTIONARY_KEYS_FIELD, [])
    ]
    converted_dict = type(x)()
    for k, v in x.items():
        serialized_key_index = parse_serialized_keys_index(k)
        if serialized_key_index is not None:
            k = non_string_key_objects[serialized_key_index]

        converted_dict[k] = from_serializable_repr(v)
    if ""__class__"" in converted_dict:
        class_object = converted_dict.pop(""__class__"")
        if ""__value__"" in converted_dict:
            return class_object(converted_dict[""__value__""])
        elif hasattr(class_object, ""from_dict""):
            return class_object.from_dict(converted_dict)
        else:
            return class_object(**converted_dict)
    return converted_dict"
3395,"def to_dict(obj):
    """"""
    If value wasn't isn't a primitive scalar or collection then it needs to
    either implement to_dict (instances of Serializable) or has member
    data matching each required arg of __init__.
    """"""
    if isinstance(obj, dict):
        return obj
    elif hasattr(obj, ""to_dict""):
        return obj.to_dict()
    try:
        return simple_object_to_dict(obj)
    except:
        raise ValueError(
            ""Cannot convert %s : %s to dictionary"" % (
                obj, type(obj)))"
3396,"def to_serializable_repr(x):
    """"""
    Convert an instance of Serializable or a primitive collection containing
    such instances into serializable types.
    """"""
    t = type(x)
    if isinstance(x, list):
        return list_to_serializable_repr(x)
    elif t in (set, tuple):
        return {
            ""__class__"": class_to_serializable_representation(t),
            ""__value__"": list_to_serializable_repr(x)
        }
    elif isinstance(x, dict):
        return dict_to_serializable_repr(x)
    elif isinstance(x, (FunctionType, BuiltinFunctionType)):
        return function_to_serializable_representation(x)
    elif type(x) is type:
        return class_to_serializable_representation(x)
    else:
        state_dictionary = to_serializable_repr(to_dict(x))
        state_dictionary[""__class__""] = class_to_serializable_representation(
            x.__class__)
        return state_dictionary"
3397,"def _convert_rules_bubble(self, srules=''):
        """"""srules, a string containing the rules in bubble format will be
        converted to the internal list of dictonary based rules.
        '>>>': seperator  : a rule has only certain amount of seperators
        a rule is built like: >>>input>>>function>>>output>>>
        for example:
        >>>i>>>adder>>>o>>>>
        >>>42>>>is_it_the_answer>>>the_answer>>>

        is converted to:
        [{'in':'i','fun':'adder','out':'o'},
         {'in':'42','fun':'is_it_the_answer','out':'the_answer'}]

        a rule withhout a name, but with a depency on rule_one
        >>>panic>>>is_there_an_answer>>>dont_panic>>>rule_one>>>

        a rule without depencies and a name
        >>>42>>>is_it_the_answer>>>the_answer>>>nodeps>>rule_one>>>
        """"""

        if not isinstance(srules, str):
            self.cry('convert_rules_bubble: cannot convert srules of type,' +
                     'list of rules ==> [] :' + str(type(srules)),
                     stuff=srules,
                     verbosity=10)
            return []

        if not srules:
            self.say('convert_rules_bubble: cannot convert empty srules',
                     verbosity=10)
            return []  # no rules

        lines = srules.splitlines()
        self.say('convert_rules_bubble:lines', stuff=lines, verbosity=10)

        line_number = 0
        rules = []
        for r in lines:
            line_number += 1
            # todo: do we wan't this in a configuration, yes! add magic!
            # in util.escaped it's defined as an escape
            # but for rules it is best to define a magic value something like
            # BMGC.TRANSFORMER.RULES_SEPERATOR  #seems better option for
            # or
            # BMGC.TRANSFORMER_RULES_SEPERATOR  #seems simpler
            # BMGC should implement a sane default magic for undefined values.

            r = r.strip()
            if not r.endswith('>>>'):
                continue
            if not r.startswith('>>>'):
                continue

            parts = [p.strip() for p in r.split('>>>')]

            rule = None
            lp = len(parts)
            if lp == 3:
                rule = Rule(input=parts[1],
                            src_nr=line_number)
            if lp == 4:
                rule = Rule(input=parts[1],
                            fun=parts[2],
                            src_nr=line_number)
            if lp == 5:
                rule = Rule(input=parts[1],
                            fun=parts[2],
                            output=parts[3],
                            src_nr=line_number)
            if lp == 6:
                rule = Rule(input=parts[1],
                            fun=parts[2],
                            output=parts[3],
                            depend=parts[4],
                            src_nr=line_number)
            if lp == 7:
                rule = Rule(input=parts[1],
                            fun=parts[2],
                            output=parts[3],
                            depend=parts[4],
                            name=parts[5],
                            src_nr=line_number)

            if rule:
                rules.append(rule)
            else:
                self.cry(
                    'parts not 3..7 rule with parts[' + str(lp) +
                    '] from line:[' + str(line_number) + ']\n\'' + r + '\'',
                    verbosity=10)

        for r in rules:
            r.set_parent(self)
        self._rules = rules
        self.say('convert_rules_bubble:res:rules', stuff=rules, verbosity=10)
        return rules"
3398,"def _combine_rest_push(self):
        """"""Combining Rest and Push States""""""
        new = []
        change = 0
        # DEBUG
        # logging.debug('Combining Rest and Push')
        i = 0
        examinetypes = self.quickresponse_types[3]
        for state in examinetypes:
            if state.type == 3:
                for nextstate_id in state.trans.keys():
                    found = 0
                    # if nextstate_id != state.id:
                    if nextstate_id in self.quickresponse:
                        examines = self.quickresponse[nextstate_id]
                        for examine in examines:
                            if examine.id == nextstate_id and examine.type == 1:
                                temp = PDAState()
                                temp.type = 1
                                temp.sym = examine.sym
                                temp.id = state.id
                                for nextnextstate_id in examine.trans:
                                    # if nextnextstate_id != examine.id :

                                    for x_char in state.trans[nextstate_id]:
                                        for z_char in examine.trans[
                                                nextnextstate_id]:
                                            if nextnextstate_id not in temp.trans:
                                                temp.trans[
                                                    nextnextstate_id] = []
                                            if x_char != 0 and z_char != 0:
                                                temp.trans[
                                                    nextnextstate_id].append(x_char + z_char)
                                                # DEBUGprint 'transition is now
                                                # '+x_char +' + '+ z_char
                                            elif x_char != 0 and z_char == 0:
                                                temp.trans[
                                                    nextnextstate_id].append(x_char)
                                                # DEBUGprint 'transition is now
                                                # '+x_char
                                            elif x_char == 0 and z_char != 0:
                                                temp.trans[
                                                    nextnextstate_id].append(z_char)
                                                # DEBUGprint 'transition is now
                                                # '+z_char
                                            elif x_char == 0 and z_char == 0:
                                                temp.trans[
                                                    nextnextstate_id].append(0)
                                                # DEBUGprint 'transition is now
                                                # empty'
                                            else:
                                                pass
                                found = 1
                                new.append(temp)

                    if found == 1:
                        # print 'Lets combine one with id '+`state.id`+'(rest)
                        # and one with id '+`nextstate_id`+'(push)'
                        change = 1
                        # del(state.trans[nextstate_id])
            i = i + 1
        if change == 0:
            return []
        else:
            return new"
3399,"def _check(self, accepted):
        """"""_check for string existence""""""
        # logging.debug('A check is now happening...')
        # for key in self.statediag[1].trans:
        #    logging.debug('transition to '+`key`+"" with ""+self.statediag[1].trans[key][0])
        total = []
        if 1 in self.quickresponse:
            total = total + self.quickresponse[1]
        if (1, 0) in self.quickresponse:
            total = total + self.quickresponse[(1, 0)]
        for key in total:
            if (key.id == 1 or key.id == (1, 0)) and key.type == 3:
                if accepted is None:
                    if 2 in key.trans:
                        # print 'Found'
                        return key.trans[2]
                else:
                    for state in accepted:
                        if (2, state) in key.trans:
                            # print 'Found'
                            return key.trans[(2, state)]
        return -1"
3400,"def _stage(self, accepted, count=0):
        """"""This is a repeated state in the state removal algorithm""""""
        new5 = self._combine_rest_push()
        new1 = self._combine_push_pop()
        new2 = self._combine_push_rest()
        new3 = self._combine_pop_rest()
        new4 = self._combine_rest_rest()
        new = new1 + new2 + new3 + new4 + new5
        del new1
        del new2
        del new3
        del new4
        del new5
        if len(new) == 0:
            # self.printer()
            # print 'PDA is empty'
            # logging.debug('PDA is empty')
            return None

        self.statediag = self.statediag + new
        del new
        # print 'cleaning...'

        # It is cheaper to create a new array than to use the old one and
        # delete a key
        newstates = []
        for key in self.statediag:
            if len(key.trans) == 0 or key.trans == {}:
                # rint 'delete '+`key.id`
                # self.statediag.remove(key)
                pass
            else:
                newstates.append(key)

        del self.statediag
        self.statediag = newstates
        self.quickresponse = {}
        self.quickresponse_types = {}
        self.quickresponse_types[0] = []
        self.quickresponse_types[1] = []
        self.quickresponse_types[2] = []
        self.quickresponse_types[3] = []
        self.quickresponse_types[4] = []
        for state in self.statediag:
            if state.id not in self.quickresponse:
                self.quickresponse[state.id] = [state]
            else:
                self.quickresponse[state.id].append(state)
            self.quickresponse_types[state.type].append(state)

            # else:
            #     print `key.id`+' (type: '+`key.type`+' and sym:'+`key.sym`+')'
            #     print key.trans
        # print 'checking...'
        exists = self._check(accepted)
        if exists == -1:
            # DEBUGself.printer()
            # raw_input('next step?')
            return self._stage(accepted, count + 1)
        else:
            # DEBUGself.printer()
            # print 'Found '
            print exists
            # return self._stage(accepted, count+1)
            return exists"
3401,"def printer(self):
        """"""Visualizes the current state""""""
        for key in self.statediag:
            if key.trans is not None and len(key.trans) > 0:
                print '****** ' + repr(key.id) + '(' + repr(key.type)\
                      + ' on sym ' + repr(key.sym) + ') ******'
                print key.trans"
3402,"def init(self, states, accepted):
        """"""Initialization of the indexing dictionaries""""""
        self.statediag = []
        for key in states:
            self.statediag.append(states[key])
        self.quickresponse = {}
        self.quickresponse_types = {}
        self.quickresponse_types[0] = []
        self.quickresponse_types[1] = []
        self.quickresponse_types[2] = []
        self.quickresponse_types[3] = []
        self.quickresponse_types[4] = []
        for state in self.statediag:
            if state.id not in self.quickresponse:
                self.quickresponse[state.id] = [state]
            else:
                self.quickresponse[state.id].append(state)
            self.quickresponse_types[state.type].append(state)
        # self.printer()
        # raw_input('next stepA?')
        return self._stage(accepted, 0)"
3403,"def execute(filelocation, outpath, executable, args=None, switchArgs=None):
    """"""Executes the dinosaur tool on Windows operating systems.

    :param filelocation: either a single mgf file path or a list of file paths.
    :param outpath: path of the output file, file must not exist
    :param executable: must specify the complete file path of the
        spectra-cluster-cli.jar file, supported version is 1.0.2 BETA.
    :param args: list of arguments containing a value, for details see the
        spectra-cluster-cli help. Arguments should be added as tuples or a list.
        For example: [('precursor_tolerance', '0.5'), ('rounds', '3')]
    :param switchArgs: list of arguments not containing a value, for details see
        the spectra-cluster-cli help. Arguments should be added as strings.
        For example: ['fast_mode', 'keep_binary_files']
    """"""
    procArgs = ['java', '-jar', executable]
    procArgs.extend(['-output_path', outpath])
    if args is not None:
        for arg in args:
            procArgs.extend(['-'+arg[0], arg[1]])
    if switchArgs is not None:
        procArgs.extend(['-'+arg for arg in switchArgs])

    procArgs.extend(aux.toList(filelocation))

    ## run it ##
    proc = subprocess.Popen(procArgs, stderr=subprocess.PIPE)

    ## But do not wait till netstat finish, start displaying output immediately ##
    while True:
        out = proc.stderr.read(1)
        if out == '' and proc.poll() != None:
            break
        if out != '':
            sys.stdout.write(out)
            sys.stdout.flush()"
3404,"def generate_example():
    """"""Generate a configuration file example.

    This utility will load some number of Python modules which are assumed
    to register options with confpy and generate an example configuration file
    based on those options.
    """"""
    cmd_args = sys.argv[1:]
    parser = argparse.ArgumentParser(description='Confpy example generator.')
    parser.add_argument(
        '--module',
        action='append',
        help='A python module which should be imported.',
    )
    parser.add_argument(
        '--file',
        action='append',
        help='A python file which should be evaled.',
    )
    parser.add_argument(
        '--format',
        default='JSON',
        choices=('JSON', 'INI'),
        help='The output format of the configuration file.',
    )

    args = parser.parse_args(cmd_args)

    for module in args.module or ():

        __import__(module)

    for source_file in args.file or ():

        cfg = pyfile.PythonFile(path=source_file).config

    cfg = config.Configuration()

    print(example.generate_example(cfg, ext=args.format))"
3405,"def count(self, val=True):
        """"""Get the number of bits in the array with the specified value.

        Args:
            val: A boolean value to check against the array's value.

        Returns:
            An integer of the number of bits in the array equal to val.
        """"""
        return sum((elem.count(val) for elem in self._iter_components()))"
3406,"def prepare(self, *, primef, reqef):
        """"""Extract the composite array's data into a usable bitarray based on if NoCare bits should be rendered as True or False.

        This method does the heavy lifting of producing a bitarray
        that is more efficient for tdo bits when that optimization is
        available.

        KWArgs:
            primef: A contracts.Requirement capability of the associated primitive.
            reqef: A contracts.Requirement (generated from primitive compilation) describing the signal requirements of the data in this CompositeBitarray.

        Returns:
            A bitarray (CompositeBitarray, ConstantBitarray, etc) that
            is the combined result of all the composite bitarray's
            components. If this CompositeBitarray's backing linked
            list can be merged into a single node, that single node is
            returned. Otherwise, this CompositeBitarray is returned.

        """"""
        #TODO remove bitarray copies!
        if not primef.satisfies(reqef):
            raise Exception(""Compiler error. Requested effect can not be ""
                            ""satisfied by primitive capabilities"")
        assertPreferFalse = reqef == ZERO or primef == ARBITRARY or\
                            (reqef == NOCARE and primef == ZERO)
        testBitarrayFalse = reqef==ZERO or\
                            (reqef==NOCARE and primef==ZERO)
        testBitarrayTrue = reqef==ONE or (reqef==NOCARE and primef==ONE)
        assert not (testBitarrayTrue and testBitarrayFalse)

        #print(""DATA"", self)
        #print(""ORIG"", [""%s(%s:%s)""%
        #       (type(elem.value).__name__,
        #        elem.value._val if isinstance(elem.value,
        #                                      ConstantBitarray)\
        #        else ""_"", len(elem.value))
        #       for elem in self._llhead.iternexttill(self._lltail)])

        if self._offset or self._tailoffset:
            if self._is_single_llnode:
                if isinstance(self._llhead.value, (ConstantBitarray,
                                             NoCareBitarray,
                                             PreferFalseBitarray)):
                    oldnode = self._llhead
                    if self._offset == 0:
                        oldnode.prev = None
                    if self._tailoffset == 0:
                        oldnode.next = None
                    self._llhead = _DLLNode(
                        oldnode.value[self._offset:\
                                      self._offset+self._tailbitsused])
                    self._lltail = self._llhead
                    self._offset = 0
                    self._tailbitsused = self._taillen

                elif isinstance(self._llhead.value, bitarray):
                    if testBitarrayFalse or testBitarrayTrue:
                        oldnode = self._llhead
                        newval = oldnode.value[self._offset:
                                               self._offset+self._tailbitsused]
                        if testBitarrayFalse:
                            if not newval.any():
                                newval = ConstantBitarray(False, len(newval))
                            else:
                                raise Exception(""bitarray in data contains a 1"")
                        if testBitarrayTrue:
                            if newval.all():
                                newval = ConstantBitarray(True, len(newval))
                            else:
                                raise Exception(""bitarray in data contains a 0"")

                        self._llhead = _DLLNode(newval)
                        self._lltail = self._llhead
                        self._offset = 0
                        self._tailbitsused = self._taillen

            else: #IF HEAD IS NOT TAIL; OFFSET OR TAILOFFSET
                if self._offset:
                    if isinstance(self._llhead.value,
                                  (ConstantBitarray, NoCareBitarray,
                                   PreferFalseBitarray)):
                        oldhead = self._llhead
                        self._llhead = _DLLNode(
                            oldhead.value[self._offset:])
                        self._llhead.next = oldhead.next
                        oldhead.next = None
                        self._offset = 0
                    elif isinstance(self._llhead.value, bitarray):
                        oldhead = self._llhead
                        newval = oldhead.value[self._offset:]
                        if testBitarrayFalse:
                            if not newval.any():
                                newval = ConstantBitarray(False, len(newval))
                            else:
                                raise Exception(""bitarray in data contains a 1"")
                        if testBitarrayTrue:
                            if newval.all():
                                newval = ConstantBitarray(True, len(newval))
                            else:
                                raise Exception(""bitarray in data contains a 0"")

                        self._llhead = _DLLNode(newval)
                        self._llhead.next = oldhead.next
                        oldhead.next = None
                        self._offset = 0

                if self._tailoffset:#IF HEAD IS NOT TAIL AND TAILOFFSET
                    if isinstance(self._lltail.value,
                                  (ConstantBitarray, NoCareBitarray,
                                   PreferFalseBitarray)):
                        oldtail = self._lltail
                        self._lltail = _DLLNode(
                            oldtail.value[:self._tailbitsused])
                        self._lltail.prev = oldtail.prev
                        oldtail.prev = None
                        self._tailbitsused = self._taillen
                    elif isinstance(self._lltail.value, bitarray):
                        oldtail = self._lltail
                        newval = oldtail.value[:self._tailbitsused]
                        if testBitarrayFalse:
                            if not newval.any():
                                newval = ConstantBitarray(False, len(newval))
                            else:
                                raise Exception(""bitarray in data contains a 1"")
                        if testBitarrayTrue:
                            if newval.all():
                                newval = ConstantBitarray(True, len(newval))
                            else:
                                raise Exception(""bitarray in data contains a 0"")

                        self._lltail = _DLLNode(newval)
                        self._lltail.prev = oldtail.prev
                        oldtail.prev = None
                        self._tailbitsused = self._taillen


        for elem in self._llhead.iternexttill(self._lltail):
            if isinstance(elem.value, PreferFalseBitarray):
                if assertPreferFalse:
                    elem._value = ConstantBitarray(False, len(elem.value))
                else:
                    elem._value = NoCareBitarray(len(elem.value))
            if isinstance(elem.value, bitarray):
                if testBitarrayFalse:
                    if not elem.value.any():
                        elem.value = ConstantBitarray(False,
                                                      len(elem.value))
                    else:
                        raise Exception(""bitarray in data contains a 1"")
                if testBitarrayTrue:
                    if elem.value.all():
                        elem.value = ConstantBitarray(True,
                                                      len(elem.value))
                    else:
                        raise Exception(""bitarray in data contains a 0"")


        #print(""TRAN"", [""%s(%s:%s)""%
        #       (type(elem.value).__name__,
        #        elem.value._val if isinstance(elem.value,
        #                                      ConstantBitarray)\
        #        else ""_"", len(elem.value))
        #       for elem in self._llhead.iternexttill(self._lltail)])



        if not self._is_single_llnode and\
           (self._lltail.next is not self._llhead or\
            (self._offset == 0 and self._tailbitsused == self._taillen)
            ):
            self._do_merge(stoponfail=False)

        #print(""\033[1mPOST"", ""+ "".join([""%s%s(%s:%s)\033[0m""%
        #       ('\033[91m' if isinstance(elem.value, bitarray) else
        #        ('\033[94m' if isinstance(elem.value,
        #                            (NoCareBitarray, PreferFalseBitarray))
        #         else '\033[92m'),type(elem.value).__name__,
        #        elem.value._val if isinstance(elem.value,
        #                                      ConstantBitarray)\
        #        else (elem.value.to01() if isinstance(elem.value,
        #                                              bitarray)
        #              else ""_""), len(elem.value))
        #       for elem in self._llhead.iternexttill(self._lltail)]))
        if self._is_single_llnode and self._offset == 0 and\
           self._tailbitsused == self._taillen:
            if isinstance(self._llhead.value, (NoCareBitarray,
                                               PreferFalseBitarray)):
                return ConstantBitarray(False, len(self._llhead.value))
            return self._llhead.value
        return self"
3407,"def _api_group_for_type(cls):
    """"""
    Determine which Kubernetes API group a particular PClass is likely to
    belong with.

    This is basically nonsense.  The question being asked is wrong.  An
    abstraction has failed somewhere.  Fixing that will get rid of the need
    for this.
    """"""
    _groups = {
        (u""v1beta1"", u""Deployment""): u""extensions"",
        (u""v1beta1"", u""DeploymentList""): u""extensions"",
        (u""v1beta1"", u""ReplicaSet""): u""extensions"",
        (u""v1beta1"", u""ReplicaSetList""): u""extensions"",
    }
    key = (
        cls.apiVersion,
        cls.__name__.rsplit(u""."")[-1],
    )
    group = _groups.get(key, None)
    return group"
3408,"def response(request, status, obj):
    """"""
    Generate a response.

    :param IRequest request: The request being responsed to.
    :param int status: The response status code to set.
    :param obj: Something JSON-dumpable to write into the response body.

    :return bytes: The response body to write out.  eg, return this from a
        *render_* method.
    """"""
    request.setResponseCode(status)
    request.responseHeaders.setRawHeaders(
        u""content-type"", [u""application/json""],
    )
    body = dumps_bytes(obj)
    return body"
3409,"def create(self, collection_name, obj):
        """"""
        Create a new object in the named collection.

        :param unicode collection_name: The name of the collection in which to
            create the object.

        :param IObject obj: A description of the object to create.

        :return _KubernetesState: A new state based on the current state but
            also containing ``obj``.
        """"""
        obj = self.agency.before_create(self, obj)
        new = self.agency.after_create(self, obj)
        updated = self.transform(
            [collection_name],
            lambda c: c.add(new),
        )
        return updated"
3410,"def replace(self, collection_name, old, new):
        """"""
        Replace an existing object with a new version of it.

        :param unicode collection_name: The name of the collection in which to
            replace an object.

        :param IObject old: A description of the object being replaced.

        :param IObject new: A description of the object to take the place of
            ``old``.

        :return _KubernetesState: A new state based on the current state but
            also containing ``obj``.
        """"""
        self.agency.before_replace(self, old, new)
        updated = self.transform(
            [collection_name],
            lambda c: c.replace(old, new),
        )
        return updated"
3411,"def delete(self, collection_name, obj):
        """"""
        Delete an existing object.

        :param unicode collection_name: The name of the collection from which
            to delete the object.

        :param IObject obj: A description of the object to delete.

        :return _KubernetesState: A new state based on the current state but
            not containing ``obj``.
        """"""
        updated = self.transform(
            [collection_name],
            lambda c: obj.delete_from(c),
        )
        return updated"
3412,"def get_list_connections(self, environment, product, unique_name_list=None, is_except=False):
        """"""
        Gets list of connections that satisfy the filter by environment, product and (optionally) unique DB names
        :param environment: Environment name
        :param product: Product name
        :param unique_name_list: list of unique db aliases
        :param is_except: take the connections with aliases provided or, the other wat around, take all the rest
        :return: list of dictionaries with connections
        """"""
        return_list = []
        for item in self.connection_sets:
            if unique_name_list:
                if item['unique_name']:
                    if is_except:
                        if item['environment'] == environment and item['product'] == product and \
                                (item['unique_name'] not in unique_name_list):
                            return_list.append(item)
                    elif not is_except:
                        if item['environment'] == environment and item['product'] == product and \
                                (item['unique_name'] in unique_name_list):
                            return_list.append(item)
            else:
                if item['environment'] == environment and item['product'] == product:
                    return_list.append(item)
        return return_list"
3413,"def set_address():
    """"""Set the (host, port) to connect to from the environment.

    If the environment is updated, a call to this function will update the
    address this client connects to.

    This function will prefer to use the ``STATSD`` connection string
    environment variable, but will fall back to using the ``STATSD_HOST``
    and ``STATSD_PORT``.

    """"""
    global STATSD_ADDR
    connection_string = os.getenv('STATSD')
    if connection_string:
        url = urlparse.urlparse(connection_string)
        STATSD_ADDR = (url.hostname, url.port)
    else:
        STATSD_ADDR = (os.getenv('STATSD_HOST', 'localhost'),
                       int(os.getenv('STATSD_PORT', 8125)))"
3414,"def execution_timer(value):
    """"""The ``execution_timer`` decorator allows for easy instrumentation of
    the duration of function calls, using the method name in the key.

    The following example would add duration timing with the key ``my_function``

    .. code: python

        @statsd.execution_timer
        def my_function(foo):
            pass


    You can also have include a string argument value passed to your method as
    part of the key. Pass the index offset of the arguments to specify the
    argument number to use. In the following example, the key would be
    ``my_function.baz``:

    .. code:python

        @statsd.execution_timer(2)
        def my_function(foo, bar, 'baz'):
            pass

    """"""
    def _invoke(method, key_arg_position, *args, **kwargs):
        start_time = time.time()
        result = method(*args, **kwargs)
        duration = time.time() - start_time

        key = [method.func_name]
        if key_arg_position is not None:
            key.append(args[key_arg_position])
        add_timing('.'.join(key), value=duration)
        return result

    if type(value) is types.FunctionType:
        def wrapper(*args, **kwargs):
            return _invoke(value, None, *args, **kwargs)
        return wrapper
    else:
        def duration_decorator(func):
            def wrapper(*args, **kwargs):
                return _invoke(func, value, *args, **kwargs)
            return wrapper
        return duration_decorator"
3415,"def _send(key, value, metric_type):
    """"""Send the specified value to the statsd daemon via UDP without a
    direct socket connection.

    :param str value: The properly formatted statsd counter value

    """"""
    if STATSD_PREFIX:
        key = '.'.join([STATSD_PREFIX, key])
    try:
        STATSD_SOCKET.sendto('{0}:{1}|{2}'.format(key,
                                                  value,
                                                  metric_type).encode(),
                             STATSD_ADDR)
    except socket.error:
        LOGGER.exception(SOCKET_ERROR)"
3416,"def type_names(prefix, sizerange):
        """"""
        Helper for type name generation, like: bytes1 .. bytes32
        """"""
        namelist = []
        for i in sizerange: namelist.append(prefix + str(i))
        return tuple(namelist)"
3417,"def type_names_mn(prefix, sizerangem, sizerangen):
        """"""
        Helper for type name generation, like: fixed0x8 .. fixed0x256
        """"""
        lm = []
        ln = []
        namelist = []

        # construct lists out of ranges
        for i in sizerangem: lm.append(i)
        for i in sizerangen: ln.append(i)

        # sizes (in bits) are valid if (%8 == 0) and (m+n <= 256)
        # first condition is covered by passing proper sizerange{m,n}
        validpairs = [tuple([m,n]) for m in lm for n in ln if m+n<=256]
        for i in validpairs:
            namelist.append(prefix + str(i[0]) + 'x' + str(i[1]))

        return tuple(namelist)"
3418,"def _get_lang(self, *args, **kwargs):
        """""" Let users select language
        """"""
        if ""lang"" in kwargs:
            if kwargs[""lang""] in self._available_languages:
                self.lang = kwargs[""lang""]"
3419,"def notify(self, msg, color='green', notify='true', message_format='text'):
        """"""Send notification to specified HipChat room""""""
        self.message_dict = {
            'message': msg,
            'color': color,
            'notify': notify,
            'message_format': message_format,
        }
        if not self.debug:
            return requests.post(
                self.notification_url,
                json.dumps(self.message_dict),
                headers=self.headers
            )
        else:
            print('HipChat message: <{}>'.format(msg))
            return []"
3420,"def trial(path=TESTS_PATH, coverage=False):
    """"""Run tests using trial
    """"""
    args = ['trial']
    if coverage:
        args.append('--coverage')
    args.append(path)
    print args
    local(' '.join(args))"
3421,"def process_result_value(self, value, dialect):
        """"""
        When SQLAlchemy gets the string representation from a ReprObjType
        column, it converts it to the python equivalent via exec.
        """"""
        if value is not None:
            cmd = ""value = {}"".format(value)
            exec(cmd)
        return value"
3422,"def make_regex(separator):
    """"""Utility function to create regexp for matching escaped separators
    in strings.

    """"""
    return re.compile(r'(?:' + re.escape(separator) + r')?((?:[^' +
                      re.escape(separator) + r'\\]|\\.)+)')"
3423,"def strip_comments(text):
    """"""Comment stripper for JSON.

    """"""
    regex = r'\s*(#|\/{2}).*$'
    regex_inline = r'(:?(?:\s)*([A-Za-z\d\.{}]*)|((?<=\"").*\""),?)(?:\s)*(((#|(\/{2})).*)|)$'  # noqa
    lines = text.split('\n')

    for index, line in enumerate(lines):
        if re.search(regex, line):
            if re.search(r'^' + regex, line, re.IGNORECASE):
                lines[index] = """"
            elif re.search(regex_inline, line):
                lines[index] = re.sub(regex_inline, r'\1', line)

    return '\n'.join(lines)"
3424,"def register(action):
        """"""Action registration is used to support generating lists of
        permitted actions from a permission set and an object pattern.
        Only registered actions will be returned by such queries.

        """"""
        if isinstance(action, str):
            Action.register(Action(action))
        elif isinstance(action, Action):
            Action.registered.add(action)
        else:
            for a in action:
                Action.register(a)"
3425,"def add(self, effect=None, act=None, obj=None,
            policy=None, policies=None):
        """"""Insert an individual (effect, action, object) triple or all
        triples for a policy or list of policies.

        """"""
        if policies is not None:
            for p in policies:
                self.add(policy=p)
        elif policy is not None:
            for e, a, o in policy:
                self.add(e, a, o)
        else:
            objc = obj.components if obj is not None else []
            self.tree[act.components + objc] = effect"
3426,"def allow(self, act, obj=None):
        """"""Determine where a given action on a given object is allowed.

        """"""
        objc = obj.components if obj is not None else []
        try:
            return self.tree[act.components + objc] == 'allow'
        except KeyError:
            return False"
3427,"def permitted_actions(self, obj=None):
        """"""Determine permitted actions for a given object pattern.

        """"""
        return [a for a in Action.registered
                if self.allow(a, obj(str(a)) if obj is not None else None)]"
3428,"def subscribe(ws):
    """"""WebSocket endpoint, used for liveupdates""""""
    while ws is not None:
        gevent.sleep(0.1)
        try:
            message = ws.receive()  # expect function name to subscribe to
            if message:
                stream.register(ws, message)
        except WebSocketError:
            ws = None"
3429,"def could_scope_out(self):
        """"""
        could bubble up from current scope

        :return:
        """"""
        return not self.waiting_for or \
               isinstance(self.waiting_for, callable.EndOfStory) or \
               self.is_breaking_a_loop()"
3430,"def get_child_story(self):
        logger.debug('# get_child_story')
        """"""
        try child story that match message and get scope of it
        :return:
        """"""
        story_loop = self.compiled_story()
        if hasattr(story_loop, 'children_matcher') and not self.matched:
            return self.get_story_scope_child(story_loop)

        story_part = self.get_current_story_part()

        if not hasattr(story_part, 'get_child_by_validation_result'):
            logger.debug('# does not have get_child_by_validation_result')
            return None

        if isinstance(self.waiting_for, forking.SwitchOnValue):
            logger.debug('# switch on value')
            return story_part.get_child_by_validation_result(self.waiting_for.value)

        # for some base classes we could try validate result direct
        child_story = story_part.get_child_by_validation_result(self.waiting_for)
        if child_story:
            logger.debug('# child_story')
            logger.debug(child_story)
            return child_story

        stack_tail = self.stack_tail()
        if stack_tail['data'] is not None and not self.matched:
            validator = matchers.deserialize(stack_tail['data'])
            logger.debug('# validator')
            logger.debug(validator)
            logger.debug('# self.message')
            logger.debug(self.message)
            validation_result = validator.validate(self.message)
            logger.debug('# validation_result')
            logger.debug(validation_result)
            res = story_part.get_child_by_validation_result(validation_result)
            logger.debug('# res')
            logger.debug(res)
            # or we validate message
            # but can't find right child story
            # maybe we should use independent validators for each story here
            if res is None:
                return self.get_story_scope_child(story_part)
            else:
                return res

        return None"
3431,"def is_waiting_for_input(self):
        """"""
        could make one step further
        :return:
        """"""
        return self.waiting_for and \
               not isinstance(self.waiting_for, forking.SwitchOnValue) and \
               not is_base_type(self.waiting_for)"
3432,"def alias(self):
        """""" If the _alias cache is None, just build the alias from the item
        name.
        """"""
        if self._alias is None:
            if self.name in self.aliases_fix:
                self._alias = self.aliases_fix[self.name]
            else:
                self._alias = self.name.lower()\
                                  .replace(' ', '-')\
                                  .replace('(', '')\
                                  .replace(')', '')
        return self._alias"
3433,"def load_configs(self, conf_file):
        """"""
        Assumes that the config file does not have any sections, so throw it all in global
        """"""
        with open(conf_file) as stream:
            lines = itertools.chain((""[global]"",), stream)
            self._config.read_file(lines)
        return self._config['global']"
3434,"def remove_quotes(self, configs):
        """"""
        Because some values are wraped in single quotes
        """"""
        for key in configs:
            value = configs[key]
            if value[0] == ""'"" and value[-1] == ""'"":
                configs[key] = value[1:-1]
        return configs"
3435,"def multikey_sort(items, columns):
    """"""Source: https://stackoverflow.com/questions/1143671/python-sorting-list-of-dictionaries-by-multiple-keys
    """"""
    comparers = [
        ((itemgetter(col[1:].strip()), -1) if col.startswith('-') else (itemgetter(col.strip()), 1))
        for col in columns
    ]

    def cmp(a, b):
        return (a > b) - (a < b)

    def comparer(left, right):
        comparer_iter = (
            cmp(fn(left), fn(right)) * mult
            for fn, mult in comparers
        )
        return next((result for result in comparer_iter if result), 0)
    return sorted(items, key=cmp_to_key(comparer))"
3436,"def sanitize(string):
    """"""
    Catch and replace invalid path chars
    [replace, with]
    """"""
    replace_chars = [
        ['\\', '-'], [':', '-'], ['/', '-'],
        ['?', ''], ['<', ''], ['>', ''],
        ['`', '`'], ['|', '-'], ['*', '`'],
        ['""', '\''], ['.', ''], ['&', 'and']
    ]
    for ch in replace_chars:
        string = string.replace(ch[0], ch[1])
    return string"
3437,"def chunks_of(max_chunk_size, list_to_chunk):
    """"""
    Yields the list with a max size of max_chunk_size
    """"""
    for i in range(0, len(list_to_chunk), max_chunk_size):
        yield list_to_chunk[i:i + max_chunk_size]"
3438,"def split_into(max_num_chunks, list_to_chunk):
    """"""
    Yields the list with a max total size of max_num_chunks
    """"""
    max_chunk_size = math.ceil(len(list_to_chunk) / max_num_chunks)
    return chunks_of(max_chunk_size, list_to_chunk)"
3439,"def norm_path(path):
    """"""
    :return: Proper path for os with vars expanded out
    """"""
    # path = os.path.normcase(path)
    path = os.path.expanduser(path)
    path = os.path.expandvars(path)
    path = os.path.normpath(path)
    return path"
3440,"def create_hashed_path(base_path, name, depth=2):
    """"""
    Create a directory structure using the hashed filename
    :return: string of the path to save to not including filename/ext
    """"""
    if depth > 16:
        logger.warning(""depth cannot be greater then 16, setting to 16"")
        depth = 16

    name_hash = hashlib.md5(str(name).encode('utf-8')).hexdigest()
    if base_path.endswith(os.path.sep):
        save_path = base_path
    else:
        save_path = base_path + os.path.sep
    for i in range(1, depth + 1):
        end = i * 2
        start = end - 2
        save_path += name_hash[start:end] + os.path.sep

    return {'path': save_path,
            'hash': name_hash,
            }"
3441,"def create_path(path, is_dir=False):
    """"""
    Check if path exists, if not create it
    :param path: path or file to create directory for
    :param is_dir: pass True if we are passing in a directory, default = False
    :return: os safe path from `path`
    """"""
    path = norm_path(path)
    path_check = path
    if not is_dir:
        path_check = os.path.dirname(path)

    does_path_exists = os.path.exists(path_check)

    if does_path_exists:
        return path

    try:
        os.makedirs(path_check)
    except OSError:
        pass

    return path"
3442,"def rate_limited(num_calls=1, every=1.0):
    """"""
    Source: https://github.com/tomasbasham/ratelimit/tree/0ca5a616fa6d184fa180b9ad0b6fd0cf54c46936
    Need to make a few changes that included having num_calls be a float

    Prevent a method from being called
    if it was previously called before
    a time widows has elapsed.

    Keyword Arguments:
        num_calls (float): Maximum method invocations within a period. Must be greater than 0.
        every (float): A dampening factor (in seconds). Can be any number greater than 0.

    Return:
        function: Decorated function that will forward method invocations if the time window has elapsed.

    """"""
    frequency = abs(every) / float(num_calls)
    def decorator(func):
        """"""
        Extend the behaviour of the following
        function, forwarding method invocations
        if the time window hes elapsed.
        Arguments:
            func (function): The function to decorate

        Returns:
            function: Decorated function

        """"""

        # To get around issues with function local scope
        # and reassigning variables, we wrap the time
        # within a list. When updating the value we're
        # not reassigning `last_called`, which would not
        # work, but instead reassigning the value at a
        # particular index.
        last_called = [0.0]

        # Add thread safety
        lock = threading.RLock()

        def wrapper(*args, **kargs):
            """"""Decorator wrapper function""""""
            with lock:
                elapsed = time.time() - last_called[0]
                left_to_wait = frequency - elapsed
                if left_to_wait > 0:
                    time.sleep(left_to_wait)
                last_called[0] = time.time()
            return func(*args, **kargs)
        return wrapper
    return decorator"
3443,"def rate_limited_old(max_per_second):
    """"""
    Source: https://gist.github.com/gregburek/1441055
    """"""
    lock = threading.Lock()
    min_interval = 1.0 / max_per_second

    def decorate(func):
        last_time_called = time.perf_counter()

        @wraps(func)
        def rate_limited_function(*args, **kwargs):
            lock.acquire()
            nonlocal last_time_called
            try:
                elapsed = time.perf_counter() - last_time_called
                left_to_wait = min_interval - elapsed
                if left_to_wait > 0:
                    time.sleep(left_to_wait)

                return func(*args, **kwargs)
            finally:
                last_time_called = time.perf_counter()
                lock.release()

        return rate_limited_function

    return decorate"
3444,"def timeit(stat_tracker_func, name):
    """"""
    Pass in a function and the name of the stat
    Will time the function that this is a decorator to and send
    the `name` as well as the value (in seconds) to `stat_tracker_func`

    `stat_tracker_func` can be used to either print out the data or save it
    """"""
    def _timeit(func):
        def wrapper(*args, **kw):
            start_time = time.time()
            result = func(*args, **kw)
            stop_time = time.time()
            stat_tracker_func(name, stop_time - start_time)

            return result
        return wrapper

    return _timeit"
3445,"def get_proxy_parts(proxy):
    """"""
    Take a proxy url and break it up to its parts
    """"""
    proxy_parts = {'schema': None,
                   'user': None,
                   'password': None,
                   'host': None,
                   'port': None,
                   }
    # Find parts
    results = re.match(proxy_parts_pattern, proxy)
    if results:
        matched = results.groupdict()
        for key in proxy_parts:
            proxy_parts[key] = matched.get(key)

    else:
        logger.error(""Invalid proxy format `{proxy}`"".format(proxy=proxy))

    if proxy_parts['port'] is None:
        proxy_parts['port'] = '80'

    return proxy_parts"
3446,"def remove_html_tag(input_str='', tag=None):
    """"""
    Returns a string with the html tag and all its contents from a string
    """"""
    result = input_str
    if tag is not None:
        pattern = re.compile('<{tag}[\s\S]+?/{tag}>'.format(tag=tag))
        result = re.sub(pattern, '', str(input_str))

    return result"
3447,"def asodict(self, handlepoints=True, reportpoints=True):
        """"""Returns an ordered dictionary of handle/report points""""""
        out = odict()
        if handlepoints:
            for hp in self.handlepoints:
                out[hp.hpoint] = hp.trace
        if reportpoints:
            for rp in self.reportpoints:
                if not (rp.rpoint in out):
                    out[rp.rpoint] = odict()
                out[rp.rpoint][self.attribute] = {'value' : rp.value, 'extended': rp.extended}
        return out"
3448,"def asodict(self, freports=True, handlepoints=True, reportpoints=True):
        """"""Returns an ordered dictionary of feed, and handle/report points""""""
        out = odict()
        if freports:
            for fr in self.freports:
                out[fr.num] = {'tstamp' : fr.tstamp, 
                               'report' : fr.asodict(handlepoints, reportpoints)}           
        if handlepoints:
            for hp in self.handlepoints:
                out[hp.hpoint] = hp.trace
        if reportpoints:
            for rp in self.reportpoints:
                if not (rp.rpoint in out):
                    out[rp.rpoint] = odict()
                out[rp.rpoint][self.attribute] = {'value' : rp.value, 'extended': rp.extended}
        return out"
3449,"def ip_between(ip, start, finish):
    """"""Checks to see if IP is between start and finish""""""

    if is_IPv4Address(ip) and is_IPv4Address(start) and is_IPv4Address(finish):
        return IPAddress(ip) in IPRange(start, finish)
    else:
        return False"
3450,"def is_rfc1918(ip):
    """"""Checks to see if an IP address is used for local communications within
    a private network as specified by RFC 1918
    """"""
    if ip_between(ip, ""10.0.0.0"", ""10.255.255.255""):
        return True
    elif ip_between(ip, ""172.16.0.0"", ""172.31.255.255""):
        return True
    elif ip_between(ip, ""192.168.0.0"", ""192.168.255.255""):
        return True
    else:
        return False"
3451,"def is_reserved(ip):
    """"""Checks to see if an IP address is reserved for special purposes. This includes
    all of the RFC 1918 addresses as well as other blocks that are reserved by
    IETF, and IANA for various reasons.

    https://en.wikipedia.org/wiki/Reserved_IP_addresses
    """"""
    if ip_between(ip, ""0.0.0.0"", ""0.255.255.255""):
        return True
    elif ip_between(ip, ""10.0.0.0"", ""10.255.255.255""):
        return True
    elif ip_between(ip, ""100.64.0.0"", ""100.127.255.255""):
        return True
    elif ip_between(ip, ""127.0.0.0"", ""127.255.255.255""):
        return True
    elif ip_between(ip, ""169.254.0.0"", ""169.254.255.255""):
        return True
    elif ip_between(ip, ""172.16.0.0"", ""172.31.255.255""):
        return True
    elif ip_between(ip, ""192.0.0.0"", ""192.0.0.255""):
        return True
    elif ip_between(ip, ""192.0.2.0"", ""192.0.2.255""):
        return True
    elif ip_between(ip, ""192.88.99.0"", ""192.88.99.255""):
        return True
    elif ip_between(ip, ""192.168.0.0"", ""192.168.255.255""):
        return True
    elif ip_between(ip, ""198.18.0.0"", ""198.19.255.255""):
        return True
    elif ip_between(ip, ""198.51.100.0"", ""198.51.100.255""):
        return True
    elif ip_between(ip, ""203.0.113.0"", ""203.0.113.255""):
        return True
    elif ip_between(ip, ""224.0.0.0"", ""255.255.255.255""):
        return True
    else:
        return False"
3452,"def is_hash(fhash):
    """"""Returns true for valid hashes, false for invalid.""""""

    # Intentionally doing if/else statement for ease of testing and reading
    if re.match(re_md5, fhash):
        return True
    elif re.match(re_sha1, fhash):
        return True
    elif re.match(re_sha256, fhash):
        return True
    elif re.match(re_sha512, fhash):
        return True
    elif re.match(re_ssdeep, fhash):
        return True
    else:
        return False"
3453,"def ip_to_geojson(ipaddress, name=""Point""):
    """"""Generate GeoJSON for given IP address""""""

    geo = ip_to_geo(ipaddress)

    point = {
        ""type"": ""FeatureCollection"",
        ""features"": [
            {
                ""type"": ""Feature"",
                ""properties"": {
                    ""name"": name
                },
                ""geometry"": {
                    ""type"": ""Point"",
                    ""coordinates"": [
                        geo[""longitude""],
                        geo[""latitude""]
                    ]
                }
            }
        ]
    }

    return point"
3454,"def ips_to_geojson(ipaddresses):
    """"""Generate GeoJSON for given IP address""""""

    features = []

    for ipaddress in ipaddresses:
        geo = gi.record_by_addr(ipaddress)

        features.append({
            ""type"": ""Feature"",
            ""properties"": {
                ""name"": ipaddress
            },
            ""geometry"": {
                ""type"": ""Point"",
                ""coordinates"": [
                    geo[""longitude""],
                    geo[""latitude""]
                ]
            }
        })

    points = {
        ""type"": ""FeatureCollection"",
        ""features"": features
    }

    return points"
3455,"def reverse_dns_sna(ipaddress):
    """"""Returns a list of the dns names that point to a given ipaddress using StatDNS API""""""

    r = requests.get(""http://api.statdns.com/x/%s"" % ipaddress)

    if r.status_code == 200:
        names = []

        for item in r.json()['answer']:
            name = str(item['rdata']).strip(""."")
            names.append(name)

        return names
    elif r.json()['code'] == 503:
        # NXDOMAIN - no PTR record
        return None"
3456,"def vt_ip_check(ip, vt_api):
    """"""Checks VirusTotal for occurrences of an IP address""""""
    if not is_IPv4Address(ip):
        return None

    url = 'https://www.virustotal.com/vtapi/v2/ip-address/report'
    parameters = {'ip': ip, 'apikey': vt_api}
    response = requests.get(url, params=parameters)
    try:
        return response.json()
    except ValueError:
        return None"
3457,"def vt_name_check(domain, vt_api):
    """"""Checks VirusTotal for occurrences of a domain name""""""
    if not is_fqdn(domain):
        return None

    url = 'https://www.virustotal.com/vtapi/v2/domain/report'
    parameters = {'domain': domain, 'apikey': vt_api}
    response = requests.get(url, params=parameters)
    try:
        return response.json()
    except ValueError:
        return None"
3458,"def vt_hash_check(fhash, vt_api):
    """"""Checks VirusTotal for occurrences of a file hash""""""
    if not is_hash(fhash):
        return None

    url = 'https://www.virustotal.com/vtapi/v2/file/report'
    parameters = {'resource': fhash, 'apikey': vt_api}
    response = requests.get(url, params=parameters)
    try:
        return response.json()
    except ValueError:
        return None"
3459,"def ipinfo_ip_check(ip):
    """"""Checks ipinfo.io for basic WHOIS-type data on an IP address""""""
    if not is_IPv4Address(ip):
        return None

    response = requests.get('http://ipinfo.io/%s/json' % ip)
    return response.json()"
3460,"def ipvoid_check(ip):
    """"""Checks IPVoid.com for info on an IP address""""""
    if not is_IPv4Address(ip):
        return None

    return_dict = {}
    headers = {'User-Agent': useragent}
    url = 'http://ipvoid.com/scan/%s/' % ip
    response = requests.get(url, headers=headers)
    data = BeautifulSoup(response.text)
    if data.findAll('span', attrs={'class': 'label label-success'}):
        return None
    elif data.findAll('span', attrs={'class': 'label label-danger'}):
        for each in data.findAll('img', alt='Alert'):
            detect_site = each.parent.parent.td.text.lstrip()
            detect_url = each.parent.a['href']
            return_dict[detect_site] = detect_url

    return return_dict"
3461,"def urlvoid_check(name, api_key):
    """"""Checks URLVoid.com for info on a domain""""""
    if not is_fqdn(name):
        return None

    url = 'http://api.urlvoid.com/api1000/{key}/host/{name}'.format(key=api_key, name=name)
    response = requests.get(url)
    tree = ET.fromstring(response.text)
    if tree.find('./detections/engines'):
        return [e.text for e in tree.find('./detections/engines')]
    else:
        return None"
3462,"def urlvoid_ip_check(ip):
    """"""Checks URLVoid.com for info on an IP address""""""
    if not is_IPv4Address(ip):
        return None

    return_dict = {}
    headers = {'User-Agent': useragent}
    url = 'http://urlvoid.com/ip/%s/' % ip
    response = requests.get(url, headers=headers)
    data = BeautifulSoup(response.text)
    h1 = data.findAll('h1')[0].text
    if h1 == 'Report not found':
        return None
    elif re.match('^IP', h1):
        return_dict['bad_names'] = []
        return_dict['other_names'] = []
        for each in data.findAll('img', alt='Alert'):
            return_dict['bad_names'].append(each.parent.text.strip())
        for each in data.findAll('img', alt='Valid'):
            return_dict['other_names'].append(each.parent.text.strip())

    return return_dict"
3463,"def dshield_ip_check(ip):
    """"""Checks dshield for info on an IP address""""""
    if not is_IPv4Address(ip):
        return None

    headers = {'User-Agent': useragent}
    url = 'https://isc.sans.edu/api/ip/'
    response = requests.get('{0}{1}?json'.format(url, ip), headers=headers)
    return response.json()"
3464,"def cli(ctx,
        amount,
        index,
        stage):
    """"""Push data to  Target Service Client""""""

    if not ctx.bubble:
        ctx.say_yellow('There is no bubble present, will not push')
        raise click.Abort()

    TGT = None
    transformed = True
    STAGE = None

    if stage in STAGES and  stage in ctx.cfg.CFG:
        STAGE = ctx.cfg.CFG[stage]
    if not STAGE:
        ctx.say_red('There is no STAGE in CFG:' + stage)
        ctx.say_yellow('please check configuration in ' +
                        ctx.home + '/config/config.yaml')
        raise click.Abort()


    if 'TARGET' in STAGE:
        TGT = STAGE.TARGET
    if 'TRANSFORM' in STAGE:
        transformed = True
    else:
        transformed = False

    if not transformed:
        ctx.say_yellow(""""""There is no transform defined in the configuration, will not transform,
using the results of step 'pulled' instead of 'push'
"""""")

    if not TGT:
        ctx.say_red('There is no TARGET in: ' + stage)
        ctx.say_yellow('please check configuration in ' +
                       ctx.home + '/config/config.yaml')
        raise click.Abort()

    tgt_client = get_client(ctx.gbc, TGT.CLIENT, ctx.home)

    try:
        tclient = tgt_client.BubbleClient(cfg=TGT)
        tclient.set_parent(ctx.gbc)
        tclient.set_verbose(ctx.get_verbose())
    except Exception as e:
        ctx.say_red('cannot create bubble client:' + TGT.CLIENT)
        ctx.say_red(str(e))
        raise click.Abort('can not push')

    step_to_load = 'push'
    if not transformed:
        step_to_load = 'pulled'
    data_gen = bubble_lod_load(ctx, step_to_load, stage)

    full_data = False
    if amount == -1 and index == -1:
        full_data = True
    to_push = get_gen_slice(ctx.gbc, data_gen, amount, index)

    error_count = Counter()
    total_count = Counter()

    pushres = do_yielding_push(ctx=ctx,
                               to_push=to_push,
                               tclient=tclient,
                               total_counter=total_count,
                               error_counter=error_count)
    pfr = bubble_lod_dump(ctx=ctx,
                          step='pushed',
                          stage=stage,
                          full_data=full_data,
                          reset=True,
                          data_gen=pushres)

    ctx.say('pushed [%d] objects' % pfr['total'])

    stats = {}
    stats['pushed_stat_error_count'] = error_count.get_total()
    stats['pushed_stat_total_count'] = total_count.get_total()
    update_stats(ctx, stage, stats)

    return True"
3465,"def validate(version, comparison):
    """"""
    Returns whether or not the version for this plugin satisfies the
    inputted expression.  The expression will follow the dependency
    declaration rules associated with setuptools in Python.  More
    information can be found at
    
    [https://pythonhosted.org/setuptools/setuptools.html#declaring-dependencies]
    
    :param      version     | <str>
                expression  | <str>
    
    :return     <bool>
    """"""
    # match any
    if not comparison:
        return True
    
    # loop through all available
    opts = comparison.split(',')
    expr = re.compile('(==|!=|<=|>=|<|>)(.*)')
    for opt in opts:
        try:
            test, value = expr.match(opt.strip()).groups()
        except StandardError:
            raise errors.InvalidVersionDefinition(opt)
        
        value = value.strip()
        
        # test for an exact match
        if test == '==':
            if value == version:
                return True
        
        # test for negative exact matches
        elif test == '!=':
            if value == version:
                return False
        
        # test for range conditions
        elif test == '<':
            if vercmp(version, value) != -1:
                return False
        elif test == '<=':
            if vercmp(version, value) not in (-1, 0):
                return False
        elif test == '>':
            if vercmp(value, version) != -1:
                return False
        elif test == '>=':
            if vercmp(value, version) not in (-1, 0):
                return False
    
    return True"
3466,"def _full_kind(details):
    """"""
    Determine the full kind (including a group if applicable) for some failure
    details.

    :see: ``v1.Status.details``
    """"""
    kind = details[u""kind""]
    if details.get(u""group"") is not None:
        kind += u""."" + details[u""group""]
    return kind"
3467,"def RemoveEmptyDirectoryTree(path, silent = False, recursion = 0):
  """"""
  Delete tree of empty directories.

  Parameters
  ----------
    path : string
      Path to root of directory tree.

    silent : boolean [optional: default = False]
      Turn off log output.

    recursion : int [optional: default = 0]
      Indicates level of recursion.
  """"""
  if not silent and recursion is 0:
    goodlogging.Log.Info(""UTIL"", ""Starting removal of empty directory tree at: {0}"".format(path))
  try:
    os.rmdir(path)
  except OSError:
    if not silent:
      goodlogging.Log.Info(""UTIL"", ""Removal of empty directory tree terminated at: {0}"".format(path))
    return
  else:
    if not silent:
      goodlogging.Log.Info(""UTIL"", ""Directory deleted: {0}"".format(path))
    RemoveEmptyDirectoryTree(os.path.dirname(path), silent, recursion + 1)"
3468,"def CheckPathExists(path):
  """"""
  Check if path exists, if it does add number to path (incrementing until
  a unique path is found).

  Parameters
  ----------
    path : string
      Path of directory to try.

  Returns
  ----------
    string
      Path of unique directory.
  """"""
  i = 0
  root, ext = os.path.splitext(path)
  while os.path.exists(path):
    i = i + 1
    goodlogging.Log.Info(""UTIL"", ""Path {0} already exists"".format(path))
    path = ""{0}_{1}"".format(root, i) + ext
  return path"
3469,"def StripSpecialCharacters(string, stripAll = False):
  """"""
  Strips special characters, duplicate spaces and post/pre-ceeding spaces.
  Strip on single spaces, periods, hyphens and underscores is conditional on
  if stripAll is set

  Parameters
  ----------
    string : string
      String to strip special characters from.

    stripAll : boolean [optional: default = False]
      If set will also strip single spaces, periods, hyphens and underscores.

  Returns
  ----------
    string
      Resulting string with special characters removed.
  """"""
  goodlogging.Log.Info(""UTIL"", ""Stripping any special characters from {0}"".format(string), verbosity=goodlogging.Verbosity.MINIMAL)
  string = string.strip()
  string = re.sub('[&]', 'and', string)
  string = re.sub(r'[@#$%^&*{};:,/<>?\\|`~=+±§£]', '', string)
  string = re.sub('\s\s+', ' ', string)

  if stripAll:
    string = re.sub('[_.-]', '', string)
    string = re.sub('\s', '', string)

  goodlogging.Log.Info(""UTIL"", ""New string is: {0}"".format(string), verbosity=goodlogging.Verbosity.MINIMAL)
  return string"
3470,"def ValidUserResponse(response, validList):
  """"""
  Check if user response is in a list of valid entires.
  If an invalid response is given re-prompt user to enter
  one of the valid options. Do not proceed until a valid entry
  is given.

  Parameters
  ----------
    response : string
      Response string to check.

    validList : list
      A list of valid responses.

  Returns
  ----------
    string
      A valid response string.
  """"""
  if response in validList:
    return response
  else:
    prompt = ""Unknown response given - please reenter one of [{0}]: "".format('/'.join(validList))
    response = goodlogging.Log.Input(""DM"", prompt)
    return ValidUserResponse(response, validList)"
3471,"def UserAcceptance(
  matchList,
  recursiveLookup = True,
  promptComment = None,
  promptOnly = False,
  xStrOverride = ""to skip this selection""
):
  """"""
  Prompt user to select a entry from a given match list or to enter a new
  string to look up. If the match list is empty user must enter a new string
  or exit.

  Parameters
  ----------
    matchList : list
      A list of entries which the user can select a valid match from.

    recursiveLookup : boolean [optional: default = True]
      Allow user to enter a new string to look up.

    promptComment : string [optional: default = None]
      Add an additional comment on the end of the prompt message.

    promptOnly : boolean [optional: default = False]
      Set to true if match list is expected to be empty. In which case
      the presence of an empty match list will not be mentioned and user
      will be expected to enter a new response to look up.

    xStrOverride : string [optional: default = ""to skip this selection""]
      Override the string for 'x' response. This can be used if
      the behaviour of the 'x' response is changed.

  Returns
  ----------
    string or None
      Either a entry from matchList, another valid response or a new
      string to look up. If match list is empty and recursive lookup is
      disabled or if the user response is 'x' this will return None.
  """"""
  matchString = ', '.join(matchList)

  if len(matchList) == 1:
    goodlogging.Log.Info(""UTIL"", ""Match found: {0}"".format(matchString))
    prompt = ""Enter 'y' to accept this match or e""
  elif len(matchList) > 1:
    goodlogging.Log.Info(""UTIL"", ""Multiple possible matches found: {0}"".format(matchString))
    prompt = ""Enter correct match from list or e""
  else:
    if promptOnly is False:
      goodlogging.Log.Info(""UTIL"", ""No match found"")
    prompt = ""E""
    if not recursiveLookup:
      return None

  if recursiveLookup:
    prompt = prompt + ""nter a different string to look up or e""

  prompt = prompt + ""nter 'x' {0} or enter 'exit' to quit this program"".format(xStrOverride)

  if promptComment is None:
    prompt = prompt + "": ""
  else:
    prompt = prompt + "" ({0}): "".format(promptComment)

  while(1):
    response = goodlogging.Log.Input('UTIL', prompt)

    if response.lower() == 'exit':
      goodlogging.Log.Fatal(""UTIL"", ""Program terminated by user 'exit'"")
    if response.lower() == 'x':
      return None
    elif response.lower() == 'y' and len(matchList) == 1:
      return matchList[0]
    elif len(matchList) > 1:
      for match in matchList:
        if response.lower() == match.lower():
          return match
    if recursiveLookup:
      return response"
3472,"def GetBestMatch(target, matchList):
  """"""
  Finds the elements of matchList which best match the target string.

  Note that this searches substrings so ""abc"" will have a 100% match in
  both ""this is the abc"", ""abcde"" and ""abc"".

  The return from this function is a list of potention matches which shared
  the same highest match score. If any exact match is found (1.0 score and
  equal size string) this will be given alone.

  Parameters
  ----------
    target : string
      Target string to match.

    matchList : list
      List of strings to match target against.

  Returns
  ----------
    list
      A list of potention matches which share the same highest match score.
      If any exact match is found (1.0 score and equal size string) this
      will be given alone.
  """"""
  bestMatchList = []

  if len(matchList) > 0:
    ratioMatch = []
    for item in matchList:
      ratioMatch.append(GetBestStringMatchValue(target, item))

    maxRatio = max(ratioMatch)
    if maxRatio > 0.8:
      matchIndexList = [i for i, j in enumerate(ratioMatch) if j == maxRatio]

      for index in matchIndexList:
        if maxRatio == 1 and len(matchList[index]) == len(target):
          return [matchList[index], ]
        else:
          bestMatchList.append(matchList[index])

  return bestMatchList"
3473,"def GetBestStringMatchValue(string1, string2):
  """"""
  Return the value of the highest matching substrings between two strings.

  Parameters
  ----------
    string1 : string
      First string.

    string2 : string
      Second string.

  Returns
  ----------
    int
      Integer value representing the best match found
      between string1 and string2.
  """"""
  # Ignore case
  string1 = string1.lower()
  string2 = string2.lower()

  # Ignore non-alphanumeric characters
  string1 = ''.join(i for i in string1 if i.isalnum())
  string2 = ''.join(i for i in string2 if i.isalnum())

  # Finding best match value between string1 and string2
  if len(string1) == 0 or len(string2) == 0:
    bestRatio = 0
  elif len(string1) == len(string2):
    match = difflib.SequenceMatcher(None, string1, string2)
    bestRatio = match.ratio()
  else:
    if len(string1) > len(string2):
      shortString = string2
      longString = string1
    else:
      shortString = string1
      longString = string2

    match = difflib.SequenceMatcher(None, shortString, longString)
    bestRatio = match.ratio()

    for block in match.get_matching_blocks():
      subString = longString[block[1]:block[1]+block[2]]
      subMatch = difflib.SequenceMatcher(None, shortString, subString)
      if(subMatch.ratio() > bestRatio):
        bestRatio = subMatch.ratio()

  return(bestRatio)"
3474,"def WebLookup(url, urlQuery=None, utf8=True):
  """"""
  Look up webpage at given url with optional query string

  Parameters
  ----------
    url : string
      Web url.

    urlQuery : dictionary [optional: default = None]
      Parameter to be passed to GET method of requests module

    utf8 : boolean [optional: default = True]
      Set response encoding

  Returns
  ----------
    string
      GET response text
  """"""

  goodlogging.Log.Info(""UTIL"", ""Looking up info from URL:{0} with QUERY:{1})"".format(url, urlQuery), verbosity=goodlogging.Verbosity.MINIMAL)
  response = requests.get(url, params=urlQuery)
  goodlogging.Log.Info(""UTIL"", ""Full url: {0}"".format(response.url), verbosity=goodlogging.Verbosity.MINIMAL)
  if utf8 is True:
    response.encoding = 'utf-8'
  if(response.status_code == requests.codes.ok):
    return(response.text)
  else:
    response.raise_for_status()"
3475,"def ArchiveProcessedFile(filePath, archiveDir):
  """"""
  Move file from given file path to archive directory. Note the archive
  directory is relative to the file path directory.

  Parameters
  ----------
    filePath : string
      File path

    archiveDir : string
      Name of archive directory
  """"""
  targetDir = os.path.join(os.path.dirname(filePath), archiveDir)
  goodlogging.Log.Info(""UTIL"", ""Moving file to archive directory:"")
  goodlogging.Log.IncreaseIndent()
  goodlogging.Log.Info(""UTIL"", ""FROM: {0}"".format(filePath))
  goodlogging.Log.Info(""UTIL"", ""TO:   {0}"".format(os.path.join(targetDir, os.path.basename(filePath))))
  goodlogging.Log.DecreaseIndent()
  os.makedirs(targetDir, exist_ok=True)
  try:
    shutil.move(filePath, targetDir)
  except shutil.Error as ex4:
    err = ex4.args[0]
    goodlogging.Log.Info(""UTIL"", ""Move to archive directory failed - Shutil Error: {0}"".format(err))"
3476,"def send(self,text):
	""""""Send a string to the PiLite, can be simple text or a $$$ command""""""
	#print text
	self.s.write(text)
	time.sleep(0.001*len(text))"
3477,"def send_wait(self,text):
	""""""Send a string to the PiLite, sleep until the message has been
	displayed (based on an estimate of the speed of the display.
	Due to the font not being monotype, this will wait too long in most
	cases""""""
	self.send(text)
	time.sleep(len(text)*PiLite.COLS_PER_CHAR*self.speed/1000.0)"
3478,"def set_speed(self,speed):
	""""""Set the display speed.  The parameters is the number of milliseconds
	between each column scrolling off the display""""""
	self.speed=speed
	self.send_cmd(""SPEED""+str(speed))"
3479,"def set_fb_pic(self,pattern):
	""""""Set the ""frame buffer"".  This allows ""nice"" string to be sent,
	because it first removes all whitespace, then transposes so that the X
	and Y axes are swapped, so what is seen in the file matches what will be
	seen on the screen.  Also '.' and '*' can be used in place of 0 and 1.
	""""""
	pattern=''.join(pattern.split()) # Remove whitespace
	pattern=pattern.replace('*','1')
	pattern=pattern.replace('.','0')
	fb=''
	for x in range(14):
	    for y in range(9):
		fb+=pattern[y*14+x]
	self.set_fb(fb)"
3480,"def set_fb_random(self):
	""""""Set the ""frame buffer"" to a random pattern""""""
	pattern=''.join([random.choice(['0','1']) for i in xrange(14*9)])
	self.set_fb(pattern)"
3481,"def set_pixel(self,x,y,state):
	""""""Set pixel at ""x,y"" to ""state"" where state can be one of ""ON"", ""OFF""
	or ""TOGGLE""
	""""""
	self.send_cmd(""P""+str(x+1)+"",""+str(y+1)+"",""+state)"
3482,"def display_char(self,x,y,char):
	""""""Display character ""char"" with its top left at ""x,y""
	""""""
	self.send_cmd(""T""+str(x+1)+"",""+str(y+1)+"",""+char)"
3483,"def the_magic_mapping_function(peptides, fastaPath, importAttributes=None,
        ignoreUnmapped=True):
    """"""Returns a dictionary mapping peptides to protein group leading proteins.

    :param peptides: a set of peptide sequences
    :param fastaPath: FASTA file path
    :param importAttributes: dict, can be used to override default parameters
        passed to the function maspy.proteindb.importProteinDatabase().
        Default attribtues are:
        {'cleavageRule': '[KR]', 'removeNtermM': True, 'ignoreIsoleucine': True,
         forceId': True, 'headerParser': PROTEINDB.fastaParserSpectraClusterPy}
    :param ignoreUnmapped: bool, if True ignores peptides that cannot be mapped
        to any protein present in the FASTA file

    :returns: dict, {peptide: set([groupLeaders1, ...])}
        where groupLeaders is a string joining all leading proteins of a group
        with a "";"", for example {'peptide': {""protein1;proetin2;protein3""}}
    """"""

    missedCleavage = max([p.count('K') + p.count('R') for p in peptides]) - 1
    minLength = min([len(p) for p in peptides])
    maxLength = max([len(p) for p in peptides])
    defaultAttributes = {
        'cleavageRule': '[KR]', 'minLength': minLength, 'maxLength': maxLength,
        'removeNtermM': True,  'ignoreIsoleucine': True,
        'missedCleavage': missedCleavage, 'forceId': True,
        'headerParser': PROTEINDB.fastaParserSpectraClusterPy,
    }
    if importAttributes is not None:
        defaultAttributes.update(importAttributes)

    proteindb = PROTEINDB.importProteinDatabase(fastaPath, **defaultAttributes)

    #This could be automated by adding a function to the inference module
    proteinToPeptides = ddict(set)
    for peptide in peptides:
        #ignore any peptide that's not mapped if ""ignoreUnmapped"" is True
        try:
            peptideDbEntry = proteindb.peptides[peptide]
        except KeyError as exception:
            if ignoreUnmapped:
                continue
            else:
                exceptionText = 'No protein mappings for peptide ""'+peptide+'""'
                raise KeyError(exceptionText)

        for protein in peptideDbEntry.proteins:
            proteinToPeptides[protein].add(peptide)

    #Generate the ProteinInference instance
    inference = INFERENCE.mappingBasedGrouping(proteinToPeptides)

    peptideGroupMapping = dict()
    for peptide in peptides:
        groupLeaders = set()
        for proteinId in inference.pepToProts[peptide]:
            for proteinGroup in inference.getGroups(proteinId):
                groupLeaders.add(';'.join(sorted(proteinGroup.leading)))
        peptideGroupMapping[peptide] = groupLeaders

    return peptideGroupMapping"
3484,"def cli(ctx, amount, index, stage):
    """"""Pull, Transform, Push,streaming inside a pipe(experimental).""""""
    ctx.obj.say_green('Starting Streaming Pipe')
    res_pull = ctx.invoke(pull, amount=amount, index=index, stage=stage)
    res_tra = False
    if res_pull:
        # amount to transform can be less (or more)
        res_tra = ctx.invoke(
            transform, amount=amount, index=index, stage=stage)
    if res_tra:
        # amount to push can be less (or more)
        res_push = ctx.invoke(push, amount=amount, index=index, stage=stage)
    if res_pull and res_tra and res_push:
        ctx.obj.say_green('Streaming Pipe finsished')
        return True
    return False"
3485,"def camelHump(text):
    """"""
    Converts the inputted text to camel humps by joining all
    capital letters toegether (The Quick, Brown, 
    Fox.Tail -> TheQuickBrownFoxTail)
    
    :param:      text        <str>       text to be changed
    
    :return:     <str>
    
    :usage:      |import projex.text
                |print projex.text.camelHump('The,Quick, Brown, Fox.Tail')
    """"""
    # make sure the first letter is upper case
    output = ''.join([word[0].upper() + word[1:] for word in words(text)])
    if output:
        output = output[0].lower() + output[1:]
    return output"
3486,"def capitalize(text):
    """"""
    Capitalizes the word using the normal string capitalization 
    method, however if the word contains only capital letters and 
    numbers, then it will not be affected.
    
    :param      text                    |   <str>
    
    :return     <str>
    """"""
    text = nativestring(text)
    if EXPR_CAPITALS.match(text):
        return text
    return text.capitalize()"
3487,"def classname(text):
    """"""
    Converts the inputted text to the standard classname format (camel humped
    with a capital letter to start.
    
    :return     <str>
    """"""
    if not text:
        return text

    text = camelHump(text)
    return text[0].upper() + text[1:]"
3488,"def encoded(text, encoding=DEFAULT_ENCODING):
    """"""
    Encodes the inputted unicode/string variable with the given encoding type.
    
    :param      text | <variant>
                encoding | <str>
    
    :return     <str>
    """"""
    # already a string item
    if type(text) == bytes_type:
        return text

    elif type(text) != unicode_type:
        # convert a QString value
        if type(text).__name__ == 'QString':
            if encoding == 'utf-8':
                return unicode_type(text.toUtf8(), 'utf-8')
            elif encoding == 'latin-1':
                return unicode_type(text.toLatin1(), 'latin-1')
            elif encoding == 'ascii':
                return unicode_type(text.toAscii(), 'ascii')
            else:
                return unicode_type(text, encoding)

        # convert a standard item
        else:
            try:
                return bytes_type(text)
            except StandardError:
                return '????'

    if encoding:
        try:
            return text.encode(encoding)
        except StandardError:
            return text.encode(encoding, errors='ignore')

    else:
        for enc in SUPPORTED_ENCODINGS:
            try:
                return text.encode(enc)
            except StandardError:
                pass

    return '????'"
3489,"def decoded(text, encoding=DEFAULT_ENCODING):
    """"""
    Attempts to decode the inputted unicode/string variable using the
    given encoding type.  If no encoding is provided, then it will attempt
    to use one of the ones available from the default list.
    
    :param      text     | <variant>
                encoding | <str> || None
    
    :return     <unicode>
    """"""
    # unicode has already been decoded
    if type(text) == unicode_type:
        return text

    elif type(text) != bytes_type:
        try:
            return unicode_type(text)
        except StandardError:
            try:
                text = bytes_type(text)
            except StandardError:
                msg = u'<< projex.text.decoded: unable to decode ({0})>>'
                return msg.format(repr(text))

    if encoding:
        try:
            return text.decode(encoding)
        except StandardError:
            pass

    for enc in SUPPORTED_ENCODINGS:
        try:
            return text.decode(enc)
        except StandardError:
            pass

    return u'????'"
3490,"def nativestring(val, encodings=None):
    """"""
    Converts the inputted value to a native python string-type format.
    
    :param      val         | <variant>
                encodings   | (<str>, ..) || None
    
    :sa         decoded
    
    :return     <unicode> || <str>
    """"""
    # if it is already a native python string, don't do anything
    if type(val) in (bytes_type, unicode_type):
        return val

    # otherwise, attempt to return a decoded value
    try:
        return unicode_type(val)
    except StandardError:
        pass

    try:
        return bytes_type(val)
    except StandardError:
        return decoded(val)"
3491,"def joinWords(text, separator=''):
    """"""
    Collects all the words from a text and joins them together
    with the inputted separator.
    
    :sa         [[#words]]
    
    :param      text        <str>
    :param      separator   <str>
    
    :return     <str>
    
    :usage      |import projex
                |print projex.joinWords('This::is.a testTest','-')
    """"""
    text = nativestring(text)
    output = separator.join(words(text.strip(separator)))

    # no need to check for bookended items when its an empty string
    if not separator:
        return output

    # look for beginning characters
    begin = re.match('^\%s+' % separator, text)
    if begin:
        output = begin.group() + output

        # make sure to not double up
        if begin.group() == text:
            return output

    # otherwise, look for the ending results
    end = re.search('\%s+$' % separator, text)
    if end:
        output += end.group()

    return output"
3492,"def pluralize(word, count=None, format=u'{word}'):
    """"""
    Converts the inputted word to the plural form of it.  This method works
    best if you use the inflect module, as it will just pass along the
    request to inflect.plural  If you do not have that module, then a simpler
    and less impressive pluralization technique will be used.
    
    :sa         https://pypi.python.org/pypi/inflect
    
    :param      word | <str>
    
    :return     <str>
    """"""
    if count == 1:
        return word
    elif count is not None:
        return format.format(word=word, count=count)

    word = nativestring(word)
    if inflect_engine:
        return format.format(word=inflect_engine.plural(word))

    all_upper = EXPR_UPPERCASE.match(word) is not None

    # go through the different plural expressions, searching for the
    # proper replacement
    for expr, plural in PLURAL_RULES:
        results = expr.match(word)
        if results:
            result_dict = results.groupdict()
            single = result_dict.get('single', '')

            # check if its capitalized
            if all_upper:
                return format.format(word=single + plural.upper())
            else:
                return format.format(word=single + plural)

    # by default, just include 's' at the end
    if all_upper:
        return format.format(word=word + 'S')
    return format.format(word=word + 's')"
3493,"def render(text, options, processed=None):
    """"""
    Replaces the templates within the inputted text with the given
    options.  Templates are defined as text within matching 
    braces, and can include additional formatting options.  
    Any key that is not found in the options will be replaced 
    as it was found in the inputted text.
    
    :param      text        <str>
    :param      options     <dict> { <str> key: <variant> value, .. }
    :param      processed   <list> [ <str> key, .. ]        used internally
    
    :return     <str> formatted text
    
    :usage      |import projex.text
                |options = { 'key': 10, 'name': 'eric' }
                |template = '[name::lower]_[key]_[date::%m-%d-%y].txt'
                |projex.text.render( template, options )
    
    :built-ins  date    will render the current datetime
    
    :options    The following are a list of formatting options text:
                
                lower         | converts the value to lowercase
                upper         | converts the value to uppercase
                camelHump     | converts the value to camel-humped text
                underscore    | converts the value to underscored text
                pretty        | converts the value to pretty text
                capitalized   | converts the value to capltalized words
                words         | converts the value to space separated words
                upper_first   | capitalizes just the first letter
                lower_first   | lowercases just the first letter
                replace(x, y) | replaces the instances of x with y
                lstrip(x)     | removes the beginning instance of x
                rstrip(x)     | removes the ending instance of x
                slice(x, y)   | same as doing string[x:y]
    """"""
    output = unicode_type(text)
    expr = re.compile('(\[+([^\[\]]+)\]\]?)')
    results = expr.findall(output)
    curr_date = datetime.datetime.now()
    options_re = re.compile('(\w+)\(?([^\)]+)?\)?')

    if processed is None:
        processed = []

    for repl, key in results:
        # its possible to get multiple items for processing
        if repl in processed:
            continue

        # record the repl value as being processed
        processed.append(repl)

        # replace template templates
        if repl.startswith('[[') and repl.endswith(']]'):
            output = output.replace(repl, '[%s]' % key)
            continue

        # determine the main key and its options
        splt = key.split('::')
        key = splt[0]
        prefs = splt[1:]
        value = None

        # use the inputted options
        if key in options:
            # extract the value
            value = options[key]

            # format a float
            if type(value) in (float, int):
                if prefs:
                    value = prefs[0] % value
                else:
                    value = nativestring(value)

            # convert date time values
            elif type(value) in (datetime.datetime,
                                 datetime.date,
                                 datetime.time):
                if not prefs:
                    date_format = '%m/%d/%y'
                else:
                    date_format = prefs[0]
                    prefs = prefs[1:]

                value = value.strftime(nativestring(date_format))

            else:
                value = render(options[key], options, processed)

        # look for the built-in options
        elif key == 'date':
            value = curr_date

            if not prefs:
                date_format = '%m/%d/%y'
            else:
                date_format = prefs[0]
                prefs = prefs[1:]

            value = value.strftime(nativestring(date_format))

        # otherwise, continue
        else:
            continue

        # apply the prefs to the value
        if value and prefs:

            for pref in prefs:
                result = options_re.match(pref)
                pref, opts = result.groups()

                if opts:
                    opts = [opt.strip() for opt in opts.split(',')]
                else:
                    opts = []

                if 'lower' == pref:
                    value = value.lower()
                elif 'upper' == pref:
                    value = value.upper()
                elif 'upper_first' == pref:
                    value = value[0].upper() + value[1:]
                elif 'lower_first' == pref:
                    value = value[0].lower() + value[1:]
                elif 'camelHump' == pref:
                    value = camelHump(value)
                elif 'underscore' == pref:
                    value = underscore(value)
                elif 'capitalize' == pref:
                    value = capitalize(value)
                elif pref in ('pluralize', 'plural'):
                    value = pluralize(value)
                elif 'words' == pref:
                    value = ' '.join(words(value))
                elif 'pretty' == pref:
                    value = pretty(value)

                elif 'replace' == pref:
                    if len(opts) == 2:
                        value = value.replace(opts[0], opts[1])
                    else:
                        logger.warning('Invalid options for replace: %s',
                                       ', '.join(opts))

                elif 'slice' == pref:
                    if len(opts) == 2:
                        value = value[int(opts[0]):int(opts[1])]
                    else:
                        logger.warning('Invalid options for slice: %s',
                                       ', '.join(opts))

                elif 'lstrip' == pref:
                    if not opts:
                        value = value.lstrip()
                    else:
                        for k in opts:
                            if value.startswith(k):
                                value = value[len(k):]

                elif 'rstrip' == pref:
                    if not opts:
                        value = value.rstrip()
                    else:
                        for k in opts:
                            if value.endswith(k):
                                value = value[:-len(k)]

        output = output.replace(repl, value)

    return output"
3494,"def safe_eval(value):
    """"""
    Converts the inputted text value to a standard python value (if possible).

    :param      value | <str> || <unicode>

    :return     <variant>
    """"""
    if not isinstance(value, (str, unicode)):
        return value

    try:
        return CONSTANT_EVALS[value]
    except KeyError:
        try:
            return ast.literal_eval(value)
        except StandardError:
            return value"
3495,"def sectioned(text, sections=1):
    """"""
    Splits the inputted text up into sections.
    
    :param      text | <str>
                sections | <int>
        
    :return     <str>
    """"""
    text = nativestring(text)
    if not text:
        return ''
    count = len(text) / max(1, sections)
    return ' '.join([text[i:i + count] for i in range(0, len(text), count)])"
3496,"def singularize(word):
    """"""
    Converts the inputted word to the single form of it.  This method works
    best if you use the inflect module, as it will just pass along the
    request to inflect.singular_noun.  If you do not have that module, then a 
    simpler and less impressive singularization technique will be used.
    
    :sa         https://pypi.python.org/pypi/inflect
    
    :param      word        <str>
    
    :return     <str>
    """"""
    word = toUtf8(word)
    if inflect_engine:
        result = inflect_engine.singular_noun(word)
        if result is False:
            return word
        return result

    # go through the different plural expressions, searching for the
    # proper replacement
    if word.endswith('ies'):
        return word[:-3] + 'y'
    elif word.endswith('IES'):
        return word[:-3] + 'Y'
    elif word.endswith('s') or word.endswith('S'):
        return word[:-1]

    return word"
3497,"def stemmed(text):
    """"""
    Returns a list of simplified and stemmed down terms for the inputted text.
    
    This will remove common terms and words from the search and return only
    the important root terms.  This is useful in searching algorithms.
    
    :param      text | <str>
    
    :return     [<str>, ..]
    """"""
    terms = re.split('\s*', toAscii(text))

    output = []
    for term in terms:
        # ignore apostrophe's
        if term.endswith(""'s""):
            stripped_term = term[:-2]
        else:
            stripped_term = term

        single_term = singularize(stripped_term)

        if term in COMMON_TERMS or stripped_term in COMMON_TERMS or single_term in COMMON_TERMS:
            continue

        output.append(single_term)

    return output"
3498,"def stripHtml(html, joiner=''):
    """"""
    Strips out the HTML tags from the inputted text, returning the basic
    text.  This algorightm was found on
    [http://stackoverflow.com/questions/753052/strip-html-from-strings-in-python StackOverflow].
    
    :param      html | <str>
    
    :return     <str>
    """"""
    stripper = HTMLStripper()
    stripper.feed(html.replace('<br>', '\n').replace('<br/>', '\n'))
    return stripper.text(joiner)"
3499,"def truncate(text, length=50, ellipsis='...'):
    """"""
    Returns a truncated version of the inputted text.

    :param      text | <str>
                length | <int>
                ellipsis | <str>

    :return     <str>
    """"""
    text = nativestring(text)
    return text[:length] + (text[length:] and ellipsis)"
3500,"def toBytes(text, encoding=DEFAULT_ENCODING):
    """"""
    Converts the inputted text to base string bytes array.
    
    :param      text | <variant>
    
    :return     <str> || <bytes> (python3)
    """"""
    if not text:
        return text

    if not isinstance(text, bytes_type):
        text = text.encode(encoding)

    return text"
3501,"def toUnicode(data, encoding=DEFAULT_ENCODING):
    """"""
    Converts the inputted data to unicode format.
    
    :param      data | <str> || <unicode> || <iterable>
    
    :return     <unicode> || <iterable>
    """"""
    if isinstance(data, unicode_type):
        return data

    if isinstance(data, bytes_type):
        return unicode_type(data, encoding=encoding)

    if hasattr(data, '__iter__'):
        try:
            dict(data)
        except TypeError:
            pass
        except ValueError:
            return (toUnicode(i, encoding) for i in data)
        else:
            if hasattr(data, 'items'):
                data = data.items()

            return dict(((toUnicode(k, encoding), toUnicode(v, encoding)) for k, v in data))
    return data"
3502,"def underscore(text, lower=True):
    """"""
    Splits all the words from the inputted text into being
    separated by underscores
    
    :sa         [[#joinWords]]
    
    :param      text        <str>
    
    :return     <str>
    
    :usage      |import projex.text
                |print projex.text.underscore('TheQuick, Brown, Fox')
    """"""
    out = joinWords(text, '_')
    if lower:
        return out.lower()
    return out"
3503,"def xmlindent(elem, level=0, spacer='  '):
    """"""
    Indents the inputted XML element based on the given indent level.
    
    :param      elem    | <xml.etree.Element>
    """"""
    i = ""\n"" + level * spacer
    if len(elem):
        if not elem.text or not elem.text.strip():
            elem.text = i + spacer
        if not elem.tail or not elem.tail.strip():
            elem.tail = i
        for elem in elem:
            xmlindent(elem, level + 1)
        if not elem.tail or not elem.tail.strip():
            elem.tail = i
    else:
        if level and (not elem.tail or not elem.tail.strip()):
            elem.tail = i"
3504,"def words(text):
    """"""
    Extracts a list of words from the inputted text, parsing
    out non-alphanumeric characters and splitting camel 
    humps to build the list of words
    
    :param      text            <str>
    
    :return     <str>
    
    :usage      |import projex.text
                |print projex.text.words('TheQuick, TheBrown Fox.Tail')
    """"""
    stext = nativestring(text)
    if not stext:
        return []

    # first, split all the alphanumeric characters up
    phrases = EXPR_PHRASE.findall(stext)

    # second, split all the camel humped words
    output = []
    for phrase in phrases:
        output += EXPR_WORD.findall(phrase)

    return output"
3505,"def to_json(data):
    """"""Return data as a JSON string.""""""
    return json.dumps(data, default=lambda x: x.__dict__, sort_keys=True, indent=4)"
3506,"def convert_string(string, chars=None):
    """"""Remove certain characters from a string.""""""
    if chars is None:
        chars = [',', '.', '-', '/', ':', '  ']

    for ch in chars:
        if ch in string:
            string = string.replace(ch, ' ')
    return string"
3507,"def convert_time(time):
    """"""Convert a time string into 24-hour time.""""""
    split_time = time.split()
    try:
        # Get rid of period in a.m./p.m.
        am_pm = split_time[1].replace('.', '')
        time_str = '{0} {1}'.format(split_time[0], am_pm)
    except IndexError:
        return time
    try:
        time_obj = datetime.strptime(time_str, '%I:%M %p')
    except ValueError:
        time_obj = datetime.strptime(time_str, '%I %p')

    return time_obj.strftime('%H:%M %p')"
3508,"def convert_month(date, shorten=True, cable=True):
    """"""Replace month by shortening or lengthening it.

    :param shorten: Set to True to shorten month name.
    :param cable: Set to True if category is Cable.
    """"""
    month = date.split()[0].lower()
    if 'sept' in month:
        shorten = False if cable else True

    try:
        if shorten:
            month = SHORT_MONTHS[MONTHS.index(month)]
        else:
            month = MONTHS[SHORT_MONTHS.index(month)]
    except ValueError:
        month = month.title()

    return '{0} {1}'.format(month, ' '.join(date.split()[1:]))"
3509,"def convert_date(date):
    """"""Convert string to datetime object.""""""
    date = convert_month(date, shorten=False)
    clean_string = convert_string(date)
    return datetime.strptime(clean_string, DATE_FMT.replace('-',''))"
3510,"def date_in_range(date1, date2, range):
    """"""Check if two date objects are within a specific range""""""
    date_obj1 = convert_date(date1)
    date_obj2 = convert_date(date2)
    return (date_obj2 - date_obj1).days <= range"
3511,"def inc_date(date_obj, num, date_fmt):
    """"""Increment the date by a certain number and return date object.
    as the specific string format.
    """"""
    return (date_obj + timedelta(days=num)).strftime(date_fmt)"
3512,"def get_soup(url):
    """"""Request the page and return the soup.""""""
    html = requests.get(url, stream=True, headers=HEADERS)
    if html.status_code != 404:
        return BeautifulSoup(html.content, 'html.parser')
    else:
        return None"
3513,"def match_list(query_list, string):
    """"""Return True if all words in a word list are in the string.

    :param query_list: list of words to match
    :param string: the word or words to be matched against
    """"""
    # Get rid of 'the' word to ease string matching
    match = False
    index = 0
    string = ' '.join(filter_stopwords(string))

    if not isinstance(query_list, list):
        query_list = [query_list]

    while index < len(query_list):
        query = query_list[index]
        words_query = filter_stopwords(query)
        match = all(word in string for word in words_query)
        if match:
            break

        index += 1

    return match"
3514,"def filter_stopwords(phrase):
    """"""Filter out stop words and return as a list of words""""""
    if not isinstance(phrase, list):
        phrase = phrase.split()

    stopwords = ['the', 'a', 'in', 'to']
    return [word.lower() for word in phrase if word.lower() not in stopwords]"
3515,"def safe_unicode(string):
    """"""If Python 2, replace non-ascii characters and return encoded string.""""""
    if not PY3:
        uni = string.replace(u'\u2019', ""'"")
        return uni.encode('utf-8')
        
    return string"
3516,"def get_strings(soup, tag):
    """"""Get all the string children from an html tag.""""""
    tags = soup.find_all(tag)
    strings = [s.string for s in tags if s.string]
    return strings"
3517,"def cli(ctx, given_name, demo):
    """"""Initializes a bubble.""""""
    path = None
    if path is None:
        path = ctx.home
        bubble_file_name = path + '/.bubble'
        config_file = path + '/config/config.yaml'

        if os.path.exists(bubble_file_name) and os.path.isfile(bubble_file_name):
            ctx.say_yellow(
                'There is already a bubble present, will not initialize bubble in:' + path)
            return
        else:
            given_name = '(((' + given_name + ')))'
            with open(bubble_file_name, 'w') as dot_bubble:
                dot_bubble.write('bubble=' + metadata.version + '\n')
                dot_bubble.write('name=' + given_name + '\n')
                dot_bubble.write('home=' + ctx.home + '\n')
                dot_bubble.write(
                    'local_init_timestamp=' + str(arrow.utcnow()) + '\n')
                # aka date_of_birth
                dot_bubble.write(
                    'local_creator_user=' + str(os.getenv('USER')) + '\n')
                dot_bubble.write(
                    'local_created_in_env=' + str(os.environ) + '\n')
                ctx.say_green('Initialised a  new bubble in [%s]' %
                              click.format_filename(bubble_file_name))

        create_dir(ctx, path + '/config/')
        create_dir(ctx, path + '/logs/')
        create_dir(ctx, path + '/export/')
        create_dir(ctx, path + '/import/')
        create_dir(ctx, path + '/remember/')
        create_dir(ctx, path + '/remember/archive')

        with open(config_file, 'w') as cfg_file:
            cfg_file.write(get_example_configuration())
            ctx.say_green('Created an example configuration in %s' %
                          click.format_filename(config_file))

        rules_file = path + '/config/rules.bubble'
        with open(rules_file, 'w') as rules:
            rules.write(get_example_rules_bubble())
            ctx.say_green('Created an example rules in [%s]' %
                          click.format_filename(rules_file))

        rule_functions_file = path + '/custom_rule_functions.py'
        with open(rule_functions_file, 'w') as rule_functions:
            rule_functions.write(get_example_rule_functions())
            ctx.say_green('Created an example rule_functions in [%s]' %
                          click.format_filename(rule_functions_file))

        src_client_file = path + '/mysrcclient.py'
        with open(src_client_file, 'w') as src_client:
            src_client.write(get_example_client_pull())
            ctx.say_green('Created source example client with pull method [%s]' %
                          click.format_filename(src_client_file))
        tgt_client_file = path + '/mytgtclient.py'
        with open(tgt_client_file, 'w') as tgt_client:
            tgt_client.write(get_example_client_push())
            ctx.say_green('Created an target example client with push method [%s]' %
                          click.format_filename(src_client_file))

        ctx.say_green(
            'Bubble initialized, please adjust your configuration file')"
3518,"def _bld_op(self, op, num, **kwargs):
        """"""implements pandas an operator""""""
        kwargs['other'] = num        
        setattr(self, op, {'mtype': pab, 'kwargs': kwargs})"
3519,"def _bld_pab_generic(self, funcname, **kwargs):
        """"""
        implements a generic version of an attribute based pandas function
        """"""
        margs = {'mtype': pab, 'kwargs': kwargs}
        setattr(self, funcname, margs)"
3520,"def _bld_pnab_generic(self, funcname, **kwargs):
        """"""
        implement's a generic version of a non-attribute based pandas function
        """"""
        margs = {'mtype': pnab, 'kwargs': kwargs}
        setattr(self, funcname, margs)"
3521,"def get(self, request, *args, **kwargs):
        """"""
        List all products in the shopping cart
        """"""
        cart = ShoppingCartProxy(request)
        return JsonResponse(cart.get_products(onlypublic=request.GET.get('onlypublic', True)))"
3522,"def post(self, request, *args, **kwargs):
        """"""
        Adds new product to the current shopping cart
        """"""
        POST = json.loads(request.body.decode('utf-8'))

        if 'product_pk' in POST and 'quantity' in POST:
            cart = ShoppingCartProxy(request)
            cart.add(
                product_pk=int(POST['product_pk']),
                quantity=int(POST['quantity'])
            )
            return JsonResponse(cart.products)

        return HttpResponseBadRequest()"
3523,"def dispatch(self, *args, **kwargs):
        self.__line_pk = kwargs.get('pk', None)
        """"""
        if SalesLineBasketOption.objects.filter(line_budget__pk=self.__line_pk).exists():
            self.form_class = LineBasketFormPack
            self.__is_pack = True
        else:
            self.__is_pack = False
        """"""
        return super(LinesUpdateModalBasket, self).dispatch(*args, **kwargs)"
3524,"def get_form(self, form_class=None):
        # form_kwargs = super(LineBasketUpdateModal, self).get_form_kwargs(*args, **kwargs)
        form = super(LinesUpdateModalBasket, self).get_form(form_class)
        initial = form.initial
        initial['type_tax'] = self.object.product_final.product.tax.pk
        initial['tax'] = self.object.tax_basket
        initial['price'] = float(self.object.price_base_basket) * (1 + (self.object.tax_basket / 100))
        """"""
        if self.__is_pack:
            options = []
            lang = get_language_database()

            for option in SalesLineBasketOption.objects.filter(line_budget__pk=self.__line_pk):
                initial['packs[{}]'.format(option.product_option.pk)] = option.product_final.pk
                a = {
                    'id': option.product_option.pk,
                    'label': getattr(option.product_option, lang).name,
                    'products': list(option.product_option.products_pack.all().values('pk').annotate(name=F('{}__name'.format(lang)))),
                    'selected': option.product_final.pk,
                }
                options.append(a)
            # compatibility with GenForeignKey
            initial['packs'] = json.dumps({'__JSON_DATA__': options})
        """"""
        return form"
3525,"def form_valid(self, form):
        # lb = SalesLines.objects.filter(pk=self.__line_pk).first()

        # product_old = lb.product_final
        product_pk = self.request.POST.get(""product_final"", None)
        quantity = self.request.POST.get(""quantity"", None)
        product_final = ProductFinal.objects.filter(pk=product_pk).first()
        """"""
        if product:
            is_pack = product.is_pack()
        else:
            is_pack = False
        """"""
        if product_final and quantity:
            reason = form.data['reason']
            if reason:
                reason_obj = ReasonModification.objects.filter(pk=reason).first()
                if reason_obj:
                    try:
                        with transaction.atomic():
                            result = super(LinesUpdateModalBasket, self).form_valid(form)

                            reason_basket = ReasonModificationLineBasket()
                            reason_basket.basket = self.object.basket
                            reason_basket.reason = reason_obj
                            reason_basket.line = self.object
                            reason_basket.user = get_current_user()
                            reason_basket.quantity = self.object.quantity
                            reason_basket.save()
                            return result
                    except ValidationError as e:
                        errors = form._errors.setdefault(""product_final"", ErrorList())
                        errors.append(e)
                        return super(LinesUpdateModalBasket, self).form_invalid(form)
                else:
                    errors = form._errors.setdefault(""reason"", ErrorList())
                    errors.append(_(""Reason of modification invalid""))
                    return super(LinesUpdatelOrder, self).form_invalid(form)
            else:
                errors = form._errors.setdefault(""reason"", ErrorList())
                errors.append(_(""Reason of modification invalid""))
                return super(LinesUpdatelOrder, self).form_invalid(form)

            """"""
            if is_pack:
                options = product.productfinals_option.filter(active=True)
                options_pack = []
                for option in options:
                    field = 'packs[{}]'.format(option.pk)
                    opt = self.request.POST.get(field, None)
                    if opt:
                        opt_product = ProductFinal.objects.filter(pk=opt).first()
                        if opt_product:
                            options_pack.append({
                                'product_option': option,
                                'product_final': opt_product,
                                'quantity': quantity
                            })
                        else:
                            errors = form._errors.setdefault(field, ErrorList())
                            errors.append(_(""Product Option invalid""))
                            return super(LinesUpdateModalBasket, self).form_invalid(form)
                    else:
                        errors = form._errors.setdefault(field, ErrorList())
                        errors.append(_(""Option invalid""))
                        return super(LinesUpdateModalBasket, self).form_invalid(form)
            """"""
        else:
            errors = form._errors.setdefault(""product_final"", ErrorList())
            errors.append((_(""Product invalid""), quantity, product_final))
            return super(LinesUpdateModalBasket, self).form_invalid(form)

        """"""
        ret = super(LinesUpdateModalBasket, self).form_valid(form)
        if product_old != self.object.product:
            self.object.remove_options()
        if is_pack:
            self.object.set_options(options_pack)
        return ret
        """""""
3526,"def register_signal(alias: str, signal: pyqtSignal):
        """"""
        Used to register signal at the dispatcher. Note that you can not use alias that already exists.

        :param alias: Alias of the signal. String.
        :param signal: Signal itself. Usually pyqtSignal instance.
        :return:
        """"""
        if SignalDispatcher.signal_alias_exists(alias):
            raise SignalDispatcherError('Alias ""' + alias + '"" for signal already exists!')

        SignalDispatcher.signals[alias] = signal"
3527,"def register_handler(alias: str, handler: callable):
        """"""
        Used to register handler at the dispatcher.

        :param alias: Signal alias to match handler to.
        :param handler: Handler. Some callable.
        :return:
        """"""
        if SignalDispatcher.handlers.get(alias) is None:
            SignalDispatcher.handlers[alias] = [handler]
        else:
            SignalDispatcher.handlers.get(alias).append(handler)"
3528,"def dispatch():
        """"""
        This methods runs the wheel. It is used to connect signal with their handlers, based on the aliases.

        :return:
        """"""
        aliases = SignalDispatcher.signals.keys()

        for alias in aliases:
            handlers = SignalDispatcher.handlers.get(alias)
            signal = SignalDispatcher.signals.get(alias)

            if signal is None or handlers.__len__() == 0:
                continue

            for handler in handlers:
                signal.connect(handler)"
3529,"def signal_alias_exists(alias: str) -> bool:
        """"""
        Checks if signal alias exists.
        :param alias: Signal alias.
        :return:
        """"""
        if SignalDispatcher.signals.get(alias):
            return True

        return False"
3530,"def handler_alias_exists(alias: str) -> bool:
        """"""
        Checks if handler alisa exists.
        :param alias: Handler alias.
        :return:
        """"""
        if SignalDispatcher.handlers.get(alias):
            return True

        return False"
3531,"def get_function_data(minion, jid):
    """"""AJAX access for loading function/job details.""""""
    redis = Redis(connection_pool=redis_pool)
    data = redis.get('{0}:{1}'.format(minion, jid))
    return Response(response=data, status=200, mimetype=""application/json"")"
3532,"def get_api_publisher(self, social_user):
        """"""
            and other https://vk.com/dev.php?method=wall.post
        """"""

        def _post(**kwargs):
            api = self.get_api(social_user)
            from pudb import set_trace; set_trace()
            # api.group.getInfo('uids'='your_group_id', 'fields'='members_count')
            #response = api.wall.post(**kwargs)
            return response

        return _post"
3533,"def _get_rev(self, fpath):
        """"""
        Get an SCM version number. Try svn and git.
        """"""
        rev = None
        
        try:
            cmd = [""git"", ""log"", ""-n1"", ""--pretty=format:\""%h\"""", fpath]
            rev = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()[0]
        except:
            pass
        
        if not rev:
            try:
                cmd = [""svn"", ""info"", fpath]
                svninfo = Popen(cmd,
                                stdout=PIPE,
                                stderr=PIPE).stdout.readlines()
                for info in svninfo:
                    tokens = info.split("":"")
                    if tokens[0].strip() == ""Last Changed Rev"":
                        rev = tokens[1].strip()
            except:
                pass
        
        return rev"
3534,"def execute_migrations(self, show_traceback=True):
        """"""
        Executes all pending migrations across all capable
        databases
        """"""
        all_migrations = get_pending_migrations(self.path, self.databases)
        
        if not len(all_migrations):
            sys.stdout.write(""There are no migrations to apply.\n"")
        
        for db, migrations in all_migrations.iteritems():
            connection = connections[db]
            
            # init connection
            cursor = connection.cursor()
            cursor.close()
                        
            for migration in migrations:
                migration_path = self._get_migration_path(db, migration)
                
                with Transactional():
                    sys.stdout.write(
                        ""Executing migration %r on %r...."" %
                        (migration, db)
                    )
                    created_models = self._execute_migration(
                        db,
                        migration_path,
                        show_traceback=show_traceback
                    )

                    emit_post_sync_signal(
                        created_models=created_models,
                        verbosity=self.verbosity,
                        interactive=self.interactive,
                        db=db,
                    )
            
            if self.load_initial_data:
                sys.stdout.write(
                    ""Running loaddata for initial_data fixtures on %r.\n"" % db
                )
                call_command(
                    ""loaddata"",
                    ""initial_data"",
                    verbosity=self.verbosity,
                    database=db,
                )"
3535,"def handle(self, *args, **options):
        """"""
        Upgrades the database.
        
        Executes SQL scripts that haven't already been applied to the
        database.
        """"""
        self.do_list = options.get(""do_list"")
        self.do_execute = options.get(""do_execute"")
        self.do_create = options.get(""do_create"")
        self.do_create_all = options.get(""do_create_all"")
        self.do_seed = options.get(""do_seed"")
        self.load_initial_data = options.get(""load_initial_data"", True)
        self.args = args
        
        if options.get(""path""):
            self.path = options.get(""path"")
        else:
            default_path = self._get_default_migration_path()
            self.path = getattr(
                settings, ""NASHVEGAS_MIGRATIONS_DIRECTORY"", default_path
            )
        
        self.verbosity = int(options.get(""verbosity"", 1))
        self.interactive = options.get(""interactive"")
        self.databases = options.get(""databases"")
        
        # We only use the default alias in creation scenarios (upgrades
        # default to all databases)
        if self.do_create and not self.databases:
            self.databases = [DEFAULT_DB_ALIAS]
        
        if self.do_create and self.do_create_all:
            raise CommandError(""You cannot combine --create and --create-all"")
        
        self.init_nashvegas()
        
        if self.do_create_all:
            self.create_all_migrations()
        elif self.do_create:
            assert len(self.databases) == 1
            self.create_migrations(self.databases[0])
        
        if self.do_execute:
            self.execute_migrations()
        
        if self.do_list:
            self.list_migrations()
        
        if self.do_seed:
            self.seed_migrations()"
3536,"def is_git_directory(path='.'):
    """"""
    Checks if given directory is a git repository
    :param path: path to check
    :return: True if it's a git repo and False otherwise
    """"""
    try:
        dulwich.repo.Repo.discover(path)
    except dulwich.errors.NotGitRepository:
        return False

    return True"
3537,"def get_git_remote_url(path='.', remote='origin'):
    """"""
    Get git remote url
    :param path: path to repo
    :param remote:
    :return: remote url or exception
    """"""
    return dulwich.repo.Repo.discover(path).get_config()\
        .get((b'remote', remote.encode('utf-8')), b'url').decode('utf-8')"
3538,"def plantuml(desc):
    """"""Generate plantuml class diagram

    :param desc: result of sadisplay.describe function

    Return plantuml class diagram string
    """"""

    classes, relations, inherits = desc

    result = [
        '@startuml',
        'skinparam defaultFontName Courier',
    ]

    for cls in classes:
        # issue #11 - tabular output of class members (attrs)
        # http://stackoverflow.com/a/8356620/258194

        # build table
        class_desc = []
        # table columns
        class_desc += [(i[1], i[0]) for i in cls['cols']]
        # class properties
        class_desc += [('+', i) for i in cls['props']]
        # methods
        class_desc += [('%s()' % i, '') for i in cls['methods']]

        result.append(
            'Class %(name)s {\n%(desc)s\n}' % {
                'name': cls['name'],
                'desc': '\n'.join(tabular_output(class_desc)),
            }
        )

    for item in inherits:
        result.append(""%(parent)s <|-- %(child)s"" % item)

    for item in relations:
        result.append(""%(from)s <--o %(to)s: %(by)s"" % item)

    result += [
        'right footer generated by sadisplay v%s' % __version__,
        '@enduml',
    ]

    return '\n\n'.join(result)"
3539,"def dot(desc, color, title=""Trump's ORM""):
    """"""Generate dot file

    :param desc: result of sadisplay.describe function

    Return string
    """"""

    classes, relations, inherits = desc
	
    CLASS_TEMPLATE = """"""
        %(name)s [label=<
        <TABLE BGCOLOR=""{ncolor}"" BORDER=""0""
            CELLBORDER=""0"" CELLSPACING=""0"">
                <TR><TD COLSPAN=""2"" CELLPADDING=""4""
                        ALIGN=""CENTER"" BGCOLOR=""{ncolor}""
                ><FONT FACE=""Helvetica Bold"" COLOR=""black""
                >%(name)s</FONT></TD></TR>%(cols)s%(props)s%(methods)s
        </TABLE>
    >]
    """""".format(**color)

    COLUMN_TEMPLATE = """"""<TR><TD ALIGN=""LEFT"" BORDER=""0""
        BGCOLOR=""{ccolor}""
        ><FONT FACE=""Bitstream Vera Sans"">%(name)s</FONT
        ></TD><TD BGCOLOR=""{ccolor}"" ALIGN=""RIGHT""
        ><FONT FACE=""Bitstream Vera Sans"">%(type)s</FONT
        ></TD></TR>"""""".format(**color)

    PROPERTY_TEMPLATE = """"""<TR><TD ALIGN=""LEFT"" BORDER=""0""
        BGCOLOR=""{pcolor}""
        ><FONT FACE=""Bitstream Vera Sans"">%(name)s</FONT></TD
        ><TD BGCOLOR=""{pcolor}"" ALIGN=""RIGHT""
        ><FONT FACE=""Bitstream Vera Sans"">PROP</FONT
        ></TD></TR>"""""".format(**color)

    METHOD_TEMPLATE = """"""<TR><TD ALIGN=""LEFT"" BORDER=""0""
        BGCOLOR=""{mcolor}""
        ><FONT FACE=""Bitstream Vera Sans"">%(name)s()</FONT></TD
        ><TD BGCOLOR=""{mcolor}"" ALIGN=""RIGHT""
        ><FONT FACE=""Bitstream Vera Sans"">METH</FONT
        ></TD></TR>"""""".format(**color)

    EDGE_INHERIT = ""\tedge [\n\t\tarrowhead = empty\n\t]""
    INHERIT_TEMPLATE = ""\t%(child)s -> %(parent)s \n""

    EDGE_REL = ""\tedge [\n\t\tarrowhead = ediamond\n\t\tarrowtail = open\n\t]""
    RELATION_TEMPLATE = ""\t\""%(from)s\"" -> \""%(to)s\"" [label = \""%(by)s\""]""

    result = [""""""
        digraph G {
            label = ""%s"";
            fontname = ""Bitstream Vera Sans""
            fontsize = 12

            node [
                fontname = ""Bitstream Vera Sans""
                fontsize = 8
                shape = ""plaintext""
            ]

            edge [
                fontname = ""Bitstream Vera Sans""
                fontsize = 8
            ]
    """""" % title]

    for cls in classes:
        cols = ' '.join([
            COLUMN_TEMPLATE % {'type': c[0], 'name': c[1]} for c in cls['cols']
        ])
        props = ' '.join([
            PROPERTY_TEMPLATE % {'name': p} for p in cls['props']
        ])
        methods = ' '.join([
            METHOD_TEMPLATE % {'name': m} for m in cls['methods']
        ])
        renderd = CLASS_TEMPLATE % {
            'name': cls['name'],
            'cols': cols,
            'props': props,
            'methods': methods,
        }

        result.append(renderd)

    result += [EDGE_INHERIT]
    for item in inherits:
        result.append(INHERIT_TEMPLATE % item)

    result += [EDGE_REL]
    for item in relations:
        result.append(RELATION_TEMPLATE % item)

    result += [
        '}'
    ]

    return '\n'.join(result)"
3540,"def is_reference_target(resource, rtype, label):
    """""" Return true if the resource has this rtype with this label """"""

    prop = resource.props.references.get(rtype, False)
    if prop:
        return label in prop"
3541,"def get_sources(self, resources):
        """""" Filter resources based on which have this reference """"""

        rtype = self.rtype  # E.g. category
        label = self.props.label  # E.g. category1
        result = [
            resource
            for resource in resources.values()
            if is_reference_target(resource, rtype, label)
        ]
        return result"
3542,"def setup(app: Sphinx):
    """""" Initialize Kaybee as a Sphinx extension """"""

    # Scan for directives, first in the system, second in the docs project
    importscan.scan(plugins)
    dectate.commit(kb)

    app.add_config_value('kaybee_settings', KaybeeSettings(), 'html')
    bridge = 'kaybee.plugins.postrenderer.config.KaybeeBridge'
    app.config.template_bridge = bridge

    app.connect('env-updated', flush_everything)
    app.connect(SphinxEvent.BI.value,
                # pragma nocover
                lambda sphinx_app: EventAction.call_builder_init(
                    kb, sphinx_app)
                )
    app.connect(SphinxEvent.EPD.value,
                # pragma nocover
                lambda sphinx_app, sphinx_env,
                       docname: EventAction.call_purge_doc(
                    kb, sphinx_app, sphinx_env, docname)
                )

    app.connect(SphinxEvent.EBRD.value,
                # pragma nocover
                lambda sphinx_app, sphinx_env,
                       docnames: EventAction.call_env_before_read_docs(
                    kb, sphinx_app, sphinx_env, docnames)
                )

    app.connect(SphinxEvent.DREAD.value,
                # pragma nocover
                lambda sphinx_app,
                       doctree: EventAction.call_env_doctree_read(
                    kb, sphinx_app, doctree)
                )

    app.connect(SphinxEvent.DRES.value,
                # pragma nocover
                lambda sphinx_app, doctree,
                       fromdocname: EventAction.call_doctree_resolved(
                    kb, sphinx_app, doctree, fromdocname)
                )

    app.connect(SphinxEvent.EU.value,
                # pragma nocover
                lambda sphinx_app, sphinx_env: EventAction.call_env_updated(
                    kb, sphinx_app, sphinx_env)
                )

    app.connect(SphinxEvent.HCP.value,
                # pragma nocover
                lambda sphinx_app: EventAction.call_html_collect_pages(
                    kb, sphinx_app)
                )

    app.connect(SphinxEvent.ECC.value,
                # pragma nocover
                lambda sphinx_builder,
                       sphinx_env: EventAction.call_env_check_consistency(
                    kb, sphinx_builder, sphinx_env)
                )

    app.connect(SphinxEvent.MR.value,
                # pragma nocover
                lambda sphinx_app, sphinx_env, node,
                       contnode: EventAction.call_missing_reference(
                    kb, sphinx_app, sphinx_env, node, contnode)
                )

    app.connect(SphinxEvent.HPC.value,
                # pragma nocover
                lambda sphinx_app, pagename, templatename, context,
                       doctree: EventAction.call_html_page_context(
                    kb, sphinx_app, pagename, templatename, context, doctree)
                )

    return dict(
        version=__version__,
        parallel_read_safe=False
    )"
3543,"def icon(self):
        """"""
        Returns the icon filepath for this plugin.
        
        :return     <str>
        """"""
        path = self._icon
        if not path:
            return ''

        path = os.path.expandvars(os.path.expanduser(path))
        if path.startswith('.'):
            base_path = os.path.dirname(self.filepath())
            path = os.path.abspath(os.path.join(base_path, path))

        return path"
3544,"def addPluginPath(cls, pluginpath):
        """"""
        Adds the plugin path for this class to the given path.  The inputted
        pluginpath value can either be a list of strings, or a string
        containing paths separated by the OS specific path separator (':' on
        Mac & Linux, ';' on Windows)
        
        :param      pluginpath | [<str>, ..] || <str>
        """"""
        prop_key = '_%s__pluginpath' % cls.__name__
        curr_path = getattr(cls, prop_key, None)
        if not curr_path:
            curr_path = []
            setattr(cls, prop_key, curr_path)

        if isinstance(pluginpath, basestring):
            pluginpath = pluginpath.split(os.path.pathsep)

        for path in pluginpath:
            if not path:
                continue

            path = os.path.expanduser(os.path.expandvars(path))
            paths = path.split(os.path.pathsep)

            if len(paths) > 1:
                cls.addPluginPath(paths)
            else:
                curr_path.append(path)"
3545,"def pluginRegisterType(cls):
        """"""
        Returns the register type for this plugin class.
        
        :return     <Plugin.RegisterType>
        """"""
        default = Plugin.Type.Module
        default |= Plugin.Type.Package
        default |= Plugin.Type.RegistryFile

        return getattr(cls, '_%s__pluginRegisterType', default)"
3546,"def loadPlugins(cls):
        """"""
        Initializes the plugins by loading modules from the inputted paths.
        """"""
        plugs = getattr(cls, '_%s__plugins' % cls.__name__, None)
        if plugs is not None:
            return

        plugs = {}
        setattr(cls, '_%s__plugins' % cls.__name__, plugs)
        typ = cls.pluginRegisterType()

        for path in cls.pluginPath():
            base_package = projex.packageFromPath(path)
            base_path = os.path.normpath(projex.packageRootPath(path))

            # make sure it is at the front of the path
            if base_path in sys.path:
                sys.path.remove(base_path)

            sys.path.insert(0, base_path)
            processed = ['__init__']

            # load support for registries
            if typ & Plugin.Type.RegistryFile:
                files = glob.glob(os.path.join(path, '*/register.xml'))
                for file_ in files:
                    name = os.path.normpath(file_).split(os.path.sep)[-2]
                    processed.append(name)

                    try:
                        proxy = PluginProxy.fromFile(cls, file_)
                        cls.register(proxy)

                    except Exception, e:
                        name = projex.text.pretty(name)
                        err = Plugin(name)
                        err.setError(e)
                        err.setFilepath(file_)

                        cls.register(err)

                        # log the error
                        msg = ""%s.plugin('%s') failed to load from %s.""
                        logger.warning(msg % (cls.__name__, name, file_))
                        logger.error(e)

            # load support for packages
            if typ & Plugin.Type.Package:
                files = glob.glob(os.path.join(path, '*/__init__.py'))
                for file_ in files:
                    name = os.path.normpath(file_).split(os.path.sep)[-2]
                    if name in processed:
                        continue

                    processed.append(name)
                    package = '.'.join([base_package, name]).strip('.')
                    if not package:
                        continue

                    try:
                        __import__(package)

                    except Exception, e:
                        name = projex.text.pretty(name)
                        err = Plugin(name)
                        err.setError(e)
                        err.setFilepath(file_)

                        cls.register(err)

                        # log the error
                        msg = ""%s.plugin('%s') failed to load from %s.""
                        logger.warning(msg % (cls.__name__, name, file_))
                        logger.error(e)

            # load support for modules
            if typ & Plugin.Type.Module:
                files = glob.glob(os.path.join(path, '*.py'))
                for file_ in files:
                    name = os.path.basename(file_).split('.')[0]
                    if name in processed:
                        continue

                    processed.append(name)
                    package = '.'.join([base_package, name]).strip('.')
                    if not package:
                        continue

                    try:
                        __import__(package)

                    except Exception, e:
                        name = projex.text.pretty(name)
                        err = Plugin(name)
                        err.setError(e)
                        err.setFilepath(file_)

                        cls.register(err)

                        # log the error
                        msg = ""%s.plugin('%s') failed to load from %s.""
                        logger.warning(msg % (cls.__name__, name, file_))
                        logger.error(e)"
3547,"def plugin(cls, name):
        """"""
        Retrieves the plugin based on the inputted name.
        
        :param      name | <str>
        
        :return     <Plugin>
        """"""
        cls.loadPlugins()
        plugs = getattr(cls, '_%s__plugins' % cls.__name__, {})
        return plugs.get(nstr(name))"
3548,"def pluginNames(cls, enabled=True):
        """"""
        Returns the names of the plugins for a given class.
        
        :param      enabled     | <bool> || None
        
        :return     [<str>, ..]
        """"""
        return map(lambda x: x.name(), cls.plugins(enabled))"
3549,"def plugins(cls, enabled=True):
        """"""
        Returns the plugins for the given class.
        
        :param      enabled | <bool> || None
        
        :return     [<Plugin>, ..]
        """"""
        cls.loadPlugins()
        plugs = getattr(cls, '_%s__plugins' % cls.__name__, {}).values()
        if enabled is None:
            return plugs

        return filter(lambda x: x.isEnabled() == enabled, plugs)"
3550,"def register(cls, plugin):
        """"""
        Registers the given plugin instance to this system.  If a plugin with
        the same name is already registered, then this plugin will not take
        effect.  The first registered plugin is the one that is used.
        
        :param      plugin | <Plugin>
        
        :return     <bool>
        """"""
        plugs = getattr(cls, '_%s__plugins' % cls.__name__, None)
        if plugs is None:
            cls.loadPlugins()

        plugs = getattr(cls, '_%s__plugins' % cls.__name__, {})

        if plugin.name() in plugs:
            inst = plugs[plugin.name()]

            # assign the plugin instance to the proxy
            if isinstance(inst, PluginProxy) and \
                    not isinstance(plugin, PluginProxy) and \
                    not inst._instance:
                inst._instance = plugin
                return True

            return False

        plugs[plugin.name()] = plugin
        setattr(cls, '_%s__plugins' % cls.__name__, plugs)
        return True"
3551,"def setPluginPath(cls, pluginpath):
        """"""
        Sets the plugin path for this class to the given path.  The inputted
        pluginpath value can either be a list of strings, or a string
        containing paths separated by the OS specific path separator (':' on
        Mac & Linux, ';' on Windows)
        
        :param      pluginpath | [<str>, ..] || <str>
        """"""
        setattr(cls, '_%s__pluginpath' % cls.__name__, None)
        cls.addPluginPath(pluginpath)"
3552,"def unregister(cls, plugin):
        """"""
        Unregisters the given plugin from the system based on its name.
        
        :param      plugin | <Plugin>
        """"""
        plugs = getattr(cls, '_%s__plugins' % cls.__name__, {})
        try:
            plugs.pop(plugin.name())
        except AttributeError:
            pass
        except ValueError:
            pass"
3553,"def loadInstance(self):
        """"""
        Loads the plugin from the proxy information that was created from the
        registry file.
        """"""
        if self._loaded:
            return

        self._loaded = True
        module_path = self.modulePath()

        package = projex.packageFromPath(module_path)
        path = os.path.normpath(projex.packageRootPath(module_path))

        if path in sys.path:
            sys.path.remove(path)

        sys.path.insert(0, path)

        try:
            __import__(package)

        except Exception, e:
            err = Plugin(self.name(), self.version())
            err.setError(e)
            err.setFilepath(module_path)

            self._instance = err

            self.setError(e)

            msg = ""%s.plugin('%s') errored loading instance from %s""
            opts = (self.proxyClass().__name__, self.name(), module_path)
            logger.warning(msg % opts)
            logger.error(e)"
3554,"def modulePath(self):
        """"""
        Returns the module path information for this proxy plugin.  This path
        will represent the root module that will be imported when the instance
        is first created of this plugin.
        
        :return     <str>
        """"""
        base_path = os.path.dirname(self.filepath())
        module_path = self.importPath()

        module_path = os.path.expanduser(os.path.expandvars(module_path))
        if module_path.startswith('.'):
            module_path = os.path.abspath(os.path.join(base_path, module_path))

        return module_path"
3555,"def fromFile(cls, filepath):
        """"""
        Creates a proxy instance from the inputted registry file.
        
        :param      filepath | <str>
        
        :return     <PluginProxy> || None
        """"""
        xdata = ElementTree.parse(nstr(filepath))
        xroot = xdata.getroot()

        # collect variable information
        name = xroot.get('name')
        ver = float(xroot.get('version', '1.0'))

        if not name:
            name = os.path.basename(filepath).split('.')
            if name == '__init__':
                name = os.path.normpath(filepath).split(os.path.sep)[-2]
            name = projex.text.pretty(name)

        icon = xroot.get('icon', './icon.png')

        ximport = xroot.find('import')
        if ximport is not None:
            importpath = ximport.get('path', './__init__.py')
        else:
            importpath = './__init__.py'

        params = {'description': '', 'author': '', 'email': '', 'url': ''}
        for param, default in params.items():
            xdata = xroot.find(param)
            if xdata is not None:
                params[param] = xdata.text

        # generate the proxy information
        proxy = PluginProxy(cls, name, ver)
        proxy.setImportPath(importpath)
        proxy.setDescription(params['description'])
        proxy.setAuthor(params['author'])
        proxy.setEmail(params['email'])
        proxy.setUrl(params['url'])
        proxy.setFilepath(filepath)

        return proxy"
3556,"def clean_resource_json(resource_json):
    """""" The catalog wants to be smaller, let's drop some stuff """"""

    for a in ('parent_docname', 'parent', 'template', 'repr', 'series'):
        if a in resource_json:
            del resource_json[a]

    props = resource_json['props']
    for prop in (
            'acquireds', 'style', 'in_nav', 'nav_title', 'weight',
            'auto_excerpt'):
        if prop in props:
            del props[prop]

    return resource_json"
3557,"def resources_to_json(resources):
    """""" Make a JSON/catalog representation of the resources db """"""
    return {
        docname: clean_resource_json(resource.__json__(resources))
        for (docname, resource)
        in resources.items()
    }"
3558,"def references_to_json(resources, references):
    """""" Make a JSON/catalog representation of the references db,
     including the count for each """"""

    dump_references = {}
    for reftype, refvalue in references.items():
        dump_references[reftype] = {}
        for label, reference_resource in refvalue.items():
            target_count = len(reference_resource.get_sources(resources))
            dump_references[reftype][label] = dict(
                count=target_count,
                docname=reference_resource.docname
            )

    return dump_references"
3559,"def get(self,
            url,
            params=None,
            cache_cb=None,
            **kwargs):
        """"""
        Make http get request.

        :param url:
        :param params:
        :param cache_cb: (optional) a function that taking requests.Response
            as input, and returns a bool flag, indicate whether should update the cache.
        :param cache_expire: (optional).
        :param kwargs: optional arguments.
        """"""
        if self.use_random_user_agent:
            headers = kwargs.get(""headers"", dict())
            headers.update({Headers.UserAgent.KEY: Headers.UserAgent.random()})
            kwargs[""headers""] = headers

        url = add_params(url, params)

        cache_consumed, value = self.try_read_cache(url)
        if cache_consumed:
            response = requests.Response()
            response.url = url
            response._content = value
        else:
            response = self.ses.get(url, **kwargs)

        if self.should_we_update_cache(response, cache_cb, cache_consumed):
            self.cache.set(
                url, response.content,
                expire=kwargs.get(""cache_expire"", self.cache_expire),
            )
        return response"
3560,"def get_html(self,
                 url,
                 params=None,
                 cache_cb=None,
                 decoder_encoding=None,
                 decoder_errors=url_specified_decoder.ErrorsHandle.strict,
                 **kwargs):
        """"""
        Get html of an url.
        """"""
        response = self.get(
            url=url,
            params=params,
            cache_cb=cache_cb,
            **kwargs
        )
        return url_specified_decoder.decode(
            binary=response.content,
            url=response.url,
            encoding=decoder_encoding,
            errors=decoder_errors,
        )"
3561,"def download(self,
                 url,
                 dst,
                 params=None,
                 cache_cb=None,
                 overwrite=False,
                 stream=False,
                 minimal_size=-1,
                 maximum_size=1024 ** 6,
                 **kwargs):
        """"""
        Download binary content to destination.

        :param url: binary content url
        :param dst: path to the 'save_as' file
        :param cache_cb: (optional) a function that taking requests.Response
            as input, and returns a bool flag, indicate whether should update the cache.
        :param overwrite: bool,
        :param stream: bool, whether we load everything into memory at once, or read
            the data chunk by chunk
        :param minimal_size: default -1, if response content smaller than
          minimal_size, then delete what just download.
        :param maximum_size: default 1GB, if response content greater than
          maximum_size, then delete what just download.
        """"""
        response = self.get(
            url,
            params=params,
            cache_cb=cache_cb,
            stream=stream,
            **kwargs
        )

        if not overwrite:  # pragma: no cover
            if os.path.exists(dst):
                raise OSError(""'%s' exists!"" % dst)

        if stream:
            chunk_size = 1024 * 1024
            downloaded_size = 0
            with atomic_write(dst, mode=""wb"") as f:
                for chunk in response.iter_content(chunk_size):
                    if not chunk:  # pragma: no cover
                        break
                    f.write(chunk)
                    downloaded_size += chunk_size
                if (downloaded_size < minimal_size) or (downloaded_size > maximum_size):
                    self.raise_download_oversize_error(
                        url, downloaded_size, minimal_size, maximum_size)
        else:
            content = response.content
            downloaded_size = sys.getsizeof(content)
            if (downloaded_size < minimal_size) or (downloaded_size > maximum_size):
                self.raise_download_oversize_error(
                    url, downloaded_size, minimal_size, maximum_size)
            else:
                with atomic_write(dst, mode=""wb"") as f:
                    f.write(content)"
3562,"def option(*args, **kwargs):
    """"""Decorator to add an option to the optparser argument of a Cmdln
    subcommand

    To add a toplevel option, apply the decorator on the class itself. (see
    p4.py for an example)
    
    Example:
        @cmdln.option(""-E"", dest=""environment_path"")
        class MyShell(cmdln.Cmdln):
            @cmdln.option(""-f"", ""--force"", help=""force removal"")
            def do_remove(self, subcmd, opts, *args):
                #...
    """"""
    def decorate_sub_command(method):
        """"""create and add sub-command options""""""
        if not hasattr(method, ""optparser""):
            method.optparser = SubCmdOptionParser()
        method.optparser.add_option(*args, **kwargs)
        return method
    def decorate_class(klass):
        """"""store toplevel options""""""
        assert _forgiving_issubclass(klass, Cmdln)
        _inherit_attr(klass, ""toplevel_optparser_options"", [], cp=lambda l: l[:])
        klass.toplevel_optparser_options.append( (args, kwargs) )
        return klass
        
    #XXX Is there a possible optimization for many options to not have a
    #    large stack depth here?
    def decorate(obj):
        if _forgiving_issubclass(obj, Cmdln):
            return decorate_class(obj)
        else:
            return decorate_sub_command(obj)
    return decorate"
3563,"def _inherit_attr(klass, attr, default, cp):
    """"""Inherit the attribute from the base class

    Copy `attr` from base class (otherwise use `default`). Copying is done using
    the passed `cp` function.

    The motivation behind writing this function is to allow inheritance among
    Cmdln classes where base classes set 'common' options using the
    `@cmdln.option` decorator. To ensure this, we must not write to the base
    class's options when handling the derived class.
    """"""
    if attr not in klass.__dict__:
        if hasattr(klass, attr):
            value = cp(getattr(klass, attr))
        else:
            value = default
        setattr(klass, attr, value)"
3564,"def _forgiving_issubclass(derived_class, base_class):
    """"""Forgiving version of ``issubclass``

    Does not throw any exception when arguments are not of class type
    """"""
    return (type(derived_class) is ClassType and \
            type(base_class) is ClassType and \
            issubclass(derived_class, base_class))"
3565,"def _dispatch_cmd(self, handler, argv):
        """"""Introspect sub-command handler signature to determine how to
        dispatch the command. The raw handler provided by the base
        'RawCmdln' class is still supported:

            def do_foo(self, argv):
                # 'argv' is the vector of command line args, argv[0] is
                # the command name itself (i.e. ""foo"" or an alias)
                pass

        In addition, if the handler has more than 2 arguments option
        processing is automatically done (using optparse):

            @cmdln.option('-v', '--verbose', action='store_true')
            def do_bar(self, subcmd, opts, *args):
                # subcmd = <""bar"" or an alias>
                # opts = <an optparse.Values instance>
                if opts.verbose:
                    print ""lots of debugging output...""
                # args = <tuple of arguments>
                for arg in args:
                    bar(arg)

        TODO: explain that ""*args"" can be other signatures as well.

        The `cmdln.option` decorator corresponds to an `add_option()`
        method call on an `optparse.OptionParser` instance.

        You can declare a specific number of arguments:

            @cmdln.option('-v', '--verbose', action='store_true')
            def do_bar2(self, subcmd, opts, bar_one, bar_two):
                #...

        and an appropriate error message will be raised/printed if the
        command is called with a different number of args.
        """"""
        co_argcount = handler.__func__.__code__.co_argcount
        if co_argcount == 2:   # handler ::= do_foo(self, argv)
            return handler(argv)
        elif co_argcount >= 3: # handler ::= do_foo(self, subcmd, opts, ...)
            try:
                optparser = handler.optparser
            except AttributeError:
                optparser = handler.__func__.optparser = SubCmdOptionParser()
            assert isinstance(optparser, SubCmdOptionParser)

            # apply subcommand options' defaults from config files, if any.
            subcmd = handler.__name__.split('do_', 1)[1]
            optparser.set_defaults(**self.get_option_defaults(subcmd))
            
            optparser.set_cmdln_info(self, argv[0])
            try:
                opts, args = optparser.parse_args(argv[1:])
            except StopOptionProcessing:
                #TODO: this doesn't really fly for a replacement of
                #      optparse.py behaviour, does it?
                return 0 # Normal command termination

            try:
                return handler(argv[0], opts, *args)
            except TypeError:
                _, ex, _ = sys.exc_info()
                # Some TypeError's are user errors:
                #   do_foo() takes at least 4 arguments (3 given)
                #   do_foo() takes at most 5 arguments (6 given)
                #   do_foo() takes exactly 5 arguments (6 given)
                #   do_foo() takes exactly 5 positional arguments (6 given)
                # Raise CmdlnUserError for these with a suitably
                # massaged error message.
                tb = sys.exc_info()[2] # the traceback object
                if tb.tb_next is not None:
                    # If the traceback is more than one level deep, then the
                    # TypeError do *not* happen on the ""handler(...)"" call
                    # above. In that we don't want to handle it specially
                    # here: it would falsely mask deeper code errors.
                    raise
                msg = ex.args[0]
                match = _INCORRECT_NUM_ARGS_RE.search(msg)
                if match:
                    msg = list(match.groups())
                    msg[1] = int(msg[1]) - 3
                    if msg[1] == 1:
                        msg[2] = msg[2].replace(""arguments"", ""argument"")
                    msg[3] = int(msg[3]) - 3
                    msg = ''.join(map(str, msg))
                    raise CmdlnUserError(msg)
                else:
                    raise
        else:
            raise CmdlnError(""incorrect argcount for %s(): takes %d, must ""
                             ""take 2 for 'argv' signature or 3+ for 'opts' ""
                             ""signature"" % (handler.__name__, co_argcount))"
3566,"def aquireMs1CalibrationData(msrunContainer, specfile, siiArrays=None,
    lockMass=None, **kwargs):
    """"""Aquire mass error data, observed vs expected m/z, for calibration of MS1
    ion m/z values. Expected m/z values can be of ambient ions with known exact
    masses and from identified precursor masses of peptide spectrum matching
    results.

    :param msrunContainer: intance of :class:`maspy.core.MsrunContainer`
    :param specfile: filename of an ms-run file, used to extract mass error data
    :param siiArrays: optional, a dictionary of numpy.arrays
        Must provide the keys ""obsMz"" (observed precursor m/z), ""excMz"" (exact
        calculated m/z of the identified peptide) and ""precursorId"" (the scan id
        of the MS1 that preceeded the respective MSn scan).
    :param lockMass: None, True or a list of lock mass m/z values
        If ``None`` lock masses are not used to aquire calibration data. If
        ``True`` use the seven predefined lock mass values. Else use the
        specified lock mass m/z values.
    :param scanRange: a list of positive and negative int values
        When using MSn spectrum identifications for aquiring calibration data
        the m/z value of the peptide precursor is used to find the corresponding
        ion m/z value in the preceeding MS1 scan. By adding positive and
        negative integers to the ``scanRange`` parameter the subsequent and
        preceeding MS1 scans are also used to aquire calibration data from the
        same peptide precursor. By default ""[-1, 0, 1]"".
    :param massTolerance: float or int
        The maximal allowed deviation for matching two masses. By default
        ""10 * 1e-6"" which corresponds to 10ppm.
    :param toleranceMode: ""relative"" or ""absolute""
        Specifies how the ``massTolerance`` value is applied, by default
        ""relative
    :param topIntMatches: bool, by default False
    :param useTopIntIons: bool,  by default False

    :returns: {'siId': numpy.array([str, ...]),
               'rt': numpy.array([float, ...]),
               'obsMz': numpy.array([float, ...]),
               'excMz': numpy.array([float, ...]),
               'relDev': numpy.array([float, ...]),
               'absDev': numpy.array([float, ...]),
               'int': numpy.array([float, ...])
               'source': numpy.array(['psm' or 'lock'])
               }
    """"""
    scanRange = kwargs.get('scanRange', [-1, 0, 1])
    massTolerance = kwargs.get('massTolerance', 10*1e-6)
    toleranceMode = kwargs.get('toleranceMode', 'relative')
    topIntMatches = kwargs.get('topIntMatches', False)
    useTopIntIons = kwargs.get('useTopIntIons', False)

    ms1Arrays = msrunContainer.getArrays(['rt'], specfiles=specfile, sort='rt',
                                         selector=lambda si: si.msLevel==1
                                         )
    ms1Arrays['calibrationMz'] = [list() for x in range(len(ms1Arrays['id']))]

    if lockMass is not None:
        if lockMass == True: #Use default lock mass values
            lockMass = [445.12002, 519.13882, 593.15761, 667.1764,
                        536.16536, 610.18416, 684.20295]
        lockMassTuples = [(lockMassMz, lockMassMz, 'lock') for lockMassMz in lockMass]
        for ms1ArrayPos in range(len(ms1Arrays['id'])):
            ms1Arrays['calibrationMz'][ms1ArrayPos].extend(lockMassTuples)

    if siiArrays is not None:
        precursorArrayLookup = {__: _ for _, __ in enumerate(ms1Arrays['id'])}
        for obsMz, excMz, precursorId in zip(siiArrays['obsMz'],
                                             siiArrays['excMz'],
                                             siiArrays['precursorId']
                                             ):
            #find array position of the precursor scan
            precursorArrayPos = precursorArrayLookup[precursorId]
            #also look for the peptide precursor ions in earlier and later MS1
            #scans by modifying the precursorArrayPos according to the numbers
            #in ""scanRange""
            for posModifier in scanRange:
                _arrayPos = precursorArrayPos + posModifier
                try:
                    ms1Arrays['calibrationMz'][_arrayPos].append((obsMz, excMz, 'psm'))
                except IndexError:
                    #An IndexError can occur because of the ""scanRange""
                    #extension at the end and the beginning of the MS1 scans
                    pass

    calibrationDataMs1 = {_: [] for _ in ['siId', 'rt', 'obsMz', 'excMz', 'iit',
                                          'source', 'relDev', 'absDev', 'int'
                                          ]
                          }
    for siId, rtMs1, calibrationMz in zip(ms1Arrays['id'],
                                          ms1Arrays['rt'],
                                          ms1Arrays['calibrationMz']
                                          ):
        if len(calibrationMz) == 0:
            continue

        ionMzListMs1 = msrunContainer.saic[specfile][siId].arrays['mz']
        ionIntListMs1 = msrunContainer.saic[specfile][siId].arrays['i']

        if useTopIntIons:
            ionIntMask = ionIntListMs1.argsort()[::-1][:useTopIntIons]
            ionMzListMs1 = ionMzListMs1[ionIntMask]
            ionIntListMs1 = ionIntListMs1[ionIntMask]

        currCalibrationData = ddict(list)
        for obsMz, excMz, source in calibrationMz:
            limHigh = obsMz * (1+massTolerance)
            limLow = obsMz * (1-massTolerance)
            pL = bisect.bisect_left(ionMzListMs1, limLow)
            pH = bisect.bisect_right(ionMzListMs1, limHigh)

            if pH - pL <= 0:
                continue
            ionMatchMask = abs(ionMzListMs1[pL:pH] - obsMz).argmin()
            ms1Mz = ionMzListMs1[pL:pH][ionMatchMask]
            ms1Int = ionIntListMs1[pL:pH][ionMatchMask]

            #TODO: rel dev calculation changed, test dataFit functions!!!
            relDevObs = (1 - ms1Mz / obsMz)
            absDevObs = obsMz - ms1Mz
            relDevExc = (1 - ms1Mz / excMz)
            absDevExc = excMz - ms1Mz
            if abs(relDevObs) <= massTolerance:
                currCalibrationData['siId'].append(siId)
                currCalibrationData['rt'].append(rtMs1)
                currCalibrationData['obsMz'].append(ms1Mz)
                currCalibrationData['excMz'].append(excMz)
                currCalibrationData['relDev'].append(relDevExc)
                currCalibrationData['absDev'].append(absDevExc)
                currCalibrationData['int'].append(ms1Int)
                currCalibrationData['iit'].append(msrunContainer.sic[specfile][siId].iit)
                currCalibrationData['source'].append(source)
        if len(currCalibrationData['siId']) == 0:
            continue
        for key in currCalibrationData.keys():
            calibrationDataMs1[key].extend(currCalibrationData[key])

    # Convert calibration data into numpy arrays
    for key in calibrationDataMs1.keys():
        calibrationDataMs1[key] = numpy.array(calibrationDataMs1[key])

    return calibrationDataMs1"
3567,"def timecalMs1DataMedian(msrunContainer, specfile, calibrationData,
                         minDataPoints=50, deviationKey='relDev'):
    """"""Generates a calibration value for each MS1 scan by calculating the median
    deviation

    :param msrunContainer: intance of :class:`maspy.core.MsrunContainer`
    :param specfile: filename of an ms-run file, used to generate an calibration
        value for each MS1 spectrum item.
    :param calibrationData: a dictionary of ``numpy.arrays`` containing
        calibration data, as returned by :func:`aquireMs1CalibrationData()`
    :param minDataPoints: The minimal number of data points necessary to
        calculate the calibration value, default value is ""50"". The calibration
        value for each scan is calulated as the median of all calibration data
        points present for this scan. However, if the number of data points is
        less then specified by ``minDataPoints` the data points of the
        preceeding and subsequent scans are added until the minimal number of
        data points is reached.
    :param deviationKey: the ``calibrationData`` key which contains the
        calibration data that should be used.

    :returns: a dictionary containing the calibration values for each MS1
        ``Si``. ``{si.id: {'calibValue': float, 'n': int, 'data': list}``
    """"""
    corrData = dict()
    _posDict = dict()
    pos = 0
    for si in msrunContainer.getItems(specfiles=specfile, sort='rt',
                                      selector=lambda si: si.msLevel==1
                                      ):
        corrData[si.id] =  {'calibValue': float(), 'n': int(), 'data': list()}
        _posDict[pos] = si.id
        pos += 1

    for siId, deviation in zip(calibrationData['siId'],
                               calibrationData[deviationKey]):
        corrData[siId]['data'].append(deviation)
        corrData[siId]['n'] += 1

    for pos in range(len(corrData)):
        entry = corrData[_posDict[pos]]

        _data = [entry['data']]
        _n = entry['n']
        expansion = 0
        while _n < minDataPoints:
            expansion += 1
            try:
                expData = corrData[_posDict[pos+expansion]]['data']
                _data.append(expData)
                _n += corrData[_posDict[pos+expansion]]['n']
            except KeyError:
                pass
            try:
                expData = corrData[_posDict[pos-expansion]]['data']
                _data.append(expData)
                _n += corrData[_posDict[pos-expansion]]['n']
            except KeyError:
                pass

        if len(entry['data']) > 0:
            median = numpy.median(entry['data'])
            factor = 1
        else:
            median = float()
            factor = 0

        for expData in _data[1:]:
            if len(expData) > 0:
                median += numpy.median(expData) * 0.5
                factor += 0.5
        median = median / factor
        entry['calibValue'] = median
    return corrData"
3568,"def applyTimeCalMs1(msrunContainer, specfile, correctionData, **kwargs):
    """"""Applies correction values to the MS1 ion m/z arrays in order to correct
    for a time dependent m/z error.

    :param msrunContainer: intance of :class:`maspy.core.MsrunContainer`,
        containing the :class:`maspy.core.Sai` items of the ""specfile"".
    :param specfile: filename of an ms-run file to which the m/z calibration
        should be applied
    :param correctionData: a dictionary containing the calibration values for
        each MS1 ``Si``, as returned by :func:`timecalMs1DataMedian()`.
        ``{si.id: {'calibValue': float}``
    :param toleranceMode: ""relative"" or ""absolute""
        Specifies how the ``massTolerance`` value is applied, by default
        ""relative"".
    """"""
    toleranceMode = kwargs.get('toleranceMode', 'relative')

    if toleranceMode == 'relative':
        for siId in correctionData:
            calibValue = correctionData[siId]['calibValue']
            msrunContainer.saic[specfile][siId].arrays['mz'] *= (1 + calibValue)
    elif toleranceMode == 'absolute':
        for siId in correctionData:
            calibValue = correctionData[siId]['calibValue']
            msrunContainer.saic[specfile][siId].arrays['mz'] += calibValue
    else:
        raise Exception('#TODO: a proper exception text')"
3569,"def applyMassCalMs1(msrunContainer, specfile, dataFit, **kwargs):
    """"""Applies a correction function to the MS1 ion m/z arrays in order to
    correct for a m/z dependent m/z error.

    :param msrunContainer: intance of :class:`maspy.core.MsrunContainer`,
        containing the :class:`maspy.core.Sai` items of the ""specfile"".
    :param specfile: filename of an ms-run file to which the m/z calibration
        should be applied
    :param dataFit: a :class:`maspy.auxiliary.DataFit` object, containing
        processed calibration data.
    :param toleranceMode: ""relative"" or ""absolute""
        Specifies how the ``massTolerance`` value is applied, by default
        ""relative"".
    """"""
    toleranceMode = kwargs.get('toleranceMode', 'relative')

    if toleranceMode == 'relative':
        for si in msrunContainer.getItems(specfile,
                                          selector=lambda si: si.msLevel==1):
            mzArr = msrunContainer.saic[specfile][si.id].arrays['mz']
            corrArr = dataFit.corrArray(mzArr)
            mzArr *= (1 + corrArr)
    elif toleranceMode == 'absolute':
        for si in msrunContainer.getItems(specfile,
                                          selector=lambda si: si.msLevel==1):
            mzArr = msrunContainer.saic[specfile][si.id].arrays['mz']
            corrArr = dataFit.corrArray(mzArr)
            mzArr += corrArr
    else:
        raise Exception('#TODO: a proper exception text')"
3570,"def _make(self, key, content):
        """"""clean""""""
        pass
        self.say('make a new key>>>' + key + '>>>with>>>:' + str(content))
        if key.isdigit():
            i = int(key)  # list index [p]
            self.say('extending parent list to contain index:' + key)
            # make a list with size
            return self._list(i, content)
        else:
            return self._dict(key, content)"
3571,"def set_path(self, data, path, value):
        """"""
        Sets the given key in the given dict object to the given value. If the
        given path is nested, child dicts are created as appropriate.
        Accepts either a dot-delimited path or an array of path elements as the
        `path` variable.
        """"""
        self.say('set_path:value:' + str(value) +
                 ' at:' + str(path) + ' in:' + str(data))

        if isinstance(path, str):
            path = path.split('.')
        if len(path) > 1:
            self.set_path(data.setdefault(path[0], {}), path[1:], value)
        else:
            data[path[0]] = value
        return data"
3572,"def get_genericpage(cls, kb_app):
        """""" Return the one class if configured, otherwise default """"""

        # Presumes the registry has been committed
        q = dectate.Query('genericpage')
        klasses = sorted(q(kb_app), key=lambda args: args[0].order)
        if not klasses:
            # The site doesn't configure a genericpage,
            return Genericpage
        else:
            return klasses[0][1]"
3573,"def buy_product(self, product_pk):
        """"""
        determina si el customer ha comprado un producto
        """"""
        if self.invoice_sales.filter(lines_sales__product_final__pk=product_pk).exists() \
                or self.ticket_sales.filter(lines_sales__product_final__pk=product_pk).exists():
            return True
        else:
            return False"
3574,"def create_ticket_from_albaran(pk, list_lines):
        MODEL_SOURCE = SalesAlbaran
        MODEL_FINAL = SalesTicket
        url_reverse = 'CDNX_invoicing_ticketsaless_list'
        # type_doc
        msg_error_relation = _(""Hay lineas asignadas a ticket"")
        msg_error_not_found = _('Sales albaran not found')
        msg_error_line_not_found = _('Todas las lineas ya se han pasado a ticket')

        return SalesLines.create_document_from_another(pk, list_lines,
                                                       MODEL_SOURCE, MODEL_FINAL, url_reverse,
                                                       msg_error_relation, msg_error_not_found, msg_error_line_not_found,
                                                       False)
        """"""
        context = {}
        if list_lines:
            new_list_lines = SalesLines.objects.filter(
                pk__in=[int(x) for x in list_lines]
            ).exclude(
                invoice__isnull=True
            ).values_list('pk')

            if new_list_lines:
                new_pk = SalesLines.objects.values_list('order__pk').filter(pk__in=new_list_lines).first()
                if new_pk:
                    context = SalesLines.create_ticket_from_order(new_pk, new_list_lines)
                    return context
                else:
                    error = _('Pedido no encontrado')
            else:
                error = _('Lineas no relacionadas con pedido')
        else:
            error = _('Lineas no seleccionadas')
        context['error'] = error
        return context
        """""""
3575,"def create_invoice_from_albaran(pk, list_lines):
        MODEL_SOURCE = SalesAlbaran
        MODEL_FINAL = SalesInvoice
        url_reverse = 'CDNX_invoicing_invoicesaless_list'
        # type_doc
        msg_error_relation = _(""Hay lineas asignadas a facturas"")
        msg_error_not_found = _('Sales albaran not found')
        msg_error_line_not_found = _('Todas las lineas ya se han pasado a facturas')

        return SalesLines.create_document_from_another(pk, list_lines,
                                                       MODEL_SOURCE, MODEL_FINAL, url_reverse,
                                                       msg_error_relation, msg_error_not_found, msg_error_line_not_found,
                                                       False)
        """"""
        context = {}
        if list_lines:
            new_list_lines = SalesLines.objects.filter(
                pk__in=[int(x) for x in list_lines]
            ).exclude(
                invoice__isnull=False
            )

            if new_list_lines:
                new_pk = new_list_lines.first()
                if new_pk:
                    context = SalesLines.create_invoice_from_order(
                        new_pk.order.pk,
                        [x['pk'] for x in new_list_lines.values('pk')])
                    return context
                else:
                    error = _('Pedido no encontrado')
            else:
                error = _('Lineas no relacionadas con pedido')
        else:
            error = _('Lineas no seleccionadas')
        context['error'] = error
        return context
        """""""
3576,"def create_invoice_from_ticket(pk, list_lines):
        MODEL_SOURCE = SalesTicket
        MODEL_FINAL = SalesInvoice
        url_reverse = 'CDNX_invoicing_invoicesaless_list'
        # type_doc
        msg_error_relation = _(""Hay lineas asignadas a facturas"")
        msg_error_not_found = _('Sales ticket not found')
        msg_error_line_not_found = _('Todas las lineas ya se han pasado a facturas')

        return SalesLines.create_document_from_another(pk, list_lines,
                                                       MODEL_SOURCE, MODEL_FINAL, url_reverse,
                                                       msg_error_relation, msg_error_not_found, msg_error_line_not_found,
                                                       False)
        """"""
                                context = {}
                                if list_lines:
                                    new_list_lines = SalesLines.objects.filter(
                                        pk__in=[int(x) for x in list_lines]
                                    ).exclude(
                                        invoice__isnull=True
                                    )
                                    if new_list_lines:
                                        new_pk = new_list_lines.first()
                                        if new_pk:
                                            context = SalesLines.create_invoice_from_order(
                                                new_pk.order.pk,
                                                [x['pk'] for x in new_list_lines.values('pk')])
                                            return context
                                        else:
                                            error = _('Pedido no encontrado')
                                    else:
                                        error = _('Lineas no relacionadas con pedido')
                                else:
                                    error = _('Lineas no seleccionadas')
                                context['error'] = error
                                return context
                        """""""
3577,"def cli(ctx):
    """"""Shows the man page packed inside the bubble tool

    this is mainly too overcome limitations on installing manual pages in a distribution agnostic and simple way
    and the way bubble has been developed, in virtual python environments,
    installing a man page into a system location makes no sense,
    the system manpage will not reflect the development version.

    and if your is system is really bare like : docker.io/python,
    you will not even have man installed
    """"""
    manfile = bubble_lib_dir+os.sep+'extras'+os.sep+'Bubble.1.gz'
    mancmd = [""/usr/bin/man"", manfile]
    try:
        return subprocess.call(mancmd)
    except Exception as e:
        print('cannot run man with bubble man page')
        print('you can always have a look at: '+manfile)"
3578,"def _fetch_dimensions(self, dataset):
        """"""
            We override this method just to set the correct datatype
            and dialect for regions.
        """"""
        for dimension in super(SCB, self)._fetch_dimensions(dataset):
            if dimension.id == ""Region"":
                yield Dimension(dimension.id,
                                datatype=""region"",
                                dialect=""skatteverket"",
                                label=dimension.label)
            else:
                yield dimension"
3579,"def call(self, func, key, timeout=None):
        '''Wraps a function call with cache.

        Args:
            func (function): the function to call.
            key (str): the cache key for this call.
            timeout (int): the cache timeout for the key (the
                           unit of this parameter depends on
                           the cache class you use, for example,
                           if you use the classes from werkzeug,
                           then timeout is in seconds.)

        Returns:
            The return value of calling func
        '''
        result = self.get(key)
        if result == NONE_RESULT:
            return None
        if result is None:
            result = func()
            self.set(
                key,
                result if result is not None else NONE_RESULT,
                timeout
            )
        return result"
3580,"def map(self, key_pattern, func, all_args, timeout=None):
        '''Cache return value of multiple calls.

        Args:
            key_pattern (str): the key pattern to use for generating
                               keys for caches of the decorated function.
            func (function): the function to call.
            all_args (list): a list of args to be used to make calls to
                             the function.
            timeout (int): the cache timeout

        Returns:
            A list of the return values of the calls.

        Example::

            def add(a, b):
                return a + b

            cache.map(key_pat, add, [(1, 2), (3, 4)]) == [3, 7]
        '''
        results = []
        keys = [
            make_key(key_pattern, func, args, {})
            for args in all_args
        ]
        cached = dict(zip(keys, self.get_many(keys)))
        cache_to_add = {}
        for key, args in zip(keys, all_args):
            val = cached[key]
            if val is None:
                val = func(*args)
                cache_to_add[key] = val if val is not None else NONE_RESULT
            if val == NONE_RESULT:
                val = None
            results.append(val)
        if cache_to_add:
            self.set_many(cache_to_add, timeout)
        return results"
3581,"def default_ssl_context() -> ssl.SSLContext:
    """"""Creates an SSL context suitable for use with HTTP/2. See
    https://tools.ietf.org/html/rfc7540#section-9.2 for what this entails.
    Specifically, we are interested in these points:

        § 9.2: Implementations of HTTP/2 MUST use TLS version 1.2 or higher.
        § 9.2.1: A deployment of HTTP/2 over TLS 1.2 MUST disable compression.

    The h2 project has its own ideas about how this context should be
    constructed but the resulting context doesn't work for us in the standard
    Python Docker images (though it does work under macOS). See
    https://python-hyper.org/projects/h2/en/stable/negotiating-http2.html#client-setup-example
    for more.
    """"""
    ctx = ssl.create_default_context(purpose=ssl.Purpose.SERVER_AUTH)

    # OP_NO_SSLv2, OP_NO_SSLv3, and OP_NO_COMPRESSION are already set by default
    # so we just need to disable the old versions of TLS.
    ctx.options |= (ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1)

    # ALPN and NPN allow upgrades from HTTP/1.1, but these extensions are only
    # supported by recent versions of OpenSSL. Try to set them up, but don't cry
    # if they fail.
    try:
        ctx.set_alpn_protocols([""h2"", ""http/1.1""])
    except NotImplementedError:
        pass

    try:
        ctx.set_npn_protocols([""h2"", ""http/1.1""])
    except NotImplementedError:
        pass

    return ctx"
3582,"async def _window_open(self, stream_id: int):
        """"""Wait until the identified stream's flow control window is open.
        """"""
        stream = self._get_stream(stream_id)
        return await stream.window_open.wait()"
3583,"async def send_data(
        self,
        stream_id: int,
        data: bytes,
        end_stream: bool = False,
    ):
        """"""Send data, respecting the receiver's flow control instructions. If
        the provided data is larger than the connection's maximum outbound
        frame size, it will be broken into several frames as appropriate.
        """"""
        if self.closed:
            raise ConnectionClosedError
        stream = self._get_stream(stream_id)
        if stream.closed:
            raise StreamClosedError(stream_id)

        remaining = data
        while len(remaining) > 0:
            await asyncio.gather(
                self._writable.wait(),
                self._window_open(stream.id),
            )

            remaining_size = len(remaining)
            window_size = self._h2.local_flow_control_window(stream.id)
            max_frame_size = self._h2.max_outbound_frame_size

            send_size = min(remaining_size, window_size, max_frame_size)
            if send_size == 0:
                continue

            logger.debug(
                f'[{stream.id}] Sending {send_size} of {remaining_size} '
                f'bytes (window {window_size}, frame max {max_frame_size})'
            )

            to_send = remaining[:send_size]
            remaining = remaining[send_size:]
            end = (end_stream is True and len(remaining) == 0)

            self._h2.send_data(stream.id, to_send, end_stream=end)
            self._flush()

            if self._h2.local_flow_control_window(stream.id) == 0:
                stream.window_open.clear()"
3584,"async def read_data(self, stream_id: int) -> bytes:
        """"""Read data from the specified stream until it is closed by the remote
        peer. If the stream is never ended, this never returns.
        """"""
        frames = [f async for f in self.stream_frames(stream_id)]
        return b''.join(frames)"
3585,"async def read_frame(self, stream_id: int) -> bytes:
        """"""Read a single frame of data from the specified stream, waiting until
        frames are available if none are present in the local buffer. If the
        stream is closed and all buffered frames have been consumed, raises a
        StreamConsumedError.
        """"""
        stream = self._get_stream(stream_id)
        frame = await stream.read_frame()
        if frame.flow_controlled_length > 0:
            self._acknowledge_data(frame.flow_controlled_length, stream_id)
        return frame.data"
3586,"async def get_pushed_stream_ids(self, parent_stream_id: int) -> List[int]:
        """"""Return a list of all streams pushed by the remote peer that are
        children of the specified stream. If no streams have been pushed when
        this method is called, waits until at least one stream has been pushed.
        """"""
        if parent_stream_id not in self._streams:
            logger.error(
                f'Parent stream {parent_stream_id} unknown to this connection'
            )
            raise NoSuchStreamError(parent_stream_id)
        parent = self._get_stream(parent_stream_id)

        await parent.pushed_streams_available.wait()
        pushed_streams_ids = self._pushed_stream_ids[parent.id]

        stream_ids: List[int] = []
        if len(pushed_streams_ids) > 0:
            stream_ids.extend(pushed_streams_ids)
            pushed_streams_ids.clear()
            parent.pushed_streams_available.clear()

        return stream_ids"
3587,"def populate(self, obj):
        """""" Populate
        
        Query mongo to get information about the obj if it exists
        
        Args:
            obj (AtlasServiceBinding.Binding or AtlasServiceInstance.Instance): instance or binding
        
        Raises:
            ErrStorageTypeUnsupported: Type unsupported.
            ErrStorageMongoConnection: Error during MongoDB communication.
        """"""
        
        # query
        if type(obj) is AtlasServiceInstance.Instance:
            query = { ""instance_id"" : obj.instance_id, ""binding_id"" : { ""$exists"" : False } }
        elif type(obj) is AtlasServiceBinding.Binding:
            query = { ""binding_id"" : obj.binding_id, ""instance_id"" : obj.instance.instance_id }
        else:
            raise ErrStorageTypeUnsupported(type(obj))
        
        # find
        try:
            result = self.broker.find_one(query)
        except:
            raise ErrStorageMongoConnection(""Populate Instance or Binding"")
        
        if result is not None:
            obj.parameters = result[""parameters""]
            
            # Flags the obj to provisioned
            obj.provisioned = True
        else:
            # New
            obj.provisioned = False"
3588,"def store(self, obj):
        """""" Store 
        
        Store an object into the MongoDB storage for caching
        
        Args:
            obj (AtlasServiceBinding.Binding or AtlasServiceInstance.Instance): instance or binding
            
        Returns:
            ObjectId: MongoDB _id
        
        Raises:
            ErrStorageMongoConnection: Error during MongoDB communication.
            ErrStorageTypeUnsupported: Type unsupported.
            ErrStorageStore : Failed to store the binding or instance.
        """"""
        
        # query
        if type(obj) is AtlasServiceInstance.Instance:
            query = { ""instance_id"" : obj.instance_id, ""database"" : obj.get_dbname(), ""cluster"": obj.get_cluster(), ""parameters"" : obj.parameters }
        elif type(obj) is AtlasServiceBinding.Binding:
            query = { ""binding_id"" : obj.binding_id, ""parameters"" : obj.parameters, ""instance_id"": obj.instance.instance_id }
        else:
            raise ErrStorageTypeUnsupported(type(obj))
        
        # insert
        try:
            result = self.broker.insert_one(query)
        except:
            raise ErrStorageMongoConnection(""Store Instance or Binding"")
        
        if result is not None:
            # Flags the obj to provisioned
            obj.provisioned = True
            return result.inserted_id
        
        raise ErrStorageStore()"
3589,"def remove(self, obj):
        """""" Remove 
        
        Remove an object from the MongoDB storage for caching
        
        Args:
            obj (AtlasServiceBinding.Binding or AtlasServiceInstance.Instance): instance or binding
            
        Raises:
            ErrStorageTypeUnsupported: Type unsupported.
        """"""
        if type(obj) is AtlasServiceInstance.Instance:
            self.remove_instance(obj)
        elif type(obj) is AtlasServiceBinding.Binding:
            self.remove_binding(obj)
        else:
            raise ErrStorageTypeUnsupported(type(obj))"
3590,"def remove_instance(self, instance):
        """""" Remove an instance
        
        Remove an object from the MongoDB storage for caching
        
        Args:
            instance (AtlasServiceInstance.Instance): instance
        
        Raises:
            ErrStorageMongoConnection: Error during MongoDB communication.
            ErrStorageRemoveInstance: Failed to remove the instance.
        """"""
        
        # query
        query = { ""instance_id"" : instance.instance_id, ""binding_id"" : { ""$exists"" : False } }
        
        # delete the instance
        try:
            result = self.broker.delete_one(query)
        except:
            raise ErrStorageMongoConnection(""Remove Instance"")
        
        # return the result
        if result is not None and result.deleted_count == 1:
            instance.provisioned = False
        else:
            raise ErrStorageRemoveInstance(instance.instance_id)"
3591,"def remove_binding(self, binding):
        """""" Remove a binding
        
        Remove an object from the MongoDB storage for caching
        
        Args:
            binding (AtlasServiceBinding.Binding): binding
            
        Raises:
            ErrStorageMongoConnection: Error during MongoDB communication.
            ErrStorageRemoveBinding: Failed to remove the binding
        """"""
        
        # query
        query = { ""binding_id"" : binding.binding_id, ""instance_id"" : binding.instance.instance_id }
        
        # delete the binding
        try:
            result = self.broker.delete_one(query)
        except:
            raise ErrStorageMongoConnection(""Remove Binding"")

        # return the result
        if result is not None and result.deleted_count == 1:
            binding.provisioned = False
        else:
            raise ErrStorageRemoveBinding(binding.binding_id)"
3592,"def handle(self, request, buffer_size):
        """"""
        Handle a message
        :param request: the request socket.
        :param buffer_size: the buffer size.
        :return: True if success, False otherwise
        """"""

        if self.component_type == StreamComponent.SOURCE:
            msg = self.handler_function()
            return self.__send(request, msg)

        logger = self.logger

        data = self.__receive(request, buffer_size)
        if data is None:
            return False
        else:
            logger.debug(data.split(self.TERMINATOR))
            for message in data.split(self.TERMINATOR)[:-1]:
                logger.debug(message)
                result = self.handler_function(message)
                if self.component_type == StreamComponent.PROCESSOR:
                    if not self.__send(request, result):
                        return False
        return True"
3593,"def handle(self, request, buffer_size):
        """"""
        Handle a message
        :param request: the request socket.
        :param buffer_size: the buffer size.
        :return: True if success, False otherwise
        """"""
        logger = self.logger

        data = self.__receive(request, buffer_size)
        if data is None:
            return False
        else:
            arr = array('B',data)
            for message in split_array(arr,StxEtxHandler.ETX):
                if message[0] == StxEtxHandler.STX:
                    message = message[1:]
                logger.debug(message)
                result = self.handler_function(bytearray(message))
                if self.component_type == StreamComponent.PROCESSOR:
                    if not self.__send(request, result):
                        return False
        return True"
3594,"def handle(self, request, buffer_size):
        """"""
        Handle a message
        :param request: the request socket.
        :param buffer_size: the buffer size.
        :return: True if success, False otherwise
        """"""
        logger = self.logger
        msg = self.__receive(request, buffer_size)
        if msg is None:
            return False

        result = self.handler_function(msg)

        if self.component_type == StreamComponent.PROCESSOR:
            return self.__send(request, result)
        return True"
3595,"def importMzml(filepath, msrunContainer=None, siAttrFromSmi=None, specfilename=None):
    """"""Performs a complete import of a mzml file into a maspy MsrunContainer.

    :paramsiAttrFromSmi: allow here to specify a custom function that extracts params a from spectrumMetadataItem
    :param specfilename: by default the filename will be used as the specfilename in the MsrunContainer and all
        mzML item instances, specify here an alternative specfilename to override the default one
    """"""
    #TODO: docstring
    siAttrFromSmi = defaultFetchSiAttrFromSmi if siAttrFromSmi is None else siAttrFromSmi
    if msrunContainer is None:
        msrunContainer = maspy.core.MsrunContainer()

    basename = os.path.basename(filepath)
    dirname = os.path.dirname(filepath)
    filename, extension = os.path.splitext(basename)
    specfilename = filename if specfilename is None else specfilename

    #Check if the specified file is valid for an import
    if not os.path.isfile(filepath):
        raise IOError('File does not exist: %s' % filepath)
    elif extension.lower() != '.mzml':
        raise IOError('Filetype is not ""mzml"": %s' % filepath)
    elif specfilename in msrunContainer.info:
        print(specfilename, 'already present in the msrunContainer, aborting import.')
        return None

    mzmlReader = maspy.xml.MzmlReader(filepath)
    masterContainer = {'rm': str(), 'ci': {}, 'si': {}, 'sai': {}, 'smi': {}}
    #Dictionary recording which MS2 scans follow a MS1 scan
    ms1Record = ddict(list)

    for xmlSpectrum in mzmlReader.parseSpectra():
        smi, binaryDataArrayList = smiFromXmlSpectrum(xmlSpectrum, specfilename)
        #Generate SpectrumItem
        si = maspy.core.Si(smi.id, smi.specfile)
        si.isValid = True
        siAttrFromSmi(smi, si)
        if si.msLevel > 1:
            si.precursorId = si.precursorId.split('scan=')[1] #TODO: change to use regex to extract from known vendor format
            ms1Record[si.precursorId].append(si.id)
        else:
            ms1Record[si.id] #Touch the ddict to add the MS1 id, if it is not already present
        #Generate SpectrumArrayItem
        sai = maspy.core.Sai(smi.id, smi.specfile)
        sai.arrays, sai.arrayInfo = maspy.xml.extractBinaries(binaryDataArrayList,
                                                              smi.attributes['defaultArrayLength'])
        #Store all items in the appropriate containers
        masterContainer['smi'][smi.id] = smi
        masterContainer['si'][smi.id] = si
        masterContainer['sai'][smi.id] = sai

    for siId, msnIdList in viewitems(ms1Record):
        #Ignore KeyError if the spectrum is not present in the mzML file for whatever reason
        try:
            setattr(masterContainer['si'][siId], 'msnIdList', msnIdList)
        except KeyError:
            pass

    for xmlChromatogram in mzmlReader.chromatogramList:
        ci = ciFromXml(xmlChromatogram, specfilename)
        masterContainer['ci'][ci.id] = ci
    masterContainer['rm'] = mzmlReader.metadataNode

    msrunContainer._addSpecfile(specfilename, dirname)
    msrunContainer.rmc[specfilename] = masterContainer['rm']
    msrunContainer.info[specfilename]['status']['rm'] = True
    msrunContainer.smic[specfilename] = masterContainer['smi']
    msrunContainer.info[specfilename]['status']['smi'] = True
    msrunContainer.sic[specfilename] = masterContainer['si']
    msrunContainer.info[specfilename]['status']['si'] = True
    msrunContainer.saic[specfilename] = masterContainer['sai']
    msrunContainer.info[specfilename]['status']['sai'] = True
    msrunContainer.cic[specfilename] = masterContainer['ci']
    msrunContainer.info[specfilename]['status']['ci'] = True

    return msrunContainer"
3596,"def defaultFetchSiAttrFromSmi(smi, si):
    """"""Default method to extract attributes from a spectrum metadata item (sai) and
    adding them to a spectrum item (si).""""""
    for key, value in viewitems(fetchSpectrumInfo(smi)):
        setattr(si, key, value)
    for key, value in viewitems(fetchScanInfo(smi)):
        setattr(si, key, value)
    if si.msLevel > 1:
        for key, value in viewitems(fetchParentIon(smi)):
            setattr(si, key, value)"
3597,"def convertMzml(mzmlPath, outputDirectory=None):
    """"""Imports an mzml file and converts it to a MsrunContainer file

    :param mzmlPath: path of the mzml file
    :param outputDirectory: directory where the MsrunContainer file should be written
    if it is not specified, the output directory is set to the mzml files directory.
    """"""
    outputDirectory = outputDirectory if outputDirectory is not None else os.path.dirname(mzmlPath)
    msrunContainer = importMzml(mzmlPath)
    msrunContainer.setPath(outputDirectory)
    msrunContainer.save()"
3598,"def prepareSiiImport(siiContainer, specfile, path, qcAttr, qcLargerBetter,
                     qcCutoff, rankAttr, rankLargerBetter):
    """"""Prepares the ``siiContainer`` for the import of peptide spectrum matching
    results. Adds entries to ``siiContainer.container`` and to
    ``siiContainer.info``.

    :param siiContainer: instance of :class:`maspy.core.SiiContainer`
    :param specfile: unambiguous identifier of a ms-run file. Is also used as
        a reference to other MasPy file containers.
    :param path: folder location used by the ``SiiContainer`` to save and load
        data to the hard disk.
    :param qcAttr: name of the parameter to define a ``Sii`` quality cut off.
        Typically this is some sort of a global false positive estimator,
        for example a 'false discovery rate' (FDR).
    :param qcLargerBetter: bool, True if a large value for the ``.qcAttr`` means
        a higher confidence.
    :param qcCutOff: float, the quality threshold for the specifed ``.qcAttr``
    :param rankAttr: name of the parameter used for ranking ``Sii`` according
        to how well they match to a fragment ion spectrum, in the case when
        their are multiple ``Sii`` present for the same spectrum.
    :param rankLargerBetter: bool, True if a large value for the ``.rankAttr``
        means a better match to the fragment ion spectrum.

    For details on ``Sii`` ranking see :func:`applySiiRanking()`

    For details on ``Sii`` quality validation see :func:`applySiiQcValidation()`
    """"""
    if specfile not in siiContainer.info:
        siiContainer.addSpecfile(specfile, path)
    else:
        raise Exception('...')

    siiContainer.info[specfile]['qcAttr'] = qcAttr
    siiContainer.info[specfile]['qcLargerBetter'] = qcLargerBetter
    siiContainer.info[specfile]['qcCutoff'] = qcCutoff
    siiContainer.info[specfile]['rankAttr'] = rankAttr
    siiContainer.info[specfile]['rankLargerBetter'] = rankLargerBetter"
3599,"def addSiiToContainer(siiContainer, specfile, siiList):
    """"""Adds the ``Sii`` elements contained in the siiList to the appropriate
    list in ``siiContainer.container[specfile]``.

    :param siiContainer: instance of :class:`maspy.core.SiiContainer`
    :param specfile: unambiguous identifier of a ms-run file. Is also used as
        a reference to other MasPy file containers.
    :param siiList: a list of ``Sii`` elements imported from any PSM search
        engine results
    """"""
    for sii in siiList:
        if sii.id not in siiContainer.container[specfile]:
            siiContainer.container[specfile][sii.id] = list()
        siiContainer.container[specfile][sii.id].append(sii)"
3600,"def applySiiRanking(siiContainer, specfile):
    """"""Iterates over all Sii entries of a specfile in siiContainer and sorts Sii
    elements of the same spectrum according to the score attribute specified in
    ``siiContainer.info[specfile]['rankAttr']``. Sorted Sii elements are then
    ranked  according to their sorted position, if multiple Sii have the same
    score, all get the same rank and the next entries rank is its list position.

    :param siiContainer: instance of :class:`maspy.core.SiiContainer`
    :param specfile: unambiguous identifier of a ms-run file. Is also used as
        a reference to other MasPy file containers.
    """"""
    attr = siiContainer.info[specfile]['rankAttr']
    reverse = siiContainer.info[specfile]['rankLargerBetter']
    for itemList in listvalues(siiContainer.container[specfile]):
        sortList = [(getattr(sii, attr), sii) for sii in itemList]
        itemList = [sii for score, sii in sorted(sortList, reverse=reverse)]

        #Rank Sii according to their position
        lastValue = None
        for itemPosition, item in enumerate(itemList, 1):
            if getattr(item, attr) != lastValue:
                rank = itemPosition
            item.rank = rank
            lastValue = getattr(item, attr)"
3601,"def applySiiQcValidation(siiContainer, specfile):
    """"""Iterates over all Sii entries of a specfile in siiContainer and validates
    if they surpass a user defined quality threshold. The parameters for
    validation are defined in ``siiContainer.info[specfile]``:

        - ``qcAttr``, ``qcCutoff`` and ``qcLargerBetter``

    In addition to passing this validation a ``Sii`` has also to be at the first
    list position in the ``siiContainer.container``. If both criteria are met
    the attribute ``Sii.isValid`` is set to ``True``.

    :param siiContainer: instance of :class:`maspy.core.SiiContainer`
    :param specfile: unambiguous identifier of a ms-run file. Is also used as
        a reference to other MasPy file containers.
    """"""
    attr = siiContainer.info[specfile]['qcAttr']
    cutOff = siiContainer.info[specfile]['qcCutoff']
    if siiContainer.info[specfile]['qcLargerBetter']:
        evaluator = lambda sii: getattr(sii, attr) >= cutOff and sii.rank == 1
    else:
        evaluator = lambda sii: getattr(sii, attr) <= cutOff and sii.rank == 1

    for itemList in listvalues(siiContainer.container[specfile]):
        #Set the .isValid attribute of all Sii to False
        for sii in itemList:
            sii.isValid = False

        #Validate the first Sii
        sii = itemList[0]
        if evaluator(sii):
            sii.isValid = True"
3602,"def readPercolatorResults(filelocation, specfile, psmEngine):
    """"""Reads percolator PSM results from a txt file and returns a list of
    :class:`Sii <maspy.core.Sii>` elements.

    :param filelocation: file path of the percolator result file
    :param specfile: unambiguous identifier of a ms-run file. Is also used as
        a reference to other MasPy file containers.
    :param psmEngine: PSM PSM search engine used for peptide spectrum matching
        before percolator. This is important to specify, since the scanNr
        information is written in a different format by some engines. It might
        be necessary to adjust the settings for different versions of percolator
        or the PSM search engines used.

        Possible values are 'comet', 'xtandem', 'msgf'.

    :returns: [sii, sii, sii, ...]
    """"""
    if psmEngine not in ['comet', 'msgf', 'xtandem']:
        raise Exception('PSM search engine not supported: ', psmEngine)
    itemList = list()

    #Note: regarding headerline, xtandem seperates proteins with ';',
    #msgf separates proteins with a tab
    with io.open(filelocation, 'r', encoding='utf-8') as openfile:
        lines = openfile.readlines()

    headerDict = dict([[y,x] for (x,y) in
                       enumerate(lines[0].strip().split('\t'))
                       ])
    scanEntryList = list()
    for line in lines[1:]:
        if len(line.strip()) == 0:
            continue
        fields = line.strip().split('\t')

        if psmEngine in ['comet', 'msgf']:
            scanNr = fields[headerDict['PSMId']].split('_')[-3]
        elif psmEngine in ['xtandem']:
            scanNr = fields[headerDict['PSMId']].split('_')[-2]

        peptide = fields[headerDict['peptide']]
        if peptide.find('.') != -1:
            peptide = peptide.split('.')[1]
        #Change to the new unimod syntax
        peptide = peptide.replace('[UNIMOD:', '[u:')
        sequence = maspy.peptidemethods.removeModifications(peptide)

        qValue = fields[headerDict['q-value']]
        score = fields[headerDict['score']]
        pep = fields[headerDict['posterior_error_prob']]

        sii = maspy.core.Sii(scanNr, specfile)
        sii.peptide = peptide
        sii.sequence = sequence
        sii.qValue = float(qValue)
        sii.score = float(score)
        sii.pep = float(pep)
        sii.isValid = False

        itemList.append(sii)
    return itemList"
3603,"def importPercolatorResults(siiContainer, filelocation, specfile, psmEngine,
                            qcAttr='qValue', qcLargerBetter=False,
                            qcCutoff=0.01, rankAttr='score',
                            rankLargerBetter=True):
    """"""Import peptide spectrum matches (PSMs) from a percolator result file,
    generate :class:`Sii <maspy.core.Sii>` elements and store them in the
    specified :class:`siiContainer <maspy.core.SiiContainer>`. Imported ``Sii``
    are ranked according to a specified attribute and validated if they surpass
    a specified quality threshold.

    :param siiContainer: imported PSM results are added to this instance of
        :class:`siiContainer <maspy.core.SiiContainer>`
    :param filelocation: file path of the percolator result file
    :param specfile: unambiguous identifier of a ms-run file. Is also used as
        a reference to other MasPy file containers.
    :param psmEngine: PSM search engine used for peptide spectrum matching
        before percolator. For details see :func:`readPercolatorResults()`.
        Possible values are 'comet', 'xtandem', 'msgf'.
    :param qcAttr: name of the parameter to define a quality cut off. Typically
        this is some sort of a global false positive estimator (eg FDR)
    :param qcLargerBetter: bool, True if a large value for the ``.qcAttr`` means
        a higher confidence.
    :param qcCutOff: float, the quality threshold for the specifed ``.qcAttr``
    :param rankAttr: name of the parameter used for ranking ``Sii`` according
        to how well they match to a fragment ion spectrum, in the case when
        their are multiple ``Sii`` present for the same spectrum.
    :param rankLargerBetter: bool, True if a large value for the ``.rankAttr``
        means a better match to the fragment ion spectrum

    For details on ``Sii`` ranking see :func:`applySiiRanking()`

    For details on ``Sii`` quality validation see :func:`applySiiQcValidation()`
    """"""

    path = os.path.dirname(filelocation)
    siiList = readPercolatorResults(filelocation, specfile, psmEngine)
    prepareSiiImport(siiContainer, specfile, path, qcAttr, qcLargerBetter,
                     qcCutoff, rankAttr, rankLargerBetter)
    addSiiToContainer(siiContainer, specfile, siiList)
    applySiiRanking(siiContainer, specfile)
    applySiiQcValidation(siiContainer, specfile)"
3604,"def readMsgfMzidResults(filelocation, specfile=None):
    """"""Reads MS-GF+ PSM results from a mzIdentML file and returns a list of
    :class:`Sii <maspy.core.Sii>` elements.

    :param filelocation: file path of the percolator result file
    :param specfile: optional, unambiguous identifier of a ms-run file. Is also
        used as a reference to other MasPy file containers. If specified all
        the ``.specfile`` attribute of all ``Sii`` are set to this value, else
        it is read from the mzIdentML file.

    :returns: [sii, sii, sii, ...]
    """"""
    readSpecfile = True if specfile is None else False

    unimod = pyteomics.mass.mass.Unimod()
    _tempMods = dict()
    mzid_refs = pyteomics.mzid.read(filelocation, retrieve_refs=True,
                                    iterative=False)

    siiList = list()
    for mzidEntry in mzid_refs:
        mzidSii = mzidEntry['SpectrumIdentificationItem'][0]
        scanNumber = str(int(mzidEntry['scan number(s)']))
        if readSpecfile:
            specfile = os.path.splitext(mzidEntry['name'])[0]

        sii = maspy.core.Sii(scanNumber, specfile)
        sii.isValid = mzidSii['passThreshold']
        sii.rank = mzidSii['rank']
        sii.eValue = mzidSii['MS-GF:EValue']
        sii.charge = mzidSii['chargeState']
        sii.sequence = mzidSii['PeptideSequence']
        sii.specEValue = mzidSii['MS-GF:SpecEValue']
        sii.score = numpy.log10(sii.eValue)*-1

        if 'Modification' in mzidSii:
            modifications = list()
            for modEntry in mzidSii['Modification']:
                try:
                    modSymbolMaspy = _tempMods[modEntry['name']]
                except KeyError:
                    unimodEntry = unimod.by_title(modEntry['name'])
                    if len(unimodEntry) != 0:
                        modSymbol = 'u:'+str(unimodEntry['record_id'])
                    else:
                        modSymbol = modEntry['name']
                    modSymbolMaspy = '[' + modSymbol + ']'
                    _tempMods[modEntry['name']] = modSymbolMaspy
                modifications.append((modEntry['location'], modSymbolMaspy))
            modifications.sort(key=ITEMGETTER(0))

            _lastPos = 0
            _peptide = list()
            for pos, mod in modifications:
                 _peptide.extend((sii.sequence[_lastPos:pos], mod))
                 _lastPos = pos
            _peptide.append(sii.sequence[_lastPos:])

            sii.peptide = ''.join(_peptide)
        else:
            sii.peptide = sii.sequence
        siiList.append(sii)
    return siiList"
3605,"def importMsgfMzidResults(siiContainer, filelocation, specfile=None,
                          qcAttr='eValue', qcLargerBetter=False, qcCutoff=0.01,
                          rankAttr='score', rankLargerBetter=True):
    """"""Import peptide spectrum matches (PSMs) from a MS-GF+ mzIdentML file,
    generate :class:`Sii <maspy.core.Sii>` elements and store them in the
    specified :class:`siiContainer <maspy.core.SiiContainer>`. Imported ``Sii``
    are ranked according to a specified attribute and validated if they surpass
    a specified quality threshold.

    :param siiContainer: imported PSM results are added to this instance of
        :class:`siiContainer <maspy.core.SiiContainer>`
    :param filelocation: file path of the percolator result file
    :param specfile: optional, unambiguous identifier of a ms-run file. Is also
        used as a reference to other MasPy file containers. If specified the
        attribute ``.specfile`` of all ``Sii`` is set to this value, else
        it is read from the mzIdentML file.
    :param qcAttr: name of the parameter to define a quality cut off. Typically
        this is some sort of a global false positive estimator (eg FDR)
    :param qcLargerBetter: bool, True if a large value for the ``.qcAttr`` means
        a higher confidence.
    :param qcCutOff: float, the quality threshold for the specifed ``.qcAttr``
    :param rankAttr: name of the parameter used for ranking ``Sii`` according
        to how well they match to a fragment ion spectrum, in the case when
        their are multiple ``Sii`` present for the same spectrum.
    :param rankLargerBetter: bool, True if a large value for the ``.rankAttr``
        means a better match to the fragment ion spectrum

    For details on ``Sii`` ranking see :func:`applySiiRanking()`

    For details on ``Sii`` quality validation see :func:`applySiiQcValidation()`
    """"""
    path = os.path.dirname(filelocation)
    siiList = readMsgfMzidResults(filelocation, specfile)

    #If the mzIdentML file contains multiple specfiles, split the sii elements
    # up according to their specified ""specfile"" attribute.
    specfiles = ddict(list)
    if specfile is None:
        for sii in siiList:
            specfiles[sii.specfile].append(sii)
    else:
        specfiles[specfile] = siiList

    for specfile in specfiles:
        _siiList = specfiles[specfile]

        prepareSiiImport(siiContainer, specfile, path, qcAttr, qcLargerBetter,
                         qcCutoff, rankAttr, rankLargerBetter)
        addSiiToContainer(siiContainer, specfile, _siiList)
        applySiiRanking(siiContainer, specfile)
        applySiiQcValidation(siiContainer, specfile)"
3606,"def importPeptideFeatures(fiContainer, filelocation, specfile):
    """""" Import peptide features from a featureXml file, as generated for example
    by the OpenMS node featureFinderCentroided, or a features.tsv file by the
    Dinosaur command line tool.

    :param fiContainer: imported features are added to this instance of
        :class:`FeatureContainer <maspy.core.FeatureContainer>`.
    :param filelocation: Actual file path
    :param specfile: Keyword (filename) to represent file in the
        :class:`FeatureContainer`. Each filename can only occure once, therefore
        importing the same filename again is prevented.
    """"""
    if not os.path.isfile(filelocation):
        warnings.warn('The specified file does not exist %s' %(filelocation, ))
        return None
    elif (not filelocation.lower().endswith('.featurexml') and
          not filelocation.lower().endswith('.features.tsv')
          ):
        #TODO: this is depricated as importPeptideFeatues
        #is not longer be used solely for featurexml
        print('Wrong file extension, %s' %(filelocation, ))
    elif specfile in fiContainer.info:
        print('%s is already present in the SiContainer, import interrupted.'
              %(specfile, )
              )
        return None

    #Prepare the file container for the import
    fiContainer.addSpecfile(specfile, os.path.dirname(filelocation))

    #import featurexml file
    if filelocation.lower().endswith('.featurexml'):
        featureDict = _importFeatureXml(filelocation)
        for featureId, featureEntryDict in viewitems(featureDict):
            rtArea = set()
            for convexHullEntry in featureEntryDict['convexHullDict']['0']:
                rtArea.update([convexHullEntry[0]])

            fi = maspy.core.Fi(featureId, specfile)
            fi.rt = featureEntryDict['rt']
            fi.rtArea = max(rtArea) - min(rtArea)
            fi.rtLow = min(rtArea)
            fi.rtHigh = max(rtArea)
            fi.charge = featureEntryDict['charge']
            fi.mz = featureEntryDict['mz']
            fi.mh = maspy.peptidemethods.calcMhFromMz(featureEntryDict['mz'],
                                                      featureEntryDict['charge'])
            fi.intensity = featureEntryDict['intensity']
            fi.quality = featureEntryDict['overallquality']
            fi.isMatched = False
            fi.isAnnotated = False
            fi.isValid = True

            fiContainer.container[specfile][featureId] = fi

    #import dinosaur tsv file
    elif filelocation.lower().endswith('.features.tsv'):
        featureDict = _importDinosaurTsv(filelocation)
        for featureId, featureEntryDict in viewitems(featureDict):
            fi = maspy.core.Fi(featureId, specfile)
            fi.rt = featureEntryDict['rtApex']
            fi.rtArea = featureEntryDict['rtEnd'] - featureEntryDict['rtStart']
            fi.rtFwhm = featureEntryDict['fwhm']
            fi.rtLow = featureEntryDict['rtStart']
            fi.rtHigh = featureEntryDict['rtEnd']
            fi.charge = featureEntryDict['charge']
            fi.numScans  = featureEntryDict['nScans']
            fi.mz = featureEntryDict['mz']
            fi.mh = maspy.peptidemethods.calcMhFromMz(featureEntryDict['mz'],
                                                      featureEntryDict['charge'])
            fi.intensity = featureEntryDict['intensitySum']
            fi.intensityApex = featureEntryDict['intensityApex']
            #Note: not used keys:
            #mostAbundantMz nIsotopes nScans averagineCorr mass massCalib

            fi.isMatched = False
            fi.isAnnotated = False
            fi.isValid = True

            fiContainer.container[specfile][featureId] = fi"
3607,"def _importFeatureXml(filelocation):
    """"""Reads a featureXml file.

    :param filelocation: #TODO: docstring
    :returns: {featureKey1: {attribute1:value1, attribute2:value2, ...}, ...}

    See also :func:`importPeptideFeatures`
    """"""
    with io.open(filelocation, 'r', encoding='utf-8') as openFile:
        readingFeature = False
        readingHull = False
        featureDict = dict()

        for i, line in enumerate(openFile):
            line = line.strip()
            if readingFeature == True:
                if line.find('<convexhull') != -1:
                    readingHull = True
                    hullNr = line.split('<convexhull nr=\""')[1].split('\"">')[0]
                    hullList = list()
                elif readingHull == True:
                    if line.find('<pt') != -1:
                        x = float(line.split('x=\""')[1].split('\""')[0])
                        y = float(line.split('y=\""')[1].split('\""')[0])
                        # x = retentiontime, y = m/z
                        #retentionTimeList.append(x)
                        hullList.append([x,y])
                    elif line.find('</convexhull>') != -1:
                        featureDict[featureKey]['convexHullDict'][hullNr] = hullList
                        readingHull = False

                elif line.find('<position dim=\""0\"">') != -1:
                    featureDict[featureKey]['dim0'] = float(line.split('<position dim=\""0\"">')[1].split('</position>')[0])
                elif line.find('<position dim=\""1\"">') != -1:
                    featureDict[featureKey]['dim1'] = float(line.split('<position dim=\""1\"">')[1].split('</position>')[0])
                elif line.find('<intensity>') != -1:
                    featureDict[featureKey]['intensity'] = float(line.split('<intensity>')[1].split('</intensity>')[0])
                elif line.find('<overallquality>') != -1:
                    featureDict[featureKey]['overallquality'] = float(line.split('<overallquality>')[1].split('</overallquality>')[0])
                elif line.find('<charge>') != -1:
                    featureDict[featureKey]['charge'] = int( line.split('<charge>')[1].split('</charge>')[0] )

                elif line.find('<userParam') != -1:
                    if line.find('name=\""label\""') != -1:
                        featureDict[featureKey]['label'] = line.split('value=\""')[1].split('\""/>')[0]
                    elif line.find('name=\""score_fit\""') != -1:
                        featureDict[featureKey]['score_fit'] = float(line.split('value=\""')[1].split('\""/>')[0])
                    elif line.find('name=\""score_correlation\""') != -1:
                        featureDict[featureKey]['score_correlation'] = float(line.split('value=\""')[1].split('\""/>')[0])
                    elif line.find('name=\""FWHM\""') != -1:
                        featureDict[featureKey]['FWHM'] = float(line.split('value=\""')[1].split('\""/>')[0])
                    elif line.find('name=\""spectrum_index\""') != -1:
                        featureDict[featureKey]['spectrum_index'] = line.split('value=\""')[1].split('\""/>')[0]
                    elif line.find('name=\""spectrum_native_id\""') != -1:
                        featureDict[featureKey]['spectrum_native_id'] = line.split('value=\""')[1].split('\""/>')[0]

                elif line.find('</feature>') != -1:
                    #mzList = list()
                    #for retentionTime,mz in featureDict[featureKey]['convexHullDict']['0']:
                    #    mzList.append(mz)
                    featureDict[featureKey]['rt'] = featureDict[featureKey]['dim0']#numpy.median(retentionTimeList)
                    featureDict[featureKey]['mz'] = featureDict[featureKey]['dim1']#numpy.median(mzList)

                    readingFeature == False

            if line.find('<feature id') != -1:
                readingFeature = True
                featureKey = line.split('<feature id=\""')[1].split('\"">')[0]
                featureDict[featureKey] = dict()
                featureDict[featureKey]['convexHullDict'] = dict()
                #retentionTimeList = list()
    return featureDict"
3608,"def _importDinosaurTsv(filelocation):
    """"""Reads a Dinosaur tsv file.

    :returns: {featureKey1: {attribute1:value1, attribute2:value2, ...}, ...}

    See also :func:`importPeptideFeatures`
    """"""
    with io.open(filelocation, 'r', encoding='utf-8') as openFile:
        #NOTE: this is pretty similar to importing percolator results, maybe unify in a common function
        lines = openFile.readlines()
        headerDict = dict([[y,x] for (x,y) in enumerate(lines[0].strip().split('\t'))])
        featureDict = dict()
        for linePos, line in enumerate(lines[1:]):
            featureId = str(linePos)
            fields = line.strip().split('\t')
            entryDict = dict()
            for headerName, headerPos in viewitems(headerDict):
                entryDict[headerName] = float(fields[headerPos])
                if headerName in ['rtApex', 'rtEnd', 'rtStart', 'fwhm']:
                    #Covnert to seconds
                    entryDict[headerName] *= 60
                elif headerName in ['charge', 'intensitySum', 'nIsotopes', 'nScans', 'intensityApex']:
                    entryDict[headerName] = int(entryDict[headerName])
            featureDict[featureId] = entryDict
    return featureDict"
3609,"def rst_to_html(input_string: str) -> str:
    """""" Given a string of RST, use docutils to generate html """"""

    overrides = dict(input_encoding='unicode', doctitle_xform=True,
                     initial_header_level=1)
    parts = publish_parts(
        writer_name='html',
        source=input_string,
        settings_overrides=overrides
    )
    return parts['html_body']"
3610,"def get_rst_title(rst_doc: Node) -> Optional[Any]:
    """""" Given some RST, extract what docutils thinks is the title """"""

    for title in rst_doc.traverse(nodes.title):
        return title.astext()

    return None"
3611,"def get_rst_excerpt(rst_doc: document, paragraphs: int = 1) -> str:
    """""" Given rst, parse and return a portion """"""

    texts = []
    for count, p in enumerate(rst_doc.traverse(paragraph)):
        texts.append(p.astext())
        if count + 1 == paragraphs:
            break
    return ' '.join(texts)"
3612,"def requires_password_auth(fn):
    """"""Decorator for HAPI methods that requires the instance to be authenticated with a password""""""
    def wrapper(self, *args, **kwargs):
        self.auth_context = HAPI.auth_context_password
        return fn(self, *args, **kwargs)
    return wrapper"
3613,"def requires_api_auth(fn):
    """"""Decorator for HAPI methods that requires the instance to be authenticated with a HAPI token""""""
    def wrapper(self, *args, **kwargs):
        self.auth_context = HAPI.auth_context_hapi
        return fn(self, *args, **kwargs)
    return wrapper"
3614,"def parse(response):
        """"""Parse a postdata-style response format from the API into usable data""""""

        """"""Split a a=1b=2c=3 string into a dictionary of pairs""""""
        tokens = {r[0]: r[1] for r in [r.split('=') for r in response.split(""&"")]}

        # The odd dummy parameter is of no use to us
        if 'dummy' in tokens:
            del tokens['dummy']

        """"""
        If we have key names that end in digits, these indicate the result set contains multiple sets
        For example, planet0=Hoth&x=1&y=-10&planet1=Naboo&x=9&y=13 is actually data for two planets

        Elements that end in digits (like tag0, tag1 for planets) are formatted like (tag0_1, tag1_1), so we rstrip
        underscores afterwards.
        """"""
        if re.match('\D\d+$', tokens.keys()[0]):
            # Produce a list of dictionaries
            set_tokens = []
            for key, value in tokens:
                key = re.match('^(.+\D)(\d+)$', key)
                # If the key isn't in the format (i.e. a failsafe), skip it
                if key is not None:
                    if key.group(1) not in set_tokens:
                        set_tokens[key.group(1)] = {}

                    set_tokens[key.group(1)][key.group(0).rstrip('_')] = value
            tokens = set_tokens

        return tokens"
3615,"def init_chain(self):
        """"""Autodetect the devices attached to the Controller, and initialize a JTAGDevice for each.

        This is a required call before device specific Primitives can
        be used.

        """"""
        if not self._hasinit:
            self._hasinit = True
            self._devices = []

            self.jtag_enable()
            while True:
                # pylint: disable=no-member
                idcode = self.rw_dr(bitcount=32, read=True,
                                    lastbit=False)()
                if idcode in NULL_ID_CODES: break
                dev = self.initialize_device_from_id(self, idcode)
                if self._debug:
                    print(dev)
                self._devices.append(dev)
                if len(self._devices) >= 128:
                    raise JTAGTooManyDevicesError(""This is an arbitrary ""
                        ""limit to deal with breaking infinite loops. If ""
                        ""you have more devices, please open a bug"")

            self.jtag_disable()

            #The chain comes out last first. Reverse it to get order.
            self._devices.reverse()"
3616,"def get_fitted_lv1_prim(self, reqef, bitcount):
        """"""
             request
        r   - A C 0 1
        e -|? ! ! ! !
        s A|? ✓ ✓ 0 1 Check this logic
        u C|? m ✓ 0 1
        l 0|? M M 0 !
        t 1|? M M ! 1

        - = No Care
        A = arbitrary
        C = Constant
        0 = ZERO
        1 = ONE

        ! = ERROR
        ? = NO CARE RESULT
        ✓ = Pass data directly
        m = will require reconfiguring argument and using multiple of prim
        M = Requires using multiple of several prims to satisfy requirement
        """"""
        res = self._fitted_lv1_prim_cache.get(reqef)
        if res:
            return res
        prim = self.get_best_lv1_prim(reqef, bitcount)
        dispatcher = PrimitiveLv1Dispatcher(self, prim, reqef)
        self._fitted_lv1_prim_cache[reqef] = dispatcher
        return dispatcher"
3617,"def _UserUpdateConfigValue(self, configKey, strDescriptor, isDir = True, dbConfigValue = None):
    """"""
    Allow user to set or update config values in the database table.
    This is always called if no valid entry exists in the table already.

    Parameters
    ----------
      configKey : string
        Name of config field.

      strDescriptor : string
        Description of config field.

      isDir : boolean [optional : default = True]
        Set to True if config value is
        expected to be a directory path.

      dbConfigValue : string [optional : default = None]
        The value of an existing entry
        for the given config field.

    Returns
    ----------
      string
        New value for given config field in database.
    """"""
    newConfigValue = None

    if dbConfigValue is None:
      prompt = ""Enter new {0} or 'x' to exit: "".format(strDescriptor)
    else:
      prompt = ""Enter 'y' to use existing {0}, enter a new {0} or 'x' to exit: "".format(strDescriptor)

    while newConfigValue is None:
      response = goodlogging.Log.Input(""CLEAR"", prompt)

      if response.lower() == 'x':
        sys.exit(0)
      elif dbConfigValue is not None and response.lower() == 'y':
        newConfigValue = dbConfigValue
      elif not isDir:
        newConfigValue = response
        self._db.SetConfigValue(configKey, newConfigValue)
      else:
        if os.path.isdir(response):
          newConfigValue = os.path.abspath(response)
          self._db.SetConfigValue(configKey, newConfigValue)
        else:
          goodlogging.Log.Info(""CLEAR"", ""{0} is not recognised as a directory"".format(response))

    return newConfigValue"
3618,"def _GetConfigValue(self, configKey, strDescriptor, isDir = True):
    """"""
    Get configuration value from database table. If no value found user
    will be prompted to enter one.

    Parameters
    ----------
      configKey : string
        Name of config field.

      strDescriptor : string
        Description of config field.

      isDir : boolean [optional : default = True]
        Set to True if config value is
        expected to be a directory path.

    Returns
    ----------
      string
        Value for given config field in database.
    """"""
    goodlogging.Log.Info(""CLEAR"", ""Loading {0} from database:"".format(strDescriptor))
    goodlogging.Log.IncreaseIndent()
    configValue = self._db.GetConfigValue(configKey)

    if configValue is None:
      goodlogging.Log.Info(""CLEAR"", ""No {0} exists in database"".format(strDescriptor))
      configValue = self._UserUpdateConfigValue(configKey, strDescriptor, isDir)
    else:
      goodlogging.Log.Info(""CLEAR"", ""Got {0} {1} from database"".format(strDescriptor, configValue))


    if not isDir or os.path.isdir(configValue):
      goodlogging.Log.Info(""CLEAR"", ""Using {0} {1}"".format(strDescriptor, configValue))
      goodlogging.Log.DecreaseIndent()
      return configValue
    else:
      goodlogging.Log.Info(""CLEAR"", ""Exiting... {0} is not recognised as a directory"".format(configValue))
      sys.exit(0)"
3619,"def _UserUpdateSupportedFormats(self, origFormatList = []):
    """"""
    Add supported formats to database table. Always called if the
    database table is empty.

    User can build a list of entries to add to the database table
    (one entry at a time). Once finished they select the finish option
    and all entries will be added to the table. They can reset the
    list at any time before finishing.

    Parameters
    ----------
      origFormatList : list [optional : default = []]
        List of original formats from database table.

    Returns
    ----------
      string
        List of updated formats from database table.
    """"""
    formatList = list(origFormatList)

    inputDone = None
    while inputDone is None:
      prompt = ""Enter new format (e.g. .mp4, .avi), "" \
                             ""'r' to reset format list, "" \
                             ""'f' to finish or "" \
                             ""'x' to exit: ""
      response = goodlogging.Log.Input(""CLEAR"", prompt)

      if response.lower() == 'x':
        sys.exit(0)
      elif response.lower() == 'f':
        inputDone = 1
      elif response.lower() == 'r':
        formatList = []
      else:
        if response is not None:
          if(response[0] != '.'):
            response = '.' + response
          formatList.append(response)

    formatList = set(formatList)
    origFormatList = set(origFormatList)

    if formatList != origFormatList:
      self._db.PurgeSupportedFormats()
      for fileFormat in formatList:
        self._db.AddSupportedFormat(fileFormat)

    return formatList"
3620,"def _GetSupportedFormats(self):
    """"""
    Get supported format values from database table. If no values found user
    will be prompted to enter values for this table.

    Returns
    ----------
      string
        List of supported formats from database table.
    """"""
    goodlogging.Log.Info(""CLEAR"", ""Loading supported formats from database:"")
    goodlogging.Log.IncreaseIndent()
    formatList = self._db.GetSupportedFormats()

    if formatList is None:
      goodlogging.Log.Info(""CLEAR"", ""No supported formats exist in database"")
      formatList = self._UserUpdateSupportedFormats()
    else:
      goodlogging.Log.Info(""CLEAR"", ""Got supported formats from database: {0}"".format(formatList))

    goodlogging.Log.Info(""CLEAR"", ""Using supported formats: {0}"".format(formatList))
    goodlogging.Log.DecreaseIndent()
    return formatList"
3621,"def _UserUpdateIgnoredDirs(self, origIgnoredDirs = []):
    """"""
    Add ignored directories to database table. Always called if the
    database table is empty.

    User can build a list of entries to add to the database table
    (one entry at a time). Once finished they select the finish option
    and all entries will be added to the table. They can reset the
    list at any time before finishing.

    Parameters
    ----------
      origIgnoredDirs : list [optional : default = []]
        List of original ignored directories from database table.

    Returns
    ----------
      string
        List of updated ignored directories from database table.
    """"""
    ignoredDirs = list(origIgnoredDirs)

    inputDone = None
    while inputDone is None:
      prompt = ""Enter new directory to ignore (e.g. DONE), "" \
                           ""'r' to reset directory list, "" \
                           ""'f' to finish or "" \
                           ""'x' to exit: ""
      response = goodlogging.Log.Input(""CLEAR"", prompt)

      if response.lower() == 'x':
        sys.exit(0)
      elif response.lower() == 'f':
        inputDone = 1
      elif response.lower() == 'r':
        ignoredDirs = []
      else:
        if response is not None:
          ignoredDirs.append(response)

    ignoredDirs = set(ignoredDirs)
    origIgnoredDirs = set(origIgnoredDirs)

    if ignoredDirs != origIgnoredDirs:
      self._db.PurgeIgnoredDirs()
      for ignoredDir in ignoredDirs:
        self._db.AddIgnoredDir(ignoredDir)

    return list(ignoredDirs)"
3622,"def _GetIgnoredDirs(self):
    """"""
    Get ignored directories values from database table. If no values found user
    will be prompted to enter values for this table.

    Returns
    ----------
      string
        List of ignored directories from database table.
    """"""
    goodlogging.Log.Info(""CLEAR"", ""Loading ignored directories from database:"")
    goodlogging.Log.IncreaseIndent()
    ignoredDirs = self._db.GetIgnoredDirs()

    if ignoredDirs is None:
      goodlogging.Log.Info(""CLEAR"", ""No ignored directories exist in database"")
      ignoredDirs = self._UserUpdateIgnoredDirs()
    else:
      goodlogging.Log.Info(""CLEAR"", ""Got ignored directories from database: {0}"".format(ignoredDirs))

    if self._archiveDir not in ignoredDirs:
      ignoredDirs.append(self._archiveDir)

    goodlogging.Log.Info(""CLEAR"", ""Using ignored directories: {0}"".format(ignoredDirs))
    goodlogging.Log.DecreaseIndent()
    return ignoredDirs"
3623,"def _GetDatabaseConfig(self):
    """"""
    Get all configuration from database.

    This includes values from the Config table as well as populating lists
    for supported formats and ignored directories from their respective
    database tables.
    """"""
    goodlogging.Log.Seperator()
    goodlogging.Log.Info(""CLEAR"", ""Getting configuration variables..."")
    goodlogging.Log.IncreaseIndent()

    # SOURCE DIRECTORY
    if self._sourceDir is None:
      self._sourceDir = self._GetConfigValue('SourceDir', 'source directory')

    # TV DIRECTORY
    if self._inPlaceRename is False and self._tvDir is None:
      self._tvDir = self._GetConfigValue('TVDir', 'tv directory')

    # ARCHIVE DIRECTORY
    self._archiveDir = self._GetConfigValue('ArchiveDir', 'archive directory', isDir = False)

    # SUPPORTED FILE FORMATS
    self._supportedFormatsList = self._GetSupportedFormats()

    # IGNORED DIRECTORIES
    self._ignoredDirsList = self._GetIgnoredDirs()

    goodlogging.Log.NewLine()
    goodlogging.Log.Info(""CLEAR"", ""Configuation is:"")
    goodlogging.Log.IncreaseIndent()
    goodlogging.Log.Info(""CLEAR"", ""Source directory = {0}"".format(self._sourceDir))
    goodlogging.Log.Info(""CLEAR"", ""TV directory = {0}"".format(self._tvDir))
    goodlogging.Log.Info(""CLEAR"", ""Supported formats = {0}"".format(self._supportedFormatsList))
    goodlogging.Log.Info(""CLEAR"", ""Ignored directory list = {0}"".format(self._ignoredDirsList))
    goodlogging.Log.ResetIndent()"
3624,"def _GetArgs(self):
    """""" Parse plusargs. """"""
    parser = argparse.ArgumentParser()
    parser.add_argument('-s', '--src', help='override database source directory')
    parser.add_argument('-d', '--dst', help='override database destination directory')

    parser.add_argument('-e', '--extract', help='enable extracting of rar files', action=""store_true"")

    parser.add_argument('-c', '--copy', help='enable copying between file systems', action=""store_true"")
    parser.add_argument('-i', '--inplace', help='rename files in place', action=""store_true"")

    parser.add_argument('-u', '--update_db', help='provides option to update existing database fields', action=""store_true"")
    parser.add_argument('-p', '--print_db', help='print contents of database', action=""store_true"")

    parser.add_argument('-n', '--no_input', help='automatically accept or skip all user input', action=""store_true"")
    parser.add_argument('-nr', '--no_input_rename', help='automatically accept or skip user input for guide lookup and rename', action=""store_true"")
    parser.add_argument('-ne', '--no_input_extract', help='automatically accept or skip user input for extraction', action=""store_true"")

    parser.add_argument('--debug', help='enable full logging', action=""store_true"")
    parser.add_argument('--tags', help='enable tags on log info', action=""store_true"")

    parser.add_argument('--test', help='run with test database', action=""store_true"")
    parser.add_argument('--reset', help='resets database', action=""store_true"")

    args = parser.parse_args()

    if args.test:
      self._databasePath = 'test.db'

    if args.no_input or args.no_input_rename:
      self._skipUserInputRename = True

    if args.no_input or args.no_input_extract:
      self._skipUserInputExtract = True

    if args.reset:
      goodlogging.Log.Info(""CLEAR"", ""*WARNING* YOU ARE ABOUT TO DELETE DATABASE {0}"".format(self._databasePath))
      response = goodlogging.Log.Input(""CLEAR"", ""Are you sure you want to proceed [y/n]? "")
      if response.lower() == 'y':
        if(os.path.isfile(self._databasePath)):
          os.remove(self._databasePath)
      else:
        sys.exit(0)

    if args.inplace:
      self._inPlaceRename = True

    if args.copy:
      self._crossSystemCopyEnabled = True

    if args.tags:
      goodlogging.Log.tagsEnabled = 1

    if args.debug:
      goodlogging.Log.verbosityThreshold = goodlogging.Verbosity.MINIMAL

    if args.update_db:
      self._dbUpdate = True

    if args.print_db:
      self._dbPrint = True

    if args.extract:
      self._enableExtract = True

    if args.src:
      if os.path.isdir(args.src):
        self._sourceDir = args.src
      else:
        goodlogging.Log.Fatal(""CLEAR"", 'Source directory argument is not recognised as a directory: {}'.format(args.src))

    if args.dst:
      if os.path.isdir(args.dst):
        self._tvDir = args.dst
      else:
        goodlogging.Log.Fatal(""CLEAR"", 'Target directory argument is not recognised as a directory: {}'.format(args.dst))"
3625,"def _GetSupportedFilesInDir(self, fileDir, fileList, supportedFormatList, ignoreDirList):
    """"""
    Recursively get all supported files given a root search directory.

    Supported file extensions are given as a list, as are any directories which
    should be ignored.

    The result will be appended to the given file list argument.

    Parameters
    ----------
      fileDir : string
        Path to root of directory tree to search.

      fileList : string
        List to add any found files to.

      supportedFormatList : list
        List of supported file extensions.

      ignoreDirList : list
        List of directories to ignore.
    """"""
    goodlogging.Log.Info(""CLEAR"", ""Parsing file directory: {0}"".format(fileDir))
    if os.path.isdir(fileDir) is True:
      for globPath in glob.glob(os.path.join(fileDir, '*')):
        if util.FileExtensionMatch(globPath, supportedFormatList):
          newFile = tvfile.TVFile(globPath)
          if newFile.GetShowDetails():
            fileList.append(newFile)
        elif os.path.isdir(globPath):
          if(os.path.basename(globPath) in ignoreDirList):
            goodlogging.Log.Info(""CLEAR"", ""Skipping ignored directory: {0}"".format(globPath))
          else:
            self._GetSupportedFilesInDir(globPath, fileList, supportedFormatList, ignoreDirList)
        else:
          goodlogging.Log.Info(""CLEAR"", ""Ignoring unsupported file or folder: {0}"".format(globPath))
    else:
      goodlogging.Log.Info(""CLEAR"", ""Invalid non-directory path given to parse"")"
3626,"def Run(self):
    """"""
    Main entry point for ClearManager class.

    Does the following steps:

    - Parse script arguments.
    - Optionally print or update database tables.
    - Get all configuration settings from database.
    - Optionally parse directory for file extraction.
    - Recursively parse source directory for files matching
      supported format list.
    - Call renamer.TVRenamer with file list.
    """"""
    self._GetArgs()

    goodlogging.Log.Info(""CLEAR"", ""Using database: {0}"".format(self._databasePath))
    self._db = database.RenamerDB(self._databasePath)

    if self._dbPrint or self._dbUpdate:
      goodlogging.Log.Seperator()
      self._db.PrintAllTables()

      if self._dbUpdate:
        goodlogging.Log.Seperator()
        self._db.ManualUpdateTables()

    self._GetDatabaseConfig()

    if self._enableExtract:
      goodlogging.Log.Seperator()

      extractFileList = []
      goodlogging.Log.Info(""CLEAR"", ""Parsing source directory for compressed files"")
      goodlogging.Log.IncreaseIndent()
      extract.GetCompressedFilesInDir(self._sourceDir, extractFileList, self._ignoredDirsList)
      goodlogging.Log.DecreaseIndent()

      goodlogging.Log.Seperator()
      extract.Extract(extractFileList, self._supportedFormatsList, self._archiveDir, self._skipUserInputExtract)

    goodlogging.Log.Seperator()

    tvFileList = []
    goodlogging.Log.Info(""CLEAR"", ""Parsing source directory for compatible files"")
    goodlogging.Log.IncreaseIndent()
    self._GetSupportedFilesInDir(self._sourceDir, tvFileList, self._supportedFormatsList, self._ignoredDirsList)
    goodlogging.Log.DecreaseIndent()

    tvRenamer = renamer.TVRenamer(self._db,
                                  tvFileList,
                                  self._archiveDir,
                                  guideName = 'EPGUIDES',
                                  tvDir = self._tvDir,
                                  inPlaceRename = self._inPlaceRename,
                                  forceCopy = self._crossSystemCopyEnabled,
                                  skipUserInput = self._skipUserInputRename)
    tvRenamer.Run()"
3627,"def cli(ctx, amount, index, stage):
    """"""Transform data""""""
    if not ctx.bubble:
        ctx.say_yellow('There is no bubble present, will not transform')
        raise click.Abort()

    path = ctx.home + '/'

    STAGE = None
    RULES = None
    UNIQ_KEYS_PULL = None
    UNIQ_KEYS_PUSH = None
    CLEAN_MISSING_AFTER_SECONDS = None
    if stage in STAGES and stage in ctx.cfg.CFG:
        STAGE = ctx.cfg.CFG[stage]
    if not STAGE:
        ctx.say_red('There is no STAGE in CFG:' + stage)
        ctx.say_yellow('please check configuration in ' +
        ctx.home + '/config/config.yaml')
        raise click.Abort()

    if 'TRANSFORM' in STAGE:
         TRANSFORM = ctx.cfg.CFG[stage].TRANSFORM
    else:
         ctx.say_yellow(""""""There is no transform defined in the configuration, will not transform,
when pushing the results of step 'pulled' will be read instead of 'push'
"""""")
         raise click.Abort()

    if 'RULES' in TRANSFORM:
        RULES = TRANSFORM.RULES
    if 'UNIQ_KEYS_PULL' in TRANSFORM:
        UNIQ_KEYS_PULL = TRANSFORM.UNIQ_KEYS_PULL
    if 'UNIQ_KEYS_PUSH' in TRANSFORM:
        UNIQ_KEYS_PUSH = TRANSFORM.UNIQ_KEYS_PUSH
    if 'CLEAN_MISSING_AFTER_SECONDS' in TRANSFORM:
        CLEAN_MISSING_AFTER_SECONDS = TRANSFORM.CLEAN_MISSING_AFTER_SECONDS

    if not RULES:
        ctx.say_red('There is no TRANSFORM.RULES in stage:' + stage)
        ctx.say_yellow('please check configuration in ' +
                       ctx.home + '/config/config.yaml')
        raise click.Abort()

    full_data = False
    if amount == -1 and index == -1:
        full_data = True

    data_gen = bubble_lod_load(ctx, 'store', stage)
    stored_data = {}
    for stored_data_item in data_gen:
        stored_data = stored_data_item
        break  # first_only

    ctx.gbc.say('stored:', stuff=stored_data, verbosity=150)

    cfgdict = {}
    cfgdict['CFG'] = ctx.cfg.CFG
    cfgdict['GENERAL_BUBBLE_CONTEXT'] = ctx.GLOBALS['gbc']
    cfgdict['ARGS'] = {'stage': stage,
                       'path': path}

    if type(RULES) == str and RULES.endswith('.bubble'):
        rules = get_bubble(ctx.gbc, path + RULES)
        rule_type = 'bubble'
        transformer = Transformer(rules=rules,
                                  rule_type=rule_type,
                                  store=stored_data,
                                  config=cfgdict,
                                  bubble_path=path,
                                  verbose=ctx.get_verbose())

    src_data = bubble_lod_load(ctx, 'pulled', stage)

    to_transform = get_gen_slice(ctx.gbc, src_data, amount, index)
    ctx.gbc.say('sliced to transform:', stuff=to_transform, verbosity=50)

    if UNIQ_KEYS_PULL:
        to_transform = make_uniq_for_step(ctx=ctx,
                                          ukeys=UNIQ_KEYS_PULL,
                                          step='uniq_pull',
                                          stage=stage,
                                          full_data=full_data,
                                          clean_missing_after_seconds=CLEAN_MISSING_AFTER_SECONDS,
                                          to_uniq=to_transform)

    ctx.gbc.say('transformer to transform', stuff=to_transform, verbosity=295)

    transformed_count = Counter()

    error_count = Counter()
    result = do_yielding_transform(ctx,
                                   transformer,
                                   to_transform,
                                   transformed_count,
                                   error_count)

    ##########################################################################
    pfr = bubble_lod_dump(ctx=ctx,
                          step='push',
                          stage=stage,
                          full_data=full_data,
                          reset=True,
                          data_gen=result)
    ctx.say('transformed [%d] objects' % pfr['total'])

    # closing the store, to be sure, get store after yielding transform has
    # completed
    store = transformer.get_store()
    ctx.gbc.say('transformer persistant storage', stuff=store, verbosity=1000)

    pfr = bubble_lod_dump(ctx=ctx,
                          step='store',
                          stage=stage,
                          full_data=full_data,
                          reset=True,
                          data_gen=[store])
    ctx.say('pulled [%d] objects' % pfr['total'])
    ctx.gbc.say('transformer all done :transformed_count:%d,error_count:%d' %
                (transformed_count.get_total(), error_count.get_total()),
                verbosity=10)

    if UNIQ_KEYS_PUSH:
        make_uniq_for_step(ctx=ctx,
                           ukeys=UNIQ_KEYS_PUSH,
                           step='uniq_push',
                           stage=stage,
                           full_data=full_data,
                           clean_missing_after_seconds=CLEAN_MISSING_AFTER_SECONDS,
                           to_uniq=result)
        # TODO: check if to_uniq can be loaded inside make_uniq
        # the result of the transform is a generator and should be 'empty' already
        # by the previous dump of the results.

    stats = {}
    stats['transformed_stat_error_count'] = error_count.get_total()
    stats['transformed_stat_transformed_count'] = transformed_count.get_total()

    update_stats(ctx, stage, stats)

    return True"
3628,"def _merge_prims(prims, *, debug=False, stagenames=None, stages=None):
    """"""Helper method to greedily combine Frames (of Primitives) or Primitives based on the rules defined in the Primitive's class.

    Used by a CommandQueue during compilation and optimization of
    Primitives.

    Args:
        prims: A list or FrameSequence of Primitives or Frames (respectively) to try to merge together.
        debug: A boolean for if debug information should be generated.
        stages: A list to be edited by this method to store snapshots of the compilation state. Used if debug is True.
        stagenames: A list of strings describing each debug snapshot of the compiilation process. Used if debug is True.

    Returns:
        A list or FrameSequence (the same type as prims) of the compined Primitives or Frames.
    """"""
    if isinstance(prims, FrameSequence):
        merged_prims = FrameSequence(prims._chain)
    else:
        merged_prims = []
    working_prim = prims[0]
    i = 1
    logging_tmp = []

    while i < len(prims):
        tmp = prims[i]
        res = working_prim.merge(tmp)
        if res is not None:
            working_prim = res
            if debug:#pragma: no cover
                logging_tmp.append(
                    [p.snapshot() for p in
                     merged_prims+[working_prim]])
        else:
            merged_prims.append(working_prim)
            working_prim = tmp
        i += 1
    merged_prims.append(working_prim)
    if debug:#pragma: no cover
        stages.append(logging_tmp)
        stagenames.append(""Merge intermediate states"")

    return merged_prims"
3629,"def _compile_device_specific_prims(self, debug=False,
                                       stages=None, stagenames=None):
        """"""Using the data stored in the CommandQueue, Extract and align compatible sequences of Primitives and compile/optimize the Primitives down into a stream of Level 2 device agnostic primitives.

        BACKGROUND:
        Device Specific primitives present a special opportunity for
        optimization. Many JTAG systems program one device on the
        chain at a time. But because all devices on a JTAG chain are
        sent information at once, NO-OP instructions are sent to these
        other devices.

        When programming multiple devices, Sending these NO-OPS is a
        missed opportunity for optimization. Instead of configuring
        one device at a time, it is more efficient to collect
        instructions for all deices, and align them so multiple
        devices can be configured at the same time.

        WAT THIS METHOD DOES:
        This method takes in a list of Primitives, groups the device
        specific primitives by target device, aligns the sequences of
        device instructions, and expands the aligned sequences into a
        flat list of device agnostic primitives.

        Args:
            debug: A boolean for if debug information should be generated.
            stages: A list to be edited by this method to store snapshots of the compilation state. Used if debug is True.
            stagenames: A list of strings describing each debug snapshot of the compiilation process. Used if debug is True.

        """"""
        ############### GROUPING BY EXEC BOUNDARIES!################

        fences = []
        fence = [self[0]]
        for p in self[1:]:
            if type(fence[0])._layer == type(p)._layer and\
               isinstance(fence[0], DeviceTarget) == \
                  isinstance(p, DeviceTarget):
                fence.append(p)
            else:
                fences.append(fence)
                fence = [p]
        fences.append(fence)

        if debug: #pragma: no cover
            formatted_fences = []
            for fence in fences:
                formatted_fence = [p.snapshot() for p in fence]
                formatted_fences.append(formatted_fence)
                formatted_fences.append([])
            stages.append(formatted_fences[:-1]) #Ignore trailing []
            stagenames.append(""Fencing off execution boundaries"")

        ############## SPLIT GROUPS BY DEVICE TARGET! ##############

        split_fences = []
        for fence in fences:
            tmp_chains = {}
            for p in fence:
                k = p._device_index \
                    if isinstance(p, DeviceTarget) else ""chain""
                subchain = tmp_chains.setdefault(k, []).append(p)
            split_fences.append(list(tmp_chains.values()))

        if debug:#pragma: no cover
            formatted_split_fences = []
            for fence in split_fences:
                for group in fence:
                    formatted_split_fences.append([p.snapshot()
                                                   for p in group])
                formatted_split_fences.append([])
            stages.append(formatted_split_fences[:-1])
            stagenames.append(""Grouping prims of each boundary by ""
                              ""target device"")

        ############## ALIGN SEQUENCES AND PAD FRAMES ##############
        #FIRST DEV REQUIRED LINE
        grouped_fences = [
            FrameSequence(self._chain, *fence).finalize()
            for f_i, fence in enumerate(split_fences)
        ]

        if debug:#pragma: no cover
            formatted_grouped_fences = []
            for fence in grouped_fences:
                formatted_grouped_fences += fence.snapshot() + [[]]
            stages.append(formatted_grouped_fences[:-1])
            stagenames.append(""Aligning and combining each group dev ""
                              ""prim stream"")

        ################## RECOMBINE FRAME GROUPS ##################

        ingested_chain = grouped_fences[0]
        for fence in grouped_fences[1:]:
            ingested_chain += fence

        if debug:#pragma: no cover
            stages.append(ingested_chain.snapshot())
            stagenames.append(""Recombining sanitized exec boundaries"")

        ###################### POST INGESTION ######################
        ################ Flatten out LV3 Primitives ################
        while(any((f._layer == 3 for f in ingested_chain))):
            ################# COMBINE COMPATIBLE PRIMS #################
            ingested_chain = _merge_prims(ingested_chain)

            if debug:#pragma: no cover
                stages.append(ingested_chain.snapshot())
                stagenames.append(""Combining compatible lv3 prims."")

            ################ TRANSLATION TO LOWER LAYER ################
            sm = JTAGStateMachine(self._chain._sm.state)
            expanded_prims = FrameSequence(self._chain)
            for f in ingested_chain:
                if f._layer == 3:
                    expanded_prims += f.expand_macro(sm)
                else:
                    expanded_prims.append(f)
            expanded_prims.finalize()
            ingested_chain = expanded_prims

            if self._fsm is None:
                self._fsm = sm
            assert self._fsm == sm, ""Target %s != Actual %s""%\
                (self._fsm.state, sm.state)

            if debug:#pragma: no cover
                stages.append(ingested_chain.snapshot())
                stagenames.append(""Expanding lv3 prims"")


        ############## Flatten out Dev LV2 Primitives ##############
        while(any((isinstance(f._valid_prim, DeviceTarget)
                   for f in ingested_chain))):
            ################# COMBINE COMPATIBLE PRIMS #################
            ingested_chain = _merge_prims(ingested_chain)

            if debug:#pragma: no cover
                stages.append(ingested_chain.snapshot())
                stagenames.append(""Merging Device Specific Prims"")

            ################ TRANSLATION TO LOWER LAYER ################

            sm = JTAGStateMachine(self._chain._sm.state)
            expanded_prims = FrameSequence(self._chain)
            for f in ingested_chain:
                if issubclass(f._prim_type, DeviceTarget):
                    expanded_prims += f.expand_macro(sm)
                else:
                    f[0].apply_tap_effect(sm)
                    expanded_prims.append(f)
            expanded_prims.finalize()
            ingested_chain = expanded_prims
            if self._fsm is None:
                self._fsm = sm
            assert self._fsm == sm, ""Target %s != Actual %s""%\
                 (self._fsm.state, sm.state)

            if debug:#pragma: no cover
                stages.append(ingested_chain.snapshot())
                stagenames.append(""Expanding Device Specific Prims"")

        ############ Convert FrameSequence to flat array ###########
        flattened_prims = [f._valid_prim for f in ingested_chain]
        if debug:#pragma: no cover
            stages.append([[p.snapshot() for p in flattened_prims]])
            stagenames.append(""Converting format to single stream."")

        return flattened_prims"
3630,"def flush(self):
        """"""Force the queue of Primitives to compile, execute on the Controller, and fulfill promises with the data returned.""""""
        self.stages = []
        self.stagenames = []

        if not self.queue:
            return

        if self.print_statistics:#pragma: no cover
            print(""LEN OF QUENE"", len(self))
            t = time()

        if self._chain._collect_compiler_artifacts:
            self._compile(debug=True, stages=self.stages,
                          stagenames=self.stagenames)
        else:
            self._compile()

        if self.debug:
            print(""ABOUT TO EXEC"", self.queue)#pragma: no cover

        if self.print_statistics:#pragma: no cover
            print(""COMPILE TIME"", time()-t)
            print(""TOTAL BITS OF ALL PRIMS"", sum(
                (p.count for p in self.queue if hasattr(p, 'count'))))
            t = time()

        self._chain._controller._execute_primitives(self.queue)

        if self.print_statistics:
            print(""EXECUTE TIME"", time()-t)#pragma: no cover

        self.queue = []
        self._chain._sm.state = self._fsm.state"
3631,"def Ping(self, request, context):
        """"""
        Invoke the Server health endpoint
        :param request: Empty
        :param context: the request context
        :return: Status message 'alive'
        """"""
        status =  processor_pb2.Status()
        status.message='alive'
        return status"
3632,"def Process(self, request, context):
        """"""
        Invoke the Grpc Processor, delegating to the handler_function. If the handler_function has a single argument,
        pass the Message payload. If two arguments, pass the payload and headers as positional arguments:
        handler_function(payload, headers). If the handler function return is not of type(Message), create a new Message using
        the original header values (new id and timestamp).

        :param request: the message
        :param context: the request context
        :return: response message
        """"""
        logger.debug(request)
        message = Message.__from_protobuf_message__(request)
        sig = getfullargspec(self.handler_function)
        if len(sig.args) == 2:
            result = self.handler_function(message.payload, message.headers)
        elif len(sig.args) == 1:
            result = self.handler_function(message.payload)
        else:
            context.set_code(grpc.StatusCode.INTERNAL)
            context.set_details('wrong number of arguments for handler function - must be 1 or 2')
            raise RuntimeError('wrong number of arguments for handler function - must be 1 or 2')

        if self.component_type == StreamComponent.PROCESSOR:
            if type(result) == Message:
                return result.__to_protobuf_message__()
            else:
                headers = MessageHeaders()
                headers.copy(message.headers)
                return Message(result, headers).__to_protobuf_message__()"
3633,"def step_impl(context):
    """"""Compares text as written to the log output""""""
    expected_lines = context.text.split('\n')
    assert len(expected_lines) == len(context.output)
    for expected, actual in zip(expected_lines, context.output):
        print('--\n\texpected: {}\n\tactual: {}'.format(expected, actual))
        assert expected == actual"
3634,"def _ParseShowList(self, checkOnly=False):
    """"""
    Read self._allShowList as csv file and make list of titles and IDs.

    Parameters
    ----------
      checkOnly : boolean [optional : default = False]
          If checkOnly is True this will only check to ensure the column
          headers can be extracted correctly.
    """"""
    showTitleList = []
    showIDList = []

    csvReader = csv.reader(self._allShowList.splitlines())
    for rowCnt, row in enumerate(csvReader):
      if rowCnt == 0:
        # Get header column index
        for colCnt, column in enumerate(row):
          if column == 'title':
            titleIndex = colCnt
          if column == self.ID_LOOKUP_TAG:
            lookupIndex = colCnt
      else:
        try:
          showTitleList.append(row[titleIndex])
          showIDList.append(row[lookupIndex])
        except UnboundLocalError:
          goodlogging.Log.Fatal(""EPGUIDE"", ""Error detected in EPGUIDES allshows csv content"")
        else:
          if checkOnly and rowCnt > 1:
            return True
    self._showTitleList = showTitleList
    self._showIDList = showIDList
    return True"
3635,"def _GetAllShowList(self):
    """"""
    Populates self._allShowList with the epguides all show info.

    On the first lookup for a day the information will be loaded from
    the epguides url. This will be saved to local file _epguides_YYYYMMDD.csv
    and any old files will be removed. Subsequent accesses for the same day
    will read this file.
    """"""
    today = datetime.date.today().strftime(""%Y%m%d"")
    saveFile = '_epguides_' + today + '.csv'
    saveFilePath = os.path.join(self._saveDir, saveFile)
    if os.path.exists(saveFilePath):
      # Load data previous saved to file
      with open(saveFilePath, 'r') as allShowsFile:
        self._allShowList = allShowsFile.read()
    else:
      # Download new list from EPGUIDES and strip any leading or trailing whitespace
      self._allShowList = util.WebLookup(self.ALLSHOW_IDLIST_URL).strip()

      if self._ParseShowList(checkOnly=True):
        # Save to file to avoid multiple url requests in same day
        with open(saveFilePath, 'w') as allShowsFile:
          goodlogging.Log.Info(""EPGUIDE"", ""Adding new EPGUIDES file: {0}"".format(saveFilePath), verbosity=self.logVerbosity)
          allShowsFile.write(self._allShowList)

        # Delete old copies of this file
        globPattern = '_epguides_????????.csv'
        globFilePath = os.path.join(self._saveDir, globPattern)
        for filePath in glob.glob(globFilePath):
          if filePath != saveFilePath:
            goodlogging.Log.Info(""EPGUIDE"", ""Removing old EPGUIDES file: {0}"".format(filePath), verbosity=self.logVerbosity)
            os.remove(filePath)"
3636,"def _GetShowID(self, showName):
    """"""
    Get epguides show id for a given show name.

    Attempts to match the given show name against a show title in
    self._showTitleList and, if found, returns the corresponding index
    in self._showIDList.

    Parameters
    ----------
      showName : string
        Show name to get show ID for.

    Returns
    ----------
      int or None
        If a show id is found this will be returned, otherwise None is returned.
    """"""
    self._GetTitleList()
    self._GetIDList()

    for index, showTitle in enumerate(self._showTitleList):
      if showName == showTitle:
        return self._showIDList[index]
    return None"
3637,"def _ExtractDataFromShowHtml(self, html):
    """"""
    Extracts csv show data from epguides html source.

    Parameters
    ----------
      html : string
        Block of html text

    Returns
    ----------
       string
        Show data extracted from html text in csv format.
    """"""
    htmlLines = html.splitlines()
    for count, line in enumerate(htmlLines):
      if line.strip() == r'<pre>':
        startLine = count+1
      if line.strip() == r'</pre>':
        endLine = count

    try:
      dataList = htmlLines[startLine:endLine]
      dataString = '\n'.join(dataList)
      return dataString.strip()
    except:
      raise Exception(""Show content not found - check EPGuides html formatting"")"
3638,"def _GetEpisodeName(self, showID, season, episode):
    """"""
    Get episode name from epguides show info.

    Parameters
    ----------
      showID : string
        Identifier matching show in epguides.

      season : int
        Season number.

      epiosde : int
        Epiosde number.

    Returns
    ----------
      int or None
        If an episode name is found this is returned, otherwise the return
        value is None.
    """"""
    # Load data for showID from dictionary
    showInfo = csv.reader(self._showInfoDict[showID].splitlines())
    for rowCnt, row in enumerate(showInfo):
      if rowCnt == 0:
        # Get header column index
        for colCnt, column in enumerate(row):
          if column == 'season':
            seasonIndex = colCnt
          if column == 'episode':
            episodeIndex = colCnt
          if column == 'title':
            titleIndex = colCnt
      else:
        # Iterate rows until matching season and episode found
        try:
          int(row[seasonIndex])
          int(row[episodeIndex])
        except ValueError:
          # Skip rows which don't provide integer season or episode numbers
          pass
        else:
          if int(row[seasonIndex]) == int(season) and int(row[episodeIndex]) == int(episode):
            goodlogging.Log.Info(""EPGUIDE"", ""Episode name is {0}"".format(row[titleIndex]), verbosity=self.logVerbosity)
            return row[titleIndex]
    return None"
3639,"def ShowNameLookUp(self, string):
    """"""
    Attempts to find the best match for the given string in the list of
    epguides show titles. If this list has not previous been generated it
    will be generated first.

    Parameters
    ----------
      string : string
        String to find show name match against.

    Returns
    ----------
      string
        Show name which best matches input string.
    """"""
    goodlogging.Log.Info(""EPGUIDES"", ""Looking up show name match for string '{0}' in guide"".format(string), verbosity=self.logVerbosity)
    self._GetTitleList()
    showName = util.GetBestMatch(string, self._showTitleList)
    return(showName)"
3640,"def EpisodeNameLookUp(self, showName, season, episode):
    """"""
    Get the episode name correspondng to the given show name, season number
    and episode number.

    Parameters
    ----------
      showName : string
        Name of TV show. This must match an entry in the epguides
        title list (this can be achieved by calling ShowNameLookUp first).

      season : int
        Season number.

      epiosde : int
        Epiosde number.

    Returns
    ----------
      string or None
        If an episode name can be found it is returned, otherwise the return
        value is None.
    """"""
    goodlogging.Log.Info(""EPGUIDE"", ""Looking up episode name for {0} S{1}E{2}"".format(showName, season, episode), verbosity=self.logVerbosity)
    goodlogging.Log.IncreaseIndent()
    showID = self._GetShowID(showName)
    if showID is not None:
      try:
        self._showInfoDict[showID]
      except KeyError:
        goodlogging.Log.Info(""EPGUIDE"", ""Looking up info for new show: {0}(ID:{1})"".format(showName, showID), verbosity=self.logVerbosity)
        urlData = util.WebLookup(self.EPISODE_LOOKUP_URL, {self.EP_LOOKUP_TAG: showID})
        self._showInfoDict[showID] = self._ExtractDataFromShowHtml(urlData)
      else:
        goodlogging.Log.Info(""EPGUIDE"", ""Reusing show info previous obtained for: {0}({1})"".format(showName, showID), verbosity=self.logVerbosity)
      finally:
        episodeName = self._GetEpisodeName(showID, season, episode)
        goodlogging.Log.DecreaseIndent()
        return episodeName
    goodlogging.Log.DecreaseIndent()"
3641,"def clone(cls, srcpath, destpath):
        """"""Clone an existing repository to a new bare repository.""""""
        # Mercurial will not create intermediate directories for clones.
        try:
            os.makedirs(destpath)
        except OSError as e:
            if not e.errno == errno.EEXIST:
                raise
        cmd = [HG, 'clone', '--quiet', '--noupdate', srcpath, destpath]
        subprocess.check_call(cmd)
        return cls(destpath)"
3642,"def create(cls, path):
        """"""Create a new repository""""""
        cmd = [HG, 'init', path]
        subprocess.check_call(cmd)
        return cls(path)"
3643,"def private_path(self):
        """"""Get the path to a directory which can be used to store arbitrary data

        This directory should not conflict with any of the repository internals.
        The directory should be created if it does not already exist.

        """"""
        path = os.path.join(self.path, '.hg', '.private')
        try:
            os.mkdir(path)
        except OSError as e:
            if e.errno != errno.EEXIST:
                raise
        return path"
3644,"def bookmarks(self):
        """"""Get list of bookmarks""""""
        cmd = [HG, 'bookmarks']
        output = self._command(cmd).decode(self.encoding, 'replace')
        if output.startswith('no bookmarks set'):
            return []
        results = []
        for line in output.splitlines():
            m = bookmarks_rx.match(line)
            assert m, 'unexpected output: ' + line
            results.append(m.group('name'))
        return results"
3645,"def content(self):
        """"""Get the file contents.

        This property is cached. The file is only read once.
        """"""
        if not self._content:

            self._content = self._read()

        return self._content"
3646,"def config(self):
        """"""Get a Configuration object from the file contents.""""""
        conf = config.Configuration()
        for namespace in self.namespaces:

            if not hasattr(conf, namespace):

                if not self._strict:

                    continue

                raise exc.NamespaceNotRegistered(
                    ""The namespace {0} is not registered."".format(namespace)
                )

            name = getattr(conf, namespace)

            for item, value in compat.iteritems(self.items(namespace)):

                if not hasattr(name, item):

                    if not self._strict:

                        continue

                    raise exc.OptionNotRegistered(
                        ""The option {0} is not registered."".format(item)
                    )

                setattr(name, item, value)

        return conf"
3647,"def _read(self):
        """"""Open the file and return its contents.""""""
        with open(self.path, 'r') as file_handle:

            content = file_handle.read()

        # Py27 INI config parser chokes if the content provided is not unicode.
        # All other versions seems to work appropriately. Forcing the value to
        # unicode here in order to resolve this issue.
        return compat.unicode(content)"
3648,"async def ask(self, body, quick_replies=None, options=None, user=None):
        """"""
        simple ask with predefined quick replies

        :param body:
        :param quick_replies: (optional) in form of
        {'title': <message>, 'payload': <any json>}
        :param options:
        :param user:
        :return:
        """"""
        await self.send_text_message_to_all_interfaces(
            recipient=user,
            text=body,
            quick_replies=quick_replies,
            options=options,
        )
        return any.Any()"
3649,"async def say(self, body, user, options):
        """"""
        say something to user

        :param body:
        :param user:
        :return:
        """"""
        return await self.send_text_message_to_all_interfaces(
            recipient=user, text=body, options=options)"
3650,"async def send_audio(self, url, user, options=None):
        """"""
        send audio message

        :param url: link to the audio file
        :param user: target user
        :param options:
        :return:
        """"""
        tasks = [interface.send_audio(user, url, options) for _, interface in self.interfaces.items()]
        return [body for body in await asyncio.gather(*tasks)]"
3651,"async def send_text_message_to_all_interfaces(self, *args, **kwargs):
        """"""
        TODO:
        we should know from where user has come and use right interface
        as well right interface can be chosen

        :param args:
        :param kwargs:
        :return:
        """"""
        logger.debug('async_send_text_message_to_all_interfaces')
        tasks = [interface.send_text_message(*args, **kwargs)
                 for _, interface in self.interfaces.items()]

        logger.debug('  tasks')
        logger.debug(tasks)

        res = [body for body in await asyncio.gather(*tasks)]
        logger.debug('  res')
        logger.debug(res)
        return res"
3652,"def connect(self, protocolFactory):
        """"""Starts a process and connect a protocol to it.
        """"""
        deferred = self._startProcess()
        deferred.addCallback(self._connectRelay, protocolFactory)
        deferred.addCallback(self._startRelay)
        return deferred"
3653,"def _startProcess(self):
        """"""Use the inductor to start the process we want to relay data from.
        """"""
        connectedDeferred = defer.Deferred()
        processProtocol = RelayProcessProtocol(connectedDeferred)
        self.inductor.execute(processProtocol, *self.inductorArgs)
        return connectedDeferred"
3654,"def _connectRelay(self, process, protocolFactory):
        """"""Set up and connect the protocol we want to relay to the process.
        This method is automatically called when the process is started,
        and we are ready to relay through it.
        """"""
        try:
            wf = _WrappingFactory(protocolFactory)
            connector = RelayConnector(process, wf, self.timeout,
                                       self.inductor.reactor)
            connector.connect()
        except:
            return defer.fail()
        # Return a deferred that is called back when the protocol is connected.
        return wf._onConnection"
3655,"def _startRelay(self, client):
        """"""Start relaying data between the process and the protocol.
        This method is called when the protocol is connected.
        """"""
        process = client.transport.connector.process
        # Relay any buffered data that was received from the process before
        # we got connected and started relaying.
        for _, data in process.data:
            client.dataReceived(data)
        process.protocol = client

        @process._endedDeferred.addBoth
        def stopRelay(reason):
            """"""Stop relaying data. Called when the process has ended.
            """"""
            relay = client.transport
            relay.loseConnection(reason)
            connector = relay.connector
            connector.connectionLost(reason)

        # Pass through the client protocol.
        return client"
3656,"def connectRelay(self):
        """"""Builds the target protocol and connects it to the relay transport.
        """"""
        self.protocol = self.connector.buildProtocol(None)
        self.connected = True
        self.protocol.makeConnection(self)"
3657,"def childDataReceived(self, childFD, data):
        """"""Relay data received on any file descriptor to the process
        """"""
        protocol = getattr(self, 'protocol', None)
        if protocol:
            protocol.dataReceived(data)
        else:
            self.data.append((childFD, data))"
3658,"def publish(self, user, provider, obj, comment, **kwargs):
        '''
            user - django User or UserSocialAuth instance
            provider - name of publisher provider
            obj - sharing object
            comment - string
        '''
        social_user = self._get_social_user(user, provider)
        backend = self.get_backend(social_user, provider, context=kwargs)
        return backend.publish(obj, comment)"
3659,"def check(self, user, provider, permission, **kwargs):
        '''
            user - django User or UserSocialAuth instance
            provider - name of publisher provider
            permission - if backend maintains check permissions
                            vk - binary mask in int format
                            facebook - scope string
        '''
        try:
            social_user = self._get_social_user(user, provider)
            if not social_user:
                return False

        except SocialUserDoesNotExist:
            return False

        backend = self.get_backend(social_user, provider, context=kwargs)
        return backend.check(permission)"
3660,"def recognize_byte(self, image, timeout=10):
        """"""Process a byte image buffer.""""""
        result = []

        alpr = subprocess.Popen(
            self._cmd,
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            stderr=subprocess.DEVNULL
        )

        # send image
        try:
            # pylint: disable=unused-variable
            stdout, stderr = alpr.communicate(input=image, timeout=10)
            stdout = io.StringIO(str(stdout, 'utf-8'))
        except subprocess.TimeoutExpired:
            _LOGGER.error(""Alpr process timeout!"")
            alpr.kill()
            return None

        tmp_res = {}
        while True:
            line = stdout.readline()
            if not line:
                if len(tmp_res) > 0:
                    result.append(tmp_res)
                break

            new_plate = self.__re_plate.search(line)
            new_result = self.__re_result.search(line)

            # found a new plate
            if new_plate and len(tmp_res) > 0:
                result.append(tmp_res)
                tmp_res = {}
                continue

            # found plate result
            if new_result:
                try:
                    tmp_res[new_result.group(1)] = float(new_result.group(2))
                except ValueError:
                    continue

        _LOGGER.debug(""Process alpr with result: %s"", result)
        return result"
3661,"def finished(finished_status,
             update_interval,
             table,
             status_column,
             edit_at_column):
    """"""
    Create text sql statement query for sqlalchemy that getting all finished task.

    :param finished_status: int, status code that greater or equal than this
        will be considered as finished.
    :param update_interval: int, the record will be updated every x seconds.

    :return: sqlalchemy text sql statement.

    **中文文档**

    状态码大于某个值, 并且, 更新时间在最近一段时间以内.
    """"""
    sql = select([table]).where(
        and_(*[
            status_column >= finished_status,
            edit_at_column >= x_seconds_before_now(update_interval)
        ])
    )
    return sql"
3662,"def unfinished(finished_status,
               update_interval,
               table,
               status_column,
               edit_at_column):
    """"""
    Create text sql statement query for sqlalchemy that getting all unfinished task.

    :param finished_status: int, status code that less than this
        will be considered as unfinished.
    :param update_interval: int, the record will be updated every x seconds.

    :return: sqlalchemy text sql statement.


    **中文文档**

    状态码小于某个值, 或者, 现在距离更新时间已经超过一定阈值.
    """"""
    sql = select([table]).where(
        or_(*[
            status_column < finished_status,
            edit_at_column < x_seconds_before_now(update_interval)
        ])
    )
    return sql"
3663,"def find_nearest(x, x0) -> Tuple[int, Any]:
    """"""
    This find_nearest function does NOT assume sorted input

    inputs:
    x: array (float, int, datetime, h5py.Dataset) within which to search for x0
    x0: singleton or array of values to search for in x

    outputs:
    idx: index of flattened x nearest to x0  (i.e. works with higher than 1-D arrays also)
    xidx: x[idx]

    Observe how bisect.bisect() gives the incorrect result!

    idea based on:
    http://stackoverflow.com/questions/2566412/find-nearest-value-in-numpy-array

    """"""
    x = np.asanyarray(x)  # for indexing upon return
    x0 = np.atleast_1d(x0)
# %%
    if x.size == 0 or x0.size == 0:
        raise ValueError('empty input(s)')

    if x0.ndim not in (0, 1):
        raise ValueError('2-D x0 not handled yet')
# %%
    ind = np.empty_like(x0, dtype=int)

    # NOTE: not trapping IndexError (all-nan) becaues returning None can surprise with slice indexing
    for i, xi in enumerate(x0):
        if xi is not None and (isinstance(xi, (datetime.datetime, datetime.date, np.datetime64)) or np.isfinite(xi)):
            ind[i] = np.nanargmin(abs(x-xi))
        else:
            raise ValueError('x0 must NOT be None or NaN to avoid surprising None return value')

    return ind.squeeze()[()], x[ind].squeeze()[()]"
3664,"def ensure_context_attribute_exists(context, name, default_value=None):
    """"""
    Ensure a behave resource exists as attribute in the behave context.
    If this is not the case, the attribute is created by using the default_value.
    """"""
    if not hasattr(context, name):
        setattr(context, name, default_value)"
3665,"def ensure_workdir_exists(context):
    """"""
    Ensures that the work directory exists.
    In addition, the location of the workdir is stored as attribute in
    the context object.
    """"""
    ensure_context_attribute_exists(context, ""workdir"", None)
    if not context.workdir:
        context.workdir = os.path.abspath(WORKDIR)
    pathutil.ensure_directory_exists(context.workdir)"
3666,"def sorted_feed_cols(df):
    """"""
    takes a dataframe's columns that would be of the form:
    ['feed003', 'failsafe_feed999', 'override_feed000', 'feed001', 'feed002']
    and returns:
    ['override_feed000', 'feed001', 'feed002', 'feed003', 'failsafe_feed999']
    """"""
    cols = df.columns
    ind = [int(c.split(""feed"")[1]) for c in cols]
    cols = zip(ind,cols)
    cols.sort()
    cols = [c[1] for c in cols]
    return cols"
3667,"def mean_fill(adf):
        """""" Looks at each row, and calculates the mean. Honours
        the Trump override/failsafe logic. """"""
        ordpt = adf.values[0]
        if not pd.isnull(ordpt):
            return ordpt

        fdmn = adf.iloc[1:-1].mean()
        if not pd.isnull(fdmn):
            return fdmn

        flspt = adf.values[-1]
        if not pd.isnull(flspt):
            return flspt

        return nan"
3668,"def median_fill(adf):
        """""" Looks at each row, and chooses the median. Honours
        the Trump override/failsafe logic. """"""
        ordpt = adf.values[0]
        if not pd.isnull(ordpt):
            return ordpt

        fdmn = adf.iloc[1:-1].median()
        if not pd.isnull(fdmn):
            return fdmn

        flspt = adf.values[-1]
        if not pd.isnull(flspt):
            return flspt

        return nan"
3669,"def most_populated(adf):
        """"""
        Looks at each column, using the one with the most values
        Honours the Trump override/failsafe logic. """"""

        # just look at the feeds, ignore overrides and failsafes:
        feeds_only = adf[adf.columns[1:-1]]

        # find the most populated feed
        cnt_df = feeds_only.count()
        cnt = cnt_df.max()
        selected_feeds = cnt_df[cnt_df == cnt]

        # if there aren't any feeds, the first feed will work...
        if len(selected_feeds) == 0:
            pre_final = adf['feed001'] # if they are all empty
                                  # they should all be
                                  # equally empty
        else:
            #if there's one or more, take the highest priority one
            pre_final = adf[selected_feeds.index[0]]


        # create the final, applying the override and failsafe logic...
        final_df = pd.concat([adf.override_feed000,
                              pre_final,
                              adf.failsafe_feed999], axis=1)
        final_df = final_df.apply(_row_wise_priority, axis=1)
        return final_df"
3670,"def most_recent(adf):
        """"""
        Looks at each column, and chooses the feed with the most recent data
        point. Honours the Trump override/failsafe logic. """"""
        # just look at the feeds, ignore overrides and failsafes:
        feeds_only = adf[adf.columns[1:-1]]

        # find the feeds with the most recent data...
        feeds_with_data = feeds_only.dropna(how='all')
        selected_feeds = feeds_with_data.T.dropna().index

        # if there aren't any feeds, the first feed will work...
        if len(selected_feeds) == 0:
            pre_final = adf['feed001'] # if there all empyty
                                  # they should all be
                                  # equally empty
        else:
            #if there's one or more, take the highest priority one
            pre_final = adf[selected_feeds[0]]


        # create the final, applying the override and failsafe logic...
        final_df = pd.concat([adf.override_feed000,
                              pre_final,
                              adf.failsafe_feed999], axis=1)
        final_df = final_df.apply(_row_wise_priority, axis=1)
        return final_df"
3671,"def build_tri(adf):
        """"""
        Looks at each column, and chooses the feed with the most recent data
        point. Honours the Trump override/failsafe logic. """"""
        # just look at the capital (price), in ""feed one"", and income (dividend), in ""feed two""
        
        cap, inc = adf.columns[1:3]
        
        data = adf[[cap,inc]]

        # find the feeds with the most recent data...
        inc_pct = data[inc].div(data[cap].shift(1))
        
        cap_pct = data[cap].pct_change(1)
        
        pre_final = inc_pct + cap_pct
        
        # create the final, applying the override and failsafe logic...
        final_df = pd.concat([adf.override_feed000,
                              pre_final,
                              adf.failsafe_feed999], axis=1)
        final_df = final_df.apply(_row_wise_priority, axis=1)
        return final_df"
3672,"async def send_audio(self, url, user, options=None):
        """"""
        send audio message

        :param url: link to the audio file
        :param user: target user
        :param options:
        :return:
        """"""
        return await self.chat.send_audio(url, user, options)"
3673,"def use(self, middleware):
        """"""
        attache middleware

        :param middleware:
        :return:
        """"""

        logger.debug('use')
        logger.debug(middleware)

        self.middlewares.append(middleware)

        di.injector.register(instance=middleware)
        di.bind(middleware, auto=True)

        # TODO: should use DI somehow
        if check_spec(['send_text_message'], middleware):
            self.chat.add_interface(middleware)

        return middleware"
3674,"def del_by_idx(tree, idxs):
    """"""
    Delete a key entry based on numerical indexes into subtree lists.
    """"""
    if len(idxs) == 0:
        tree['item'] = None
        tree['subtrees'] = []
    else:
        hidx, tidxs = idxs[0], idxs[1:]
        del_by_idx(tree['subtrees'][hidx][1], tidxs)
        if len(tree['subtrees'][hidx][1]['subtrees']) == 0:
            del tree['subtrees'][hidx]"
3675,"def find_in_tree(tree, key, perfect=False):
    """"""
    Helper to perform find in dictionary tree.
    """"""
    if len(key) == 0:
        if tree['item'] is not None:
            return tree['item'], ()
        else:
            for i in range(len(tree['subtrees'])):
                if not perfect and tree['subtrees'][i][0] == '*':
                    item, trace = find_in_tree(tree['subtrees'][i][1],
                                               (), perfect)
                    return item, (i,) + trace
            raise KeyError(key)
    else:
        head, tail = key[0], key[1:]
        for i in range(len(tree['subtrees'])):
            if tree['subtrees'][i][0] == head or \
               not perfect and tree['subtrees'][i][0] == '*':
                try:
                    item, trace = find_in_tree(tree['subtrees'][i][1],
                                               tail, perfect)
                    return item, (i,) + trace
                except KeyError:
                    pass
        raise KeyError(key)"
3676,"def dominates(p, q):
    """"""
    Test for path domination.  An individual path element *a*
    dominates another path element *b*, written as *a* >= *b* if
    either *a* == *b* or *a* is a wild card.  A path *p* = *p1*, *p2*,
    ..., *pn* dominates another path *q* = *q1*, *q2*, ..., *qm* if
    *n* == *m* and, for all *i*, *pi* >= *qi*.

    """"""
    return (len(p) == len(q) and
            all(map(lambda es: es[0] == es[1] or es[0] == '*', zip(p, q))))"
3677,"def find(self, key, perfect=False):
        """"""
        Find a key path in the tree, matching wildcards.  Return value for
        key, along with index path through subtree lists to the result.  Throw
        ``KeyError`` if the key path doesn't exist in the tree.

        """"""
        return find_in_tree(self.root, key, perfect)"
3678,"def _purge_unreachable(self, key):
        """"""
        Purge unreachable dominated key paths before inserting a new key
        path.

        """"""
        dels = []
        for p in self:
            if dominates(key, p):
                dels.append(p)
        for k in dels:
            _, idxs = find_in_tree(self.root, k, perfect=True)
            del_by_idx(self.root, idxs)"
3679,"def register(self, name, namespace):
        """"""Register a new namespace with the Configuration object.

        Args:
            name (str): The name of the section/namespace.
            namespace (namespace.Namespace): The Namespace object to store.

        Raises:
            TypeError: If the namespace is not a Namespace object.
            ValueError: If the namespace is already registered.
        """"""
        if name in self._NAMESPACES:

            raise ValueError(""Namespace {0} already exists."".format(name))

        if not isinstance(namespace, ns.Namespace):

            raise TypeError(""Namespaces must be of type Namespace."")

        self._NAMESPACES[name] = namespace"
3680,"def fromSearch(text):
    """"""
    Generates a regular expression from 'simple' search terms.
    
    :param      text | <str>
    
    :usage      |>>> import projex.regex
                |>>> projex.regex.fromSearch('*cool*')
                |'^.*cool.*$'
                |>>> projex.projex.fromSearch('*cool*,*test*')
                |'^.*cool.*$|^.*test.*$'
    
    :return     <str>
    """"""
    terms = []
    for term in nstr(text).split(','):
        # assume if no *'s then the user wants to search anywhere as keyword
        if '*' not in term:
            term = '*%s*' % term

        term = term.replace('*', '.*')
        terms.append('^%s$' % term)

    return '|'.join(terms)"
3681,"def cli(ctx, monitor, full, stage):
    """"""Basic statistics""""""
    if not ctx.bubble:
        msg = 'There is no bubble present, will not search stats'
        if monitor:
            ctx.say_yellow('Unknown - ' + msg, 0)
            raise SystemExit(3)
        else:
            ctx.say_yellow(msg)
        raise click.Abort()

    stats = {}
    stats_found = False
    flowing_full = False
    flowing_decrease = False
    flowing_increase = False
    errors = False

    loader = bubble_lod_load(ctx, 'stats', stage)
    lod_gen = _find_lod_gen(ctx, loader)
    if lod_gen:
        last_stats = {}
        ctx.say('lod_gen', stuff=lod_gen)
        for stats_data in lod_gen:
            last_stats = stats_data
        if last_stats:
            ctx.say('found last_stats:', stuff=last_stats, verbosity=10)

    try:
        ctx.say('trying:last stats:', stuff=last_stats, verbosity=10)
        if last_stats:
            l = last_stats
            stats['pull_err'] = k0(l, 'pulled_stat_error_count')
            stats['pull_total'] = k0(l, 'pulled_stat_total_count')

            stats['trans_err'] = k0(l, 'transformed_stat_error_count')
            stats['trans_total'] = k0(l, 'transformed_stat_total_count')

            stats['push_err'] = k0(l, 'pushed_stat_error_count')
            stats['push_total'] = k0(l, 'pushed_stat_total_count')
            stats_found = True
        else:
            stats_found = False

        ctx.say('stats:', stuff=stats, verbosity=10)

        if stats_found and stats['pull_err'] > 0 or \
                stats['trans_err'] > 0 or \
                stats['push_err'] > 0:
            errors = True
        if stats_found and stats['pull_total'] == stats['trans_total'] and \
                stats['trans_total'] == stats['push_total']:
            flowing_full = True
        if stats_found and stats['pull_total'] >= stats['trans_total'] >= stats['push_total']:
            flowing_decrease = True
        if stats_found and stats['pull_total'] <= stats['trans_total'] <= stats['push_total']:
            flowing_increase = True
    except KeyError as stat_key_error:
        errors = True
        ctx.gbc.cry('cannot create status from last stats', stuff=stat_key_error)

    if full:
        ctx.say_yellow('Stats full')
        ctx.say_yellow('Full flow:' + str(flowing_full))
        ctx.say_yellow('Flowing decrease:' + str(flowing_decrease))
        ctx.say_yellow('Flowing increase:' + str(flowing_increase))
        ctx.say_yellow('Errors:' + str(errors))
        ctx.say_yellow('totals:')
        ctx.say_yellow(pf(stats, indent=8))

    if monitor == 'nagios' or full:

        """"""
        for Numeric Value Service Status Status Description, please see:
        https://nagios-plugins.org/doc/guidelines.html#AEN78
        0 OK The plugin was able to check the service and
          it appeared to be functioning properly
        1 Warning The plugin was able to check the service,
          but it appeared to be above some ""warning"" threshold or did not appear to be working properly
        2 Critical The plugin detected that either the service was not running or
          it was above some ""critical"" threshold
        3 Unknown Invalid command line arguments were supplied to the plugin or
          low-level failures internal to the plugin (such as unable to fork, or open a tcp socket)
          that prevent it from performing the specified operation. Higher-level errors (such as name resolution errors,
          socket timeouts, etc) are outside of the control of plugins and
          should generally NOT be reported as UNKNOWN states.

        http://nagios.sourceforge.net/docs/3_0/perfdata.html
        http://nagios.sourceforge.net/docs/3_0/pluginapi.html
        """"""
        if stats_found:
            templ_nagios = 'pull: %d %d transform: %d  %d push: %d %d '
            res_nagios = templ_nagios % (stats['pull_total'],
                                         stats['pull_err'],
                                         stats['trans_total'],
                                         stats['trans_err'],
                                         stats['push_total'],
                                         stats['push_err']
                                         )
        else:
            res_nagios = 'Cannot find or read stats'

        if not stats_found:
            print('Unknown - ' + res_nagios)
            raise SystemExit(3)
            # return

        if not errors and flowing_full:
            print('Ok - ' + res_nagios)
            return

        # magister and databyte with amount
        if not errors and flowing_decrease:
            print('Ok - ' + res_nagios)
            return

        if not errors and not flowing_full:
            print('Warning - ' + res_nagios)
            raise SystemExit(1)
            # return

        if errors:
            print('Critical - ' + res_nagios)
            raise SystemExit(2)
            # return
    return False"
3682,"def ast_smart(val):
    """"""Return a suitable subclass of :class:`ast.AST` for storing numbers
    or strings. For other type of objects, return a node class that will
    indicate that the variable is contained in one of global or local
    namespaces.""""""

    if isinstance(val, Number):
        return Num(n=val)
    elif isinstance(val, basestring):
        return Str(s=val)
    else:
        return ast_name(str(val))"
3683,"def napi_compare(left, ops, comparators, **kwargs):
    """"""Make pairwise comparisons of comparators.""""""

    values = []
    for op, right in zip(ops, comparators):
        value = COMPARE[op](left, right)
        values.append(value)
        left = right
    result = napi_and(values, **kwargs)
    if isinstance(result, ndarray):
        return result
    else:
        return bool(result)"
3684,"def napi_and(values, **kwargs):
    """"""Perform element-wise logical *and* operation on arrays.

    If *values* contains a non-array object with truth_ value **False**, the
    outcome will be an array of **False**\s with suitable shape without arrays
    being evaluated. Non-array objects with truth value **True** are omitted.

    If array shapes do not match (after squeezing when enabled by user),
    :exc:`ValueError` is raised.

    This function uses :obj:`numpy.logical_and` or :obj:`numpy.all`.""""""

    arrays = []
    result = None
    shapes = set()

    for value in values:
        if isinstance(value, ndarray) and value.shape:
            arrays.append(value)
            shapes.add(value.shape)
        elif not value:
            result = value

    if len(shapes) > 1 and kwargs.get('sq', kwargs.get('squeeze', False)):
        shapes.clear()
        for i, a in enumerate(arrays):
            a = arrays[i] = a.squeeze()
            shapes.add(a.shape)
        if len(shapes) > 1:
            raise ValueError('array shape mismatch, even after squeezing')

    if len(shapes) > 1:
        raise ValueError('array shape mismatch')

    shape = shapes.pop() if shapes else None

    if result is not None:
        if shape:
            return numpy.zeros(shape, bool)
        else:
            return result
    elif arrays:
        sc = kwargs.get('sc', kwargs.get('shortcircuit', 0))
        if sc and numpy.prod(shape) >= sc:
            return short_circuit_and(arrays, shape)
        elif len(arrays) == 2:
            return numpy.logical_and(*arrays)
        else:
            return numpy.all(arrays, 0)
    else:
        return value"
3685,"def napi_or(values, **kwargs):
    """"""Perform element-wise logical *or* operation on arrays.

    If *values* contains a non-array object with truth_ value **True**, the
    outcome will be an array of **True**\s with suitable shape without arrays
    being evaluated. Non-array objects with truth value **False** are omitted.

    If array shapes do not match (after squeezing when enabled by user),
    :exc:`ValueError` is raised.

    This function uses :obj:`numpy.logical_or` or :obj:`numpy.any`.""""""

    arrays = []
    result = None
    shapes = set()

    for value in values:
        if isinstance(value, ndarray) and value.shape:
            arrays.append(value)
            shapes.add(value.shape)
        elif value:
            result = value

    if len(shapes) > 1 and kwargs.get('squeeze', kwargs.get('sq', False)):
        shapes.clear()
        for i, a in enumerate(arrays):
            a = arrays[i] = a.squeeze()
            shapes.add(a.shape)
        if len(shapes) > 1:
            raise ValueError('array shape mismatch, even after squeezing')

    if len(shapes) > 1:
        raise ValueError('array shape mismatch')

    shape = shapes.pop() if shapes else None

    if result is not None:
        if shape:
            return numpy.ones(shape, bool)
        else:
            return result
    elif arrays:
        sc = kwargs.get('sc', kwargs.get('shortcircuit', 0))
        if sc and numpy.prod(shape) >= sc:
            return short_circuit_or(arrays, shape)
        elif len(arrays) == 2:
            return numpy.logical_or(*arrays)
        else:
            return numpy.any(arrays, 0)
    else:
        return value"
3686,"def visit_Compare(self, node):
        """"""Replace chained comparisons with calls to :func:`.napi_compare`.""""""

        if len(node.ops) > 1:
            func = Name(id=self._prefix + 'napi_compare', ctx=Load())
            args = [node.left,
                    List(elts=[Str(op.__class__.__name__)
                               for op in node.ops], ctx=Load()),
                    List(elts=node.comparators, ctx=Load())]
            node = Call(func=func, args=args, keywords=self._kwargs)
            fml(node)
        self.generic_visit(node)
        return node"
3687,"def visit_BoolOp(self, node):
        """"""Replace logical operations with calls to :func:`.napi_and` or
        :func:`.napi_or`.""""""

        if isinstance(node.op, And):
            func = Name(id=self._prefix + 'napi_and', ctx=Load())
        else:
            func = Name(id=self._prefix + 'napi_or', ctx=Load())
        args = [List(elts=node.values, ctx=Load())]
        node = Call(func=func, args=args, keywords=self._kwargs)
        fml(node)
        self.generic_visit(node)
        return node"
3688,"def visit_UnaryOp(self, node):
        """"""Interfere with ``not`` operation to :func:`numpy.logical_not`.""""""

        if isinstance(node.op, Not):
            self._debug('UnaryOp', node.op, incr=1)
            operand = self[node.operand]
            self._debug('|-', operand, incr=2)
            tn = self._tn()
            result = numpy.logical_not(operand)
            self._debug('|_', result, incr=2)
            self[tn] = result
            return ast_name(tn)
        else:
            return self.generic_visit(node)"
3689,"def visit_BoolOp(self, node):
        """"""Interfere with boolean operations and use :func:`numpy.all` and
        :func:`numpy.any` functions for ``and`` and ``or`` operations.
        *axis* argument to these functions is ``0``.""""""

        self._incr()
        self._debug('BoolOp', node.op)
        if isinstance(node.op, And):
            result = self._and(node)
        else:
            result = self._or(node)
        self._debug('|_', result, incr=1)
        self._decr()
        return self._return(result, node)"
3690,"def rec_load_all(self, zone):
        """"""
        Lists all DNS records for the given domain
        :param zone: the domain for which records are being retrieved
        :type zone: str
        :return:
        :rtype: generator
        """"""
        has_more = True
        current_count = 0
        while has_more:
            records = self._request({
                'a': 'rec_load_all',
                'o': current_count,
                'z': zone
            })
            try:
                has_more = records['response']['recs']['has_more']
                current_count += records['response']['recs']['count']
                for record in records['response']['recs']['objs']:
                    yield record
            except KeyError:
                has_more = False"
3691,"def zone_ips(self, zone, hours=24, ip_class=None, geo=False):
        """"""
        Retrieve IP addresses of recent visitors
        :param zone: the target domain
        :type zone: str
        :param hours: Past number of hours to query. Defaults to 24, maximum is 48.
        :type hours: int
        :param ip_class: Optional. Restrict the result set to a given class as given by:
            ""r"" -- regular
            ""s"" -- crawler
            ""t"" -- threat
        :type ip_class: str
        :param geo: Optional. Set to True to add longitude and latitude information to response
        :type geo: bool
        :return:
        :rtype: dict
        """"""
        params = {
            'a': 'zone_ips',
            'z': zone,
            'hours': hours,
            'class': ip_class,
        }
        if geo:
            params['geo'] = geo
        return self._request(params)"
3692,"def rec_new(self, zone, record_type, name, content, ttl=1, priority=None, service=None, service_name=None,
                protocol=None, weight=None, port=None, target=None):
        """"""
        Create a DNS record for the given zone
        :param zone: domain name
        :type zone: str
        :param record_type: Type of DNS record. Valid values are [A/CNAME/MX/TXT/SPF/AAAA/NS/SRV/LOC]
        :type record_type: str
        :param name: name of the DNS record
        :type name: str
        :param content: content of the DNS record
        :type content: str
        :param ttl: TTL of the DNS record in seconds. 1 = Automatic, otherwise, value must in between 120 and
            4,294,967,295 seconds.
        :type ttl: int
        :param priority: [applies to MX/SRV] MX record priority.
        :type priority: int
        :param service: Service for SRV record
        :type service: str
        :param service_name: Service Name for SRV record
        :type service_name: str
        :param protocol: Protocol for SRV record. Values are [_tcp/_udp/_tls].
        :type protocol: str
        :param weight: Weight for SRV record.
        :type weight: int
        :param port: Port for SRV record
        :type port: int
        :param target: Target for SRV record
        :type target: str
        :return:
        :rtype: dict
        """"""
        params = {
            'a': 'rec_new',
            'z': zone,
            'type': record_type,
            'name': name,
            'content': content,
            'ttl': ttl
        }
        if priority is not None:
            params['prio'] = priority
        if service is not None:
            params['service'] = service
        if service_name is not None:
            params['srvname'] = service_name
        if protocol is not None:
            params['protocol'] = protocol
        if weight is not None:
            params['weight'] = weight
        if port is not None:
            params['port'] = port
        if target is not None:
            params['target'] = target
        return self._request(params)"
3693,"def rec_edit(self, zone, record_type, record_id, name, content, ttl=1, service_mode=None, priority=None,
                 service=None, service_name=None, protocol=None, weight=None, port=None, target=None):
        """"""
        Edit a DNS record for the given zone.
        :param zone: domain name
        :type zone: str
        :param record_type: Type of DNS record. Valid values are [A/CNAME/MX/TXT/SPF/AAAA/NS/SRV/LOC]
        :type record_type: str
        :param record_id: DNS Record ID. Available by using the rec_load_all call.
        :type record_id: int
        :param name: Name of the DNS record
        :type name: str
        :param content: The content of the DNS record, will depend on the the type of record being added
        :type content: str
        :param ttl: TTL of record in seconds. 1 = Automatic, otherwise, value must in between 120 and 4,294,967,295
            seconds.
        :type ttl: int
        :param service_mode: [applies to A/AAAA/CNAME] Status of CloudFlare Proxy, 1 = orange cloud, 0 = grey cloud.
        :type service_mode: int
        :param priority: [applies to MX/SRV] MX record priority.
        :type priority: int
        :param service: Service for SRV record
        :type service: str
        :param service_name: Service Name for SRV record
        :type service_name: str
        :param protocol: Protocol for SRV record. Values are [_tcp/_udp/_tls].
        :type protocol: str
        :param weight: Weight for SRV record.
        :type weight: int
        :param port: Port for SRV record
        :type port: int
        :param target: Target for SRV record
        :type target: str
        :return:
        :rtype: dict
        """"""
        params = {
            'a': 'rec_edit',
            'z': zone,
            'type': record_type,
            'id': record_id,
            'name': name,
            'content': content,
            'ttl': ttl
        }
        if service_mode is not None:
            params['service_mode'] = service_mode
        if priority is not None:
            params['prio'] = priority
        if service is not None:
            params['service'] = service
        if service_name is not None:
            params['srvname'] = service_name
        if protocol is not None:
            params['protocol'] = protocol
        if weight is not None:
            params['weight'] = weight
        if port is not None:
            params['port'] = port
        if target is not None:
            params['target'] = target
        return self._request(params)"
3694,"def calc_transition_to_state(self, newstate):
        """"""Given a target state, generate the sequence of transitions that would move this state machine instance to that target state.

        Args:
            newstate: A str state name to calculate the path to.

        Returns:
            A bitarray containing the bits that would transition this
            state machine to the target state. The bits read from right
            to left. For efficiency, this retulting bitarray is cached.
            Do not edit this bitarray, or it will cause undefined
            behavior.
        """"""
        cached_val = JTAGStateMachine._lookup_cache.\
                     get((self.state, newstate))
        if cached_val:
            return cached_val

        if newstate not in self.states:
            raise ValueError(""%s is not a valid state for this state ""
                             ""machine""%newstate)

        path = self._find_shortest_path(self._statestr, newstate)
        if not path:
            raise ValueError(""No path to the requested state."")
        res = self._get_steps_from_nodes_path(path)
        res.reverse()
        JTAGStateMachine._lookup_cache[(self.state, newstate)] = res
        return res"
3695,"def prompt(self, error=''):
        """"""
        Prompts the user to set the value for this item.
        
        :return     <bool> | success
        """"""
        if self.hidden:
            return True

        cmd = [self.label]

        if self.default is not None:
            cmd.append('(default: {0})'.format(self.default))
        elif not self.required:
            cmd.append('(default: )')

        if self.type == 'bool':
            cmd.append('(y/n)')

        if self.choices:
            print 'Choices:'
            for choice in self.choices:
                print choice
        if error:
            print error

        value = raw_input(' '.join(cmd) + ':')
        if value == '':
            value = self.default

        if self.type == 'bool':
            if value == 'y':
                value = True
            elif value == 'n':
                value = False
            else:
                value = self.default

        if value is None and self.required:
            return self.prompt('{0} is required.')

        if self.regex and not re.match(self.regex, value):
            error = '{0} must match {1}'.format(self.name, self.regex)
            return self.prompt(error)

        self.value = value
        return True"
3696,"def build(self, outpath, structure=None):
        """"""
        Builds this scaffold out to the given filepath with the 
        chosen structure.
        
        :param      outpath   | <str>
                    structure | <xml.etree.ElementTree.Element> || None

        :return     <bool> | success
        """"""
        if not os.path.exists(outpath):
            return False

        opts = {'scaffold': self}

        if structure is not None:
            xstruct = structure
        else:
            xstruct = self.structure()

        if zipfile.is_zipfile(self.source()):
            zfile = zipfile.ZipFile(self.source(), 'r')
        else:
            zfile = None
            base = os.path.dirname(self.source())

        # build the structure information
        # noinspection PyShadowingNames
        def build_level(root, xlevel):
            # ignore the entry
            if xlevel.get('enabled', 'True') == 'False':
                return

            # create a folder
            if xlevel.tag == 'folder':
                name = makotext.render(xlevel.get('name'), opts)
                dirname = os.path.join(root, name)
                if not os.path.exists(dirname):
                    os.mkdir(dirname)

                for xchild in xlevel:
                    build_level(dirname, xchild)

            # create a file
            elif xlevel.tag == 'file':
                name = makotext.render(xlevel.get('name'), opts)
                fname = os.path.join(root, name)

                # create from a template
                templ = xlevel.get('templ')
                if templ:
                    if zfile:
                        templ_str = zfile.read('templ/{0}'.format(templ))
                    else:
                        templ_path = os.path.join(base, 'templ', templ)
                        templ_str = open(templ_path, 'r').read()

                    rendered = makotext.render(templ_str, opts)
                    rendered = rendered.replace('\r\n', '\r')

                    f = open(fname, 'w')
                    f.write(rendered)
                    f.close()

                # create a blank file
                else:
                    f = open(fname, 'w')
                    f.close()

        for xlevel in xstruct:
            build_level(outpath, xlevel)

        if zfile:
            zfile.close()
        return True"
3697,"def render(self, template, fail='## :todo: add {template}'):
        """"""
        Returns the rendered value for the inputted template name.
        
        :param      template | <str>
        """"""
        try:
            return self._templates[template].render(scaffold=self)
        except KeyError:
            return fail.format(template=template)"
3698,"def run(self, path=None):
        """"""
        Runs the scaffold option generation for this scaffold in the given
        path.  If no path is supplied, then the current path is used.
        
        :param      path | <str> || None
        """"""
        if path is None:
            path = '.'

        for prop in self._properties.values():
            if not prop.prompt():
                return False

        return self.build(path)"
3699,"def structure(self):
        """"""
        Returns the structure for this scaffold.
        
        :return     <xml.etree.ElementTree.Element> || None
        """"""
        opts = {'scaffold': self}

        # build from a zip file
        if zipfile.is_zipfile(self.source()):
            zfile = zipfile.ZipFile(self.source(), 'r')
            try:
                contents = zfile.read('structure.xml')
                contents = makotext.render(contents, opts)
                zfile.close()
                return ElementTree.fromstring(contents)
            except StandardError:
                logger.exception('Failed to load structure.')
                zfile.close()
                return None

        else:
            try:
                filename = os.path.join(os.path.dirname(self.source()),
                                        'structure.xml')
                xdata = open(filename, 'r').read()
                xdata = makotext.render(xdata, opts)
                return ElementTree.fromstring(xdata)
            except StandardError:
                logger.exception('Failed to load structure.')
                return None"
3700,"def template(self, key):
        """"""
        Returns the template associated with this scaffold.
        
        :param      key | <str>
        
        :return     <projex.scaffold.Template> || None
        """"""
        try:
            return self._templates[key]
        except KeyError:
            return Template.Plugins[key]"
3701,"def uifile(self):
        """"""
        Returns the uifile for this scaffold.
        
        :return     <str>
        """"""
        output = ''

        # build from a zip file
        if zipfile.is_zipfile(self.source()):
            zfile = zipfile.ZipFile(self.source(), 'r')
            if 'properties.ui' in zfile.namelist():
                tempdir = tempfile.gettempdir()
                output = os.path.join(tempdir,
                                      '{0}_properties.ui'.format(self.name()))

                f = open(output, 'w')
                f.write(zfile.read('properties.ui'))
                f.close()
            zfile.close()

        else:
            uifile = os.path.join(os.path.dirname(self.source()),
                                  'properties.ui')
            if os.path.exists(uifile):
                output = uifile

        return output"
3702,"def load(filename):
        """"""
        Loads the scaffold from the given XML file.
        
        :param      filename | <str>
        
        :return     <Scaffold> || None
        """"""
        # parse a zipped file
        if zipfile.is_zipfile(filename):
            zfile = zipfile.ZipFile(filename, 'r')
            try:
                xml = ElementTree.fromstring(zfile.read('scaffold.xml'))
            except StandardError:
                logger.exception('Failed to load scaffold: {0}'.format(filename))
                zfile.close()
                return None
            zfile.close()

        # parse a standard xml file
        else:
            try:
                xml = ElementTree.parse(filename).getroot()
            except StandardError:
                logger.exception('Failed to load scaffold: {0}'.format(filename))
                return None

        # generate a scaffold
        scaffold = Scaffold()
        scaffold.setSource(filename)
        scaffold.setName(xml.get('name', 'Missing'))
        scaffold.setGroup(xml.get('group', 'Default'))
        scaffold.setLanguage(xml.get('lang', 'Python'))
        scaffold.setIcon(xml.get('icon', ''))

        # define properties
        xprops = xml.find('properties')
        if xprops is not None:
            for xprop in xprops:
                scaffold.addProperty(Property.fromXml(xprop))

        return scaffold"
3703,"def displayhook(value):
    """"""
    Runs all of the registered display hook methods with the given value.
    Look at the sys.displayhook documentation for more information.
    
    :param      value | <variant>
    """"""
    global _displayhooks
    new_hooks = []

    for hook_ref in _displayhooks:
        hook = hook_ref()
        if hook:
            hook(value)
            new_hooks.append(hook_ref)

    _displayhooks = new_hooks

    sys.__displayhook__(value)"
3704,"def excepthook(cls, error, trace):
    """"""
    Runs all of the registered exception hook methods with the given value.
    Look at the sys.excepthook documentation for more information.
    
    :param      cls     | <type>
                error   | <str>
                trace   | <traceback>
    """"""
    global _excepthooks
    new_hooks = []

    for hook_ref in _excepthooks:
        hook = hook_ref()
        if hook:
            hook(cls, error, trace)
            new_hooks.append(hook_ref)

    _excepthook = new_hooks
    sys.__excepthook__(cls, error, trace)"
3705,"def formatExcept(cls, error, trace):
    """"""
    Formats the inputted class, error, and traceback information to the standard
    output commonly found in Python interpreters.
    
    :param      cls     | <type>
                error   | <str>
                trace   | <traceback>
    
    :return     <str>
    """"""
    clsname = cls.__name__ if cls else 'UnknownError'
    tb = 'Traceback (most recent call last):\n'
    tb += ''.join(traceback.format_tb(trace))
    tb += '{0}: {1}'.format(clsname, error)
    return tb"
3706,"def registerDisplay(func):
    """"""
    Registers a function to the display hook queue to be called on hook.
    Look at the sys.displayhook documentation for more information.
    
    :param      func | <callable>
    """"""
    setup()
    ref = weakref.ref(func)
    if ref not in _displayhooks:
        _displayhooks.append(ref)"
3707,"def registerExcept(func):
    """"""
    Registers a function to the except hook queue to be called on hook.
    Look at the sys.displayhook documentation for more information.
    
    :param      func | <callable>
    """"""
    setup()
    ref = weakref.ref(func)
    if ref not in _excepthooks:
        _excepthooks.append(ref)"
3708,"def registerStdErr(func):
    """"""
    Registers a function to the print hook queue to be called on hook.
    This method will also override the current sys.stdout variable with a new
    <StreamHooks> instance.  This will preserve any current sys.stdout 
    overrides while providing a hookable class for linking multiple methods to.
    
    :param      func | <callable>
    """"""
    if not isinstance(sys.stderr, StreamHooks):
        sys.stderr = StreamHooks(sys.stderr)

    ref = weakref.ref(func)
    if ref not in sys.stderr.hooks:
        sys.stderr.hooks.append(ref)"
3709,"def registerStdOut(func):
    """"""
    Registers a function to the print hook queue to be called on hook.
    This method will also override the current sys.stdout variable with a new
    <StreamHooks> instance.  This will preserve any current sys.stdout 
    overrides while providing a hookable class for linking multiple methods to.
    
    :param      func | <callable>
    """"""
    if not isinstance(sys.stdout, StreamHooks):
        sys.stdout = StreamHooks(sys.stdout)

    ref = weakref.ref(func)
    if ref not in sys.stdout.hooks:
        sys.stdout.hooks.append(ref)"
3710,"def setup():
    """"""
    Initializes the hook queues for the sys module.  This method will
    automatically be called on the first registration for a hook to the system
    by either the registerDisplay or registerExcept functions.
    """"""
    global _displayhooks, _excepthooks
    if _displayhooks is not None:
        return

    _displayhooks = []
    _excepthooks = []

    # store any current hooks
    if sys.displayhook != sys.__displayhook__:
        _displayhooks.append(weakref.ref(sys.displayhook))

    if sys.excepthook != sys.__excepthook__:
        _excepthooks.append(weakref.ref(sys.excepthook))

    # replace the current hooks
    sys.displayhook = displayhook
    sys.excepthook = excepthook"
3711,"def unregisterStdErr(func):
    """"""
    Un-registers a function from the print hook queue.
    Look at the sys.displayhook documentation for more information.
    
    :param      func | <callable>
    """"""
    try:
        sys.stderr.hooks.remove(weakref.ref(func))
    except (AttributeError, ValueError):
        pass"
3712,"def unregisterStdOut(func):
    """"""
    Un-registers a function from the print hook queue.
    Look at the sys.displayhook documentation for more information.
    
    :param      func | <callable>
    """"""
    try:
        sys.stdout.hooks.remove(weakref.ref(func))
    except (AttributeError, ValueError):
        pass"
3713,"def _parse_iso8601(text):
    """"""
    Maybe parse an ISO8601 datetime string into a datetime.

    :param text: Either a ``unicode`` string to parse or any other object
        (ideally a ``datetime`` instance) to pass through.

    :return: A ``datetime.datetime`` representing ``text``.  Or ``text`` if it
        was anything but a ``unicode`` string.
    """"""
    if isinstance(text, unicode):
        try:
            return parse_iso8601(text)
        except ValueError:
            raise CheckedValueTypeError(
                None, (datetime,), unicode, text,
            )
    # Let pyrsistent reject it down the line.
    return text"
3714,"def from_path(cls, spec_path):
        """"""
        Load a specification from a path.

        :param FilePath spec_path: The location of the specification to read.
        """"""
        with spec_path.open() as spec_file:
            return cls.from_document(load(spec_file))"
3715,"def add_behavior_for_pclass(self, definition, cls):
        """"""
        Define an additional base class for the Python class created for a
        particular definition.

        :param unicode definition: The definition the Python class for which
            the base class will be included.

        :param type cls: The additional base class.

        :raise ValueError: If a Python class for the given definition has
            already been created.  Behavior cannot be retroactively added to a
            Python class.  All behaviors must be registered before the first
            call to ``pclass_for_definition`` for a particular definition.

        :return: ``None``
        """"""
        if definition in self._pclasses:
            raise AlreadyCreatedClass(definition)
        if definition not in self.definitions:
            raise NoSuchDefinition(definition)
        self._behaviors.setdefault(definition, []).append(cls)"
3716,"def to_document(self):
        """"""
        Serialize this specification to a JSON-compatible object representing a
        Swagger specification.
        """"""
        return dict(
            info=thaw(self.info),
            paths=thaw(self.paths),
            definitions=thaw(self.definitions),
            securityDefinitions=thaw(self.securityDefinitions),
            security=thaw(self.security),
            swagger=thaw(self.swagger),
        )"
3717,"def pclass_for_definition(self, name):
        """"""
        Get a ``pyrsistent.PClass`` subclass representing the Swagger definition
        in this specification which corresponds to the given name.

        :param unicode name: The name of the definition to use.

        :return: A Python class which can be used to represent the Swagger
            definition of the given name.
        """"""
        while True:
            try:
                cls = self._pclasses[name]
            except KeyError:
                try:
                    original_definition = self.definitions[name]
                except KeyError:
                    raise NoSuchDefinition(name)

                if ""$ref"" in original_definition:
                    # Identify definitions that are merely a reference to
                    # another and restart processing.  There is some
                    # duplication of logic between this and the $ref handling
                    # in _ClassModel.  It would be nice to eliminate this
                    # duplication.
                    name = original_definition[u""$ref""]
                    assert name.startswith(u""#/definitions/"")
                    name = name[len(u""#/definitions/""):]
                    continue

                definition = self.transform_definition(name, original_definition)
                kind = self._identify_kind(definition)
                if kind is None:
                    raise NotClassLike(name, definition)
                generator = getattr(self, ""_model_for_{}"".format(kind))
                model = generator(name, definition)
                bases = tuple(self._behaviors.get(name, []))
                cls = model.pclass(bases)
                self._pclasses[name] = cls
            return cls"
3718,"def _model_for_CLASS(self, name, definition):
        """"""
        Model a Swagger definition that is like a Python class.

        :param unicode name: The name of the definition from the
            specification.

        :param pyrsistent.PMap definition: A Swagger definition to categorize.
            This will be a value like the one found at
            ``spec[""definitions""][name]``.
        """"""
        return _ClassModel.from_swagger(
            self.pclass_for_definition,
            name,
            definition,
        )"
3719,"def pclass_field_for_attribute(self):
        """"""
        :return: A pyrsistent field reflecting this attribute and its type model.
        """"""
        return self.type_model.pclass_field_for_type(
            required=self.required,
            default=self.default,
        )"
3720,"def from_swagger(cls, pclass_for_definition, name, definition):
        """"""
        Create a new ``_ClassModel`` from a single Swagger definition.

        :param pclass_for_definition: A callable like
            ``Swagger.pclass_for_definition`` which can be used to resolve
            type references encountered in the definition.

        :param unicode name: The name of the definition.

        :param definition: The Swagger definition to model.  This will be a
            value like the one found at ``spec[""definitions""][name]``.

        :return: A new model for the given definition.
        """"""
        return cls(
            name=name,
            doc=definition.get(u""description"", name),
            attributes=cls._attributes_for_definition(
                pclass_for_definition,
                definition,
            ),
        )"
3721,"def pclass(self, bases):
        """"""
        Create a ``pyrsistent.PClass`` subclass representing this class.

        :param tuple bases: Additional base classes to give the resulting
            class.  These will appear to the left of ``PClass``.
        """"""
        def discard_constant_fields(cls, **kwargs):
            def ctor():
                return super(huh, cls).__new__(cls, **kwargs)
            try:
                return ctor()
            except AttributeError:
                if u""kind"" in kwargs or u""apiVersion"" in kwargs:
                    kwargs.pop(""kind"", None)
                    kwargs.pop(""apiVersion"", None)
                    return ctor()
                raise


        def lt_pclass(self, other):
            if isinstance(other, self.__class__):
                return sorted(self.serialize().items()) < sorted(other.serialize().items())
            return NotImplemented


        def eq_pclass(self, other):
            if isinstance(other, self.__class__):
                return sorted(self.serialize().items()) == sorted(other.serialize().items())
            return NotImplemented


        content = {
            attr.name: attr.pclass_field_for_attribute()
            for attr
            in self.attributes
        }
        content[""__doc__""] = nativeString(self.doc)
        content[""serialize""] = _serialize_with_omit
        content[""__new__""] = discard_constant_fields
        content[""__lt__""] = lt_pclass
        content[""__eq__""] = eq_pclass
        content[""__hash__""] = PClass.__hash__
        content = total_ordering(content)
        huh = type(nativeString(self.name), bases + (PClass,), content)
        return huh"
3722,"def add_behavior_for_pclass(self, cls):
        """"""
        Define an additional base class for the Python class created for a
        particular definition.

        :param type cls: The additional base class.  Its name must exactly
            match the name of a definition with a version matching this
            object's version.

        :return: ``None``
        """"""
        kind = cls.__name__
        for version in sorted(self.versions):
            try:
                self.spec.add_behavior_for_pclass(self.full_name(version, kind), cls)
            except NoSuchDefinition:
                pass
            else:
                return None
        raise NoSuchDefinition(kind)"
3723,"def dumps_bytes(obj):
    """"""
    Serialize ``obj`` to JSON formatted ``bytes``.
    """"""
    b = dumps(obj)
    if isinstance(b, unicode):
        b = b.encode(""ascii"")
    return b"
3724,"def native_string_to_bytes(s, encoding=""ascii"", errors=""strict""):
    """"""
    Ensure that the native string ``s`` is converted to ``bytes``.
    """"""
    if not isinstance(s, str):
        raise TypeError(""{} must be type str, not {}"".format(s, type(s)))
    if str is bytes:
        # Python 2
        return s
    else:
        # Python 3
        return s.encode(encoding=encoding, errors=errors)"
3725,"def native_string_to_unicode(s, encoding=""ascii"", errors=""strict""):
    """"""
    Ensure that the native string ``s`` is converted to ``unicode``.
    """"""
    if not isinstance(s, str):
        raise TypeError(""{} must be type str, not {}"".format(s, type(s)))
    if str is unicode:
        # Python 3
        return s
    else:
        # Python 2
        return s.decode(encoding=encoding, errors=errors)"
3726,"def datetime_handler(x):
    """""" Allow serializing datetime objects to JSON """"""
    if isinstance(x, datetime.datetime) or isinstance(x, datetime.date):
        return x.isoformat()
    raise TypeError(""Unknown type"")"
3727,"def save(self, *args, **kwargs):
        """"""
        **uid**: :code:`party:{apcode}`
        """"""
        self.uid = 'party:{}'.format(slugify(self.ap_code))
        if not self.slug:
            if self.organization:
                self.slug = slugify(self.organization.name)
            else:
                self.slug = slugify(self.label)
        super(Party, self).save(*args, **kwargs)"
3728,"def parsed(self):
        """"""Get the code object which represents the compiled Python file.

        This property is cached and only parses the content once.
        """"""
        if not self._parsed:

            self._parsed = compile(self.content, self.path, 'exec')

        return self._parsed"
3729,"def get_version():
    """"""
    parse __init__.py for version number instead of importing the file
    see http://stackoverflow.com/questions/458550/standard-way-to-embed-version-into-python-package
    """"""
    version_file = os.path.join(PKG, 'lib/version.py')
    ver_str_line = open(version_file, ""rt"").read()
    version_regex = r'^__version__ = [\'""]([^\'""]*)[\'""]'
    mo = re.search(version_regex, ver_str_line, re.M)
    if mo:
        return mo.group(1)
    else:
        raise RuntimeError('Unable to find version string in %s.'
                           % (version_file,))"
3730,"def _chunk(iterable, size):
    """"""Split an iterable into chunks of a fixed size.""""""
    # We're going to use some star magic to chunk the iterable. We create a
    # copy of the iterator size times, then pull a value from each to form a
    # chunk. The last chunk may have some trailing Nones if the length of the
    # iterable isn't a multiple of size, so we filter them out.

    args = (iter(iterable),) * size

    return (
        # pylint: disable=star-args
        itertools.takewhile(lambda x: x is not None, group)
        for group in itertools.zip_longest(*args)
    )"
3731,"def _matrix_add_column(matrix, column, default=0):
    """"""Given a matrix as a list of lists, add a column to the right, filling in
    with a default value if necessary.
    """"""
    height_difference = len(column) - len(matrix)

    # The width of the matrix is the length of its longest row.
    width = max(len(row) for row in matrix) if matrix else 0

    # For now our offset is 0. We may need to shift our column down later.
    offset = 0

    # If we need extra rows, add them to the top of the matrix.
    if height_difference > 0:
        for _ in range(height_difference):
            matrix.insert(0, [default] * width)

    # If the column is shorter, we'll need to shift it down.
    if height_difference < 0:
        offset = -height_difference
        #column = ([default] * offset) + column

    for index, value in enumerate(column):
        # The row index is the index in the column plus our offset.
        row_index = index + offset
        row = matrix[row_index]

        # If this row is short, pad it with default values.
        width_difference = width - len(row)
        row.extend([default] * width_difference)

        row.append(value)"
3732,"def vertical_graph(*args, sep='\n'):
    r""""""Consume an iterable of integers and produce a vertical bar graph using
    braille characters.

    The graph is vertical in that its dependent axis is the vertical axis. Thus
    each value is represented as a row running left to right, and values are
    listed top to bottom.

    If the iterable contains more than four integers, it will be chunked into
    groups of four, separated with newlines by default.

        >>> vertical_graph([1, 2, 3, 4])
        '⣷⣄'
        >>> vertical_graph([1, 2, 3, 4, 5, 6])
        '⣷⣄\n⠛⠛⠓'
        >>> print(vertical_graph([1, 2, 3, 4, 5, 6]))
        ⣷⣄
        ⠛⠛⠓

    Alternately, the arguments can be passed directly:

        >>> vertical_graph(1, 2, 3, 4)
        '⣷⣄'

    The optional sep parameter controls how groups are separated. If sep is not
    passed (or if it is None), they are put on their own lines. For example, to
    keep everything on one line, space could be used:

        >>> vertical_graph(3, 1, 4, 1, 5, 9, 2, 6, sep=' ')
        '⡯⠥ ⣿⣛⣓⠒⠂'

    """"""
    lines = []

    # If the arguments were passed as a single iterable, pull it out.
    # Otherwise, just use them as-is.
    if len(args) == 1:
        bars = args[0]
    else:
        bars = args

    # Make sure we use the default when needed
    if sep is None:
        sep = '\n'

    # Break the bars into groups of four, one for each row in the braille
    # blocks.
    for bar_group in _chunk(bars, 4):
        line = []

        for braille_row, bar_value in enumerate(bar_group):
            # The number of full braille blocks needed to draw this bar. Each
            # block is two dots wide.
            full_blocks_needed = bar_value // 2

            # The number of braille blocks needed to draw this bar. The second
            # term accounts for a possible half row.
            blocks_needed = full_blocks_needed + (bar_value % 2)

            # The number of braille blocks we'll need to append to the current
            # line to accomodate this bar
            extra_blocks_needed = blocks_needed - len(line)

            # If we need extra blocks, add them.
            if extra_blocks_needed > 0:
                line.extend([_BRAILLE_EMPTY_BLOCK] * extra_blocks_needed)

            # Fill in the majority of the bar with full braille rows (two dots).
            for block_index in range(full_blocks_needed):
                line[block_index] += _BRAILLE_FULL_ROW[braille_row]

            # If the bar's value is odd, we'll need to add a single dot at the
            # end.
            if bar_value % 2:
                line[full_blocks_needed] += _BRAILLE_HALF_ROW[braille_row]

        # Wrap up this line by converting all the code points to characters
        # and concatenating them.
        lines.append(''.join(chr(code) for code in line))

    # Join all the lines to make the final graph
    return sep.join(lines)"
3733,"def horizontal_graph(*args):
    r""""""Consume an iterable of integers and produce a horizontal bar graph using
    braille characters.

    The graph is horizontal in that its dependent axis is the horizontal axis.
    Thus each value is represented as a column running bottom to top, and
    values are listed left to right.

    The graph is anchored to the bottom, so columns fill in from the bottom of
    the current braille character and the next character is added on top when
    needed. For columns with no dots, the blank braille character is used, not
    a space character.

        >>> horizontal_graph([1, 2, 3, 4])
        '⣠⣾'
        >>> horizontal_graph([1, 2, 3, 4, 5, 6])
        '⠀⠀⣠\n⣠⣾⣿'
        >>> print(horizontal_graph([1, 2, 3, 4, 5, 6]))
        ⠀⠀⣠
        ⣠⣾⣿

    Alternately, the arguments can be passed directly:

        >>> horizontal_graph(1, 2, 3, 4)
        '⣠⣾'

    """"""
    lines = []

    # If the arguments were passed as a single iterable, pull it out.
    # Otherwise, just use them as-is.
    if len(args) == 1:

        bars = args[0]
    else:
        bars = args

    # Break the bars into groups of two, one for each column in the braille
    # blocks.
    for bar_group in _chunk(bars, 2):
        column = []

        for braille_col, bar_value in enumerate(bar_group):
            # The number of full braille blocks needed to draw this bar. Each
            # block is four dots tall.
            full_blocks_needed = bar_value // 4

            # The number of braille blocks needed to draw this bar. This
            # accounts for a possible partial block.
            blocks_needed = full_blocks_needed + (1 if bar_value % 4 else 0)

            # The number of new lines we'll need to prepend to accomodate this
            # bar
            extra_blocks_needed = blocks_needed - len(column)

            # If we need extra blocks, add them.
            column = ([_BRAILLE_EMPTY_BLOCK] * extra_blocks_needed) + column

            # Fill in the majority of the column with full braille colums (four
            # dots). We negate the index to access from the end of the list.
            for block_index in range(-full_blocks_needed, 0, 1):
                column[block_index] += _BRAILLE_FULL_COL[braille_col]

            # If we need a partial column, fill it in. We negate the index to
            # access from the end of the list.
            if bar_value % 4:
                partial_index = (bar_value % 4) - 1
                column[-blocks_needed] += (
                    _BRAILLE_PARTIAL_COL[braille_col][partial_index]
                )

        # Add this column to the lines.
        _matrix_add_column(lines, column, default=_BRAILLE_EMPTY_BLOCK)

    # Convert all the code points into characters, concatenate them into lines,
    # then concatenate all the lines to make the final graph.
    return '\n'.join(''.join(chr(code) for code in line) for line in lines)"
3734,"def isValid(self):
        """"""
        Checks to see if the callback pointers are still valid or not.
        
        :return     <bool>
        """"""
        if self._callback_func_ref is not None and self._callback_func_ref():
            if self._callback_self_ref is None or self._callback_self_ref():
                return True
        return False"
3735,"def clear(self, signal=None):
        """"""
        Clears either all the callbacks or the callbacks for a particular
        signal.
        
        :param      signal | <variant> || None
        """"""
        if signal is not None:
            self._callbacks.pop(signal, None)
        else:
            self._callbacks.clear()"
3736,"def connect(self, signal, slot):
        """"""
        Creates a new connection between the inputted signal and slot.
        
        :param      signal | <variant>
                    slot   | <callable>
        
        :return     <bool> | new connection created
        """"""
        if self.isConnected(signal, slot):
            return False

        callback = Callback(slot)
        self._callbacks.setdefault(signal, [])
        self._callbacks[signal].append(callback)
        return True"
3737,"def disconnect(self, signal, slot):
        """"""
        Breaks the connection between the inputted signal and the given slot.
        
        :param      signal | <variant>
                    slot   | <callable>
        
        :return     <bool> | connection broken
        """"""
        sig_calls = self._callbacks.get(signal, [])
        for callback in sig_calls:
            if callback == slot:
                sig_calls.remove(callback)
                return True
        return False"
3738,"def isConnected(self, signal, slot):
        """"""
        Returns if the given signal is connected to the inputted slot.
        
        :param      signal | <variant>
                    slot   | <callable>
        
        :return     <bool> | is connected
        """"""
        sig_calls = self._callbacks.get(signal, [])
        for callback in sig_calls:
            if callback == slot:
                return True
        return False"
3739,"def emit(self, signal, *args):
        """"""
        Emits the given signal with the inputted args.  This will go through
        its list of connected callback slots and call them.
        
        :param      signal | <variant>
                    *args  | variables
        """"""
        callbacks = self._callbacks.get(signal, [])
        new_callbacks = []
        for callback in callbacks:
            # clear out deleted pointers
            if not callback.isValid():
                continue

            new_callbacks.append(callback)

            try:
                callback(*args)
            except StandardError:
                logger.exception('Error occurred during callback.')

        self._callbacks[signal] = new_callbacks"
3740,"def generate_example(config, ext='json'):
    """"""Generate an example file based on the given Configuration object.

    Args:
        config (confpy.core.configuration.Configuration): The configuration
            object on which to base the example.
        ext (str): The file extension to render. Choices: JSON and INI.

    Returns:
        str: The text of the example file.
    """"""
    template_name = 'example.{0}'.format(ext.lower())
    template = ENV.get_template(template_name)
    return template.render(config=config)"
3741,"def run(self):
        """""" Run at parse time.

        When the documents are initially being scanned, this method runs
        and does two things: (a) creates an instance that is added to
        the site's widgets, and (b) leaves behind a placeholder docutils
        node that can later be processed after the docs are resolved.
        The latter needs enough information to retrieve the former.

        """"""

        rtype = self.name
        resource_content = '\n'.join(self.content)
        resource_class = ResourceDirective.get_resource_class(rtype)
        this_resource = resource_class(self.docname, rtype, resource_content)

        # Add this resource to the site
        self.resources[this_resource.docname] = this_resource

        # Don't need to return a resource ""node"", the document is the node
        return []"
3742,"def importProteinDatabase(filePath, proteindb=None, headerParser=None,
        forceId=False, decoyTag='[decoy]', contaminationTag='[cont]',
        ignoreIsoleucine=False,  cleavageRule='[KR]', minLength=5, maxLength=40,
        missedCleavage=0, removeNtermM=False):
    """"""Generates a :class:`ProteinDatabase` by in silico digestion of proteins
    from a fasta file.

    :param filePath: File path
    :param proteindb: optional an existing :class:`ProteinDatabase` can be
        specified, otherwise a new instance is generated and returned
    :param decoyTag: If a fasta file contains decoy protein entries, they should
        be specified with a sequence tag
    :param contaminationTag: If a fasta file contains contamination protein
        entries, they should be specified with a sequence tag
    :param headerParser: optional, allows specifying an individual headerParser
    :param forceId: bool, if True and no id can be extracted from the fasta
        header the whole header sequence is used as a protein id instead of
        raising an exception.
    :param cleavageRule: cleavage rule expressed in a regular expression, see
        :attr:`maspy.constants.expasy_rules`
    :param missedCleavage: number of allowed missed cleavage sites
    :param removeNtermM: bool, True to consider also peptides with the
        N-terminal Methionine of the protein removed
    :param minLength: int, only yield peptides with length >= minLength
    :param maxLength: int, only yield peptides with length <= maxLength
    :param ignoreIsoleucine: bool, if True treat Isoleucine and Leucine in
        peptide sequences as indistinguishable

    See also :func:`maspy.peptidemethods.digestInSilico`
    """"""
    if proteindb is None:
        proteindb = ProteinDatabase(ignoreIsoleucine=ignoreIsoleucine)

    # - Add protein entries to the protein database - #
    for fastaHeader, sequence in _readFastaFile(filePath):
        #TODO: function, make protein entry or something like this.
        header, isDecoy = _removeHeaderTag(fastaHeader, decoyTag)
        header, isContaminant = _removeHeaderTag(header, contaminationTag)

        headerInfo = _parseFastaHeader(header, headerParser, forceId)
        proteinId = _idFromHeaderInfo(headerInfo, isDecoy, decoyTag)
        proteinName = _nameFromHeaderInfo(headerInfo, isDecoy, decoyTag)

        if not isDecoy:
            isDecoy = _proteinTagPresent(header, decoyTag)
        if not isContaminant:
            isContaminant = _proteinTagPresent(header, contaminationTag)

        proteindb._addProtein(
            proteinId, proteinName, sequence, fastaHeader, headerInfo,
            isDecoy=isDecoy, isContaminant=isContaminant
        )

    # - Perform an insilico digestion and add peptides to the proteindb - #
    for proteinId in proteindb.proteins:
        sequence = proteindb.proteins[proteinId].sequence
        digestInfo = maspy.peptidemethods.digestInSilico(
            sequence, cleavageRule, missedCleavage, removeNtermM,
            minLength, maxLength
        )
        for sequence, info in digestInfo:
            proteindb._addPeptide(sequence, proteinId, info)

    #Define wheter a peptide is unique to one protein entry
    for peptide, peptideEntry in viewitems(proteindb.peptides):
        if len(peptideEntry.proteins) == 1:
            peptideEntry.isUnique = True
        else:
            peptideEntry.isUnique = False

    #Add peptide as shared or unique to its protein entries
    for peptide, peptideEntry in viewitems(proteindb.peptides):
        for proteinId in peptideEntry.proteins:
            if peptideEntry.isUnique:
                proteindb.proteins[proteinId].uniquePeptides.add(peptide)
            else:
                proteindb.proteins[proteinId].sharedPeptides.add(peptide)

    #Define unique proteins, i.e. have at least one unique peptide
    for proteinEntry in viewvalues(proteindb.proteins):
        if len(proteinEntry.uniquePeptides) > 0:
            proteinEntry.isUnique = True
        else:
            proteinEntry.isUnique = False

    return proteindb"
3743,"def fastaParserSpectraClusterPy(header):
    """"""Custom parser for fasta headers adapted from
    https://github.com/spectra-cluster/spectra-cluster-py

    :param header: str, protein entry header from a fasta file

    :returns: dict, parsed header
    """"""
    isUniprot = lambda h: h[0:3] in ['sp|', 'tr|', 'up|']

    if isUniprot(header):
        start = 3
        end = header.find('|', start)
    else:
        start = 0
        breakPositions = [header.find(' '), header.find('|')]
        breakPositions = [i if i > 0 else len(header) for i in breakPositions]
        end = min(breakPositions)

    return {'id': header[start:end]}"
3744,"def _removeHeaderTag(header, tag):
    """"""Removes a tag from the beginning of a header string.

    :param header: str
    :param tag: str
    :returns: (str, bool), header without the tag and a bool that indicates
        wheter the tag was present.
    """"""
    if header.startswith(tag):
        tagPresent = True
        header = header[len(tag):]
    else:
        tagPresent = False
    return header, tagPresent"
3745,"def _parseFastaHeader(fastaHeader, parser=None, forceId=False):
    """"""Parses a fasta header and returns extracted information in a dictionary.

    Unless a custom parser is specified, a ``Pyteomics`` function is used, which
    provides parsers for the formats of UniProtKB, UniRef, UniParc and  UniMES
    (UniProt Metagenomic and Environmental Sequences), described at
    `www.uniprot.org <http://www.uniprot.org/help/fasta-headers>_`.

    :param fastaHeader: str, protein entry header from a fasta file
    :param parser: is a function that takes a fastaHeader string and returns a
        dictionary, containing at least the key ""id"". If None the parser
        function from pyteomics ``pyteomics.fasta.parse()`` is used.
    :param forceId: bool, if True and no id can be extracted from the fasta
        header the whole header sequence is used as a protein id instead of
        raising an exception.

    :returns: dict, describing a fasta header. Minimally contains an 'id' key.
    """"""
    if parser is None:
        try:
            headerInfo = pyteomics.fasta.parse(fastaHeader)
        except pyteomics.auxiliary.PyteomicsError as raisedPyteomicsError:
            #If forceId is set True, the whole header is used as id
            if forceId:
                headerInfo = {'id': fastaHeader}
            else:
                raise raisedPyteomicsError
    else:
        headerInfo = parser(fastaHeader)
    return headerInfo"
3746,"def _idFromHeaderInfo(headerInfo, isDecoy, decoyTag):
    """"""Generates a protein id from headerInfo. If ""isDecoy"" is True, the
    ""decoyTag"" is added to beginning of the generated protein id.

    :param headerInfo: dict, must contain a key ""id""
    :param isDecoy: bool, determines if the ""decoyTag"" is added or not.
    :param decoyTag: str, a tag that identifies decoy / reverse protein entries.
    :returns: str, protein id
    """"""
    proteinId = headerInfo['id']
    if isDecoy:
        proteinId = ''.join((decoyTag, proteinId))

    return proteinId"
3747,"def _nameFromHeaderInfo(headerInfo, isDecoy, decoyTag):
    """"""Generates a protein name from headerInfo. If ""isDecoy"" is True, the
    ""decoyTag"" is added to beginning of the generated protein name.

    :param headerInfo: dict, must contain a key ""name"" or ""id""
    :param isDecoy: bool, determines if the ""decoyTag"" is added or not.
    :param decoyTag: str, a tag that identifies decoy / reverse protein entries.
    :returns: str, protein name
    """"""
    if 'name' in headerInfo:
        proteinName = headerInfo['name']
    else:
        proteinName = headerInfo['id']
    if isDecoy:
        proteinName = ''.join((decoyTag, proteinName))

    return proteinName"
3748,"def _addProtein(self, proteinId, proteinName, sequence, fastaHeader,
                    headerInfo, isDecoy=False, isContaminant=False):
        """"""#TODO""""""
        proteinEntry = ProteinEntry(
            proteinId, proteinName, sequence, fastaHeader, headerInfo,
            isDecoy=isDecoy, isContaminant=isContaminant
        )
        self.proteins[proteinEntry.id] = proteinEntry"
3749,"def _addPeptide(self, sequence, proteinId, digestInfo):
        """"""Add a peptide to the protein database.

        :param sequence: str, amino acid sequence
        :param proteinId: str, proteinId
        :param digestInfo: dict, contains information about the in silico digest
            must contain the keys 'missedCleavage', 'startPos' and 'endPos'
        """"""
        stdSequence = self.getStdSequence(sequence)

        if stdSequence not in self.peptides:
            self.peptides[stdSequence] = PeptideEntry(
                stdSequence, mc=digestInfo['missedCleavage']
            )
        if sequence not in self.peptides:
            self.peptides[sequence] = self.peptides[stdSequence]

        if proteinId not in self.peptides[stdSequence].proteins:
            #FUTURE: peptide can appear at multiple positions per protein.
            #peptideEntry.addSource(proteinId, startPos, endPos)
            self.peptides[stdSequence].proteins.add(proteinId)
            self.peptides[stdSequence].proteinPositions[proteinId] = (
                                    digestInfo['startPos'], digestInfo['endPos']
                                    )
            self.proteins[proteinId].peptides.add(sequence)"
3750,"def options(self, parser, env):
        """"""
        Add options to command line.
        """"""
        super(LeakDetectorPlugin, self).options(parser, env)
        parser.add_option(""--leak-detector-level"", action=""store"",
                          default=env.get('NOSE_LEAK_DETECTOR_LEVEL'),
                          dest=""leak_detector_level"",
                          help=""Level at which to detect leaks and report memory deltas ""
                               ""(0=None, 1=Dir, 2=Module, 3=TestCaseClass, 4=Test)"")

        parser.add_option(""--leak-detector-report-delta"", action=""store_true"",
                          default=env.get('NOSE_LEAK_DETECTOR_REPORT_DELTA'),
                          dest=""leak_detector_report_delta"",
                          help="""")

        parser.add_option(""--leak-detector-patch-mock"", action=""store_true"",
                          default=env.get('NOSE_LEAK_DETECTOR_PATCH_MOCK', True),
                          dest=""leak_detector_patch_mock"",
                          help="""")

        parser.add_option(""--leak-detector-add-traceback"", action=""store_true"",
                          default=env.get('NOSE_LEAK_DETECTOR_SAVE_TRACEBACK', False),
                          dest=""leak_detector_save_traceback"",
                          help="""")

        parser.add_option(""--leak-detector-ignore-pattern"", action=""append"",
                          default=(list(filter(operator.truth,
                                               env.get('NOSE_LEAK_DETECTOR_IGNORE_PATTERNS',
                                                       '').split(','))) or
                                   ['NOSE_LEAK_DETECTOR_IGNORE']),
                          dest=""leak_detector_ignore_patterns"",
                          help="""")"
3751,"def configure(self, options, conf):
        """"""
        Configure plugin.
        """"""
        super(LeakDetectorPlugin, self).configure(options, conf)
        if options.leak_detector_level:
            self.reporting_level = int(options.leak_detector_level)
        self.report_delta = options.leak_detector_report_delta
        self.patch_mock = options.leak_detector_patch_mock
        self.ignore_patterns = options.leak_detector_ignore_patterns
        self.save_traceback = options.leak_detector_save_traceback
        self.multiprocessing_enabled = bool(getattr(options, 'multiprocess_workers', False))"
3752,"def bind(self, instance, auto=False):
        """"""
        Bind deps to instance

        :param instance:
        :param auto: follow update of DI and refresh binds once we will get something new
        :return:
        """"""
        methods = [
            (m, cls.__dict__[m])
            for cls in inspect.getmro(type(instance))
            for m in cls.__dict__ if inspect.isfunction(cls.__dict__[m])
            ]

        try:
            deps_of_endpoints = [(method_ptr, self.entrypoint_deps(method_ptr))
                                 for (method_name, method_ptr) in methods]

            for (method_ptr, method_deps) in deps_of_endpoints:
                if len(method_deps) > 0:
                    method_ptr(instance, **method_deps)
        except KeyError:
            pass

        if auto and instance not in self.current_scope.get_auto_bind_list():
            self.current_scope.auto_bind(instance)

        return instance"
3753,"def map_dict(self, dict_entity):
        """""" map dict_entity to current instance(self) """"""
        self.dict_entity = dict_entity
        Entity.map(self, self.dict_entity)"
3754,"def as_dict(self):
        """""" create a dict based on class attributes """"""
        odict = OrderedDict()
        for name in self._order:
            attr_value = getattr(self, name)
            if isinstance(attr_value, List):
                _list = []
                for item in attr_value:
                    _list.append((item.as_dict() if isinstance(item, Entity) else item))
                    odict[name] = _list
            elif isinstance(attr_value, Entity):
                odict[name] = attr_value.as_dict()
            else:
                odict[name] = getattr(self, name)
        return odict"
3755,"def map(cls, dict_entity):
        """""" staticmethod which will be used in recursive mode in order to map dict to instance """"""
        for key, value in dict_entity.items():
            if hasattr(cls, key):
                if isinstance(value, list):
                    _list = getattr(cls, key)
                    if isinstance(_list.expected_type, list):
                        for _dict in value:
                            _list.append(cls.map(_list.typeof(), _dict))
                elif isinstance(value, dict):
                    attr = getattr(cls, key)
                    instance = attr.expected_type()
                    Entity.map(instance, value)
                    setattr(cls, key, instance)
                else:
                    setattr(cls, key, value)
            else:
                setattr(cls, key, value)"
3756,"def generateParams(rawfilepath, outputpath, isolationWindow, coElute):
    """"""Generates a string containing the parameters for a pParse parameter file
    but doesn't write any file yet.

    :param rawfilepath: location of the thermo "".raw"" file
    :param outputpath: path to the output directory of pParse
    :param isolationWindow: MSn isolation window that was used for the
        aquisition of the specified thermo raw file
    :param coElute: 0 or 1, see ""[Advanced Options]"" below

    :returns: string containing pParse parameters

    .. note:
        # pParse.para params template
        # For help: mail to tuhuijun@ict.ac.cn
        # Time: 2014.12.08

        [Basic Options]
        datapath = C:\filedirectory\filename
        logfilepath = C:\filedirectory
        outputpath = C:\filedirectory

        [Advanced Options]
        co-elute = 1
        # 0, output single precursor for single scan;
        # 1, output all co-eluted precursors.
        input_format = raw
        # raw / ms1
        isolation_width = 1.6
        # 2 / 2.5 / 3 / 4
        mars_threshold = -0.5
        ipv_file = .\IPV.txt
        trainingset = EmptyPath

        [Internal Switches]
        output_mars_y = 0
        delete_msn = 0
        output_mgf = 1
        output_pf = 1
        debug_mode = 0
        check_activationcenter = 1
        output_all_mars_y = 0
        rewrite_files = 0
        export_unchecked_mono = 0
        cut_similiar_mono = 1
        mars_model = 4
        output_trainingdata = 0
    """"""
    output = str()
    #Basic options
    output = '\n'.join([output, ' = '.join(['datapath', rawfilepath])])
    output = '\n'.join([output, ' = '.join(['logfilepath', outputpath])])
    output = '\n'.join([output, ' = '.join(['outputpath', outputpath])])
    #Advanced options
    output = '\n'.join([output, ' = '.join(['co-elute', str(coElute)])])
    output = '\n'.join([output, ' = '.join(['input_format', 'raw'])])
    output = '\n'.join([output, ' = '.join(['isolation_width',
                                            str(isolationWindow)]
                                            )])
    output = '\n'.join([output, ' = '.join(['mars_threshold', '-0.5'])])
    output = '\n'.join([output, ' = '.join(['ipv_file', '.\IPV.txt'])])
    output = '\n'.join([output, ' = '.join(['trainingset', 'EmptyPath'])])
    #Internal Switches
    output = '\n'.join([output, ' = '.join(['output_mars_y', '0'])])
    output = '\n'.join([output, ' = '.join(['delete_msn', '0'])])
    output = '\n'.join([output, ' = '.join(['output_mgf', '1'])])
    output = '\n'.join([output, ' = '.join(['output_pf', '0'])])
    output = '\n'.join([output, ' = '.join(['debug_mode', '0'])])
    output = '\n'.join([output, ' = '.join(['check_activationcenter', '1'])])
    output = '\n'.join([output, ' = '.join(['output_all_mars_y', '0'])])
    output = '\n'.join([output, ' = '.join(['rewrite_files', '0'])])
    output = '\n'.join([output, ' = '.join(['export_unchecked_mono', '0'])])
    output = '\n'.join([output, ' = '.join(['cut_similiar_mono', '1'])])
    output = '\n'.join([output, ' = '.join(['mars_model', '4'])])
    output = '\n'.join([output, ' = '.join(['output_trainingdata', '0'])])

    return output"
3757,"def writeParams(rawfilepath, outputpath, isolationWindow, coElute=0):
    """"""Generate and write a pParse parameter file.

    :param rawfilepath: location of the thermo "".raw"" file
    :param outputpath: path to the output directory of pParse
    :param isolationWindow: MSn isolation window that was used for the
        aquisition of the specified thermo raw file
    :param coElute:

    :returns: file path of the pParse parameter file
    """"""
    paramText = generateParams(rawfilepath, outputpath, isolationWindow,
                               coElute)
    filename, fileext = os.path.splitext(os.path.basename(rawfilepath))
    paramPath = aux.joinpath(outputpath, filename+'.pparse.para')
    with open(paramPath, 'wb') as openfile:
        openfile.write(paramText)
    return paramPath"
3758,"def execute(paramPath, executable='pParse.exe'):
    """"""Execute pParse with the specified parameter file.

    :param paramPath: location of the pParse parameter file
    :param executable: must specify the complete file path of the pParse.exe
        if its location is not in the ``PATH`` environment variable.

    :returns: :func:`subprocess.Popen` return code, 0 if pParse was executed
        successful
    """"""
    procArgs = [executable, paramPath]

    ## run it ##
    proc = subprocess.Popen(procArgs, stderr=subprocess.PIPE)

    ## But do not wait till netstat finish, start displaying output immediately ##
    while True:
        out = proc.stderr.read(1)
        if out == '' and proc.poll() != None:
            break
        if out != '':
            sys.stdout.write(out)
            sys.stdout.flush()

    return proc.returncode"
3759,"def cleanUpPparse(outputpath, rawfilename, mgf=False):
    """"""Delete temporary files generated by pparse, including the filetypes
    "".csv"", "".ms1"", "".ms2"", "".xtract"",  the files ""pParsePlusLog.txt"" and
    ""pParse.para"" and optionally also the "".mgf"" file generated by pParse.

    .. warning:
        When the parameter ""mgf"" is set to ""True"" all files ending with "".mgf""
        and containing the specified ""filename"" are deleted. This could
        potentially also affect MGF files not generated by pParse.

    :param outputpath: path to the output directory of pParse
    :param rawfilename: filename of the thermo "".raw"" file
    :param mgf: bool, if True the "".mgf"" file generated by pParse is also
        removed
    """"""
    extensions = ['csv', 'ms1', 'ms2', 'xtract']
    filename, fileext = os.path.splitext(os.path.basename(rawfilename))
    additionalFiles = [aux.joinpath(outputpath, 'pParsePlusLog.txt'),
                       aux.joinpath(outputpath, filename+'.pparse.para'),
                       ]

    for ext in extensions:
        filepath = aux.joinpath(outputpath, '.'.join([filename, ext]))
        if os.path.isfile(filepath):
            print('Removing file: ', filepath)
            os.remove(filepath)
    for filepath in additionalFiles:
        if os.path.isfile(filepath):
            print('Removing file: ', filepath)
            os.remove(filepath)
    if mgf:
        for _filename in os.listdir(outputpath):
            _basename, _fileext = os.path.splitext(_filename)
            if _fileext.lower() != '.mgf':
                continue
            if _basename.find(basename) != -1 and _basename != basename:
                filepath = aux.joinpath(outputpath, _filename)
                print('Removing file: ', filepath)
                os.remove(filepath)"
3760,"def launch_server(message_handler, options):
    """"""
    Launch a message server
    :param handler_function: The handler function to execute for each message
    :param options: Application options for TCP, etc.
    """"""
    logger = logging.getLogger(__name__)
    if (options.debug):
        logger.setLevel(logging.DEBUG)

    if not options.monitor_port:
        logger.warning(
            ""Monitoring not enabled. No monitor-port option defined."")
    else:
        threading.Thread(target=launch_monitor_server, args=(options.host, options.monitor_port, logger)).start()

    # Create the server, binding to specified host on configured port

    logger.info(
        'Starting server on host %s port %d Python version %s.%s.%s' % ((options.host, options.port) + sys.version_info[:3]))
    server = ThreadedTCPServer((options.host, options.port),
                       StreamHandler.create_handler(message_handler,
                                                    options.buffer_size,
                                                    logger))

    # Activate the server; this will keep running until you
    # interrupt the program with Ctrl-C
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        logger.info(""Ctrl-C, exiting..."")
        os._exit(142)"
3761,"def launch_monitor_server(host, port, logger):
    """"""
    Launch a monitor server
    :param port: the monitor port
    :param logger: the logger
    """"""
    logger.info('Starting monitor server on host %s port %d' % (host, port))
    server = ThreadedTCPServer((host, port), MonitorHandler)
    server.serve_forever()"
3762,"def create_handler(cls, message_handler, buffer_size, logger):
        """"""
        Class variables used here since the framework creates an instance for each connection

        :param message_handler: the MessageHandler used to process each message.
        :param buffer_size: the TCP buffer size.
        :param logger: the global logger.
        :return: this class.
        """"""
        cls.BUFFER_SIZE = buffer_size
        cls.message_handler = message_handler
        cls.logger = logger

        cls.message_handler.logger = logging.getLogger(message_handler.__class__.__name__)
        cls.message_handler.logger.setLevel(logger.level)
        return cls"
3763,"def handle(self):
        """"""
        The required handle method.
        """"""
        logger = StreamHandler.logger
        logger.debug(""handling requests with message handler %s "" % StreamHandler.message_handler.__class__.__name__)

        message_handler = StreamHandler.message_handler

        try:
            while True:
                logger.debug('waiting for more data')
                if not message_handler.handle(self.request, StreamHandler.BUFFER_SIZE):
                    break

            logger.warning(""connection closed from %s"" % (self.client_address[0]))
            self.request.close()
        except:
            logger.exception(""connection closed from %s"" % (self.client_address[0]))
        finally:
            self.request.close()"
3764,"def receiveError(self, reasonCode, description):
        """"""
        Called when we receive a disconnect error message from the other
        side.
        """"""
        error = disconnectErrors.get(reasonCode, DisconnectError)
        self.connectionClosed(error(reasonCode, description))
        SSHClientTransport.receiveError(self, reasonCode, description)"
3765,"def get_logger(name):
    """"""
    Special get_logger.  Typically name is the name of the application using Balsa.
    :param name: name of the logger to get, which is usually the application name. Optionally it can be a python file
    name or path (e.g. __file__).
    :return: the logger for the logger name
    """"""

    # if name is a python file, or a path to a python file, extract the module name
    if name.endswith("".py""):
        name = name[:-3]
        if os.sep in name:
            name = name.split(os.sep)[-1]

    return logging.getLogger(name)"
3766,"def traceback_string():
    """"""
    Helper function that formats most recent traceback.  Useful when a program has an overall try/except
    and it wants to output the program trace to the log.
    :return: formatted traceback string (or None if no traceback available)
    """"""
    tb_string = None
    exc_type, exc_value, exc_traceback = traceback.sys.exc_info()
    if exc_type is not None:
        display_lines_list = [str(exc_value)] + traceback.format_tb(exc_traceback)
        tb_string = ""\n"".join(display_lines_list)
    return tb_string"
3767,"def lookup_path(bin_name):
    """"""Calls to external binaries can't depend on $PATH
    """"""
    paths = ('/usr/local/sbin/', '/usr/local/bin/', '/usr/sbin/', '/usr/bin/')
    for p in paths:
        fq_path = p + bin_name
        found = os.path.isfile(fq_path) and os.access(fq_path, os.X_OK)
        if found:
            return fq_path
    return False"
3768,"def get_message_handler(self, message_handlers):
        """"""
        Create a MessageHandler for the configured Encoder
        :param message_handlers: a dictionart of MessageHandler keyed by encoder
        :return: a MessageHandler
        """"""
        encoder = self.options.encoder
        try:
            return message_handlers[encoder]
        except KeyError:
            raise NotImplementedError('No RequestHandler defined for given encoder (%s).' % encoder)"
3769,"def handle(self, event):
        """"""
        Entry point to handle user events.

        :param event: Received event. See a full list `here <https://dev.twitter.com/streaming/overview/messages-types#Events_event>`_.
        """"""
        callback = getattr(self, 'on_{event}'.format(event=event.event), None)
        callback(event)"
3770,"def form_valid(self, form):
        if self.__pk:
            obj = PurchasesAlbaran.objects.get(pk=self.__pk)
            self.request.albaran = obj
            form.instance.albaran = obj

        form.instance.validator_user = self.request.user

        raise Exception(""revisar StorageBatch"")
        """"""
        batch = StorageBatch.objects.filter(pk=form.data['batch']).first()
        if not batch:
            errors = form._errors.setdefault(""batch"", ErrorList())
            errors.append(_(""Batch invalid""))
            return super(LineAlbaranCreate, self).form_invalid(form)
        """"""

        # comprueba si el producto comprado requiere un valor de atributo especial
        product_final = ProductFinal.objects.filter(pk=form.data['product']).first()
        feature_special_value = None
        if not product_final:
            errors = form._errors.setdefault(""feature_special_value"", ErrorList())
            errors.append(_(""Product not selected""))
            return super(LineAlbaranCreate, self).form_invalid(form)
        elif product_final.product.feature_special:
            # es obligatorio la informacion de caracteristicas especiales
            if 'feature_special_value' not in form.data or not form.data['feature_special_value']:
                errors = form._errors.setdefault(""feature_special_value"", ErrorList())
                errors.append(_(""Product needs information of feature special""))
                return super(LineAlbaranCreate, self).form_invalid(form)
            else:
                feature_special_value = list(set(filter(None, form.data['feature_special_value'].split('\n'))))
                try:
                    quantity = int(float(form.data['quantity']))
                except ValueError:
                    errors = form._errors.setdefault(""quantity"", ErrorList())
                    errors.append(_(""Quantity is not valid""))
                    return super(LineAlbaranCreate, self).form_invalid(form)

                if product_final.product.feature_special.unique:
                    # mismo numero de caracteristicas que de cantidades
                    # si el feature special esta marcado como 'unico'
                    if len(feature_special_value) != quantity:
                        errors = form._errors.setdefault(""feature_special_value"", ErrorList())
                        errors.append(_(""Quantity and values of feature special not equals""))
                        return super(LineAlbaranCreate, self).form_invalid(form)
                    # no existen las caracteristicas especiales dadas de alta en el sistema
                    elif ProductUnique.objects.filter(product_final=product_final, value__in=feature_special_value).exists():
                        errors = form._errors.setdefault(""feature_special_value"", ErrorList())
                        errors.append(_(""Some value of feature special exists""))
                        return super(LineAlbaranCreate, self).form_invalid(form)
                elif len(feature_special_value) != 1:
                    errors = form._errors.setdefault(""feature_special_value"", ErrorList())
                    errors.append(_(""The special feature must be unique for all products""))
                    return super(LineAlbaranCreate, self).form_invalid(form)
        try:
            with transaction.atomic():
                # save line albaran
                result = super(LineAlbaranCreate, self).form_valid(form)

                raise Exception(""Cambiar ProductStock por ProductUnique"")
                """"""
                if self.object.status != PURCHASE_ALBARAN_LINE_STATUS_REJECTED:
                    # prepare stock
                    ps = ProductStock()
                    ps.product_final = product_final
                    ps.line_albaran = self.object
                    ps.batch = batch
                    # save stock
                    ps.quantity = self.object.quantity
                    ps.save()

                    if feature_special_value:
                        # prepare product feature special
                        if product_final.product.feature_special.unique:
                            pfs = ProductUnique()
                            pfs.product_final = product_final
                            # save product featureSpecial and stock
                            for fs in feature_special_value:
                                pfs.pk = None
                                pfs.value = fs
                                pfs.save()

                        else:
                            pfs = ProductUnique.objects.filter(
                                value=feature_special_value[0],
                                product_final=product_final
                            ).first()
                            if pfs:
                                pfs.stock_real += self.object.quantity
                            else:
                                pfs = ProductUnique()
                                pfs.product_final = product_final
                                pfs.value = feature_special_value[0]
                                pfs.stock_real = self.object.quantity
                            pfs.save()
                    else:
                        # product unique by default
                        pfs = ProductUnique.objects.filter(product_final=product_final).first()
                        if not pfs:
                            pfs = ProductUnique()
                            pfs.product_final = product_final
                            pfs.stock_real = self.object.quantity
                        else:
                            pfs.stock_real += self.object.quantity
                        pfs.save()
                """"""
                return result
        except IntegrityError as e:
            errors = form._errors.setdefault(""product"", ErrorList())
            errors.append(_(""Integrity Error: {}"".format(e)))
            return super(LineAlbaranCreate, self).form_invalid(form)"
3771,"def get_form(self, form_class=None):
        form = super(LineAlbaranUpdate, self).get_form(form_class)

        raise Exception(""Cambiar ProductStock por ProductUnique"")
        """"""
        ps = ProductStock.objects.filter(line_albaran=self.object).first()
        if ps:
            # initial field
            form.fields['storage'].initial = ps.batch.zone.storage
            form.fields['zone'].initial = ps.batch.zone
            form.fields['batch'].initial = ps.batch
        """"""
        return form"
3772,"def _emplace_pmrna(mrnas, parent, strict=False):
    """"""Retrieve the primary mRNA and discard all others.""""""
    mrnas.sort(key=lambda m: (m.cdslen, m.get_attribute('ID')))
    pmrna = mrnas.pop()
    if strict:
        parent.children = [pmrna]
    else:
        parent.children = [c for c in parent.children if c not in mrnas]"
3773,"def _emplace_transcript(transcripts, parent):
    """"""Retrieve the primary transcript and discard all others.""""""
    transcripts.sort(key=lambda t: (len(t), t.get_attribute('ID')))
    pt = transcripts.pop()
    parent.children = [pt]"
3774,"def primary_mrna(entrystream, parenttype='gene'):
    """"""
    Select a single mRNA as a representative for each protein-coding gene.

    The primary mRNA is the one with the longest translation product. In cases
    where multiple isoforms have the same translated length, the feature ID is
    used for sorting.

    This function **does not** return only mRNA features, it returns all GFF3
    entry types (pragmas, features, sequences, etc). The function **does**
    modify the gene features that pass through to ensure that they have at most
    a single mRNA feature.

    >>> reader = tag.GFF3Reader(tag.pkgdata('pdom-withseq.gff3'))
    >>> filter = tag.transcript.primary_mrna(reader)
    >>> for gene in tag.select.features(filter, type='gene'):
    ...    assert gene.num_children == 1
    """"""
    for entry in entrystream:
        if not isinstance(entry, tag.Feature):
            yield entry
            continue

        for parent in tag.select.features(entry, parenttype, traverse=True):
            mrnas = [f for f in parent.children if f.type == 'mRNA']
            if len(mrnas) == 0:
                continue
            _emplace_pmrna(mrnas, parent)
        yield entry"
3775,"def _get_primary_type(ttypes, parent, logstream=stderr):
    """"""Check for multiple transcript types and, if possible, select one.""""""
    if len(ttypes) > 1:
        if logstream:  # pragma: no branch
            message = '[tag::transcript::primary_transcript]'
            message += ' WARNING: feature {:s}'.format(parent.slug)
            message += ' has multiple associated transcript types'
            message += ' {}'.format(ttypes)
            print(message, file=logstream)
        if 'mRNA' not in ttypes:
            message = (
                'cannot resolve multiple transcript types if ""mRNA"" is'
                ' not one of those types {}'.format(ttypes)
            )
            raise Exception(message)
        ttypes = ['mRNA']
    return ttypes[0]"
3776,"def primary_transcript(entrystream, parenttype='gene', logstream=stderr):
    """"""
    Select a single transcript as a representative for each gene.

    This function is a generalization of the `primary_mrna` function that
    attempts, under certain conditions, to select a single transcript as a
    representative for each gene. If a gene encodes multiple transcript types,
    one of those types must be **mRNA** or the function will complain loudly
    and fail.

    For mRNAs, the primary transcript is selected according to translated
    length. For all other transcript types, the length of the transcript
    feature itself is used. I'd be eager to hear suggestions for alternative
    selection criteria.

    Like the `primary_mrna` function, this function **does not** return only
    transcript features. It **does** modify gene features to ensure that each
    has at most one transcript feature.

    >>> reader = tag.GFF3Reader(tag.pkgdata('psyllid-mixed-gene.gff3.gz'))
    >>> gene_filter = tag.select.features(reader, type='gene')
    >>> trans_filter = tag.transcript.primary_transcript(gene_filter)
    >>> for gene in trans_filter:
    ...     assert gene.num_children == 1

    In cases where the direct children of a gene feature have heterogenous
    types, the `primary_mrna` function will only discard mRNA features. This
    function, however, will discard all direct children of the gene that are
    not the primary transcript, including non-transcript children. This is a
    retty subtle distinction, and anecdotal experience suggests that cases in
    which the distinction actually matters are extremely rare.
    """"""
    for entry in entrystream:
        if not isinstance(entry, tag.Feature):
            yield entry
            continue

        for parent in tag.select.features(entry, parenttype, traverse=True):
            if parent.num_children == 0:
                continue

            transcripts = defaultdict(list)
            for child in parent.children:
                if child.type in type_terms:
                    transcripts[child.type].append(child)

            if len(transcripts) == 0:
                continue

            ttypes = list(transcripts.keys())
            ttype = _get_primary_type(ttypes, parent)
            transcript_list = transcripts[ttype]

            if ttype == 'mRNA':
                _emplace_pmrna(transcript_list, parent, strict=True)
            else:
                _emplace_transcript(transcript_list, parent)

        yield entry"
3777,"def parse_parent(docname):
    """""" Given a docname path, pick apart and return name of parent """"""

    lineage = docname.split('/')
    lineage_count = len(lineage)

    if docname == 'index':
        # This is the top of the Sphinx project
        parent = None
    elif lineage_count == 1:
        # This is a non-index doc in root, e.g. about
        parent = 'index'
    elif lineage_count == 2 and lineage[-1] == 'index':
        # This is blog/index, parent is the root
        parent = 'index'
    elif lineage_count == 2:
        # This is blog/about
        parent = lineage[0] + '/index'
    elif lineage[-1] == 'index':
        # This is blog/sub/index
        parent = '/'.join(lineage[:-2]) + '/index'
    else:
        # This should be blog/sub/about
        parent = '/'.join(lineage[:-1]) + '/index'

    return parent"
3778,"def parents(self, resources):
        """""" Split the path in name and get parents """"""

        if self.docname == 'index':
            # The root has no parents
            return []
        parents = []
        parent = resources.get(self.parent)
        while parent is not None:
            parents.append(parent)
            parent = resources.get(parent.parent)
        return parents"
3779,"def acquire(self, resources, prop_name):
        """""" Starting with self, walk until you find prop or None """"""

        # Instance
        custom_prop = getattr(self.props, prop_name, None)
        if custom_prop:
            return custom_prop

        # Parents...can't use acquire as have to keep going on acquireds
        for parent in self.parents(resources):
            acquireds = parent.props.acquireds
            if acquireds:
                # First try in the per-type acquireds
                rtype_acquireds = acquireds.get(self.rtype)
                if rtype_acquireds:
                    prop_acquired = rtype_acquireds.get(prop_name)
                    if prop_acquired:
                        return prop_acquired

                # Next in the ""all"" section of acquireds
                all_acquireds = acquireds.get('all')
                if all_acquireds:
                    prop_acquired = all_acquireds.get(prop_name)
                    if prop_acquired:
                        return prop_acquired

        return"
3780,"def template(self, resources):
        """""" Get the template from: YAML, hierarchy, or class """"""

        template_name = self.acquire(resources, 'template')
        if template_name:
            return template_name
        else:
            # We're putting an exception for ""resource"", the built-in
            # rtype/directive. We want it to work out-of-the-box without
            # requiring an _templates/resource.html in the docs project.
            # Instead, use the page.html the ships with Sphinx.
            if self.rtype == 'resource':
                return 'page'
            else:
                return self.rtype"
3781,"def find_prop_item(self, prop_name, prop_key, prop_value):
        """""" Look for a list prop with an item where key == value """"""
        # Image props are a sequence of dicts. We often need one of them.
        # Where one of the items has a dict key matching a value, and if
        # nothing matches, return None

        prop = getattr(self.props, prop_name, None)
        if prop:
            return next(
                (p for p in prop
                 if getattr(p, prop_key) == prop_value),
                None
            )

        return None"
3782,"def default() :
		"""""" Get default shaman instance by ""data/trained.json""
		""""""
		if Shaman._default_instance is not None :
			return Shaman._default_instance

		with open((os.path.dirname(__file__) or '.') + '/data/trained.json') as file :
			tset = json.loads(file.read())

		Shaman._default_instance = Shaman(tset)
		return Shaman._default_instance"
3783,"def detect(self, code) :
		"""""" Detect language with code
		""""""
		
		keywords = KeywordFetcher.fetch( code )
		probabilities = {}

		for keyword in keywords :
			if keyword not in self.trained_set['keywords'] :
				continue

			data = self.trained_set['keywords'][keyword]
			p_avg = sum(data.values()) / len(data) # Average probability of all languages

			for language, probability in data.items() :
				# By Naïve Bayes Classification
				p = probability / p_avg

				probabilities[ language ] = probabilities.get(language, 0) + math.log(1 + p)


		for pattern, data in self.trained_set['patterns'].items() :
			matcher = PatternMatcher(pattern)
			p0 = matcher.getratio(code)
			
			for language, p_avg in data.items() :
				if language not in probabilities :
					continue

				p = 1 - abs(p_avg - p0)
				probabilities[ language ] *= p
				

		# Convert `log` operated probability to percentile
		sum_val = 0
		for language, p in probabilities.items() :
			sum_val += math.pow(math.e / 2, p)

		for language, p in probabilities.items() :
			probabilities[language] = math.pow(math.e / 2, p) / sum_val * 100

		return sorted(probabilities.items(), key=lambda a: a[1], reverse=True)"
3784,"def fetch(code) :
		"""""" Fetch keywords by Code
		""""""
		ret = {}

		code = KeywordFetcher._remove_strings(code)
		result = KeywordFetcher.prog.findall(code)

		for keyword in result :
			if len(keyword) <= 1: continue # Ignore single-length word
			if keyword.isdigit(): continue # Ignore number

			if keyword[0] == '-' or keyword[0] == '*' : keyword = keyword[1:] # Remove first char if string is starting by '-' or '*' (Pointer or Negative numbers)
			if keyword[-1] == '-' or keyword[-1] == '*' : keyword = keyword[0:-1] # Remove last char if string is finished by '-' or '*'

			if len(keyword) <= 1: continue

			ret[ keyword ] = ret.get(keyword, 0) + 1 # `ret[ keyword ] += 1` with initial value

		return ret"
3785,"def _remove_strings(code) :
		"""""" Remove strings in code
		""""""
		removed_string = """"
		is_string_now = None
		
		for i in range(0, len(code)-1) :
			append_this_turn = False

			if code[i] == ""'"" and (i == 0 or code[i-1] != '\\') :
				if is_string_now == ""'"" :
					is_string_now = None

				elif is_string_now == None :
					is_string_now = ""'""
					append_this_turn = True

			elif code[i] == '""' and (i == 0 or code[i-1] != '\\') :
				if is_string_now == '""' :
					is_string_now = None

				elif is_string_now == None :
					is_string_now = '""'
					append_this_turn = True


			if is_string_now == None or append_this_turn == True :
				removed_string += code[i]

		return removed_string"
3786,"def getratio(self, code) :
		"""""" Get ratio of code and pattern matched
		""""""
		if len(code) == 0 : return 0

		code_replaced = self.prog.sub('', code)
		return (len(code) - len(code_replaced)) / len(code)"
3787,"def loadXmlProperty(self, xprop):
        """"""
        Loads an XML property that is a child of the root data being loaded.

        :param      xprop | <xml.etree.ElementTree.Element>
        """"""
        if xprop.tag == 'property':
            value = self.dataInterface().fromXml(xprop[0])
            self._xmlData[xprop.get('name', '')] = value"
3788,"def toXml(self, xparent=None):
        """"""
        Converts this object to XML.

        :param      xparent | <xml.etree.ElementTree.Element> || None

        :return     <xml.etree.ElementTree.Element>
        """"""
        if xparent is None:
            xml = ElementTree.Element('object')
        else:
            xml = ElementTree.SubElement(xparent, 'object')

        xml.set('class', self.__class__.__name__)
        for name, value in self._xmlData.items():
            xprop = ElementTree.SubElement(xml, 'property')
            xprop.set('name', name)
            XmlDataIO.toXml(value, xprop)
        return xml"
3789,"def fromXml(cls, xml):
        """"""
        Restores an object from XML.

        :param      xml | <xml.etree.ElementTree.Element>

        :return     subclass of <XmlObject>
        """"""
        clsname = xml.get('class')
        if clsname:
            subcls = XmlObject.byName(clsname)
            if subcls is None:
                inst = MissingXmlObject(clsname)
            else:
                inst = subcls()
        else:
            inst = cls()

        inst.loadXml(xml)
        return inst"
3790,"def fromXml(cls, elem):
        """"""
        Converts the inputted element to a Python object by looking through
        the IO addons for the element's tag.
        
        :param      elem | <xml.etree.ElementTree.Element>
        
        :return     <variant>
        """"""
        if elem is None:
            return None

        addon = cls.byName(elem.tag)
        if not addon:
            raise RuntimeError('{0} is not a supported XML tag'.format(elem.tag))

        return addon.load(elem)"
3791,"def toXml(cls, data, xparent=None):
        """"""
        Converts the inputted element to a Python object by looking through
        the IO addons for the element's tag.
        
        :param      data     | <variant>
                    xparent | <xml.etree.ElementTree.Element> || None
        
        :return     <xml.etree.ElementTree.Element>
        """"""
        if data is None:
            return None

        # store XmlObjects separately from base types
        if isinstance(data, XmlObject):
            name = 'object'
        else:
            name = type(data).__name__

        addon = cls.byName(name)
        if not addon:
            raise RuntimeError('{0} is not a supported XML tag'.format(name))

        return addon.save(data, xparent)"
3792,"def save(self, data, xparent=None):
        """"""
        Parses the element from XML to Python.
        
        :param      data    | <variant>
                    xparent | <xml.etree.ElementTree.Element> || None
        
        :return     <xml.etree.ElementTree.Element>
        """"""
        if xparent is not None:
            elem = ElementTree.SubElement(xparent, 'bool')
        else:
            elem = ElementTree.Element('bool')

        elem.text = nstr(data)
        return elem"
3793,"def load(self, elem):
        """"""
        Converts the inputted dict tag to Python.
        
        :param      elem | <xml.etree.ElementTree>
        
        :return     <dict>
        """"""
        self.testTag(elem, 'dict')

        out = {}
        for xitem in elem:
            key = xitem.get('key')
            try:
                value = XmlDataIO.fromXml(xitem[0])
            except IndexError:
                value = None
            out[key] = value
        return out"
3794,"def save(self, data, xparent=None):
        """"""
        Parses the element from XML to Python.
        
        :param      data    | <variant>
                    xparent | <xml.etree.ElementTree.Element> || None
        
        :return     <xml.etree.ElementTree.Element>
        """"""
        if xparent is not None:
            elem = ElementTree.SubElement(xparent, 'dict')
        else:
            elem = ElementTree.Element('dict')

        for key, value in sorted(data.items()):
            xitem = ElementTree.SubElement(elem, 'item')
            xitem.set('key', nstr(key))
            XmlDataIO.toXml(value, xitem)

        return elem"
3795,"def load(self, elem):
        """"""
        Converts the inputted list tag to Python.
        
        :param      elem | <xml.etree.ElementTree>
        
        :return     <list>
        """"""
        self.testTag(elem, 'list')
        out = []
        for xitem in elem:
            out.append(XmlDataIO.fromXml(xitem))
        return out"
3796,"def save(self, data, xparent=None):
        """"""
        Parses the element from XML to Python.
        
        :param      data    | <variant>
                    xparent | <xml.etree.ElementTree.Element> || None
        
        :return     <xml.etree.ElementTree.Element>
        """"""
        if xparent is not None:
            elem = ElementTree.SubElement(xparent, 'list')
        else:
            elem = ElementTree.Element('list')

        for item in data:
            XmlDataIO.toXml(item, elem)

        return elem"
3797,"def load(self, elem):
        """"""
        Converts the inputted set tag to Python.
        
        :param      elem | <xml.etree.ElementTree>
        
        :return     <set>
        """"""
        self.testTag(elem, 'set')
        out = set()
        for xitem in elem:
            out.add(XmlDataIO.fromXml(xitem))
        return out"
3798,"def load(self, elem):
        """"""
        Converts the inputted string tag to Python.
        
        :param      elem | <xml.etree.ElementTree>
        
        :return     <str>
        """"""
        self.testTag(elem, 'str')
        return elem.text if elem.text is not None else ''"
3799,"def template_substitute(text, **kwargs):
    """"""
    Replace placeholders in text by using the data mapping.
    Other placeholders that is not represented by data is left untouched.

    :param text:   Text to search and replace placeholders.
    :param data:   Data mapping/dict for placeholder key and values.
    :return: Potentially modified text with replaced placeholders.
    """"""
    for name, value in kwargs.items():
        placeholder_pattern = ""{%s}"" % name
        if placeholder_pattern in text:
            text = text.replace(placeholder_pattern, value)
    return text"
3800,"def text_remove_empty_lines(text):
    """"""
    Whitespace normalization:

      - Strip empty lines
      - Strip trailing whitespace
    """"""
    lines = [ line.rstrip()  for line in text.splitlines()  if line.strip() ]
    return ""\n"".join(lines)"
3801,"def text_normalize(text):
    """"""
    Whitespace normalization:

      - Strip empty lines
      - Strip leading whitespace  in a line
      - Strip trailing whitespace in a line
      - Normalize line endings
    """"""
    # if not isinstance(text, str):
    if isinstance(text, bytes):
        # -- MAYBE: command.ouput => bytes, encoded stream output.
        text = codecs.decode(text)
    lines = [ line.strip()  for line in text.splitlines()  if line.strip() ]
    return ""\n"".join(lines)"
3802,"def _wva(values, weights):
        """""" Calculates a weighted average
        """"""
        assert len(values) == len(weights) and len(weights) > 0
        return sum([mul(*x) for x in zip(values, weights)]) / sum(weights)"
3803,"def mode_interactive(options):
    """"""Interactive Mode: terminal prompts repeatedly for a url to fetch""""""
    articles = set()
    failures = set()

    url = input('Enter a URL: ')
    while url != '':
        article = _get_article(url=url, bodyLines=options.bodyLines, debug=options.debug)
        if (article):
            articles.add(article)
        else:
            failures.add(url)
        url = input('Enter a URL (press enter to end): ')

    _output(articles, options.outputFile, failures, options.failureFile)"
3804,"def mode_clipboard_watch(options):
    """"""Clipboard Watch Mode: watches for a new string on the clipboard, and tries to fetch that URL""""""
    articles = set()
    failures = set()

    print('Hello, this is news-scraper. Copy a URL to start!')
    print('To quit, press CTRL+C in this window.\n')
    url = pyperclip.paste()
    while True:
        try:
            tmp_value = pyperclip.paste()
            if tmp_value != url:
                url = tmp_value
                print('Fetching article...')
                if options.debug:
                    print(""Value changed: %s"" % str(url)[:100])

                article = _get_article(url=url, bodyLines=options.bodyLines, debug=options.debug)
                if (article):
                    articles.add(article)
                else:
                    failures.add(url)
                    time.sleep(0.2)
        except KeyboardInterrupt:
            break

    _output(articles, options.outputFile, failures, options.failureFile)"
3805,"def execute_one_to_many_job(parent_class=None,
                            get_unfinished_kwargs=None,
                            get_unfinished_limit=None,
                            parser_func=None,
                            parser_func_kwargs=None,
                            build_url_func_kwargs=None,
                            downloader_func=None,
                            downloader_func_kwargs=None,
                            post_process_response_func=None,
                            post_process_response_func_kwargs=None,
                            process_item_func_kwargs=None,
                            logger=None,
                            sleep_time=None):
    """"""
    A standard one-to-many crawling workflow.

    :param parent_class:
    :param get_unfinished_kwargs:
    :param get_unfinished_limit:
    :param parser_func: html parser function.
    :param parser_func_kwargs: other keyword arguments for ``parser_func``
    :param build_url_func_kwargs: other keyword arguments for
        ``parent_class().build_url(**build_url_func_kwargs)``
    :param downloader_func: a function that taking ``url`` as first arg, make
        http request and return response/html.
    :param downloader_func_kwargs: other keyword arguments for ``downloader_func``
    :param post_process_response_func: a callback function taking response/html
        as first argument. You can put any logic in it. For example, you can
        make it sleep if you detect that you got banned.
    :param post_process_response_func_kwargs: other keyword arguments for
        ``post_process_response_func``
    :param process_item_func_kwargs: other keyword arguments for
        ``ParseResult().process_item(**process_item_func_kwargs)``
    :param logger:
    :param sleep_time: default 0, wait time before making each request.
    """"""
    # prepare arguments
    get_unfinished_kwargs = prepare_kwargs(get_unfinished_kwargs)
    parser_func_kwargs = prepare_kwargs(parser_func_kwargs)
    build_url_func_kwargs = prepare_kwargs(build_url_func_kwargs)
    downloader_func_kwargs = prepare_kwargs(downloader_func_kwargs)
    post_process_response_func_kwargs = prepare_kwargs(
        post_process_response_func_kwargs)
    process_item_func_kwargs = prepare_kwargs(process_item_func_kwargs)

    if post_process_response_func is None:
        def post_process_response_func(response, **kwargs):
            pass

    if not isinstance(logger, SpiderLogger):
        raise TypeError

    if sleep_time is None:
        sleep_time = 0

    # do the real job
    query_set = parent_class.get_all_unfinished(**get_unfinished_kwargs)
    if get_unfinished_limit is not None:
        query_set = query_set.limit(get_unfinished_limit)
    todo = list(query_set)
    logger.log_todo_volumn(todo)

    for parent_instance in todo:
        url = parent_instance.build_url(**build_url_func_kwargs)
        logger.log_to_crawl_url(url)

        logger.log_sleeper(sleep_time)
        time.sleep(sleep_time)

        try:
            response_or_html = downloader_func(url, **downloader_func_kwargs)
            if isinstance(response_or_html, string_types):
                parser_func_kwargs[""html""] = response_or_html
            else:
                parser_func_kwargs[""response""] = response_or_html
            post_process_response_func(
                response_or_html, **post_process_response_func_kwargs)
        except Exception as e:
            logger.log_error(e)
            continue

        try:
            parse_result = parser_func(
                parent=parent_instance,
                **parser_func_kwargs
            )
            parse_result.process_item(**process_item_func_kwargs)
            logger.log_status(parse_result)
        except Exception as e:
            logger.log_error(e)
            continue"
3806,"def parse_connection_string_psycopg2(connection_string):
    """"""
    parses psycopg2 consumable connection string
    :param connection_string:
    :return: return dictionary with connection string parts
    """"""
    conn_prepared = {}
    conn_parsed = urlparse(connection_string)
    if not conn_parsed.hostname:
        _re_dbstr = re.compile(r'\bhost=(?P<host>[0-9a-zA-Z_.!@#$%^&*()~]+)|'
                               r'dbname=(?P<dbname>[0-9a-zA-Z_.!@#$%^&*()~]+)|'
                               r'port=(?P<port>[0-9a-zA-Z_.!@#$%^&*()~]+)|'
                               r'user=(?P<user>[0-9a-zA-Z_.!@#$%^&*()~]+)|'
                               r'password=(?P<password>[0-9a-zA-Z_.!@#$%^&*()~]+)\b', re.IGNORECASE)
        for match in _re_dbstr.finditer(connection_string):
            match_dict = match.groupdict()
            if match_dict['host']:
                conn_prepared['host'] = match_dict['host']
            if match_dict['port']:
                conn_prepared['port'] = match_dict['port']
            if match_dict['dbname']:
                conn_prepared['dbname'] = match_dict['dbname']
            if match_dict['user']:
                conn_prepared['user'] = match_dict['user']
            if match_dict['password']:
                conn_prepared['password'] = match_dict['password']
    else:
        conn_prepared = {
            'host': conn_parsed.hostname,
            'port': conn_parsed.port,
            'dbname': conn_parsed.path,
            'user': conn_parsed.username,
            'password': conn_parsed.password
        }

    return conn_prepared"
3807,"def get_pgpm_db_version(cls, cur, schema_name='_pgpm'):
        """"""
        returns current version of pgpm schema
        :return: tuple of major, minor and patch components of version
        """"""
        cls.set_search_path(cur, schema_name)
        cur.execute(""SELECT _find_schema('{0}', '{1}')""
                    .format(schema_name, 'x'))
        # TODO: make it work with the way it's written below. currently throws error as func returns record
        # without column list
        # cur.callproc('_find_schema', [schema_name, 'x'])
        pgpm_v_ext = tuple(cur.fetchone()[0][1:-1].split(','))

        return pgpm_v_ext[2], pgpm_v_ext[3], pgpm_v_ext[4]"
3808,"def create_db_schema(cls, cur, schema_name):
        """"""
        Create Postgres schema script and execute it on cursor
        """"""
        create_schema_script = ""CREATE SCHEMA {0} ;\n"".format(schema_name)
        cur.execute(create_schema_script)"
3809,"def grant_usage_privileges(cls, cur, schema_name, roles):
        """"""
        Sets search path
        """"""
        cur.execute('GRANT USAGE ON SCHEMA {0} TO {1};'
                    'GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA {0} TO {1};'
                    .format(schema_name, roles))"
3810,"def grant_usage_install_privileges(cls, cur, schema_name, roles):
        """"""
        Sets search path
        """"""
        cur.execute('GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA {0} TO {1};'
                    'GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA {0} TO {1};'
                    'GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA {0} TO {1};'
                    .format(schema_name, roles))"
3811,"def grant_default_usage_install_privileges(cls, cur, schema_name, roles):
        """"""
        Sets search path
        """"""
        cur.execute('ALTER DEFAULT PRIVILEGES IN SCHEMA {0} '
                    'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO {1};'
                    'ALTER DEFAULT PRIVILEGES IN SCHEMA {0} GRANT EXECUTE ON FUNCTIONS TO {1};'
                    'ALTER DEFAULT PRIVILEGES IN SCHEMA {0} '
                    'GRANT USAGE, SELECT ON SEQUENCES TO {1};'
                    .format(schema_name, roles))"
3812,"def revoke_all(cls, cur, schema_name, roles):
        """"""
        Revoke all privileges from schema, tables, sequences and functions for a specific role
        """"""
        cur.execute('REVOKE ALL ON SCHEMA {0} FROM {1};'
                    'REVOKE ALL ON ALL TABLES IN SCHEMA {0} FROM {1};'
                    'REVOKE ALL ON ALL SEQUENCES IN SCHEMA {0} FROM {1};'
                    'REVOKE ALL ON ALL FUNCTIONS IN SCHEMA {0} FROM {1};'.format(schema_name, roles))"
3813,"def schema_exists(cls, cur, schema_name):
        """"""
        Check if schema exists
        """"""
        cur.execute(""SELECT EXISTS (SELECT schema_name FROM information_schema.schemata WHERE schema_name = '{0}');""
                    .format(schema_name))
        return cur.fetchone()[0]"
3814,"def pandas(self):
        """"""Return a Pandas dataframe.""""""
        if self._pandas is None:
            self._pandas = pd.DataFrame().from_records(self.list_of_dicts)
        return self._pandas"
3815,"def translate(self, dialect):
        """"""Return a copy of this ResultSet in a different dialect.""""""
        new_resultset = copy(self)
        new_resultset.dialect = dialect

        for result in new_resultset:
            for dimensionvalue in result.dimensionvalues:
                dimensionvalue.value = dimensionvalue.translate(dialect)
        return new_resultset"
3816,"def append(self, val):
        """"""Connect any new results to the resultset.

        This is where all the heavy lifting is done for creating results:
         - We add a datatype here, so that each result can handle
        validation etc independently. This is so that scraper authors
        don't need to worry about creating and passing around datatype objects.
         - As the scraper author yields result objects, we append them to
        a resultset.
         - This is also where we normalize dialects.
        """"""
        val.resultset = self
        val.dataset = self.dataset

        # Check result dimensions against available dimensions for this dataset
        if val.dataset:
            dataset_dimensions = self.dataset.dimensions
            for k, v in val.raw_dimensions.items():
                if k not in dataset_dimensions:
                    d = Dimension(k)
                else:
                    d = dataset_dimensions[k]

                # Normalize if we have a datatype and a foreign dialect
                normalized_value = unicode(v)
                if d.dialect and d.datatype:
                    if d.dialect in d.datatype.dialects:
                        for av in d.allowed_values:
                            # Not all allowed_value have all dialects
                            if unicode(v) in av.dialects.get(d.dialect, []):
                                normalized_value = av.value
                                # Use first match
                                # We do not support multiple matches
                                # This is by design.
                                break

                # Create DimensionValue object
                if isinstance(v, DimensionValue):
                    dim = v
                    v.value = normalized_value
                else:
                    if k in dataset_dimensions:
                        dim = DimensionValue(normalized_value, d)
                    else:
                        dim = DimensionValue(normalized_value, Dimension())

                val.dimensionvalues.append(dim)

            # Add last list of dimension values to the ResultSet
            # They will usually be the same for each result
            self.dimensionvalues = val.dimensionvalues

        super(ResultSet, self).append(val)"
3817,"def tuple(self):
        """""" Tuple conversion to (value, dimensions), e.g.:
         (123, {dimension_1: ""foo"", dimension_2: ""bar""})
        """"""
        return (self.value, {dv.id: dv.value for dv in self.dimensionvalues})"
3818,"def allowed_values(self):
        """"""Return a list of allowed values.""""""
        if self._allowed_values is None:
            self._allowed_values = ValueList()
            for val in self.scraper._fetch_allowed_values(self):
                if isinstance(val, DimensionValue):
                    self._allowed_values.append(val)
                else:
                    self._allowed_values.append(DimensionValue(val,
                                                               Dimension()))
        return self._allowed_values"
3819,"def append(self, val):
        """"""Connect any new items to the scraper.""""""
        val.scraper = self.scraper
        val._collection_path = copy(self.collection._collection_path)
        val._collection_path.append(val)
        super(ItemList, self).append(val)"
3820,"def _move_here(self):
        """"""Move the cursor to this item.""""""
        cu = self.scraper.current_item
        # Already here?
        if self is cu:
            return
        # A child?
        if cu.items and self in cu.items:
            self.scraper.move_to(self)
            return
        # A parent?
        if self is cu.parent:
            self.scraper.move_up()
        # A sibling?
        if self.parent and self in self.parent.items:
            self.scraper.move_up()
            self.scraper.move_to(self)
            return
        # Last resort: Move to top and all the way down again
        self.scraper.move_to_top()
        for step in self.path:
            self.scraper.move_to(step)"
3821,"def items(self):
        """"""ItemList of children.""""""
        if self.scraper.current_item is not self:
            self._move_here()

        if self._items is None:
            self._items = ItemList()
            self._items.scraper = self.scraper
            self._items.collection = self
            for i in self.scraper._fetch_itemslist(self):
                i.parent = self
                if i.type == TYPE_DATASET and i.dialect is None:
                    i.dialect = self.scraper.dialect
                self._items.append(i)
        return self._items"
3822,"def _hash(self):
        """"""Return a hash for the current query.

        This hash is _not_ a unique representation of the dataset!
        """"""
        dump = dumps(self.query, sort_keys=True)
        if isinstance(dump, str):
            dump = dump.encode('utf-8')
        return md5(dump).hexdigest()"
3823,"def fetch_next(self, query=None, **kwargs):
        """"""Generator to yield data one row at a time.
        Yields a Result, not the entire ResultSet. The containing ResultSet
        can be accessed through `Result.resultset`, but be careful not to
        manipulate the ResultSet until it is populated (when this generator
        is empty), or you may see unexpected results.
        """"""
        if query:
            self.query = query

        hash_ = self._hash
        if hash_ in self._data:
            for result in self._data[hash_]:
                yield result

        if self.scraper.current_item is not self:
            self._move_here()

        self._data[hash_] = ResultSet()
        self._data[hash_].dialect = self.dialect
        self._data[hash_].dataset = self
        for result in self.scraper._fetch_data(self,
                                               query=self.query,
                                               **kwargs):
            self._data[hash_].append(result)
            yield result"
3824,"def dimensions(self):
        """"""Available dimensions, if defined.""""""
        # First of all: Select this dataset
        if self.scraper.current_item is not self:
            self._move_here()

        if self._dimensions is None:
            self._dimensions = DimensionList()
            for d in self.scraper._fetch_dimensions(self):
                d.dataset = self
                d.scraper = self.scraper
                self._dimensions.append(d)
        return self._dimensions"
3825,"def shape(self):
        """"""Compute the shape of the dataset as (rows, cols).""""""
        if not self.data:
            return (0, 0)
        return (len(self.data), len(self.dimensions))"
3826,"def on(cls, hook):
        """"""Hook decorator.""""""
        def decorator(function_):
            cls._hooks[hook].append(function_)
            return function_
        return decorator"
3827,"def move_to_top(self):
        """"""Move to root item.""""""
        self.current_item = self.root
        for f in self._hooks[""top""]:
            f(self)
        return self"
3828,"def move_up(self):
        """"""Move up one level in the hierarchy, unless already on top.""""""
        if self.current_item.parent is not None:
            self.current_item = self.current_item.parent

        for f in self._hooks[""up""]:
            f(self)
        if self.current_item is self.root:
            for f in self._hooks[""top""]:
                f(self)
        return self"
3829,"def move_to(self, id_):
        """"""Select a child item by id (str), reference or index.""""""
        if self.items:
            try:
                self.current_item = self.items[id_]
            except (StopIteration, IndexError, NoSuchItem):
                raise NoSuchItem
            for f in self._hooks[""select""]:
                f(self, id_)
        return self"
3830,"def descendants(self):
        """"""Recursively return every dataset below current item.""""""
        for i in self.current_item.items:
            self.move_to(i)
            if i.type == TYPE_COLLECTION:
                for c in self.children:
                    yield c
            else:
                yield i
            self.move_up()"
3831,"def children(self):
        """"""Former, misleading name for descendants.""""""
        from warnings import warn
        warn(""Deprecated. Use Scraper.descendants."", DeprecationWarning)
        for descendant in self.descendants:
            yield descendant"
3832,"def make_python_name(s, default=None, number_prefix='N',encoding=""utf-8""):
    """"""Returns a unicode string that can be used as a legal python identifier.

    :Arguments:
      *s*
         string
      *default*
         use *default* if *s* is ``None``
      *number_prefix*
         string to prepend if *s* starts with a number
    """"""
    if s in ('', None):
        s = default
    s = str(s)
    s = re.sub(""[^a-zA-Z0-9_]"", ""_"", s)
    if not re.match('\d', s) is None:
        s = number_prefix+s
    return unicode(s, encoding)"
3833,"def recarray(self):
        """"""Returns data as :class:`numpy.recarray`.""""""
        return numpy.rec.fromrecords(self.records, names=self.names)"
3834,"def main(arguments=None):
    """"""
    The main function used when ``yaml_to_database.py`` when installed as a cl tool
    """"""

    # setup the command-line util settings
    su = tools(
        arguments=arguments,
        docString=__doc__,
        logLevel=""WARNING"",
        options_first=False,
        projectName=False
    )
    arguments, settings, log, dbConn = su.setup()

    # unpack remaining cl arguments using `exec` to setup the variable names
    # automatically
    for arg, val in arguments.iteritems():
        if arg[0] == ""-"":
            varname = arg.replace(""-"", """") + ""Flag""
        else:
            varname = arg.replace(""<"", """").replace("">"", """")
        if isinstance(val, str) or isinstance(val, unicode):
            exec(varname + "" = '%s'"" % (val,))
        else:
            exec(varname + "" = %s"" % (val,))
        if arg == ""--dbConn"":
            dbConn = val
        log.debug('%s = %s' % (varname, val,))

    if os.path.isfile(pathToYaml):
        from fundamentals.mysql import yaml_to_database
        # PARSE YAML FILE CONTENTS AND ADD TO DATABASE
        yaml2db = yaml_to_database(
            log=log,
            settings=settings,
            dbConn=dbConn
        )
        yaml2db.add_yaml_file_content_to_database(
            filepath=pathToYaml,
            deleteFile=deleteFlag
        )
        basename = os.path.basename(pathToYaml)
        print ""Content of %(basename)s added to database"" % locals()

    else:
        from fundamentals.mysql import yaml_to_database
        yaml2db = yaml_to_database(
            log=log,
            settings=settings,
            dbConn=dbConn,
            pathToInputDir=pathToYaml,
            deleteFiles=deleteFlag
        )
        yaml2db.ingest()
        print ""Content of %(pathToYaml)s directory added to database"" % locals()

    return"
3835,"def ingest(self):
        """"""
        *ingest the contents of the directory of yaml files into a database*

        **Return:**
            - None

        **Usage:**

            To import an entire directory of yaml files into a database, use the following:

        .. code-block:: python 

            from fundamentals.mysql import yaml_to_database
            yaml2db = yaml_to_database(
                log=log,
                settings=settings,
                dbConn=dbConn,
                pathToInputDir=""/path/to/yaml/directory"",
                deleteFiles=False
            ) 
            yaml2db.ingest() 
        """"""
        self.log.debug('starting the ``ingest`` method')

        for d in os.listdir(self.pathToInputDir):
            if os.path.isfile(os.path.join(self.pathToInputDir, d)) and ""yaml"" in d.lower():
                self.add_yaml_file_content_to_database(
                    filepath=os.path.join(self.pathToInputDir, d),
                    deleteFile=self.deleteFiles
                )

        self.log.debug('completed the ``ingest`` method')
        return None"
3836,"def add_yaml_file_content_to_database(
        self,
        filepath,
        deleteFile=False
    ):
        """"""*given a file to a yaml file, add yaml file content to database*

        **Key Arguments:**
            - ``filepath`` -- the path to the yaml file
            - ``deleteFile`` -- delete the yaml file when its content has been added to the database. Default *False*

        **Return:**
            - None

        **Usage:**

            To parse and import the contents of a single yaml file into the database, use the following:

            .. code-block:: python 

                from fundamentals.mysql import yaml_to_database
                # PARSE YAML FILE CONTENTS AND ADD TO DATABASE
                yaml2db = yaml_to_database(
                    log=log,
                    settings=settings,
                    dbConn=dbConn
                ) 
                yaml2db.add_yaml_file_content_to_database(
                    filepath=${1:""/path/to/file.yaml""},
                    deleteFile=True
                )
        """"""
        self.log.debug(
            'completed the ````add_yaml_file_content_to_database`` method')

        import codecs
        try:
            self.log.debug(""attempting to open the file %s"" % (filepath,))
            readFile = codecs.open(filepath, encoding='utf-8', mode='r')
            thisData = readFile.read()
            readFile.close()
        except IOError, e:
            message = 'could not open the file %s' % (filepath,)
            self.log.critical(message)
            raise IOError(message)
        readFile.close()

        matchObject = re.finditer(
            r'(^|\n)(?P<key>[^\:]*)\:\s(?P<value>.*?)(\n|$)',
            thisData,
            flags=re.M | re.S  # re.S
        )

        yamlContent = {}
        for match in matchObject:
            if match.group(""value"")[0] == '""' and match.group(""value"")[-1] == '""':
                v = match.group(""value"")[1:-1]
            elif match.group(""value"")[0] == ""'"" and match.group(""value"")[-1] == ""'"":
                v = match.group(""value"")[1:-1]
            else:
                v = match.group(""value"")
            yamlContent[match.group(""key"")] = v

        if ""table"" not in yamlContent:
            self.log.warning(
                'A table value is need in the yaml content to indicate which database table to add the content to: %(filepath)s' % locals())
            return None

        # NOTE THERE MAY BE MORE THAN ONE DATABASE TABLE
        dbTablesTmp = yamlContent[""table""].split("","")
        del yamlContent[""table""]
        dbTables = []
        dbTables[:] = [d.strip() for d in dbTablesTmp]

        # UNSHORTEN URL
        try:
            r = requests.head(yamlContent[""url""], allow_redirects=True)
            yamlContent[""url""] = r.url
        except:
            pass

        yamlContent[""original_yaml_path""] = filepath

        if ""url"" in yamlContent:
            uniqueKeyList = [""url""]
        else:
            uniqueKeyList = []

        for t in dbTables:
            convert_dictionary_to_mysql_table(
                dbConn=self.dbConn,
                log=self.log,
                dictionary=yamlContent,
                dbTableName=t,
                uniqueKeyList=uniqueKeyList,
                dateModified=True,
                returnInsertOnly=False,
                replace=True
            )
        if deleteFile:
            os.remove(filepath)

        self.log.debug(
            'completed the ``add_yaml_file_content_to_database`` method')
        return None"
3837,"def data_type(self, data_type):
        """"""Sets the data_type of this Option.


        :param data_type: The data_type of this Option.
        :type: str
        """"""
        allowed_values = [""string"", ""number"", ""date"", ""color""]
        if data_type is not None and data_type not in allowed_values:
            raise ValueError(
                ""Invalid value for `data_type` ({0}), must be one of {1}""
                .format(data_type, allowed_values)
            )

        self._data_type = data_type"
3838,"def create_option(cls, option, **kwargs):
        """"""Create Option

        Create a new Option
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_option(option, async=True)
        >>> result = thread.get()

        :param async bool
        :param Option option: Attributes of option to create (required)
        :return: Option
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_option_with_http_info(option, **kwargs)
        else:
            (data) = cls._create_option_with_http_info(option, **kwargs)
            return data"
3839,"def delete_option_by_id(cls, option_id, **kwargs):
        """"""Delete Option

        Delete an instance of Option by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_option_by_id(option_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str option_id: ID of option to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_option_by_id_with_http_info(option_id, **kwargs)
        else:
            (data) = cls._delete_option_by_id_with_http_info(option_id, **kwargs)
            return data"
3840,"def get_option_by_id(cls, option_id, **kwargs):
        """"""Find Option

        Return single instance of Option by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_option_by_id(option_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str option_id: ID of option to return (required)
        :return: Option
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_option_by_id_with_http_info(option_id, **kwargs)
        else:
            (data) = cls._get_option_by_id_with_http_info(option_id, **kwargs)
            return data"
3841,"def list_all_options(cls, **kwargs):
        """"""List Options

        Return a list of Options
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_options(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[Option]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_options_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_options_with_http_info(**kwargs)
            return data"
3842,"def replace_option_by_id(cls, option_id, option, **kwargs):
        """"""Replace Option

        Replace all attributes of Option
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_option_by_id(option_id, option, async=True)
        >>> result = thread.get()

        :param async bool
        :param str option_id: ID of option to replace (required)
        :param Option option: Attributes of option to replace (required)
        :return: Option
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_option_by_id_with_http_info(option_id, option, **kwargs)
        else:
            (data) = cls._replace_option_by_id_with_http_info(option_id, option, **kwargs)
            return data"
3843,"def update_option_by_id(cls, option_id, option, **kwargs):
        """"""Update Option

        Update attributes of Option
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_option_by_id(option_id, option, async=True)
        >>> result = thread.get()

        :param async bool
        :param str option_id: ID of option to update. (required)
        :param Option option: Attributes of option to update. (required)
        :return: Option
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_option_by_id_with_http_info(option_id, option, **kwargs)
        else:
            (data) = cls._update_option_by_id_with_http_info(option_id, option, **kwargs)
            return data"
3844,"def get_callable_signature_as_string(the_callable):
    """"""Return a string representing a callable.

    It is executed as if it would have been declared on the prompt.

    >>> def foo(arg1, arg2, arg3='val1', arg4='val2', *args, **argd):
    ...     pass
    >>> get_callable_signature_as_string(foo)
    def foo(arg1, arg2, arg3='val1', arg4='val2', *args, **argd)

    :param the_callable: the callable to be analyzed.
    :type the_callable: function/callable.
    :return: the signature.
    """"""
    args, varargs, varkw, defaults = inspect.getargspec(the_callable)
    tmp_args = list(args)
    args_dict = {}
    if defaults:
        defaults = list(defaults)
    else:
        defaults = []
    while defaults:
        args_dict[tmp_args.pop()] = defaults.pop()

    while tmp_args:
        args_dict[tmp_args.pop()] = None

    args_list = []
    for arg in args:
        if args_dict[arg] is not None:
            args_list.append(""%s=%s"" % (arg, repr(args_dict[arg])))
        else:
            args_list.append(arg)

    if varargs:
        args_list.append(""*%s"" % varargs)

    if varkw:
        args_list.append(""**%s"" % varkw)

    args_string = ', '.join(args_list)

    return ""def %s(%s)"" % (the_callable.__name__, args_string)"
3845,"def get_callable_documentation(the_callable):
    """"""Return a string with the callable signature and its docstring.

    :param the_callable: the callable to be analyzed.
    :type the_callable: function/callable.
    :return: the signature.
    """"""
    return wrap_text_in_a_box(
        title=get_callable_signature_as_string(the_callable),
        body=(getattr(the_callable, '__doc__') or 'No documentation').replace(
            '\n', '\n\n'),
        style='ascii_double')"
3846,"def register_extension_class(ext, base, *args, **kwargs):
    """"""Instantiate the given extension class and register as a public attribute of the given base.

    README: The expected protocol here is to instantiate the given extension and pass the base
    object as the first positional argument, then unpack args and kwargs as additional arguments to
    the extension's constructor.
    """"""
    ext_instance = ext.plugin(base, *args, **kwargs)
    setattr(base, ext.name.lstrip('_'), ext_instance)"
3847,"def register_extension_method(ext, base, *args, **kwargs):
    """"""Register the given extension method as a public attribute of the given base.

    README: The expected protocol here is that the given extension method is an unbound function.
    It will be bound to the specified base as a method, and then set as a public attribute of that
    base.
    """"""
    bound_method = create_bound_method(ext.plugin, base)
    setattr(base, ext.name.lstrip('_'), bound_method)"
3848,"def token_auto_auth(func):
    """"""Wrap class methods with automatic token re-authentication.

    This wrapper will detect authentication failures coming from its wrapped method. When one is
    caught, it will request a new token, and simply replay the original request.

    The one constraint that this wrapper has is that the wrapped method's class must have the
    :py:class:`objectrocket.client.Client` object embedded in it as the property ``_client``. Such
    is the design of all current client operations layers.
    """"""

    @functools.wraps(func)
    def wrapper(self, *args, **kwargs):
        try:
            response = func(self, *args, **kwargs)

        # If auth failure occurs, attempt to re-authenticate and replay once at most.
        except errors.AuthFailure:

            # Request to have authentication refreshed.
            self._client.auth._refresh()

            # Replay original request.
            response = func(self, *args, **kwargs)

        return response

    # TODO(TheDodd): match func call signature and docs.
    return wrapper"
3849,"def check_auth(args, role=None):
    """"""Check the user authentication.""""""
    users = boto3.resource(""dynamodb"").Table(os.environ['people'])
    if not (args.get('email', None) and args.get('api_key', None)):
        mesg = ""Invalid request: `email` and `api_key` are required""
        return {'success': False, 'message': mesg}
    user = users.get_item(Key={'email': args.get('email')})
    if 'Item' not in user:
        return {'success': False, 'message': 'User does not exist.'}
    user = user['Item']
    if user['api_key'] != args['api_key']:
        return {'success': False, 'message': 'API key was invalid.'}
    if role:
        if user['role'] not in role:
            mesg = 'User is not authorized to make this change.'
            return {'success': False, 'message': mesg}
    return {'success': True, 'message': None, 'user': user}"
3850,"def lambda_handler(event, context):
    """"""Main handler.""""""
    auth = check_auth(event, role=[""admin""])
    if not auth['success']:
        return auth

    table = boto3.resource(""dynamodb"").Table(os.environ['database'])
    results = table.scan()
    output = {'success': True, 'events': list(), 'eventsCount': 0}
    for item in results.get('Items', list()):
        output['events'].append(item)
    output['eventsCount'] = len(output['events'])
    return output"
3851,"def get_theme_dir():
    """"""
    Returns path to directory containing this package's theme.
    
    This is designed to be used when setting the ``html_theme_path``
    option within Sphinx's ``conf.py`` file.
    """"""
    return os.path.abspath(os.path.join(os.path.dirname(__file__), ""theme""))"
3852,"def create_discount_promotion(cls, discount_promotion, **kwargs):
        """"""Create DiscountPromotion

        Create a new DiscountPromotion
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_discount_promotion(discount_promotion, async=True)
        >>> result = thread.get()

        :param async bool
        :param DiscountPromotion discount_promotion: Attributes of discountPromotion to create (required)
        :return: DiscountPromotion
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_discount_promotion_with_http_info(discount_promotion, **kwargs)
        else:
            (data) = cls._create_discount_promotion_with_http_info(discount_promotion, **kwargs)
            return data"
3853,"def delete_discount_promotion_by_id(cls, discount_promotion_id, **kwargs):
        """"""Delete DiscountPromotion

        Delete an instance of DiscountPromotion by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_discount_promotion_by_id(discount_promotion_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str discount_promotion_id: ID of discountPromotion to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_discount_promotion_by_id_with_http_info(discount_promotion_id, **kwargs)
        else:
            (data) = cls._delete_discount_promotion_by_id_with_http_info(discount_promotion_id, **kwargs)
            return data"
3854,"def get_discount_promotion_by_id(cls, discount_promotion_id, **kwargs):
        """"""Find DiscountPromotion

        Return single instance of DiscountPromotion by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_discount_promotion_by_id(discount_promotion_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str discount_promotion_id: ID of discountPromotion to return (required)
        :return: DiscountPromotion
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_discount_promotion_by_id_with_http_info(discount_promotion_id, **kwargs)
        else:
            (data) = cls._get_discount_promotion_by_id_with_http_info(discount_promotion_id, **kwargs)
            return data"
3855,"def list_all_discount_promotions(cls, **kwargs):
        """"""List DiscountPromotions

        Return a list of DiscountPromotions
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_discount_promotions(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[DiscountPromotion]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_discount_promotions_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_discount_promotions_with_http_info(**kwargs)
            return data"
3856,"def replace_discount_promotion_by_id(cls, discount_promotion_id, discount_promotion, **kwargs):
        """"""Replace DiscountPromotion

        Replace all attributes of DiscountPromotion
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_discount_promotion_by_id(discount_promotion_id, discount_promotion, async=True)
        >>> result = thread.get()

        :param async bool
        :param str discount_promotion_id: ID of discountPromotion to replace (required)
        :param DiscountPromotion discount_promotion: Attributes of discountPromotion to replace (required)
        :return: DiscountPromotion
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_discount_promotion_by_id_with_http_info(discount_promotion_id, discount_promotion, **kwargs)
        else:
            (data) = cls._replace_discount_promotion_by_id_with_http_info(discount_promotion_id, discount_promotion, **kwargs)
            return data"
3857,"def update_discount_promotion_by_id(cls, discount_promotion_id, discount_promotion, **kwargs):
        """"""Update DiscountPromotion

        Update attributes of DiscountPromotion
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_discount_promotion_by_id(discount_promotion_id, discount_promotion, async=True)
        >>> result = thread.get()

        :param async bool
        :param str discount_promotion_id: ID of discountPromotion to update. (required)
        :param DiscountPromotion discount_promotion: Attributes of discountPromotion to update. (required)
        :return: DiscountPromotion
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_discount_promotion_by_id_with_http_info(discount_promotion_id, discount_promotion, **kwargs)
        else:
            (data) = cls._update_discount_promotion_by_id_with_http_info(discount_promotion_id, discount_promotion, **kwargs)
            return data"
3858,"def make_code_readable(s):
    """"""Add newlines at strategic places in code string for printing.

    Args:
        s: str, piece of code. If not str, will attempt to convert to str.

    Returns:
        str
    """"""

    s = s if isinstance(s, str) else str(s)

    MAP = {"","": "",\n"", ""{"": ""{\n "", ""}"": ""\n}""}

    ll = []

    state = ""open""
    flag_single = False
    flag_double = False
    flag_backslash = False
    for ch in s:
        if flag_backslash:
            flag_backslash = False
            continue

        if ch == ""\\"":
            flag_backslash = True
            continue

        if flag_single:
            if ch == ""'"":
                flag_single = False
        elif not flag_double and ch == ""'"":
            flag_single = True

        if flag_double:
            if ch == '""':
                flag_double = False
        elif not flag_single and ch == '""':
            flag_double = True

        if flag_single or flag_double:
            ll.append(ch)
        else:
            ll.append(MAP.get(ch, ch))

    return """".join(ll)"
3859,"def chunk_string(string, length):
    """"""
    Splits a string into fixed-length chunks.

    This function returns a generator, using a generator comprehension. The
    generator returns the string sliced, from 0 + a multiple of the length
    of the chunks, to the length of the chunks + a multiple of the length
    of the chunks.

    Reference: http://stackoverflow.com/questions/18854620
    """"""
    return (string[0 + i:length + i] for i in range(0, len(string), length))"
3860,"def seconds2str(seconds):
    """"""Returns string such as 1h 05m 55s.""""""

    if seconds < 0:
        return ""{0:.3g}s"".format(seconds)
    elif math.isnan(seconds):
        return ""NaN""
    elif math.isinf(seconds):
        return ""Inf""

    m, s = divmod(seconds, 60)
    h, m = divmod(m, 60)
    if h >= 1:
        return ""{0:g}h {1:02g}m {2:.3g}s"".format(h, m, s)
    elif m >= 1:
        return ""{0:02g}m {1:.3g}s"".format(m, s)
    else:
        return ""{0:.3g}s"".format(s)"
3861,"def make_fits_keys_dict(keys):
    """"""
    Returns a dictionary to translate to unique FITS header keys up to 8 characters long

    This is similar to Windows making up 8-character names for filenames that
    are longer than this

    ""The keyword names may be up to 8 characters long and can only contain
    uppercase letters A to Z, the digits 0 to 9, the hyphen, and the underscore
    character."" [1]

    Arguments:
        keys -- list of strings

    Returns:
        dictionary whose keys are the elements in the ""keys"" argument, and whose
        values are made-up uppercase names

    References:
        [1] http://fits.gsfc.nasa.gov/fits_primer.html
    """"""

    key_dict = {}
    new_keys = []
    for key in keys:
        # converts to valid FITS key according to reference [1] above
        fits_key = valid_fits_key(key)
        num_digits = 1
        i = -1
        i_max = 9
        while fits_key in new_keys:
            i += 1
            if i > i_max:
                i = 0
                i_max = i_max * 10 + 9
                num_digits += 1
            fits_key = fits_key[:(8 - num_digits)] + ((""%0{0:d}d"".format(num_digits)) % i)

        key_dict[key] = fits_key
        new_keys.append(fits_key)

    return key_dict"
3862,"def valid_fits_key(key):
    """"""
    Makes valid key for a FITS header

    ""The keyword names may be up to 8 characters long and can only contain
    uppercase letters A to Z, the digits 0 to 9, the hyphen, and the underscore
    character."" (http://fits.gsfc.nasa.gov/fits_primer.html)
    """"""

    ret = re.sub(""[^A-Z0-9\-_]"", """", key.upper())[:8]
    if len(ret) == 0:
        raise RuntimeError(""key '{0!s}' has no valid characters to be a key in a FITS header"".format(key))
    return ret"
3863,"def eval_fieldnames(string_, varname=""fieldnames""):
    """"""Evaluates string_, must evaluate to list of strings. Also converts field names to uppercase""""""
    ff = eval(string_)
    if not isinstance(ff, list):
        raise RuntimeError(""{0!s} must be a list"".format(varname))
    if not all([isinstance(x, str) for x in ff]):
        raise RuntimeError(""{0!s} must be a list of strings"".format(varname))
    ff = [x.upper() for x in ff]
    return ff"
3864,"def module_to_dict(module):
    """"""Creates a dictionary whose keys are module.__all__

    Returns: {""(attribute name)"": attribute, ...}
    """"""

    lot = [(key, module.__getattribute__(key)) for key in module.__all__]
    ret = dict(lot)
    return ret"
3865,"def strip_accents(s):
    """"""
    Strip accents to prepare for slugification.
    """"""
    nfkd = unicodedata.normalize('NFKD', unicode(s))
    return u''.join(ch for ch in nfkd if not unicodedata.combining(ch))"
3866,"def slugify(s):
    """"""
    Converts the given string to a URL slug.
    """"""
    s = strip_accents(s.replace(""'"", '').lower())
    return re.sub('[^a-z0-9]+', ' ', s).strip().replace(' ', '-')"
3867,"def _legacy_status(stat):
    """"""Legacy status method from the 'qsmobile.js' library.

    Pass in the 'val' from &devices or the
    'data' received after calling a specific ID.
    """"""
    # 2d0c00002a0000
    if stat[:2] == '30' or stat[:2] == '47':  # RX1 CT
        ooo = stat[4:5]
        # console.log(""legstat. "" + o);
        if ooo == '0':
            return 0
        if ooo == '8':
            return 100
    if stat == '7e':
        return 0
    if stat == '7f':
        return 100
    if len(stat) == 6:  # old
        try:
            val = int(stat[4:], 16)
        except ValueError:
            val = 0
        hwt = stat[:2]
        if hwt == '01':  # old dim
            return round(((125 - val) / 125) * 100)
        if hwt == '02':  # old rel
            return 100 if val == 127 else 0
        if hwt == '28':  # LED DIM
            if stat[2:4] == '01':
                if stat[4:] == '78':
                    return 0
            return round(((120 - val) / 120) * 100)

    # Additional decodes not part of qsmobile.js
    if stat.upper().find('ON') >= 0:  # Relay
        return 100
    if (not stat) or stat.upper().find('OFF') >= 0:
        return 0
    if stat.endswith('%'):  # New style dimmers
        if stat[:-1].isdigit:
            return int(stat[:-1])
    _LOGGER.debug(""val='%s' used a -1 fallback in legacy_status"", stat)
    return -1"
3868,"def decode_qwikcord(packet, channel=1):
    """"""Extract the qwikcord current measurements from val (CTavg, CTsum).""""""
    val = str(packet.get('val', ''))
    if len(val) != 16:
        return None
    if channel == 1:
        return int(val[6:12], 16)  # CTavg
    return int(val[12:], 16)"
3869,"def decode_door(packet, channel=1):
    """"""Decode a door sensor.""""""
    val = str(packet.get(QSDATA, ''))
    if len(val) == 6 and val.startswith('46') and channel == 1:
        return val[-1] == '0'
    return None"
3870,"def decode_imod(packet, channel=1):
    """"""Decode an 4 channel imod. May support 6 channels.""""""
    val = str(packet.get(QSDATA, ''))
    if len(val) == 8 and val.startswith('4e'):
        try:
            _map = ((5, 1), (5, 2), (5, 4), (4, 1), (5, 1), (5, 2))[
                channel - 1]
            return (int(val[_map[0]], 16) & _map[1]) == 0
        except IndexError:
            return None
    return None"
3871,"def decode_pir(packet, channel=1):
    """"""Decode a PIR.""""""
    val = str(packet.get(QSDATA, ''))
    if len(val) == 8 and val.startswith('0f') and channel == 1:
        return int(val[-4:], 16) > 0
    return None"
3872,"def decode_temperature(packet, channel=1):
    """"""Decode the temperature.""""""
    val = str(packet.get(QSDATA, ''))
    if len(val) == 12 and val.startswith('34') and channel == 1:
        temperature = int(val[-4:], 16)
        return round(float((-46.85 + (175.72 * (temperature / pow(2, 16))))))
    return None"
3873,"def decode_humidity(packet, channel=1):
    """"""Decode the humidity.""""""
    val = str(packet.get(QSDATA, ''))
    if len(val) == 12 and val.startswith('34') and channel == 1:
        humidity = int(val[4:-4], 16)
        return round(float(-6 + (125 * (humidity / pow(2, 16)))))
    return None"
3874,"def set_value(self, qsid, new):
        # Set value & encode new to be passed to QSUSB
        """"""Set a value.""""""
        try:
            dev = self[qsid]
        except KeyError:
            raise KeyError(""Device {} not found"".format(qsid))
        if new < 0:
            new = 0
        if new == dev.value:
            return

        if dev.is_dimmer:
            new = _MAX if new > (_MAX * .9) else new
        else:  # QSType.relay and any other
            new = _MAX if new > 0 else 0

        def success():
            """"""Success closure to update value.""""""
            self[qsid].value = new
            _LOGGER.debug(""set success %s=%s"", qsid, new)
            self._cb_value_changed(self, qsid, new)

        newqs = round(math.pow(round(new / _MAX * 100), 1 / self.dim_adj))
        _LOGGER.debug(""%s hass=%s --> %s"", qsid, new, newqs)
        self._cb_set_qsvalue(qsid, newqs, success)"
3875,"def update_devices(self, devices):
        """"""Update values from response of URL_DEVICES, callback if changed.""""""
        for qspacket in devices:
            try:
                qsid = qspacket[QS_ID]
            except KeyError:
                _LOGGER.debug(""Device without ID: %s"", qspacket)
                continue

            if qsid not in self:
                self[qsid] = QSDev(data=qspacket)

            dev = self[qsid]
            dev.data = qspacket
            # Decode value from QSUSB
            newqs = _legacy_status(qspacket[QS_VALUE])
            if dev.is_dimmer:
                # Adjust dimmer exponentially to get a smoother effect
                newqs = min(round(math.pow(newqs, self.dim_adj)), 100)
            newin = round(newqs * _MAX / 100)
            if abs(dev.value - newin) > 1:  # Significant change
                _LOGGER.debug(""%s qs=%s  -->  %s"", qsid, newqs, newin)
                dev.value = newin
                self._cb_value_changed(self, qsid, newin)"
3876,"def geist_replay(wrapped, instance, args, kwargs):
    """"""Wraps a test of other function and injects a Geist GUI which will
    enable replay (set environment variable GEIST_REPLAY_MODE to 'record' to
    active record mode.""""""
    path_parts = []
    file_parts = []

    if hasattr(wrapped, '__module__'):
        module = wrapped.__module__
        module_file = sys.modules[module].__file__
        root, _file = os.path.split(module_file)
        path_parts.append(root)
        _file, _ = os.path.splitext(_file)
        file_parts.append(_file)
    if hasattr(wrapped, '__objclass__'):
        file_parts.append(wrapped.__objclass__.__name__)
    elif hasattr(wrapped, '__self__'):
        file_parts.append(wrapped.__self__.__class__.__name__)
    file_parts.append(wrapped.__name__ + '.log')
    path_parts.append('_'.join(file_parts))
    filename = os.path.join(*path_parts)

    if is_in_record_mode():
        platform_backend = get_platform_backend()
        backend = RecordingBackend(
            source_backend=platform_backend,
            recording_filename=filename
        )
    else:
        backend = PlaybackBackend(
            recording_filename=filename
        )
    gui = GUI(backend)
    return wrapped(gui, *args, **kwargs)"
3877,"def reverse_cyk_transforms(root):
        # type: (Nonterminal) -> Nonterminal
        """"""
        Reverse transformation made to grammar before CYK.
        Performs following steps:
        - transform from chomsky normal form
        - restore unit rules
        - restore epsilon rules
        :param root: Root node of the parsed tree.
        :return: Restored parsed tree.
        """"""
        root = InverseContextFree.transform_from_chomsky_normal_form(root)
        root = InverseContextFree.unit_rules_restore(root)
        root = InverseContextFree.epsilon_rules_restore(root)
        return root"
3878,"def _geom_solve_p_from_mu(mu, b):
    """"""
    For the geom_uptrunc, given mu and b, return p.
    Ref: Harte 2011, Oxford U Press. Eq. 7.50.
    """"""

    def p_eq(x, mu, b):
        x, mu, b = Decimal(x), Decimal(mu), Decimal(b)
        return ( (x / (1 - x)) - ((b + 1) / (x**-b - 1)) - mu )

    # x here is the param raised to the k_agg power, or 1 - p
    return 1 - optim.brentq(p_eq, 1e-16, 100, args=(mu, b), disp=True)"
3879,"def _nbinom_ztrunc_p(mu, k_agg):
        """""" Calculates p parameter for truncated negative binomial

        Function given in Sampford 1955, equation 4

        Note that omega = 1 / 1 + p in Sampford
        """"""

        p_eq = lambda p, mu, k_agg: (k_agg * p) / (1 - (1 + p)**-k_agg) - mu

        # The upper bound needs to be large. p will increase with increasing mu
        # and decreasing k_agg
        p = optim.brentq(p_eq, 1e-10, 1e10, args=(mu, k_agg))
        return p"
3880,"def _ln_choose(n, k_agg):
    '''
    log binomial coefficient with extended gamma factorials. n and k_agg may be
    int or array - if both array, must be the same length.

    '''
    gammaln = special.gammaln
    return gammaln(n + 1) - (gammaln(k_agg + 1) + gammaln(n - k_agg + 1))"
3881,"def _solve_k_from_mu(data, k_array, nll, *args):
    """"""
    For given args, return k_agg from searching some k_range.

    Parameters
    ----------
    data : array
    k_range : array
    nll : function

    args :

    Returns
    --------
    :float
        Minimum k_agg

    """"""
    # TODO: See if a root finder like fminbound would work with Decimal used in
    # logpmf method (will this work with arrays?)

    nll_array = np.zeros(len(k_array))

    for i in range(len(k_array)):
        nll_array[i] = nll(data, k_array[i], *args)

    min_nll_idx = np.argmin(nll_array)

    return k_array[min_nll_idx]"
3882,"def _trunc_logser_solver(bins, b):
    """"""
    Given bins (S) and b (N) solve for MLE of truncated logseries
    parameter p

    Parameters
    -----------
    bins : float
        Number of bins. Considered S in an ecological context
    b : float
        Upper truncation of distribution. Considered N in an ecological context

    Returns
    -------
    : float
        MLE estimate of p

    Notes
    ------
    Adapted from Ethan White's macroecology_tools
    """"""

    if bins == b:
        p = 0

    else:
        BOUNDS = [0, 1]
        DIST_FROM_BOUND = 10 ** -15
        m = np.array(np.arange(1, np.int(b) + 1))
        y = lambda x: np.sum(x ** m / b * bins) - np.sum((x ** m) / m)
        p = optim.bisect(y, BOUNDS[0] + DIST_FROM_BOUND,
                   min((sys.float_info[0] / bins) ** (1 / b), 2),
                   xtol=1.490116e-08, maxiter=1000)
    return p"
3883,"def _expon_solve_lam_from_mu(mu, b):
    """"""
    For the expon_uptrunc, given mu and b, return lam.
    Similar to geom_uptrunc
    """"""

    def lam_eq(lam, mu, b):
        # Small offset added to denominator to avoid 0/0 erors
        lam, mu, b = Decimal(lam), Decimal(mu), Decimal(b)
        return ( (1 - (lam*b + 1) * np.exp(-lam*b)) /
                 (lam - lam * np.exp(-lam*b) + Decimal(1e-32)) - mu )

    return optim.brentq(lam_eq, -100, 100, args=(mu, b), disp=True)"
3884,"def _make_rank(dist_obj, n, mu, sigma, crit=0.5, upper=10000, xtol=1):
    """"""
    Make rank distribution using both ppf and brute force.

    Setting crit = 1 is equivalent to just using the ppf

    Parameters
    ----------
    {0}

    """"""
    qs = (np.arange(1, n + 1) - 0.5) / n
    rank = np.empty(len(qs))

    brute_ppf = lambda val, prob: prob - dist_obj.cdf(val, mu, sigma)

    qs_less = qs <= crit
    ind = np.sum(qs_less)

    # Use ppf if qs are below crit
    rank[qs_less] = dist_obj.ppf(qs[qs_less], mu, sigma)

    # Use brute force if they are above
    for i, tq in enumerate(qs[~qs_less]):

        j = ind + i
        try:
            # TODO: Use an adaptable lower bound to increase speed
            rank[j] = np.abs(np.ceil(optim.brentq(brute_ppf, -1, upper,
                                        args=(tq,), xtol=xtol)))

        except ValueError:

            # If it is above the upper bound set all remaining values
            # to the previous value
            rank[j:] = np.repeat(rank[j - 1], len(rank[j:]))
            break

    return rank"
3885,"def _mean_var(vals, pmf):
    """"""
    Calculates the mean and variance from vals and pmf

    Parameters
    ----------
    vals : ndarray
        Value range for a distribution
    pmf : ndarray
        pmf values corresponding with vals

    Returns
    -------
    : tuple
        (mean, variance)

    """"""

    mean = np.sum(vals * pmf)
    var = np.sum(vals ** 2 * pmf) - mean ** 2
    return mean, var"
3886,"def rank(self, n, *args):
        """"""{0}""""""
        return self.ppf((np.arange(1, n+1) - 0.5) / n, *args)"
3887,"def rvs_alt(self, *args, **kwargs):
        """"""{0}""""""
        l = kwargs.get('l', 1)
        b = kwargs.get('b', 1e5)
        size = kwargs.get('size', 1)

        model_cdf = self.cdf(np.arange(l, b + 1), *args)

        unif_rands = np.random.random(size)
        model_rands = np.array([np.where(tx <= model_cdf)[0][0] + l
                            for tx in unif_rands])

        return model_rands"
3888,"def fit_mle(self, data, b=None):
        """"""%(super)s
        In addition to data, requires ``b``, the upper limit of the
        distribution.
        """"""
        # Take mean of data as MLE of distribution mean, then calculate p
        mu = np.mean(data)
        if not b:
            b = np.sum(data)
        p = _geom_solve_p_from_mu_vect(mu, b)

        # Just return float, not len 1 array
        if len(np.atleast_1d(p)) == 1:
            return float(p), b
        else:
            return p, b"
3889,"def fit_mle(self, data, init_vals=(80, 80)):
        """"""%(super)s
        In addition to data, can take init_vals which allows the user to
        specify initial values for (alpha, theta) during the optimization.

        """"""

        if len(data) > 1:
            mu = np.mean(data)
            var = np.var(data)
            theta0 = var / mu
            alpha0 = mu / theta0
        else:
            alpha0 = init_vals[0]
            theta0 = init_vals[1]

        def mle(params):
            return -np.sum(np.log(self.pmf(data, params[0], params[1])))

        # Bounded fmin?
        alpha, theta = optim.fmin(mle, x0=[alpha0, theta0], disp=0)

        return alpha, theta"
3890,"def fit_mle(self, data, k_array=np.arange(0.1, 100, 0.1)):
        """"""%(super)s

        In addition to data, gives an optional keyword argument k_array
        containing the values to search for k_agg. A brute force search is then
        used to find the parameter k_agg.

        """"""
        # todo: check and mention in docstring biases of mle for k_agg
        data = np.array(data)
        mu = np.mean(data)
        return mu, _solve_k_from_mu(data, k_array, nbinom_nll, mu)"
3891,"def translate_args(self, mu, k_agg, return_p=False):
        """"""%(super)s

        The keyword argument return_p computes the p values used to define the
        the truncated negative binomial
        """"""
        if return_p:
            return nbinom_ztrunc_p(mu, k_agg), k_agg
        else:
            return mu, k_agg"
3892,"def fit_mle(self, data, k_agg0=0.5):
        """"""%(super)s

        In addition to data, gives an optional keyword argument k_agg0 that
        specifies the initial value of k_agg used in the optimization.

        """"""

        mu = np.mean(data)

        def mle(k):

            return -np.sum(np.log(self.pmf(data, mu, k)))

        k = optim.fmin(mle, x0=k_agg0, disp=0)

        return mu, k[0]"
3893,"def fit_mle(self, data, b=None):
        """"""%(super)s
b : float
    The upper bound of the distribution. If None, fixed at sum(data)
        """"""

        data = np.array(data)
        length = len(data)

        if not b:
            b = np.sum(data)

        return _trunc_logser_solver(length, b), b"
3894,"def rank(self, n, mu, sigma, crit=.5, upper=10000, xtol=1):
        """"""%(super)s

Additional Parameters
----------------------
        {0}

        """"""

        return _make_rank(self, n, mu, sigma, crit=crit, upper=upper,
                                                                    xtol=xtol)"
3895,"def fit_mle(self, data, b=None):
        """"""%(super)s

        Additional Parameters
        ----------------------
        b : float
            The upper limit of the distribution
        """"""
        # Take mean of data as MLE of distribution mean, then calculate p
        mu = np.mean(data)
        if not b:
            b = np.sum(data)
        lam = _expon_solve_lam_from_mu_vect(mu, b)

        # Just return float, not len 1 array
        if len(np.atleast_1d(lam)) == 1:
            return float(lam), b
        else:
            return lam, b"
3896,"def fit_mle(self, data, fix_mean=False):
        """"""%(super)s

        Additional Parameters
        ----------------------
        fix_mean : bool
            Default False.  If True, fixes mean before optimizing sigma

        """"""

        if not fix_mean:
            sigma, _, scale = stats.lognorm.fit(data, floc=0)
            return np.log(scale), sigma

        else:
            mean = np.mean(data)

            # MLE fxn to be optmimized
            mle = lambda sigma, x, mean: -1 *\
                                    np.sum(self._pdf_w_mean(x, mean, sigma))

            sigma = optim.fmin(mle, np.array([np.std(np.log(data), ddof=1)]),
                                            args=(data, mean), disp=0)[0]

            return self.translate_args(mean, sigma)"
3897,"def _pdf_w_mean(self, x, mean, sigma):
        """"""
        Calculates the pdf of a lognormal distribution with parameters mean
        and sigma

        Parameters
        ----------
        mean : float or ndarray
            Mean of the lognormal distribution
        sigma : float or ndarray
            Sigma parameter of the lognormal distribution

        Returns
        -------
        : float or ndarray
            pdf of x
        """"""

        # Lognorm pmf with mean for optimization
        mu, sigma = self.translate_args(mean, sigma)
        return self.logpdf(x, mu, sigma)"
3898,"def union_join(left, right, left_as='left', right_as='right'):
    """"""
    Join function truest to the SQL style join.  Merges both objects together in a sum-type,
    saving references to each parent in ``left`` and ``right`` attributes.

        >>> Dog = namedtuple('Dog', ['name', 'woof', 'weight'])
        >>> dog = Dog('gatsby', 'Ruff!', 15)
        >>> Cat = namedtuple('Cat', ['name', 'meow', 'weight'])
        >>> cat = Cat('pleo', 'roooowwwr', 12)
        >>> catdog = union_join(cat, dog, 'cat', 'dog')
        >>> catdog.name
        pleo
        >>> catdog.woof
        Ruff!
        >>> catdog.dog.name
        gatsby

    :param left: left object to be joined with right
    :param right: right object to be joined with left
    :return: joined object with attrs/methods from both parents available
    """"""
    attrs = {}
    attrs.update(get_object_attrs(right))
    attrs.update(get_object_attrs(left))
    attrs[left_as] = left
    attrs[right_as] = right
    if isinstance(left, dict) and isinstance(right, dict):
        return attrs
    else:
        joined_class = type(left.__class__.__name__ + right.__class__.__name__, (Union,),
                            {})
        return joined_class(attrs)"
3899,"def setKeyButton( self, btnId, keyCallback, bounceTime = DEF_BOUNCE_TIME_NORMAL, pullUpDown = GPIO.PUD_UP, event = GPIO.BOTH ):
        """"""!
        \~english
        Set key button event
        @param btnId: Key button pin number in BCM
        @param keyCallback: A interrupt <b>callback_function</b> or <b>None</b>. <br>
               If set to <b>None</b> means keybutton work in query mode<br>
               then uses RPiKeyButtons#readKeyButton for get keybutton status
        @param bounceTime: Default set to DEF_BOUNCE_TIME_NORMAL
        @param pullUpDown: Default set to GPIO.PUD_UP
        @param event: Default set to GPIO.BOTH. it can be: { GPIO.RISING | GPIO.FALLING | GPIO.BOTH }

        \~chinese
        设置按键事件
        @param btnId: 按键IO号(in BCM mode)
        @param keyCallback: 按键中断回调函数 <b>callback_function</b> 或 <b>None</b><br>
                如果设置为<b>None</b>，则表示按键工作在查询模式<br>
                然后使用 RPiKeyButtons#readKeyButton 获取 keybutton 状态
        @param bounceTime: 默认 DEF_BOUNCE_TIME_NORMAL
        @param pullUpDown: 默认 GPIO.PUD_UP
        @param event: 默认 GPIO.BOTH 它可以是: { GPIO.RISING | GPIO.FALLING | GPIO.BOTH }

        \~ \n
        @see DEF_BOUNCE_TIME_SHORT_MON (10ms)
        @see DEF_BOUNCE_TIME_SHORT (50ms)
        @see DEF_BOUNCE_TIME_NORMAL (100ms)
        @see DEF_BOUNCE_TIME_LONG (200ms)

        @note
            * setKeyButton(btnId = 12, keyCallback = None )
            * setKeyButton(btnId = 14, keyCallback = aKeyCallbackFun ) <br>
                <pre>
                \# a simple callback function
                def aKeyCallbackFun(channel):
                    print(channel)
                    pass
                </pre>
        """"""
        GPIO.setup( btnId, GPIO.IN, pull_up_down=pullUpDown)
        # The keyCallback is None means setting keybutton in query mode, 
        # then uses readKeyButton for get keybutton status
        # event can be { RISING, FALLING, BOTH }
        if keyCallback != None:
            try:
                GPIO.add_event_detect( btnId, event, callback=keyCallback, bouncetime=bounceTime )
            except:
                pass
        pass"
3900,"def removeKeyButtonEvent(self, buttons= [] ):
        """"""!
        \~english
        Remove key button event callbacks
        @param buttons: an array of button Ids. eg. [ 12,13,15, ...]

        \~chinese
        移除按键事件回调
        @param buttons: 按钮ID数组。 例如: [12,13,15，...]
        """"""
        for i in range( 0, len(buttons)-1 ):
            GPIO.remove_event_detect( buttons[i] )"
3901,"def configKeyButtons( self, enableButtons = [], bounceTime = DEF_BOUNCE_TIME_NORMAL, pullUpDown = GPIO.PUD_UP, event = GPIO.BOTH ):
        """"""!
        \~english
        Config multi key buttons IO and event on same time

        @param enableButtons: an array of key button configs. eg. <br>
                [{ ""id"":BUTTON_ACT_A, ""callback"": aCallbackFun }, ... ]
        @param bounceTime: Default set to DEF_BOUNCE_TIME_NORMAL
        @param pullUpDown: Default set to GPIO.PUD_UP
        @param event: Default set to GPIO.BOTH. it can be: { GPIO.RISING | GPIO.FALLING | GPIO.BOTH }

        \~chinese
        同时配置多个按键IO和事件

        @param enableButtons: 组按键配置 例如: <br>
                [{ ""id"":BUTTON_ACT_A, ""callback"": aCallbackFun }, ... ]
        @param bounceTime: 默认 DEF_BOUNCE_TIME_NORMAL
        @param pullUpDown: 默认 GPIO.PUD_UP
        @param event: 默认 GPIO.BOTH 它可以是: { GPIO.RISING | GPIO.FALLING | GPIO.BOTH }

        \~ \n
        @see DEF_BOUNCE_TIME_SHORT_MON (10ms)
        @see DEF_BOUNCE_TIME_SHORT (50ms)
        @see DEF_BOUNCE_TIME_NORMAL (100ms)
        @see DEF_BOUNCE_TIME_LONG (200ms)
        """"""
        for key in enableButtons:
            self.setKeyButton( key[""id""], key[""callback""], bounceTime, pullUpDown, event )
        pass"
3902,"def matches_from_list(item,options,fuzzy=90,fname_match=True,fuzzy_fragment=None,guess=False):
    '''Returns the members of ``options`` that best matches ``item``. Will prioritize
    exact matches, then filename-style matching, then fuzzy matching. Returns a tuple of item,
    index, match type, and fuzziness (if applicable)
    
         :item:             string to match
         :options:          list of examples to test against
         :fuzzy:            integer (out of 100) describing how close to match string
         :fname_match:      use filename globbing to match files?
         :fuzzy_fragment:   if not ``None``, will accept substring matches of
                            at least ``fuzzy_fragment`` fuzziness
         :guess:            if ``True``, shortcut for setting ``fuzzy`` and ``min_fragment``
                            to very lenient options
    '''
    matches = []
    
    if guess:
        fuzzy = min(fuzzy,80)
        fuzzy_fragment = min(fuzzy_fragment,70)
    
    option_not_in = lambda item,match_list: all([x[0]!=item for x in match_list])
    
    # Exact matches
    if item in options:
        matches += [(options[i],i,'exact',None) for i in xrange(len(options)) if options[i].lower()==item.lower()]
        # If we have exact matches, don't bother with fuzzy matching
        return matches
    
    # Filename-style matches
    if fname_match:
        matches += [(x,options.index(x),'fname',None) for x in fnmatch.filter(options,item) if option_not_in(x,matches)]
    
    # Fuzzy matches
    if fuzzy:
        sub_matches = []
        for i in xrange(len(options)):
            r = fuzz.ratio(item.lower(),options[i].lower())
            if r>=fuzzy and option_not_in(options[i],matches):
                sub_matches.append((r,i))
        matches += [(options[x[1]],x[1],'fuzzy',x[0]) for x in sorted(sub_matches)]
    
    # Fragment matches
    if fuzzy_fragment:
        sub_matches = []
        for i in xrange(len(options)):
            r = fuzz.partial_ratio(item.lower(),options[i].lower())
            if r>=fuzzy_fragment and option_not_in(options[i],matches):
                sub_matches.append((r,i))
        matches += [(options[x[1]],x[1],'fuzzy_fragment',x[0]) for x in sorted(sub_matches)]
    
    return matches"
3903,"def best_match_from_list(item,options,fuzzy=90,fname_match=True,fuzzy_fragment=None,guess=False):
    '''Returns the best match from :meth:`matches_from_list` or ``None`` if no good matches'''
    matches = matches_from_list(item,options,fuzzy,fname_match,fuzzy_fragment,guess)
    if len(matches)>0:
        return matches[0]
    return None"
3904,"def best_item_from_list(item,options,fuzzy=90,fname_match=True,fuzzy_fragment=None,guess=False):
    '''Returns just the best item, or ``None``'''
    match = best_match_from_list(item,options,fuzzy,fname_match,fuzzy_fragment,guess)
    if match:
        return match[0]
    return None"
3905,"async def create_hlk_sw16_connection(port=None, host=None,
                                     disconnect_callback=None,
                                     reconnect_callback=None, loop=None,
                                     logger=None, timeout=None,
                                     reconnect_interval=None):
    """"""Create HLK-SW16 Client class.""""""
    client = SW16Client(host, port=port,
                        disconnect_callback=disconnect_callback,
                        reconnect_callback=reconnect_callback,
                        loop=loop, logger=logger,
                        timeout=timeout, reconnect_interval=reconnect_interval)
    await client.setup()

    return client"
3906,"def _reset_timeout(self):
        """"""Reset timeout for date keep alive.""""""
        if self._timeout:
            self._timeout.cancel()
        self._timeout = self.loop.call_later(self.client.timeout,
                                             self.transport.close)"
3907,"def reset_cmd_timeout(self):
        """"""Reset timeout for command execution.""""""
        if self._cmd_timeout:
            self._cmd_timeout.cancel()
        self._cmd_timeout = self.loop.call_later(self.client.timeout,
                                                 self.transport.close)"
3908,"def _handle_lines(self):
        """"""Assemble incoming data into per-line packets.""""""
        while b'\xdd' in self._buffer:
            linebuf, self._buffer = self._buffer.rsplit(b'\xdd', 1)
            line = linebuf[-19:]
            self._buffer += linebuf[:-19]
            if self._valid_packet(line):
                self._handle_raw_packet(line)
            else:
                self.logger.warning('dropping invalid data: %s',
                                    binascii.hexlify(line))"
3909,"def _valid_packet(raw_packet):
        """"""Validate incoming packet.""""""
        if raw_packet[0:1] != b'\xcc':
            return False
        if len(raw_packet) != 19:
            return False
        checksum = 0
        for i in range(1, 17):
            checksum += raw_packet[i]
        if checksum != raw_packet[18]:
            return False
        return True"
3910,"def _handle_raw_packet(self, raw_packet):
        """"""Parse incoming packet.""""""
        if raw_packet[1:2] == b'\x1f':
            self._reset_timeout()
            year = raw_packet[2]
            month = raw_packet[3]
            day = raw_packet[4]
            hour = raw_packet[5]
            minute = raw_packet[6]
            sec = raw_packet[7]
            week = raw_packet[8]
            self.logger.debug(
                'received date: Year: %s, Month: %s, Day: %s, Hour: %s, '
                'Minute: %s, Sec: %s, Week %s',
                year, month, day, hour, minute, sec, week)
        elif raw_packet[1:2] == b'\x0c':
            states = {}
            changes = []
            for switch in range(0, 16):
                if raw_packet[2+switch:3+switch] == b'\x01':
                    states[format(switch, 'x')] = True
                    if (self.client.states.get(format(switch, 'x'), None)
                            is not True):
                        changes.append(format(switch, 'x'))
                        self.client.states[format(switch, 'x')] = True
                elif raw_packet[2+switch:3+switch] == b'\x02':
                    states[format(switch, 'x')] = False
                    if (self.client.states.get(format(switch, 'x'), None)
                            is not False):
                        changes.append(format(switch, 'x'))
                        self.client.states[format(switch, 'x')] = False
            for switch in changes:
                for status_cb in self.client.status_callbacks.get(switch, []):
                    status_cb(states[switch])
            self.logger.debug(states)
            if self.client.in_transaction:
                self.client.in_transaction = False
                self.client.active_packet = False
                self.client.active_transaction.set_result(states)
                while self.client.status_waiters:
                    waiter = self.client.status_waiters.popleft()
                    waiter.set_result(states)
                if self.client.waiters:
                    self.send_packet()
                else:
                    self._cmd_timeout.cancel()
            elif self._cmd_timeout:
                self._cmd_timeout.cancel()
        else:
            self.logger.warning('received unknown packet: %s',
                                binascii.hexlify(raw_packet))"
3911,"def send_packet(self):
        """"""Write next packet in send queue.""""""
        waiter, packet = self.client.waiters.popleft()
        self.logger.debug('sending packet: %s', binascii.hexlify(packet))
        self.client.active_transaction = waiter
        self.client.in_transaction = True
        self.client.active_packet = packet
        self.reset_cmd_timeout()
        self.transport.write(packet)"
3912,"def format_packet(command):
        """"""Format packet to be sent.""""""
        frame_header = b""\xaa""
        verify = b""\x0b""
        send_delim = b""\xbb""
        return frame_header + command.ljust(17, b""\x00"") + verify + send_delim"
3913,"def connection_lost(self, exc):
        """"""Log when connection is closed, if needed call callback.""""""
        if exc:
            self.logger.error('disconnected due to error')
        else:
            self.logger.info('disconnected because of close/abort.')
        if self.disconnect_callback:
            asyncio.ensure_future(self.disconnect_callback(), loop=self.loop)"
3914,"async def setup(self):
        """"""Set up the connection with automatic retry.""""""
        while True:
            fut = self.loop.create_connection(
                lambda: SW16Protocol(
                    self,
                    disconnect_callback=self.handle_disconnect_callback,
                    loop=self.loop, logger=self.logger),
                host=self.host,
                port=self.port)
            try:
                self.transport, self.protocol = \
                    await asyncio.wait_for(fut, timeout=self.timeout)
            except asyncio.TimeoutError:
                self.logger.warning(""Could not connect due to timeout error."")
            except OSError as exc:
                self.logger.warning(""Could not connect due to error: %s"",
                                    str(exc))
            else:
                self.is_connected = True
                if self.reconnect_callback:
                    self.reconnect_callback()
                break
            await asyncio.sleep(self.reconnect_interval)"
3915,"def stop(self):
        """"""Shut down transport.""""""
        self.reconnect = False
        self.logger.debug(""Shutting down."")
        if self.transport:
            self.transport.close()"
3916,"async def handle_disconnect_callback(self):
        """"""Reconnect automatically unless stopping.""""""
        self.is_connected = False
        if self.disconnect_callback:
            self.disconnect_callback()
        if self.reconnect:
            self.logger.debug(""Protocol disconnected...reconnecting"")
            await self.setup()
            self.protocol.reset_cmd_timeout()
            if self.in_transaction:
                self.protocol.transport.write(self.active_packet)
            else:
                packet = self.protocol.format_packet(b""\x1e"")
                self.protocol.transport.write(packet)"
3917,"def register_status_callback(self, callback, switch):
        """"""Register a callback which will fire when state changes.""""""
        if self.status_callbacks.get(switch, None) is None:
            self.status_callbacks[switch] = []
        self.status_callbacks[switch].append(callback)"
3918,"def _send(self, packet):
        """"""Add packet to send queue.""""""
        fut = self.loop.create_future()
        self.waiters.append((fut, packet))
        if self.waiters and self.in_transaction is False:
            self.protocol.send_packet()
        return fut"
3919,"async def turn_on(self, switch=None):
        """"""Turn on relay.""""""
        if switch is not None:
            switch = codecs.decode(switch.rjust(2, '0'), 'hex')
            packet = self.protocol.format_packet(b""\x10"" + switch + b""\x01"")
        else:
            packet = self.protocol.format_packet(b""\x0a"")
        states = await self._send(packet)
        return states"
3920,"async def turn_off(self, switch=None):
        """"""Turn off relay.""""""
        if switch is not None:
            switch = codecs.decode(switch.rjust(2, '0'), 'hex')
            packet = self.protocol.format_packet(b""\x10"" + switch + b""\x02"")
        else:
            packet = self.protocol.format_packet(b""\x0b"")
        states = await self._send(packet)
        return states"
3921,"async def status(self, switch=None):
        """"""Get current relay status.""""""
        if switch is not None:
            if self.waiters or self.in_transaction:
                fut = self.loop.create_future()
                self.status_waiters.append(fut)
                states = await fut
                state = states[switch]
            else:
                packet = self.protocol.format_packet(b""\x1e"")
                states = await self._send(packet)
                state = states[switch]
        else:
            if self.waiters or self.in_transaction:
                fut = self.loop.create_future()
                self.status_waiters.append(fut)
                state = await fut
            else:
                packet = self.protocol.format_packet(b""\x1e"")
                state = await self._send(packet)
        return state"
3922,"def value(self, item):
        # type: (Any) -> Any
        """"""
        Return value stored in weakref.
        :param item: Object from which get the value.
        :return: Value stored in the weakref, otherwise original value.
        :raise TreeDeletedException: when weakref is already deleted.
        """"""
        if isinstance(item, weakref.ReferenceType):
            if item() is None:
                raise TreeDeletedException()
            return item()
        return item"
3923,"def remove_all(self, item):
        # type: (Any) -> None
        """"""
        Remove all occurrence of the parameter.
        :param item: Value to delete from the WeakList.
        """"""
        item = self.ref(item)
        while list.__contains__(self, item):
            list.remove(self, item)"
3924,"def index(self, item, **kwargs):
        # type: (Any, dict) -> int
        """"""
        Get index of the parameter.
        :param item: Item for which get the index.
        :return: Index of the parameter in the WeakList.
        """"""
        return list.index(self, self.ref(item), **kwargs)"
3925,"def insert(self, index, item):
        # type: (int, Any) -> None
        """"""
        Insert item at the specific index.
        :param index: Index where to insert the item.
        :param item: Item to insert.
        """"""
        return list.insert(self, index, self.ref(item))"
3926,"def sort(self, *, key: Optional[Callable[[Any], Any]] = None, reverse: bool = False) -> None:
        """"""
        Sort _WeakList.
        :param key: Key by which to sort, default None.
        :param reverse: True if return reversed WeakList, false by default.
        """"""
        return list.sort(self, key=self._sort_key(key), reverse=reverse)"
3927,"def get_feed(self, datasource_id):
        """"""
        Получение настроек для фида
        :param datasource_id: идентификатор фида
        :return: FeedDataSource
        """"""
        info = self.__metadb.one(
            """"""
            SELECT to_json(ds) as datasource
                 , to_json(fc) as connector
                 , to_json(fct) as connector_type
                 , to_json(ctp) as connector_type_preset
                 , json_build_object('email', u.email, 'full_name', u.full_name) as author_user
              FROM meta.feed_datasource ds
              LEFT JOIN meta.feed_connector fc 
                     ON fc.id=ds.connector_id
              LEFT JOIN meta.feed_connector_type fct 
                     ON fct.id=fc.connector_type_id
              LEFT JOIN meta.feed_connector_type_preset ctp 
                     ON ctp.id=ds.connector_type_preset_id
              LEFT JOIN meta.user_list u 
                     ON u.id=ds.author_user_id
             WHERE ds.id = :datasource_id::uuid
            """""",
            {""datasource_id"": datasource_id}
        )
        return FeedDataSource(**info)"
3928,"def get_data(self, datasource, callback):
        """"""
        Сохранение медиафайла
        :param task:
        :param media_metadata:
        :param file_suffix:
        :param callback:
        :return:
        """"""
        task = self.__app.worker.current_task
        media_metadata = datasource.connector_type_preset['preset_data']['media_metadata']
        result_data = task['result_data']
        tmp_file = NamedTemporaryFile(delete=False, suffix=SOURCE_FORMAT_EXTENSION.get(media_metadata['sourceFormat']))
        self.__app.log.info(""Открываем файл"", {""filename"": tmp_file.name})
        with open(tmp_file.name, 'wb') as f:
            callback(f)

        self.__app.log.info(""start media upload"")

        result_data['stage_id'] = ""persist_media_file""
        self.__starter.update_task_result_data(task)
        result = self.__media.upload(open(tmp_file.name), {
            ""ttlInSec"": 60 * 60 * 24,  # 24h
            ""entityId"": 2770,
            ""objectId"": task.get('data', {}).get(""ds_id""),
            ""info"": {""metadata"": media_metadata}
        })

        result_data['stage_id'] = ""generate_media_finish""
        result_data['media_id'] = result['id']
        self.__starter.update_task_result_data(task)

        return result"
3929,"def datasource_process(self, datasource_id):
        """"""
        deprecated
        Запускает настроенные обработки в фиде
        :param datasource_id: uuid
        """"""
        # TODO Выпилить потом класс используется для другого
        # TODO без applicationId не выбираются поля сущностей. Подумать на сколько это НЕ нормально
        response = self.__app.native_api_call('feed', 'datasource/' + datasource_id + '/process?applicationId=1', {},
                                              self.__options, False, None, False, http_method=""POST"")
        return json.loads(response.text)"
3930,"def _delta_dir():
    """"""returns the relative path of the current directory to the git
    repository.
    This path will be added the 'filename' path to find the file.
    It current_dir is the git root, this function returns an empty string.

    Keyword Arguments:
        <none>

    Returns:
        str -- relative path of the current dir to git root dir
               empty string if current dir is the git root dir
    """"""
    repo = Repo()
    current_dir = os.getcwd()
    repo_dir = repo.tree().abspath
    delta_dir = current_dir.replace(repo_dir, '')
    if delta_dir:
        return delta_dir + '/'
    else:
        return ''"
3931,"def commit(filename):
    """"""Commit (git) a specified file

    This method does the same than a ::

        $ git commit -a ""message""

    Keyword Arguments:
        :filename: (str) -- name of the file to commit

    Returns:
        <nothing>
    """"""
    try:
        repo = Repo()
        # gitcmd = repo.git
        # gitcmd.commit(filename)
        index = repo.index
        index.commit(""Updated file: {0}"".format(filename))
    except Exception as e:
        print(""exception while commit: %s"" % e.message)"
3932,"def add_file_to_repo(filename):
    """"""Add a file to the git repo

    This method does the same than a ::

        $ git add filename

    Keyword Arguments:
        :filename: (str) -- name of the file to commit

    Returns:
        <nothing>
    """"""
    try:
        repo = Repo()
        index = repo.index
        index.add([_delta_dir() + filename])
    except Exception as e:
        print(""exception while gitadding file: %s"" % e.message)"
3933,"def reset_to_last_commit():
    """"""reset a modified file to his last commit status

    This method does the same than a ::

        $ git reset --hard

    Keyword Arguments:
        <none>

    Returns:
        <nothing>
    """"""
    try:
        repo = Repo()
        gitcmd = repo.git
        gitcmd.reset(hard=True)
    except Exception:
        pass"
3934,"def commit_history(filename):
    """"""Retrieve the commit history for a given filename.

    Keyword Arguments:
        :filename: (str) -- full name of the file

    Returns:
        list of dicts -- list of commit
                if the file is not found, returns an empty list
    """"""
    result = []
    repo = Repo()
    for commit in repo.head.commit.iter_parents(paths=_delta_dir() + filename):
        result.append({'date':
                       datetime.fromtimestamp(commit.committed_date +
                                              commit.committer_tz_offset),
                       'hexsha': commit.hexsha})
    return result"
3935,"def read_committed_file(gitref, filename):
    """"""Retrieve the content of a file in an old commit and returns it.

    Ketword Arguments:
        :gitref: (str) -- full reference of the git commit
        :filename: (str) -- name (full path) of the file

    Returns:
        str -- content of the file
    """"""
    repo = Repo()
    commitobj = repo.commit(gitref)

    blob = commitobj.tree[_delta_dir() + filename]
    return blob.data_stream.read()"
3936,"def get(self, key, _else=None):
        """"""The method to get an assets value
        """"""
        with self._lock:
            self.expired()
            # see if everything expired
            try:
                value = self._dict[key].get()
                return value
            except KeyError:
                return _else
            except ValueError:
                return _else"
3937,"def set(self, key, value, expires=None, future=None):
        """"""Set a value
        """"""
        # assert the values above
        with self._lock:
            try:
                self._dict[key].set(value, expires=expires, future=future)
            except KeyError:
                self._dict[key] = moment(value, expires=expires, future=future, lock=self._lock)
            return value"
3938,"def values(self):
        """"""Will only return the current values
        """"""
        self.expired()
        values = []
        for key in self._dict.keys():
            try:
                value = self._dict[key].get()
                values.append(value)
            except:
                continue
        return values"
3939,"def has_key(self, key):
        """"""Does the key exist?
        This method will check to see if it has expired too.
        """"""
        if key in self._dict:
            try: 
                self[key]
                return True
            except ValueError:
                return False
            except KeyError:
                return False
        return False"
3940,"def dicom2db(file_path, file_type, is_copy, step_id, db_conn, sid_by_patient=False, pid_in_vid=False,
             visit_in_path=False, rep_in_path=False):
    """"""Extract some meta-data from a DICOM file and store in a DB.

    Arguments:
    :param file_path: File path.
    :param file_type: File type (should be 'DICOM').
    :param is_copy: Indicate if this file is a copy.
    :param step_id: Step ID
    :param db_conn: Database connection.
    :param sid_by_patient: Rarely, a data set might use study IDs which are unique by patient
    (not for the whole study).
    E.g.: LREN data. In such a case, you have to enable this flag. This will use PatientID + StudyID as a session ID.
    :param pid_in_vid: Rarely, a data set might mix patient IDs and visit IDs. E.g. : LREN data. In such a case, you
    to enable this flag. This will try to split PatientID into VisitID and PatientID.
    :param visit_in_path: Enable this flag to get the visit ID from the folder hierarchy instead of DICOM meta-data
    (e.g. can be useful for PPMI).
    :param rep_in_path: Enable this flag to get the repetition ID from the folder hierarchy instead of DICOM meta-data
    (e.g. can be useful for PPMI).
    :return: A dictionary containing the following IDs : participant_id, visit_id, session_id, sequence_type_id,
    sequence_id, repetition_id, file_id.
    """"""
    global conn
    conn = db_conn

    tags = dict()
    logging.info(""Extracting DICOM headers from '%s'"" % file_path)

    try:
        dcm = dicom.read_file(file_path)
        dataset = db_conn.get_dataset(step_id)

        tags['participant_id'] = _extract_participant(dcm, dataset, pid_in_vid)
        if visit_in_path:
            tags['visit_id'] = _extract_visit_from_path(
                dcm, file_path, pid_in_vid, sid_by_patient, dataset, tags['participant_id'])
        else:
            tags['visit_id'] = _extract_visit(dcm, dataset, tags['participant_id'], sid_by_patient, pid_in_vid)
        tags['session_id'] = _extract_session(dcm, tags['visit_id'])
        tags['sequence_type_id'] = _extract_sequence_type(dcm)
        tags['sequence_id'] = _extract_sequence(tags['session_id'], tags['sequence_type_id'])
        if rep_in_path:
            tags['repetition_id'] = _extract_repetition_from_path(dcm, file_path, tags['sequence_id'])
        else:
            tags['repetition_id'] = _extract_repetition(dcm, tags['sequence_id'])
        tags['file_id'] = extract_dicom(file_path, file_type, is_copy, tags['repetition_id'], step_id)
    except InvalidDicomError:
        logging.warning(""%s is not a DICOM file !"" % step_id)
    except IntegrityError:
        # TODO: properly deal with concurrency problems
        logging.warning(""A problem occurred with the DB ! A rollback will be performed..."")
        conn.db_session.rollback()
    return tags"
3941,"def regularized_function(x,y,func,bins=None,range=None):
    """"""Compute func() over data aggregated in bins.

    (x,y) --> (x', func(Y'))  with Y' = {y: y(x) where x in x' bin}

    First the data is collected in bins x' along x and then func is applied to
    all data points Y' that have been collected in the bin.

    :Arguments:
       x
          abscissa values (for binning)
       y
          ordinate values (func is applied)
       func
          a numpy ufunc that takes one argument, func(Y')
       bins
          number or array
       range
          limits (used with number of bins)

    :Returns:
       F,edges
          function and edges (midpoints = 0.5*(edges[:-1]+edges[1:]))
    """"""
    _x = numpy.asarray(x)
    _y = numpy.asarray(y)

    # setup of bins from numpy.histogram
    if (range is not None):
        mn, mx = range
        if (mn > mx):
            raise ValueError('max must be larger than min in range parameter.')

    if not numpy.iterable(bins):
        if range is None:
            range = (_x.min(), _x.max())
        mn, mx = [float(mi) for mi in range]
        if mn == mx:
            mn -= 0.5
            mx += 0.5
        bins = numpy.linspace(mn, mx, bins+1, endpoint=True)
    else:
        bins = numpy.asarray(bins)
        if (numpy.diff(bins) < 0).any():
            raise ValueError('bins must increase monotonically.')

    sorting_index = numpy.argsort(_x)
    sx = _x[sorting_index]
    sy = _y[sorting_index]

    # boundaries in SORTED data that demarcate bins; position in bin_index is the bin number
    bin_index = numpy.r_[sx.searchsorted(bins[:-1], 'left'),
                         sx.searchsorted(bins[-1], 'right')]

    # naive implementation: apply operator to each chunk = sy[start:stop] separately
    #
    # It's not clear to me how one could effectively block this procedure (cf
    # block = 65536 in numpy.histogram) because there does not seem to be a
    # general way to combine the chunks for different blocks, just think of
    # func=median
    F = numpy.zeros(len(bins)-1)  # final function
    F[:] = [func(sy[start:stop]) for start,stop in izip(bin_index[:-1],bin_index[1:])]
    return F,bins"
3942,"def unit_rules_restore(root):
    # type: (Nonterminal) -> Nonterminal
    """"""
    Transform parsed tree for grammar with removed unit rules.
    The unit rules will be returned back to the tree.
    :param root: Root of the parsed tree.
    :return: Modified tree.
    """"""
    items = Traversing.post_order(root)
    items = filter(lambda x: isinstance(x, ReducedUnitRule), items)
    for rule in items:
        parent_nonterm = rule.from_symbols[0]  # type: Nonterminal
        # restore chain of unit rules
        for r in rule.by_rules:
            created_rule = r()  # type: Rule
            parent_nonterm._set_to_rule(created_rule)
            created_rule._from_symbols.append(parent_nonterm)
            created_nonterm = r.toSymbol()  # type: Nonterminal
            created_rule._to_symbols.append(created_nonterm)
            created_nonterm._set_from_rule(created_rule)
            parent_nonterm = created_nonterm
        # restore last rule
        last_rule = rule.end_rule()  # type: Rule
        last_rule._from_symbols.append(parent_nonterm)
        parent_nonterm._set_to_rule(last_rule)
        for ch in rule.to_symbols:  # type: Nonterminal
            ch._set_from_rule(last_rule)
            last_rule._to_symbols.append(ch)
    return root"
3943,"def remaining_bytes(self, meta=True):
        """"""
        Returns the remaining, unread bytes from the buffer.
        """"""
        pos, self._pos = self._pos, len(self.buffer)
        return self.buffer[pos:]"
3944,"def decode(self, bytes):
        """"""
        Decodes the packet off the byte string.
        """"""

        self.buffer = bytes
        self._pos = 0

        Packet = identifier.get_packet_from_id(self._read_variunt())

        # unknown packets will be None from the identifier
        if Packet is None:
            return None

        packet = Packet()
        packet.ParseFromString(self.remaining_bytes())
        return packet"
3945,"def encode(self, packet):
        """"""
        Pushes a packet to the writer, encoding it on the internal
        buffer.
        """"""

        id = identifier.get_packet_id(packet)
        if id is None:
            raise EncoderException('unknown packet')

        self._write_variunt(id)
        self._write(packet.SerializeToString())

        return bytes(self.buffer)"
3946,"def setup_logging(level):
    """""" Setup logger. """"""
    logging.root.setLevel(level)
    logging.root.addHandler(STREAM_HANDLER)"
3947,"def create(self, data):
        """""" Create object from the given data.

        The given data may or may not have been validated prior to calling
        this function. This function will try its best in creating the object.
        If the resulting object cannot be produced, raises ``ValidationError``.

        The spec can affect how individual fields will be created by
        implementing ``clean()`` for the fields needing customization.

        :param data: the data as a dictionary.
        :return: instance of ``klass`` or dictionary.
        :raises: ``ValidationError`` if factory is unable to create object.
        """"""

        # todo: copy-paste code from representation.validate -> refactor

        if data is None:
            return None

        prototype = {}
        errors = {}

        # create and populate the prototype
        for field_name, field_spec in self.spec.fields.items():
            try:
                value = self._create_value(data, field_name, self.spec)
            except ValidationError, e:
                if field_name not in self.default_create_values:
                    if hasattr(e, 'message_dict'):
                        # prefix error keys with top level field name
                        errors.update(dict(zip(
                            [field_name + '.' + key for key in e.message_dict.keys()],
                            e.message_dict.values())))
                    else:
                        errors[field_name] = e.messages
            else:
                key_name = self.property_name_map[field_name]
                prototype[key_name] = value

        # check extra fields
        if self.prevent_extra_fields:
            extras = set(data.keys()) - set(self.property_name_map.keys())
            if extras:
                errors[', '.join(extras)] = ['field(s) not allowed']

        # if errors, raise ValidationError
        if errors:
            raise ValidationError(errors)

        # return dict or object based on the prototype
        _data = deepcopy(self.default_create_values)
        _data.update(prototype)
        if self.klass:
            instance = self.klass()
            instance.__dict__.update(prototype)
            return instance
        else:
            return prototype"
3948,"def serialize(self, entity, request=None):
        """""" Serialize entity into dictionary.

        The spec can affect how individual fields will be serialized by
        implementing ``serialize()`` for the fields needing customization.

        :returns: dictionary
        """"""

        def should_we_insert(value, field_spec):
            return value not in self.missing or field_spec.required

        errors = {}
        ret = {}

        for field_name, field_spec in self.spec.fields.items():
            value = self._get_value_for_serialization(entity, field_name, field_spec)
            func = self._get_serialize_func(field_name, self.spec)
            try:
                # perform serialization
                value = func(value, entity, request)
                if should_we_insert(value, field_spec):
                    ret[field_name] = value
            except ValidationError, e:
                if hasattr(e, 'message_dict'):
                    # prefix error keys with top level field name
                    errors.update(dict(zip(
                        [field_name + '.' + key for key in e.message_dict.keys()],
                        e.message_dict.values())))
                else:
                    errors[field_name] = e.messages

        if errors:
            raise ValidationError(errors)

        return None if ret == {} else ret"
3949,"def _create_value(self, data, name, spec):
        """""" Create the value for a field.

        :param data: the whole data for the entity (all fields).
        :param name: name of the initialized field.
        :param spec: spec for the whole entity.
        """"""

        field = getattr(self, 'create_' + name, None)
        if field:
            # this factory has a special creator function for this field
            return field(data, name, spec)
        value = data.get(name)
        return spec.fields[name].clean(value)"
3950,"def _get_serialize_func(self, name, spec):
        """""" Return the function that is used for serialization. """"""
        func = getattr(self, 'serialize_' + name, None)
        if func:
            # this factory has a special serializer function for this field
            return func
        func = getattr(spec.fields[name], 'serialize', None)
        if func:
            return func
        return lambda value, entity, request: value"
3951,"def _get_value_for_serialization(self, data, name, spec):
        """""" Return the value of the field in entity (or ``None``). """"""
        name = self.property_name_map[name]
        return getattr(data, name, None)"
3952,"def _create_mappings(self, spec):
        """""" Create property name map based on aliases. """"""
        ret = dict(zip(set(spec.fields), set(spec.fields)))
        ret.update(dict([(n, s.alias) for n, s in spec.fields.items() if s.alias]))
        return ret"
3953,"def all_substrings(s):
    ''' yields all substrings of a string '''
    join = ''.join
    for i in range(1, len(s) + 1):
        for sub in window(s, i):
            yield join(sub)"
3954,"def equivalent_release_for_product(self, product):
        """"""
        Returns the release for a specified product with the same
        channel and major version with the highest minor version,
        or None if no such releases exist
        """"""
        releases = self._default_manager.filter(
            version__startswith=self.major_version() + '.',
            channel=self.channel, product=product).order_by('-version')
        if not getattr(settings, 'DEV', False):
            releases = releases.filter(is_public=True)
        if releases:
            return sorted(
                sorted(releases, reverse=True,
                       key=lambda r: len(r.version.split('.'))),
                reverse=True, key=lambda r: r.version.split('.')[1])[0]"
3955,"def notes(self, public_only=False):
        """"""
        Retrieve a list of Note instances that should be shown for this
        release, grouped as either new features or known issues, and sorted
        first by sort_num highest to lowest and then by created date,
        which is applied to both groups,
        and then for new features we also sort by tag in the order specified
        by Note.TAGS, with untagged notes coming first, then finally moving
        any note with the fixed tag that starts with the release version to
        the top, for what we call ""dot fixes"".
        """"""
        tag_index = dict((tag, i) for i, tag in enumerate(Note.TAGS))
        notes = self.note_set.order_by('-sort_num', 'created')
        if public_only:
            notes = notes.filter(is_public=True)
        known_issues = [n for n in notes if n.is_known_issue_for(self)]
        new_features = sorted(
            sorted(
                (n for n in notes if not n.is_known_issue_for(self)),
                key=lambda note: tag_index.get(note.tag, 0)),
            key=lambda n: n.tag == 'Fixed' and n.note.startswith(self.version),
            reverse=True)

        return new_features, known_issues"
3956,"def to_dict(self):
        """"""Return a dict all all data about the release""""""
        data = model_to_dict(self, exclude=['id'])
        data['title'] = unicode(self)
        data['slug'] = self.slug
        data['release_date'] = self.release_date.date().isoformat()
        data['created'] = self.created.isoformat()
        data['modified'] = self.modified.isoformat()
        new_features, known_issues = self.notes(public_only=False)
        for note in known_issues:
            note.tag = 'Known'
        data['notes'] = [n.to_dict(self) for n in chain(new_features, known_issues)]
        return data"
3957,"def to_simple_dict(self):
        """"""Return a dict of only the basic data about the release""""""
        return {
            'version': self.version,
            'product': self.product,
            'channel': self.channel,
            'is_public': self.is_public,
            'slug': self.slug,
            'title': unicode(self),
        }"
3958,"def playTone(self, freq, reps = 1, delay = 0.1, muteDelay = 0.0):
        """"""!
        \~english Play a tone
        \~chinese 播放音符
        \~english 
        @param freq
        @param reps
        @param delay >= 0(s) if 0 means do not delay. tone play will be Stop immediately <br>
        @param muteDelay >= 0(s) If 0 means no pause after playing, play the next note immediately
        \~chinese 
        @param freq: 频率
        @param reps: 重复次数
        @param delay >= 0(s) 如果是 0 意味着不延迟。 音符会立即停止播放 <br>
        @param muteDelay >= 0(s) 如果是 0 表示音符播放结束后没有停顿，立刻播放下一个音符
        """"""
        if freq == 0: 
            self.stopTone()
            self._delay(delay)
            #sleep(delay)
            return False

        if self._pwmPlayer == None: self._initPWMPlayer(freq)

        for r in range(0,reps):
            self._pwmPlayer.start(self.TONE_DUTY)
            self._pwmPlayer.ChangeFrequency( freq )
            self._delay(delay)
            #sleep(delay)

            if muteDelay>0:
                self.stopTone()
                self._delay(muteDelay)
                #sleep(muteDelay)

        return True"
3959,"def playToneList(self, playList = None):
        """"""!
        \~english
        Play tone from a tone list
        @param playList a array of tones
        
        \~chinese
        播放音调列表
        @param playList: 音调数组
        
        \~english @note <b>playList</b> format:\n
        \~chinese @note <b>playList</b> 格式:\n
        \~
            <pre>
            [
              {""freq"": 440, ""reps"": 1, ""delay"": 0.08, ""muteDelay"": 0.15},
              {""freq"": 567, ""reps"": 3, ""delay"": 0.08, ""muteDelay"": 0.15},
              ...
            ]
           </pre>\n
        \~english
        \e delay: >= 0(s) if 0 means do not delay. tone play will be Stop immediately <br>
        \e muteDelay: 0.15 >= 0(s) If 0 means no pause after playing, play the next note immediately
        \~chinese
        \e delay: >= 0（s）如果是 0 意味着不延迟。 音调会立即停止播放 <br>
        \e muteDelay: >= 0（s）如果是 0 表示播放音符结束后没有停顿，立刻播放下一个音符
        """"""
        if playList == None: return False
        for t in playList:
            self.playTone(t[""freq""], t[""reps""], t[""delay""], t[""muteDelay""])

        self.stopTone()
        return True"
3960,"def all(self, instance):
        """"""Get all ACLs associated with the instance specified by name.

        :param str instance: The name of the instance from which to fetch ACLs.
        :returns: A list of :py:class:`Acl` objects associated with the specified instance.
        :rtype: list
        """"""
        url = self._url.format(instance=instance)
        response = requests.get(url, **self._default_request_kwargs)
        data = self._get_response_data(response)
        return self._concrete_acl_list(data)"
3961,"def create(self, instance, cidr_mask, description, **kwargs):
        """"""Create an ACL entry for the specified instance.

        :param str instance: The name of the instance to associate the new ACL entry with.
        :param str cidr_mask: The IPv4 CIDR mask for the new ACL entry.
        :param str description: A short description for the new ACL entry.
        :param collector kwargs: (optional) Additional key=value pairs to be supplied to the
            creation payload. **Caution:** fields unrecognized by the API will cause this request
            to fail with a 400 from the API.
        """"""
        # Build up request data.
        url = self._url.format(instance=instance)
        request_data = {
            'cidr_mask': cidr_mask,
            'description': description
        }
        request_data.update(kwargs)

        # Call to create an instance.
        response = requests.post(
            url,
            data=json.dumps(request_data),
            **self._default_request_kwargs
        )

        # Log outcome of instance creation request.
        if response.status_code == 200:
            logger.info('Successfully created a new ACL for instance {} with: {}.'
                        .format(instance, request_data))
        else:
            logger.info('Failed to create a new ACL for instance {} with: {}.'
                        .format(instance, request_data))

        data = self._get_response_data(response)
        return self._concrete_acl(data)"
3962,"def get(self, instance, acl):
        """"""Get an ACL by ID belonging to the instance specified by name.

        :param str instance: The name of the instance from which to fetch the ACL.
        :param str acl: The ID of the ACL to fetch.
        :returns: An :py:class:`Acl` object, or None if ACL does not exist.
        :rtype: :py:class:`Acl`
        """"""
        base_url = self._url.format(instance=instance)
        url = '{base}{aclid}/'.format(base=base_url, aclid=acl)
        response = requests.get(url, **self._default_request_kwargs)
        data = self._get_response_data(response)
        return self._concrete_acl(data)"
3963,"def delete(self, instance, acl):
        """"""Delete an ACL by ID belonging to the instance specified by name.

        :param str instance: The name of the instance on which the ACL exists.
        :param str acll: The ID of the ACL to delete.
        """"""
        base_url = self._url.format(instance=instance)
        url = '{base}{aclid}/'.format(base=base_url, aclid=acl)
        response = requests.delete(url, **self._default_request_kwargs)

        if response.status_code == 200:
            logger.info('Successfully deleted ACL {}'.format(acl))
        else:
            logger.info('Failed to delete ACL {}'.format(acl))
            logger.info('Response: [{0}] {1}'.format(response.status_code, response.content))
            raise errors.ObjectRocketException('Failed to delete ACL.')"
3964,"def _concrete_acl(self, acl_doc):
        """"""Concretize an ACL document.

        :param dict acl_doc: A document describing an ACL entry. Should come from the API.
        :returns: An :py:class:`Acl`, or None.
        :rtype: :py:class:`bases.BaseInstance`
        """"""
        if not isinstance(acl_doc, dict):
            return None

        # Attempt to instantiate an Acl object with the given dict.
        try:
            return Acl(document=acl_doc, acls=self)

        # If construction fails, log the exception and return None.
        except Exception as ex:
            logger.exception(ex)
            logger.error('Could not instantiate ACL document. You probably need to upgrade to a '
                         'recent version of the client. Document which caused this error: {}'
                         .format(acl_doc))
            return None"
3965,"def _concrete_acl_list(self, acl_docs):
        """"""Concretize a list of ACL documents.

        :param list acl_docs: A list of ACL documents. Should come from the API.
        :returns: A list of :py:class:`ACL` objects.
        :rtype: list
        """"""
        if not acl_docs:
            return []

        return list(filter(None, [self._concrete_acl(acl_doc=doc) for doc in acl_docs]))"
3966,"def _default_request_kwargs(self):
        """"""The default request keyword arguments to be passed to the requests library.""""""
        defaults = copy.deepcopy(super(Acls, self)._default_request_kwargs)
        defaults.setdefault('headers', {}).update({
            'X-Auth-Token': self._client.auth._token
        })
        return defaults"
3967,"def _url(self):
        """"""The URL of this ACL object.""""""
        base_url = self._client._url.rstrip('/')
        return '{}/instances/{}/acls/{}/'.format(base_url, self.instance_name, self.id)"
3968,"def first(pipe, items=1):
    ''' first is essentially the next() function except it's second argument
        determines how many of the first items you want. If items is more than
        1 the output is an islice of the generator. If items is 1, the first
        item is returned
    '''
    pipe = iter(pipe)
    return next(pipe) if items == 1 else islice(pipe, 0, items)"
3969,"def create_state(cls, state, **kwargs):
        """"""Create State

        Create a new State
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_state(state, async=True)
        >>> result = thread.get()

        :param async bool
        :param State state: Attributes of state to create (required)
        :return: State
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_state_with_http_info(state, **kwargs)
        else:
            (data) = cls._create_state_with_http_info(state, **kwargs)
            return data"
3970,"def delete_state_by_id(cls, state_id, **kwargs):
        """"""Delete State

        Delete an instance of State by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_state_by_id(state_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str state_id: ID of state to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_state_by_id_with_http_info(state_id, **kwargs)
        else:
            (data) = cls._delete_state_by_id_with_http_info(state_id, **kwargs)
            return data"
3971,"def get_state_by_id(cls, state_id, **kwargs):
        """"""Find State

        Return single instance of State by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_state_by_id(state_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str state_id: ID of state to return (required)
        :return: State
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_state_by_id_with_http_info(state_id, **kwargs)
        else:
            (data) = cls._get_state_by_id_with_http_info(state_id, **kwargs)
            return data"
3972,"def list_all_states(cls, **kwargs):
        """"""List States

        Return a list of States
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_states(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[State]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_states_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_states_with_http_info(**kwargs)
            return data"
3973,"def replace_state_by_id(cls, state_id, state, **kwargs):
        """"""Replace State

        Replace all attributes of State
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_state_by_id(state_id, state, async=True)
        >>> result = thread.get()

        :param async bool
        :param str state_id: ID of state to replace (required)
        :param State state: Attributes of state to replace (required)
        :return: State
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_state_by_id_with_http_info(state_id, state, **kwargs)
        else:
            (data) = cls._replace_state_by_id_with_http_info(state_id, state, **kwargs)
            return data"
3974,"def update_state_by_id(cls, state_id, state, **kwargs):
        """"""Update State

        Update attributes of State
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_state_by_id(state_id, state, async=True)
        >>> result = thread.get()

        :param async bool
        :param str state_id: ID of state to update. (required)
        :param State state: Attributes of state to update. (required)
        :return: State
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_state_by_id_with_http_info(state_id, state, **kwargs)
        else:
            (data) = cls._update_state_by_id_with_http_info(state_id, state, **kwargs)
            return data"
3975,"def insert_list_of_dictionaries_into_database_tables(
        dbConn,
        log,
        dictList,
        dbTableName,
        uniqueKeyList=[],
        dateModified=False,
        dateCreated=True,
        batchSize=2500,
        replace=False,
        dbSettings=False):
    """"""insert list of dictionaries into database tables

    **Key Arguments:**
        - ``dbConn`` -- mysql database connection
        - ``log`` -- logger
        - ``dictList`` -- list of python dictionaries to add to the database table
        - ``dbTableName`` -- name of the database table
        - ``uniqueKeyList`` -- a list of column names to append as a unique constraint on the database
        - ``dateModified`` -- add the modification date as a column in the database
        - ``dateCreated`` -- add the created date as a column in the database
        - ``batchSize`` -- batch the insert commands into *batchSize* batches
        - ``replace`` -- repalce row if a duplicate is found
        - ``dbSettings`` -- pass in the database settings so multiprocessing can establish one connection per process (might not be faster)

    **Return:**
        - None

    **Usage:**

        .. code-block:: python

            from fundamentals.mysql import insert_list_of_dictionaries_into_database_tables
            insert_list_of_dictionaries_into_database_tables(
                dbConn=dbConn,
                log=log,
                dictList=dictList,
                dbTableName=""test_insert_many"",
                uniqueKeyList=[""col1"", ""col3""],
                dateModified=False,
                batchSize=2500
            )
    """"""

    log.debug(
        'completed the ````insert_list_of_dictionaries_into_database_tables`` function')

    global count
    global totalCount
    global globalDbConn
    global sharedList

    reDate = re.compile('^[0-9]{4}-[0-9]{2}-[0-9]{2}T')

    if dbSettings:
        globalDbConn = dbSettings
    else:
        globalDbConn = dbConn

    if len(dictList) == 0:
        log.warning(
            'the dictionary to be added to the database is empty' % locals())
        return None

    if len(dictList):
        convert_dictionary_to_mysql_table(
            dbConn=dbConn,
            log=log,
            dictionary=dictList[0],
            dbTableName=dbTableName,
            uniqueKeyList=uniqueKeyList,
            dateModified=dateModified,
            reDatetime=reDate,
            replace=replace,
            dateCreated=dateCreated)
        dictList = dictList[1:]

    dbConn.autocommit(False)

    if len(dictList):

        total = len(dictList)
        batches = int(total / batchSize)

        start = 0
        end = 0
        sharedList = []
        for i in range(batches + 1):
            end = end + batchSize
            start = i * batchSize
            thisBatch = dictList[start:end]
            sharedList.append((thisBatch, end))

        totalCount = total + 1
        ltotalCount = totalCount

        print ""Starting to insert %(ltotalCount)s rows into %(dbTableName)s"" % locals()

        print dbSettings

        if dbSettings == False:

            fmultiprocess(
                log=log,
                function=_insert_single_batch_into_database,
                inputArray=range(len(sharedList)),
                dbTableName=dbTableName,
                uniqueKeyList=uniqueKeyList,
                dateModified=dateModified,
                replace=replace,
                batchSize=batchSize,
                reDatetime=reDate,
                dateCreated=dateCreated
            )

        else:
            fmultiprocess(log=log, function=_add_dictlist_to_database_via_load_in_file,
                          inputArray=range(len(sharedList)), dbTablename=dbTableName,
                          dbSettings=dbSettings, dateModified=dateModified)

        sys.stdout.write(""\x1b[1A\x1b[2K"")
        print ""%(ltotalCount)s / %(ltotalCount)s rows inserted into %(dbTableName)s"" % locals()

    log.debug(
        'completed the ``insert_list_of_dictionaries_into_database_tables`` function')
    return None"
3976,"def _insert_single_batch_into_database(
        batchIndex,
        log,
        dbTableName,
        uniqueKeyList,
        dateModified,
        replace,
        batchSize,
        reDatetime,
        dateCreated):
    """"""*summary of function*

    **Key Arguments:**
        - ``batchIndex`` -- the index of the batch to insert
        - ``dbConn`` -- mysql database connection
        - ``log`` -- logger

    **Return:**
        - None

    **Usage:**
        .. todo::

            add usage info
            create a sublime snippet for usage

        .. code-block:: python 

            usage code            
    """"""
    log.debug('starting the ``_insert_single_batch_into_database`` function')

    global totalCount
    global globalDbConn
    global sharedList

    batch = sharedList[batchIndex]

    reDate = reDatetime

    if isinstance(globalDbConn, dict):
        # SETUP ALL DATABASE CONNECTIONS

        dbConn = database(
            log=log,
            dbSettings=globalDbConn,
            autocommit=False
        ).connect()
    else:
        dbConn = globalDbConn

    count = batch[1]
    if count > totalCount:
        count = totalCount
    ltotalCount = totalCount

    inserted = False
    while inserted == False:

        if not replace:
            insertVerb = ""INSERT IGNORE""
        else:
            insertVerb = ""INSERT IGNORE""

        uniKeys = set().union(*(d.keys() for d in batch[0]))
        tmp = []
        tmp[:] = [m.replace("" "", ""_"").replace(
            ""-"", ""_"") for m in uniKeys]
        uniKeys = tmp

        myKeys = '`,`'.join(uniKeys)
        vals = [tuple([None if d[k] in [""None"", None] else str(d[k])
                       for k in uniKeys]) for d in batch[0]]
        valueString = (""%s, "" * len(vals[0]))[:-2]
        insertCommand = insertVerb + """""" INTO `"""""" + dbTableName + \
            """"""` (`"""""" + myKeys + """"""`, dateCreated) VALUES ("""""" + \
            valueString + """""", NOW())""""""

        if not dateCreated:
            insertCommand = insertCommand.replace(
                "", dateCreated)"", "")"").replace("", NOW())"", "")"")

        dup = """"
        if replace:
            dup = "" ON DUPLICATE KEY UPDATE ""
            for k in uniKeys:
                dup = """"""%(dup)s %(k)s=values(%(k)s),"""""" % locals()
            dup = """"""%(dup)s updated=1, dateLastModified=NOW()"""""" % locals()

        insertCommand = insertCommand + dup

        insertCommand = insertCommand.replace('\\""""', '\\"" ""')
        insertCommand = insertCommand.replace('""""', ""null"")
        insertCommand = insertCommand.replace('""None""', 'null')

        message = """"
        # log.debug('adding new data to the %s table; query: %s' %
        # (dbTableName, addValue))
        try:
            message = writequery(
                log=log,
                sqlQuery=insertCommand,
                dbConn=dbConn,
                Force=True,
                manyValueList=vals
            )
        except:
            theseInserts = []
            for aDict in batch[0]:

                insertCommand, valueTuple = convert_dictionary_to_mysql_table(
                    dbConn=dbConn,
                    log=log,
                    dictionary=aDict,
                    dbTableName=dbTableName,
                    uniqueKeyList=uniqueKeyList,
                    dateModified=dateModified,
                    returnInsertOnly=True,
                    replace=replace,
                    reDatetime=reDate,
                    skipChecks=True
                )
                theseInserts.append(valueTuple)

            message = """"
            # log.debug('adding new data to the %s table; query: %s' %
            # (dbTableName, addValue))
            message = writequery(
                log=log,
                sqlQuery=insertCommand,
                dbConn=dbConn,
                Force=True,
                manyValueList=theseInserts
            )

        if message == ""unknown column"":
            for aDict in batch:
                convert_dictionary_to_mysql_table(
                    dbConn=dbConn,
                    log=log,
                    dictionary=aDict,
                    dbTableName=dbTableName,
                    uniqueKeyList=uniqueKeyList,
                    dateModified=dateModified,
                    reDatetime=reDate,
                    replace=replace
                )
        else:
            inserted = True

        dbConn.commit()

    log.debug('completed the ``_insert_single_batch_into_database`` function')
    return ""None"""
3977,"def _add_dictlist_to_database_via_load_in_file(
        masterListIndex,
        log,
        dbTablename,
        dbSettings,
        dateModified=False):
    """"""*load a list of dictionaries into a database table with load data infile*

    **Key Arguments:**

        - ``masterListIndex`` -- the index of the sharedList of dictionary lists to process
        - ``dbTablename`` -- the name of the database table to add the list to
        - ``dbSettings`` -- the dictionary of database settings
        - ``log`` -- logger
        - ``dateModified`` -- add a dateModified stamp with an updated flag to rows?

    **Return:**
        - None

    **Usage:**
        .. todo::

            add usage info
            create a sublime snippet for usage

        .. code-block:: python

            usage code
    """"""
    log.debug('starting the ``_add_dictlist_to_database_via_load_in_file`` function')

    global sharedList

    dictList = sharedList[masterListIndex][0]

    count = sharedList[masterListIndex][1]
    if count > totalCount:
        count = totalCount
    ltotalCount = totalCount

    # SETUP ALL DATABASE CONNECTIONS
    dbConn = database(
        log=log,
        dbSettings=dbSettings
    ).connect()

    now = datetime.now()
    tmpTable = now.strftime(""tmp_%Y%m%dt%H%M%S%f"")

    # CREATE A TEMPORY TABLE TO ADD DATA TO
    sqlQuery = """"""CREATE TEMPORARY TABLE %(tmpTable)s SELECT * FROM %(dbTablename)s WHERE 1=0;"""""" % locals()
    writequery(
        log=log,
        sqlQuery=sqlQuery,
        dbConn=dbConn
    )

    csvColumns = [k for d in dictList for k in d.keys()]
    csvColumns = list(set(csvColumns))
    csvColumnsString = (', ').join(csvColumns)

    df = pd.DataFrame(dictList)
    df.replace(['nan', 'None', '', 'NaN', np.nan], '\\N', inplace=True)
    df.to_csv('/tmp/%(tmpTable)s' % locals(), sep=""|"",
              index=False, escapechar=""\\"", quotechar='""', columns=csvColumns, encoding='utf-8')

    sqlQuery = """"""LOAD DATA LOCAL INFILE '/tmp/%(tmpTable)s'
INTO TABLE %(tmpTable)s
FIELDS TERMINATED BY '|' OPTIONALLY ENCLOSED BY '""'
IGNORE 1 LINES
(%(csvColumnsString)s);"""""" % locals()

    writequery(
        log=log,
        sqlQuery=sqlQuery,
        dbConn=dbConn
    )

    updateStatement = """"
    for i in csvColumns:
        updateStatement += ""`%(i)s` = VALUES(`%(i)s`), "" % locals()
    if dateModified:
        updateStatement += ""dateLastModified = NOW(), updated = 1""
    else:
        updateStatement = updateStatement[0:-2]

    sqlQuery = """"""
INSERT IGNORE INTO %(dbTablename)s
SELECT * FROM %(tmpTable)s
ON DUPLICATE KEY UPDATE %(updateStatement)s;"""""" % locals()
    writequery(
        log=log,
        sqlQuery=sqlQuery,
        dbConn=dbConn
    )

    sqlQuery = """"""DROP TEMPORARY TABLE %(tmpTable)s;"""""" % locals()
    writequery(
        log=log,
        sqlQuery=sqlQuery,
        dbConn=dbConn
    )

    try:
        os.remove('/tmp/%(tmpTable)s' % locals())
    except:
        pass

    log.debug(
        'completed the ``_add_dictlist_to_database_via_load_in_file`` function')
    return None"
3978,"def make_directory(path):
        """""" Create directory if that not exists. """"""
        try:
            makedirs(path)
            logging.debug('Directory created: {0}'.format(path))

        except OSError as e:
            if e.errno != errno.EEXIST:
                raise"
3979,"def copy_file(self, from_path, to_path):
        """""" Copy file. """"""
        if not op.exists(op.dirname(to_path)):
            self.make_directory(op.dirname(to_path))

        shutil.copy(from_path, to_path)
        logging.debug('File copied: {0}'.format(to_path))"
3980,"def params(self):
        """""" Read self params from configuration. """"""
        parser = JinjaInterpolationNamespace()
        parser.read(self.configuration)
        return dict(parser['params'] or {})"
3981,"def scan(cls, path):
        """""" Scan directory for templates. """"""
        result = []
        try:
            for _p in listdir(path):
                try:
                    result.append(Template(_p, op.join(path, _p)))
                except ValueError:
                    continue
        except OSError:
            pass

        return result"
3982,"def copy(self):
        """""" Prepare and paste self templates. """"""
        templates = self.prepare_templates()
        if self.params.interactive:
            keys = list(self.parser.default)
            for key in keys:
                if key.startswith('_'):
                    continue
                prompt = ""{0} (default is \""{1}\"")? "".format(
                    key, self.parser.default[key])

                if _compat.PY2:
                    value = raw_input(prompt.encode('utf-8')).decode('utf-8')
                else:
                    value = input(prompt.encode('utf-8'))

                value = value.strip()
                if value:
                    self.parser.default[key] = value

        self.parser.default['templates'] = tt = ','.join(
            t.name for t in templates)
        logging.warning(""Paste templates: {0}"".format(tt))
        self.make_directory(self.params.TARGET)

        logging.debug(""\nDefault context:\n----------------"")
        logging.debug(
            ''.join('{0:<15} {1}\n'.format(*v)
                    for v in self.parser.default.items())
        )
        return [t.paste(
            **dict(self.parser.default.items())) for t in templates]"
3983,"def iterate_templates(self):
        """""" Iterate self starter templates.

        :returns: A templates generator

        """"""
        return [t for dd in self.dirs for t in Template.scan(dd)]"
3984,"def _dump_files_to_local_drive(bodies, theseUrls, log):
    """"""
    *takes the files stored in memory and dumps them to the local drive*

    ****Key Arguments:****
      - ``bodies`` -- array of file data (currently stored in memory)
      - ``theseUrls`` -- array of local files paths to dump the file data into
      - ``log`` -- the logger

    **Return:**
      - ``None``
    """"""
    j = 0
    log.debug(""attempting to write file data to local drive"")
    log.debug('%s URLS = %s' % (len(theseUrls), str(theseUrls),))
    for body in bodies:
        try:
            if theseUrls[j]:
                with open(theseUrls[j], 'w') as f:
                    f.write(body)
                f.close()
            j += 1
        except Exception, e:
            log.error(
                ""could not write downloaded file to local drive - failed with this error %s: "" %
                (str(e),))
            return -1
    return"
3985,"def register_shortcuts(self):
        '''
        .. versionchanged:: 0.14
            Add keyboard shortcuts to set neighbouring electrode states based
            on directional input using ``<Control>`` key plus the corresponding
            direction (e.g., ``<Control>Up``)
        '''
        def control_protocol(command):
            if self.plugin is not None:
                self.plugin.execute_async('microdrop.gui.protocol_controller',
                                          command)

        def actuate_direction(direction):
            if self.plugin is not None:
                self.plugin.execute_async('microdrop.electrode_controller_plugin',
                                          'set_electrode_direction_states',
                                          direction=direction)

        # Tie shortcuts to protocol controller commands (next, previous, etc.)
        shortcuts = {'<Control>r': lambda *args:
                     control_protocol('run_protocol'),
                     '<Control>z': lambda *args: self.undo(),
                     '<Control>y': lambda *args: self.redo(),
                     'A': lambda *args: control_protocol('first_step'),
                     'S': lambda *args: control_protocol('prev_step'),
                     'D': lambda *args: control_protocol('next_step'),
                     'F': lambda *args: control_protocol('last_step'),
                     '<Control>Up': lambda *args: actuate_direction('up'),
                     '<Control>Down': lambda *args: actuate_direction('down'),
                     '<Control>Left': lambda *args: actuate_direction('left'),
                     '<Control>Right': lambda *args:
                     actuate_direction('right')}
        register_shortcuts(self.widget.parent, shortcuts)"
3986,"def cleanup_video(self):
        '''
        .. versionchanged:: 0.6.1
            Log terminated video source process ID.
        '''
        if self.video_source_process is not None:
            self.video_source_process.terminate()
            logger.info('Terminated video process: %s',
                        self.video_source_process.pid)
            self.video_source_process = None"
3987,"def on_canvas_slave__electrode_selected(self, slave, data):
        '''
        .. versionchanged:: 0.11
            Clear any temporary routes (drawn while mouse is down) from routes
            list.

        .. versionchanged:: 0.11.3
            Clear temporary routes by setting ``df_routes`` property of
            :attr:`canvas_slave`.
        '''
        if self.plugin is None:
            return
        # XXX Negative `route_i` corresponds to temporary route being
        # drawn.  Since electrode selection terminates route drawing, clear any
        # rows corresponding to negative `route_i` values from the routes
        # table.
        slave.df_routes = slave.df_routes.loc[slave.df_routes.route_i >=
                                              0].copy()
        state = self.canvas_slave.electrode_states.get(data['electrode_id'], 0)
        self.plugin.execute_async('microdrop.electrode_controller_plugin',
                                  'set_electrode_states',
                                  electrode_states=pd
                                  .Series([not state],
                                          index=[data['electrode_id']]))"
3988,"def on_canvas_slave__electrode_pair_selected(self, slave, data):
        '''
        Process pair of selected electrodes.

        For now, this consists of finding the shortest path between the two
        electrodes and appending it to the list of droplet routes for the
        current step.

        Note that the droplet routes for a step are stored in a frame/table in
        the `DmfDeviceController` step options.


        .. versionchanged:: 0.11
            Clear any temporary routes (drawn while mouse is down) from routes
            list.

        .. versionchanged:: 0.11.3
            Clear temporary routes by setting ``df_routes`` property of
            :attr:`canvas_slave`.
        '''
        import networkx as nx

        source_id = data['source_id']
        target_id = data['target_id']

        if self.canvas_slave.device is None or self.plugin is None:
            return
        # XXX Negative `route_i` corresponds to temporary route being
        # drawn.  Since electrode pair selection terminates route drawing,
        # clear any rows corresponding to negative `route_i` values from the
        # routes table.
        slave.df_routes = slave.df_routes.loc[slave.df_routes.route_i >=
                                              0].copy()
        try:
            shortest_path = self.canvas_slave.device.find_path(source_id,
                                                               target_id)
            self.plugin.execute_async('droplet_planning_plugin',
                                      'add_route', drop_route=shortest_path)
        except nx.NetworkXNoPath:
            logger.error('No path found between %s and %s.', source_id,
                         target_id)"
3989,"def on_canvas_slave__route_electrode_added(self, slave, electrode_id):
        '''
        .. versionchanged:: 0.11
            Draw temporary route currently being formed.

        .. versionchanged:: 0.11.3
            Update routes table by setting ``df_routes`` property of
            :attr:`canvas_slave`.
        '''
        logger.debug('Route electrode added: %s', electrode_id)
        if slave._route.electrode_ids is None:
            return
        df_route = pd.DataFrame([[-1, e, i] for i, e in
                                 enumerate(slave._route.electrode_ids)],
                                columns=['route_i', 'electrode_i',
                                         'transition_i'])
        # XXX Negative `route_i` corresponds to temporary route being
        # drawn.  Append row entries for temporary route to existing routes
        # table.
        df_routes = slave.df_routes.loc[slave.df_routes.route_i >= 0].copy()
        self.canvas_slave.df_routes = pd.concat([df_routes, df_route])"
3990,"def ping_hub(self):
        '''
        Attempt to ping the ZeroMQ plugin hub to verify connection is alive.

        If ping is successful, record timestamp.
        If ping is unsuccessful, call `on_heartbeat_error` method.
        '''
        if self.plugin is not None:
            try:
                self.plugin.execute(self.plugin.hub_name, 'ping', timeout_s=1,
                                    silent=True)
            except IOError:
                self.on_heartbeat_error()
            else:
                self.heartbeat_alive_timestamp = datetime.now()
                logger.debug('Hub connection alive as of %s',
                             self.heartbeat_alive_timestamp)
                return True"
3991,"def on_electrode_states_updated(self, states):
        '''
        .. versionchanged:: 0.12
            Refactor to use :meth:`on_electrode_states_set`.
        '''
        states['electrode_states'] = \
            states['electrode_states'].combine_first(self.canvas_slave
                                                     .electrode_states)
        self.on_electrode_states_set(states)"
3992,"def on_electrode_states_set(self, states):
        '''
        Render and draw updated **static** electrode actuations layer on
        canvas.
        '''
        if (self.canvas_slave.electrode_states
                .equals(states['electrode_states'])):
            return

        self.canvas_slave.electrode_states = states['electrode_states']

        surface = self.canvas_slave.render_static_electrode_state_shapes()
        self.canvas_slave.set_surface('static_electrode_state_shapes', surface)
        self.canvas_slave.cairo_surface = flatten_surfaces(self.canvas_slave
                                                           .df_surfaces)
        gobject.idle_add(self.canvas_slave.draw)"
3993,"def on_dynamic_electrode_states_set(self, states):
        '''
        Render and draw updated **dynamic** electrode actuations layer on
        canvas.


        .. versionadded:: 0.12
        '''
        self.canvas_slave._dynamic_electrodes = states

        surface = self.canvas_slave.render_dynamic_electrode_state_shapes()
        self.canvas_slave.set_surface('dynamic_electrode_state_shapes',
                                      surface)
        self.canvas_slave.cairo_surface = flatten_surfaces(self.canvas_slave
                                                           .df_surfaces)
        gobject.idle_add(self.canvas_slave.draw)"
3994,"def set_video_config(self, video_config):
        '''
        .. versionchanged:: 0.6.1
            Log video source process ID.
        '''
        self.video_config = video_config
        if video_config is None:
            self.disable_video()
            return

        py_exe = sys.executable
        port = self.canvas_slave.video_sink.socket_info['port']
        transport = self.canvas_slave.video_sink.socket_info['transport']
        host = (self.canvas_slave.video_sink.socket_info['host']
                .replace('*', 'localhost'))

        # Terminate existing process (if running).
        self.cleanup_video()

        # Launch new video source process using JSON serialized video
        # configuration.
        command = [py_exe, '-m', 'pygst_utils.video_view.video_source',
                   'fromjson', '-p', str(port), transport, host,
                   video_config.to_json()]
        logger.info(' '.join(command))
        self.video_source_process = sp.Popen(command)
        logger.info('Launched video source process: %s',
                    self.video_source_process.pid)
        self.canvas_slave.enable()"
3995,"def on_canvas_slave__routes_set(self, slave, df_routes):
        '''
        .. versionadded:: 0.11.3
        '''
        self.canvas_slave.set_surface('routes',
                                      self.canvas_slave.render_routes())
        self.canvas_slave.cairo_surface = flatten_surfaces(self.canvas_slave
                                                           .df_surfaces)
        gtk.idle_add(self.canvas_slave.draw)"
3996,"def on_canvas_slave__global_command(self, slave, group, command, data):
        '''
        .. versionadded:: 0.13

            Execute global command (i.e., command not tied to a specific
            electrode or route).
        '''
        def command_callback(reply):
            _L().debug('%s.%s()', group, command)
            # Decode content to raise error, if necessary.
            try:
                decode_content_data(reply)
            except Exception:
                _L().error('Global command error.', exc_info=True)
        self.plugin.execute_async(group, command, callback=command_callback)"
3997,"def get_string_version(name,
                       default=DEFAULT_STRING_NOT_FOUND,
                       allow_ambiguous=True):
    """"""
    Get string version from installed package information.

    It will return :attr:`default` value when the named package is not
    installed.

    Parameters
    -----------
    name : string
        An application name used to install via setuptools.
    default : string
        A default returning value used when the named application is not
        installed yet
    allow_ambiguous : boolean
        ``True`` for allowing ambiguous version information.
        Turn this argument to ``False`` if ``get_string_version`` report wrong
        version.

    Returns
    --------
    string
        A version string or not found message (:attr:`default`)

    Examples
    --------
    >>> import re
    >>> v = get_string_version('app_version', allow_ambiguous=True)
    >>> re.match('^\d+.\d+\.\d+', v) is not None
    True
    >>> get_string_version('distribution_which_is_not_installed')
    'Please install this application with setup.py'
    """"""
    # get filename of callar
    callar = inspect.getouterframes(inspect.currentframe())[1][1]
    if callar.startswith('<doctest'):
        # called from doctest, find written script file
        callar = inspect.getouterframes(inspect.currentframe())[-1][1]
    # get version info from distribution
    try:
        di = get_distribution(name)
        installed_directory = os.path.join(di.location, name)
        if not callar.startswith(installed_directory) and not allow_ambiguous:
            # not installed, but there is another version that *is*
            raise DistributionNotFound
    except DistributionNotFound:
        return default
    else:
        return di.version"
3998,"def get_tuple_version(name,
                      default=DEFAULT_TUPLE_NOT_FOUND,
                      allow_ambiguous=True):
    """"""
    Get tuple version from installed package information for easy handling.

    It will return :attr:`default` value when the named package is not
    installed.

    Parameters
    -----------
    name : string
        An application name used to install via setuptools.
    default : tuple
        A default returning value used when the named application is not
        installed yet
    allow_ambiguous : boolean
        ``True`` for allowing ambiguous version information.

    Returns
    --------
    string
        A version tuple

    Examples
    --------
    >>> v = get_tuple_version('app_version', allow_ambiguous=True)
    >>> len(v) >= 3
    True
    >>> isinstance(v[0], int)
    True
    >>> isinstance(v[1], int)
    True
    >>> isinstance(v[2], int)
    True
    >>> get_tuple_version('distribution_which_is_not_installed')
    (0, 0, 0)
    """"""
    def _prefer_int(x):
        try:
            return int(x)
        except ValueError:
            return x
    version = get_string_version(name, default=default,
                                 allow_ambiguous=allow_ambiguous)
    # convert string version to tuple version
    # prefer integer for easy handling
    if isinstance(version, tuple):
        # not found
        return version
    return tuple(map(_prefer_int, version.split('.')))"
3999,"def get_versions(name,
                 default_string=DEFAULT_STRING_NOT_FOUND,
                 default_tuple=DEFAULT_TUPLE_NOT_FOUND,
                 allow_ambiguous=True):
    """"""
    Get string and tuple versions from installed package information

    It will return :attr:`default_string` and :attr:`default_tuple` values when
    the named package is not installed.

    Parameters
    -----------
    name : string
        An application name used to install via setuptools.
    default : string
        A default returning value used when the named application is not
        installed yet
    default_tuple : tuple
        A default returning value used when the named application is not
        installed yet
    allow_ambiguous : boolean
        ``True`` for allowing ambiguous version information.

    Returns
    --------
    tuple
        A version string and version tuple

    Examples
    --------
    >>> import re
    >>> v1, v2 = get_versions('app_version', allow_ambiguous=True)
    >>> isinstance(v1, str)
    True
    >>> isinstance(v2, tuple)
    True
    >>> get_versions('distribution_which_is_not_installed')
    ('Please install this application with setup.py', (0, 0, 0))
    """"""
    version_string = get_string_version(name, default_string, allow_ambiguous)
    version_tuple = get_tuple_version(name, default_tuple, allow_ambiguous)
    return version_string, version_tuple"
4000,"def _get_toSymbol(cls):
        # type: (_MetaRule) -> object
        """"""
        Get symbol from which the rule is rewrote.
        :param cls: Rule for which return the symbol.
        :return: Symbol from which the rule is rewrote.
        :raise RuleNotDefinedException: If the rule is not defined.
        :raise CantCreateSingleRuleException: If the rule consists of more rules.
        :raise NotASingleSymbolException: If number of symbols on the left is more.
        """"""
        if cls._traverse:
            raise RuleNotDefinedException(cls)
        if len(cls.rules) > 1:
            raise CantCreateSingleRuleException(cls)
        right = cls.rules[0][1]
        if len(right) > 1:
            raise NotASingleSymbolException(right)
        return right[0]"
4001,"def _get_fromSymbol(cls):
        # type: (_MetaRule) -> object
        """"""
        Get symbol to which the rule is rewrote.
        :param cls: Rule for which return the symbol.
        :return: Symbol to which the rule is rewrote.
        :raise RuleNotDefinedException: If the rule is not defined.
        :raise CantCreateSingleRuleException: If the rule consists of more rules.
        :raise NotASingleSymbolException: If number of symbols on the right is more.
        """"""
        if cls._traverse:
            raise RuleNotDefinedException(cls)
        if len(cls.rules) > 1:
            raise CantCreateSingleRuleException(cls)
        left = cls.rules[0][0]
        if len(left) > 1:
            raise NotASingleSymbolException(left)
        return left[0]"
4002,"def _get_right(cls):
        # type: (_MetaRule) -> List[object]
        """"""
        Get right part of the rule.
        :param cls: Rule for which return the right side.
        :return: Symbols on the right side of the array.
        :raise RuleNotDefinedException: If the rule is not defined.
        :raise CantCreateSingleRuleException: If the rule consists of more rules.
        :raise NotASingleSymbolException: If number of symbols on the left is more.
        """"""
        if cls._traverse:
            return [cls.toSymbol]
        if len(cls.rules) > 1:
            raise CantCreateSingleRuleException(cls)
        return cls.rules[0][1]"
4003,"def _get_left(cls):
        # type: (_MetaRule) -> List[object]
        """"""
        Get left part of the rule.
        :param cls: Rule for which return the left side.
        :return: Symbols on the left side of the array.
        :raise RuleNotDefinedException: If the rule is not defined.
        :raise CantCreateSingleRuleException: If the rule consists of more rules.
        :raise NotASingleSymbolException: If number of symbols on the left is more.
        """"""
        if cls._traverse:
            return [cls.fromSymbol]
        if len(cls.rules) > 1:
            raise CantCreateSingleRuleException(cls)
        return cls.rules[0][0]"
4004,"def _get_rule(cls):
        # type: (_MetaRule) -> (List[object], List[object])
        """"""
        Get rule on the Rule class.
        :param cls: Rule for which return the rule.
        :return: Rule inside the Rule class.
        :raise RuleNotDefinedException: If the rule is not defined.
        :raise CantCreateSingleRuleException: If the rule consists of more rules.
        :raise NotASingleSymbolException: If number of symbols on the left is more.
        """"""
        if cls._traverse:
            return (cls.left, cls.right)
        if len(cls.rules) > 1:
            raise CantCreateSingleRuleException(cls)
        return cls.rules[0]"
4005,"def _get_rules(cls):
        # type: (_MetaRule) -> List[(List[object], List[object])]
        """"""
        Get rules on the Rule class.
        :param cls: Rule for which return the rules.
        :return: Rules inside the Rule class.
        :raise RuleNotDefinedException: If the rule is not defined.
        :raise CantCreateSingleRuleException: If the rule consists of more rules.
        :raise NotASingleSymbolException: If number of symbols on the left is more.
        """"""
        cls._traverse = True
        r = cls.rule
        cls._traverse = False
        return [r]"
4006,"def _controlSide(cls, side, grammar):
        # type: (_MetaRule, List[object], Grammar) -> None
        """"""
        Validate one side of the rule.
        :param side: Iterable side of the rule.
        :param grammar: Grammar on which to validate.
        :raise RuleSyntaxException: If invalid syntax is use.
        :raise UselessEpsilonException: If useless epsilon is used.
        :raise TerminalDoesNotExistsException: If terminal does not exists in the grammar.
        :raise NonterminalDoesNotExistsException: If nonterminal does not exists in the grammar.
        """"""
        if not isinstance(side, list):
            raise RuleSyntaxException(cls, 'One side of rule is not enclose by list', side)
        if len(side) == 0:
            raise RuleSyntaxException(cls, 'One side of rule is not define', side)
        if EPS in side and len(side) > 1:
            raise UselessEpsilonException(cls)
        for symb in side:
            if isclass(symb) and issubclass(symb, Nonterminal):
                if symb not in grammar.nonterminals:
                    raise NonterminalDoesNotExistsException(cls, symb, grammar)
            elif symb is EPS:
                continue
            elif symb not in grammar.terminals:
                raise TerminalDoesNotExistsException(cls, symb, grammar)"
4007,"def validate(cls, grammar):
        # type: (_MetaRule, Grammar) -> None
        """"""
        Perform rules validation of the class.
        :param grammar: Grammar on which to validate.
        :raise RuleSyntaxException: If invalid syntax is used.
        :raise UselessEpsilonException: If epsilon used in rules in useless.
        :raise TerminalDoesNotExistsException: If terminal does not exists in the grammar.
        :raise NonterminalDoesNotExistsException: If nonterminal does not exists in the grammar.
        """"""
        # check if the rule is not defined multiple times
        defined = set(dir(cls))
        if 'rules' in defined and len(defined & {'rule', 'left', 'right', 'toSymbol', 'fromSymbol'}) > 0 or \
                'rule' in defined and len(defined & {'left', 'right', 'toSymbol', 'fromSymbol'}) > 0 or \
                'left' in defined and 'fromSymbol' in defined or \
                'right' in defined and 'toSymbol' in defined:
            raise MultipleDefinitionException(cls, 'Rule is defined multiple times')
        # check if the rule is defined properly
        all = cls.rules
        if not isinstance(all, list):
            raise RuleSyntaxException(cls, 'Rules property is not enclose in list')
        for rule in all:
            if not isinstance(rule, tuple):
                raise RuleSyntaxException(cls, 'One of the rules is not enclose in tuple', rule)
            if len(rule) != 2:
                raise RuleSyntaxException(cls, 'One of the rules does not have define left and right part', rule)
            left = rule[0]
            right = rule[1]
            cls._controlSide(left, grammar)
            cls._controlSide(right, grammar)
            if left == [EPS] and right == [EPS]:
                raise UselessEpsilonException(cls)"
4008,"def no_empty_value(func):
    """"""Raises an exception if function argument is empty.""""""
    @wraps(func)
    def wrapper(value):
        if not value:
            raise Exception(""Empty value not allowed"")
        return func(value)
    return wrapper"
4009,"def to_bool(value):
    """"""Converts human boolean-like values to Python boolean.

    Falls back to :class:`bool` when ``value`` is not recognized.

    :param value: the value to convert
    :returns: ``True`` if value is truthy, ``False`` otherwise
    :rtype: bool
    """"""
    cases = {
        '0': False,
        'false': False,
        'no': False,

        '1': True,
        'true': True,
        'yes': True,
    }
    value = value.lower() if isinstance(value, basestring) else value
    return cases.get(value, bool(value))"
4010,"def etree_to_dict(t, trim=True, **kw):
    u""""""Converts an lxml.etree object to Python dict.

    >>> etree_to_dict(etree.Element('root'))
    {'root': None}

    :param etree.Element t: lxml tree to convert
    :returns d: a dict representing the lxml tree ``t``
    :rtype: dict
    """"""
    d = {t.tag: {} if t.attrib else None}
    children = list(t)
    etree_to_dict_w_args = partial(etree_to_dict, trim=trim, **kw)

    if children:
        dd = defaultdict(list)
        d = {t.tag: {}}

        for dc in map(etree_to_dict_w_args, children):
            for k, v in dc.iteritems():
                # do not add Comment instance to the key
                if k is not etree.Comment:
                    dd[k].append(v)

        d[t.tag] = {k: v[0] if len(v) == 1 else v for k, v in dd.iteritems()}

    if t.attrib:
        d[t.tag].update(('@' + k, v) for k, v in t.attrib.iteritems())
    if trim and t.text:
        t.text = t.text.strip()
    if t.text:
        if t.tag is etree.Comment and not kw.get('without_comments'):
            # adds a comments node
            d['#comments'] = t.text
        elif children or t.attrib:
            d[t.tag]['#text'] = t.text
        else:
            d[t.tag] = t.text
    return d"
4011,"def dict_to_etree(d, root):
    u""""""Converts a dict to lxml.etree object.

    >>> dict_to_etree({'root': {'#text': 'node_text', '@attr': 'val'}}, etree.Element('root')) # doctest: +ELLIPSIS
    <Element root at 0x...>

    :param dict d: dict representing the XML tree
    :param etree.Element root: XML node which will be assigned the resulting tree
    :returns: Textual representation of the XML tree
    :rtype: str
    """"""
    def _to_etree(d, node):
        if d is None or len(d) == 0:
            return
        elif isinstance(d, basestring):
            node.text = d
        elif isinstance(d, dict):
            for k, v in d.items():
                assert isinstance(k, basestring)
                if k.startswith('#'):
                    assert k == '#text'
                    assert isinstance(v, basestring)
                    node.text = v
                elif k.startswith('@'):
                    assert isinstance(v, basestring)
                    node.set(k[1:], v)
                elif isinstance(v, list):
                    # No matter the child count, their parent will be the same.
                    sub_elem = etree.SubElement(node, k)

                    for child_num, e in enumerate(v):
                        if e is None:
                            if child_num == 0:
                                # Found the first occurrence of an empty child,
                                # skip creating of its XML repr, since it would be
                                # the same as ``sub_element`` higher up.
                                continue
                            # A list with None element means an empty child node
                            # in its parent, thus, recreating tags we have to go
                            # up one level.
                            # <node><child/></child></node> <=> {'node': 'child': [None, None]}
                            _to_etree(node, k)
                        else:
                            # If this isn't first child and it's a complex
                            # value (dict), we need to check if it's value
                            # is equivalent to None.
                            if child_num != 0 and not (isinstance(e, dict) and not all(e.values())):
                                # At least one child was None, we have to create
                                # a new parent-node, which will not be empty.
                                sub_elem = etree.SubElement(node, k)
                            _to_etree(e, sub_elem)
                else:
                    _to_etree(v, etree.SubElement(node, k))
        elif etree.iselement(d):
            # Supports the case, when we got an empty child and want to recreate it.
            etree.SubElement(d, node)
        else:
            raise AttributeError('Argument is neither dict nor basestring.')

    _to_etree(d, root)
    return root"
4012,"def objwalk(self, obj, path=(), memo=None):
        """"""Traverse a dictionary recursively and save path

        Taken from:
  http://code.activestate.com/recipes/577982-recursively-walk-python-objects/
""""""

        # dual python 2/3 compatability, inspired by the ""six"" library
        string_types = (str, unicode) if str is bytes else (str, bytes)
        iteritems = lambda mapping: getattr(mapping, 'iteritems', mapping.items)()

        if memo is None:
            memo = set()
        iterator = None
        if isinstance(obj, Mapping):
            iterator = iteritems
        elif isinstance(obj, (Sequence, Set)) and not isinstance(obj, string_types):
            iterator = enumerate
        if iterator:
            if id(obj) not in memo:
                memo.add(id(obj))
                for path_component, value in iterator(obj):
                    for result in self.objwalk(value, path + (path_component,), memo):
                        yield result
                memo.remove(id(obj))
        else:
            yield path, obj"
4013,"def set_cache_dir(directory):
    """"""Set the directory to cache JSON responses from most API endpoints.
    """"""
    global cache_dir

    if directory is None:
        cache_dir = None
        return

    if not os.path.exists(directory):
        os.makedirs(directory)
    if not os.path.isdir(directory):
        raise ValueError(""not a directory"")
    cache_dir = directory"
4014,"def create_element_tree(elem_or_name=None, text=None, **attribute_kwargs):
    """"""
    Creates an ElementTree from elem_or_name, updated it with text and attributes.
    If elem_or_name is None, a permanently empty ElementTree is returned.
    :param elem_or_name: an Element or the name of the root element tag
    :param text: optional text with which to update the root element
    :param attribute_kwargs: optional attributes to add to the root element
    :return: a new ElementTree with the specified root and attributes
    """"""

    if elem_or_name is None:
        return ElementTree()

    is_elem = isinstance(elem_or_name, ElementType)
    element = elem_or_name if is_elem else Element(elem_or_name)

    if text is not None:
        element.text = text

    element.attrib.update(attribute_kwargs)

    return ElementTree(element)"
4015,"def clear_children(parent_to_parse, element_path=None):
    """"""
    Clears only children (not text or attributes) from the parsed parent
    or named element.
    """"""

    element = get_element(parent_to_parse, element_path)

    if element is None:
        return parent_to_parse
    else:
        elem_txt = element.text
        elem_atr = element.attrib

        element.clear()

        element.text = elem_txt
        element.attrib = elem_atr

    return element"
4016,"def clear_element(parent_to_parse, element_path=None):
    """"""
    Clears everything (text, attributes and children) from the parsed parent
    or named element.
    """"""

    element = get_element(parent_to_parse, element_path)

    if element is None:
        return parent_to_parse
    else:
        element.clear()

    return element"
4017,"def copy_element(from_element, to_element=None, path_to_copy=None):
    """"""
    Copies the element at path_to_copy in from_element and uses it to create or update
    the first element found at the same location (path_to_copy) in to_element.

    If path_to_copy is not provided, from_element is copied to the root of to_element.
    """"""

    from_element = get_element(from_element, path_to_copy)
    dest_element = get_element(to_element, path_to_copy)

    if from_element is None:
        return None

    if dest_element is None:
        if path_to_copy is None:
            dest_element = Element(from_element.tag)
        else:
            dest_element = insert_element(Element(from_element.tag), 0, path_to_copy)

    dest_element.tag = from_element.tag
    dest_element.text = from_element.text
    dest_element.tail = from_element.tail
    dest_element.attrib = from_element.attrib

    copied_children = []

    for elem in from_element:
        copied_children.append(copy_element(elem))

    for idx, child in enumerate(copied_children):
        dest_element.insert(idx, child)

    return dest_element"
4018,"def get_element_tree(parent_to_parse):
    """"""
    :return: an ElementTree initialized with the parsed element.
    :see: get_element(parent_to_parse, element_path)
    """"""

    if isinstance(parent_to_parse, ElementTree):
        return parent_to_parse

    element = get_element(parent_to_parse)

    return ElementTree() if element is None else ElementTree(element)"
4019,"def get_element(parent_to_parse, element_path=None):
    """"""
    :return: an element from the parent or parsed from a Dictionary, XML string
    or file. If element_path is not provided the root element is returned.
    """"""

    if parent_to_parse is None:
        return None

    elif isinstance(parent_to_parse, ElementTree):
        parent_to_parse = parent_to_parse.getroot()

    elif hasattr(parent_to_parse, 'read'):
        parent_to_parse = string_to_element(parent_to_parse.read())

    elif isinstance(parent_to_parse, STRING_TYPES):
        parent_to_parse = string_to_element(parent_to_parse)

    elif isinstance(parent_to_parse, dict):
        parent_to_parse = dict_to_element(parent_to_parse)

    if parent_to_parse is None:
        return None
    elif not isinstance(parent_to_parse, ElementType):
        element_type = type(parent_to_parse).__name__
        raise TypeError('Invalid element type: {0}'.format(element_type))

    return parent_to_parse.find(element_path) if element_path else parent_to_parse"
4020,"def get_remote_element(url, element_path=None):
    """"""
    :return: an element initialized with the content at the specified file or URL
    :see: get_element(parent_to_parse, element_path)
    """"""

    content = None

    if url is None:
        return content
    elif _FILE_LOCATION_REGEX.match(url):
        with open(url, 'rb') as xml:
            content = xml.read()
    else:
        try:
            urllib = getattr(six_moves, 'urllib')
            remote = urllib.request.urlopen(url)
            content = remote.read()
        finally:
            # For Python 2 compliance: fails in `with` block (no `__exit__`)
            remote.close()

    return get_element(strip_namespaces(content), element_path)"
4021,"def elements_exist(elem_to_parse, element_paths=None, all_exist=False):
    """"""
    :return: true if any of the named elements exist in the parent by default,
    unless all_exist is true, in which case all the named elements must exist
    """"""

    element = get_element(elem_to_parse)

    if element is None:
        return False

    if not element_paths or isinstance(element_paths, string_types):
        return element_exists(element, element_paths)

    exists = False

    for element_path in element_paths:
        exists = element_exists(element, element_path)

        if all_exist and not exists:
            return False

        if exists and not all_exist:
            return True

    return exists"
4022,"def element_is_empty(elem_to_parse, element_path=None):
    """"""
    Returns true if the element is None, or has no text, tail, children or attributes.
    Whitespace in the element is stripped from text and tail before making the determination.
    """"""

    element = get_element(elem_to_parse, element_path)

    if element is None:
        return True

    is_empty = (
        (element.text is None or not element.text.strip()) and
        (element.tail is None or not element.tail.strip()) and
        (element.attrib is None or not len(element.attrib)) and
        (not len(element.getchildren()))
    )

    return is_empty"
4023,"def insert_element(elem_to_parse, elem_idx, elem_path, elem_txt=u'', **attrib_kwargs):
    """"""
    Creates an element named after elem_path, containing elem_txt, with kwargs
    as attributes, inserts it into elem_to_parse at elem_idx and returns it.

    If elem_path is an XPATH pointing to a non-existent element, elements not
    in the path are inserted and the text and index are applied to the last one.

    If elem_path is an XPATH pointing to an existing element, the new element is
    inserted as a sibling of the last one in the path at the index specified.
    """"""

    element = get_element(elem_to_parse)

    if element is None or not elem_path:
        return None

    if not elem_idx:
        elem_idx = 0

    if elem_path and XPATH_DELIM in elem_path:
        tags = elem_path.split(XPATH_DELIM)

        if element_exists(element, elem_path):

            # Get the next to last element in the XPATH
            parent = get_element(element, XPATH_DELIM.join(tags[:-1]))

            # Insert the new element as sibling to the last one
            return insert_element(parent, elem_idx, tags[-1], elem_txt, **attrib_kwargs)

        else:
            this_elem = element
            last_idx = len(tags) - 1

            # Iterate over tags from root to leaf
            for idx, tag in enumerate(tags):
                next_elem = get_element(this_elem, tag)

                # Insert missing elements in the path or continue
                if next_elem is None:

                    # Apply text and index to last element only
                    if idx == last_idx:
                        next_elem = insert_element(this_elem, elem_idx, tag, elem_txt, **attrib_kwargs)
                    else:
                        next_elem = insert_element(this_elem, 0, tag, u'', **attrib_kwargs)

                this_elem = next_elem

            return this_elem

    subelem = Element(elem_path, attrib_kwargs)
    subelem.text = elem_txt

    element.insert(elem_idx, subelem)

    return subelem"
4024,"def remove_element(parent_to_parse, element_path, clear_empty=False):
    """"""
    Searches for a sub-element named after element_name in the parsed element,
    and if it exists, removes them all and returns them as a list.
    If clear_empty is True, removes empty parents if all children are removed.
    :see: remove_empty_element(parent_to_parse, element_path, target_element=None)
    :see: get_element(parent_to_parse, element_path)
    """"""

    element = get_element(parent_to_parse)
    removed = []

    if element is None or not element_path:
        return None

    if element_exists(element, element_path):
        if XPATH_DELIM not in element_path:
            for subelem in get_elements(element, element_path):
                removed.append(subelem)
                element.remove(subelem)
        else:
            xpath_segments = element_path.split(XPATH_DELIM)
            parent_segment = XPATH_DELIM.join(xpath_segments[:-1])
            last_segment = xpath_segments[-1]

            for parent in get_elements(element, parent_segment):
                rem = remove_element(parent, last_segment)
                removed.extend(rem if isinstance(rem, list) else [rem])

            if clear_empty:
                removed.extend(remove_empty_element(element, parent_segment))

    return removed[0] if len(removed) == 1 else (removed or None)"
4025,"def remove_elements(parent_to_parse, element_paths, clear_empty=False):
    """"""
    Removes all elements named after each elements_or_paths. If clear_empty is True,
    for each XPATH, empty parents are removed if all their children are removed.
    :see: remove_element(parent_to_parse, element_path)
    """"""

    element = get_element(parent_to_parse)
    removed = []

    if element is None or not element_paths:
        return removed

    if isinstance(element_paths, string_types):
        rem = remove_element(element, element_paths, clear_empty)
        removed.extend(rem if isinstance(rem, list) else [rem])
    else:
        for xpath in element_paths:
            rem = remove_element(element, xpath, clear_empty)
            removed.extend(rem if isinstance(rem, list) else [rem])

    return removed"
4026,"def remove_empty_element(parent_to_parse, element_path, target_element=None):
    """"""
    Searches for all empty sub-elements named after element_name in the parsed element,
    and if it exists, removes them all and returns them as a list.
    """"""

    element = get_element(parent_to_parse)
    removed = []

    if element is None or not element_path:
        return removed

    if target_element:

        # Always deal with just the element path
        if not element_path.endswith(target_element):
            element_path = XPATH_DELIM.join([element_path, target_element])
        target_element = None

    if XPATH_DELIM not in element_path:

        # Loop over and remove empty sub-elements directly
        for subelem in get_elements(element, element_path):
            if element_is_empty(subelem):
                removed.append(subelem)
                element.remove(subelem)
    else:
        # Parse target element from last node in element path
        xpath_segments = element_path.split(XPATH_DELIM)
        element_path = XPATH_DELIM.join(xpath_segments[:-1])
        target_element = xpath_segments[-1]

        # Loop over children and remove empty ones directly
        for parent in get_elements(element, element_path):
            for child in get_elements(parent, target_element):
                if element_is_empty(child):
                    removed.append(child)
                    parent.remove(child)

            # Parent may be empty now: recursively remove empty elements in XPATH
            if element_is_empty(parent):
                if len(xpath_segments) == 2:
                    removed.extend(remove_empty_element(element, xpath_segments[0]))
                else:
                    next_element_path = XPATH_DELIM.join(xpath_segments[:-2])
                    next_target_element = parent.tag

                    removed.extend(remove_empty_element(element, next_element_path, next_target_element))

    return removed"
4027,"def get_elements(parent_to_parse, element_path):
    """"""
    :return: all elements by name from the parsed parent element.
    :see: get_element(parent_to_parse, element_path)
    """"""

    element = get_element(parent_to_parse)

    if element is None or not element_path:
        return []

    return element.findall(element_path)"
4028,"def get_element_attribute(elem_to_parse, attrib_name, default_value=u''):
    """"""
    :return: an attribute from the parsed element if it has the attribute,
    otherwise the default value
    """"""

    element = get_element(elem_to_parse)

    if element is None:
        return default_value

    return element.attrib.get(attrib_name, default_value)"
4029,"def get_element_attributes(parent_to_parse, element_path=None):
    """"""
    :return: all the attributes for the parsed element if it has any, or an empty dict
    """"""

    element = get_element(parent_to_parse, element_path)

    return {} if element is None else element.attrib"
4030,"def set_element_attributes(elem_to_parse, **attrib_kwargs):
    """"""
    Adds the specified key/value pairs to the element's attributes, and
    returns the updated set of attributes.

    If the element already contains any of the attributes specified in
    attrib_kwargs, they are updated accordingly.
    """"""

    element = get_element(elem_to_parse)

    if element is None:
        return element

    if len(attrib_kwargs):
        element.attrib.update(attrib_kwargs)

    return element.attrib"
4031,"def remove_element_attributes(elem_to_parse, *args):
    """"""
    Removes the specified keys from the element's attributes, and
    returns a dict containing the attributes that have been removed.
    """"""

    element = get_element(elem_to_parse)

    if element is None:
        return element

    if len(args):
        attribs = element.attrib
        return {key: attribs.pop(key) for key in args if key in attribs}

    return {}"
4032,"def get_element_tail(parent_to_parse, element_path=None, default_value=u''):
    """"""
    :return: text following the parsed parent element if it exists,
    otherwise the default value.
    :see: get_element(parent_to_parse, element_path)
    """"""

    parent_element = get_element(parent_to_parse, element_path)

    if parent_element is None:
        return default_value

    if parent_element.tail:
        return parent_element.tail.strip() or default_value

    return default_value"
4033,"def get_element_text(parent_to_parse, element_path=None, default_value=u''):
    """"""
    :return: text from the parsed parent element if it has a text value,
    otherwise the default value.
    :see: get_element(parent_to_parse, element_path)
    """"""

    parent_element = get_element(parent_to_parse, element_path)

    if parent_element is None:
        return default_value

    if parent_element.text:
        return parent_element.text.strip() or default_value

    return default_value"
4034,"def get_elements_attributes(parent_to_parse, element_path=None, attrib_name=None):
    """"""
    :return: list of text representing an attribute of parent or each element at element path,
             or a list of dicts representing all the attributes parsed from each element
    """"""

    attrs = _get_elements_property(parent_to_parse, element_path, 'attrib')

    if not attrib_name:
        return attrs

    return [attr[attrib_name] for attr in attrs if attrib_name in attr]"
4035,"def _get_elements_property(parent_to_parse, element_path, prop_name):
    """""" A helper to construct a list of values from """"""

    parent_element = get_element(parent_to_parse)

    if parent_element is None:
        return []

    if element_path and not element_exists(parent_element, element_path):
        return []

    if not element_path:
        texts = getattr(parent_element, prop_name)
        texts = texts.strip() if isinstance(texts, string_types) else texts
        texts = [texts] if texts else []
    else:
        texts = [t for t in (
            prop.strip() if isinstance(prop, string_types) else prop
            for prop in (getattr(node, prop_name) for node in parent_element.findall(element_path)) if prop
        ) if t]

    return texts"
4036,"def set_element_tail(parent_to_parse, element_path=None, element_tail=u''):
    """"""
    Assigns the text following the parsed parent element and then returns it.
    If element_path is provided and doesn't exist, it is inserted with element_tail.
    :see: get_element(parent_to_parse, element_path)
    """"""

    return _set_element_property(parent_to_parse, element_path, _ELEM_TAIL, element_tail)"
4037,"def set_element_text(parent_to_parse, element_path=None, element_text=u''):
    """"""
    Assigns a string value to the parsed parent element and then returns it.
    If element_path is provided and doesn't exist, it is inserted with element_text.
    :see: get_element(parent_to_parse, element_path)
    """"""

    return _set_element_property(parent_to_parse, element_path, _ELEM_TEXT, element_text)"
4038,"def _set_element_property(parent_to_parse, element_path, prop_name, value):
    """""" Assigns the value to the parsed parent element and then returns it """"""

    element = get_element(parent_to_parse)

    if element is None:
        return None

    if element_path and not element_exists(element, element_path):
        element = insert_element(element, 0, element_path)

    if not isinstance(value, string_types):
        value = u''

    setattr(element, prop_name, value)

    return element"
4039,"def set_elements_tail(parent_to_parse, element_path=None, tail_values=None):
    """"""
    Assigns an array of tail values to each of the elements parsed from the parent. The
    tail values are assigned in the same order they are provided.
    If there are less values then elements, the remaining elements are skipped; but if
    there are more, new elements will be inserted for each with the remaining tail values.
    """"""

    if tail_values is None:
        tail_values = []

    return _set_elements_property(parent_to_parse, element_path, _ELEM_TAIL, tail_values)"
4040,"def set_elements_text(parent_to_parse, element_path=None, text_values=None):
    """"""
    Assigns an array of text values to each of the elements parsed from the parent. The
    text values are assigned in the same order they are provided.
    If there are less values then elements, the remaining elements are skipped; but if
    there are more, new elements will be inserted for each with the remaining text values.
    """"""

    if text_values is None:
        text_values = []

    return _set_elements_property(parent_to_parse, element_path, _ELEM_TEXT, text_values)"
4041,"def _set_elements_property(parent_to_parse, element_path, prop_name, values):
    """"""
    Assigns an array of string values to each of the elements parsed from the parent.
    The values must be strings, and they are assigned in the same order they are provided.
    The operation stops when values run out; extra values will be inserted as new elements.
    :see: get_element(parent_to_parse, element_path)
    """"""

    element = get_element(parent_to_parse)

    if element is None or not values:
        return []

    if isinstance(values, string_types):
        values = [values]

    if not element_path:
        return [_set_element_property(element, None, prop_name, values[0])]

    elements = get_elements(element, element_path)
    affected = []

    for idx, val in enumerate(values):
        if idx < len(elements):
            next_elem = elements[idx]
        else:
            next_elem = insert_element(element, idx, element_path)

        affected.append(
            _set_element_property(next_elem, None, prop_name, val)
        )

    return affected"
4042,"def dict_to_element(element_as_dict):
    """"""
    Converts a Dictionary object to an element. The Dictionary can
    include any of the following tags, only name is required:
        - name (required): the name of the element tag
        - text: the text contained by element
        - tail: text immediately following the element
        - attributes: a Dictionary containing element attributes
        - children: a List of converted child elements
    """"""

    if element_as_dict is None:
        return None
    elif isinstance(element_as_dict, ElementTree):
        return element_as_dict.getroot()
    elif isinstance(element_as_dict, ElementType):
        return element_as_dict
    elif not isinstance(element_as_dict, dict):
        raise TypeError('Invalid element dict: {0}'.format(element_as_dict))

    if len(element_as_dict) == 0:
        return None

    try:
        converted = Element(
            element_as_dict[_ELEM_NAME],
            element_as_dict.get(_ELEM_ATTRIBS, {})
        )

        converted.tail = element_as_dict.get(_ELEM_TAIL, u'')
        converted.text = element_as_dict.get(_ELEM_TEXT, u'')

        for child in element_as_dict.get(_ELEM_CHILDREN, []):
            converted.append(dict_to_element(child))

    except KeyError:
        raise SyntaxError('Invalid element dict: {0}'.format(element_as_dict))

    return converted"
4043,"def element_to_dict(elem_to_parse, element_path=None, recurse=True):
    """"""
    :return: an element losslessly as a dictionary. If recurse is True,
    the element's children are included, otherwise they are omitted.

    The resulting Dictionary will have the following attributes:
        - name: the name of the element tag
        - text: the text contained by element
        - tail: text immediately following the element
        - attributes: a Dictionary containing element attributes
        - children: a List of converted child elements
    """"""

    element = get_element(elem_to_parse, element_path)

    if element is not None:
        converted = {
            _ELEM_NAME: element.tag,
            _ELEM_TEXT: element.text,
            _ELEM_TAIL: element.tail,
            _ELEM_ATTRIBS: element.attrib,
            _ELEM_CHILDREN: []
        }

        if recurse is True:
            for child in element:
                converted[_ELEM_CHILDREN].append(element_to_dict(child, recurse=recurse))

        return converted

    return {}"
4044,"def element_to_object(elem_to_parse, element_path=None):
    """"""
    :return: the root key, and a dict with all the XML data, but without preserving structure, for instance:

    <elem val=""attribute""><val>nested text</val><val prop=""attr"">nested dict text</val>nested dict tail</elem>
    {'elem': {
        'val': [
            u'nested text',
            {'prop': u'attr', 'value': [u'nested dict text', u'nested dict tail']},
            u'attribute'
        ]
    }}
    """"""

    if isinstance(elem_to_parse, STRING_TYPES) or hasattr(elem_to_parse, 'read'):
        # Always strip namespaces if not already parsed
        elem_to_parse = strip_namespaces(elem_to_parse)

    if element_path is not None:
        elem_to_parse = get_element(elem_to_parse, element_path)

    element_tree = get_element_tree(elem_to_parse)
    element_root = element_tree.getroot()
    root_tag = u'' if element_root is None else element_root.tag

    return root_tag, {root_tag: _element_to_object(element_root)}"
4045,"def element_to_string(element, include_declaration=True, encoding=DEFAULT_ENCODING, method='xml'):
    """""" :return: the string value of the element or element tree """"""

    if isinstance(element, ElementTree):
        element = element.getroot()
    elif not isinstance(element, ElementType):
        element = get_element(element)

    if element is None:
        return u''

    element_as_string = tostring(element, encoding, method).decode(encoding=encoding)
    if include_declaration:
        return element_as_string
    else:
        return strip_xml_declaration(element_as_string)"
4046,"def string_to_element(element_as_string, include_namespaces=False):
    """""" :return: an element parsed from a string value, or the element as is if already parsed """"""

    if element_as_string is None:
        return None
    elif isinstance(element_as_string, ElementTree):
        return element_as_string.getroot()
    elif isinstance(element_as_string, ElementType):
        return element_as_string
    else:
        element_as_string = _xml_content_to_string(element_as_string)

    if not isinstance(element_as_string, string_types):
        # Let cElementTree handle the error
        return fromstring(element_as_string)
    elif not strip_xml_declaration(element_as_string):
        # Same as ElementTree().getroot()
        return None
    elif include_namespaces:
        return fromstring(element_as_string)
    else:
        return fromstring(strip_namespaces(element_as_string))"
4047,"def iter_elements(element_function, parent_to_parse, **kwargs):
    """"""
    Applies element_function to each of the sub-elements in parent_to_parse.
    The passed in function must take at least one element, and an optional
    list of kwargs which are relevant to each of the elements in the list:
        def elem_func(each_elem, **kwargs)
    """"""

    parent = get_element(parent_to_parse)

    if not hasattr(element_function, '__call__'):
        return parent

    for child in ([] if parent is None else parent):
        element_function(child, **kwargs)

    return parent"
4048,"def iterparse_elements(element_function, file_or_path, **kwargs):
    """"""
    Applies element_function to each of the sub-elements in the XML file.
    The passed in function must take at least one element, and an optional
    list of **kwarg which are relevant to each of the elements in the list:
        def elem_func(each_elem, **kwargs)

    Implements the recommended cElementTree iterparse pattern, which is
    efficient for reading in a file, making changes and writing it again.
    """"""

    if not hasattr(element_function, '__call__'):
        return

    file_path = getattr(file_or_path, 'name', file_or_path)
    context = iter(iterparse(file_path, events=('start', 'end')))
    root = None  # Capture root for Memory management

    # Start event loads child; by the End event it's ready for processing

    for event, child in context:
        if root is None:
            root = child
        if event == 'end':  # Ensures the element has been fully read
            element_function(child, **kwargs)
            root.clear()"
4049,"def strip_namespaces(file_or_xml):
    """"""
    Removes all namespaces from the XML file or string passed in.
    If file_or_xml is not a file or string, it is returned as is.
    """"""

    xml_content = _xml_content_to_string(file_or_xml)
    if not isinstance(xml_content, string_types):
        return xml_content

    # This pattern can have overlapping matches, necessitating the loop
    while _NAMESPACES_FROM_DEC_REGEX.search(xml_content) is not None:
        xml_content = _NAMESPACES_FROM_DEC_REGEX.sub(r'\1', xml_content)

    # Remove namespaces at the tag level
    xml_content = _NAMESPACES_FROM_TAG_REGEX.sub(r'\1', xml_content)

    # Remove namespaces at the attribute level
    xml_content = _NAMESPACES_FROM_ATTR_REGEX.sub(r'\1\3', xml_content)

    return xml_content"
4050,"def strip_xml_declaration(file_or_xml):
    """"""
    Removes XML declaration line from file or string passed in.
    If file_or_xml is not a file or string, it is returned as is.
    """"""

    xml_content = _xml_content_to_string(file_or_xml)
    if not isinstance(xml_content, string_types):
        return xml_content

    # For Python 2 compliance: replacement string must not specify unicode u''
    return _XML_DECLARATION_REGEX.sub(r'', xml_content, 1)"
4051,"def write_element(elem_to_parse, file_or_path, encoding=DEFAULT_ENCODING):
    """"""
    Writes the contents of the parsed element to file_or_path
    :see: get_element(parent_to_parse, element_path)
    """"""

    xml_header = '<?xml version=""1.0"" encoding=""{0}""?>'.format(encoding)

    get_element_tree(elem_to_parse).write(file_or_path, encoding, xml_header)"
4052,"def floating_point_to_datetime(day, fp_time):
    """"""Convert a floating point time to a datetime.""""""
    result = datetime(year=day.year, month=day.month, day=day.day)
    result += timedelta(minutes=math.ceil(60 * fp_time))
    return result"
4053,"def adhan(day, location, parameters, timezone_offset=0):
    """"""Calculate adhan times given the parameters.

    This function will compute the adhan times for a certain location on
    certain day. The method for calculating the prayers as well as the time for
    Asr can also be specified. The timezone offset naively adds the specified
    number of hours to each time that is returned.

    :param day: The datetime.date to calculate for
    :param location: 2-tuple of floating point coordiantes for latitude and
                     longitude of location in degrees
    :param parameters: A dictionary-like object of parameters for computing
                       adhan times. Commonly used calculation methods are
                       available in the adhan.methods module
    :param timezone_offset: The number of hours to add to each prayer time
                            to account for timezones. Can be floating point

    """"""
    latitude, longitude = location

    #
    # To reduce a little repetitiveness, using a partial function that has the
    # day and latitude already set
    #
    time_at_sun_angle = partial(
        compute_time_at_sun_angle,
        day=day,
        latitude=latitude
    )

    zuhr_time = compute_zuhr_utc(day, longitude)

    shuruq_time = zuhr_time - time_at_sun_angle(angle=SUNRISE_ANGLE)
    maghrib_time = zuhr_time + time_at_sun_angle(angle=SUNSET_ANGLE)

    fajr_time = zuhr_time - time_at_sun_angle(angle=parameters['fajr_angle'])

    #
    # Most methods define Isha as a certain angle the sun has to be below
    # the horizon, but some methods define it as a certain number of minutes
    # after Maghrib
    #
    if parameters.get('isha_delay', None):
        isha_time = maghrib_time + parameters['isha_delay']
    else:
        isha_time = (
            zuhr_time +
            time_at_sun_angle(angle=parameters['isha_angle'])
        )

    #
    # Default to standard Asr method if not specified
    #
    asr_multiplier = parameters.get('asr_multiplier', ASR_STANDARD)
    asr_time = zuhr_time + time_at_shadow_length(
        day=day, latitude=latitude, multiplier=asr_multiplier
    )

    offset = timedelta(minutes=60 * timezone_offset)
    return {
        'fajr': floating_point_to_datetime(day, fajr_time) + offset,
        'zuhr': floating_point_to_datetime(day, zuhr_time) + offset,
        'shuruq': floating_point_to_datetime(day, shuruq_time) + offset,
        'asr': floating_point_to_datetime(day, asr_time) + offset,
        'maghrib': floating_point_to_datetime(day, maghrib_time) + offset,
        'isha': floating_point_to_datetime(day, isha_time) + offset,
    }"
4054,"def _make_fn_text(self):
        """"""Makes filename text""""""
        if not self._f:
            text = ""(not loaded)""
        elif self._f.filename:
            text = os.path.relpath(self._f.filename, ""."")
        else:
            text = ""(filename not set)""
        return text"
4055,"def format_BLB():
    """"""Sets some formatting options in Matplotlib.""""""
    rc(""figure"", facecolor=""white"")
    rc('font', family = 'serif', size=10) #, serif = 'cmr10')
    rc('xtick', labelsize=10)
    rc('ytick', labelsize=10)
    rc('axes', linewidth=1)
    rc('xtick.major', size=4, width=1)
    rc('xtick.minor', size=2, width=1)
    rc('ytick.major', size=4, width=1)
    rc('ytick.minor', size=2, width=1)"
4056,"def set_figure_size(fig, width, height):
    """"""Sets MatPlotLib figure width and height in pixels

    Reference: https://github.com/matplotlib/matplotlib/issues/2305/
    """"""
    dpi = float(fig.get_dpi())
    fig.set_size_inches(float(width) / dpi, float(height) / dpi)"
4057,"def create_zip_codes_geo_zone(cls, zip_codes_geo_zone, **kwargs):
        """"""Create ZipCodesGeoZone

        Create a new ZipCodesGeoZone
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_zip_codes_geo_zone(zip_codes_geo_zone, async=True)
        >>> result = thread.get()

        :param async bool
        :param ZipCodesGeoZone zip_codes_geo_zone: Attributes of zipCodesGeoZone to create (required)
        :return: ZipCodesGeoZone
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_zip_codes_geo_zone_with_http_info(zip_codes_geo_zone, **kwargs)
        else:
            (data) = cls._create_zip_codes_geo_zone_with_http_info(zip_codes_geo_zone, **kwargs)
            return data"
4058,"def delete_zip_codes_geo_zone_by_id(cls, zip_codes_geo_zone_id, **kwargs):
        """"""Delete ZipCodesGeoZone

        Delete an instance of ZipCodesGeoZone by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_zip_codes_geo_zone_by_id(zip_codes_geo_zone_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str zip_codes_geo_zone_id: ID of zipCodesGeoZone to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_zip_codes_geo_zone_by_id_with_http_info(zip_codes_geo_zone_id, **kwargs)
        else:
            (data) = cls._delete_zip_codes_geo_zone_by_id_with_http_info(zip_codes_geo_zone_id, **kwargs)
            return data"
4059,"def get_zip_codes_geo_zone_by_id(cls, zip_codes_geo_zone_id, **kwargs):
        """"""Find ZipCodesGeoZone

        Return single instance of ZipCodesGeoZone by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_zip_codes_geo_zone_by_id(zip_codes_geo_zone_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str zip_codes_geo_zone_id: ID of zipCodesGeoZone to return (required)
        :return: ZipCodesGeoZone
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_zip_codes_geo_zone_by_id_with_http_info(zip_codes_geo_zone_id, **kwargs)
        else:
            (data) = cls._get_zip_codes_geo_zone_by_id_with_http_info(zip_codes_geo_zone_id, **kwargs)
            return data"
4060,"def list_all_zip_codes_geo_zones(cls, **kwargs):
        """"""List ZipCodesGeoZones

        Return a list of ZipCodesGeoZones
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_zip_codes_geo_zones(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[ZipCodesGeoZone]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_zip_codes_geo_zones_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_zip_codes_geo_zones_with_http_info(**kwargs)
            return data"
4061,"def replace_zip_codes_geo_zone_by_id(cls, zip_codes_geo_zone_id, zip_codes_geo_zone, **kwargs):
        """"""Replace ZipCodesGeoZone

        Replace all attributes of ZipCodesGeoZone
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_zip_codes_geo_zone_by_id(zip_codes_geo_zone_id, zip_codes_geo_zone, async=True)
        >>> result = thread.get()

        :param async bool
        :param str zip_codes_geo_zone_id: ID of zipCodesGeoZone to replace (required)
        :param ZipCodesGeoZone zip_codes_geo_zone: Attributes of zipCodesGeoZone to replace (required)
        :return: ZipCodesGeoZone
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_zip_codes_geo_zone_by_id_with_http_info(zip_codes_geo_zone_id, zip_codes_geo_zone, **kwargs)
        else:
            (data) = cls._replace_zip_codes_geo_zone_by_id_with_http_info(zip_codes_geo_zone_id, zip_codes_geo_zone, **kwargs)
            return data"
4062,"def update_zip_codes_geo_zone_by_id(cls, zip_codes_geo_zone_id, zip_codes_geo_zone, **kwargs):
        """"""Update ZipCodesGeoZone

        Update attributes of ZipCodesGeoZone
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_zip_codes_geo_zone_by_id(zip_codes_geo_zone_id, zip_codes_geo_zone, async=True)
        >>> result = thread.get()

        :param async bool
        :param str zip_codes_geo_zone_id: ID of zipCodesGeoZone to update. (required)
        :param ZipCodesGeoZone zip_codes_geo_zone: Attributes of zipCodesGeoZone to update. (required)
        :return: ZipCodesGeoZone
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_zip_codes_geo_zone_by_id_with_http_info(zip_codes_geo_zone_id, zip_codes_geo_zone, **kwargs)
        else:
            (data) = cls._update_zip_codes_geo_zone_by_id_with_http_info(zip_codes_geo_zone_id, zip_codes_geo_zone, **kwargs)
            return data"
4063,"def get_declared_fields(bases, attrs):
    """""" Find all fields and return them as a dictionary.

    note:: this function is copied and modified
        from django.forms.get_declared_fields
    """"""

    def is_field(prop):
        return isinstance(prop, forms.Field) or \
            isinstance(prop, BaseRepresentation)

    fields = [(field_name, attrs.pop(field_name)) for field_name, obj in attrs.items() if is_field(obj)]
    # add fields from base classes:
    for base in bases[::-1]:
        if hasattr(base, 'base_fields'):
            fields = base.base_fields.items() + fields
    return dict(fields)"
4064,"def validate(self, data=None):
        """""" Validate the data

        Check also that no extra properties are present.

        :raises: ValidationError if the data is not valid.
        """"""

        errors = {}

        data = self._getData(data)

        # validate each field, one by one
        for name, field in self.fields.items():
            try:
                field.clean(data.get(name))
            except ValidationError, e:
                errors[name] = e.messages
            except AttributeError, e:
                raise ValidationError('data should be of type dict but is %s' % (type(data),))

        # check for extra fields
        extras = set(data.keys()) - set(self.fields.keys())
        if extras:
            errors[', '.join(extras)] = ['field(s) not allowed']

        # if errors, raise ValidationError
        if errors:
            raise ValidationError(errors)"
4065,"def _getData(self, data):
        """""" Check that data is acceptable and return it.

        Default behavior is that the data has to be of type `dict`. In derived
        classes this method could for example allow `None` or empty strings and
        just return empty dictionary.

        :raises: ``ValidationError`` if data is missing or wrong type
        :return: the data to be validated
        """"""

        if not isinstance(data, dict):
            raise ValidationError(
                'data is not a valid dictionary: %s' % (str(type(data)),))
        return data"
4066,"def lambda_handler(event, context):
    """"""Main handler.""""""
    users = boto3.resource(""dynamodb"").Table(os.environ['people'])
    auth = check_auth(event, role=[""admin""])
    if not auth['success']:
        return auth
    user_email = event.get('user_email', None)
    if not user_email:
        msg = ""Missing user_email parameter in your request.""
        return {'success': False, 'message': msg}
    user_role = event.get('user_role', None)
    if not user_role:
        msg = ""Missing user role: `admin`, `analyst`""
        return {'success': False, 'message': msg}
    user_name = event.get('user_name', '')
    seed = random.randint(100000000, 999999999)
    hash_key = ""{}{}"".format(user_email, seed)
    api_key = hashlib.sha256(hash_key).hexdigest()
    if auth.get('init', False):
        user_role = 'admin'
    else:
        user_role = user_role
    obj = {'email': user_email, 'name': user_name, 'api_key': api_key,
           'role': user_role}
    response = users.put_item(Item=obj)
    return obj"
4067,"def get_connection(self, internal=False):
        """"""Get a live connection to this instance.

        :param bool internal: Whether or not to use a DC internal network connection.

        :rtype: :py:class:`redis.client.StrictRedis`
        """"""
        # Determine the connection string to use.
        connect_string = self.connect_string
        if internal:
            connect_string = self.internal_connect_string

        # Stripe Redis protocol prefix coming from the API.
        connect_string = connect_string.strip('redis://')
        host, port = connect_string.split(':')

        # Build and return the redis client.
        return redis.StrictRedis(host=host, port=port, password=self._password)"
4068,"def get_cached(self, path, cache_name, **kwargs):
        """"""Request a resource form the API, first checking if there is a cached
        response available. Returns the parsed JSON data.
        """"""
        if gw2api.cache_dir and gw2api.cache_time and cache_name:
            cache_file = os.path.join(gw2api.cache_dir, cache_name)
            if mtime(cache_file) >= time.time() - gw2api.cache_time:
                with open(cache_file, ""r"") as fp:
                    tmp = json.load(fp)
                return self.make_response(tmp[""data""], tmp[""meta""])
        else:
            cache_file = None

        meta, data = self._get(path, **kwargs)

        if cache_file:
            with open(cache_file, ""w"") as fp:
                json.dump({""meta"": meta, ""data"": data}, fp, indent=2)

        return self.make_response(data, meta)"
4069,"def main():
    """"""
    Loop over a list of input text strings. Parse each string using a list of
    parsers, one included in megaparsex and one defined in this script. If a
    confirmation is requested, seek confirmation, otherwise display any response
    text and engage any triggered functions.
    """"""
    for text in [
        ""how are you"",
        ""ip address"",
        ""restart"",
        ""run command"",
        ""rain EGPF"",
        ""reverse SSH""
        ]:
        print(""\nparse text: "" + text + ""\nWait 3 seconds, then parse."")
        time.sleep(3)
        response = megaparsex.multiparse(
            text         = text,
            parsers      = [
                           megaparsex.parse,
                           parse_networking
                           ],
            help_message = ""Does not compute. I can report my IP address and I ""
                           ""can restart my script.""
        )
        if type(response) is megaparsex.confirmation:
            while response.confirmed() is None:
                response.test(
                    text = megaparsex.get_input(
                        prompt = response.prompt() + "" ""
                    )
                )
            if response.confirmed():
                print(response.feedback())
                response.run()
            else:
                print(response.feedback())
        elif type(response) is megaparsex.command:
            output = response.engage_command(
                command    = megaparsex.get_input(
                    prompt = response.prompt() + "" ""
                ),
                background = False
            )
            if output:
                print(""output:\n{output}"".format(output = output))
        else:
            print(response)"
4070,"def get_packet_id(self, packet):
        """"""
        Returns the ID of a protocol buffer packet. Returns None
        if no ID was found.
        """"""

        for p in self._packets:
            if isinstance(packet, p['cls']):
                return p['id']

        return None"
4071,"def main(*args):
    """""" Enter point. """"""
    args = args or sys.argv[1:]
    params = PARSER.parse_args(args)

    from .log import setup_logging
    setup_logging(params.level.upper())

    from .core import Starter
    starter = Starter(params)

    if not starter.params.TEMPLATES or starter.params.list:
        setup_logging('WARN')
        for t in sorted(starter.iterate_templates()):
            logging.warn(""%s -- %s"", t.name, t.params.get(
                'description', 'no description'))
        return True

    try:
        starter.copy()

    except Exception as e: # noqa
        logging.error(e)
        sys.exit(1)"
4072,"def summarize(df,preview_rows = 8,
            display_max_cols = None,display_width = None,
            output_path = None, output_safe = True,to_folder = False): 
    """""" Prints information about the DataFrame to a file or to the prompt.

    Parameters
    ----------
    df - DataFrame
        The DataFrame to summarize
    preview_rows - int, default 5
        Amount of rows to preview from the head and tail of the DataFrame
    display_max_cols - int, default None
        Maximum amount of columns to display. If set to None, all columns will be displayed.
        If set to 0, only as many as fit in the screen's width will be displayed
    display_width - int, default None
        Width of output. Can be width of file or width of console for printing.
        Set to None for pandas to detect it from console.
    output_path - path-like, default None
        If not None, this will be used as the path of the output file, and this
        function will print to a file instead of to the prompt
    output_safe - boolean, default True
        If True and output_file is not None, this function will not overwrite any
        existing files.
    output_csv: boolean, default False
        If True, will output to a directory with name of output_path with all data in 
        csv format. WARNING: If set to true, this function will overwrite existing files
        in the directory with the following names: 
            ['Preview.csv','Describe.csv','Info.csv','Percentile Details.csv',
             'Missing Values Summary.csv','Potential Outliers.csv','Correlation Matrix.csv']
    """"""
    assert type(df) is pd.DataFrame
    
    # Reformat displays
    initial_settings = pd_settings(display_max_cols, None, display_width)

    # --------Values of data-----------
    df_preview = _io.preview(df,preview_rows)
    df_desc_num, df_desc_cat = detailed_desc(df)
    percent_values = stats.percentiles(df)
    potential_outliers = stats.df_outliers(df).dropna(axis = 1,how = 'all')
    potential_outliers = potential_outliers if _utils.rows(potential_outliers) else None
    corr_values = regstats.corr_matrix(df)

    # ----------Build lists------------
    
    title_list = \
    ['Preview','Describe (Numerical)','Describe (Categorical)','Percentile Details',
     'Potential Outliers','Correlation Matrix']
    info_list = \
    [df_preview,df_desc_num, df_desc_cat,percent_values,
     potential_outliers,corr_values]
    error_list = [None,'No numerical data.','All numerical data.','No numerical data.',
                  'No potential outliers.','No categorical, bool, or numerical data.']
    
    # ----------Build output------------
    
    output = ''
    for title, value,error_text in zip(title_list,info_list,error_list):
        if value is None:
            value = ""{} skipped: {}"".format(title,error_text)
        if str(value).endswith('\n'):
            value = value[:-1]
        output+='{}\n{}\n\n'.format(_io.title_line(title),value)

    # ----------Send to file/print to console------------
    if output_path is None: 
        # Potentially could change this to allow for output_safe to work with directories
         print(output)
    else:
        if not to_folder:
            print('Outputting to file...')
            _io.output_to_file(output,output_path,output_safe)
        else:
            print('Outputting to folder...')
            if not os.path.exists(output_path):
                os.mkdir(output_path)
            for title, value,error_text in zip(title_list,info_list,error_list):
                if value is None:
                    print(""{} skipped: {}"".format(title,error_text))
                else:
                    file_dir = os.path.join(output_path,""{}.csv"".format(title))
                    if type(value) is pd.DataFrame:
                        # Eventually add a check to see if file exists
                        value.to_csv(file_dir)
                    else:
                        _io.output_to_file(value,file_dir,False) 
                        # Change to output_safe when directory output_safe is implemented
        print('Done!')

    # Reset display settings
    pd_settings(*initial_settings)"
4073,"def timed_pipe(generator, seconds=3):
    ''' This is a time limited pipeline. If you have a infinite pipeline and
        want it to stop yielding after a certain amount of time, use this! '''
    # grab the highest precision timer
    # when it started
    start = ts()
    # when it will stop
    end = start + seconds
    # iterate over the pipeline
    for i in generator:
        # if there is still time
        if ts() < end:
            # yield the next item
            yield i
        # otherwise
        else:
            # stop
            break"
4074,"def destruct(particles, index):
    """"""Fermion annihilation operator in matrix representation for a indexed
       particle in a bounded N-particles fermion fock space""""""

    mat = np.zeros((2**particles, 2**particles))

    flipper = 2**index
    for i in range(2**particles):
        ispin = btest(i, index)
        if ispin == 1:
            mat[i ^ flipper, i] = phase(i, index)
    return csr_matrix(mat)"
4075,"def on(self):
        """"""!
        \~english
        Open Audio output. set pin mode to ALT0
        @return a boolean value. if True means open audio output is OK otherwise failed to open.

        \~chinese
        打开音频输出。 将引脚模式设置为ALT0
        @return 布尔值。 如果 True 表示打开音频输出成功，否则不成功。
        """"""
        isOK = True
        try:
            if self.channelR!=None:
                sub.call([""gpio"", ""-g"", ""mode"", ""{}"".format(self.channelR), self.PIN_MODE_AUDIO ])
        except:
            isOK = False
            print(""Open audio right channel failed."")

        try:
            if self.channelL!=None:
                sub.call([""gpio"",""-g"",""mode"", ""{}"".format(self.channelL), self.PIN_MODE_AUDIO ])
        except:
            isOK = False
            print(""Open audio left channel failed."")

        return isOK"
4076,"def off(self):
        """"""!
        \~english
        Close Audio output. set pin mode to output
        @return a boolean value. if True means close audio output is OK otherwise failed to close.

        \~chinese
        关闭音频输出。 将引脚模式设置为输出
        @return 布尔值。 如果为 True 关闭音频输出成功，否则关闭不成功。
        """"""
        isOK = True
        try:
            if self.channelR!=None:
                sub.call([""gpio"",""-g"",""mode"", ""{}"".format(self.channelR), self.PIN_MODE_OUTPUT ])
        except:
            isOK = False
            print(""Close audio right channel failed."")

        try:
            if self.channelL!=None:
                sub.call([""gpio"",""-g"",""mode"", ""{}"".format(self.channelL), self.PIN_MODE_OUTPUT ])
        except:
            isOK = False
            print(""Close audio left channel failed."")
        return isOK"
4077,"def parse_database_url(url):
    """"""Parses a database URL.""""""

    if url == 'sqlite://:memory:':
        # this is a special case, because if we pass this URL into
        # urlparse, urlparse will choke trying to interpret ""memory""
        # as a port number
        return {
            'ENGINE': DATABASE_SCHEMES['sqlite'],
            'NAME': ':memory:'
        }
        # note: no other settings are required for sqlite

    # otherwise parse the url as normal
    config = {}

    url = urlparse.urlparse(url)

    # Remove query strings.
    path = url.path[1:]
    path = path.split('?', 2)[0]

    # if we are using sqlite and we have no path, then assume we
    # want an in-memory database (this is the behaviour of sqlalchemy)
    if url.scheme == 'sqlite' and path == '':
        path = ':memory:'

    # Update with environment configuration.
    config.update({
        'NAME': path or '',
        'USER': url.username or '',
        'PASSWORD': url.password or '',
        'HOST': url.hostname or '',
        'PORT': url.port or '',
    })

    if url.scheme in DATABASE_SCHEMES:
        config['ENGINE'] = DATABASE_SCHEMES[url.scheme]

    return config"
4078,"def config(name='DATABASE_URL', default='sqlite://:memory:'):
    """"""Returns configured DATABASE dictionary from DATABASE_URL.""""""
    config = {}
    s = env(name, default)
    if s:
        config = parse_database_url(s)
    return config"
4079,"def json_unicode_to_utf8(data):
    """"""Change all strings in a JSON structure to UTF-8.""""""
    if isinstance(data, unicode):
        return data.encode('utf-8')
    elif isinstance(data, dict):
        newdict = {}
        for key in data:
            newdict[json_unicode_to_utf8(
                key)] = json_unicode_to_utf8(data[key])
        return newdict
    elif isinstance(data, list):
        return [json_unicode_to_utf8(elem) for elem in data]
    else:
        return data"
4080,"def json_decode_file(filename):
    """"""
    Parses a textfile using json to build a python object representation
    """"""
    seq = open(filename).read()
    # The JSON standard has no comments syntax. We have to remove them
    # before feeding python's JSON parser
    seq = json_remove_comments(seq)
    # Parse all the unicode stuff to utf-8
    return json_unicode_to_utf8(json.loads(seq))"
4081,"def wash_for_js(text):
    """"""
    DEPRECATED: use htmlutils.escape_javascript_string() instead,
    and take note that returned value is no longer enclosed into
    quotes.
    """"""
    from invenio_utils.html import escape_javascript_string
    if isinstance(text, six.string_types):
        return '""%s""' % escape_javascript_string(
            text,
            escape_for_html=False,
            escape_CDATA=False,
            escape_script_tag_with_quote=None)
    else:
        return text"
4082,"def _post_init(self):
        """"""A post init trigger""""""
        try:
            return self.postinit()
        except Exception as exc:
            return self._onerror(Result.from_exception(exc, uuid=self.uuid))"
4083,"def check_required_params(self):
        """""" Check if all required parameters are set""""""
        for param in self.REQUIRED_FIELDS:
            if param not in self.params:
                raise ValidationError(""Missing parameter: {}"".format(param))"
4084,"def _onsuccess(self, result):
        """""" To execute on execution success

        :param kser.result.Result result: Execution result
        :return: Execution result
        :rtype: kser.result.Result
        """"""
        if KSER_METRICS_ENABLED == ""yes"":
            KSER_TASKS_STATUS.labels(
                __hostname__, self.__class__.path, 'SUCCESS'
            ).inc()
        if result:
            result = self.result + result
        else:
            result = self.result
        logger.info(
            ""{}.Success: {}[{}]: {}"".format(
                self.__class__.__name__, self.__class__.path, self.uuid, result
            ),
            extra=dict(
                kmsg=Message(
                    self.uuid, entrypoint=self.__class__.path,
                    params=self.params, metadata=self.metadata
                ).dump(),
                kresult=ResultSchema().dump(result) if result else dict()
            )
        )
        return self.onsuccess(result)"
4085,"def _onerror(self, result):
        """""" To execute on execution failure

        :param kser.result.Result result: Execution result
        :return: Execution result
        :rtype: kser.result.Result
        """"""
        if KSER_METRICS_ENABLED == ""yes"":
            KSER_TASKS_STATUS.labels(
                __hostname__, self.__class__.path, 'FAILED'
            ).inc()

        if result:
            result = self.result + result
        else:
            result = self.result
        logger.error(
            ""{}.Failed: {}[{}]: {}"".format(
                self.__class__.__name__, self.__class__.path, self.uuid, result
            ),
            extra=dict(
                kmsg=Message(
                    self.uuid, entrypoint=self.__class__.path,
                    params=self.params, metadata=self.metadata
                ).dump(),
                kresult=ResultSchema().dump(result) if result else dict()
            )
        )
        return self.onerror(result)"
4086,"def _postrun(self, result):
        """""" To execute after exection

        :param kser.result.Result result: Execution result
        :return: Execution result
        :rtype: kser.result.Result
        """"""
        logger.debug(
            ""{}.PostRun: {}[{}]"".format(
                self.__class__.__name__, self.__class__.path, self.uuid
            ),
            extra=dict(
                kmsg=Message(
                    self.uuid, entrypoint=self.__class__.path,
                    params=self.params, metadata=self.metadata
                ).dump()
            )
        )
        return self.postrun(result)"
4087,"def _run(self):
        """""" Execution body

        :return: Execution result
        :rtype: kser.result.Result
        """"""
        if KSER_METRICS_ENABLED == ""yes"":
            KSER_TASK_COUNT.inc()

        logger.debug(
            ""{}.Run: {}[{}]"".format(
                self.__class__.__name__, self.__class__.path, self.uuid
            ),
            extra=dict(
                kmsg=Message(
                    self.uuid, entrypoint=self.__class__.path,
                    params=self.params, metadata=self.metadata
                ).dump()
            )
        )
        return self.run()"
4088,"def unsafe_execute(self, result=None):
        """""" un-wrapped execution, can raise excepetion

        :return: Execution result
        :rtype: kser.result.Result
        """"""
        if result:
            self.result += result

        self._prerun()
        return self._onsuccess(self._postrun(self._run()))"
4089,"def execute(self, result=None):
        """""" Execution 'wrapper' to make sure that it return a result

        :return: Execution result
        :rtype: kser.result.Result
        """"""
        try:
            return self.unsafe_execute(result=result)
        except Exception as exc:
            return self._onerror(Result.from_exception(exc, uuid=self.uuid))"
4090,"def to_Message(self, result=None):
        """""" Entrypoint -> Message

        :param kser.result.Result result: Execution result
        :return: Kafka message
        :rtype kser.schemas.Message
        """"""
        return Message(
            uuid=self.uuid, entrypoint=self.__class__.path, params=self.params,
            result=result if result else self.result, metadata=self.metadata
        )"
4091,"def from_Message(cls, kmsg):
        """""" Message -> Entrypoint

        :param kser.schemas.Message kmsg: Kafka message
        :return: a entrypoint
        :rtype kser.entry.Entrypoint
        """"""
        return cls(
            uuid=kmsg.uuid, params=kmsg.params, result=kmsg.result,
            metadata=kmsg.metadata
        )"
4092,"def save_as(self, filename=None):
        """"""
        Dumps object contents into file on disk.

        Args:
          filename (optional): defaults to self.filename. If passed, self.filename
            will be updated to filename.
        """"""
        if filename is None:
            filename = self.filename
        if filename is None:
            filename = self.default_filename
        if filename is None:
            raise RuntimeError(""Class '{}' has no default filename"".format(self.__class__.__name__))
        self._do_save_as(filename)
        self.filename = filename"
4093,"def load(self, filename=None):
        """"""Loads file and registers filename as attribute.""""""
        assert not self.__flag_loaded, ""File can be loaded only once""
        if filename is None:
            filename = self.default_filename
        assert filename is not None, \
            ""{0!s} class has no default filename"".format(self.__class__.__name__)

        # Convention: trying to open empty file is an error,
        # because it could be of (almost) any type.

        size = os.path.getsize(filename)
        if size == 0:
            raise RuntimeError(""Empty file: '{0!s}'"".format(filename))

        self._test_magic(filename)
        self._do_load(filename)
        self.filename = filename
        self.__flag_loaded = True"
4094,"def init_default(self):
        """"""
        Initializes object with its default values

        Tries to load self.default_filename from default
        data directory. For safety, filename is reset to None so that it doesn't point to the
        original file.
        """"""
        import f311
        if self.default_filename is None:
            raise RuntimeError(""Class '{}' has no default filename"".format(self.__class__.__name__))
        fullpath = f311.get_default_data_path(self.default_filename, class_=self.__class__)
        self.load(fullpath)
        self.filename = None"
4095,"def availability(self, availability):
        """"""Sets the availability of this Product.


        :param availability: The availability of this Product.
        :type: str
        """"""
        allowed_values = [""available"", ""comingSoon"", ""retired""]
        if availability is not None and availability not in allowed_values:
            raise ValueError(
                ""Invalid value for `availability` ({0}), must be one of {1}""
                .format(availability, allowed_values)
            )

        self._availability = availability"
4096,"def stock_status(self, stock_status):
        """"""Sets the stock_status of this Product.


        :param stock_status: The stock_status of this Product.
        :type: str
        """"""
        allowed_values = [""available"", ""alert"", ""unavailable""]
        if stock_status is not None and stock_status not in allowed_values:
            raise ValueError(
                ""Invalid value for `stock_status` ({0}), must be one of {1}""
                .format(stock_status, allowed_values)
            )

        self._stock_status = stock_status"
4097,"def create_product(cls, product, **kwargs):
        """"""Create Product

        Create a new Product
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_product(product, async=True)
        >>> result = thread.get()

        :param async bool
        :param Product product: Attributes of product to create (required)
        :return: Product
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_product_with_http_info(product, **kwargs)
        else:
            (data) = cls._create_product_with_http_info(product, **kwargs)
            return data"
4098,"def delete_product_by_id(cls, product_id, **kwargs):
        """"""Delete Product

        Delete an instance of Product by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_product_by_id(product_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str product_id: ID of product to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_product_by_id_with_http_info(product_id, **kwargs)
        else:
            (data) = cls._delete_product_by_id_with_http_info(product_id, **kwargs)
            return data"
4099,"def get_product_by_id(cls, product_id, **kwargs):
        """"""Find Product

        Return single instance of Product by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_product_by_id(product_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str product_id: ID of product to return (required)
        :return: Product
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_product_by_id_with_http_info(product_id, **kwargs)
        else:
            (data) = cls._get_product_by_id_with_http_info(product_id, **kwargs)
            return data"
4100,"def list_all_products(cls, **kwargs):
        """"""List Products

        Return a list of Products
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_products(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[Product]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_products_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_products_with_http_info(**kwargs)
            return data"
4101,"def replace_product_by_id(cls, product_id, product, **kwargs):
        """"""Replace Product

        Replace all attributes of Product
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_product_by_id(product_id, product, async=True)
        >>> result = thread.get()

        :param async bool
        :param str product_id: ID of product to replace (required)
        :param Product product: Attributes of product to replace (required)
        :return: Product
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_product_by_id_with_http_info(product_id, product, **kwargs)
        else:
            (data) = cls._replace_product_by_id_with_http_info(product_id, product, **kwargs)
            return data"
4102,"def update_product_by_id(cls, product_id, product, **kwargs):
        """"""Update Product

        Update attributes of Product
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_product_by_id(product_id, product, async=True)
        >>> result = thread.get()

        :param async bool
        :param str product_id: ID of product to update. (required)
        :param Product product: Attributes of product to update. (required)
        :return: Product
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_product_by_id_with_http_info(product_id, product, **kwargs)
        else:
            (data) = cls._update_product_by_id_with_http_info(product_id, product, **kwargs)
            return data"
4103,"def asserts(input_value, rule, message=''):
    """""" this function allows you to write asserts in generators since there are
        moments where you actually want the program to halt when certain values
        are seen.
    """"""
    assert callable(rule) or type(rule)==bool, 'asserts needs rule to be a callable function or a test boolean'
    assert isinstance(message, str), 'asserts needs message to be a string'
    # if the message is empty and rule is callable, fill message with rule's source code
    if len(message)==0 and callable(rule):
        try:
            s = getsource(rule).splitlines()[0].strip()
        except:
            s = repr(rule).strip()
        message = 'illegal input of {} breaks - {}'.format(input_value, s)
    if callable(rule):
        # if rule is a function, run the function and assign it to rule
        rule = rule(input_value)
    # now, assert the rule and return the input value
    assert rule, message
    return input_value"
4104,"def print(*a):
    """""" print just one that returns what you give it instead of None """"""
    try:
        _print(*a)
        return a[0] if len(a) == 1 else a
    except:
        _print(*a)"
4105,"def pattern2re(pattern):
    """"""Makes a unicode regular expression from a pattern.

    Returns ``(start, full_re, int_re)`` where:

     * `start` is either empty or the subdirectory in which to start searching,
     * `full_re` is a regular expression object that matches the requested
       files, i.e. a translation of the pattern
     * `int_re` is either None of a regular expression object that matches
       the requested paths or their ancestors (i.e. if a path doesn't match
       `int_re`, no path under it will match `full_re`)

    This uses extended patterns, where:

      * a slash '/' always represents the path separator
      * a backslash '\' escapes other special characters
      * an initial slash '/' anchors the match at the beginning of the
        (relative) path
      * a trailing '/' suffix is removed
      * an asterisk '*'  matches a sequence of any length (including 0) of any
        characters (except the path separator)
      * a '?' matches exactly one character (except the path separator)
      * '[abc]' matches characters 'a', 'b' or 'c'
      * two asterisks '**' matches one or more path components (might match '/'
        characters)
    """"""
    pattern_segs = filter(None, pattern.split('/'))

    # This anchors the first component either at the start of the string or at
    # the start of a path component
    if not pattern:
        return '', re.compile(''), None
    elif '/' in pattern:
        full_regex = '^'  # Start at beginning of path
        int_regex = []
        int_regex_done = False
        start_dir = []
        start_dir_done = False
    else:
        full_regex = '(?:^|/)'  # Skip any number of full components
        int_regex = None
        int_regex_done = True
        start_dir = []
        start_dir_done = True

    # Handles each component
    for pnum, pat in enumerate(pattern_segs):
        comp = patterncomp2re(pat)

        # The first component is already anchored
        if pnum > 0:
            full_regex += '/'
        full_regex += comp

        if not int_regex_done:
            if pat == '**':
                int_regex_done = True
            else:
                int_regex.append(comp)
                if not start_dir_done and no_special_chars.match(pat):
                    start_dir.append(pat)
                else:
                    start_dir_done = True

    full_regex = re.compile(full_regex.rstrip('/') + '$')
    if int_regex is not None:
        n = len(int_regex)
        int_regex_s = ''
        for i, c in enumerate(reversed(int_regex)):
            if i == n - 1:  # Last iteration (first component)
                int_regex_s = '^(?:%s%s)?' % (c, int_regex_s)
            elif int_regex_s:
                int_regex_s = '(?:/%s%s)?' % (c, int_regex_s)
            else:  # First iteration (last component)
                int_regex_s = '(?:/%s)?' % c
        int_regex = re.compile(int_regex_s + '$')
    start_dir = '/'.join(start_dir)
    return start_dir, full_regex, int_regex"
4106,"def _to_backend(self, p):
        """"""Converts something to the correct path representation.

        If given a Path, this will simply unpack it, if it's the correct type.
        If given the correct backend, it will return that.
        If given bytes for unicode of unicode for bytes, it will encode/decode
        with a reasonable encoding. Note that these operations can raise
        UnicodeError!
        """"""
        if isinstance(p, self._cmp_base):
            return p.path
        elif isinstance(p, self._backend):
            return p
        elif self._backend is unicode and isinstance(p, bytes):
            return p.decode(self._encoding)
        elif self._backend is bytes and isinstance(p, unicode):
            return p.encode(self._encoding,
                            'surrogateescape' if PY3 else 'strict')
        else:
            raise TypeError(""Can't construct a %s from %r"" % (
                            self.__class__.__name__, type(p)))"
4107,"def parent(self):
        """"""The parent directory of this path.
        """"""
        p = self._lib.dirname(self.path)
        p = self.__class__(p)
        return p"
4108,"def unicodename(self):
        """"""The name of this path as unicode.
        """"""
        n = self._lib.basename(self.path)
        if self._backend is unicode:
            return n
        else:
            return n.decode(self._encoding, 'replace')"
4109,"def split_root(self):
        """"""Splits this path into a pair (drive, location).

        Note that, because all paths are normalized, a root of ``'.'`` will be
        returned for relative paths.
        """"""
        if not PY3 and hasattr(self._lib, 'splitunc'):
            root, rest = self._lib.splitunc(self.path)
            if root:
                if rest.startswith(self._sep):
                    root += self._sep
                    rest = rest[1:]
                return self.__class__(root), self.__class__(rest)
        root, rest = self._lib.splitdrive(self.path)
        if root:
            if rest.startswith(self._sep):
                root += self._sep
                rest = rest[1:]
            return self.__class__(root), self.__class__(rest)
        if self.path.startswith(self._sep):
            return self.__class__(self._sep), self.__class__(rest[1:])
        return self.__class__(''), self"
4110,"def rel_path_to(self, dest):
        """"""Builds a relative path leading from this one to the given `dest`.

        Note that these paths might be both relative, in which case they'll be
        assumed to start from the same directory.
        """"""
        dest = self.__class__(dest)

        orig_list = self.norm_case()._components()
        dest_list = dest._components()

        i = -1
        for i, (orig_part, dest_part) in enumerate(zip(orig_list, dest_list)):
            if orig_part != self._normcase(dest_part):
                up = ['..'] * (len(orig_list) - i)
                return self.__class__(*(up + dest_list[i:]))

        if len(orig_list) <= len(dest_list):
            if len(dest_list) > i + 1:
                return self.__class__(*dest_list[i + 1:])
            else:
                return self.__class__('')
        else:
            up = ['..'] * (len(orig_list) - i - 1)
            return self.__class__(*up)"
4111,"def lies_under(self, prefix):
        """"""Indicates if the `prefix` is a parent of this path.
        """"""
        orig_list = self.norm_case()._components()
        pref_list = self.__class__(prefix).norm_case()._components()

        return (len(orig_list) >= len(pref_list) and
                orig_list[:len(pref_list)] == pref_list)"
4112,"def tempfile(cls, suffix='', prefix=None, dir=None, text=False):
        """"""Returns a new temporary file.

        The return value is a pair (fd, path) where fd is the file descriptor
        returned by :func:`os.open`, and path is a :class:`~rpaths.Path` to it.

        :param suffix: If specified, the file name will end with that suffix,
            otherwise there will be no suffix.

        :param prefix: Is specified, the file name will begin with that prefix,
            otherwise a default prefix is used.

        :param dir: If specified, the file will be created in that directory,
            otherwise a default directory is used.

        :param text: If true, the file is opened in text mode. Else (the
            default) the file is opened in binary mode.  On some operating
            systems, this makes no difference.

        The file is readable and writable only by the creating user ID.
        If the operating system uses permission bits to indicate whether a
        file is executable, the file is executable by no one. The file
        descriptor is not inherited by children of this process.

        The caller is responsible for deleting the file when done with it.
        """"""
        if prefix is None:
            prefix = tempfile.template
        if dir is not None:
            # Note that this is not safe on Python 2
            # There is no work around, apart from not using the tempfile module
            dir = str(Path(dir))
        fd, filename = tempfile.mkstemp(suffix, prefix, dir, text)
        return fd, cls(filename).absolute()"
4113,"def tempdir(cls, suffix='', prefix=None, dir=None):
        """"""Returns a new temporary directory.

        Arguments are as for :meth:`~rpaths.Path.tempfile`, except that the
        `text` argument is not accepted.

        The directory is readable, writable, and searchable only by the
        creating user.

        The caller is responsible for deleting the directory when done with it.
        """"""
        if prefix is None:
            prefix = tempfile.template
        if dir is not None:
            # Note that this is not safe on Python 2
            # There is no work around, apart from not using the tempfile module
            dir = str(Path(dir))
        dirname = tempfile.mkdtemp(suffix, prefix, dir)
        return cls(dirname).absolute()"
4114,"def rel_path_to(self, dest):
        """"""Builds a relative path leading from this one to another.

        Note that these paths might be both relative, in which case they'll be
        assumed to be considered starting from the same directory.

        Contrary to :class:`~rpaths.AbstractPath`'s version, this will also
        work if one path is relative and the other absolute.
        """"""
        return super(Path, self.absolute()).rel_path_to(Path(dest).absolute())"
4115,"def listdir(self, pattern=None):
        """"""Returns a list of all the files in this directory.

        The special entries ``'.'`` and ``'..'`` will not be returned.

        :param pattern: A pattern to match directory entries against.
        :type pattern: NoneType | Callable | Pattern | unicode | bytes
        """"""
        files = [self / self.__class__(p) for p in os.listdir(self.path)]
        if pattern is None:
            pass
        elif callable(pattern):
            files = filter(pattern, files)
        else:
            if isinstance(pattern, backend_types):
                if isinstance(pattern, bytes):
                    pattern = pattern.decode(self._encoding, 'replace')
                start, full_re, _int_re = pattern2re(pattern)
            elif isinstance(pattern, Pattern):
                start, full_re = pattern.start_dir, pattern.full_regex
            else:
                raise TypeError(""listdir() expects pattern to be a callable, ""
                                ""a regular expression or a string pattern, ""
                                ""got %r"" % type(pattern))
            # If pattern contains slashes (other than first and last chars),
            # listdir() will never match anything
            if start:
                return []
            files = [f for f in files if full_re.search(f.unicodename)]
        return files"
4116,"def recursedir(self, pattern=None, top_down=True, follow_links=False,
                   handle_errors=None):
        """"""Recursively lists all files under this directory.

        :param pattern: An extended patterns, where:

            * a slash '/' always represents the path separator
            * a backslash '\' escapes other special characters
            * an initial slash '/' anchors the match at the beginning of the
              (relative) path
            * a trailing '/' suffix is removed
            * an asterisk '*'  matches a sequence of any length (including 0)
              of any characters (except the path separator)
            * a '?' matches exactly one character (except the path separator)
            * '[abc]' matches characters 'a', 'b' or 'c'
            * two asterisks '**' matches one or more path components (might
              match '/' characters)
        :type pattern: NoneType | Callable | Pattern | unicode | bytes

        :param follow_links: If False, symbolic links will not be followed (the
            default). Else, they will be followed, but directories reached
            through different names will *not* be listed multiple times.

        :param handle_errors: Can be set to a callback that will be called when
            an error is encountered while accessing the filesystem (such as a
            permission issue). If set to None (the default), exceptions will be
            propagated.
        """"""
        if not self.is_dir():
            raise ValueError(""recursedir() called on non-directory %s"" % self)

        start = ''
        int_pattern = None
        if pattern is None:
            pattern = lambda p: True
        elif callable(pattern):
            pass
        else:
            if isinstance(pattern, backend_types):
                if isinstance(pattern, bytes):
                    pattern = pattern.decode(self._encoding, 'replace')
                start, full_re, int_re = pattern2re(pattern)
            elif isinstance(pattern, Pattern):
                start, full_re, int_re = \
                    pattern.start_dir, pattern.full_regex, pattern.int_regex
            else:
                raise TypeError(""recursedir() expects pattern to be a ""
                                ""callable, a regular expression or a string ""
                                ""pattern, got %r"" % type(pattern))
            if self._lib.sep != '/':
                pattern = lambda p: full_re.search(
                    unicode(p).replace(self._lib.sep, '/'))
                if int_re is not None:
                    int_pattern = lambda p: int_re.search(
                        unicode(p).replace(self._lib.sep, '/'))
            else:
                pattern = lambda p: full_re.search(unicode(p))
                if int_re is not None:
                    int_pattern = lambda p: int_re.search(unicode(p))
        if not start:
            path = self
        else:
            path = self / start
            if not path.exists():
                return []
            elif not path.is_dir():
                return [path]
        return path._recursedir(pattern=pattern, int_pattern=int_pattern,
                                top_down=top_down, seen=set(),
                                path=self.__class__(start),
                                follow_links=follow_links,
                                handle_errors=handle_errors)"
4117,"def mkdir(self, name=None, parents=False, mode=0o777):
        """"""Creates that directory, or a directory under this one.

        ``path.mkdir(name)`` is a shortcut for ``(path/name).mkdir()``.

        :param name: Path component to append to this path before creating the
            directory.

        :param parents: If True, missing directories leading to the path will
            be created too, recursively. If False (the default), the parent of
            that path needs to exist already.

        :param mode: Permissions associated with the directory on creation,
            without race conditions.
        """"""
        if name is not None:
            return (self / name).mkdir(parents=parents, mode=mode)
        if self.exists():
            return
        if parents:
            os.makedirs(self.path, mode)
        else:
            os.mkdir(self.path, mode)
        return self"
4118,"def rmdir(self, parents=False):
        """"""Removes this directory, provided it is empty.

        Use :func:`~rpaths.Path.rmtree` if it might still contain files.

        :param parents: If set to True, it will also destroy every empty
            directory above it until an error is encountered.
        """"""
        if parents:
            os.removedirs(self.path)
        else:
            os.rmdir(self.path)"
4119,"def rename(self, new, parents=False):
        """"""Renames this path to the given new location.

        :param new: New path where to move this one.

        :param parents: If set to True, it will create the parent directories
            of the target if they don't exist.
        """"""
        if parents:
            os.renames(self.path, self._to_backend(new))
        else:
            os.rename(self.path, self._to_backend(new))"
4120,"def copyfile(self, target):
        """"""Copies this file to the given `target` location.
        """"""
        shutil.copyfile(self.path, self._to_backend(target))"
4121,"def copymode(self, target):
        """"""Copies the mode of this file on the `target` file.

        The owner is not copied.
        """"""
        shutil.copymode(self.path, self._to_backend(target))"
4122,"def copystat(self, target):
        """"""Copies the permissions, times and flags from this to the `target`.

        The owner is not copied.
        """"""
        shutil.copystat(self.path, self._to_backend(target))"
4123,"def copy(self, target):
        """"""Copies this file the `target`, which might be a directory.

        The permissions are copied.
        """"""
        shutil.copy(self.path, self._to_backend(target))"
4124,"def copytree(self, target, symlinks=False):
        """"""Recursively copies this directory to the `target` location.

        The permissions and times are copied (like
        :meth:`~rpaths.Path.copystat`).

        If the optional `symlinks` flag is true, symbolic links in the source
        tree result in symbolic links in the destination tree; if it is false,
        the contents of the files pointed to by symbolic links are copied.
        """"""
        shutil.copytree(self.path, self._to_backend(target), symlinks)"
4125,"def move(self, target):
        """"""Recursively moves a file or directory to the given target location.
        """"""
        shutil.move(self.path, self._to_backend(target))"
4126,"def open(self, mode='r', name=None, **kwargs):
        """"""Opens this file, or a file under this directory.

        ``path.open(mode, name)`` is a shortcut for ``(path/name).open(mode)``.

        Note that this uses :func:`io.open()` which behaves differently from
        :func:`open()` on Python 2; see the appropriate documentation.

        :param name: Path component to append to this path before opening the
            file.
        """"""
        if name is not None:
            return io.open((self / name).path, mode=mode, **kwargs)
        else:
            return io.open(self.path, mode=mode, **kwargs)"
4127,"def rewrite(self, mode='r', name=None, temp=None, tempext='~', **kwargs):
        r""""""Replaces this file with new content.

        This context manager gives you two file objects, (r, w), where r is
        readable and has the current content of the file, and w is writable
        and will replace the file at the end of the context (unless an
        exception is raised, in which case it is rolled back).

        Keyword arguments will be used for both files, unless they are prefixed
        with ``read_`` or ``write_``. For instance::

            with Path('test.txt').rewrite(read_newline='\n',
                                          write_newline='\r\n') as (r, w):
                w.write(r.read())

        :param name: Path component to append to this path before opening the
            file.

        :param temp: Temporary file name to write, and then move over this one.
            By default it's this filename with a ``~`` suffix.

        :param tempext: Extension to add to this file to get the temporary file
            to write then move over this one. Defaults to ``~``.
        """"""
        if name is not None:
            pathr = self / name
        else:
            pathr = self
        for m in 'war+':
            mode = mode.replace(m, '')

        # Build options
        common_kwargs = {}
        readable_kwargs = {}
        writable_kwargs = {}
        for key, value in kwargs.items():
            if key.startswith('read_'):
                readable_kwargs[key[5:]] = value
            elif key.startswith('write_'):
                writable_kwargs[key[6:]] = value
            else:
                common_kwargs[key] = value
        readable_kwargs = dict_union(common_kwargs, readable_kwargs)
        writable_kwargs = dict_union(common_kwargs, writable_kwargs)

        with pathr.open('r' + mode, **readable_kwargs) as readable:
            if temp is not None:
                pathw = Path(temp)
            else:
                pathw = pathr + tempext
            try:
                pathw.remove()
            except OSError:
                pass
            writable = pathw.open('w' + mode, **writable_kwargs)
            try:
                yield readable, writable
            except Exception:
                # Problem, delete writable
                writable.close()
                pathw.remove()
                raise
            else:
                writable.close()
        # Alright, replace
        pathr.copymode(pathw)
        pathr.remove()
        pathw.rename(pathr)"
4128,"def matches(self, path):
        """"""Tests if the given path matches the pattern.

        Note that the unicode translation of the patch is matched, so
        replacement characters might have been added.
        """"""
        path = self._prepare_path(path)
        return self.full_regex.search(path) is not None"
4129,"def may_contain_matches(self, path):
        """"""Tests whether it's possible for paths under the given one to match.

        If this method returns None, no path under the given one will match the
        pattern.
        """"""
        path = self._prepare_path(path)
        return self.int_regex.search(path) is not None"
4130,"def _fetch(url,):
    """"""
    *Retrieve an HTML document or file from the web at a given URL*

    **Key Arguments:**
      - ``url`` -- the URL of the document or file

    **Return:**
      - ``url`` -- the URL of the document or file, or None if an error occured
      - ``body`` -- the text content of the HTML document.
    """"""
    import logging as log
    import socket
    from eventlet import Timeout
    from eventlet.green import urllib2
    import sys

    # TRY AND DOWNLOAD X TIMES BEFORE QUITING
    tries = 10
    count = 1
    downloaded = False
    while count < tries and downloaded == False:
        try:
            log.debug('downloading ' + url.get_full_url())
            body = urllib2.urlopen(url).read()
            downloaded = True
        except socket.timeout, e:
            print ""timeout on URL, trying again""
            count += 1
        except Exception, e:
            if ""[Errno 60]"" in str(e):
                log.warning('timeout on URL, trying again' % locals())
                count += 1
            if ""Error 502"" in str(e):
                log.warning('proxy error on URL, trying again' % locals())
                count += 1
            else:
                log.warning(
                    ""could not download "" + url.get_full_url() + "" : "" + str(e) + ""\n"")
                url = None
                body = None
                downloaded = True

    return url, body"
4131,"def tgcanrecruit(self, region=None):
        """"""Whether the nation will receive a recruitment telegram.

        Useful in conjunction with the Telegrams API.

        Parameters
        ----------
        region : str
            Name of the region you are recruiting for.

        Returns
        -------
        an :class:`ApiQuery` of bool
        """"""
        params = {'from': normalize(region)} if region is not None else {}
        @api_query('tgcanrecruit', **params)
        async def result(_, root):
            return bool(int(root.find('TGCANRECRUIT').text))
        return result(self)"
4132,"async def freedom(self, root):
        """"""Nation's `Freedoms`: three basic indicators of the nation's
        Civil Rights, Economy, and Political Freedom, as expressive
        adjectives.

        Returns
        -------
        an :class:`ApiQuery` of :class:`collections.OrderedDict` with \
        keys and values of str
            Keys being, in order: ``Civil Rights``, ``Economy``, and
            ``Political Freedom``.
        """"""
        elem = root.find('FREEDOM')
        result = OrderedDict()

        result['Civil Rights'] = elem.find('CIVILRIGHTS').text
        result['Economy'] = elem.find('ECONOMY').text
        result['Political Freedom'] = elem.find('POLITICALFREEDOM').text
        return result"
4133,"async def freedomscores(self, root):
        """"""Nation's `Freedoms`: three basic indicators of the nation's
        Civil Rights, Economy, and Political Freedom, as percentages.

        Returns
        -------
        an :class:`ApiQuery` of :class:`collections.OrderedDict` with \
        keys of str and values of int
            Keys being, in order: ``Civil Rights``, ``Economy``, and
            ``Political Freedom``.
        """"""
        elem = root.find('FREEDOMSCORES')
        result = OrderedDict()

        result['Civil Rights'] = int(elem.find('CIVILRIGHTS').text)
        result['Economy'] = int(elem.find('ECONOMY').text)
        result['Political Freedom'] = int(elem.find('POLITICALFREEDOM').text)
        return result"
4134,"async def govt(self, root):
        """"""Nation's government expenditure, as percentages.

        Returns
        -------
        an :class:`ApiQuery` of :class:`collections.OrderedDict` with \
        keys of str and values of float
            Keys being, in order: ``Administration``, ``Defense``,
            ``Education``, ``Environment``, ``Healthcare``, ``Industry``,
            ``International Aid``, ``Law & Order``, ``Public Transport``,
            ``Social Policy``, ``Spirituality``, and ``Welfare``.
        """"""
        elem = root.find('GOVT')
        result = OrderedDict()

        result['Administration'] = float(elem.find('ADMINISTRATION').text)
        result['Defense'] = float(elem.find('DEFENCE').text)  # match the web UI
        result['Education'] = float(elem.find('EDUCATION').text)
        result['Environment'] = float(elem.find('ENVIRONMENT').text)
        result['Healthcare'] = float(elem.find('HEALTHCARE').text)
        result['Industry'] = float(elem.find('COMMERCE').text)  # Don't ask
        result['International Aid'] = float(elem.find('INTERNATIONALAID').text)
        result['Law & Order'] = float(elem.find('LAWANDORDER').text)
        result['Public Transport'] = float(elem.find('PUBLICTRANSPORT').text)
        result['Social Policy'] = float(elem.find('SOCIALEQUALITY').text)  # Shh
        result['Spirituality'] = float(elem.find('SPIRITUALITY').text)
        result['Welfare'] = float(elem.find('WELFARE').text)
        return result"
4135,"async def sectors(self, root):
        """"""Components of the nation's economy, as percentages.

        Returns
        -------
        an :class:`ApiQuery` of :class:`collections.OrderedDict` with \
        keys of str and values of float
            Keys being, in order: ``Black Market (estimated)``, ``Government``,
            ``Private Industry``, and ``State-Owned Industry``.
        """"""
        elem = root.find('SECTORS')
        result = OrderedDict()

        result['Black Market (estimated)'] = float(elem.find('BLACKMARKET').text)
        result['Government'] = float(elem.find('GOVERNMENT').text)
        result['Private Industry'] = float(elem.find('INDUSTRY').text)
        result['State-Owned Industry'] = float(elem.find('PUBLIC').text)
        return result"
4136,"async def deaths(self, root):
        """"""Causes of death in the nation, as percentages.

        Returns
        -------
        an :class:`ApiQuery` of dict with keys of str and values of float
        """"""
        return {
            elem.get('type'): float(elem.text)
            for elem in root.find('DEATHS')
        }"
4137,"async def endorsements(self, root):
        """"""Regional neighbours endorsing the nation.

        Returns
        -------
        an :class:`ApiQuery` of a list of :class:`Nation`
        """"""
        text = root.find('ENDORSEMENTS').text
        return [Nation(name) for name in text.split(',')] if text else []"
4138,"def verify(self, checksum, *, token=None):
        """"""Interface to the `NationStates Verification API
        <https://www.nationstates.net/pages/api.html#verification>`_.

        Parameters
        ----------
        checksum : str
            The user-supplied verification code.  Expires if the nation
            logs out, if it performs a significant in-game action such
            as moving regions or endorsing another nation, and after it
            is successfully verified.
        token : str
            A token specific to your service and the nation being verified.

        Returns
        -------
        an :class:`ApiQuery` of bool
        """"""
        params = {'a': 'verify', 'checksum': checksum}
        if token:
            params['token'] = token
        # Needed so that we get output in xml, as opposed to
        # plain text. It doesn't actually matter what the
        # q param is, it's just important that it's not empty.
        @api_query('i_need_the_output_in_xml', **params)
        async def result(self, root):
            return bool(int(root.find('VERIFY').text))
        return result(self)"
4139,"async def description(self):
        """"""Nation's full description, as seen on its in-game page.

        Returns
        -------
        an awaitable of str
        """"""
        resp = await self._call_web(f'nation={self.id}')
        return html.unescape(
            re.search(
                '<div class=""nationsummary"">(.+?)<p class=""nationranktext"">',
                resp.text,
                flags=re.DOTALL
            )
            .group(1)
            .replace('\n', '')
            .replace('</p>', '')
            .replace('<p>', '\n\n')
            .strip()
        )"
4140,"def accept(self):
        """"""Accept the option.

        Returns
        -------
        an awaitable of :class:`IssueResult`
        """"""
        return self._issue._nation._accept_issue(self._issue.id, self._id)"
4141,"def list_all_promotions(cls, **kwargs):
        """"""List Promotions

        Return a list of Promotions
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_promotions(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[Promotion]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_promotions_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_promotions_with_http_info(**kwargs)
            return data"
4142,"def pip_upgrade_all_user(line):
    """"""Attempt to upgrade all packages installed with --user""""""
    import pip
    for dist in pip.get_installed_distributions(user_only=True):
        do_pip([""install"", ""--upgrade"", ""--user"", dist.project_name])"
4143,"def pip_upgrade_all(line):
    """"""Attempt to upgrade all packages""""""
    from pip import get_installed_distributions
    user = set(d.project_name for d in get_installed_distributions(user_only=True))
    all = set(d.project_name for d in get_installed_distributions())
    for dist in all - user:
        do_pip([""install"", ""--upgrade"", dist])
    for dist in  user:
        do_pip([""install"", ""--upgrade"", ""--user"", dist])"
4144,"def enc_name_descr(name, descr, color=a99.COLOR_DESCR):
    """"""Encodes html given name and description.""""""
    return enc_name(name, color)+""<br>""+descr"
4145,"def style_checkboxes(widget):
    """"""
    Iterates over widget children to change checkboxes stylesheet.

    The default rendering of checkboxes does not allow to tell a focused one
    from an unfocused one.
    """"""

    ww = widget.findChildren(QCheckBox)
    for w in ww:
        w.setStyleSheet(""QCheckBox:focus {border: 1px solid #000000;}"")"
4146,"def check_return_space(event, callable_):
    """"""Checks if event corresponds to Return/Space being pressed and calls callable_ if so.""""""
    if event.type() == QEvent.KeyPress:
        if event.key() in [Qt.Key_Return, Qt.Key_Space]:
            callable_()
            return True
    return False"
4147,"def are_you_sure(flag_changed, evt, parent=None, title=""File has been changed"",
                 msg=""Are you sure you want to exit?""):
    """"""
    ""Are you sure you want to exit"" question dialog.

    If flag_changed, shows question dialog. If answer is not yes, calls evt.ignore()

    Arguments:
      flag_changed
      evt -- QCloseEvent instance
      parent=None -- parent form, used to centralize the question dialog at
      title -- title for question dialog
      msg -- text of question dialog

    Returns True or False. True means: ""yes, I want to exit""
    """"""
    if flag_changed:
        r = QMessageBox.question(parent, title, msg,
             QMessageBox.Yes|QMessageBox.No, QMessageBox.Yes)
        if r != QMessageBox.Yes:
            evt.ignore()"
4148,"def reset_table_widget(t, rowCount, colCount):
    """"""Clears and resizes a table widget.""""""
    t.reset()
    t.horizontalHeader().reset()
    t.clear()
    t.sortItems(-1)
    t.setRowCount(rowCount)
    t.setColumnCount(colCount)"
4149,"def show_edit_form(obj, attrs=None, title="""", toolTips=None):
    """"""Shows parameters editor modal form.

    Arguments:
       obj: object to extract attribute values from, or a dict-like
       attrs: list of attribute names
       title:
       toolTips:
    """"""

    if attrs is None:
        if hasattr(obj, ""keys""):
            attrs = list(obj.keys())
        else:
            raise RuntimeError(""attrs is None and cannot determine it from obj"")

    specs = []
    for i, name in enumerate(attrs):
        # Tries as attribute, then as key
        try:
            value = obj.__getattribute__(name)
        except AttributeError:
            value = obj[name]

        if value is None:
            value = """"  # None becomes str

        dict_ = {""value"": value}

        if toolTips is not None:
            dict_[""toolTip""] = toolTips[i]
            dict_[""tooltip""] = toolTips[i]

        specs.append((name, dict_))
    form = XParametersEditor(specs=specs, title=title)
    r = form.exec_()
    return r, form"
4150,"def place_left_top(window, width=None, height=None):
    """"""Places window in top left corner of screen.

    Arguments:
      window -- a QWidget
      width=None -- window width, in case you want to change it (if not passed, not changed)
      height=None -- window height, in case you want to change it (if not passed, not changed)
    """"""

    if width is None:
        width = window.width()
    if height is None:
        height = window.height()

    window.setGeometry(_DESKTOP_OFFSET_LEFT, _DESKTOP_OFFSET_TOP, width, height)"
4151,"def place_center(window, width=None, height=None):
    """"""Places window in the center of the screen.""""""
    screenGeometry = QApplication.desktop().screenGeometry()

    w, h = window.width(), window.height()

    if width is not None or height is not None:
        w = width if width is not None else w
        h = height if height is not None else h
        window.setGeometry(0, 0, w, h)

    x = (screenGeometry.width() - w) / 2
    y = (screenGeometry.height() - h) / 2
    window.move(x, y)"
4152,"def snap_left(window, width=None):
    """"""Snaps window to left of desktop.
    Arguments:
      window -- a QWidget
      width=None -- window width, in case you want to change it (if not passed, not changed)
    """"""
    if not width:
        width = window.width()
    rect = QApplication.desktop().screenGeometry()
    window.setGeometry(_DESKTOP_OFFSET_LEFT, _DESKTOP_OFFSET_TOP, width, rect.height())"
4153,"def snap_right(window, width=None):
    """"""Snaps window to right of desktop.
    Arguments:
      window -- a QWidget
      width=None -- window width, in case you want to change it (if not passed, not changed)
    """"""
    if not width:
        width = window.width()
    rect = QApplication.desktop().screenGeometry()
    window.setGeometry(rect.width()-width, _DESKTOP_OFFSET_TOP, width, rect.height())"
4154,"def get_matplotlib_layout(widget, flag_toolbar=True):
    """"""
    Creates figure, toolbar, layout, sets widget layout

    Returns figure, canvas, layout

    Reference: http://stackoverflow.com/questions/12459811

    """"""
    fig = plt.figure()
    canvas = FigureCanvas(fig)
    #        self.canvas.mpl_connect('button_press_event', self.on_plot_click)
    layout = QVBoxLayout(widget)
    if flag_toolbar:
        toolbar = NavigationToolbar2QT(canvas, widget)
        layout.addWidget(toolbar)
    layout.addWidget(canvas)
    a99.set_margin(layout, 0)

    return fig, canvas, layout"
4155,"def get_icon(keyword):
    """"""
    Transforms a PNG file in a QIcon

    Looks for a file named <keyword>.png in the ""icons"" directory

    If file does not exist, returns None
    """"""

    filename = a99.get_path( ""icons"", keyword + "".png"")
    if not os.path.isfile(filename):
        raise FileNotFoundError(""File '{}' does not exist"".format(filename))
    return QIcon(filename)"
4156,"def get_QApplication(args=[]):
    """"""Returns the QApplication instance, creating it is does not yet exist.""""""
    global _qapp
    if _qapp is None:
        QCoreApplication.setAttribute(Qt.AA_X11InitThreads)
        _qapp = QApplication(args)

    return _qapp"
4157,"def table_info_to_parameters(table_info):
    """"""
    Converts a list of MyDBRow into a parameters.Parameters object

    This facilitates transfering data from SQLite table row to a XParameterEditor window

    See also: get_table_info()
    """"""

    # Example of item in table_info:
    #   MyDBRow([('cid', 0), ('name', 'id'), ('type', 'integer'), ('notnull', 0), ('dflt_value', None), ('pk', 1)])

    opbj = a99.Parameters()
    for field_info in table_info.values():
        p = a99.Parameter()
        if field_info.type == ""integer"":
            p.type = int
        elif field_info.type == ""real"":
            p.type = float
        else:
            p.type = str

        p.name = field_info.name
        if field_info.dflt_value is not None:
            p.value = field_info.dflt_value
        opbj.params.append(p)
    return opbj"
4158,"def get_frame():
    """"""Returns a QFrame formatted in a particular way""""""
    ret = QFrame()
    ret.setLineWidth(1)
    ret.setMidLineWidth(0)
    ret.setFrameShadow(QFrame.Sunken)
    ret.setFrameShape(QFrame.Box)
    return ret"
4159,"def set_checkbox_value(w, value):
    """"""
    Sets a checkbox's ""checked"" property + signal blocking + value tolerance

    Args:
        w: QCheckBox instance
        value: something that can be converted to a bool
    """"""
    save = w.blockSignals(True)
    try:
        w.setChecked(bool(value))
    finally:
        w.blockSignals(save)"
4160,"def add_signal(self, signal):
        """"""Adds ""input"" signal to connected signals.
        Internally connects the signal to a control slot.""""""
        self.__signals.append(signal)
        if self.__connected:
            # Connects signal if the current state is ""connected""
            self.__connect_signal(signal)"
4161,"def connect_all(self):
        """"""[Re-]connects all signals and slots.

        If already in ""connected"" state, ignores the call.
        """"""
        if self.__connected:
            return  # assert not self.__connected, ""connect_all() already in \""connected\"" state""
        with self.__lock:
            for signal in self.__signals:
                self.__connect_signal(signal)
            if self.__slot is not None:
                self.__sigDelayed.connect(self.__slot, Qt.QueuedConnection)
            self.__connected = True"
4162,"def disconnect_all(self):
        """"""Disconnects all signals and slots.

        If already in ""disconnected"" state, ignores the call.
        """"""
        if not self.__connected:
            return  # assert self.__connected, ""disconnect_all() already in \""disconnected\"" state""
        self.__disconnecting = True
        try:
            for signal in self.__signals:
                signal.disconnect(self.__signalReceived)
            if self.__slot is not None:
                self.__sigDelayed.disconnect(self.__slot)
            self.__connected = False
        finally:
            self.__disconnecting = False"
4163,"def __signalReceived(self, *args):
        """"""Received signal. Cancel previous timer and store args to be forwarded later.""""""
        if self.__disconnecting:
            return
        with self.__lock:
            self.__args = args
            if self.__rateLimit == 0:
                self.__timer.stop()
                self.__timer.start((self.__delay * 1000) + 1)
            else:
                now = time.time()
                if self.__lastFlushTime is None:
                    leakTime = 0
                else:
                    lastFlush = self.__lastFlushTime
                    leakTime = max(0, (lastFlush + (1.0 / self.__rateLimit)) - now)

                self.__timer.stop()
                # Note: original was min() below.
                timeout = (max(leakTime, self.__delay) * 1000) + 1
                self.__timer.start(timeout)"
4164,"def __flush(self):
        """"""If there is a signal queued up, send it now.""""""
        if self.__args is None or self.__disconnecting:
            return False
        #self.emit(self.signal, *self.args)
        self.__sigDelayed.emit(self.__args)
        self.__args = None
        self.__timer.stop()
        self.__lastFlushTime = time.time()
        return True"
4165,"def clean_indicators(indicators):
    """"""Remove any extra details from indicators.""""""
    output = list()
    for indicator in indicators:
        strip = ['http://', 'https://']
        for item in strip:
            indicator = indicator.replace(item, '')
        indicator = indicator.strip('.').strip()
        parts = indicator.split('/')
        if len(parts) > 0:
            indicator = parts.pop(0)
        output.append(indicator)
    output = list(set(output))
    return output"
4166,"def hash_values(values, alg=""md5""):
    """"""Hash a list of values.""""""
    import hashlib
    if alg not in ['md5', 'sha1', 'sha256']:
        raise Exception(""Invalid hashing algorithm!"")

    hasher = getattr(hashlib, alg)
    if type(values) == str:
        output = hasher(values).hexdigest()
    elif type(values) == list:
        output = list()
        for item in values:
            output.append(hasher(item).hexdigest())
    return output"
4167,"def check_whitelist(values):
    """"""Check the indicators against known whitelists.""""""
    import os
    import tldextract
    whitelisted = list()
    for name in ['alexa.txt', 'cisco.txt']:
        config_path = os.path.expanduser('~/.config/blockade')
        file_path = os.path.join(config_path, name)
        whitelisted += [x.strip() for x in open(file_path, 'r').readlines()]
    output = list()
    for item in values:
        ext = tldextract.extract(item)
        if ext.registered_domain in whitelisted:
            continue
        output.append(item)
    return output"
4168,"def cache_items(values):
    """"""Cache indicators that were successfully sent to avoid dups.""""""
    import os
    config_path = os.path.expanduser('~/.config/blockade')
    file_path = os.path.join(config_path, 'cache.txt')
    if not os.path.isfile(file_path):
        file(file_path, 'w').close()
    written = [x.strip() for x in open(file_path, 'r').readlines()]
    handle = open(file_path, 'a')
    for item in values:
        # Because of the option to submit in clear or hashed, we need to make
        # sure we're not re-hashing before adding.
        if is_hashed(item):
            hashed = item
        else:
            hashed = hash_values(item)

        if hashed in written:
            continue
        handle.write(hashed + ""\n"")
    handle.close()
    return True"
4169,"def prune_cached(values):
    """"""Remove the items that have already been cached.""""""
    import os
    config_path = os.path.expanduser('~/.config/blockade')
    file_path = os.path.join(config_path, 'cache.txt')
    if not os.path.isfile(file_path):
        return values
    cached = [x.strip() for x in open(file_path, 'r').readlines()]
    output = list()
    for item in values:
        hashed = hash_values(item)
        if hashed in cached:
            continue
        output.append(item)
    return output"
4170,"def get_logger(name):
    """"""Get a logging instance we can use.""""""
    import logging
    import sys
    logger = logging.getLogger(name)
    logger.setLevel(logging.DEBUG)
    shandler = logging.StreamHandler(sys.stdout)
    fmt = """"
    fmt += '\033[1;32m%(levelname)-5s %(module)s:%(funcName)s():'
    fmt += '%(lineno)d %(asctime)s\033[0m| %(message)s'
    fmtr = logging.Formatter(fmt)
    shandler.setFormatter(fmtr)
    logger.addHandler(shandler)
    return logger"
4171,"def process_whitelists():
    """"""Download approved top 1M lists.""""""
    import csv
    import grequests
    import os
    import StringIO
    import zipfile
    mapping = {
        'http://s3.amazonaws.com/alexa-static/top-1m.csv.zip': {
            'name': 'alexa.txt'
        }, 'http://s3-us-west-1.amazonaws.com/umbrella-static/top-1m.csv.zip': {
            'name': 'cisco.txt'
        }
    }
    rs = (grequests.get(u) for u in mapping.keys())
    responses = grequests.map(rs)
    for r in responses:
        data = zipfile.ZipFile(StringIO.StringIO(r.content)).read('top-1m.csv')
        stream = StringIO.StringIO(data)
        reader = csv.reader(stream, delimiter=',', quoting=csv.QUOTE_MINIMAL)
        items = [row[1].strip() for row in reader]
        stream.close()

        config_path = os.path.expanduser('~/.config/blockade')
        file_path = os.path.join(config_path, mapping[r.url]['name'])
        handle = open(file_path, 'w')
        for item in items:
            if item.count('.') == 0:
                continue
            handle.write(item + ""\n"")
        handle.close()
    return True"
4172,"def mode(self, mode):
        """"""Sets the mode of this BraintreeGateway.


        :param mode: The mode of this BraintreeGateway.
        :type: str
        """"""
        allowed_values = [""test"", ""live""]
        if mode is not None and mode not in allowed_values:
            raise ValueError(
                ""Invalid value for `mode` ({0}), must be one of {1}""
                .format(mode, allowed_values)
            )

        self._mode = mode"
4173,"def create_braintree_gateway(cls, braintree_gateway, **kwargs):
        """"""Create BraintreeGateway

        Create a new BraintreeGateway
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_braintree_gateway(braintree_gateway, async=True)
        >>> result = thread.get()

        :param async bool
        :param BraintreeGateway braintree_gateway: Attributes of braintreeGateway to create (required)
        :return: BraintreeGateway
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_braintree_gateway_with_http_info(braintree_gateway, **kwargs)
        else:
            (data) = cls._create_braintree_gateway_with_http_info(braintree_gateway, **kwargs)
            return data"
4174,"def delete_braintree_gateway_by_id(cls, braintree_gateway_id, **kwargs):
        """"""Delete BraintreeGateway

        Delete an instance of BraintreeGateway by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_braintree_gateway_by_id(braintree_gateway_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str braintree_gateway_id: ID of braintreeGateway to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_braintree_gateway_by_id_with_http_info(braintree_gateway_id, **kwargs)
        else:
            (data) = cls._delete_braintree_gateway_by_id_with_http_info(braintree_gateway_id, **kwargs)
            return data"
4175,"def get_braintree_gateway_by_id(cls, braintree_gateway_id, **kwargs):
        """"""Find BraintreeGateway

        Return single instance of BraintreeGateway by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_braintree_gateway_by_id(braintree_gateway_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str braintree_gateway_id: ID of braintreeGateway to return (required)
        :return: BraintreeGateway
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_braintree_gateway_by_id_with_http_info(braintree_gateway_id, **kwargs)
        else:
            (data) = cls._get_braintree_gateway_by_id_with_http_info(braintree_gateway_id, **kwargs)
            return data"
4176,"def list_all_braintree_gateways(cls, **kwargs):
        """"""List BraintreeGateways

        Return a list of BraintreeGateways
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_braintree_gateways(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[BraintreeGateway]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_braintree_gateways_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_braintree_gateways_with_http_info(**kwargs)
            return data"
4177,"def replace_braintree_gateway_by_id(cls, braintree_gateway_id, braintree_gateway, **kwargs):
        """"""Replace BraintreeGateway

        Replace all attributes of BraintreeGateway
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_braintree_gateway_by_id(braintree_gateway_id, braintree_gateway, async=True)
        >>> result = thread.get()

        :param async bool
        :param str braintree_gateway_id: ID of braintreeGateway to replace (required)
        :param BraintreeGateway braintree_gateway: Attributes of braintreeGateway to replace (required)
        :return: BraintreeGateway
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_braintree_gateway_by_id_with_http_info(braintree_gateway_id, braintree_gateway, **kwargs)
        else:
            (data) = cls._replace_braintree_gateway_by_id_with_http_info(braintree_gateway_id, braintree_gateway, **kwargs)
            return data"
4178,"def update_braintree_gateway_by_id(cls, braintree_gateway_id, braintree_gateway, **kwargs):
        """"""Update BraintreeGateway

        Update attributes of BraintreeGateway
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_braintree_gateway_by_id(braintree_gateway_id, braintree_gateway, async=True)
        >>> result = thread.get()

        :param async bool
        :param str braintree_gateway_id: ID of braintreeGateway to update. (required)
        :param BraintreeGateway braintree_gateway: Attributes of braintreeGateway to update. (required)
        :return: BraintreeGateway
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_braintree_gateway_by_id_with_http_info(braintree_gateway_id, braintree_gateway, **kwargs)
        else:
            (data) = cls._update_braintree_gateway_by_id_with_http_info(braintree_gateway_id, braintree_gateway, **kwargs)
            return data"
4179,"def diagnose(df,preview_rows = 2,
            display_max_cols = 0,display_width = None): 
    """""" Prints information about the DataFrame pertinent to data cleaning.

    Parameters
    ----------
    df - DataFrame
        The DataFrame to summarize
    preview_rows - int, default 5
        Amount of rows to preview from the head and tail of the DataFrame
    display_max_cols - int, default None
        Maximum amount of columns to display. If set to None, all columns will be displayed.
        If set to 0, only as many as fit in the screen's width will be displayed
    display_width - int, default None
        Width of output. Can be width of file or width of console for printing.
        Set to None for pandas to detect it from console.
    """"""
    assert type(df) is pd.DataFrame
    # Diagnose problems with the data formats that can be addressed in cleaning
    
     # Get initial display settings
    initial_max_cols = pd.get_option('display.max_columns')
    initial_max_rows = pd.get_option('display.max_rows')
    initial_width = pd.get_option('display.width')

    # Reformat displays
    pd.set_option('display.max_columns', display_max_cols)
    pd.set_option('display.max_rows',None)
    if display_width is not None:
            pd.set_option('display.width',display_width)

    # --------Values of data-----------
    df_preview = _io.preview(df,preview_rows)
    
    df_info = _io.get_info(df,verbose = True, max_cols = display_max_cols, 
                               memory_usage = 'deep',null_counts = True)
    
    dtypes = stats.dtypes_summary(df).apply(_io.format_row,args = [_utils.rows(df)],axis = 1)
    
    potential_outliers = stats.df_outliers(df).dropna(axis = 1,how = 'all')
    potential_outliers = potential_outliers if _utils.rows(potential_outliers) \
                    else None

    # ----------Build lists------------
    
    title_list = \
    ['Preview','Info',
     'Data Types Summary','Potential Outliers']
    info_list = \
    [df_preview,df_info,
     dtypes,potential_outliers]
    error_list = [None,None,
                  None,'No potential outliers.']
    
    # ----------Build output------------
    
    output = ''
    for title, value,error_text in zip(title_list,info_list,error_list):
        if value is None:
            value = ""{} skipped: {}"".format(title,error_text)
        if str(value).endswith('\n'):
            value = value[:-1]
        output+='{}\n{}\n\n'.format(_io.title_line(title),value)

    # ----------Send to file/print to console------------
        # Potentially could change this to allow for output_safe to work with directories
    print(output)

    # Reset display settings
    pd.set_option('display.max_columns', initial_max_cols)
    pd.set_option('display.max_rows', initial_max_rows)
    pd.set_option('display.width', initial_width)"
4180,"def cut_spectrum(sp, l0, lf):
    """"""
    Cuts spectrum given a wavelength interval, leaving origina intact

    Args:
        sp: Spectrum instance
        l0: initial wavelength
        lf: final wavelength

    Returns:
        Spectrum: cut spectrum
    """"""

    if l0 >= lf:
        raise ValueError(""l0 must be lower than lf"")
    idx0 = np.argmin(np.abs(sp.x - l0))
    idx1 = np.argmin(np.abs(sp.x - lf))
    out = copy.deepcopy(sp)
    out.x = out.x[idx0:idx1]
    out.y = out.y[idx0:idx1]
    return out"
4181,"def remove_nongenerating_nonterminals(grammar, inplace=False):
    # type: (Grammar, bool) -> Grammar
    """"""
    Remove nongenerating symbols from the grammar.
    Nongenerating symbols are symbols, that don't generate sequence of terminals.
    For example never ending recursion.
    :param grammar: Grammar where to remove nongenerating symbols.
    :param inplace: True if transformation should be performed in place. False by default.
    :return: Grammar without nongenerating symbols.
    """"""
    # copy if required
    if inplace is False:
        grammar = copy(grammar)
    # create working sets
    generates = grammar.terminals.copy()
    generates.add(EPSILON)
    rules = grammar.rules.copy()
    # iterate until the set doesn't change
    while True:
        # create set for the next iteration
        additional = generates.copy()
        # iterate over unprocessed rules
        for rule in rules.copy():
            rightPart = rule.right
            allIn = True
            # check if all symbols on the right part of rule are in generates set
            for symbol in rightPart:
                if symbol not in generates:
                    allIn = False
                    break
            # Symbol is missing so rule is not process
            if not allIn:
                continue
            # Rule is process - remove it from processing rules and make symbol as generating
            additional.add(rule.fromSymbol)
            rules.remove(rule)
            # end of rules iterations
        # ff current and previous iterations are same, than end iterations
        if additional == generates:
            break
        # swap sets from previous and current iterations
        generates = additional
    # remove nonterms that are not generating
    nongenerating = grammar.nonterminals.difference(generates)
    grammar.nonterminals.remove(*nongenerating)
    # return the grammar
    return grammar"
4182,"def skip_first(pipe, items=1):
    ''' this is an alias for skip to parallel the dedicated skip_last function
        to provide a little more readability to the code. the action of actually
        skipping does not occur until the first iteration is done
    '''
    pipe = iter(pipe)
    for i in skip(pipe, items):
        yield i"
4183,"def find(self, query=None, **kwargs):
        """"""
        You can pass in the appropriate model object from the queries module,
        or a dictionary with the keys and values for the query,
        or a set of key=value parameters.
        """"""
        url = self.getUrl()
        if query is not None:
            if isinstance(query, queries.SlickQuery):
                url = url + ""?"" + urlencode(query.to_dict())
            elif isinstance(query, dict):
                url = url + ""?"" + urlencode(query)
        elif len(kwargs) > 0:
            url = url + ""?"" + urlencode(kwargs)

        # hopefully when we discover what problems exist in slick to require this, we can take the loop out
        for retry in range(3):
            try:
                self.logger.debug(""Making request to slick at url %s"", url)
                r = requests.get(url)
                self.logger.debug(""Request returned status code %d"", r.status_code)
                if r.status_code is 200:
                    retval = []
                    objects = r.json()
                    for dct in objects:
                        retval.append(self.model.from_dict(dct))
                    return retval
                else:
                    self.logger.error(""Slick returned an error when trying to access %s: status code %s"" % (url, str(r.status_code)))
                    self.logger.error(""Slick response: "", pprint.pformat(r))
                    
            except BaseException as error:
                self.logger.warn(""Received exception while connecting to slick at %s"", url, exc_info=sys.exc_info())
        raise SlickCommunicationError(
            ""Tried 3 times to request data from slick at url %s without a successful status code."", url)"
4184,"def findOne(self, query=None, mode=FindOneMode.FIRST, **kwargs):
        """"""
        Perform a find, with the same options present, but only return a maximum of one result.  If find returns
        an empty array, then None is returned.

        If there are multiple results from find, the one returned depends on the mode parameter.  If mode is
        FindOneMode.FIRST, then the first result is returned.  If the mode is FindOneMode.LAST, then the last is
        returned.  If the mode is FindOneMode.ERROR, then a SlickCommunicationError is raised.
        """"""
        results = self.find(query, **kwargs)
        if len(results) is 0:
            return None
        elif len(results) is 1 or mode == FindOneMode.FIRST:
            return results[0]
        elif mode == FindOneMode.LAST:
            return results[-1]"
4185,"def get(self):
        """"""Get the specified object from slick.  You specify which one you want by providing the id as a parameter to
        the parent object.  Example:
        slick.projects(""4fd8cd95e4b0ee7ba54b9885"").get()
        """"""
        url = self.getUrl()

        # hopefully when we discover what problems exist in slick to require this, we can take the loop out
        for retry in range(3):
            try:
                self.logger.debug(""Making request to slick at url %s"", url)
                r = requests.get(url)
                self.logger.debug(""Request returned status code %d"", r.status_code)
                if r.status_code is 200:
                    return self.model.from_dict(r.json())
                else:
                    self.logger.debug(""Body of what slick returned: %s"", r.text)
            except BaseException as error:
                self.logger.warn(""Received exception while connecting to slick at %s"", url, exc_info=sys.exc_info())
        raise SlickCommunicationError(
            ""Tried 3 times to request data from slick at url %s without a successful status code."", url)"
4186,"def update(self):
        """"""Update the specified object from slick.  You specify the object as a parameter, using the parent object as
        a function.  Example:
        proj = slick.projects.findByName(""foo"")
        ... update proj here
        slick.projects(proj).update()
        """"""
        obj = self.data
        url = self.getUrl()

        # hopefully when we discover what problems exist in slick to require this, we can take the loop out
        last_stats_code = None
        last_body = None
        for retry in range(3):
            try:
                json_data = obj.to_json()
                self.logger.debug(""Making request to slick at url %s, with data: %s"", url, json_data)
                r = requests.put(url, data=json_data, headers=json_content)
                self.logger.debug(""Request returned status code %d"", r.status_code)
                if r.status_code is 200:
                    return self.model.from_dict(r.json())
                else:
                    last_stats_code = r.status_code
                    last_body = r.text
                    self.logger.warn(""Slick status code: %d"", r.status_code)
                    self.logger.warn(""Body of what slick returned: %s"", r.text)
            except BaseException as error:
                self.logger.warn(""Received exception while connecting to slick at %s"", url, exc_info=sys.exc_info())
                traceback.print_exc()
        raise SlickCommunicationError(
            ""Tried 3 times to request data from slick at url %s without a successful status code.  Last status code: %d, body: %s"", url, last_stats_code, last_body)"
4187,"def create(self):
        """"""Create the specified object (perform a POST to the api).  You specify the object as a parameter, using
        the parent object as a function.  Example:
        proj = Project()
        ... add project data here
        proj = slick.projects(proj).create()
        """"""
        obj = self.data
        self.data = None
        url = self.getUrl()

        # hopefully when we discover what problems exist in slick to require this, we can take the loop out
        for retry in range(3):
            try:
                json_data = obj.to_json()
                self.logger.debug(""Making request to slick at url %s, with data: %s"", url, json_data)
                r = requests.post(url, data=json_data, headers=json_content)
                self.logger.debug(""Request returned status code %d"", r.status_code)
                if r.status_code is 200:
                    return self.model.from_dict(r.json())
                else:
                    self.logger.debug(""Body of what slick returned: %s"", r.text)
            except BaseException as error:
                self.logger.warn(""Received exception while connecting to slick at %s"", url, exc_info=sys.exc_info())
        raise SlickCommunicationError(
            ""Tried 3 times to request data from slick at url %s without a successful status code."", url)"
4188,"def remove(self):
        """"""Remove or delete the specified object from slick.  You specify which one you want by providing the id as
        a parameter to the parent object, using it as a function.  Example:
        slick.projects(""4fd8cd95e4b0ee7ba54b9885"").remove()
        """"""
        url = self.getUrl()

        # hopefully when we discover what problems exist in slick to require this, we can take the loop out
        for retry in range(3):
            try:
                self.logger.debug(""Making DELETE request to slick at url %s"", url)
                r = requests.delete(url)
                self.logger.debug(""Request returned status code %d"", r.status_code)
                if r.status_code is 200:
                    return None
                else:
                    self.logger.debug(""Body of what slick returned: %s"", r.text)
            except BaseException as error:
                self.logger.warn(""Received exception while connecting to slick at %s"", url, exc_info=sys.exc_info())
        raise SlickCommunicationError(
            ""Tried 3 times to request data from slick at url %s without a successful status code."", url)"
4189,"def upload_local_file(self, local_file_path, file_obj=None):
        """"""Create a Stored File and upload it's data.  This is a one part do it all type method.  Here is what
        it does:
            1. ""Discover"" information about the file (mime-type, size)
            2. Create the stored file object in slick
            3. Upload (chunked) all the data in the local file
            4. re-fetch the stored file object from slick, and return it
        """"""
        if file_obj is None and not os.path.exists(local_file_path):
            return
        storedfile = StoredFile()
        storedfile.mimetype = mimetypes.guess_type(local_file_path)[0]
        storedfile.filename = os.path.basename(local_file_path)
        if file_obj is None:
            storedfile.length = os.stat(local_file_path).st_size
        else:
            file_obj.seek(0,os.SEEK_END)
            storedfile.length = file_obj.tell()
            file_obj.seek(0)
        storedfile = self(storedfile).create()
        md5 = hashlib.md5()
        url = self(storedfile).getUrl() + ""/addchunk""
        if file_obj is None:
            with open(local_file_path, 'rb') as filecontents:
                upload_chunks(url, storedfile, filecontents)
        else:
            upload_chunks(url, storedfile, file_obj)
        return self(storedfile).update()"
4190,"def lookup_cc_partner(nu_pid):
    """"""Lookup the charge current partner

    Takes as an input neutrino nu_pid is a PDG code, then returns
    the charged lepton partner.  So 12 (nu_e) returns 11.  Keeps sign
    """"""

    neutrino_type = math.fabs(nu_pid)
    assert neutrino_type in [12, 14, 16]

    cc_partner = neutrino_type - 1  # get e, mu, tau
    cc_partner = math.copysign(
        cc_partner, nu_pid)  # make sure matter/antimatter
    cc_partner = int(cc_partner)  # convert to int

    return cc_partner"
4191,"def _set_vector_value(self, var_name, value):
        """"""Private""""""
        self.particle[var_name] = convert_3vector_to_dict(value)

        for coord in self.particle[var_name].keys():
            new_value = Distribution(self.particle[var_name][coord])
            self.particle[var_name][coord] = new_value"
4192,"def _get_next_events(self, material):
        """"""Get next events from Genie ROOT file

        Looks over the generator""""""

        f = ROOT.TFile(self.filenames[material])
        try:
            t = f.Get('gst')
            n = t.GetEntries()
        except:
            self.log.critical('Could not open the ROOT file with Genie events')
            raise

        for i in range(n):
            t.GetEntry(i)
            next_events = []

            position = convert_3vector_to_dict([self.particle['position']['x'].get_cache(),
                                                self.particle['position']['y'].get_cache(),
                                                self.particle['position']['z'].get_cache()])

            lepton_event = {}
            if t.El ** 2 - (t.pxl ** 2 + t.pyl ** 2 + t.pzl ** 2) < 1e-7:
                lepton_event['pid'] = self.particle[
                                      'pid'].get()  # Either NC or ES
            else:
                lepton_event['pid'] = lookup_cc_partner(
                    self.particle['pid'].get())

            # units: GeV -> MeV
            momentum_vector = [1000 * x for x in [t.pxl, t.pyl, t.pzl]]

            lepton_event['momentum'] = convert_3vector_to_dict(momentum_vector)

            lepton_event['position'] = position

            next_events.append(lepton_event)

            for j in range(t.nf):  # nf, number final hadronic states
                hadron_event = {}
                hadron_event['pid'] = t.pdgf[j]
                hadron_event['position'] = position

                # units: GeV -> MeV
                momentum_vector = [1000 * x for x in [t.pxf[j], t.pyf[j], t.pzf[j]]]

                hadron_event['momentum'] = convert_3vector_to_dict(momentum_vector)

                next_events.append(hadron_event)

            event_type = {}

            event_type['vertex'] = position

            to_save = {} # maps our names to Genie gst names
            to_save['incoming_neutrino'] = 'neu'
            to_save['neutrino_energy'] = 'Ev'
            to_save['target_material'] = 'tgt'

            for key, value in to_save.iteritems():
                self.log.info('%s : %s' % (key, str(t.__getattr__(value))))
                event_type[key] = t.__getattr__(value)

            self.log.debug('Event type:')
            for my_type in ['qel', 'res', 'dis', 'coh', 'dfr',
                            'imd', 'nuel', 'em']:
                if t.__getattr__(my_type) == 1:
                    self.log.debug('\t%s', my_type)
                event_type[my_type] = t.__getattr__(my_type)

            self.log.debug('Propogator:')
            for prop in ['nc', 'cc']:
                if t.__getattr__(prop) == 1:
                    self.log.debug('\t%s', prop)
                event_type[prop] = t.__getattr__(prop)

            yield next_events, event_type

        f.Close()
        os.remove(self.filenames[material])"
4193,"def block_comment(solver, start, end):
  '''embedable block comment'''
  text, pos = solver.parse_state
  length = len(text)
  startlen = len(start)
  endlen = len(end)
  if pos==length: return
  if not text[pos:].startswith(start):
    return
  level = 1
  p = pos+1
  while p<length:
    if text[p:].startswith(end):
      level -= 1
      p += endlen
      if level==0: break
    elif text[p:].startswith(start):
      level += 1
      p += startlen
    else:
      p += 1
  else: return
  solver.parse_state = text, p
  yield cont, text[pos:p]
  solver.parse_state = text, pos"
4194,"def formatException(self, record):
        """"""
        Format and return the specified exception information as a string.
        :type record logging.LogRecord
        :rtype: dict
        """"""
        if record.exc_info is None:
            return {}

        (exc_type, exc_message, trace) = record.exc_info

        return {
            'e': {
                'class': str(type(exc_type).__name__),  # ZeroDivisionError
                'message': str(exc_message),  # integer division or modulo by zero
                'trace': list(traceback.format_tb(trace)),
            }
        }"
4195,"def insert(self, val):     
      """"""\
      Inserts a value and returns a :class:`Pair <Pair>`.

      If the generated key exists or memcache cannot store it, a 
      :class:`KeyInsertError <shorten.KeyInsertError>` is raised (or a
      :class:`TokenInsertError <shorten.TokenInsertError>` if a token
      exists or cannot be stored).      
      """"""

      key, token, formatted_key, formatted_token = self.next_formatted_pair()

      if self.has_key(key):
         raise KeyInsertError(key)

      if self.has_token(token):
         raise TokenInsertError(token)

      # Memcache is down or read-only

      if not self._mc.add(formatted_key, (val, token)):
         raise KeyInsertError(key, 'key could not be stored')

      if not self._mc.add(formatted_token, key):
         raise TokenInsertError(token, 'token could not be stored')

      return Pair(key, token)"
4196,"def pip_install(*args):
    '''
    Run pip install ...

    Explicitly ignores user's config.
    '''
    pip_cmd = os.path.join(os.path.dirname(sys.executable), 'pip')
    with set_env('PIP_CONFIG_FILE', os.devnull):
        cmd = [pip_cmd, 'install'] + list(args)
        print_command(cmd)
        subprocess.call(cmd, stdout=sys.stdout, stderr=sys.stderr)"
4197,"def indent_text(text,
                nb_tabs=0,
                tab_str=""  "",
                linebreak_input=""\n"",
                linebreak_output=""\n"",
                wrap=False):
    r""""""Add tabs to each line of text.

    :param text: the text to indent
    :param nb_tabs: number of tabs to add
    :param tab_str: type of tab (could be, for example ""\t"", default: 2 spaces
    :param linebreak_input: linebreak on input
    :param linebreak_output: linebreak on output
    :param wrap: wethever to apply smart text wrapping.
        (by means of wrap_text_in_a_box)
    :return: indented text as string
    """"""
    if not wrap:
        lines = text.split(linebreak_input)
        tabs = nb_tabs * tab_str
        output = """"
        for line in lines:
            output += tabs + line + linebreak_output
        return output
    else:
        return wrap_text_in_a_box(body=text, style='no_border',
                                  tab_str=tab_str, tab_num=nb_tabs)"
4198,"def wrap_text_in_a_box(body='', title='', style='double_star', **args):
    r""""""Return a nicely formatted text box.

        e.g.
       ******************
       **  title       **
       **--------------**
       **  body        **
       ******************

    Indentation and newline are respected.

    :param body: the main text
    :param title: an optional title
    :param style: the name of one of the style in CFG_WRAP_STYLES. By default
        the double_star style is used.

    You can further tune the desired style by setting various optional
    parameters:

        :param horiz_sep: a string that is repeated in order to produce a
            separator row between the title and the body (if needed)
            or a tuple of three characters in the form (l, c, r)
        :param max_col: the maximum number of coulmns used by the box
            (including indentation)
        :param min_col: the symmetrical minimum number of columns
        :param tab_str: a string to represent indentation
        :param tab_num: the number of leveles of indentations
        :param border: a tuple of 8 element in the form
            (tl, t, tr, l, r, bl, b, br) of strings that represent the
            different corners and sides of the box
        :param prefix: a prefix string added before the box
        :param suffix: a suffix string added after the box
        :param break_long: wethever to break long words in order to respect
            max_col
        :param force_horiz: True in order to print the horizontal line even when
            there is no title

    e.g.:
    print wrap_text_in_a_box(title='prova',
        body='  123 prova.\n    Vediamo come si indenta',
        horiz_sep='-', style='no_border', max_col=20, tab_num=1)

        prova
        ----------------
        123 prova.
            Vediamo come
            si indenta

    """"""
    def _wrap_row(row, max_col, break_long):
        """"""Wrap a single row.""""""
        spaces = _RE_BEGINNING_SPACES.match(row).group()
        row = row[len(spaces):]
        spaces = spaces.expandtabs()
        return textwrap.wrap(row, initial_indent=spaces,
                             subsequent_indent=spaces, width=max_col,
                             break_long_words=break_long)

    def _clean_newlines(text):
        text = _RE_LONELY_NEWLINES.sub(' \n', text)
        return _RE_NEWLINES_CLEANER.sub(lambda x: x.group()[:-1], text)

    body = unicode(body, 'utf-8')
    title = unicode(title, 'utf-8')

    astyle = dict(CFG_WRAP_TEXT_IN_A_BOX_STYLES['__DEFAULT'])
    if style in CFG_WRAP_TEXT_IN_A_BOX_STYLES:
        astyle.update(CFG_WRAP_TEXT_IN_A_BOX_STYLES[style])
    astyle.update(args)

    horiz_sep = astyle['horiz_sep']
    border = astyle['border']
    tab_str = astyle['tab_str'] * astyle['tab_num']
    max_col = max(astyle['max_col'] -
                  len(border[3]) - len(border[4]) - len(tab_str), 1)
    min_col = astyle['min_col']
    prefix = astyle['prefix']
    suffix = astyle['suffix']
    force_horiz = astyle['force_horiz']
    break_long = astyle['break_long']

    body = _clean_newlines(body)
    tmp_rows = [_wrap_row(row, max_col, break_long)
                for row in body.split('\n')]
    body_rows = []
    for rows in tmp_rows:
        if rows:
            body_rows += rows
        else:
            body_rows.append('')
    if not ''.join(body_rows).strip():
        # Concrete empty body
        body_rows = []

    title = _clean_newlines(title)
    tmp_rows = [_wrap_row(row, max_col, break_long)
                for row in title.split('\n')]
    title_rows = []
    for rows in tmp_rows:
        if rows:
            title_rows += rows
        else:
            title_rows.append('')
    if not ''.join(title_rows).strip():
        # Concrete empty title
        title_rows = []

    max_col = max([len(row) for row in body_rows + title_rows] + [min_col])

    mid_top_border_len = max_col + \
        len(border[3]) + len(border[4]) - len(border[0]) - len(border[2])
    mid_bottom_border_len = max_col + \
        len(border[3]) + len(border[4]) - len(border[5]) - len(border[7])
    top_border = border[0] + \
        (border[1] * mid_top_border_len)[:mid_top_border_len] + border[2]
    bottom_border = border[5] + \
        (border[6] * mid_bottom_border_len)[:mid_bottom_border_len] + \
        border[7]
    if isinstance(horiz_sep, tuple) and len(horiz_sep) == 3:
        horiz_line = horiz_sep[0] + \
            (horiz_sep[1] * (max_col + 2))[:(max_col + 2)] + horiz_sep[2]
    else:
        horiz_line = border[3] + (horiz_sep * max_col)[:max_col] + border[4]

    title_rows = [tab_str + border[3] + row +
                  ' ' * (max_col - len(row)) +
                  border[4] for row in title_rows]
    body_rows = [tab_str + border[3] + row +
                 ' ' * (max_col - len(row)) + border[4] for row in body_rows]

    ret = []
    if top_border:
        ret += [tab_str + top_border]
    ret += title_rows
    if title_rows or force_horiz:
        ret += [tab_str + horiz_line]
    ret += body_rows
    if bottom_border:
        ret += [tab_str + bottom_border]
    return (prefix + '\n'.join(ret) + suffix).encode('utf-8')"
4199,"def wait_for_user(msg=""""):
    """"""
    Print MSG and a confirmation prompt.

    Waiting for user's confirmation, unless silent '--yes-i-know'
    command line option was used, in which case the function
    returns immediately without printing anything.
    """"""
    if '--yes-i-know' in sys.argv:
        return
    print(msg)
    try:
        answer = raw_input(""Please confirm by typing 'Yes, I know!': "")
    except KeyboardInterrupt:
        print()
        answer = ''
    if answer != 'Yes, I know!':
        sys.stderr.write(""ERROR: Aborted.\n"")
        sys.exit(1)
    return"
4200,"def guess_minimum_encoding(text, charsets=('ascii', 'latin1', 'utf8')):
    """"""Try to guess the minimum charset that is able to represent.

    Try to guess the minimum charset that is able to represent the given
    text using the provided charsets. text is supposed to be encoded in utf8.
    Returns (encoded_text, charset) where charset is the first charset
    in the sequence being able to encode text.
    Returns (text_in_utf8, 'utf8') in case no charset is able to encode text.

    @note: If the input text is not in strict UTF-8, then replace any
        non-UTF-8 chars inside it.
    """"""
    text_in_unicode = text.decode('utf8', 'replace')
    for charset in charsets:
        try:
            return (text_in_unicode.encode(charset), charset)
        except (UnicodeEncodeError, UnicodeDecodeError):
            pass
    return (text_in_unicode.encode('utf8'), 'utf8')"
4201,"def encode_for_xml(text, wash=False, xml_version='1.0', quote=False):
    """"""Encode special characters in a text so that it would be XML-compliant.

    :param text: text to encode
    :return: an encoded text
    """"""
    text = text.replace('&', '&amp;')
    text = text.replace('<', '&lt;')
    if quote:
        text = text.replace('""', '&quot;')
    if wash:
        text = wash_for_xml(text, xml_version=xml_version)
    return text"
4202,"def wash_for_xml(text, xml_version='1.0'):
    """"""Remove any character which isn't a allowed characters for XML.

    The allowed characters depends on the version
    of XML.

        - XML 1.0:
            <http://www.w3.org/TR/REC-xml/#charsets>
        - XML 1.1:
            <http://www.w3.org/TR/xml11/#charsets>

    :param text: input string to wash.
    :param xml_version: version of the XML for which we wash the
        input. Value for this parameter can be '1.0' or '1.1'
    """"""
    if xml_version == '1.0':
        return RE_ALLOWED_XML_1_0_CHARS.sub(
            '', unicode(text, 'utf-8')).encode('utf-8')
    else:
        return RE_ALLOWED_XML_1_1_CHARS.sub(
            '', unicode(text, 'utf-8')).encode('utf-8')"
4203,"def wash_for_utf8(text, correct=True):
    """"""Return UTF-8 encoded binary string with incorrect characters washed away.

    :param text: input string to wash (can be either a binary or Unicode string)
    :param correct: whether to correct bad characters or throw exception
    """"""
    if isinstance(text, unicode):
        return text.encode('utf-8')

    errors = ""ignore"" if correct else ""strict""
    return text.decode(""utf-8"", errors).encode(""utf-8"", errors)"
4204,"def nice_number(number, thousands_separator=',', max_ndigits_after_dot=None):
    """"""Return nicely printed number NUMBER in language LN.

    Return nicely printed number NUMBER in language LN using
    given THOUSANDS_SEPARATOR character.
    If max_ndigits_after_dot is specified and the number is float, the
    number is rounded by taking in consideration up to max_ndigits_after_dot
    digit after the dot.

    This version does not pay attention to locale.  See
    tmpl_nice_number_via_locale().
    """"""
    if isinstance(number, float):
        if max_ndigits_after_dot is not None:
            number = round(number, max_ndigits_after_dot)
        int_part, frac_part = str(number).split('.')
        return '%s.%s' % (nice_number(int(int_part), thousands_separator),
                          frac_part)
    else:
        chars_in = list(str(number))
        number = len(chars_in)
        chars_out = []
        for i in range(0, number):
            if i % 3 == 0 and i != 0:
                chars_out.append(thousands_separator)
            chars_out.append(chars_in[number - i - 1])
        chars_out.reverse()
        return ''.join(chars_out)"
4205,"def nice_size(size):
    """"""Nice size.

    :param size: the size.
    :type size: int
    :return: a nicely printed size.
    :rtype: string
    """"""
    unit = 'B'
    if size > 1024:
        size /= 1024.0
        unit = 'KB'
        if size > 1024:
            size /= 1024.0
            unit = 'MB'
            if size > 1024:
                size /= 1024.0
                unit = 'GB'
    return '%s %s' % (nice_number(size, max_ndigits_after_dot=2), unit)"
4206,"def remove_line_breaks(text):
    """"""Remove line breaks from input.

    Including unicode 'line separator', 'paragraph separator',
    and 'next line' characters.
    """"""
    return unicode(text, 'utf-8').replace('\f', '').replace('\n', '') \
        .replace('\r', '').replace(u'\xe2\x80\xa8', '') \
        .replace(u'\xe2\x80\xa9', '').replace(u'\xc2\x85', '') \
        .encode('utf-8')"
4207,"def decode_to_unicode(text, default_encoding='utf-8'):
    """"""Decode input text into Unicode representation.

    Decode input text into Unicode representation by first using the default
    encoding utf-8.
    If the operation fails, it detects the type of encoding used in the
    given text.
    For optimal result, it is recommended that the 'chardet' module is
    installed.
    NOTE: Beware that this might be slow for *very* large strings.

    If chardet detection fails, it will try to decode the string using the basic
    detection function guess_minimum_encoding().

    Also, bear in mind that it is impossible to detect the correct encoding at
    all times, other then taking educated guesses. With that said, this function
    will always return some decoded Unicode string, however the data returned
    may not be the same as original data in some cases.

    :param text: the text to decode
    :type text: string

    :param default_encoding: the character encoding to use. Optional.
    :type default_encoding: string

    :return: input text as Unicode
    :rtype: string
    """"""
    if not text:
        return """"
    try:
        return text.decode(default_encoding)
    except (UnicodeError, LookupError):
        pass
    detected_encoding = None
    if CHARDET_AVAILABLE:
        # We can use chardet to perform detection
        res = chardet.detect(text)
        if res['confidence'] >= 0.8:
            detected_encoding = res['encoding']
    if detected_encoding is None:
        # No chardet detection, try to make a basic guess
        dummy, detected_encoding = guess_minimum_encoding(text)
    return text.decode(detected_encoding)"
4208,"def to_unicode(text):
    """"""Convert to unicode.""""""
    if isinstance(text, unicode):
        return text
    if isinstance(text, six.string_types):
        return decode_to_unicode(text)
    return unicode(text)"
4209,"def translate_latex2unicode(text, kb_file=None):
    """"""Translate latex text to unicode.

    This function will take given text, presumably containing LaTeX symbols,
    and attempts to translate it to Unicode using the given or default KB
    translation table located under
    CFG_ETCDIR/bibconvert/KB/latex-to-unicode.kb.
    The translated Unicode string will then be returned.

    If the translation table and compiled regular expression object is not
    previously generated in the current session, they will be.

    :param text: a text presumably containing LaTeX symbols.
    :type text: string

    :param kb_file: full path to file containing latex2unicode translations.
                    Defaults to CFG_ETCDIR/bibconvert/KB/latex-to-unicode.kb
    :type kb_file: string

    :return: Unicode representation of translated text
    :rtype: unicode
    """"""
    if kb_file is None:
        kb_file = get_kb_filename()
    # First decode input text to Unicode
    try:
        text = decode_to_unicode(text)
    except UnicodeDecodeError:
        text = unicode(wash_for_utf8(text))
    # Load translation table, if required
    if CFG_LATEX_UNICODE_TRANSLATION_CONST == {}:
        _load_latex2unicode_constants(kb_file)
    # Find all matches and replace text
    for match in CFG_LATEX_UNICODE_TRANSLATION_CONST['regexp_obj'] \
            .finditer(text):
        # If LaTeX style markers {, } and $ are before or after the
        # matching text, it will replace those as well
        text = re.sub(""[\{\$]?%s[\}\$]?"" % (re.escape(match.group()),),
                      CFG_LATEX_UNICODE_TRANSLATION_CONST[
                          'table'][match.group()],
                      text)
    # Return Unicode representation of translated text
    return text"
4210,"def _load_latex2unicode_constants(kb_file=None):
    """"""Load LaTeX2Unicode translation table dictionary.

    Load LaTeX2Unicode translation table dictionary and regular
    expression object from KB to a global dictionary.

    :param kb_file: full path to file containing latex2unicode translations.
                    Defaults to CFG_ETCDIR/bibconvert/KB/latex-to-unicode.kb
    :type kb_file: string

    :return: dict of type: {'regexp_obj': regexp match object,
                            'table': dict of LaTeX -> Unicode mappings}
    :rtype: dict
    """"""
    if kb_file is None:
        kb_file = get_kb_filename()

    try:
        data = open(kb_file)
    except IOError:
        # File not found or similar
        sys.stderr.write(
            ""\nCould not open LaTeX to Unicode KB file. ""
            ""Aborting translation.\n"")
        return CFG_LATEX_UNICODE_TRANSLATION_CONST
    latex_symbols = []
    translation_table = {}
    for line in data:
        # The file has form of latex|--|utf-8. First decode to Unicode.
        line = line.decode('utf-8')
        mapping = line.split('|--|')
        translation_table[mapping[0].rstrip('\n')] = mapping[1].rstrip('\n')
        latex_symbols.append(re.escape(mapping[0].rstrip('\n')))
    data.close()
    CFG_LATEX_UNICODE_TRANSLATION_CONST[
        'regexp_obj'] = re.compile(""|"".join(latex_symbols))
    CFG_LATEX_UNICODE_TRANSLATION_CONST['table'] = translation_table"
4211,"def translate_to_ascii(values):
    r""""""Transliterate the string into ascii representation.

    Transliterate the string contents of the given sequence into ascii
    representation.
    Returns a sequence with the modified values if the module 'unidecode'
    is available. Otherwise it will fall back to the inferior strip_accents
    function.

    For example: H\xc3\xb6hne becomes Hohne.

    Note: Passed strings are returned as a list.

    :param values: sequence of strings to transform
    :type values: sequence

    :return: sequence with values transformed to ascii
    :rtype: sequence
    """"""
    if not values and not isinstance(values, str):
        return values

    if isinstance(values, str):
        values = [values]
    for index, value in enumerate(values):
        if not value:
            continue
        unicode_text = decode_to_unicode(value)
        if u""[?]"" in unicode_text:
            decoded_text = []
            for unicode_char in unicode_text:
                decoded_char = unidecode(unicode_char)
                # Skip unrecognized characters
                if decoded_char != ""[?]"":
                    decoded_text.append(decoded_char)
            ascii_text = ''.join(decoded_text).encode('ascii')
        else:
            ascii_text = unidecode(unicode_text).replace(
                u""[?]"", u"""").encode('ascii')
        values[index] = ascii_text
    return values"
4212,"def xml_entities_to_utf8(text, skip=('lt', 'gt', 'amp')):
    """"""Translate HTML or XML character references to UTF-8.

    Removes HTML or XML character references and entities from a text string
    and replaces them with their UTF-8 representation, if possible.

    :param text: The HTML (or XML) source text.
    :type text: string

    :param skip: list of entity names to skip when transforming.
    :type skip: iterable

    :return: The plain text, as a Unicode string, if necessary.
    @author: Based on http://effbot.org/zone/re-sub.htm#unescape-html
    """"""
    def fixup(m):
        text = m.group(0)
        if text[:2] == ""&#"":
            # character reference
            try:
                if text[:3] == ""&#x"":
                    return unichr(int(text[3:-1], 16)).encode(""utf-8"")
                else:
                    return unichr(int(text[2:-1])).encode(""utf-8"")
            except ValueError:
                pass
        else:
            # named entity
            if text[1:-1] not in skip:
                try:
                    text = unichr(
                        html_entities.name2codepoint[text[1:-1]]) \
                        .encode(""utf-8"")
                except KeyError:
                    pass
        return text  # leave as is
    return re.sub(""&#?\w+;"", fixup, text)"
4213,"def strip_accents(x):
    u""""""Strip accents in the input phrase X.

    Strip accents in the input phrase X (assumed in UTF-8) by replacing
    accented characters with their unaccented cousins (e.g. é by e).

    :param x: the input phrase to strip.
    :type x: string

    :return: Return such a stripped X.
    """"""
    x = re_latex_lowercase_a.sub(""a"", x)
    x = re_latex_lowercase_ae.sub(""ae"", x)
    x = re_latex_lowercase_oe.sub(""oe"", x)
    x = re_latex_lowercase_e.sub(""e"", x)
    x = re_latex_lowercase_i.sub(""i"", x)
    x = re_latex_lowercase_o.sub(""o"", x)
    x = re_latex_lowercase_u.sub(""u"", x)
    x = re_latex_lowercase_y.sub(""x"", x)
    x = re_latex_lowercase_c.sub(""c"", x)
    x = re_latex_lowercase_n.sub(""n"", x)
    x = re_latex_uppercase_a.sub(""A"", x)
    x = re_latex_uppercase_ae.sub(""AE"", x)
    x = re_latex_uppercase_oe.sub(""OE"", x)
    x = re_latex_uppercase_e.sub(""E"", x)
    x = re_latex_uppercase_i.sub(""I"", x)
    x = re_latex_uppercase_o.sub(""O"", x)
    x = re_latex_uppercase_u.sub(""U"", x)
    x = re_latex_uppercase_y.sub(""Y"", x)
    x = re_latex_uppercase_c.sub(""C"", x)
    x = re_latex_uppercase_n.sub(""N"", x)

    # convert input into Unicode string:
    try:
        y = unicode(x, ""utf-8"")
    except Exception:
        return x  # something went wrong, probably the input wasn't UTF-8
    # asciify Latin-1 lowercase characters:
    y = re_unicode_lowercase_a.sub(""a"", y)
    y = re_unicode_lowercase_ae.sub(""ae"", y)
    y = re_unicode_lowercase_oe.sub(""oe"", y)
    y = re_unicode_lowercase_e.sub(""e"", y)
    y = re_unicode_lowercase_i.sub(""i"", y)
    y = re_unicode_lowercase_o.sub(""o"", y)
    y = re_unicode_lowercase_u.sub(""u"", y)
    y = re_unicode_lowercase_y.sub(""y"", y)
    y = re_unicode_lowercase_c.sub(""c"", y)
    y = re_unicode_lowercase_n.sub(""n"", y)
    y = re_unicode_lowercase_ss.sub(""ss"", y)
    # asciify Latin-1 uppercase characters:
    y = re_unicode_uppercase_a.sub(""A"", y)
    y = re_unicode_uppercase_ae.sub(""AE"", y)
    y = re_unicode_uppercase_oe.sub(""OE"", y)
    y = re_unicode_uppercase_e.sub(""E"", y)
    y = re_unicode_uppercase_i.sub(""I"", y)
    y = re_unicode_uppercase_o.sub(""O"", y)
    y = re_unicode_uppercase_u.sub(""U"", y)
    y = re_unicode_uppercase_y.sub(""Y"", y)
    y = re_unicode_uppercase_c.sub(""C"", y)
    y = re_unicode_uppercase_n.sub(""N"", y)
    # return UTF-8 representation of the Unicode string:
    return y.encode(""utf-8"")"
4214,"def slugify(text, delim=u'-'):
    """"""Generate an ASCII-only slug.""""""
    result = []
    for word in _punct_re.split(text.lower()):
        result.extend(unidecode(word).split())
    return unicode(delim.join(result))"
4215,"def show_diff(original, modified, prefix='', suffix='',
              prefix_unchanged=' ',
              suffix_unchanged='',
              prefix_removed='-',
              suffix_removed='',
              prefix_added='+',
              suffix_added=''):
    """"""Return the diff view between original and modified strings.

    Function checks both arguments line by line and returns a string
    with a:
    - prefix_unchanged when line is common to both sequences
    - prefix_removed when line is unique to sequence 1
    - prefix_added when line is unique to sequence 2
    and a corresponding suffix in each line
    :param original: base string
    :param modified: changed string
    :param prefix: prefix of the output string
    :param suffix: suffix of the output string
    :param prefix_unchanged: prefix of the unchanged line
    :param suffix_unchanged: suffix of the unchanged line
    :param prefix_removed: prefix of the removed line
    :param suffix_removed: suffix of the removed line
    :param prefix_added: prefix of the added line
    :param suffix_added: suffix of the added line

    :return: string with the comparison of the records
    :rtype: string
    """"""
    import difflib
    differ = difflib.Differ()

    result = [prefix]
    for line in differ.compare(modified.splitlines(), original.splitlines()):
        if line[0] == ' ':
            # Mark as unchanged
            result.append(
                prefix_unchanged + line[2:].strip() + suffix_unchanged)
        elif line[0] == '-':
            # Mark as removed
            result.append(prefix_removed + line[2:].strip() + suffix_removed)
        elif line[0] == '+':
            # Mark as added/modified
            result.append(prefix_added + line[2:].strip() + suffix_added)

    result.append(suffix)
    return '\n'.join(result)"
4216,"def escape_latex(text):
    r""""""Escape characters of given text.

    This function takes the given text and escapes characters
    that have a special meaning in LaTeX: # $ % ^ & _ { } ~ \
    """"""
    text = unicode(text.decode('utf-8'))
    CHARS = {
        '&': r'\&',
        '%': r'\%',
        '$': r'\$',
        '#': r'\#',
        '_': r'\_',
        '{': r'\{',
        '}': r'\}',
        '~': r'\~{}',
        '^': r'\^{}',
        '\\': r'\textbackslash{}',
    }
    escaped = """".join([CHARS.get(char, char) for char in text])
    return escaped.encode('utf-8')"
4217,"def _copy_attr(self, module, varname, cls, attrname=None):
        """"""
        Copies attribute from module object to self. Raises if object not of expected class

        Args:
            module: module object
            varname: variable name
            cls: expected class of variable
            attrname: attribute name of self. Falls back to varname
        """"""

        if not hasattr(module, varname):
            raise RuntimeError(""Variable '{}' not found"".format(varname))

        obj = getattr(module, varname)

        if not isinstance(obj, cls):
            raise RuntimeError(
                ""Expecting fobj to be a {}, not a '{}'"".format(cls.__name__, obj.__class__.__name__))

        if attrname is None:
            attrname = varname

        setattr(self, attrname, obj)"
4218,"def __check_to_permit(self, entry_type, entry_filename):
        """"""Applying the filter rules.""""""

        rules = self.__filter_rules[entry_type]

        # Should explicitly include?
        for pattern in rules[fss.constants.FILTER_INCLUDE]:
            if fnmatch.fnmatch(entry_filename, pattern):
                _LOGGER_FILTER.debug(""Entry explicitly INCLUDED: [%s] [%s] ""
                                     ""[%s]"", 
                                     entry_type, pattern, entry_filename)

                return True

        # Should explicitly exclude?
        for pattern in rules[fss.constants.FILTER_EXCLUDE]:
            if fnmatch.fnmatch(entry_filename, pattern):
                _LOGGER_FILTER.debug(""Entry explicitly EXCLUDED: [%s] [%s] ""
                                     ""[%s]"", 
                                     entry_type, pattern, entry_filename)

                return False

        # Implicitly include.

        _LOGGER_FILTER.debug(""Entry IMPLICITLY included: [%s] [%s]"", 
                             entry_type, entry_filename)

        return True"
4219,"def get_next_item(self):
        """"""Override the default functionality to not only try to pull things 
        off the external input-queue, but to first try to pull things from a 
        local input-queue that we'll primarily depend on. We'll only use the 
        external input-queue to get the initial root-path (we could reuse it to 
        do the recursion, but it's more costly and prone to delay).
        """"""

        # Try to pop something off the local input-queue.

        try:
            return self.__local_input_q.get(block=False)
        except queue.Empty:
            pass

        # Try to pop something off the external input-queue.

        return self.input_q.get(block=False)"
4220,"def index_nearest(array, value):
    """"""
    Finds index of nearest value in array.

    Args:
        array: numpy array
        value:

    Returns:
        int

    http://stackoverflow.com/questions/2566412/find-nearest-value-in-numpy-array
    """"""
    idx = (np.abs(array-value)).argmin()
    return idx"
4221,"def BSearch(a, x, lo=0, hi=None):
    """"""Returns index of x in a, or -1 if x not in a.

    Arguments:
      a -- ordered numeric sequence
      x -- element to search within a
      lo -- lowest index to consider in search*
      hi -- highest index to consider in search*

    *bisect.bisect_left capability that we don't need to loose.""""""
    if len(a) == 0: return -1
    hi = hi if hi is not None else len(a)
    pos = bisect_left(a, x, lo, hi)
    return pos if pos != hi and a[pos] == x else -1"
4222,"def BSearchRound(a, x, lo=0, hi=None):
    """"""Returns index of a that is closest to x.

    Arguments:
      a -- ordered numeric sequence
      x -- element to search within a
      lo -- lowest index to consider in search*
      hi -- highest index to consider in search*

    *bisect.bisect_left capability that we don't need to loose.""""""
    if len(a) == 0: return -1
    hi = hi if hi is not None else len(a)
    pos = bisect_left(a, x, lo, hi)

    if pos >= hi:
        return hi - 1
    elif a[pos] == x or pos == lo:
        return pos
    else:
        return pos - 1 if x - a[pos - 1] <= a[pos] - x else pos"
4223,"def BSearchCeil(a, x, lo=0, hi=None):
    """"""Returns lowest i such as a[i] >= x, or -1 if x > all elements in a

    So, if x is in between two elements in a, this function will return the
    index of the higher element, hence ""Ceil"".

    Arguments:
      a -- ordered numeric sequence
      x -- element to search within a
      lo -- lowest index to consider in search
      hi -- highest index to consider in search""""""
    if len(a) == 0: return -1
    hi = hi if hi is not None else len(a)
    pos = bisect_left(a, x, lo, hi)
    return pos if pos < hi else -1"
4224,"def BSearchFloor(a, x, lo=0, hi=None):
    """"""Returns highest i such as a[i] <= x, or -1 if x < all elements in a

    So, if x is in between two elements in a, this function will return the
    index of the lower element, hence ""Floor"".

    Arguments:
      a -- ordered numeric sequence
      x -- element to search within a
      lo -- lowest index to consider in search
      hi -- highest index to consider in search""""""
    if len(a) == 0: return -1
    hi = hi if hi is not None else len(a)
    pos = bisect_left(a, x, lo, hi)
    return pos - 1 if pos >= hi \
        else (pos if x == a[pos] else (pos - 1 if pos > lo else -1))"
4225,"def FindNotNaNBackwards(x, i):
    """"""Returns last position (starting at i backwards) which is not NaN, or -1.""""""
    while i >= 0:
        if not np.isnan(x[i]):
            return i
        i -= 1
    return -1"
4226,"def census(self, *scales):
        """"""Current World Census data.

        By default returns data on today's featured World Census
        scale, use arguments to get results on specific scales.  In
        order to request data on all scales at once you can do
        ``x.census(*range(81))``.

        Parameters
        ----------
        scales : int
            World Census scales, integers between 0 and 85 inclusive.

        Returns
        -------
        an :class:`ApiQuery` of a list of :class:`CensusScaleCurrent`
        """"""
        params = {'mode': 'score+rank+rrank+prank+prrank'}
        if scales:
            params['scale'] = '+'.join(str(x) for x in scales)

        @api_query('census', **params)
        async def result(_, root):
            return [
                CensusScaleCurrent(scale_elem)
                for scale_elem in root.find('CENSUS')
            ]
        return result(self)"
4227,"def censushistory(self, *scales):
        """"""Historical World Census data.

        Was split into its own method for the sake of simplicity.

        By default returns data on today's featured World Census
        scale, use arguments to get results on specific scales.  In
        order to request data on all scales at once you can do
        ``x.censushistory(*range(81))``.

        Returns data for the entire length of history NationStates
        stores.  There is no way to override that.

        Parameters
        ----------
        scales : int
            World Census scales, integers between 0 and 85 inclusive.

        Returns
        -------
        an :class:`ApiQuery` of a list of :class:`CensusScaleHistory`
        """"""
        params = {'mode': 'history'}
        if scales:
            params['scale'] = '+'.join(str(x) for x in scales)

        @api_query('census', **params)
        async def result(_, root):
            return [
                CensusScaleHistory(scale_elem)
                for scale_elem in root.find('CENSUS')
            ]
        return result(self)"
4228,"async def censusranks(self, scale):
        """"""Iterate through nations ranked on the World Census scale.

        If the ranks change while you interate over them, they may be
        inconsistent.

        Parameters
        ----------
        scale : int
            A World Census scale, an integer between 0 and 85 inclusive.

        Returns
        -------
        asynchronous iterator of :class:`CensusRank`
        """"""
        order = count(1)
        for offset in count(1, 20):
            census_ranks = await self._get_censusranks(
                scale=scale, start=offset)
            for census_rank in census_ranks:
                assert census_rank.rank == next(order)
                yield census_rank
            if len(census_ranks) < 20:
                break"
4229,"def loads(astring):
        """"""Decompress and deserialize string into Python object via marshal.""""""
        try:
            return marshal.loads(zlib.decompress(astring))
        except zlib.error as e:
            raise SerializerError(
                'Cannot decompress object (""{}"")'.format(str(e))
            )
        except Exception as e:
            # marshal module does not provide a proper Exception model
            raise SerializerError(
                'Cannot restore object (""{}"")'.format(str(e))
            )"
4230,"def loads(astring):
        """"""Decompress and deserialize string into Python object via pickle.""""""
        try:
            return pickle.loads(zlib.decompress(astring))
        except zlib.error as e:
            raise SerializerError(
                'Cannot decompress object (""{}"")'.format(str(e))
            )
        except pickle.UnpicklingError as e:
            raise SerializerError(
                'Cannot restore object (""{}"")'.format(str(e))
            )"
4231,"def loads(astring):
        """"""Decompress and deserialize string into a Python object via pickle.""""""
        try:
            return pickle.loads(lzma.decompress(astring))
        except lzma.LZMAError as e:
            raise SerializerError(
                'Cannot decompress object (""{}"")'.format(str(e))
            )
        except pickle.UnpicklingError as e:
            raise SerializerError(
                'Cannot restore object (""{}"")'.format(str(e))
            )"
4232,"def search(self, path_expression, mode=UXP, values=None, ifunc=lambda x: x):
        """"""
        find matches for the given path expression in the data

        :param path_expression: path tuple or string
        :return:
        """"""
        # keys = path_expression if isinstance(path_expression, six.string_types) else path_expression[-1]

        path_and_value_list = iterutils.search(
            self.data,
            path_expression=path_expression,
            required_values=values,
            exact=(mode[1] == ""x""))

        return self.__return_value(path_and_value_list, mode, ifunc)"
4233,"def __visit_index_path(self, src, p, k, v):
        """"""
            Called during processing of source data
        """"""
        cp = p + (k,)
        self.path_index[cp] = self.indexed_obj_factory(p, k, v, self.path_index.get(cp))
        if cp in self.path_index:
            # if self.path_index[cp].assert_val_equals(v):
            #     raise ValueError('unexpected value change at path_index[{}]'.format(cp))
            self.path_index[cp].add_src(src)
        else:
            self.path_index[cp] = Flobject(val=v, path=cp, srcs=set([src]))"
4234,"def get_default_data_path(*args, module=None, class_=None, flag_raise=True):
    """"""
    Returns path to default data directory

    Arguments 'module' and 'class' give the chance to return path relative to package other than
    f311.filetypes

    Args:
        module: Python module object. It is expected that this module has a sub-subdirectory
                named 'data/default'
        class_: Python class object to extract path information from. If this argument is used,
                it will be expected that the class ""root"" package will have a sub-subdirectory
                named 'data/default'. Argument 'class_' **has precedence over argument 'module'**
        flag_raise: raises error if file is not found. This can be turned off for whichever purpose
    """"""
    if module is None:
        module = __get_filetypes_module()

    if class_ is not None:
        pkgname =  class_.__module__
        mseq = pkgname.split(""."")
        if len(mseq) < 2 or mseq[1] != ""filetypes"":
            raise ValueError(""Invalid module name for class '{}': '{}' ""
                             ""(must be '(...).filetypes[.(...)]')"".format(class_.__name__, pkgname))
        # gets ""root"" module object
        # For example, if pkgname is ""pyfant.filetypes.filemain"", module below will be
        # the ""pyfant"" module object
        module = sys.modules[mseq[0]]
    module_path = os.path.split(module.__file__)[0]
    p = os.path.abspath(os.path.join(module_path, ""data"", ""default"", *args))

    if flag_raise:
        if not os.path.isfile(p):
            raise RuntimeError(""Path not found '{}'"".format(p))

    return p"
4235,"def copy_default_data_file(filename, module=None):
    """"""Copies file from default data directory to local directory.""""""
    if module is None:
        module = __get_filetypes_module()
    fullpath = get_default_data_path(filename, module=module)
    shutil.copy(fullpath, ""."")"
4236,"def _find_display(self):
        """"""
        Find a usable display, which doesn't have an existing Xvfb file
        """"""
        self.display_num = 2
        while os.path.isdir(XVFB_PATH % (self.display_num,)):
            self.display_num += 1"
4237,"def comments(recid):
    """"""Display comments.""""""
    from invenio_access.local_config import VIEWRESTRCOLL
    from invenio_access.mailcookie import \
        mail_cookie_create_authorize_action
    from .api import check_user_can_view_comments
    auth_code, auth_msg = check_user_can_view_comments(current_user, recid)
    if auth_code and current_user.is_guest:
        cookie = mail_cookie_create_authorize_action(VIEWRESTRCOLL, {
            'collection': g.collection})
        url_args = {'action': cookie, 'ln': g.ln, 'referer': request.referrer}
        flash(_(""Authorization failure""), 'error')
        return redirect(url_for('webaccount.login', **url_args))
    elif auth_code:
        flash(auth_msg, 'error')
        abort(401)

    # FIXME check restricted discussion
    comments = CmtRECORDCOMMENT.query.filter(db.and_(
        CmtRECORDCOMMENT.id_bibrec == recid,
        CmtRECORDCOMMENT.in_reply_to_id_cmtRECORDCOMMENT == 0,
        CmtRECORDCOMMENT.star_score == 0
    )).order_by(CmtRECORDCOMMENT.date_creation).all()
    return render_template('comments/comments.html', comments=comments,
                           option='comments')"
4238,"def getattr(self, key, default=None, callback=None):
        u""""""Getting the attribute of an element.

        >>> xml = etree.Element('root')
        >>> xml.text = 'text'
        >>> Node(xml).getattr('text')
        'text'
        >>> Node(xml).getattr('text', callback=str.upper)
        'TEXT'
        >>> Node(xml).getattr('wrong_attr', default='default')
        'default'
        """"""
        value = self._xml.text if key == 'text' else self._xml.get(key, default)
        return callback(value) if callback else value"
4239,"def setattr(self, key, value):
        u""""""Sets an attribute on a node.

        >>> xml = etree.Element('root')
        >>> Node(xml).setattr('text', 'text2')
        >>> Node(xml).getattr('text')
        'text2'
        >>> Node(xml).setattr('attr', 'val')
        >>> Node(xml).getattr('attr')
        'val'
        """"""
        if key == 'text':
            self._xml.text = str(value)
        else:
            self._xml.set(key, str(value))"
4240,"def get(self, default=None, callback=None):
        u""""""Returns leaf's value.""""""
        value = self._xml.text if self._xml.text else default
        return callback(value) if callback else value"
4241,"def to_str(self, pretty_print=False, encoding=None, **kw):
        u""""""Converts a node with all of it's children to a string.

        Remaining arguments are passed to etree.tostring as is.

        kwarg without_comments: bool because it works only in C14N flags:
        'pretty print' and 'encoding' are ignored.

        :param bool pretty_print: whether to format the output
        :param str encoding: which encoding to use (ASCII by default)
        :rtype: str
        :returns: node's representation as a string
        """"""
        if kw.get('without_comments') and not kw.get('method'):
            kw.pop('without_comments')
            kw['method'] = 'c14n'
            kw['with_comments'] = False
        return etree.tostring(
            self._xml,
            pretty_print=pretty_print,
            encoding=encoding,
            **kw
        )"
4242,"def iter_children(self, key=None):
        u""""""Iterates over children.

        :param key: A key for filtering children by tagname.
        """"""
        tag = None

        if key:
            tag = self._get_aliases().get(key)

            if not tag:
                raise KeyError(key)

        for child in self._xml.iterchildren(tag=tag):
            if len(child):
                yield self.__class__(child)
            else:
                yield Literal(child)"
4243,"def update(self, **kwargs):
        u""""""Updating or creation of new simple nodes.

        Each dict key is used as a tagname and value as text.
        """"""
        for key, value in kwargs.items():
            helper = helpers.CAST_DICT.get(type(value), str)
            tag = self._get_aliases().get(key, key)

            elements = list(self._xml.iterchildren(tag=tag))
            if elements:
                for element in elements:
                    element.text = helper(value)
            else:
                element = etree.Element(key)
                element.text = helper(value)
                self._xml.append(element)
                self._aliases = None"
4244,"def sget(self, path, default=NONE_NODE):
        u""""""Enables access to nodes if one or more of them don't exist.

        Example:
        >>> m = Mappet('<root><tag attr1=""attr text"">text value</tag></root>')
        >>> m.sget('tag')
        text value
        >>> m.sget('tag.@attr1')
        'attr text'
        >>> m.sget('tag.#text')
        'text value'
        >>> m.sget('reply.vms_model_cars.car.0.params.doors')
        NONE_NODE

        Accessing nonexistent path returns None-like object with mocked
        converting functions which returns None:
        >>> m.sget('reply.fake_node').to_dict() is None
        True
        """"""
        attrs = str(path).split(""."")
        text_or_attr = None
        last_attr = attrs[-1]
        # Case of getting text or attribute
        if last_attr == '#text' or last_attr.startswith('@'):
            # #text => text, @attr => attr
            text_or_attr = last_attr[1:]
            attrs = attrs[:-1]
            # When getting #text and @attr we want default value to be None.
            if default is NONE_NODE:
                default = None

        my_object = self
        for attr in attrs:
            try:
                if isinstance(my_object, (list, tuple)) and re.match('^\-?\d+$', attr):
                    my_object_next = my_object[int(attr)]
                else:
                    my_object_next = getattr(my_object, attr)
                my_object = my_object_next
            except (AttributeError, KeyError, IndexError):
                return default

        # Return #text or @attr
        if text_or_attr:
            try:
                return my_object.getattr(text_or_attr)
            except AttributeError:
                # myObject can be a list.
                return None
        else:
            return my_object"
4245,"def create(self, tag, value):
        u""""""Creates a node, if it doesn't exist yet.

        Unlike attribute access, this allows to pass a node's name with hyphens.
        Those hyphens will be normalized automatically.

        In case the required element already exists, raises an exception.
        Updating/overwriting should be done using `update``.
        """"""
        child_tags = {child.tag for child in self._xml}

        if tag in child_tags:
            raise KeyError('Node {} already exists in XML tree.'.format(tag))

        self.set(tag, value)"
4246,"def set(self, name, value):
        u""""""Assigns a new XML structure to the node.

        A literal value, dict or list can be passed in. Works for all nested levels.

        Dictionary:
        >>> m = Mappet('<root/>')
        >>> m.head = {'a': 'A', 'b': {'#text': 'B', '@attr': 'val'}}
        >>> m.head.to_str()
        '<head><a>A</a><b attr=""val"">B</b></head>'

        List:
        >>> m.head = [{'a': i} for i in 'ABC']
        >>> m.head.to_str()
        '<head><a>A</a><a>B</a><a>C</a></head>'

        Literals:
        >>> m.head.leaf = 'A'
        >>> m.head.leaf.get()
        'A'
        """"""
        try:
            # Searches for a node to assign to.
            element = next(self._xml.iterchildren(tag=name))
        except StopIteration:
            # There is no such node in the XML tree. We create a new one
            # with current root as parent (self._xml).
            element = etree.SubElement(self._xml, name)

        if isinstance(value, dict):
            self.assign_dict(element, value)
        elif isinstance(value, (list, tuple, set)):
            self.assign_sequence_or_set(element, value)
        else:
            # Literal value.
            self.assign_literal(element, value)

        # Clear the aliases.
        self._aliases = None"
4247,"def assign_dict(self, node, xml_dict):
        """"""Assigns a Python dict to a ``lxml`` node.

        :param node: A node to assign the dict to.
        :param xml_dict: The dict with attributes/children to use.
        """"""
        new_node = etree.Element(node.tag)

        # Replaces the previous node with the new one
        self._xml.replace(node, new_node)

        # Copies #text and @attrs from the xml_dict
        helpers.dict_to_etree(xml_dict, new_node)"
4248,"def assign_literal(element, value):
        u""""""Assigns a literal.

        If a given node doesn't exist, it will be created.

        :param etree.Element element: element to which we assign.
        :param value: the value to assign
        """"""
        # Searches for a conversion method specific to the type of value.
        helper = helpers.CAST_DICT.get(type(value), str)

        # Removes all children and attributes.
        element.clear()
        element.text = helper(value)"
4249,"def to_dict(self, **kw):
        u""""""Converts the lxml object to a dict.

        possible kwargs:
            without_comments: bool
        """"""
        _, value = helpers.etree_to_dict(self._xml, **kw).popitem()
        return value"
4250,"def _get_aliases(self):
        u""""""Creates a dict with aliases.

        The key is a normalized tagname, value the original tagname.
        """"""
        if self._aliases is None:
            self._aliases = {}

            if self._xml is not None:
                for child in self._xml.iterchildren():
                    self._aliases[helpers.normalize_tag(child.tag)] = child.tag

        return self._aliases"
4251,"def xpath(
            self,
            path,
            namespaces=None,
            regexp=False,
            smart_strings=True,
            single_use=False,
    ):
        u""""""Executes XPath query on the ``lxml`` object and returns a correct object.

        :param str path: XPath string e.g., 'cars'/'car'

        :param str/dict namespaces: e.g., 'exslt', 're' or
            ``{'re': ""http://exslt.org/regular-expressions""}``
        :param bool regexp: if ``True`` and no namespaces is provided, it will use
            ``exslt`` namespace
        :param bool smart_strings:
        :param bool single_use: faster method for using only once. Does not
            create ``XPathEvaluator`` instance.

        >>> root = mappet.Mappet(""<root><a>aB</a><b>aBc</b></root>"")
        >>> root.XPath(
            ""//*[re:test(., '^abc$', 'i')]"",
            namespaces='exslt',
            regexp=True,
        )
        """"""
        if (
            namespaces in ['exslt', 're'] or
            (regexp and not namespaces)
        ):
            namespaces = {'re': ""http://exslt.org/regular-expressions""}
        if single_use:
            node = self._xml.xpath(path)
        else:
            xpe = self.xpath_evaluator(
                namespaces=namespaces,
                regexp=regexp,
                smart_strings=smart_strings
            )
            node = xpe(path)

        if len(node) == 1:
            node = node[0]
            if len(node):
                return self.__class__(node)
            else:
                return Literal(node)
        return node"
4252,"def xpath_evaluator(self, namespaces=None, regexp=False, smart_strings=True):
        u""""""Creates an XPathEvaluator instance for an ElementTree or an Element.

        :returns: ``XPathEvaluator`` instance
        """"""
        return etree.XPathEvaluator(
            self._xml,
            namespaces=namespaces,
            regexp=regexp,
            smart_strings=smart_strings
        )"
4253,"def get_last_modified_date(*args, **kwargs):
    """"""Returns the date of the last modified Note or Release.

    For use with Django's last_modified decorator.
    """"""
    try:
        latest_note = Note.objects.latest()
        latest_release = Release.objects.latest()
    except ObjectDoesNotExist:
        return None

    return max(latest_note.modified, latest_release.modified)"
4254,"def using_ios_stash():
    ''' returns true if sys path hints the install is running on ios '''
    print('detected install path:')
    print(os.path.dirname(__file__))
    module_names = set(sys.modules.keys())
    return 'stash' in module_names or 'stash.system' in module_names"
4255,"def pad_bin_image_to_shape(image, shape):
    """"""
    Padd image to size :shape: with zeros
    """"""
    h, w = shape
    ih, iw = image.shape
    assert ih <= h
    assert iw <= w
    if iw < w:
        result = numpy.hstack((image, numpy.zeros((ih, w - iw), bool)))
    else:
        result = image
    if ih < h:
        result = numpy.vstack((result, numpy.zeros((h - ih, w), bool)))
    return result"
4256,"def best_convolution(bin_template, bin_image,
                     tollerance=0.5, overlap_table=OVERLAP_TABLE):
    """"""
    Selects and applies the best convolution method to find template in image.

    Returns a list of matches in (width, height, x offset, y offset)
    format (where the x and y offsets are from the top left corner).

    As the images are binary images, we can utilise the extra bit space in the
    float64's by cutting the image into tiles and stacking them into variable
    grayscale values.

    This allows converting a sparse binary image into a dense(r) grayscale one.
    """"""

    template_sum = numpy.count_nonzero(bin_template)
    th, tw = bin_template.shape
    ih, iw = bin_image.shape
    if template_sum == 0 or th == 0 or tw == 0:
        # If we don't have a template
        return []
    if th > ih or tw > iw:
        # If the template is bigger than the image
        return []

    # How many cells can we split the image into?
    max_vert_cells = ih // th
    max_hor_cells = iw // th

    # Try to work out how many times we can stack the image
    usable_factors = {n: factors for n, factors in overlap_table.iteritems()
                      if ((template_sum + 1) ** (n)) < ACCURACY_LIMIT}
    overlap_options = [(factor, n // factor)
                       for n, factors in usable_factors.iteritems()
                       for factor in factors
                       if (factor <= max_vert_cells and
                           n // factor <= max_hor_cells)]
    if not overlap_options:
        # We can't stack the image
        return convolution(bin_template, bin_image, tollerance=tollerance)
    best_overlap = min(overlap_options,
                       key=lambda x: ((ih // x[0] + th) * (iw // x[1] + tw)))
    return overlapped_convolution(bin_template, bin_image,
                                  tollerance=tollerance, splits=best_overlap)"
4257,"def overlapped_convolution(bin_template, bin_image,
                           tollerance=0.5, splits=(4, 2)):
    """"""
    As each of these images are hold only binary values, and RFFT2 works on
    float64 greyscale values, we can make the convolution more efficient by
    breaking the image up into :splits: sectons. Each one of these sections
    then has its greyscale value adjusted and then stacked.

    We then apply the convolution to this 'stack' of images, and adjust the
    resultant position matches.
    """"""
    th, tw = bin_template.shape
    ih, iw = bin_image.shape
    hs, ws = splits
    h = ih // hs
    w = iw // ws
    count = numpy.count_nonzero(bin_template)
    assert count > 0
    assert h >= th
    assert w >= tw

    yoffset = [(i * h, ((i + 1) * h) + (th - 1)) for i in range(hs)]
    xoffset = [(i * w, ((i + 1) * w) + (tw - 1)) for i in range(ws)]

    # image_stacks is Origin (x,y), array, z (height in stack)
    image_stacks = [((x1, y1), bin_image[y1:y2, x1:x2], float((count + 1) ** (num)))
                    for num, (x1, x2, y1, y2) in
                    enumerate((x1, x2, y1, y2) for (x1, x2)
                              in xoffset for (y1, y2) in yoffset)]

    pad_h = max(i.shape[0] for _, i, _ in image_stacks)
    pad_w = max(i.shape[1] for _, i, _ in image_stacks)

    # rfft metrics must be an even size - why ... maths?
    pad_w += pad_w % 2
    pad_h += pad_h % 2

    overlapped_image = sum_2d_images(pad_bin_image_to_shape(i, (pad_h, pad_w))
                                     * num for _, i, num in image_stacks)
    #print ""Overlap splits %r, Image Size (%d,%d),
    #Overlapped Size (%d,%d)""  % (splits,iw,ih,pad_w,pad_h)

    # Calculate the convolution of the FFT's of the overlapped image & template
    convolution_freqs = (rfft2(overlapped_image) *
                         rfft2(bin_template[::-1, ::-1],
                               overlapped_image.shape))

    # Reverse the FFT to find the result overlapped image
    convolution_image = irfft2(convolution_freqs)
    # At this point, the maximum point in convolution_image should be the
    # bottom right (why?) of the area of greatest match

    results = set()
    for (x, y), _, num in image_stacks[::-1]:
        test = convolution_image / num
        filtered = ((test >= (count - tollerance)) &
                   (test <= (count + tollerance)))
        match_points = numpy.transpose(numpy.nonzero(filtered))  # bottom right
        for (fy, fx) in match_points:
            if fx < (tw - 1) or fy < (th - 1):
                continue
            results.add((x + fx - (tw - 1), y + fy - (th - 1)))
        convolution_image %= num
    return list(results)"
4258,"def get_partition_scores(image, min_w=1, min_h=1):
    """"""Return list of best to worst binary splits along the x and y axis.

    """"""
    h, w = image.shape[:2]
    if w == 0 or h == 0:
        return []
    area = h * w
    cnz = numpy.count_nonzero
    total = cnz(image)
    if total == 0 or area == total:
        return []
    if h < min_h * 2:
        y_c = []
    else:
        y_c = [(-abs((count / ((h - y) * w)) - ((total - count) / (y * w))),
                y, 0)
               for count, y in ((cnz(image[y:]), y)
                                for y in range(min_h, image.shape[0] - min_h))]
    if w < min_w * 2:
        x_c = []
    else:
        x_c = [(-abs((count / (h * (w - x))) - ((total - count) / (h * x))),
                x, 1)
               for count, x in ((cnz(image[:, x:]), x)
                                for x in range(min_w, image.shape[1] - min_w))]
    return sorted(x_c + y_c)"
4259,"def binary_partition_image(image, min_w=1, min_h=1, depth=0, max_depth=-1):
    """"""Return a bsp of [pos, axis, [before_node, after_node]] nodes where leaf
    nodes == None.

    If max_depth < 0 this function will continue until all leaf nodes have
    been found, if it is >= 0 leaf nodes will be created at that depth.

    min_w and min_h are the minimum width or height of a partition.

    """"""
    if max_depth >= 0 and depth >= max_depth:
        return None
    partition = get_best_partition(image, min_w=min_w, min_h=min_h)
    if partition is None:
        return None
    pos, axis = partition
    if axis == 0:
        p1 = binary_partition_image(
            image[pos:], min_w, min_h, depth + 1, max_depth)
        p2 = binary_partition_image(
            image[:pos], min_w, min_h, depth + 1, max_depth)
    elif axis == 1:
        p1 = binary_partition_image(
            image[:, pos:], min_w, min_h, depth + 1, max_depth)
        p2 = binary_partition_image(
            image[:, :pos], min_w, min_h, depth + 1, max_depth)
    return [pos, axis, [p1, p2]]"
4260,"def find_threshold_near_density(img, density, low=0, high=255):
    """"""Find a threshold where the fraction of pixels above the threshold
    is closest to density where density is (count of pixels above
    threshold / count of pixels).

    The highest threshold closest to the desired density will be returned.

    Use low and high to exclude undesirable thresholds.

    :param img: target image
    :type img: 2d :class:`numpy.ndarray`
    :param density: target density
    :type density: float between 0.0 and 1.0
    :param low: min threshold to test
    :type low: ubyte
    :param migh: max threshold to test
    :type low: ubyte
    :rtype: ubyte

    """"""
    size = numpy.size(img)
    densities = []
    last_t = None
    while True:
        t = ((high - low) // 2) + low
        if t == last_t:
            densities.sort(key=lambda x: (abs(x[0] - density), 256 - x[1]))
            return densities[0][1]
        else:
            last_t = t
        d = numpy.count_nonzero(img > t) / size
        densities.append((d, t))
        if d < density:
            high = t
        elif d >= density:  # search away from low
            low = t"
4261,"def filter_greys_using_image(image, target):
    """"""Filter out any values in target not in image

    :param image: image containing values to appear in filtered image
    :param target: the image to filter
    :rtype: 2d  :class:`numpy.ndarray` containing only value in image
        and with the same dimensions as target

    """"""
    maskbase = numpy.array(range(256), dtype=numpy.uint8)
    mask = numpy.where(numpy.in1d(maskbase, numpy.unique(image)), maskbase, 0)
    return mask[target]"
4262,"def get_swagger_view(title=None, url=None, generator_class=SchemaGenerator):
    """"""
    Returns schema view which renders Swagger/OpenAPI.
    """"""
    return schemas.get_schema_view(
        title=title,
        url=url,
        renderer_classes=[
            CoreJSONRenderer,
            renderers.OpenAPIRenderer,
            renderers.SwaggerUIRenderer],
        generator_class=generator_class)"
4263,"def __init_defaults(self, config):
        """"""Initializes the default connection settings.""""""

        provider = self.__provider

        if provider == 'sqlite':
            config.setdefault('dbname', ':memory:')
            config.setdefault('create_db',  True)
        elif provider == 'mysql':
            config.setdefault('port', 3306)
            config.setdefault('charset', 'utf8')
        elif provider == 'postgres':
            config.setdefault('port', 5432)
        elif provider == 'oracle':
            config.setdefault('port', 1521)
        else:
            raise ValueError('Unsupported provider ""{}""'.format(provider))

        if provider != 'sqlite':
            config.setdefault('host', 'localhost')
            config.setdefault('user', None)
            config.setdefault('password', None)
            config.setdefault('dbname', None)"
4264,"def persist_one(self, file_base64_content, filename, extension, mime, is_private=True):
        """"""
        Загружает файл в облако
        :type origin: string Принимает значения ROBOT, USER
        """"""
        return self.__app.api_call(""MediaService"", ""persist_one"", locals(), {})"
4265,"def upload(self, file_descriptor, settings):
        """"""
        Загружает файл в облако
        :param file_descriptor: открытый дескриптор
        :param settings: настройки загрузки
        :rtype: requests.Response
        """"""
        multipart_form_data = {
            'file': file_descriptor
        }
        params = {""settings"": json.dumps(settings)}
        dr = self.__app.native_api_call('media', 'upload', params, self.__options, True, multipart_form_data, False, http_path=""/api/meta/v1/"", http_method='POST',
                                        connect_timeout_sec=60 * 10)
        return json.loads(dr.text)"
4266,"def download(self, media_id, as_stream=False):
        """"""
        Скачивает указанный файл
        :param media_id: string
        :rtype: requests.Response
        """"""
        response = self.__app.native_api_call('media', 'd/' + media_id, {}, self.__options, False, None, as_stream, http_path=""/api/meta/v1/"", http_method='GET')
        return response"
4267,"def info(self, media_id):
        """"""
        Получить информацию по файлу
        :param media_id:
        :rtype: requests.Response
        """"""
        dr = self.__app.native_api_call('media', 'i/' + media_id, {}, self.__options, False, None, False, http_path=""/api/meta/v1/"", http_method='GET')
        return json.loads(dr.text)"
4268,"def create_order(cls, order, **kwargs):
        """"""Create Order

        Create a new Order
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_order(order, async=True)
        >>> result = thread.get()

        :param async bool
        :param Order order: Attributes of order to create (required)
        :return: Order
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_order_with_http_info(order, **kwargs)
        else:
            (data) = cls._create_order_with_http_info(order, **kwargs)
            return data"
4269,"def delete_order_by_id(cls, order_id, **kwargs):
        """"""Delete Order

        Delete an instance of Order by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_order_by_id(order_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str order_id: ID of order to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_order_by_id_with_http_info(order_id, **kwargs)
        else:
            (data) = cls._delete_order_by_id_with_http_info(order_id, **kwargs)
            return data"
4270,"def get_order_by_id(cls, order_id, **kwargs):
        """"""Find Order

        Return single instance of Order by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_order_by_id(order_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str order_id: ID of order to return (required)
        :return: Order
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_order_by_id_with_http_info(order_id, **kwargs)
        else:
            (data) = cls._get_order_by_id_with_http_info(order_id, **kwargs)
            return data"
4271,"def list_all_orders(cls, **kwargs):
        """"""List Orders

        Return a list of Orders
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_orders(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[Order]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_orders_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_orders_with_http_info(**kwargs)
            return data"
4272,"def replace_order_by_id(cls, order_id, order, **kwargs):
        """"""Replace Order

        Replace all attributes of Order
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_order_by_id(order_id, order, async=True)
        >>> result = thread.get()

        :param async bool
        :param str order_id: ID of order to replace (required)
        :param Order order: Attributes of order to replace (required)
        :return: Order
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_order_by_id_with_http_info(order_id, order, **kwargs)
        else:
            (data) = cls._replace_order_by_id_with_http_info(order_id, order, **kwargs)
            return data"
4273,"def update_order_by_id(cls, order_id, order, **kwargs):
        """"""Update Order

        Update attributes of Order
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_order_by_id(order_id, order, async=True)
        >>> result = thread.get()

        :param async bool
        :param str order_id: ID of order to update. (required)
        :param Order order: Attributes of order to update. (required)
        :return: Order
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_order_by_id_with_http_info(order_id, order, **kwargs)
        else:
            (data) = cls._update_order_by_id_with_http_info(order_id, order, **kwargs)
            return data"
4274,"async def newnations(self, root):
        """"""Most recently founded nations, from newest.

        Returns
        -------
        an :class:`ApiQuery` of a list of :class:`Nation`
        """"""
        return [aionationstates.Nation(n)
                for n in root.find('NEWNATIONS').text.split(',')]"
4275,"async def regions(self, root):
        """"""List of all the regions, seemingly in order of creation.

        Returns
        -------
        an :class:`ApiQuery` of a list of :class:`Region`
        """"""
        return [aionationstates.Region(r)
                for r in root.find('REGIONS').text.split(',')]"
4276,"def regionsbytag(self, *tags):
        """"""All regions with any of the named tags.

        Parameters
        ----------
        *tags : str
            Regional tags.  Can be preceded by a ``-`` to select regions
            without that tag.

        Returns
        -------
        an :class:`ApiQuery` of a list of :class:`Region`
        """"""
        if len(tags) > 10:
            raise ValueError('You can specify up to 10 tags')
        if not tags:
            raise ValueError('No tags specified')

        # We don't check for invalid tags here because the behaviour is
        # fairly intuitive - quering for a non-existent tag returns no
        # regions, excluding it returns all of them.
        @api_query('regionsbytag', tags=','.join(tags))
        async def result(_, root):
            text = root.find('REGIONS').text
            return ([aionationstates.Region(r) for r in text.split(',')]
                    if text else [])
        return result(self)"
4277,"def dispatch(self, id):
        """"""Dispatch by id.

        Parameters
        ----------
        id : int
            Dispatch id.

        Returns
        -------
        an :class:`ApiQuery` of :class:`Dispatch`

        Raises
        ------
        :class:`NotFound`
            If a dispatch with the requested id doesn't exist.
        """"""
        @api_query('dispatch', dispatchid=str(id))
        async def result(_, root):
            elem = root.find('DISPATCH')
            if not elem:
                raise NotFound(f'No dispatch found with id {id}')
            return Dispatch(elem)
        return result(self)"
4278,"def dispatchlist(self, *, author=None, category=None,
                     subcategory=None, sort='new'):
        """"""Find dispatches by certain criteria.

        Parameters
        ----------
        author : str
            Name of the nation authoring the dispatch.
        category : str
            Dispatch's primary category.
        subcategory : str
            Dispatch's secondary category.
        sort : str
            Sort order, 'new' or 'best'.

        Returns
        -------
        an :class:`ApiQuery` of a list of :class:`DispatchThumbnail`
        """"""
        params = {'sort': sort}
        if author:
            params['dispatchauthor'] = author
        # Here we do need to ensure that our categories are valid, cause
        # NS just ignores the categories it doesn't recognise and returns
        # whatever it feels like.
        if category and subcategory:
            if (category not in dispatch_categories or
                    subcategory not in dispatch_categories[category]):
                raise ValueError('Invalid category/subcategory')
            params['dispatchcategory'] = f'{category}:{subcategory}'
        elif category:
            if category not in dispatch_categories:
                raise ValueError('Invalid category')
            params['dispatchcategory'] = category
        else:
            raise ValueError('Cannot request subcategory without category')

        @api_query('dispatchlist', **params)
        async def result(_, root):
            return [
                DispatchThumbnail._from_elem(elem)
                for elem in root.find('DISPATCHLIST')
            ]
        return result(self)"
4279,"def poll(self, id):
        """"""Poll with a given id.

        Parameters
        ----------
        id : int
            Poll id.

        Returns
        -------
        an :class:`ApiQuery` of :class:`Poll`

        Raises
        ------
        :class:`NotFound`
            If a poll with the requested id doesn't exist.
        """"""
        @api_query('poll', pollid=str(id))
        async def result(_, root):
            elem = root.find('POLL')
            if not elem:
                raise NotFound(f'No poll found with id {id}')
            return Poll(elem)
        return result(self)"
4280,"def banner(self, *ids, _expand_macros=None):
        """"""Get data about banners by their ids.

        Macros in banners' names and descriptions are not expanded.

        Parameters
        ----------
        *ids : str
           Banner ids.

        Returns
        -------
        an :class:`ApiQuery` of a list of :class:`Banner`

        Raises
        ------
        :class:`NotFound`
            If any of the provided ids is invalid.
        """"""
        async def noop(s):
            return s

        _expand_macros = _expand_macros or noop

        @api_query('banner', banner=','.join(ids))
        async def result(_, root):
            banners = [await Banner(elem, _expand_macros)
                       for elem in root.find('BANNERS')]
            if not len(banners) == len(ids):
                raise NotFound('one of the banner ids provided is invalid')
            return banners
        return result(self)"
4281,"async def send_telegram(self, *, client_key, telegram_id,
                            telegram_key, recepient):
        """"""A basic interface to the Telegrams API.

        Parameters
        ----------
        client_key : str
            Telegrams API Client Key.
        telegram_id : int or str
            Telegram id.
        telegram_key : str
            Telegram key.
        recepient : str
            Name of the nation you want to telegram.

        Returns
        -------
        an awaitable
        """"""
        params = {
            'a': 'sendTG',
            'client': client_key,
            'tgid': str(telegram_id),
            'key': telegram_key,
            'to': recepient
        }
        return await self._call_api(params)"
4282,"async def happenings(self, *, nations=None, regions=None, filters=None,
                         beforeid=None, beforetime=None):
        """"""Iterate through happenings from newest to oldest.

        Parameters
        ----------
        nations : iterable of str
            Nations happenings of which will be requested.  Cannot be
            specified at the same time with ``regions``.
        regions : iterable of str
            Regions happenings of which will be requested.  Cannot be
            specified at the same time with ``nations``.
        filters : iterable of str
            Categories to request happenings by.  Available filters
            are: ``law``, ``change``, ``dispatch``, ``rmb``,
            ``embassy``, ``eject``, ``admin``, ``move``, ``founding``,
            ``cte``, ``vote``, ``resolution``, ``member``, and ``endo``.
        beforeid : int
            Only request happenings before this id.
        beforetime : :class:`datetime.datetime`
            Only request happenings that were emitted before this
            moment.

        Returns
        -------
        an asynchronous iterator yielding any of the classes from \
        the :mod:`~aionationstates.happenings` module
        """"""
        while True:
            happening_bunch = await self._get_happenings(
                nations=nations, regions=regions, filters=filters,
                beforeid=beforeid, beforetime=beforetime
            )
            for happening in happening_bunch:
                yield happening
            if len(happening_bunch) < 100:
                break
            beforeid = happening_bunch[-1].id"
4283,"async def new_happenings(self, poll_period=30, *, nations=None,
                             regions=None, filters=None):
        """"""Iterate through new happenings as they arrive::

            async for happening in \\
                    world.new_happenings(region='the north pacific'):
                # Your processing code here
                print(happening.text)  # As an example

        Guarantees that:

        * Every happening is generated from the moment the generator
          is started;
        * No happening is generated more than once;
        * Happenings are generated in order from oldest to newest.

        Parameters
        ----------
        poll_period : int
            How long to wait between requesting the next portion of
            happenings, in seconds.  Note that this should only be
            tweaked for latency reasons, as the function gives a
            guarantee that all happenings will be generated.

            Also note that, regardless of the ``poll_period`` set, all
            of the code in your loop body still has to execute (likely
            several times) before a new portion of happenings can be
            requested.  Consider wrapping your happening-processing code
            in a coroutine and launching it as a task from the loop body
            if you suspect this might become an issue.

            Requests made by this generator are, of course, subject to
            the API rate limit, and if the limiter has to temporarily
            block new requests the time spent waiting will be added on
            top of ``poll_period``.
        nations : iterable of str
            Nations happenings of which will be requested.  Cannot be
            specified at the same time with ``regions``.
        regions : iterable of str
            Regions happenings of which will be requested.  Cannot be
            specified at the same time with ``nations``.
        filters : iterable of str
            Categories to request happenings by.  Available filters
            are: ``law``, ``change``, ``dispatch``, ``rmb``,
            ``embassy``, ``eject``, ``admin``, ``move``, ``founding``,
            ``cte``, ``vote``, ``resolution``, ``member``, and ``endo``.

        Returns
        -------
        an asynchronous iterator yielding any of the classes from \
        the :mod:`~aionationstates.happenings` module
        """"""
        try:
            # We only need the happenings from this point forwards
            last_id = (await self._get_happenings(
                nations=nations, regions=regions, filters=filters,
                limit=1))[0].id
        except IndexError:
            # Happenings before this point have all been deleted
            last_id = 0

        while True:
            # Sleep before the loop body to avoid wasting the first request
            await sleep(poll_period)

            # I don't think there's a cleaner solution, sadly.
            happenings = []
            async for happening in self.happenings(
                    nations=nations, regions=regions, filters=filters):
                if happening.id <= last_id:
                    break
                happenings.append(happening)

            with suppress(IndexError):
                last_id = happenings[0].id

            for happening in reversed(happenings):
                yield happening"
4284,"def find_potential_match_regions(template, transformed_array, method='correlation', raw_tolerance=0.666):
    """"""To prevent prohibitively slow calculation of normalisation coefficient at each point in image
       find potential match points, and normalise these only these.
       This function uses the definitions of the matching functions to calculate the expected match value
       and finds positions in the transformed array matching these- normalisation will then eliminate false positives
    """"""
    if method == 'correlation':
        match_value  = np.sum(template**2) # this will be the value of the match in the
    elif method == 'squared difference':
        match_value = 0
    elif method == 'correlation coefficient':
        temp_minus_mean = template - np.mean(template)
        match_value = np.sum(temp_minus_mean**2)
    else:
        raise ValueError('Matching method not implemented')
    condition = ((np.round(transformed_array, decimals=3)>=match_value*raw_tolerance) &
                 (np.round(transformed_array, decimals=3)<=match_value*(1./raw_tolerance)))
    return np.transpose(condition.nonzero())"
4285,"def normalise_correlation(image_tile_dict, transformed_array, template, normed_tolerance=1):
    """"""Calculates the normalisation coefficients of potential match positions
       Then normalises the correlation at these positions, and returns them
       if they do indeed constitute a match
    """"""
    template_norm = np.linalg.norm(template)
    image_norms = {(x,y):np.linalg.norm(image_tile_dict[(x,y)])*template_norm for (x,y) in image_tile_dict.keys()}
    match_points = image_tile_dict.keys()
    # for correlation, then need to transofrm back to get correct value for division
    h, w = template.shape
    #points_from_transformed_array = [(match[0] + h - 1, match[1] + w - 1) for match in match_points]
    image_matches_normalised = {match_points[i]:transformed_array[match_points[i][0], match_points[i][1]]/image_norms[match_points[i]] for i in range(len(match_points))}
    result = {key:value for key, value in image_matches_normalised.items() if np.round(value, decimals=3) >= normed_tolerance}
    return result.keys()"
4286,"def normalise_correlation_coefficient(image_tile_dict, transformed_array, template, normed_tolerance=1):
    """"""As above, but for when the correlation coefficient matching method is used
    """"""
    template_mean = np.mean(template)
    template_minus_mean = template - template_mean
    template_norm = np.linalg.norm(template_minus_mean)
    image_norms = {(x,y):np.linalg.norm(image_tile_dict[(x,y)]- np.mean(image_tile_dict[(x,y)]))*template_norm for (x,y) in image_tile_dict.keys()}
    match_points = image_tile_dict.keys()
    # for correlation, then need to transofrm back to get correct value for division
    h, w = template.shape
    image_matches_normalised = {match_points[i]:transformed_array[match_points[i][0], match_points[i][1]]/image_norms[match_points[i]] for i in range(len(match_points))}
    normalised_matches = {key:value for key, value in image_matches_normalised.items() if np.round(value, decimals=3) >= normed_tolerance}
    return normalised_matches.keys()"
4287,"def calculate_squared_differences(image_tile_dict, transformed_array, template, sq_diff_tolerance=0.1):
    """"""As above, but for when the squared differences matching method is used
    """"""
    template_norm_squared = np.sum(template**2)
    image_norms_squared = {(x,y):np.sum(image_tile_dict[(x,y)]**2) for (x,y) in image_tile_dict.keys()}
    match_points = image_tile_dict.keys()
    # for correlation, then need to transofrm back to get correct value for division
    h, w = template.shape
    image_matches_normalised = {match_points[i]:-2*transformed_array[match_points[i][0], match_points[i][1]] + image_norms_squared[match_points[i]] + template_norm_squared for i in range(len(match_points))}
    #print image_matches_normalised
    cutoff = h*w*255**2*sq_diff_tolerance
    normalised_matches = {key:value for key, value in image_matches_normalised.items() if np.round(value, decimals=3) <= cutoff}
    return normalised_matches.keys()"
4288,"def __init_os_api(self):
        """"""
        Initialise client objects for talking to OpenStack API.

        This is in a separate function so to be called by ``__init__`` and
        ``__setstate__``.
        """"""
        loader = loading.get_plugin_loader('password')
        auth = loader.load_from_options(auth_url=self._os_auth_url,
                                        username=self._os_username,
                                        password=self._os_password,
                                        project_name=self._os_tenant_name)
        sess = session.Session(auth=auth)
        self.nova_client = nova_client.Client(self.nova_api_version, session=sess)
        self.neutron_client = neutron_client.Client(session=sess)
        self.glance_client = glance_client.Client('2', session=sess)
        self.cinder_client = cinder_client.Client('2', session=sess)"
4289,"def stop_instance(self, instance_id):
        """"""Stops the instance gracefully.

        :param str instance_id: instance identifier
        """"""
        instance = self._load_instance(instance_id)
        instance.delete()
        del self._instances[instance_id]"
4290,"def get_ips(self, instance_id):
        """"""Retrieves all IP addresses associated to a given instance.

        :return: tuple (IPs)
        """"""
        instance = self._load_instance(instance_id)
        IPs = sum(instance.networks.values(), [])
        return IPs"
4291,"def is_instance_running(self, instance_id):
        """"""Checks if the instance is up and running.

        :param str instance_id: instance identifier

        :return: bool - True if running, False otherwise
        """"""

        # Here, it's always better if we update the instance.
        instance = self._load_instance(instance_id, force_reload=True)
        return instance.status == 'ACTIVE'"
4292,"def _check_keypair(self, name, public_key_path, private_key_path):
        """"""First checks if the keypair is valid, then checks if the keypair
        is registered with on the cloud. If not the keypair is added to the
        users ssh keys.

        :param str name: name of the ssh key
        :param str public_key_path: path to the ssh public key file
        :param str private_key_path: path to the ssh private key file

        :raises: `KeypairError` if key is not a valid RSA or DSA key,
                 the key could not be uploaded or the fingerprint does not
                 match to the one uploaded to the cloud.
        """"""

        # Read key. We do it as first thing because we need it either
        # way, to check the fingerprint of the remote keypair if it
        # exists already, or to create a new keypair.
        pkey = None
        try:
            pkey = DSSKey.from_private_key_file(private_key_path)
        except PasswordRequiredException:
            warn(""Unable to check key file `{0}` because it is encrypted with a ""
                 ""password. Please, ensure that you added it to the SSH agent ""
                 ""with `ssh-add {1}`""
                 .format(private_key_path, private_key_path))
        except SSHException:
            try:
                pkey = RSAKey.from_private_key_file(private_key_path)
            except PasswordRequiredException:
                warn(""Unable to check key file `{0}` because it is encrypted with a ""
                     ""password. Please, ensure that you added it to the SSH agent ""
                     ""with `ssh-add {1}`""
                     .format(private_key_path, private_key_path))
            except SSHException:
                raise KeypairError('File `%s` is neither a valid DSA key '
                                   'or RSA key.' % private_key_path)

        try:
            # Check if a keypair `name` exists on the cloud.
            keypair = self.nova_client.keypairs.get(name)

            # Check if it has the correct keypair, but only if we can read the local key
            if pkey:
                fingerprint = str.join(
                    ':', (i.encode('hex') for i in pkey.get_fingerprint()))
                if fingerprint != keypair.fingerprint:
                    raise KeypairError(
                        ""Keypair `%s` is present but has ""
                        ""different fingerprint. Aborting!"" % name)
            else:
                warn(""Unable to check if the keypair is using the correct key."")
        except NotFound:
            log.warning(
                ""Keypair `%s` not found on resource `%s`, Creating a new one"",
                name, self._os_auth_url)

            # Create a new keypair
            with open(os.path.expanduser(public_key_path)) as f:
                key_material = f.read()
                try:
                    self.nova_client.keypairs.create(name, key_material)
                except Exception as ex:
                    log.error(
                        ""Could not import key `%s` with name `%s` to `%s`"",
                        name, public_key_path, self._os_auth_url)
                    raise KeypairError(
                        ""could not create keypair `%s`: %s"" % (name, ex))"
4293,"def _load_instance(self, instance_id, force_reload=True):
        """"""
        Return instance with the given id.

        For performance reasons, the instance ID is first searched for in the
        collection of VM instances started by ElastiCluster
        (`self._instances`), then in the list of all instances known to the
        cloud provider at the time of the last update
        (`self._cached_instances`), and finally the cloud provider is directly
        queried.

        :param str instance_id: instance identifier
        :param bool force_reload:
          if ``True``, skip searching caches and reload instance from server
          and immediately reload instance data from cloud provider
        :return: py:class:`novaclient.v1_1.servers.Server` - instance
        :raises: `InstanceError` is returned if the instance can't
                 be found in the local cache or in the cloud.
        """"""
        if force_reload:
            try:
                # Remove from cache and get from server again
                vm = self.nova_client.servers.get(instance_id)
            except NotFound:
                raise InstanceNotFoundError(
                    ""Instance `{instance_id}` not found""
                    .format(instance_id=instance_id))
            # update caches
            self._instances[instance_id] = vm
            self._cached_instances[instance_id] = vm

        # if instance is known, return it
        if instance_id in self._instances:
            return self._instances[instance_id]

        # else, check (cached) list from provider
        if instance_id not in self._cached_instances:
            # Refresh the cache, just in case
            self._cached_instances = dict(
                (vm.id, vm) for vm in self.nova_client.servers.list())

        if instance_id in self._cached_instances:
            inst = self._cached_instances[instance_id]
            self._instances[instance_id] = inst
            return inst

        # If we reached this point, the instance was not found neither
        # in the caches nor on the website.
        raise InstanceNotFoundError(
            ""Instance `{instance_id}` not found""
            .format(instance_id=instance_id))"
4294,"def _allocate_address(self, instance, network_ids):
        """"""
        Allocates a floating/public ip address to the given instance.

        :param instance: instance to assign address to

        :param list network_id: List of IDs (as strings) of networks where to
        request allocation the floating IP.

        :return: public ip address
        """"""
        with OpenStackCloudProvider.__node_start_lock:
            try:
                # Use the `novaclient` API (works with python-novaclient <8.0.0)
                free_ips = [ip for ip in self.nova_client.floating_ips.list() if not ip.fixed_ip]
                if not free_ips:
                    free_ips.append(self.nova_client.floating_ips.create())
            except AttributeError:
                # Use the `neutronclient` API
                #
                # for some obscure reason, using `fixed_ip_address=None` in the
                # call to `list_floatingips()` returns *no* results (not even,
                # in fact, those with `fixed_ip_address: None`) whereas
                # `fixed_ip_address=''` acts as a wildcard and lists *all* the
                # addresses... so filter them out with a list comprehension
                free_ips = [ip for ip in
                            self.neutron_client.list_floatingips(fixed_ip_address='')['floatingips']
                            if ip['fixed_ip_address'] is None]
                if not free_ips:
                    # FIXME: OpenStack Network API v2 requires that we specify
                    # a network ID along with the request for a floating IP.
                    # However, ElastiCluster configuration allows for multiple
                    # networks to be connected to a VM, but does not give any
                    # hint as to which one(s) should be used for such requests.
                    # So we try them all, ignoring errors until one request
                    # succeeds and hope that it's the OK. One can imagine
                    # scenarios where this is *not* correct, but: (1) these
                    # scenarios are unlikely, and (2) the old novaclient code
                    # above has not even had the concept of multiple networks
                    # for floating IPs and no-one has complained in 5 years...
                    allocated_ip = None
                    for network_id in network_ids:
                        log.debug(
                            ""Trying to allocate floating IP on network %s ..."", network_id)
                        try:
                            allocated_ip = self.neutron_client.create_floatingip({
                                'floatingip': {'floating_network_id':network_id}})
                        except BadNeutronRequest as err:
                            log.debug(
                                ""Failed allocating floating IP on network %s: %s"",
                                network_id, err)
                        if allocated_ip:
                            free_ips.append(allocated_ip)
                            break
                        else:
                            continue  # try next network
            if free_ips:
                ip = free_ips.pop()
            else:
                raise RuntimeError(
                    ""Could not allocate floating IP for VM {0}""
                    .format(vm.id))
            instance.add_floating_ip(ip)
        return ip.ip"
4295,"async def post(self):
        """"""Get the message lodged.

        Returns
        -------
        an :class:`aionationstates.ApiQuery` of :class:`aionationstates.Post`
        """"""
        post = (await self.region._get_messages(
            fromid=self._post_id, limit=1))[0]
        assert post.id == self._post_id
        return post"
4296,"async def resolution(self):
        """"""Get the resolution voted on.

        Returns
        -------
        awaitable of :class:`aionationstates.ResolutionAtVote`
            The resolution voted for.

        Raises
        ------
        aionationstates.NotFound
            If the resolution has since been passed or defeated.
        """"""
        resolutions = await asyncio.gather(
            aionationstates.ga.resolution_at_vote,
            aionationstates.sc.resolution_at_vote,
        )
        for resolution in resolutions:
            if (resolution is not None
                    and resolution.name == self.resolution_name):
                return resolution
        raise aionationstates.NotFound"
4297,"async def proposal(self):
        """"""Get the proposal in question.

        Actually just the first proposal with the same name, but the
        chance of a collision is tiny.

        Returns
        -------
        awaitable of :class:`aionationstates.Proposal`
            The proposal submitted.

        Raises
        ------
        aionationstates.NotFound
            If the proposal has since been withdrawn or promoted.
        """"""
        proposals = await aionationstates.wa.proposals()
        for proposal in proposals:
            if (proposal.name == self.proposal_name):
                return proposal
        raise aionationstates.NotFound"
4298,"def create_free_shipping_promotion(cls, free_shipping_promotion, **kwargs):
        """"""Create FreeShippingPromotion

        Create a new FreeShippingPromotion
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_free_shipping_promotion(free_shipping_promotion, async=True)
        >>> result = thread.get()

        :param async bool
        :param FreeShippingPromotion free_shipping_promotion: Attributes of freeShippingPromotion to create (required)
        :return: FreeShippingPromotion
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_free_shipping_promotion_with_http_info(free_shipping_promotion, **kwargs)
        else:
            (data) = cls._create_free_shipping_promotion_with_http_info(free_shipping_promotion, **kwargs)
            return data"
4299,"def delete_free_shipping_promotion_by_id(cls, free_shipping_promotion_id, **kwargs):
        """"""Delete FreeShippingPromotion

        Delete an instance of FreeShippingPromotion by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_free_shipping_promotion_by_id(free_shipping_promotion_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str free_shipping_promotion_id: ID of freeShippingPromotion to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_free_shipping_promotion_by_id_with_http_info(free_shipping_promotion_id, **kwargs)
        else:
            (data) = cls._delete_free_shipping_promotion_by_id_with_http_info(free_shipping_promotion_id, **kwargs)
            return data"
4300,"def get_free_shipping_promotion_by_id(cls, free_shipping_promotion_id, **kwargs):
        """"""Find FreeShippingPromotion

        Return single instance of FreeShippingPromotion by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_free_shipping_promotion_by_id(free_shipping_promotion_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str free_shipping_promotion_id: ID of freeShippingPromotion to return (required)
        :return: FreeShippingPromotion
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_free_shipping_promotion_by_id_with_http_info(free_shipping_promotion_id, **kwargs)
        else:
            (data) = cls._get_free_shipping_promotion_by_id_with_http_info(free_shipping_promotion_id, **kwargs)
            return data"
4301,"def list_all_free_shipping_promotions(cls, **kwargs):
        """"""List FreeShippingPromotions

        Return a list of FreeShippingPromotions
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_free_shipping_promotions(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[FreeShippingPromotion]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_free_shipping_promotions_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_free_shipping_promotions_with_http_info(**kwargs)
            return data"
4302,"def replace_free_shipping_promotion_by_id(cls, free_shipping_promotion_id, free_shipping_promotion, **kwargs):
        """"""Replace FreeShippingPromotion

        Replace all attributes of FreeShippingPromotion
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_free_shipping_promotion_by_id(free_shipping_promotion_id, free_shipping_promotion, async=True)
        >>> result = thread.get()

        :param async bool
        :param str free_shipping_promotion_id: ID of freeShippingPromotion to replace (required)
        :param FreeShippingPromotion free_shipping_promotion: Attributes of freeShippingPromotion to replace (required)
        :return: FreeShippingPromotion
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_free_shipping_promotion_by_id_with_http_info(free_shipping_promotion_id, free_shipping_promotion, **kwargs)
        else:
            (data) = cls._replace_free_shipping_promotion_by_id_with_http_info(free_shipping_promotion_id, free_shipping_promotion, **kwargs)
            return data"
4303,"def update_free_shipping_promotion_by_id(cls, free_shipping_promotion_id, free_shipping_promotion, **kwargs):
        """"""Update FreeShippingPromotion

        Update attributes of FreeShippingPromotion
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_free_shipping_promotion_by_id(free_shipping_promotion_id, free_shipping_promotion, async=True)
        >>> result = thread.get()

        :param async bool
        :param str free_shipping_promotion_id: ID of freeShippingPromotion to update. (required)
        :param FreeShippingPromotion free_shipping_promotion: Attributes of freeShippingPromotion to update. (required)
        :return: FreeShippingPromotion
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_free_shipping_promotion_by_id_with_http_info(free_shipping_promotion_id, free_shipping_promotion, **kwargs)
        else:
            (data) = cls._update_free_shipping_promotion_by_id_with_http_info(free_shipping_promotion_id, free_shipping_promotion, **kwargs)
            return data"
4304,"def append(self, electrode_id):
        '''
        Append the specified electrode to the route.

        The route is not modified (i.e., electrode is not appended) if
        electrode is not connected to the last electrode in the existing route.

        Parameters
        ----------
        electrode_id : str
            Electrode identifier.
        '''
        do_append = False

        if not self.electrode_ids:
            do_append = True
        elif self.device.shape_indexes.shape[0] > 0:
            source = self.electrode_ids[-1]
            target = electrode_id
            if not (source == target):
                source_id, target_id = self.device.shape_indexes[[source,
                                                                  target]]
                try:
                    if self.device.adjacency_matrix[source_id, target_id]:
                        # Electrodes are connected, so append target to current
                        # route.
                        do_append = True
                except IndexError:
                    logger.warning('Electrodes `%s` and `%s` are not '
                                   'connected.', source, target)

        if do_append:
            self.electrode_ids.append(electrode_id)
        return do_append"
4305,"def df_routes(self, value):
        '''
        .. versionadded:: 0.11.3
        '''
        self._df_routes = value
        try:
            self.emit('routes-set', self._df_routes.copy())
        except TypeError:
            pass"
4306,"def create_ui(self):
        '''
        .. versionchanged:: 0.9
            Update device registration in real-time while dragging video
            control point to new position.

        .. versionchanged:: 0.12
            Add ``dynamic_electrode_state_shapes`` layer to show dynamic
            electrode actuations.
        '''
        super(DmfDeviceCanvas, self).create_ui()
        self.video_sink = VideoSink(*[self.socket_info[k]
                                      for k in ['transport', 'host', 'port']])
        # Initialize video sink socket.
        self.video_sink.reset()
        # Required to have key-press and key-release events trigger.
        self.widget.set_flags(gtk.CAN_FOCUS)
        self.widget.add_events(gtk.gdk.KEY_PRESS_MASK |
                               gtk.gdk.KEY_RELEASE_MASK)
        # Create initial (empty) cairo surfaces.
        surface_names = ('background', 'shapes', 'connections', 'routes',
                         'channel_labels', 'static_electrode_state_shapes',
                         'dynamic_electrode_state_shapes', 'registration')
        self.df_surfaces = pd.DataFrame([[self.get_surface(), 1.]
                                         for i in xrange(len(surface_names))],
                                        columns=['surface', 'alpha'],
                                        index=pd.Index(surface_names,
                                                       name='name'))

        def _update_registration(event):
            try:
                start_event = self.start_event.copy()
                self.start_event = event.copy()
                self.emit('point-pair-selected', {'start_event': start_event,
                                                  'end_event': event})
            except AttributeError:
                # Mouse button was released, causing `self.start_event` to be
                # `None` before event was handled here.
                pass

        # Debounce calls to `_update_registration` function to prevent too many
        # calls being triggered from mouse movement events.
        update_registration = debounce.Debounce(_update_registration, wait=10)

        def _on_mouse_move(area, event):
            # XXX Need to make a copy of the event here since the original
            # event will be deallocated before the debounced
            # `update_registration` function is called.
            event = event.copy()

            if self.mode == 'register_video' and self.start_event is not None:
                update_registration(event.copy())

        # Connect video registration update event to mouse movement event.
        self.widget.connect(""motion_notify_event"", _on_mouse_move)"
4307,"def insert_surface(self, position, name, surface, alpha=1.):
        '''
        Insert Cairo surface as new layer.


        Args
        ----

            position (int) : Index position to insert layer at.
            name (str) : Name of layer.
            surface (cairo.Context) : Surface to render.
            alpha (float) : Alpha/transparency level in the range `[0, 1]`.
        '''
        if name in self.df_surfaces.index:
            raise NameError('Surface already exists with `name=""{}""`.'
                            .format(name))
        self.df_surfaces.loc[name] = surface, alpha

        # Reorder layers such that the new surface is placed at the specified
        # layer position (relative to the background surface).
        surfaces_order = self.df_surfaces.index.values.tolist()
        surfaces_order.remove(name)
        base_index = surfaces_order.index('background') + 1
        if position < 0:
            position = len(surfaces_order) + position
        surfaces_order.insert(base_index + position, name)
        self.reorder_surfaces(surfaces_order)"
4308,"def append_surface(self, name, surface, alpha=1.):
        '''
        Append Cairo surface as new layer on top of existing layers.

        Args
        ----

            name (str) : Name of layer.
            surface (cairo.ImageSurface) : Surface to render.
            alpha (float) : Alpha/transparency level in the range `[0, 1]`.
        '''
        self.insert_surface(position=self.df_surfaces.index.shape[0],
                            name=name, surface=surface, alpha=alpha)"
4309,"def remove_surface(self, name):
        '''
        Remove layer from rendering stack and flatten remaining layers.

        Args
        ----

            name (str) : Name of layer.
        '''
        self.df_surfaces.drop(name, axis=0, inplace=True)

        # Order of layers may have changed after removing a layer. Trigger
        # refresh of surfaces.
        self.reorder_surfaces(self.df_surfaces.index)"
4310,"def clone_surface(self, source_name, target_name, target_position=-1,
                      alpha=1.):
        '''
        Clone surface from existing layer to a new name, inserting new surface
        at specified position.

        By default, new surface is appended as the top surface layer.

        Args
        ----

            source_name (str) : Name of layer to clone.
            target_name (str) : Name of new layer.
        '''
        source_surface = self.df_surfaces.surface.ix[source_name]
        source_width = source_surface.get_width()
        source_height = source_surface.get_height()
        source_format = source_surface.get_format()

        target_surface = cairo.ImageSurface(source_format, source_width,
                                            source_height)
        target_cairo_context = cairo.Context(target_surface)
        target_cairo_context.set_source_surface(source_surface, 0, 0)
        target_cairo_context.paint()
        self.insert_surface(target_position, target_name, target_surface,
                            alpha)"
4311,"def render_dynamic_electrode_state_shapes(self):
        '''
        Render **dynamic** states reported by the electrode controller.

        **Dynamic** electrode states are only applied while a protocol is
        running -- _not_ while in real-time programming mode.

        See also :meth:`render_electrode_shapes()`.


        .. versionadded:: 0.12
        '''
        df_shapes = self.canvas.df_canvas_shapes.copy()
        # Only include shapes for electrodes reported as actuated.
        on_electrodes = self._dynamic_electrodes[self._dynamic_electrodes > 0]
        df_shapes = (df_shapes.set_index('id').loc[on_electrodes.index]
                     .reset_index())

        return self.render_electrode_shapes(df_shapes=df_shapes,
                                            shape_scale=0.75,
                                            # Lignt blue
                                            fill=(136 / 255.,
                                                  189 / 255.,
                                                  230 / 255.))"
4312,"def render_static_electrode_state_shapes(self):
        '''
        Render **static** states reported by the electrode controller.

        **Static** electrode states are applied while a protocol is **running**
        _or_ while **real-time** control is activated.

        See also :meth:`render_electrode_shapes()`.


        .. versionadded:: 0.12
        '''
        df_shapes = self.canvas.df_canvas_shapes.copy()
        if self.electrode_states.shape[0]:
            df_shapes['state'] = self.electrode_states.ix[df_shapes.id].values
        else:
            df_shapes['state'] = 0
        df_shapes = df_shapes.loc[df_shapes.state > 0].dropna(subset=['state'])

        return self.render_electrode_shapes(df_shapes=df_shapes)"
4313,"def render_electrode_shapes(self, df_shapes=None, shape_scale=0.8,
                                fill=(1, 1, 1)):
        '''
        Render electrode state shapes.

        By default, draw each electrode shape filled white.

        See also :meth:`render_shapes()`.

        Parameters
        ----------
        df_shapes = : pandas.DataFrame


        .. versionadded:: 0.12
        '''
        surface = self.get_surface()
        if df_shapes is None:
            if hasattr(self.canvas, 'df_canvas_shapes'):
                df_shapes = self.canvas.df_canvas_shapes
            else:
                return surface
        if 'x_center' not in df_shapes or 'y_center' not in df_shapes:
            # No center points have been computed for shapes.
            return surface

        cairo_context = cairo.Context(surface)

        df_shapes = df_shapes.copy()
        # Scale shapes to leave shape edges uncovered.
        df_shapes[['x', 'y']] = (df_shapes[['x_center', 'y_center']] +
                                 df_shapes[['x_center_offset',
                                            'y_center_offset']].values *
                                 shape_scale)

        for path_id, df_path_i in (df_shapes.groupby(self.canvas
                                                     .shape_i_columns)[['x',
                                                                        'y']]):
            # Use attribute lookup for `x` and `y`, since it is considerably
            # faster than `get`-based lookup using columns name strings.
            vertices_x = df_path_i.x.values
            vertices_y = df_path_i.y.values
            cairo_context.move_to(vertices_x[0], vertices_y[0])
            for x, y in itertools.izip(vertices_x[1:], vertices_y[1:]):
                cairo_context.line_to(x, y)
            cairo_context.close_path()

            # Draw filled shape to indicate actuated electrode state.
            cairo_context.set_source_rgba(*fill)
            cairo_context.fill()
        return surface"
4314,"def render_shapes(self, df_shapes=None, clip=False):
        '''
        Render static electrode shapes (independent of actuation state).

        If video is enabled, draw white outline for each electrode (no fill).

        If video is disabled, draw white outline for each electrode and fill
        blue.

        See also :meth:`render_electrode_state_shapes()`.
        '''
        surface = self.get_surface()
        if df_shapes is None:
            if hasattr(self.canvas, 'df_canvas_shapes'):
                df_shapes = self.canvas.df_canvas_shapes
            else:
                return surface

        cairo_context = cairo.Context(surface)

        for path_id, df_path_i in (df_shapes
                                   .groupby(self.canvas
                                            .shape_i_columns)[['x', 'y']]):
            # Use attribute lookup for `x` and `y`, since it is considerably
            # faster than `get`-based lookup using columns name strings.
            vertices_x = df_path_i.x.values
            vertices_y = df_path_i.y.values
            cairo_context.move_to(vertices_x[0], vertices_y[0])
            for x, y in itertools.izip(vertices_x[1:], vertices_y[1:]):
                cairo_context.line_to(x, y)
            cairo_context.close_path()

            if self.enabled:
                # Video is enabled.

                # Draw white border around electrode.
                line_width = 1
                if path_id not in self.electrode_channels.index:
                    #         on  off on  off
                    dashes = [10, 10]
                    color = (1, 0, 1)
                    line_width *= 2
                else:
                    dashes = []
                    color = (1, 1, 1)
                cairo_context.set_dash(dashes)
                cairo_context.set_line_width(line_width)
                cairo_context.set_source_rgb(*color)
                cairo_context.stroke()
            else:
                # Video is enabled.  Fill electrode blue.
                color = ((0, 0, 1) if path_id in self.electrode_channels.index
                         else (1, 0, 1))
                cairo_context.set_source_rgb(*color)
                cairo_context.fill_preserve()
                # Draw white border around electrode.
                cairo_context.set_line_width(1)
                cairo_context.set_source_rgba(1, 1, 1)
                cairo_context.stroke()
        return surface"
4315,"def render_registration(self):
        '''
        Render pinned points on video frame as red rectangle.
        '''
        surface = self.get_surface()
        if self.canvas is None or self.df_canvas_corners.shape[0] == 0:
            return surface

        corners = self.df_canvas_corners.copy()
        corners['w'] = 1

        transform = self.canvas.shapes_to_canvas_transform
        canvas_corners = corners.values.dot(transform.T.values).T

        points_x = canvas_corners[0]
        points_y = canvas_corners[1]

        cairo_context = cairo.Context(surface)
        cairo_context.move_to(points_x[0], points_y[0])
        for x, y in zip(points_x[1:], points_y[1:]):
            cairo_context.line_to(x, y)
        cairo_context.line_to(points_x[0], points_y[0])
        cairo_context.set_source_rgb(1, 0, 0)
        cairo_context.stroke()
        return surface"
4316,"def render(self):
        '''
        .. versionchanged:: 0.12
            Add ``dynamic_electrode_state_shapes`` layer to show dynamic
            electrode actuations.
        '''
        # Render each layer and update data frame with new content for each
        # surface.
        surface_names = ('background', 'shapes', 'connections', 'routes',
                         'channel_labels', 'static_electrode_state_shapes',
                         'dynamic_electrode_state_shapes', 'registration')
        for k in surface_names:
            self.set_surface(k, getattr(self, 'render_' + k)())
        self.emit('surfaces-reset', self.df_surfaces)
        self.cairo_surface = flatten_surfaces(self.df_surfaces)"
4317,"def draw_route(self, df_route, cr, color=None, line_width=None):
        '''
        Draw a line between electrodes listed in a route.

        Arguments
        ---------

         - `df_route`:
             * A `pandas.DataFrame` containing a column named `electrode_i`.
             * For each row, `electrode_i` corresponds to the integer index of
               the corresponding electrode.
         - `cr`: Cairo context.
         - `color`: Either a RGB or RGBA tuple, with each color channel in the
           range [0, 1].  If `color` is `None`, the electrode color is set to
           white.
        '''
        df_route_centers = (self.canvas.df_shape_centers
                            .ix[df_route.electrode_i][['x_center',
                                                       'y_center']])
        df_endpoint_marker = (.6 * self.get_endpoint_marker(df_route_centers)
                              + df_route_centers.iloc[-1].values)

        # Save cairo context to restore after drawing route.
        cr.save()
        if color is None:
            # Colors from [""Show me the numbers""][1].
            #
            # [1]: http://blog.axc.net/its-the-colors-you-have/
            # LiteOrange = rgb(251,178,88);
            # MedOrange = rgb(250,164,58);
            # LiteGreen = rgb(144,205,151);
            # MedGreen = rgb(96,189,104);
            color_rgb_255 = np.array([96,189,104, .8 * 255])
            color = (color_rgb_255 / 255.).tolist()
        if len(color) < 4:
            color += [1.] * (4 - len(color))
        cr.set_source_rgba(*color)
        cr.move_to(*df_route_centers.iloc[0])
        for electrode_i, center_i in df_route_centers.iloc[1:].iterrows():
            cr.line_to(*center_i)
        if line_width is None:
            line_width = np.sqrt((df_endpoint_marker.max().values -
                                  df_endpoint_marker.min().values).prod()) * .1
        cr.set_line_width(4)
        cr.stroke()

        cr.move_to(*df_endpoint_marker.iloc[0])
        for electrode_i, center_i in df_endpoint_marker.iloc[1:].iterrows():
            cr.line_to(*center_i)
        cr.close_path()
        cr.set_source_rgba(*color)
        cr.fill()
        # Restore cairo context after drawing route.
        cr.restore()"
4318,"def on_widget__button_press_event(self, widget, event):
        '''
        Called when any mouse button is pressed.


        .. versionchanged:: 0.11
            Do not trigger `route-electrode-added` event if `ALT` key is
            pressed.
        '''
        if self.mode == 'register_video' and event.button == 1:
            self.start_event = event.copy()
            return
        elif self.mode == 'control':
            shape = self.canvas.find_shape(event.x, event.y)

            if shape is None: return
            state = event.get_state()
            if event.button == 1:
                # Start a new route.
                self._route = Route(self.device)
                self._route.append(shape)
                self.last_pressed = shape
                if not (state & gtk.gdk.MOD1_MASK):
                    # `<Alt>` key is not held down.
                    self.emit('route-electrode-added', shape)"
4319,"def on_widget__button_release_event(self, widget, event):
        '''
        Called when any mouse button is released.


        .. versionchanged:: 0.11.3
            Always reset pending route, regardless of whether a route was
            completed.  This includes a) removing temporary routes from routes
            table, and b) resetting the state of the current route electrode
            queue.  This fixes
            https://github.com/sci-bots/microdrop/issues/256.
        '''
        event = event.copy()
        if self.mode == 'register_video' and (event.button == 1 and
                                              self.start_event is not None):
            self.emit('point-pair-selected', {'start_event': self.start_event,
                                              'end_event': event.copy()})
            self.start_event = None
            return
        elif self.mode == 'control':
            # XXX Negative `route_i` corresponds to temporary route being
            # drawn.  Since release of mouse button terminates route drawing,
            # clear any rows corresponding to negative `route_i` values from
            # the routes table.
            self.df_routes = self.df_routes.loc[self.df_routes.route_i >=
                                                0].copy()
            shape = self.canvas.find_shape(event.x, event.y)

            if shape is not None:
                electrode_data = {'electrode_id': shape, 'event': event.copy()}
                if event.button == 1:
                    if gtk.gdk.BUTTON1_MASK == event.get_state():
                        if self._route.append(shape):
                            self.emit('route-electrode-added', shape)
                        if len(self._route.electrode_ids) == 1:
                            # Single electrode, so select electrode.
                            self.emit('electrode-selected', electrode_data)
                        else:
                            # Multiple electrodes, so select route.
                            route = self._route
                            self.emit('route-selected', route)
                    elif (event.get_state() == (gtk.gdk.MOD1_MASK |
                                                gtk.gdk.BUTTON1_MASK) and
                        self.last_pressed != shape):
                        # `<Alt>` key was held down.
                        self.emit('electrode-pair-selected',
                                {'source_id': self.last_pressed,
                                 'target_id': shape, 'event': event.copy()})
                    self.last_pressed = None
                elif event.button == 3:
                    # Create right-click pop-up menu.
                    menu = self.create_context_menu(event, shape)

                    # Display menu popup
                    menu.popup(None, None, None, event.button, event.time)
            # Clear route.
            self._route = None"
4320,"def create_context_menu(self, event, shape):
        '''
        Parameters
        ----------
        event : gtk.gdk.Event
            GTK mouse click event.
        shape : str
            Electrode shape identifier (e.g., `""electrode028""`).

        Returns
        -------
        gtk.Menu
            Context menu.


        .. versionchanged:: 0.13
            - Deprecate hard-coded commands (e.g., clear electrodes, clear
              routes).
            - Add anonymous global commands section at head of menu (i.e.,
              commands not specific to an electrode or route).
            - Add ""Electrode"" and ""Route(s)"" sub-menus.
        '''
        routes = self.df_routes.loc[self.df_routes.electrode_i == shape,
                                    'route_i'].astype(int).unique().tolist()

        def _connect_callback(menu_item, command_signal, group, command, data):
            callback_called = threading.Event()

            def _callback(signal, widget, *args):
                if callback_called.is_set():
                    return
                callback_called.set()

                _L().debug('`%s`: %s %s %s', signal, group, command, data)
                gtk.idle_add(self.emit, command_signal, group, command, data)
            menu_item.connect('activate', ft.partial(_callback, 'activate'))
            menu_item.connect('button-press-event',
                              ft.partial(_callback, 'button-press-event'))

            if group is not None:
                menu_item.set_tooltip_text(group)

        menu = gtk.Menu()

        # Add menu items/groups for registered global commands.
        if self.global_commands:
            data = {'event': event.copy()}
            command_signal = 'global-command'

            for group, commands in self.global_commands.iteritems():
                for command, title in commands.iteritems():
                    menu_item_j = gtk.MenuItem(title)
                    menu.append(menu_item_j)

                    _connect_callback(menu_item_j, command_signal, group,
                                      command, data)

        # Add menu items/groups for registered electrode commands.
        if self.electrode_commands:
            separator = gtk.SeparatorMenuItem()
            menu.append(separator)

            # Add electrode sub-menu.
            menu_e = gtk.Menu()
            menu_head_e = gtk.MenuItem('_Electrode')
            menu_head_e.set_submenu(menu_e)
            menu_head_e.set_use_underline(True)
            menu.append(menu_head_e)

            command_signal = 'electrode-command'
            data = {'electrode_id': shape, 'event': event.copy()}

            for group, commands in self.electrode_commands.iteritems():
                for command, title in commands.iteritems():
                    menu_item_j = gtk.MenuItem(title)
                    menu_e.append(menu_item_j)
                    _connect_callback(menu_item_j, command_signal, group,
                                      command, data)

        # Add menu items/groups for registered route commands.
        if routes and self.route_commands:
            # TODO: Refactor electrode/route command menu code to reduce code
            # duplication (i.e., DRY).
            separator = gtk.SeparatorMenuItem()
            menu.append(separator)

            # Add route sub-menu.
            menu_r = gtk.Menu()
            menu_head_r = gtk.MenuItem('_Route(s)')
            menu_head_r.set_submenu(menu_r)
            menu_head_r.set_use_underline(True)
            menu.append(menu_head_r)

            command_signal = 'route-command'
            data = {'route_ids': routes, 'event': event.copy()}
            for group, commands in self.route_commands.iteritems():
                for command, title in commands.iteritems():
                    menu_item_j = gtk.MenuItem(title)
                    menu_r.append(menu_item_j)

                    _connect_callback(menu_item_j, command_signal, group,
                                      command, data)

        menu.show_all()
        return menu"
4321,"def on_widget__motion_notify_event(self, widget, event):
        '''
        Called when mouse pointer is moved within drawing area.


        .. versionchanged:: 0.11
            Do not trigger `route-electrode-added` event if `ALT` key is
            pressed.
        '''
        if self.canvas is None:
            # Canvas has not been initialized.  Nothing to do.
            return
        elif event.is_hint:
            pointer = event.window.get_pointer()
            x, y, mod_type = pointer
        else:
            x = event.x
            y = event.y
        shape = self.canvas.find_shape(x, y)

        # Grab focus to [enable notification on key press/release events][1].
        #
        # [1]: http://mailman.daa.com.au/cgi-bin/pipermail/pygtk/2003-August/005770.html
        self.widget.grab_focus()

        if shape != self.last_hovered:
            if self.last_hovered is not None:
                # Leaving shape
                self.emit('electrode-mouseout', {'electrode_id':
                                                 self.last_hovered,
                                                 'event': event.copy()})
                self.last_hovered = None
            elif shape is not None:
                # Entering shape
                self.last_hovered = shape

                if self._route is not None:
                    if self._route.append(shape) and not (event.get_state() &
                                                          gtk.gdk.MOD1_MASK):
                        # `<Alt>` key was not held down.
                        self.emit('route-electrode-added', shape)

                self.emit('electrode-mouseover', {'electrode_id':
                                                  self.last_hovered,
                                                  'event': event.copy()})"
4322,"def register_global_command(self, command, title=None, group=None):
        '''
        .. versionadded:: 0.13


        Register global command (i.e., not specific to electrode or route).

        Add global command to context menu.
        '''
        commands = self.global_commands.setdefault(group, OrderedDict())
        if title is None:
            title = (command[:1].upper() + command[1:]).replace('_', ' ')
        commands[command] = title"
4323,"def register_electrode_command(self, command, title=None, group=None):
        '''
        Register electrode command.

        Add electrode plugin command to context menu.
        '''
        commands = self.electrode_commands.setdefault(group, OrderedDict())
        if title is None:
            title = (command[:1].upper() + command[1:]).replace('_', ' ')
        commands[command] = title"
4324,"def register_route_command(self, command, title=None, group=None):
        '''
        Register route command.

        Add route plugin command to context menu.
        '''
        commands = self.route_commands.setdefault(group, OrderedDict())
        if title is None:
            title = (command[:1].upper() + command[1:]).replace('_', ' ')
        commands[command] = title"
4325,"def list_all_gateways(cls, **kwargs):
        """"""List Gateways

        Return a list of Gateways
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_gateways(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[Gateway]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_gateways_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_gateways_with_http_info(**kwargs)
            return data"
4326,"def list_of_dictionaries_to_mysql_inserts(
        log,
        datalist,
        tableName):
    """"""Convert a python list of dictionaries to pretty csv output

    **Key Arguments:**
        - ``log`` -- logger
        - ``datalist`` -- a list of dictionaries
        - ``tableName`` -- the name of the table to create the insert statements for

    **Return:**
        - ``output`` -- the mysql insert statements (as a string)

    **Usage:**

        .. code-block:: python 

            from fundamentals.files import list_of_dictionaries_to_mysql_inserts
            mysqlInserts = list_of_dictionaries_to_mysql_inserts(
                log=log,
                datalist=dataList,
                tableName=""my_new_table""
            )
            print mysqlInserts

        this output the following:

        .. code-block:: plain

            INSERT INTO `testing_table` (a_newKey,and_another,dateCreated,uniqueKey2,uniquekey1) VALUES (""cool"" ,""super cool"" ,""2016-09-14T13:17:26"" ,""burgers"" ,""cheese"")  ON DUPLICATE KEY UPDATE  a_newKey=""cool"", and_another=""super cool"", dateCreated=""2016-09-14T13:17:26"", uniqueKey2=""burgers"", uniquekey1=""cheese"" ;
            ...
            ...
    """"""
    log.debug('starting the ``list_of_dictionaries_to_mysql_inserts`` function')

    if not len(datalist):
        return ""NO MATCH""

    inserts = []

    for d in datalist:
        insertCommand = convert_dictionary_to_mysql_table(
            log=log,
            dictionary=d,
            dbTableName=""testing_table"",
            uniqueKeyList=[],
            dateModified=False,
            returnInsertOnly=True,
            replace=True,
            batchInserts=False
        )
        inserts.append(insertCommand)

    output = "";\n"".join(inserts) + "";""

    log.debug('completed the ``list_of_dictionaries_to_mysql_inserts`` function')
    return output"
4327,"def after(self):
        """"""
        Return a deferred that will fire after the request is finished.

        Returns:

            Deferred: a new deferred that will fire appropriately

        """"""

        d = Deferred()
        self._after_deferreds.append(d)
        return d.chain"
4328,"def after_response(self, request, fn, *args, **kwargs):
        """"""
        Call the given callable after the given request has its response.

        Arguments:

            request:

                the request to piggyback

            fn (callable):

                a callable that takes at least two arguments, the request and
                the response (in that order), along with any additional
                positional and keyword arguments passed to this function which
                will be passed along. If the callable returns something other
                than ``None``, it will be used as the new response.
        """"""

        self._requests[id(request)][""callbacks""].append((fn, args, kwargs))"
4329,"def plot_degbandshalffill():
    """"""Plot of Quasiparticle weight for degenerate
       half-filled bands, showing the Mott transition""""""
    ulim = [3.45, 5.15, 6.85, 8.55]
    bands = range(1, 5)
    for band, u_int in zip(bands, ulim):
        name = 'Z_half_'+str(band)+'band'
        dop = [0.5]
        data = ssplt.calc_z(band, dop, np.arange(0, u_int, 0.1),0., name)
        plt.plot(data['u_int'], data['zeta'][0, :, 0], label='$N={}$'.format(str(band)))

    ssplt.label_saves('Z_half_multiorb.png')"
4330,"def plot_dop(bands, int_max, dop, hund_cu, name):
    """"""Plot of Quasiparticle weight for N degenerate bands
       under selected doping shows transition only at half-fill
       the rest are metallic states""""""
    data = ssplt.calc_z(bands, dop, np.arange(0, int_max, 0.1), hund_cu, name)
    ssplt.plot_curves_z(data, name)"
4331,"def plot_dop_phase(bands, int_max, hund_cu):
    """"""Phase plot of Quasiparticle weight for N degenerate bands
       under doping shows transition only at interger filling
       the rest are metallic states""""""
    name = 'Z_dop_phase_'+str(bands)+'bands_U'+str(int_max)+'J'+str(hund_cu)
    dop = np.sort(np.hstack((np.linspace(0.01,0.99,50),
                    np.arange(1./2./bands, 1, 1/2/bands))))
    data = ssplt.calc_z(bands, dop, np.arange(0, int_max, 0.1), hund_cu, name)

    ssplt.imshow_z(data, name)
    ssplt.surf_z(data, name)"
4332,"def create_store_credit(cls, store_credit, **kwargs):
        """"""Create StoreCredit

        Create a new StoreCredit
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_store_credit(store_credit, async=True)
        >>> result = thread.get()

        :param async bool
        :param StoreCredit store_credit: Attributes of storeCredit to create (required)
        :return: StoreCredit
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_store_credit_with_http_info(store_credit, **kwargs)
        else:
            (data) = cls._create_store_credit_with_http_info(store_credit, **kwargs)
            return data"
4333,"def delete_store_credit_by_id(cls, store_credit_id, **kwargs):
        """"""Delete StoreCredit

        Delete an instance of StoreCredit by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_store_credit_by_id(store_credit_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str store_credit_id: ID of storeCredit to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_store_credit_by_id_with_http_info(store_credit_id, **kwargs)
        else:
            (data) = cls._delete_store_credit_by_id_with_http_info(store_credit_id, **kwargs)
            return data"
4334,"def get_store_credit_by_id(cls, store_credit_id, **kwargs):
        """"""Find StoreCredit

        Return single instance of StoreCredit by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_store_credit_by_id(store_credit_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str store_credit_id: ID of storeCredit to return (required)
        :return: StoreCredit
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_store_credit_by_id_with_http_info(store_credit_id, **kwargs)
        else:
            (data) = cls._get_store_credit_by_id_with_http_info(store_credit_id, **kwargs)
            return data"
4335,"def list_all_store_credits(cls, **kwargs):
        """"""List StoreCredits

        Return a list of StoreCredits
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_store_credits(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[StoreCredit]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_store_credits_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_store_credits_with_http_info(**kwargs)
            return data"
4336,"def replace_store_credit_by_id(cls, store_credit_id, store_credit, **kwargs):
        """"""Replace StoreCredit

        Replace all attributes of StoreCredit
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_store_credit_by_id(store_credit_id, store_credit, async=True)
        >>> result = thread.get()

        :param async bool
        :param str store_credit_id: ID of storeCredit to replace (required)
        :param StoreCredit store_credit: Attributes of storeCredit to replace (required)
        :return: StoreCredit
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_store_credit_by_id_with_http_info(store_credit_id, store_credit, **kwargs)
        else:
            (data) = cls._replace_store_credit_by_id_with_http_info(store_credit_id, store_credit, **kwargs)
            return data"
4337,"def update_store_credit_by_id(cls, store_credit_id, store_credit, **kwargs):
        """"""Update StoreCredit

        Update attributes of StoreCredit
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_store_credit_by_id(store_credit_id, store_credit, async=True)
        >>> result = thread.get()

        :param async bool
        :param str store_credit_id: ID of storeCredit to update. (required)
        :param StoreCredit store_credit: Attributes of storeCredit to update. (required)
        :return: StoreCredit
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_store_credit_by_id_with_http_info(store_credit_id, store_credit, **kwargs)
        else:
            (data) = cls._update_store_credit_by_id_with_http_info(store_credit_id, store_credit, **kwargs)
            return data"
4338,"def on_mouse_motion(x, y, dx, dy):
    """""" 当鼠标没有按下时移动的时候触发 """"""
    mouse.x, mouse.y = x, y
    mouse.move()
    window.update_caption(mouse)"
4339,"def on_mouse_drag(x, y, dx, dy, buttons, modifiers):
    """""" 当鼠标按下并且移动的时候触发 """"""
    mouse.x, mouse.y = x, y
    mouse.move()"
4340,"def on_mouse_press(x, y, button, modifiers):
    """""" 按下鼠标时 

    """""" 
    if button == MouseKeyCode.LEFT:
        mouse.press()
    elif button == MouseKeyCode.RIGHT:
        mouse.right_press()

    # 判断是否有图形的点击事件被触发了
    shapes = list(all_shapes)
    while shapes:
        shape = shapes.pop()
        if(shape._press and shape_clicked(shape)):
            shape._press()"
4341,"def on_mouse_release(x, y, button, modifiers):
    """""" 松开鼠标时 """""" 
    if button == MouseKeyCode.LEFT:
        mouse.release()
    elif button == MouseKeyCode.RIGHT:
        mouse.right_release()"
4342,"def _register_extensions(self, namespace):
        """"""Register any extensions under the given namespace.""""""

        # Register any extension classes for this class.
        extmanager = ExtensionManager(
            'extensions.classes.{}'.format(namespace),
            propagate_map_exceptions=True
        )

        if extmanager.extensions:
            extmanager.map(util.register_extension_class, base=self)

        # Register any extension methods for this class.
        extmanager = ExtensionManager(
            'extensions.methods.{}'.format(namespace),
            propagate_map_exceptions=True
        )
        if extmanager.extensions:
            extmanager.map(util.register_extension_method, base=self)"
4343,"def acls(self):
        """"""The instance bound ACLs operations layer.""""""
        if self._acls is None:
            self._acls = InstanceAcls(instance=self)
        return self._acls"
4344,"def all(self):
        """"""Get all ACLs for this instance.""""""
        return self._instance._client.acls.all(self._instance.name)"
4345,"def create(self, cidr_mask, description, **kwargs):
        """"""Create an ACL for this instance.

        See :py:meth:`Acls.create` for call signature.
        """"""
        return self._instance._client.acls.create(
            self._instance.name,
            cidr_mask,
            description,
            **kwargs
        )"
4346,"def get(self, acl):
        """"""Get the ACL specified by ID belonging to this instance.

        See :py:meth:`Acls.get` for call signature.
        """"""
        return self._instance._client.acls.get(self._instance.name, acl)"
4347,"def is_number(num, if_bool=False):
    """""" :return: True if num is either an actual number, or an object that converts to one """"""

    if isinstance(num, bool):
        return if_bool
    elif isinstance(num, int):
        return True
    try:
        number = float(num)
        return not (isnan(number) or isinf(number))
    except (TypeError, ValueError):
        return False"
4348,"def _VarintDecoder(mask):
  """"""Return an encoder for a basic varint value (does not include tag).

  Decoded values will be bitwise-anded with the given mask before being
  returned, e.g. to limit them to 32 bits.  The returned decoder does not
  take the usual ""end"" parameter -- the caller is expected to do bounds checking
  after the fact (often the caller can defer such checking until later).  The
  decoder returns a (value, new_pos) pair.
  """"""

  def DecodeVarint(buffer, pos):
    result = 0
    shift = 0
    while 1:
      if pos > len(buffer) -1:
        raise NotEnoughDataException( ""Not enough data to decode varint"" )
      b = buffer[pos]
      result |= ((b & 0x7f) << shift)
      pos += 1
      if not (b & 0x80):
        result &= mask
        return (result, pos)
      shift += 7
      if shift >= 64:
        raise _DecodeError('Too many bytes when decoding varint.')

  return DecodeVarint"
4349,"def _SignedVarintDecoder(mask):
  """"""Like _VarintDecoder() but decodes signed values.""""""


  def DecodeVarint(buffer, pos):
    result = 0
    shift = 0
    while 1:
      if pos > len(buffer) -1:
        raise NotEnoughDataException(  ""Not enough data to decode varint"" )
      b = local_ord(buffer[pos])
      result |= ((b & 0x7f) << shift)
      pos += 1
      if not (b & 0x80):
        if result > 0x7fffffffffffffff:
          result -= (1 << 64)
          result |= ~mask
        else:
          result &= mask
        return (result, pos)
      shift += 7
      if shift >= 64:
        raise _DecodeError('Too many bytes when decoding varint.')

  return DecodeVarint"
4350,"def varintSize(value):
  """"""Compute the size of a varint value.""""""
  if value <= 0x7f: return 1
  if value <= 0x3fff: return 2
  if value <= 0x1fffff: return 3
  if value <= 0xfffffff: return 4
  if value <= 0x7ffffffff: return 5
  if value <= 0x3ffffffffff: return 6
  if value <= 0x1ffffffffffff: return 7
  if value <= 0xffffffffffffff: return 8
  if value <= 0x7fffffffffffffff: return 9
  return 10"
4351,"def signedVarintSize(value):
  """"""Compute the size of a signed varint value.""""""
  if value < 0: return 10
  if value <= 0x7f: return 1
  if value <= 0x3fff: return 2
  if value <= 0x1fffff: return 3
  if value <= 0xfffffff: return 4
  if value <= 0x7ffffffff: return 5
  if value <= 0x3ffffffffff: return 6
  if value <= 0x1ffffffffffff: return 7
  if value <= 0xffffffffffffff: return 8
  if value <= 0x7fffffffffffffff: return 9
  return 10"
4352,"def _VarintEncoder():
  """"""Return an encoder for a basic varint value.""""""

  local_chr = chr
  def EncodeVarint(write, value):
    bits = value & 0x7f
    value >>= 7
    while value:
      write(0x80|bits)
      bits = value & 0x7f
      value >>= 7
    return write(bits)

  return EncodeVarint"
4353,"def _SignedVarintEncoder():
  """"""Return an encoder for a basic signed varint value.""""""

  local_chr = chr
  def EncodeSignedVarint(write, value):
    if value < 0:
      value += (1 << 64)
    bits = value & 0x7f
    value >>= 7
    while value:
      write(0x80|bits)
      bits = value & 0x7f
      value >>= 7
    return write(bits)

  return EncodeSignedVarint"
4354,"def match(value, query):
    """"""
    Determine whether a value satisfies a query.
    """"""
    if type(query) in [str, int, float, type(None)]:
        return value == query
    elif type(query) == dict and len(query.keys()) == 1:
        for op in query:
            if op == ""$eq"": return value == query[op]
            elif op == ""$lt"": return value < query[op]
            elif op == ""$lte"": return value <= query[op]
            elif op == ""$gt"": return value > query[op]
            elif op == ""$gte"": return value >= query[op]
            elif op == ""$ne"": return value != query[op]
            elif op == ""$in"": return value in query[op]
            elif op == ""$nin"": return value not in query[op]
            else: GeoQLError(""Not a valid query operator: "" + op)
    else:
        raise GeoQLError(""Not a valid query: "" + str(query))"
4355,"def features_properties_null_remove(obj):
    """"""
    Remove any properties of features in the collection that have 
    entries mapping to a null (i.e., None) value
    """"""
    features = obj['features']
    for i in tqdm(range(len(features))):
        if 'properties' in features[i]:
            properties = features[i]['properties']
            features[i]['properties'] = {p:properties[p] for p in properties if properties[p] is not None}
    return obj"
4356,"def features_tags_parse_str_to_dict(obj):
    """"""
    Parse tag strings of all features in the collection into a Python
    dictionary, if possible.
    """"""
    features = obj['features']
    for i in tqdm(range(len(features))):
        tags = features[i]['properties'].get('tags')
        if tags is not None:
            try:
                tags = json.loads(""{"" + tags.replace(""=>"", "":"") + ""}"")
            except:
                try:
                    tags = eval(""{"" + tags.replace(""=>"", "":"") + ""}"")
                except:
                    tags = None
        if type(tags) == dict:
            features[i]['properties']['tags'] = {k:tags[k] for k in tags}
        elif tags is None and 'tags' in features[i]['properties']:
            del features[i]['properties']['tags']
    return obj"
4357,"def features_keep_by_property(obj, query):
    """"""
    Filter all features in a collection by retaining only those that
    satisfy the provided query.
    """"""
    features_keep = []
    for feature in tqdm(obj['features']):
        if all([match(feature['properties'].get(prop), qry) for (prop, qry) in query.items()]):
            features_keep.append(feature)
    obj['features'] = features_keep
    return obj"
4358,"def features_keep_within_radius(obj, center, radius, units):
    """"""
    Filter all features in a collection by retaining only those that
    fall within the specified radius.
    """"""
    features_keep = []
    for feature in tqdm(obj['features']):
        if all([getattr(geopy.distance.vincenty((lat,lon), center), units) < radius for (lon,lat) in geojson.utils.coords(feature)]):
            features_keep.append(feature)
    obj['features'] = features_keep
    return obj"
4359,"def features_keep_using_features(obj, bounds):
    """"""
    Filter all features in a collection by retaining only those that
    fall within the features in the second collection.
    """"""
    # Build an R-tree index of bound features and their shapes.
    bounds_shapes = [
        (feature, shapely.geometry.shape(feature['geometry'])) 
        for feature in tqdm(bounds['features'])
        if feature['geometry'] is not None
      ]
    index = rtree.index.Index()
    for i in tqdm(range(len(bounds_shapes))):
        (feature, shape) = bounds_shapes[i]
        index.insert(i, shape.bounds)

    features_keep = []
    for feature in tqdm(obj['features']):
        if 'geometry' in feature and 'coordinates' in feature['geometry']:
            coordinates = feature['geometry']['coordinates']
            if any([
                shape.contains(shapely.geometry.Point(lon, lat))
                for (lon, lat) in coordinates
                for (feature, shape) in [bounds_shapes[i]
                for i in index.nearest((lon,lat,lon,lat), 1)]
              ]):
                features_keep.append(feature)
                continue
    obj['features'] = features_keep
    return obj"
4360,"def features_node_edge_graph(obj):
    """"""
    Transform the features into a more graph-like structure by
    appropriately splitting LineString features into two-point
    ""edges"" that connect Point ""nodes"".
    """"""
    points = {}
    features = obj['features']
    for feature in tqdm(obj['features']):
        for (lon, lat) in geojson.utils.coords(feature):
            points.setdefault((lon, lat), 0)
            points[(lon, lat)] += 1
    points = [p for (p, c) in points.items() if c > 1]
    features = [geojson.Point(p) for p in points]

    # For each feature, split it into ""edge"" features
    # that occur between every point.
    for f in tqdm(obj['features']):
        seqs = []
        seq = []
        for point in geojson.utils.coords(f):
            if len(seq) > 0:
                seq.append(point)
            if point in points:
                seq.append(point)
                if len(seq) > 1 and seq[0] in points:
                    seqs.append(seq)
                    seq = [point]
        for seq in seqs:
            features.append(geojson.Feature(geometry={""coordinates"":seq, ""type"":f['geometry']['type']}, properties=f['properties'], type=f['type']))

    obj['features'] = features
    return obj"
4361,"def get_conn(filename):
    """"""Returns new sqlite3.Connection object with _dict_factory() as row factory""""""
    conn = sqlite3.connect(filename)
    conn.row_factory = _dict_factory
    return conn"
4362,"def conn_is_open(conn):
    """"""Tests sqlite3 connection, returns T/F""""""
    if conn is None:
        return False

    try:
        get_table_names(conn)
        return True

        # # Idea taken from
        # # http: // stackoverflow.com / questions / 1981392 / how - to - tell - if -python - sqlite - database - connection - or -cursor - is -closed
        # conn.execute(""select id from molecule limit 1"")
        # return True
    except sqlite3.ProgrammingError as e:
        # print(e)
        return False"
4363,"def cursor_to_data_header(cursor):
    """"""Fetches all rows from query (""cursor"") and returns a pair (data, header)

    Returns: (data, header), where
        - data is a [num_rows]x[num_cols] sequence of sequences;
        - header is a [num_cols] list containing the field names
    """"""
    n = 0
    data, header = [], {}
    for row in cursor:
        if n == 0:
            header = row.keys()
        data.append(row.values())
    return data, list(header)"
4364,"def get_table_info(conn, tablename):
    """"""Returns TableInfo object""""""
    r = conn.execute(""pragma table_info('{}')"".format(tablename))
    ret = TableInfo(((row[""name""], row) for row in r))
    return ret"
4365,"def find(self, **kwargs):
        """"""
        Finds row matching specific field value

        Args:
            **kwargs: (**only one argument accepted**) fielname=value, e.g., formula=""OH""

        Returns: list element or None
        """"""

        if len(kwargs) != 1:
            raise ValueError(""One and only one keyword argument accepted"")

        key = list(kwargs.keys())[0]
        value = list(kwargs.values())[0]
        ret = None
        for row in self.values():
            if row[key] == value:
                ret = row
                break
        return ret"
4366,"def early_warning(iterable, name='this generator'):
    ''' This function logs an early warning that the generator is empty.

    This is handy for times when you're manually playing with generators and
    would appreciate the console warning you ahead of time that your generator
    is now empty, instead of being surprised with a StopIteration or
    GeneratorExit exception when youre trying to test something. '''

    nxt = None
    prev = next(iterable)
    while 1:
        try:
            nxt = next(iterable)
        except:
            warning(' {} is now empty'.format(name))
            yield prev
            break
        else:
            yield prev
            prev = nxt"
4367,"def post(self, data, request, id):
        """""" Create a new resource using POST """"""
        if id:
            # can't post to individual user
            raise errors.MethodNotAllowed()
        user = self._dict_to_model(data)
        user.save()
        # according to REST, return 201 and Location header
        return Response(201, None, {
            'Location': '%s%d' % (reverse('user'), user.pk)})"
4368,"def get(self, request, id):
        """""" Get one user or all users """"""
        if id:
            return self._get_one(id)
        else:
            return self._get_all()"
4369,"def put(self, data, request, id):
        """""" Update a single user. """"""
        if not id:
            # can't update the whole container
            raise errors.MethodNotAllowed()
        userdata = self._dict_to_model(data)
        userdata.pk = id
        try:
            userdata.save(force_update=True)
        except DatabaseError:
            # can't udpate non-existing user
            raise errors.NotFound()"
4370,"def delete(self, request, id):
        """""" Delete a single user. """"""
        if not id:
            # can't delete the whole container
            raise errors.MethodNotAllowed()
        try:
            models.User.objects.get(pk=id).delete()
        except models.User.DoesNotExist:
            # we never had it, so it's definitely deleted
            pass"
4371,"def _get_one(self, id):
        """""" Get one user from db and turn into dict """"""
        try:
            return self._to_dict(models.User.objects.get(pk=id))
        except models.User.DoesNotExist:
            raise errors.NotFound()"
4372,"def _get_all(self):
        """""" Get all users from db and turn into list of dicts """"""
        return [self._to_dict(row) for row in models.User.objects.all()]"
4373,"def _dict_to_model(self, data):
        """""" Create new user model instance based on the received data.

        Note that the created user is not saved into database.
        """"""

        try:
            # we can do this because we have same fields
            # in the representation and in the model:
            user = models.User(**data)
        except TypeError:
            # client sent bad data
            raise errors.BadRequest()
        else:
            return user"
4374,"def captures(self, uuid, withTitles=False):
        """"""Return the captures for a given uuid
            optional value withTitles=yes""""""
        picker = lambda x: x.get('capture', [])
        return self._get((uuid,), picker, withTitles='yes' if withTitles else 'no')"
4375,"def uuid(self, type, val):
        """"""Return the item-uuid for a identifier""""""
        picker = lambda x: x.get('uuid', x)
        return self._get((type, val), picker)"
4376,"def search(self, q, field=None, page=None, per_page=None):
        """"""Search across all (without field) or in specific field
        (valid fields at http://www.loc.gov/standards/mods/mods-outline.html)""""""

        def picker(results):
            if type(results['result']) == list:
                return results['result']
            else:
                return [results['result']]

        return self._get(('search',), picker, q=q, field=field, page=page, per_page=per_page)"
4377,"def mods(self, uuid):
        """"""Return a mods record for a given uuid""""""
        picker = lambda x: x.get('mods', {})
        return self._get(('mods', uuid), picker)"
4378,"def _get(self, components, picker, **params):
        """"""Generic get which handles call to api and setting of results
        Return: Results object""""""
        url = '/'.join((self.base,) + components)

        headers = {""Authorization"": ""Token token="" + self._token}

        params['page'] = params.get('page') or self.page
        params['per_page'] = params.get('per_page') or self.per_page

        r = requests.get(""."".join([url, self.format]),
                         params=params,
                         headers=headers)

        _next = self._nextify(components, picker, params)

        return Result(r, picker, _next)"
4379,"def convert_datetext_to_dategui(datetext, ln=None, secs=False):
    """"""Convert: '2005-11-16 15:11:57' => '16 nov 2005, 15:11'

    Or optionally with seconds:
    '2005-11-16 15:11:57' => '16 nov 2005, 15:11:57'
    Month is internationalized
    """"""
    assert ln is None, 'setting language is not supported'
    try:
        datestruct = convert_datetext_to_datestruct(datetext)
        if datestruct == datestruct_default:
            raise ValueError

        if secs:
            output_format = ""d MMM Y, H:mm:ss""
        else:
            output_format = ""d MMM Y, H:mm""
        dt = datetime.fromtimestamp(time.mktime(datestruct))
        return babel_format_datetime(dt, output_format)
    except ValueError:
        return _(""N/A"")"
4380,"def get_datetext(year, month, day):
    """"""year=2005, month=11, day=16 => '2005-11-16 00:00:00'""""""
    input_format = ""%Y-%m-%d""
    try:
        datestruct = time.strptime(""%i-%i-%i"" % (year, month, day),
                                   input_format)
        return strftime(datetext_format, datestruct)
    except:
        return datetext_default"
4381,"def get_i18n_day_name(day_nb, display='short', ln=None):
    """"""Get the string representation of a weekday, internationalized

    @param day_nb: number of weekday UNIX like.
                   => 0=Sunday
    @param ln: language for output
    @return: the string representation of the day
    """"""
    ln = default_ln(ln)
    _ = gettext_set_language(ln)
    if display == 'short':
        days = {0: _(""Sun""),
                1: _(""Mon""),
                2: _(""Tue""),
                3: _(""Wed""),
                4: _(""Thu""),
                5: _(""Fri""),
                6: _(""Sat"")}
    else:
        days = {0: _(""Sunday""),
                1: _(""Monday""),
                2: _(""Tuesday""),
                3: _(""Wednesday""),
                4: _(""Thursday""),
                5: _(""Friday""),
                6: _(""Saturday"")}

    return days[day_nb]"
4382,"def get_i18n_month_name(month_nb, display='short', ln=None):
    """"""Get a non-numeric representation of a month, internationalized.

    @param month_nb: number of month, (1 based!)
                     =>1=jan,..,12=dec
    @param ln: language for output
    @return: the string representation of month
    """"""
    ln = default_ln(ln)
    _ = gettext_set_language(ln)
    if display == 'short':
        months = {0: _(""Month""),
                  1: _(""Jan""),
                  2: _(""Feb""),
                  3: _(""Mar""),
                  4: _(""Apr""),
                  5: _(""May""),
                  6: _(""Jun""),
                  7: _(""Jul""),
                  8: _(""Aug""),
                  9: _(""Sep""),
                  10: _(""Oct""),
                  11: _(""Nov""),
                  12: _(""Dec"")}
    else:
        months = {0: _(""Month""),
                  1: _(""January""),
                  2: _(""February""),
                  3: _(""March""),
                  4: _(""April""),
                  5: _(""May ""),  # trailing space distinguishes short/long form
                  6: _(""June""),
                  7: _(""July""),
                  8: _(""August""),
                  9: _(""September""),
                  10: _(""October""),
                  11: _(""November""),
                  12: _(""December"")}
    return months[month_nb].strip()"
4383,"def create_day_selectbox(name, selected_day=0, ln=None):
    """"""Creates an HTML menu for day selection. (0..31 values).

    @param name: name of the control (i.e. name of the var you'll get)
    @param selected_day: preselect a day. Use 0 for the label 'Day'
    @param ln: language of the menu
    @return: html a string
    """"""
    ln = default_ln(ln)
    _ = gettext_set_language(ln)
    out = ""<select name=\""%s\"">\n"" % name
    for i in range(0, 32):
        out += ""  <option value=\""%i\"""" % i
        if (i == selected_day):
            out += "" selected=\""selected\""""
        if (i == 0):
            out += "">%s</option>\n"" % _(""Day"")
        else:
            out += "">%i</option>\n"" % i
    out += ""</select>\n""
    return out"
4384,"def create_month_selectbox(name, selected_month=0, ln=None):
    """"""Creates an HTML menu for month selection. Value of selected field is
    numeric.

    @param name: name of the control, your form will be sent with name=value...
    @param selected_month: preselect a month. use 0 for the Label 'Month'
    @param ln: language of the menu
    @return: html as string
    """"""
    ln = default_ln(ln)
    out = ""<select name=\""%s\"">\n"" % name

    for i in range(0, 13):
        out += ""<option value=\""%i\"""" % i
        if (i == selected_month):
            out += "" selected=\""selected\""""
        out += "">%s</option>\n"" % get_i18n_month_name(i, ln)
    out += ""</select>\n""
    return out"
4385,"def create_year_selectbox(name, from_year=-1, length=10, selected_year=0,
                          ln=None):
    """"""Creates an HTML menu (dropdownbox) for year selection.

    @param name: name of control( i.e. name of the variable you'll get)
    @param from_year: year on which to begin. if <0 assume it is current year
    @param length: number of items in menu
    @param selected_year: initial selected year (if in range), else: label is
                          selected
    @param ln: language
    @return: html as string
    """"""
    ln = default_ln(ln)
    _ = gettext_set_language(ln)
    if from_year < 0:
        from_year = time.localtime()[0]
    out = ""<select name=\""%s\"">\n"" % name
    out += '  <option value=""0""'
    if selected_year == 0:
        out += ' selected=""selected""'
    out += "">%s</option>\n"" % _(""Year"")
    for i in range(from_year, from_year + length):
        out += ""<option value=\""%i\"""" % i
        if (i == selected_year):
            out += "" selected=\""selected\""""
        out += "">%i</option>\n"" % i
    out += ""</select>\n""
    return out"
4386,"def parse_runtime_limit(value, now=None):
    """"""Parsing CLI option for runtime limit, supplied as VALUE.

    Value could be something like: Sunday 23:00-05:00, the format being
    [Wee[kday]] [hh[:mm][-hh[:mm]]].
    The function will return two valid time ranges. The first could be in the
    past, containing the present or in the future. The second is always in the
    future.
    """"""

    def extract_time(value):
        value = _RE_RUNTIMELIMIT_HOUR.search(value).groupdict()
        return timedelta(hours=int(value['hours']),
                         minutes=int(value['minutes']))

    def extract_weekday(value):
        key = value[:3].lower()
        try:
            return {
                'mon': 0,
                'tue': 1,
                'wed': 2,
                'thu': 3,
                'fri': 4,
                'sat': 5,
                'sun': 6,
            }[key]
        except KeyError:
            raise ValueError(""%s is not a good weekday name."" % value)

    if now is None:
        now = datetime.now()

    today = now.date()
    g = _RE_RUNTIMELIMIT_FULL.search(value)
    if not g:
        raise ValueError('""%s"" does not seem to be correct format for '
                         'parse_runtime_limit() '
                         '[Wee[kday]] [hh[:mm][-hh[:mm]]]).' % value)
    pieces = g.groupdict()

    if pieces['weekday_begin'] is None:
        # No weekday specified. So either today or tomorrow
        first_occasion_day = timedelta(days=0)
        next_occasion_delta = timedelta(days=1)
    else:
        # If given 'Mon' then we transform it to 'Mon-Mon'
        if pieces['weekday_end'] is None:
            pieces['weekday_end'] = pieces['weekday_begin']

        # Day range
        weekday_begin = extract_weekday(pieces['weekday_begin'])
        weekday_end = extract_weekday(pieces['weekday_end'])

        if weekday_begin <= today.weekday() <= weekday_end:
            first_occasion_day = timedelta(days=0)
        else:
            days = (weekday_begin - today.weekday()) % 7
            first_occasion_day = timedelta(days=days)

        weekday = (now + first_occasion_day).weekday()
        if weekday < weekday_end:
            # Fits in the same week
            next_occasion_delta = timedelta(days=1)
        else:
            # The week after
            days = weekday_begin - weekday + 7
            next_occasion_delta = timedelta(days=days)

    if pieces['hour_begin'] is None:
        pieces['hour_begin'] = '00:00'
    if pieces['hour_end'] is None:
        pieces['hour_end'] = '00:00'

    beginning_time = extract_time(pieces['hour_begin'])
    ending_time = extract_time(pieces['hour_end'])

    if not ending_time:
        ending_time = beginning_time + timedelta(days=1)
    elif beginning_time and ending_time and beginning_time > ending_time:
        ending_time += timedelta(days=1)

    start_time = real_datetime.combine(today, real_time(hour=0, minute=0))
    current_range = (
        start_time + first_occasion_day + beginning_time,
        start_time + first_occasion_day + ending_time
    )
    if now > current_range[1]:
        current_range = tuple(t + next_occasion_delta for t in current_range)

    future_range = (
        current_range[0] + next_occasion_delta,
        current_range[1] + next_occasion_delta
    )
    return current_range, future_range"
4387,"def guess_datetime(datetime_string):
    """"""Try to guess the datetime contained in a string of unknow format.

    @param datetime_string: the datetime representation.
    @type datetime_string: string
    @return: the guessed time.
    @rtype: L{time.struct_time}
    @raises ValueError: in case it's not possible to guess the time.
    """"""
    if CFG_HAS_EGENIX_DATETIME:
        try:
            return Parser.DateTimeFromString(datetime_string).timetuple()
        except ValueError:
            pass
    else:
        for format in (None, '%x %X', '%X %x', '%Y-%M-%dT%h:%m:%sZ'):
            try:
                return time.strptime(datetime_string, format)
            except ValueError:
                pass
    raise ValueError(""It is not possible to guess the datetime format of %s"" %
                     datetime_string)"
4388,"def get_time_estimator(total):
    """"""Given a total amount of items to compute, return a function that,
    if called every time an item is computed (or every step items are computed)
    will give a time estimation for how long it will take to compute the whole
    set of itmes. The function will return two values: the first is the number
    of seconds that are still needed to compute the whole set, the second value
    is the time in the future when the operation is expected to end.
    """"""
    t1 = time.time()
    count = [0]

    def estimate_needed_time(step=1):
        count[0] += step
        t2 = time.time()
        t3 = 1.0 * (t2 - t1) / count[0] * (total - count[0])
        return t3, t3 + t1
    return estimate_needed_time"
4389,"def pretty_date(ugly_time=False, ln=None):
    """"""Get a datetime object or a int() Epoch timestamp and return a pretty
    string like 'an hour ago', 'Yesterday', '3 months ago', 'just now', etc.
    """"""

    ln = default_ln(ln)
    _ = gettext_set_language(ln)

    now = real_datetime.now()

    if isinstance(ugly_time, six.string_types):
        # try to convert it to epoch timestamp
        date_format = '%Y-%m-%d %H:%M:%S.%f'
        try:
            ugly_time = time.strptime(ugly_time, date_format)
            ugly_time = int(time.mktime(ugly_time))
        except ValueError:
            # doesn't match format, let's try to guess
            try:
                ugly_time = int(guess_datetime(ugly_time))
            except ValueError:
                return ugly_time
            ugly_time = int(time.mktime(ugly_time))

    # Initialize the time period difference
    if isinstance(ugly_time, int):
        diff = now - real_datetime.fromtimestamp(ugly_time)
    elif isinstance(ugly_time, real_datetime):
        diff = now - ugly_time
    elif not ugly_time:
        diff = now - now
    second_diff = diff.seconds
    day_diff = diff.days

    if day_diff < 0:
        return ''

    if day_diff == 0:
        if second_diff < 10:
            return _(""just now"")
        if second_diff < 60:
            return str(second_diff) + _("" seconds ago"")
        if second_diff < 120:
            return _(""a minute ago"")
        if second_diff < 3600:
            return str(second_diff / 60) + _("" minutes ago"")
        if second_diff < 7200:
            return _(""an hour ago"")
        if second_diff < 86400:
            return str(second_diff / 3600) + _("" hours ago"")
    if day_diff == 1:
        return _(""Yesterday"")
    if day_diff < 7:
        return str(day_diff) + _("" days ago"")
    if day_diff < 31:
        if day_diff / 7 == 7:
            return _(""Last week"")
        else:
            return str(day_diff / 7) + _("" weeks ago"")
    if day_diff < 365:
        if day_diff / 30 == 1:
            return _(""Last month"")
        else:
            return str(day_diff / 30) + _("" months ago"")
    if day_diff / 365 == 1:
        return _(""Last year"")
    else:
        return str(day_diff / 365) + _("" years ago"")"
4390,"def get_dst(date_obj):
    """"""Determine if dst is locally enabled at this time""""""
    dst = 0
    if date_obj.year >= 1900:
        tmp_date = time.mktime(date_obj.timetuple())
        # DST is 1 so reduce time with 1 hour.
        dst = time.localtime(tmp_date)[-1]
    return dst"
4391,"def utc_to_localtime(
        date_str,
        fmt=""%Y-%m-%d %H:%M:%S"",
        input_fmt=""%Y-%m-%dT%H:%M:%SZ""):
    """"""
    Convert UTC to localtime

    Reference:
     - (1) http://www.openarchives.org/OAI/openarchivesprotocol.html#Dates
     - (2) http://www.w3.org/TR/NOTE-datetime

    This function works only with dates complying with the
    ""Complete date plus hours, minutes and seconds"" profile of
    ISO 8601 defined by (2), and linked from (1).

    Eg:    1994-11-05T13:15:30Z
    """"""
    date_struct = datetime.strptime(date_str, input_fmt)
    date_struct += timedelta(hours=get_dst(date_struct))
    date_struct -= timedelta(seconds=time.timezone)
    return strftime(fmt, date_struct)"
4392,"def njsd_all(network, ref, query, file, verbose=True):
    """"""Compute transcriptome-wide nJSD between reference and query expression profiles.
    Attribute:
        network (str): File path to a network file.
        ref (str): File path to a reference expression file.
        query (str): File path to a query expression file.
    """"""
    graph, gene_set_total = util.parse_network(network)
    ref_gene_expression_dict = util.parse_gene_expression(ref, mean=True)
    query_gene_expression_dict = util.parse_gene_expression(query, mean=False)
    maximally_ambiguous_gene_experession_dict = util.get_maximally_ambiguous_network(query_gene_expression_dict)
    gene_set_present = set(query_gene_expression_dict.keys())

    with open(file, 'w') as outFile:
        print('nJSD_NT', 'nJSD_TA', 'tITH', sep='\t', file=outFile)

    normal_to_tumor_njsd = entropy.njsd(network=graph,
                                        ref_gene_expression_dict=ref_gene_expression_dict,
                                        query_gene_expression_dict=query_gene_expression_dict,
                                        gene_set=gene_set_present)

    tumor_to_ambiguous_njsd = entropy.njsd(network=graph,
                                           ref_gene_expression_dict=maximally_ambiguous_gene_experession_dict,
                                           query_gene_expression_dict=query_gene_expression_dict,
                                           gene_set=gene_set_present)
    tITH = normal_to_tumor_njsd / (normal_to_tumor_njsd + tumor_to_ambiguous_njsd)

    with open(file, 'a') as outFile:
        print(normal_to_tumor_njsd, tumor_to_ambiguous_njsd, tITH, sep='\t', file=outFile)
    return normal_to_tumor_njsd / (normal_to_tumor_njsd + tumor_to_ambiguous_njsd)"
4393,"def njsd_geneset(network, ref, query, gene_set, file, verbose=True):
    """"""Compute gene set-specified nJSD between reference and query expression profiles.
    Attribute;
        network (str): File path to a network file.
        ref (str): File path to a reference expression file.
        query (str): File path to a query expression file.
        geneset (str): File path to a gene set file.
    """"""
    graph, gene_set_total = util.parse_network(network)
    ref_gene_expression_dict = util.parse_gene_expression(ref, mean=True)
    query_gene_expression_dict = util.parse_gene_expression(query, mean=False)
    group_gene_set_dict = util.parse_gene_set(gene_set)
    maximally_ambiguous_gene_experession_dict = util.get_maximally_ambiguous_network(query_gene_expression_dict)
    gene_set_present = set(query_gene_expression_dict.keys())

    with open(file, 'w') as outFile:
        print('Gene_set_ID', 'nJSD_NT', 'nJSD_TA', 'tITH', sep='\t', file=outFile)

    for group, gene_set in group_gene_set_dict.items():
        gene_set_to_be_analyzed = gene_set.intersection(gene_set_present)
        # If no genes are available for the group, just ignore it.
        if len(gene_set_to_be_analyzed) == 0:
            logger.warning('%s has no genes available for analysis. Ignoring the group.' % group)
            continue

        # If every gene has a single neighbor, just ignore it.
        if all([graph.degree(gene) == 1 for gene in gene_set_to_be_analyzed]):
            logger.warning('%s has no genes with enough neighbors. Ignoring the group.' % group)
            continue

        normal_to_tumor_njsd = entropy.njsd(network=graph,
                                            ref_gene_expression_dict=ref_gene_expression_dict,
                                            query_gene_expression_dict=query_gene_expression_dict,
                                            gene_set=gene_set)

        tumor_to_ambiguous_njsd = entropy.njsd(network=graph,
                                               ref_gene_expression_dict=maximally_ambiguous_gene_experession_dict,
                                               query_gene_expression_dict=query_gene_expression_dict,
                                               gene_set=gene_set)

        tITH = normal_to_tumor_njsd / (normal_to_tumor_njsd + tumor_to_ambiguous_njsd)
        with open(file, 'a') as outFile:
            print(group, normal_to_tumor_njsd, tumor_to_ambiguous_njsd, tITH, sep='\t', file=outFile)"
4394,"def create_collection(cls, collection, **kwargs):
        """"""Create Collection

        Create a new Collection
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_collection(collection, async=True)
        >>> result = thread.get()

        :param async bool
        :param Collection collection: Attributes of collection to create (required)
        :return: Collection
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_collection_with_http_info(collection, **kwargs)
        else:
            (data) = cls._create_collection_with_http_info(collection, **kwargs)
            return data"
4395,"def delete_collection_by_id(cls, collection_id, **kwargs):
        """"""Delete Collection

        Delete an instance of Collection by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_collection_by_id(collection_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str collection_id: ID of collection to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_collection_by_id_with_http_info(collection_id, **kwargs)
        else:
            (data) = cls._delete_collection_by_id_with_http_info(collection_id, **kwargs)
            return data"
4396,"def get_collection_by_id(cls, collection_id, **kwargs):
        """"""Find Collection

        Return single instance of Collection by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_collection_by_id(collection_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str collection_id: ID of collection to return (required)
        :return: Collection
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_collection_by_id_with_http_info(collection_id, **kwargs)
        else:
            (data) = cls._get_collection_by_id_with_http_info(collection_id, **kwargs)
            return data"
4397,"def list_all_collections(cls, **kwargs):
        """"""List Collections

        Return a list of Collections
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_collections(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[Collection]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_collections_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_collections_with_http_info(**kwargs)
            return data"
4398,"def replace_collection_by_id(cls, collection_id, collection, **kwargs):
        """"""Replace Collection

        Replace all attributes of Collection
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_collection_by_id(collection_id, collection, async=True)
        >>> result = thread.get()

        :param async bool
        :param str collection_id: ID of collection to replace (required)
        :param Collection collection: Attributes of collection to replace (required)
        :return: Collection
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_collection_by_id_with_http_info(collection_id, collection, **kwargs)
        else:
            (data) = cls._replace_collection_by_id_with_http_info(collection_id, collection, **kwargs)
            return data"
4399,"def update_collection_by_id(cls, collection_id, collection, **kwargs):
        """"""Update Collection

        Update attributes of Collection
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_collection_by_id(collection_id, collection, async=True)
        >>> result = thread.get()

        :param async bool
        :param str collection_id: ID of collection to update. (required)
        :param Collection collection: Attributes of collection to update. (required)
        :return: Collection
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_collection_by_id_with_http_info(collection_id, collection, **kwargs)
        else:
            (data) = cls._update_collection_by_id_with_http_info(collection_id, collection, **kwargs)
            return data"
4400,"def setupModule(
            self):
        """"""
        *The setupModule method*

        **Return:**
            - ``log`` -- a logger
            - ``dbConn`` -- a database connection to a test database (details from yaml settings file)
            - ``pathToInputDir`` -- path to modules own test input directory
            - ``pathToOutputDir`` -- path to modules own test output directory
        """"""
        import pymysql as ms
        ## VARIABLES ##
        logging.config.dictConfig(yaml.load(self.loggerConfig))
        log = logging.getLogger(__name__)
        connDict = yaml.load(self.dbConfig)
        dbConn = ms.connect(
            host=connDict['host'],
            user=connDict['user'],
            passwd=connDict['password'],
            db=connDict['db'],
            use_unicode=True,
            charset='utf8',
            local_infile=1,
            client_flag=ms.constants.CLIENT.MULTI_STATEMENTS,
            connect_timeout=3600
        )
        dbConn.autocommit(True)

        return log, dbConn, self.pathToInputDir, self.pathToOutputDir"
4401,"def _handle_call(self, actual_call, stubbed_call):
        """"""Extends Stub call handling behavior to be callable by default.""""""
        self._actual_calls.append(actual_call)
        use_call = stubbed_call or actual_call
        return use_call.return_value"
4402,"def formatted_args(self):
        """"""Format call arguments as a string.

        This is used to make test failure messages more helpful by referring
        to calls using a string that matches how they were, or should have been
        called.

        >>> call = Call('arg1', 'arg2', kwarg='kwarg')
        >>> call.formatted_args
        ""('arg1', 'arg2', kwarg='kwarg')""

        """"""
        arg_reprs = list(map(repr, self.args))
        kwarg_reprs = ['%s=%s' % (k, repr(v)) for k, v in self.kwargs.items()]
        return '(%s)' % ', '.join(arg_reprs + kwarg_reprs)"
4403,"def passing(self, *args, **kwargs):
        """"""Assign expected call args/kwargs to this call.

        Returns `self` for the common case of chaining a call to `Call.returns`

        >>> Call().passing('foo', bar='baz')
        <Call args=('foo',) kwargs={'bar': 'baz'}>

        """"""
        self.args = args
        self.kwargs = kwargs
        return self"
4404,"def check(self):
        """""" Check if data and third party tools are available

        :raises: RuntimeError
        """"""

        #for path in self.path.values():
        #    if not os.path.exists(path):
        #        raise RuntimeError(""File '{}' is missing"".format(path))

        for tool in ('cd-hit', 'prank', 'hmmbuild', 'hmmpress', 'hmmscan', 'phmmer', 'mafft', 'meme'):
            if not self.pathfinder.exists(tool):
                raise RuntimeError(""Dependency {} is missing"".format(tool))"
4405,"def generate_non_rabs(self):
        """""" Shrink the non-Rab DB size by reducing sequence redundancy.
        """"""

        logging.info('Building non-Rab DB')
        run_cmd([self.pathfinder['cd-hit'], '-i', self.path['non_rab_db'], '-o', self.output['non_rab_db'],
                 '-d', '100', '-c', str(config['param']['non_rab_db_identity_threshold']), '-g', '1', '-T', self.cpu])
        os.remove(self.output['non_rab_db'] + '.clstr')"
4406,"def parse_duration(duration):
    """"""Attepmts to parse an ISO8601 formatted ``duration``.

    Returns a ``datetime.timedelta`` object.
    """"""
    duration = str(duration).upper().strip()

    elements = ELEMENTS.copy()

    for pattern in (SIMPLE_DURATION, COMBINED_DURATION):
        if pattern.match(duration):
            found = pattern.match(duration).groupdict()
            del found['time']

            elements.update(dict((k, int(v or 0))
                                 for k, v
                                 in found.items()))

            return datetime.timedelta(days=(elements['days'] +
                                            _months_to_days(elements['months']) +
                                            _years_to_days(elements['years'])),
                                      hours=elements['hours'],
                                      minutes=elements['minutes'],
                                      seconds=elements['seconds'])            
    
    return ParseError()"
4407,"def skin_details(skin_id, lang=""en""):
    """"""This resource returns details about a single skin.

    :param skin_id: The skin to query for.
    :param lang: The language to display the texts in.

    The response is an object with at least the following properties. Note that
    the availability of some properties depends on the type of item the skin
    applies to.

    skin_id (number):
        The skin id.

    name (string):
        The name of the skin.

    type (string):
        The type of item the skin applies to. One of ``Armor``, ``Back`` or
        ``Weapon``.

    flags (list):
        Skin flags. Currently known skin flags are ``ShowInWardrobe``,
        ``HideIfLocked`` and ``NoCost``.

    restrictions (list):
        Race restrictions: ``Asura``, ``Charr``, ``Human``, ``Norn`` and
        ``Sylvari``.

    icon_file_id (string):
        The icon file id to be used with the render service.

    icon_file_signature (string):
        The icon file signature to be used with the render service.

    """"""
    params = {""skin_id"": skin_id, ""lang"": lang}
    cache_name = ""skin_details.%(skin_id)s.%(lang)s.json"" % params
    return get_cached(""skin_details.json"", cache_name, params=params)"
4408,"def bubble_to_dot(bblfile:str, dotfile:str=None, render:bool=False,
                  oriented:bool=False):
    """"""Write in dotfile a graph equivalent to those depicted in bubble file""""""
    tree = BubbleTree.from_bubble_file(bblfile, oriented=bool(oriented))
    return tree_to_dot(tree, dotfile, render=render)"
4409,"def bubble_to_gexf(bblfile:str, gexffile:str=None, oriented:bool=False):
    """"""Write in bblfile a graph equivalent to those depicted in bubble file""""""
    tree = BubbleTree.from_bubble_file(bblfile, oriented=bool(oriented))
    gexf_converter.tree_to_file(tree, gexffile)
    return gexffile"
4410,"def bubble_to_js(bblfile:str, jsdir:str=None, oriented:bool=False, **style):
    """"""Write in jsdir a graph equivalent to those depicted in bubble file""""""
    js_converter.bubble_to_dir(bblfile, jsdir, oriented=bool(oriented), **style)
    return jsdir"
4411,"def tree_to_dot(tree:BubbleTree, dotfile:str=None, render:bool=False):
    """"""Write in dotfile a graph equivalent to those depicted in bubble file

    See http://graphviz.readthedocs.io/en/latest/examples.html#cluster-py
    for graphviz API

    """"""
    graph = tree_to_graph(tree)
    path = None
    if dotfile:  # first save the dot file.
        path = graph.save(dotfile)
    if render:  # secondly, show it.
        # As the dot file is known by the Graph object,
        # it will be placed around the dot file.
        graph.view()
    return path"
4412,"def tree_to_graph(bbltree:BubbleTree) -> Graph or Digraph:
    """"""Compute as a graphviz.Graph instance the given graph.

    If given BubbleTree instance is oriented, returned value
    is a graphviz.Digraph.

    See http://graphviz.readthedocs.io/en/latest/examples.html#cluster-py
    for graphviz API

    """"""
    GraphObject = Digraph if bbltree.oriented else Graph
    def create(name:str):
        """"""Return a graphviz graph figurating a powernode""""""
        ret = GraphObject('cluster_' + name)
        # dirty hack to get links between clusters: add a blank node inside
        # so the subgraph don't take it's name directly, but the blank node do.
        # ret.body.append('label = ""{}""'.format(name))  # replaced by:
        ret.node(name, style='invis', shape='point')
        # ret.body.append('style=plaintext')
        ret.body.append('color=lightgrey')
        ret.body.append('label=""""')
        ret.body.append('shape=ellipse')
        ret.body.append('penwidth=2')
        ret.body.append('pencolor=black')
        return ret
    nodes = frozenset(bbltree.nodes())
    subgraphs = {}
    # build for each powernode the associated subgraph, and add its successors
    for powernode in bbltree.powernodes():
        if powernode not in subgraphs:
            subgraphs[powernode] = create(powernode)
        for succ in bbltree.inclusions[powernode]:
            if succ not in subgraphs:
                if succ not in nodes:
                    subgraphs[succ] = create(succ)
                else:
                    subgraphs[powernode].node(succ)
    # add to Graph instances the Graph of successors as subgraphs 
    for powernode, succs in bbltree.inclusions.items():
        for succ in succs:
            if succ not in nodes:
                subgraphs[powernode].subgraph(subgraphs[succ])
    # build the final graph by adding to it subgraphs of roots
    graph = GraphObject('graph', graph_attr={'compound': 'true'})
    for root in bbltree.roots:
        if root in subgraphs:
            graph.subgraph(subgraphs[root])
    # add the edges to the final graph
    for source, targets in bbltree.edges.items():
        for target in targets:
            if source <= target:
                attrs = {}
                if source not in nodes:
                    attrs.update({'ltail': 'cluster_' + source})
                if target not in nodes:
                    attrs.update({'lhead': 'cluster_' + target})
                graph.edge(source, target, **attrs)
    # print(graph)  # debug line
    # graph.view()  # debug line
    return graph"
4413,"def fill(self, term_dict, terms):
        # type: (Dict[int, Set[Type[Rule]]], Any) -> None
        """"""
        Fill first row of the structure witch nonterminal directly rewritable to terminal.
        :param term_dict: Dictionary of rules directly rewritable to terminal.
        Key is hash of terminal, value is set of rules with key terminal at the right side.
        :param terms: Input sequence of terminal.
        """"""
        for i in range(len(terms)):
            t = terms[i]
            self._field[0][i] += term_dict[hash(t)]"
4414,"def rules(self, x, y):
        # type: (int, int) -> List[Type[Rule]]
        """"""
        Get rules at specific position in the structure.
        :param x: X coordinate
        :param y: Y coordinate
        :return: List of rules
        """"""
        return [r for r in self._field[y][x]]"
4415,"def positions(self, x, y):
        # type: (int, int) -> List[(Point, Point)]
        """"""
        Get all positions, that can be combined to get word parsed at specified position.
        :param x: X coordinate.
        :param y: Y coordinate.
        :return: List of tuples with two Point instances.
        """"""
        return [(Point(x, v), Point(x + 1 + v, y - 1 - v)) for v in range(y)]"
4416,"def put(self, x, y, rules):
        # type: (int, int, List[PlaceItem]) -> None
        """"""
        Set possible rules at specific position.
        :param x: X coordinate.
        :param y: Y coordinate.
        :param rules: Value to set.
        """"""
        self._field[y][x] = rules"
4417,"def froze_it(cls):
    """"""
    Decorator to prevent from creating attributes in the object ouside __init__().

    This decorator must be applied to the final class (doesn't work if a
    decorated class is inherited).

    Yoann's answer at http://stackoverflow.com/questions/3603502
    """"""
    cls._frozen = False

    def frozensetattr(self, key, value):
        if self._frozen and not hasattr(self, key):
            raise AttributeError(""Attribute '{}' of class '{}' does not exist!""
                  .format(key, cls.__name__))
        else:
            object.__setattr__(self, key, value)

    def init_decorator(func):
        @wraps(func)
        def wrapper(self, *args, **kwargs):
            func(self, *args, **kwargs)
            self._frozen = True
        return wrapper

    cls.__setattr__ = frozensetattr
    cls.__init__ = init_decorator(cls.__init__)

    return cls"
4418,"def one_liner_str(self):
        """"""Returns string (supposed to be) shorter than str() and not contain newline""""""
        assert self.less_attrs is not None, ""Forgot to set attrs class variable""
        s_format = ""{}={}""
        s = ""; "".join([s_format.format(x, self.__getattribute__(x)) for x in self.less_attrs])
        return s"
4419,"def to_dict(self):
        """"""Returns OrderedDict whose keys are self.attrs""""""
        ret = OrderedDict()
        for attrname in self.attrs:
            ret[attrname] = self.__getattribute__(attrname)
        return ret"
4420,"def to_list(self):
        """"""Returns list containing values of attributes listed in self.attrs""""""

        ret = OrderedDict()
        for attrname in self.attrs:
            ret[attrname] = self.__getattribute__(attrname)
        return ret"
4421,"def uniq(pipe):
    ''' this works like bash's uniq command where the generator only iterates
        if the next value is not the previous '''
    pipe = iter(pipe)
    previous = next(pipe)
    yield previous
    for i in pipe:
        if i is not previous:
            previous = i
            yield i"
4422,"def chunks_generator(iterable, count_items_in_chunk):
    """"""
    Очень внимательно! Не дает обходить дважды

    :param iterable:
    :param count_items_in_chunk:
    :return:
    """"""
    iterator = iter(iterable)
    for first in iterator:  # stops when iterator is depleted
        def chunk():  # construct generator for next chunk
            yield first  # yield element from for loop
            for more in islice(iterator, count_items_in_chunk - 1):
                yield more  # yield more elements from the iterator

        yield chunk()"
4423,"def chunks(list_, count_items_in_chunk):
    """"""
    разбить list (l) на куски по n элементов

    :param list_:
    :param count_items_in_chunk:
    :return:
    """"""
    for i in range(0, len(list_), count_items_in_chunk):
        yield list_[i:i + count_items_in_chunk]"
4424,"def pretty_json(obj):
    """"""
    Представить объект в вище json красиво отформатированной строки
    :param obj:
    :return:
    """"""
    return json.dumps(obj, sort_keys=True, indent=4, separators=(',', ': '), ensure_ascii=False)"
4425,"def decode_jwt(input_text, secure_key):
    """"""
    Раскодирование строки на основе ключа
    :param input_text: исходная строка
    :param secure_key: секретный ключ
    :return:
    """"""
    if input_text is None:
        return None

    encoded = (input_text.split("":"")[1]).encode('utf-8')
    decoded = jwt.decode(encoded, secure_key)
    return decoded['sub']"
4426,"def send_request(url, method, data, 
	args, params, headers, cookies, timeout, is_json, verify_cert):
	""""""
	Forge and send HTTP request.
	""""""
	## Parse url args
	for p in args:
		url = url.replace(':' + p, str(args[p]))

	try:
		if data:
			if is_json:
				headers['Content-Type'] = 'application/json'
				data = json.dumps(data)

			request = requests.Request(
				method.upper(), url, data=data, params=params, 
				headers=headers, cookies=cookies
			)
		else:
			request = requests.Request(
				method.upper(), url, params=params, headers=headers, 
				cookies=cookies
			)

		## Prepare and send HTTP request.
		session = requests.Session()
		session.verify = verify_cert
		r = session.send(request.prepare(), timeout=timeout)
		session.close()

	except requests.exceptions.Timeout:
		return {
			'data': {}, 
			'cookies': CookieJar(),
			'content_type': '', 
			'status': 0, 
			'is_json': False,
			'timeout': True
		}

	try:
		content_type = r.headers.get('Content-Type', 'application/json')
		response = r.json()
		isjson = True
		
	except json.decoder.JSONDecodeError:
		content_type = r.headers.get('Content-Type', 'text/html')
		response = r.text
		isjson = False

	return {
		'data': response,
		'cookies': r.cookies,
		'content_type': content_type, 
		'status': r.status_code,
		'is_json': isjson,
		'timeout': False
	}"
4427,"def neighbors(self) -> List['Node']:
        """"""
        The list of neighbors of the node.
        """"""
        self._load_neighbors()
        return [edge.source if edge.source != self else edge.target
                for edge in self._neighbors.values()]"
4428,"def add_neighbor(self, edge: ""Edge"") -> None:
        """"""
        Adds a new neighbor to the node.

        Arguments:
            edge (Edge): The edge that would connect this node with its neighbor.
        """"""
        if edge is None or (edge.source != self and edge.target != self):
            return

        if edge.source == self:
            other: Node = edge.target
        elif edge.target == self:
            other: Node = edge.source
        else:
            raise ValueError(""Tried to add a neighbor with an invalid edge."")

        edge_key: Tuple(int, int) = edge.key

        # The graph is considered undirected, check neighbor existence accordingly.
        if self._neighbors.get(edge_key) or self._neighbors.get((edge_key[1], edge_key[0])):
            return  # The neighbor is already added.

        self._neighbors[edge_key] = edge
        self.dispatch_event(NeighborAddedEvent(other))"
4429,"def _load_neighbors(self) -> None:
        """"""
        Loads all neighbors of the node from the local database and
        from the external data source if needed.
        """"""
        if not self.are_neighbors_cached:
            self._load_neighbors_from_external_source()
            db: GraphDatabaseInterface = self._graph.database
            db_node: DBNode = db.Node.find_by_name(self.name)
            db_node.are_neighbors_cached = True
            db.session.commit()
            self.are_neighbors_cached = True
        if not self._are_neighbors_loaded:
            self._load_neighbors_from_database()"
4430,"def _load_neighbors_from_database(self) -> None:
        """"""
        Loads the neighbors of the node from the local database.
        """"""
        self._are_neighbors_loaded = True

        graph: Graph = self._graph
        neighbors: List[DBNode] = graph.database.Node.find_by_name(self.name).neighbors
        nodes: NodeList = graph.nodes

        for db_node in neighbors:
            graph.add_node(db_node.name, db_node.external_id)
            neighbor: Node = nodes.get_node_by_name(db_node.name)
            graph.add_edge(self, neighbor, 1, False)"
4431,"def key(self) -> Tuple[int, int]:
        """"""
        The unique identifier of the edge consisting of the indexes of its
        source and target nodes.
        """"""
        return self._source.index, self._target.index"
4432,"def add_node_by_name(self, node_name: str, external_id: Optional[str] = None) -> None:
        """"""
        Adds a new node to the graph if it doesn't exist.

        Arguments:
            node_name (str): The name of the node to add.
            external_id (Optional[str]): The external ID of the node.
        """"""
        if node_name is None:
            return

        node_name = node_name.strip()
        if len(node_name) == 0:
            return

        node: Node = self.get_node_by_name(node_name, external_id=external_id)
        if node is None:
            self._internal_add_node(node_name=node_name,
                                    external_id=external_id,
                                    are_neighbors_cached=False,
                                    add_to_cache=True)"
4433,"def get_node(self, index: int) -> Optional[Node]:
        """"""
        Returns the node with the given index if such a node currently exists in the node list.

        Arguments:
            index (int): The index of the queried node.

        Returns:
            The node with the given index if such a node currently exists in the node list,
            `None` otherwise.
        """"""
        return self._nodes.get(index)"
4434,"def get_node_by_name(self, node_name: str,
                         can_validate_and_load: bool = False,
                         external_id: Optional[str] = None) -> Optional[Node]:
        """"""
        Returns the node with the given name if it exists either in the graph
        or in its database cache or `None` otherwise.

        Arguments:
            node_name (str): The name of the node to return.
            can_validate_and_load (bool): Whether `self._graph.get_authentic_node_name(node_name)`
                                          can be called to validate the node name and add the node
                                          to the graph if the node name is valid.
            external_id (Optional[str]): An optional external ID that is used only if there no node
                                         with the given name in the graph or in the cache and
                                         `can_validate_and_load` is `True`.

        Returns:
            The node with the given name if it exists either in the graph
            or in its database cache, `None` otherwise.
        """"""
        node: Node = self._node_name_map.get(node_name)
        if node is not None:
            return node

        db_node: DBNode = self._graph.database.Node.find_by_name(node_name)
        if db_node is None:
            if can_validate_and_load:
                node_name = self._graph.get_authentic_node_name(node_name)
                if node_name is not None:
                    node = self._node_name_map.get(node_name)
                    if node is not None:
                        return node

                    db_node = self._graph.database.Node.find_by_name(node_name)
                    if db_node is None:
                        self._internal_add_node(node_name=node_name,
                                                external_id=external_id,
                                                are_neighbors_cached=False,
                                                add_to_cache=True)
                    else:
                        self._internal_add_node(node_name=db_node.name,
                                                external_id=db_node.external_id,
                                                are_neighbors_cached=db_node.are_neighbors_cached,
                                                add_to_cache=False)
            else:
                return None
        else:
            self._internal_add_node(node_name=db_node.name,
                                    external_id=db_node.external_id,
                                    are_neighbors_cached=db_node.are_neighbors_cached,
                                    add_to_cache=False)

        node = self._node_name_map.get(node_name)

        # Trying to load the cached neighbors of the created node from the database could
        # cause a very-very-very deep recursion, so don't even think about doing it here.

        return node"
4435,"def _internal_add_node(self,
                           node_name: str,
                           external_id: Optional[str] = None,
                           are_neighbors_cached: bool = False,
                           add_to_cache: bool = False) -> None:
        """"""
        Adds a node with the given name to the graph without checking whether it already exists or not.

        Arguments:
            node_name (str): The name of the node to add.
            external_id (Optional[str]): The external ID of the node.
            are_neighbors_cached (bool): Whether the neighbors of the node have already been cached.
            add_to_cache (bool): Whether the node should also be created in the local cache.
        """"""
        index: int = len(self)
        node: Node = self._create_node(index, node_name, external_id)
        node.are_neighbors_cached = are_neighbors_cached
        self._nodes[index] = node
        self._node_name_map[node_name] = node

        if add_to_cache:
            db: GraphDatabaseInterface = self._graph.database
            db_node: DBNode = db.Node.find_by_name(node.name)
            if db_node is None:
                db_node = db.Node(node.name, node.external_id)
                db_node.are_neighbors_cached = False
                db.session.add(db_node)
                db.session.commit()"
4436,"def edge_list(self) -> List[Edge]:
        """"""
        The ordered list of edges in the container.
        """"""
        return [edge for edge in sorted(self._edges.values(), key=attrgetter(""key""))]"
4437,"def add_edge(self,
                 source: Node,
                 target: Node,
                 weight: float = 1,
                 save_to_cache: bool = True) -> None:
        """"""
        Adds an edge to the edge list that will connect the specified nodes.

        Arguments:
            source (Node): The source node of the edge.
            target (Node): The target node of the edge.
            weight (float): The weight of the created edge.
            save_to_cache (bool): Whether the edge should be saved to the local database.
        """"""
        if not isinstance(source, Node):
            raise TypeError(""Invalid source: expected Node instance, got {}."".format(source))
        if not isinstance(target, Node):
            raise TypeError(""Invalid target: expected Node instance, got {}."".format(target))

        if source.index == target.index or\
           self.get_edge_by_index(source.index, target.index) is not None:
            return

        self._edges[(source.index, target.index)] = Edge(source, target, weight)

        if save_to_cache:
            should_commit: bool = False
            database: GraphDatabaseInterface = self._graph.database
            db_edge: DBEdge = database.Edge.find_by_name(source.name, target.name)
            if db_edge is None:
                database.session.add(database.Edge(source.name, target.name, weight))
                should_commit = True
            elif db_edge.weight != weight:
                db_edge.weight = weight
                should_commit = True

            if should_commit:
                database.session.commit()"
4438,"def get_edge(self, source: Node, target: Node) -> Optional[Edge]:
        """"""
        Returns the edge connection the given nodes if such an edge exists.

        Arguments:
            source (Node): One of the endpoints of the queried edge.
            target (Node): The other endpoint of the queried edge.

        Returns:
            Returns the edge connection the given nodes
            or `None` if no such node exists.
        """"""
        return self.get_edge_by_index(source.index, target.index)"
4439,"def get_edge_by_index(self, source_index: int, target_index: int) -> Optional[Edge]:
        """"""
        Returns the edge connecting the nodes with the specified indices if such an edge exists.

        Arguments:
            source_index (int): The index of one of the endpoints of queried edge.
            target_index (int): The index of the other endpoint of the queried edge.

        Returns:
            The edge connecting the nodes with the specified indices
            or `None` if no such node exists.
        """"""
        edge = self._edges.get((source_index, target_index))
        if edge is not None:
            return edge
        return self._edges.get((target_index, source_index))"
4440,"def get_edge_by_name(self, source_name: str, target_name: str) -> Optional[Edge]:
        """"""
        Returns the edge connecting the nodes with the specified names if such an edge exists.

        Arguments:
            source_name (str): The name of one of the endpoints of queried edge.
            target_name (str): The name of the other endpoint of the queried edge.

        Returns:
            The edge connecting the nodes with the specified names
            or `None` if no such node exists.
        """"""
        nodes: NodeList = self._graph.nodes
        source: Optional[Node] = nodes.get_node_by_name(source_name)
        if source is None:
            return None
        target: Optional[Node] = nodes.get_node_by_name(target_name)
        if target is None:
            return None
        return self.get_edge_by_index(source.index, target.index)"
4441,"def add_edge(self, source: Node,
                 target: Node,
                 weight: float = 1,
                 save_to_cache: bool = True) -> None:
        """"""
        Adds an edge between the specified nodes of the graph.

        Arguments:
            source (Node): The source node of the edge to add.
            target (Node): The target node of the edge to add.
            weight (float): The weight of the edge.
            save_to_cache (bool): Whether the edge should be saved to the local database. This
                                  argument is necessary (and `False`) when we load edges from
                                  the local cache.
        """"""
        if self._edges.get_edge(source, target) is not None:
            return

        self._edges.add_edge(
            source=source,
            target=target,
            weight=weight,
            save_to_cache=save_to_cache
        )"
4442,"def add_edge_by_index(self, source_index: int, target_index: int,
                          weight: float, save_to_cache: bool = True) -> None:
        """"""
        Adds an edge between the nodes with the specified indices to the graph.

        Arguments:
            source_index (int): The index of the source node of the edge to add.
            target_index (int): The index of the target node of the edge to add.
            weight (float): The weight of the edge.
            save_to_cache (bool): Whether the edge should be saved to the local database. This
                                  argument is necessary (and `False`) when we load edges from
                                  the local cache.
        """"""
        source: Node = self._nodes.get_node(source_index)
        target: Node = self._nodes.get_node(target_index)
        if source is None or target is None:
            return

        self.add_edge(
            source=source,
            target=target,
            weight=weight,
            save_to_cache=save_to_cache
        )"
4443,"def add_node(self, node_name: str, external_id: Optional[str] = None) -> None:
        """"""
        Adds the node with the given name to the graph.

        Arguments:
            node_name (str): The name of the node to add to the graph.
            external_id (Optional[str]): The external ID of the node.
        """"""
        self._nodes.add_node_by_name(node_name, external_id)"
4444,"def get_authentic_node_name(self, node_name: str) -> Optional[str]:
        """"""
        Returns the exact, authentic node name for the given node name if a node corresponding to
        the given name exists in the graph (maybe not locally yet) or `None` otherwise.

        By default, this method checks whether a node with the given name exists locally in the
        graph and return `node_name` if it does or `None` otherwise.

        In `Graph` extensions that are used by applications where the user can enter potentially
        incorrect node names, this method should be overridden to improve usability.

        Arguments:
            node_name (str): The node name to return the authentic node name for.

        Returns:
            The authentic name of the node corresponding to the given node name or
            `None` if no such node exists.
        """"""
        node: Node = self._nodes.get_node_by_name(node_name)
        return node.name if node is not None else None"
4445,"def beforeSummaryReport(self, event):
        '''Output profiling results'''
        self.prof.disable()
        stats = pstats.Stats(self.prof, stream=event.stream).sort_stats(
            self.sort)
        event.stream.writeln(nose2.util.ln('Profiling results'))
        stats.print_stats()
        if self.pfile:
            stats.dump_stats(self.pfile)
        if self.cachegrind:
            visualize(self.prof.getstats())"
4446,"def separate(text):
    '''Takes text and separates it into a list of words'''
    alphabet = 'abcdefghijklmnopqrstuvwxyz'
    words = text.split()
    standardwords = []
    for word in words:
        newstr = ''
        for char in word:
            if char in alphabet or char in alphabet.upper():
               newstr += char
        if newstr != '':
            standardwords.append(newstr)
    return map(lambda x: x.lower(),standardwords)"
4447,"def eliminate_repeats(text):
    '''Returns a list of words that occur in the text. Eliminates stopwords.'''
    
    bannedwords = read_file('stopwords.txt')
    alphabet = 'abcdefghijklmnopqrstuvwxyz'
    words = text.split()
    standardwords = []
    for word in words:
        newstr = ''
        for char in word:
            if char in alphabet or char in alphabet.upper():
               newstr += char
        if newstr not in standardwords and newstr != '' and newstr not in bannedwords:
            standardwords.append(newstr)
        
    return map(lambda x: x.lower(),standardwords)"
4448,"def wordcount(text):
    '''Returns the count of the words in a file.'''
    bannedwords = read_file('stopwords.txt')
    wordcount = {}
    separated = separate(text)
    for word in separated:
        if word not in bannedwords:
            if not wordcount.has_key(word):
                wordcount[word] = 1
            else:
                wordcount[word] += 1
    return wordcount"
4449,"def tuplecount(text):
    '''Changes a dictionary into a list of tuples.'''
    worddict = wordcount(text)
    countlist = []
    for key in worddict.keys():
        countlist.append((key,worddict[key]))
    countlist = list(reversed(sorted(countlist,key = lambda x: x[1])))
    return countlist"
4450,"def add_log_error(self, x, flag_also_show=False, E=None):
        """"""Delegates to parent form""""""
        self.parent_form.add_log_error(x, flag_also_show, E)"
4451,"def add_log(self, x, flag_also_show=False):
        """"""Delegates to parent form""""""
        self.parent_form.add_log(x, flag_also_show)"
4452,"def get_file_md5(filename):
    """"""Get a file's MD5""""""
    if os.path.exists(filename):
        blocksize = 65536
        try:
            hasher = hashlib.md5()
        except BaseException:
            hasher = hashlib.new('md5', usedForSecurity=False)
        with open(filename, 'rb') as afile:
            buf = afile.read(blocksize)
            while len(buf) > 0:  # pylint: disable=len-as-condition
                hasher.update(buf)
                buf = afile.read(blocksize)
        return hasher.hexdigest()

    return ''"
4453,"def get_md5(string):
    """"""Get a string's MD5""""""
    try:
        hasher = hashlib.md5()
    except BaseException:
        hasher = hashlib.new('md5', usedForSecurity=False)
    hasher.update(string)
    return hasher.hexdigest()"
4454,"def deploy_signature(source, dest, user=None, group=None):
    """"""Deploy a signature fole""""""
    move(source, dest)
    os.chmod(dest, 0644)
    if user and group:
        try:
            uid = pwd.getpwnam(user).pw_uid
            gid = grp.getgrnam(group).gr_gid
            os.chown(dest, uid, gid)
        except (KeyError, OSError):
            pass"
4455,"def get_local_version(sigdir, sig):
    """"""Get the local version of a signature""""""
    version = None
    filename = os.path.join(sigdir, '%s.cvd' % sig)
    if os.path.exists(filename):
        cmd = ['sigtool', '-i', filename]
        sigtool = Popen(cmd, stdout=PIPE, stderr=PIPE)
        while True:
            line = sigtool.stdout.readline()
            if line and line.startswith('Version:'):
                version = line.split()[1]
                break
            if not line:
                break
        sigtool.wait()
    return version"
4456,"def verify_sigfile(sigdir, sig):
    """"""Verify a signature file""""""
    cmd = ['sigtool', '-i', '%s/%s.cvd' % (sigdir, sig)]
    sigtool = Popen(cmd, stdout=PIPE, stderr=PIPE)
    ret_val = sigtool.wait()
    return ret_val == 0"
4457,"def check_download(obj, *args, **kwargs):
    """"""Verify a download""""""
    version = args[0]
    workdir = args[1]
    signame = args[2]
    if version:
        local_version = get_local_version(workdir, signame)
        if not verify_sigfile(workdir, signame) or version != local_version:
            error(""[-] \033[91mFailed to verify signature: %s from: %s\033[0m""
                  % (signame, obj.url))
            raise ValueError('Failed to verify signature: %s' % signame)"
4458,"def download_sig(opts, sig, version=None):
    """"""Download signature from hostname""""""
    code = None
    downloaded = False
    useagent = 'ClamAV/0.101.1 (OS: linux-gnu, ARCH: x86_64, CPU: x86_64)'
    manager = PoolManager(
        headers=make_headers(user_agent=useagent),
        cert_reqs='CERT_REQUIRED',
        ca_certs=certifi.where(),
        timeout=Timeout(connect=10.0, read=60.0)
    )
    if version:
        path = '/%s.cvd' % sig
        filename = os.path.join(opts.workdir, '%s.cvd' % sig)
    else:
        path = '/%s.cdiff' % sig
        filename = os.path.join(opts.workdir, '%s.cdiff' % sig)
    try:
        req = manager.request('GET', 'http://%s%s' % (opts.hostname, path))
    except BaseException as msg:
        error(""Request error: %s"" % msg)
    data = req.data
    code = req.status
    if req.status == 200:
        with open(filename, 'w') as handle:
            handle.write(data)
        downloaded = os.path.exists(filename)
    return downloaded, code"
4459,"def get_record(opts):
    """"""Get record""""""
    count = 1
    for passno in range(1, 5):
        count = passno
        info(""[+] \033[92mQuerying TXT record:\033[0m %s pass: %s"" %
             (opts.txtrecord, passno))
        record = get_txt_record(opts.txtrecord)
        if record:
            info(""=> Query returned: %s"" % record)
            break
        else:
            info(""=> Txt record query failed, sleeping 5 secs"")
            time.sleep(5)
    if not record:
        error(""=> Txt record query failed after %d tries"" % count)
        sys.exit(3)
    return record"
4460,"def copy_sig(sig, opts, isdiff):
    """"""Deploy a sig""""""
    info(""[+] \033[92mDeploying signature:\033[0m %s"" % sig)
    if isdiff:
        sourcefile = os.path.join(opts.workdir, '%s.cdiff' % sig)
        destfile = os.path.join(opts.mirrordir, '%s.cdiff' % sig)
    else:
        sourcefile = os.path.join(opts.workdir, '%s.cvd' % sig)
        destfile = os.path.join(opts.mirrordir, '%s.cvd' % sig)
    deploy_signature(sourcefile, destfile, opts.user, opts.group)
    info(""=> Deployed signature: %s"" % sig)"
4461,"def update_sig(queue):
    """"""update signature""""""
    while True:
        options, sign, vers = queue.get()
        info(""[+] \033[92mChecking signature version:\033[0m %s"" % sign)
        localver = get_local_version(options.mirrordir, sign)
        remotever = vers[sign]
        if localver is None or (localver and int(localver) < int(remotever)):
            info(""=> Update required local: %s => remote: %s"" %
                 (localver, remotever))
            info(""=> Downloading signature: %s"" % sign)
            status, code = download_sig(options, sign, remotever)
            if status:
                info(""=> Downloaded signature: %s"" % sign)
                copy_sig(sign, options, 0)
            else:
                if code == 404:
                    error(""=> \033[91mSignature:\033[0m %s not found"" % sign)
                error(""=> \033[91mDownload failed:\033[0m %s code: %d""
                      % (sign, code))
        else:
            info(
                ""=> No update required L: %s => R: %s"" % (localver, remotever))
        queue.task_done()"
4462,"def update_diff(opts, sig):
    """"""Update diff""""""
    for _ in range(1, 6):
        info(""[+] \033[92mDownloading cdiff:\033[0m %s"" % sig)
        status, code = download_sig(opts, sig)
        if status:
            info(""=> Downloaded cdiff: %s"" % sig)
            copy_sig(sig, opts, 1)
        else:
            if code == 404:
                error(""=> \033[91mSignature:\033[0m %s not found"" % sig)
            error(""=> \033[91mDownload failed:\033[0m %s code: %d""
                  % (sig, code))"
4463,"def create_dns_file(opts, record):
    """"""Create the DNS record file""""""
    info(""[+] \033[92mUpdating dns.txt file\033[0m"")
    filename = os.path.join(opts.mirrordir, 'dns.txt')
    localmd5 = get_file_md5(filename)
    remotemd5 = get_md5(record)
    if localmd5 != remotemd5:
        create_file(filename, record)
        info(""=> dns.txt file updated"")
    else:
        info(""=> No update required L: %s => R: %s"" % (localmd5, remotemd5))"
4464,"def download_diffs(queue):
    """"""Download the cdiff files""""""
    while True:
        options, signature_type, localver, remotever = queue.get()
        for num in range(int(localver), int(remotever) + 1):
            sig_diff = '%s-%d' % (signature_type, num)
            filename = os.path.join(options.mirrordir, '%s.cdiff' % sig_diff)
            if not os.path.exists(filename):
                update_diff(options, sig_diff)
        queue.task_done()"
4465,"def work(options):
    """"""The work functions""""""
    # pylint: disable=too-many-locals
    record = get_record(options)
    _, mainv, dailyv, _, _, _, safebrowsingv, bytecodev = record.split(':')
    versions = {'main': mainv, 'daily': dailyv,
                'safebrowsing': safebrowsingv,
                'bytecode': bytecodev}
    dqueue = Queue(maxsize=0)
    dqueue_workers = 3
    info(""[+] \033[92mStarting workers\033[0m"")
    for index in range(dqueue_workers):
        info(""=> Starting diff download worker: %d"" % (index + 1))
        worker = Thread(target=download_diffs, args=(dqueue,))
        worker.setDaemon(True)
        worker.start()
    mqueue = Queue(maxsize=0)
    mqueue_workers = 4
    for index in range(mqueue_workers):
        info(""=> Starting signature download worker: %d"" % (index + 1))
        worker = Thread(target=update_sig, args=(mqueue,))
        worker.setDaemon(True)
        worker.start()
    for signature_type in ['main', 'daily', 'bytecode', 'safebrowsing']:
        if signature_type in ['daily', 'bytecode', 'safebrowsing']:
            # cdiff downloads
            localver = get_local_version(options.mirrordir, signature_type)
            remotever = versions[signature_type]
            if localver is not None:
                dqueue.put(
                    (
                        options,
                        signature_type,
                        localver,
                        remotever
                    )
                )
        mqueue.put((options, signature_type, versions))
    info(""=> Waiting on workers to complete tasks"")
    dqueue.join()
    mqueue.join()
    info(""=> Workers done processing queues"")
    create_dns_file(options, record)
    sys.exit(0)"
4466,"def main():
    """"""Main entry point""""""
    parser = OptionParser()
    parser.add_option('-a', '--hostname',
                      help='ClamAV source server hostname',
                      dest='hostname',
                      type='str',
                      default='db.de.clamav.net')
    parser.add_option('-r', '--text-record',
                      help='ClamAV Updates TXT record',
                      dest='txtrecord',
                      type='str',
                      default='current.cvd.clamav.net')
    parser.add_option('-w', '--work-directory',
                      help='Working directory',
                      dest='workdir',
                      type='str',
                      default='/var/spool/clamav-mirror')
    parser.add_option('-d', '--mirror-directory',
                      help='The mirror directory',
                      dest='mirrordir',
                      type='str',
                      default='/srv/www/clamav')
    parser.add_option('-u', '--user',
                      help='Change file owner to this user',
                      dest='user',
                      type='str',
                      default='nginx')
    parser.add_option('-g', '--group',
                      help='Change file group to this group',
                      dest='group',
                      type='str',
                      default='nginx')
    parser.add_option('-l', '--locks-directory',
                      help='Lock files directory',
                      dest='lockdir',
                      type='str',
                      default='/var/lock/subsys')
    parser.add_option('-v', '--verbose',
                      help='Display verbose output',
                      dest='verbose',
                      action='store_true',
                      default=False)
    options, _ = parser.parse_args()
    try:
        lockfile = os.path.join(options.lockdir, 'clamavmirror')
        with open(lockfile, 'w+') as lock:
            fcntl.lockf(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
            work(options)
    except IOError:
        info(""=> Another instance is already running"")
        sys.exit(254)"
4467,"def copy_resource(src, dest):
    """"""
    To copy package data to destination
    """"""
    package_name = ""yass""
    dest = (dest + ""/"" + os.path.basename(src)).rstrip(""/"")
    if pkg_resources.resource_isdir(package_name, src):
        if not os.path.isdir(dest):
            os.makedirs(dest)
        for res in pkg_resources.resource_listdir(__name__, src):
            copy_resource(src + ""/"" + res, dest)
    else:
        if not os.path.isfile(dest) \
                and os.path.splitext(src)[1] not in ["".pyc""]:
            with open(dest, ""wb"") as f:
                f.write(pkg_resources.resource_string(__name__, src))
        else:
            print(""File exists: %s "" % dest)"
4468,"def publish(endpoint, purge_files, rebuild_manifest, skip_upload):
    """"""Publish the site""""""
    print(""Publishing site to %s ..."" % endpoint.upper())

    yass = Yass(CWD)
    target = endpoint.lower()

    sitename = yass.sitename
    if not sitename:
        raise ValueError(""Missing site name"")

    endpoint = yass.config.get(""hosting.%s"" % target)
    if not endpoint:
        raise ValueError(""%s endpoint is missing in the config"" % target.upper())

    if target == ""s3"":
        p = publisher.S3Website(sitename=sitename,
                                aws_access_key_id=endpoint.get(""aws_access_key_id""),
                                aws_secret_access_key=endpoint.get(""aws_secret_access_key""),
                                region=endpoint.get(""aws_region""))

        if not p.website_exists:
            print("">>>"")
            print(""Setting S3 site..."")
            if p.create_website() is True:
                # Need to give it enough time to create it
                # Should be a one time thing
                time.sleep(10)
                p.create_www_website()
                print(""New bucket created: %s"" % p.sitename)

        if rebuild_manifest:
            print("">>>"")
            print(""Rebuilding site's manifest..."")
            p.create_manifest_from_s3_files()

        if purge_files is True or endpoint.get(""purge_files"") is True:
            print("">>>"")
            print(""Purging files..."")
            exclude_files = endpoint.get(""purge_exclude_files"", [])
            p.purge_files(exclude_files=exclude_files)

        if not skip_upload:
            print("">>>"")
            print(""Uploading your site..."")
            p.upload(yass.build_dir)
        else:
            print("">>>"")
            print(""WARNING: files upload was skipped because of the use of --skip-upload"")

        print("""")
        print(""Yass! Your site has been successfully published to: "")
        print(p.website_endpoint_url)

    footer()"
4469,"def setup_dns(endpoint):
    """"""Setup site domain to route to static site""""""
    print(""Setting up DNS..."")

    yass = Yass(CWD)
    target = endpoint.lower()

    sitename = yass.sitename
    if not sitename:
        raise ValueError(""Missing site name"")

    endpoint = yass.config.get(""hosting.%s"" % target)
    if not endpoint:
        raise ValueError(
            ""%s endpoint is missing in the hosting config"" % target.upper())

    if target == ""s3"":
        p = publisher.S3Website(sitename=sitename,
                                aws_access_key_id=endpoint.get(""aws_access_key_id""),
                                aws_secret_access_key=endpoint.get(""aws_secret_access_key""),
                                region=endpoint.get(""aws_region""))

        print(""Setting AWS Route53 for: %s ..."" % p.sitename)
        p.setup_dns()
        print("""")
        print(""Yass! Route53 setup successfully!"")
        print(""You can now visit the site at :"")
        print(p.sitename_endpoint)
    footer()"
4470,"def create_site(sitename):
    """"""Create a new site directory and init Yass""""""
    sitepath = os.path.join(CWD, sitename)
    if os.path.isdir(sitepath):
        print(""Site directory '%s' exists already!"" % sitename)
    else:
        print(""Creating site: %s..."" % sitename)
        os.makedirs(sitepath)
        copy_resource(""skel/"", sitepath)
        stamp_yass_current_version(sitepath)
        print(""Site created successfully!"")
        print(""CD into '%s' and run 'yass serve' to view the site"" % sitename)

    footer()"
4471,"def init():
    """"""Initialize Yass in the current directory """"""
    yass_conf = os.path.join(CWD, ""yass.yml"")
    if os.path.isfile(yass_conf):
        print(""::ALERT::"")
        print(""It seems like Yass is already initialized here."")
        print(""If it's a mistake, delete 'yass.yml' in this directory"")
    else:
        print(""Init Yass in %s ..."" % CWD)
        copy_resource(""skel/"", CWD)
        stamp_yass_current_version(CWD)
        print(""Yass init successfully!"")
        print(""Run 'yass serve' to view the site"")

    footer()"
4472,"def create_page(pagename):
    """""" Create a new page Omit the extension, it will create it as .jade file """"""
    page = pagename.lstrip(""/"").rstrip(""/"")
    _, _ext = os.path.splitext(pagename)

    # If the file doesn't have an extension, we'll just create one
    if not _ext or _ext == """":
        page += "".jade""

    if not page.endswith(PAGE_FORMAT):
        error(""Can't create '%s'"" % page)
        print(""Invalid filename format"")
        print(""Filename must be in: '%s'"" % "" | "".join(PAGE_FORMAT))
    else:
        engine = Yass(CWD)
        markup = ""jade""
        if page.endswith("".md""):
            markup = ""md""
        if page.endswith("".html""):
            markup = ""html""

        dest_file = os.path.join(engine.pages_dir, page)
        dest_dir = os.path.dirname(dest_file)

        content = TPL_HEADER
        content += TPL_BODY[markup]

        if os.path.isfile(dest_file):
            error(""File exists already"")
            print(""Location: %s"" % dest_file)

        else:
            if not os.path.isdir(dest_dir):
                os.makedirs(dest_dir)
            with open(dest_file, ""w"") as f:
                f.write(content)

            print(""New page created: '%s'"" % page)
            print(""Location: %s"" % dest_file)


    footer()"
4473,"def serve(port, no_livereload, open_url):
    """"""Serve the site """"""

    engine = Yass(CWD)
    if not port:
        port = engine.config.get(""local_server.port"", 8000)
    if no_livereload is None:
        no_livereload = True if engine.config.get(""local_server.livereload"") is False else False
    if open_url is None:
        open_url = False if engine.config.get(""local_server.open_url"") is False else True

    print(""Serving at %s"" % port)
    print(""Livereload is %s"" % (""OFF"" if no_livereload else ""ON""))

    def build_static():
        engine.build_static()

    def build_pages():
        engine.build_pages()

    engine.build()

    server = Server()
    if no_livereload is False:
        server.watch(engine.static_dir + ""/"", build_static)
        server.watch(engine.pages_dir + ""/"", build_pages)
        server.watch(engine.templates_dir + ""/"", build_pages)
        server.watch(engine.data_dir + ""/"", build_pages)

    server.serve(open_url_delay=open_url, port=port, root=engine.build_dir)"
4474,"def get_map_location(self):
        """"""Get the location of the player, converted to world coordinates.

        :return: a tuple (x, y, z).

        """"""
        map_data = self.get_map()
        (bounds_e, bounds_n), (bounds_w, bounds_s) = map_data[""continent_rect""]
        (map_e, map_n), (map_w, map_s) = map_data[""map_rect""]

        assert bounds_w < bounds_e
        assert bounds_n < bounds_s
        assert map_w < map_e
        assert map_n < map_s

        meters_to_inches = 39.3701
        x, y, z = self.fAvatarPosition

        map_x = bounds_w + ((x * meters_to_inches - map_w) /
                            (map_e - map_w) * (bounds_e - bounds_w))
        map_y = bounds_n + ((-z * meters_to_inches - map_n) /
                            (map_s - map_n) * (bounds_s - bounds_n))
        map_z = y * meters_to_inches

        return map_x, map_y, map_z"
4475,"def CreateVertices(self, points):
        """"""
        Returns a dictionary object with keys that are 2tuples
        represnting a point.
        """"""
        gr = digraph()

        for z, x, Q in points:
            node = (z, x, Q)
            gr.add_nodes([node])

        return gr"
4476,"def CreateDirectedEdges(self, points, gr, layer_width):
        """"""
        Take each key (ie. point) in the graph and for that point
        create an edge to every point downstream of it where the weight
        of the edge is the tuple (distance, angle)
        """"""
        for z0, x0, Q0 in points:
            for z1, x1, Q1 in points:
                dz = z1 - z0  # no fabs because we check arrow direction
                if dz > 0.0:  # make sure arrow in right direction
                    if dz - layer_width < distance_threshold:  # only adjacents
                        dx = math.fabs(x1 - x0)

                        if dx > 5 * bar_width:
                            continue

                        # Weights are negative to in order to use shortest path
                        # algorithms on the graph.
                        weight = -1 * math.hypot(dz, dx)

                        edge = ((z0, x0, Q0), (z1, x1, Q1))

                        gr.add_edge(edge, wt=weight)

        # Ensure that it is already transitively reduced
        assert len(critical.transitive_edges(gr)) == 0

        return gr"
4477,"def GetFarthestNode(self, gr, node):
        """"""node is start node""""""
        # Remember: weights are negative
        distance = minmax.shortest_path_bellman_ford(gr, node)[1]

        # Find the farthest node, which is end of track
        min_key = None
        for key, value in distance.iteritems():
            if min_key is None or value < distance[min_key]:
                min_key = key

        return min_key"
4478,"def on_success(self, fn, *args, **kwargs):
        """"""
        Call the given callback if or when the connected deferred succeeds.

        """"""

        self._callbacks.append((fn, args, kwargs))

        result = self._resulted_in
        if result is not _NOTHING_YET:
            self._succeed(result=result)"
4479,"def _succeed(self, result):
        """"""
        Fire the success chain.

        """"""

        for fn, args, kwargs in self._callbacks:
            fn(result, *args, **kwargs)
        self._resulted_in = result"
4480,"def random_name(num_surnames=2):
    """"""
    Returns a random person name

    Arguments:
      num_surnames -- number of surnames
    """"""
    a = []

    # Prefix
    if random.random() < _PROB_PREF:
        a.append(_prefixes[random.randint(0, len(_prefixes) - 1)])

    # Forename
    a.append(_forenames[random.randint(0, len(_forenames) - 1)])

    # Surnames
    for i in range(num_surnames):
        a.append(_surnames[random.randint(0, len(_surnames) - 1)])

    # Suffix
    if random.random() < _PROB_SUFF:
        a.append(_suffixes[random.randint(0, len(_suffixes) - 1)])

    return "" "".join(a)"
4481,"def create_free_shipping_coupon(cls, free_shipping_coupon, **kwargs):
        """"""Create FreeShippingCoupon

        Create a new FreeShippingCoupon
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_free_shipping_coupon(free_shipping_coupon, async=True)
        >>> result = thread.get()

        :param async bool
        :param FreeShippingCoupon free_shipping_coupon: Attributes of freeShippingCoupon to create (required)
        :return: FreeShippingCoupon
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_free_shipping_coupon_with_http_info(free_shipping_coupon, **kwargs)
        else:
            (data) = cls._create_free_shipping_coupon_with_http_info(free_shipping_coupon, **kwargs)
            return data"
4482,"def delete_free_shipping_coupon_by_id(cls, free_shipping_coupon_id, **kwargs):
        """"""Delete FreeShippingCoupon

        Delete an instance of FreeShippingCoupon by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_free_shipping_coupon_by_id(free_shipping_coupon_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str free_shipping_coupon_id: ID of freeShippingCoupon to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_free_shipping_coupon_by_id_with_http_info(free_shipping_coupon_id, **kwargs)
        else:
            (data) = cls._delete_free_shipping_coupon_by_id_with_http_info(free_shipping_coupon_id, **kwargs)
            return data"
4483,"def get_free_shipping_coupon_by_id(cls, free_shipping_coupon_id, **kwargs):
        """"""Find FreeShippingCoupon

        Return single instance of FreeShippingCoupon by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_free_shipping_coupon_by_id(free_shipping_coupon_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str free_shipping_coupon_id: ID of freeShippingCoupon to return (required)
        :return: FreeShippingCoupon
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_free_shipping_coupon_by_id_with_http_info(free_shipping_coupon_id, **kwargs)
        else:
            (data) = cls._get_free_shipping_coupon_by_id_with_http_info(free_shipping_coupon_id, **kwargs)
            return data"
4484,"def list_all_free_shipping_coupons(cls, **kwargs):
        """"""List FreeShippingCoupons

        Return a list of FreeShippingCoupons
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_free_shipping_coupons(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[FreeShippingCoupon]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_free_shipping_coupons_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_free_shipping_coupons_with_http_info(**kwargs)
            return data"
4485,"def replace_free_shipping_coupon_by_id(cls, free_shipping_coupon_id, free_shipping_coupon, **kwargs):
        """"""Replace FreeShippingCoupon

        Replace all attributes of FreeShippingCoupon
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_free_shipping_coupon_by_id(free_shipping_coupon_id, free_shipping_coupon, async=True)
        >>> result = thread.get()

        :param async bool
        :param str free_shipping_coupon_id: ID of freeShippingCoupon to replace (required)
        :param FreeShippingCoupon free_shipping_coupon: Attributes of freeShippingCoupon to replace (required)
        :return: FreeShippingCoupon
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_free_shipping_coupon_by_id_with_http_info(free_shipping_coupon_id, free_shipping_coupon, **kwargs)
        else:
            (data) = cls._replace_free_shipping_coupon_by_id_with_http_info(free_shipping_coupon_id, free_shipping_coupon, **kwargs)
            return data"
4486,"def update_free_shipping_coupon_by_id(cls, free_shipping_coupon_id, free_shipping_coupon, **kwargs):
        """"""Update FreeShippingCoupon

        Update attributes of FreeShippingCoupon
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_free_shipping_coupon_by_id(free_shipping_coupon_id, free_shipping_coupon, async=True)
        >>> result = thread.get()

        :param async bool
        :param str free_shipping_coupon_id: ID of freeShippingCoupon to update. (required)
        :param FreeShippingCoupon free_shipping_coupon: Attributes of freeShippingCoupon to update. (required)
        :return: FreeShippingCoupon
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_free_shipping_coupon_by_id_with_http_info(free_shipping_coupon_id, free_shipping_coupon, **kwargs)
        else:
            (data) = cls._update_free_shipping_coupon_by_id_with_http_info(free_shipping_coupon_id, free_shipping_coupon, **kwargs)
            return data"
4487,"def fetch_config(filename):
    """"""Fetch the Configuration schema information

    Finds the schema file, loads the file and reads the JSON, then converts to a dictionary that is returned
    """"""

    #  This trick gets the directory of *this* file Configuration.py thus
    # allowing to find the schema files relative to this file.
    dir_name = get_source_dir()

    # Append json
    filename = os.path.join('json', filename)

    fileobj = open(os.path.join(dir_name, filename), 'r')
    my_dict = json.loads(fileobj.read())
    return my_dict"
4488,"def populate_args_level(schema, parser):
    """"""Use a schema to populate a command line argument parser""""""
    for key, value in schema['properties'].iteritems():
        if key == 'name':
            continue

        arg = '--%s' % key
        desc = value['description']

        if 'type' in value:
            if value['type'] == 'string':
                if 'enum' in value:
                    parser.add_argument(arg, help=desc, type=str,
                        choices=value['enum'])
                else:
                    parser.add_argument(arg, help=desc, type=str)
            elif value['type'] == 'number':
                parser.add_argument(arg, help=desc, type=float)
            elif value['type'] == 'integer':
                parser.add_argument(arg, help=desc, type=int)
            elif str(value['type']) == 'array':
                assert value['minItems'] == value['maxItems']

                if value['items']['type'] != 'number':
                    raise NotImplementedError(""Only float arrays work"")
                parser.add_argument(arg, help=desc, type=float,
                    nargs=value['maxItems'], metavar='N')
            elif value['type'] == 'object':
                #group = parser.add_argument_group(key, value['description'])
                #populate_args_level(value, group)
                pass"
4489,"def set_json(self, config_json):
        """"""Permanently set the JSON configuration

        Unable to call twice.""""""

        if self.configuration_dict is not None:
            raise RuntimeError(""Can only set configuration once"", self.configuration_dict)

        schema = fetch_config('ConfigurationSchema.json')
        validictory.validate(config_json, schema)

        config_json['name'] = self.name
        config_json['run_number'] = self.run
        config_json['src_dir'] = get_source_dir()
        config_json['data_dir'] = get_data_dir()
        config_json['log_dir'] = get_log_dir()

        self.configuration_dict = config_json"
4490,"def bulk_send(self, topic, kmsgs, timeout=60):
        """""" Send a batch of messages

        :param str topic: a kafka topic
        :param ksr.transport.Message kmsgs: Messages to serialize
        :param int timeout: Timeout in seconds
        :return: Execution result
        :rtype: kser.result.Result
        """"""

        try:
            for kmsg in kmsgs:
                self.client.send(
                    topic, self._onmessage(kmsg).dumps().encode(""UTF-8"")
                )
            self.client.flush(timeout=timeout)
            return Result(stdout=""{} message(s) sent"".format(len(kmsgs)))

        except Exception as exc:
            return Result.from_exception(exc)"
4491,"def send(self, topic, kmsg, timeout=60):
        """""" Send the message into the given topic

        :param str topic: a kafka topic
        :param ksr.transport.Message kmsg: Message to serialize
        :param int timeout: Timeout in seconds (not used in proto producer)
        :return: Execution result
        :rtype: kser.result.Result
        """"""
        result = Result(uuid=kmsg.uuid)
        try:
            self.client.produce(
                topic, self._onmessage(kmsg).dumps().encode(""UTF-8"")
            )
            result.stdout = ""Message {}[{}] sent"".format(
                kmsg.entrypoint, kmsg.uuid
            )
            self.client.flush()

        except Exception as exc:
            result = Result.from_exception(exc, kmsg.uuid)

        finally:
            if result.retcode < 300:
                return self._onsuccess(kmsg=kmsg, result=result)
            else:
                return self._onerror(kmsg=kmsg, result=result)"
4492,"def file_strip_ext(
        afile,
        skip_version=False,
        only_known_extensions=False,
        allow_subformat=True):
    """"""
    Strip in the best way the extension from a filename.

    >>> file_strip_ext(""foo.tar.gz"")
    'foo'
    >>> file_strip_ext(""foo.buz.gz"")
    'foo.buz'
    >>> file_strip_ext(""foo.buz"")
    'foo'
    >>> file_strip_ext(""foo.buz"", only_known_extensions=True)
    'foo.buz'
    >>> file_strip_ext(""foo.buz;1"", skip_version=False,
    ... only_known_extensions=True)
    'foo.buz;1'
    >>> file_strip_ext(""foo.gif;icon"")
    'foo'
    >>> file_strip_ext(""foo.gif;icon"", only_know_extensions=True,
    ... allow_subformat=False)
    'foo.gif;icon'

    @param afile: the path/name of a file.
    @type afile: string
    @param skip_version: whether to skip a trailing "";version"".
    @type skip_version: bool
    @param only_known_extensions: whether to strip out only known extensions or
        to consider as extension anything that follows a dot.
    @type only_known_extensions: bool
    @param allow_subformat: whether to consider also subformats as part of
        the extension.
    @type allow_subformat: bool
    @return: the name/path without the extension (and version).
    @rtype: string
    """"""
    import os
    afile = afile.split(';')
    if len(afile) > 1 and allow_subformat and not afile[-1].isdigit():
        afile = afile[0:-1]
    if len(afile) > 1 and skip_version and afile[-1].isdigit():
        afile = afile[0:-1]
    afile = ';'.join(afile)
    nextfile = _extensions.sub('', afile)
    if nextfile == afile and not only_known_extensions:
        nextfile = os.path.splitext(afile)[0]
    while nextfile != afile:
        afile = nextfile
        nextfile = _extensions.sub('', afile)
    return nextfile"
4493,"def guess_extension(amimetype, normalize=False):
    """"""
    Tries to guess extension for a mimetype.

    @param amimetype: name of a mimetype
    @time amimetype: string
    @return: the extension
    @rtype: string
    """"""
    ext = _mimes.guess_extension(amimetype)
    if ext and normalize:
        # Normalize some common magic mis-interpreation
        ext = {'.asc': '.txt', '.obj': '.bin'}.get(ext, ext)
        from invenio.legacy.bibdocfile.api_normalizer import normalize_format
        return normalize_format(ext)
    return ext"
4494,"def get_magic_guesses(fullpath):
    """"""
    Return all the possible guesses from the magic library about
    the content of the file.

    @param fullpath: location of the file
    @type fullpath: string
    @return: guesses about content of the file
    @rtype: tuple
    """"""
    if CFG_HAS_MAGIC == 1:
        magic_cookies = _get_magic_cookies()
        magic_result = []
        for key in magic_cookies.keys():
            magic_result.append(magic_cookies[key].file(fullpath))
        return tuple(magic_result)
    elif CFG_HAS_MAGIC == 2:
        magic_result = []
        for key in ({'mime': False, 'mime_encoding': False},
                    {'mime': True, 'mime_encoding': False},
                    {'mime': False, 'mime_encoding': True}):
            magic_result.append(_magic_wrapper(fullpath, **key))
        return tuple(magic_result)"
4495,"def mimes(self):
        """"""
        Returns extended MimeTypes.
        """"""
        _mimes = MimeTypes(strict=False)
        _mimes.suffix_map.update({'.tbz2': '.tar.bz2'})
        _mimes.encodings_map.update({'.bz2': 'bzip2'})

        if cfg['CFG_BIBDOCFILE_ADDITIONAL_KNOWN_MIMETYPES']:
            for key, value in iteritems(
                    cfg['CFG_BIBDOCFILE_ADDITIONAL_KNOWN_MIMETYPES']):
                _mimes.add_type(key, value)
                del key, value

        return _mimes"
4496,"def extensions(self):
        """"""
        Generate the regular expression to match all the known extensions.

        @return: the regular expression.
        @rtype: regular expression object
        """"""
        _tmp_extensions = self.mimes.encodings_map.keys() + \
            self.mimes.suffix_map.keys() + \
            self.mimes.types_map[1].keys() + \
            cfg['CFG_BIBDOCFILE_ADDITIONAL_KNOWN_FILE_EXTENSIONS']
        extensions = []
        for ext in _tmp_extensions:
            if ext.startswith('.'):
                extensions.append(ext)
            else:
                extensions.append('.' + ext)
        extensions.sort()
        extensions.reverse()
        extensions = set([ext.lower() for ext in extensions])
        extensions = '\\' + '$|\\'.join(extensions) + '$'
        extensions = extensions.replace('+', '\\+')
        return re.compile(extensions, re.I)"
4497,"def __deserialize(self, data, klass):
        """"""Deserializes dict, list, str into an object.

        :param data: dict, list or str.
        :param klass: class literal, or string of class name.

        :return: object.
        """"""
        if data is None:
            return None

        if type(klass) == str:
            from tradenity.resources.paging import Page
            if klass.startswith('page['):
                sub_kls = re.match('page\[(.*)\]', klass).group(1)
                return Page([self.__deserialize(sub_data, sub_kls)
                            for sub_data in data[""items""]], self.__deserialize_page_info(data[""__meta""]))
            if klass.startswith('list['):
                sub_kls = re.match('list\[(.*)\]', klass).group(1)
                return [self.__deserialize(sub_data, sub_kls)
                        for sub_data in data]

            if klass.startswith('dict('):
                sub_kls = re.match('dict\(([^,]*), (.*)\)', klass).group(2)
                return {k: self.__deserialize(v, sub_kls)
                        for k, v in six.iteritems(data)}

            # convert str to class
            if klass in self.NATIVE_TYPES_MAPPING:
                klass = self.NATIVE_TYPES_MAPPING[klass]
            else:
                klass = getattr(tradenity.resources, klass)

        if klass in self.PRIMITIVE_TYPES:
            return self.__deserialize_primitive(data, klass)
        elif klass == object:
            return self.__deserialize_object(data)
        elif klass == datetime.date:
            return self.__deserialize_date(data)
        elif klass == datetime.datetime:
            return self.__deserialize_datatime(data)
        else:
            return self.__deserialize_model(data, klass)"
4498,"def update_params_for_auth(self, headers, querys, auth_settings):
        """"""Updates header and query params based on authentication setting.

        :param headers: Header parameters dict to be updated.
        :param querys: Query parameters tuple list to be updated.
        :param auth_settings: Authentication setting identifiers list.
        """"""
        if self.auth_token_holder.token is not None:
            headers[Configuration.AUTH_TOKEN_HEADER_NAME] = self.auth_token_holder.token
        else:
            headers['Authorization'] = self.configuration.get_basic_auth_token()"
4499,"def start(self, service):
        """"""
        Start the service, catching and logging exceptions
        """"""
        try:
            map(self.start_class, service.depends)
            if service.is_running():
                return
            if service in self.failed:
                log.warning(""%s previously failed to start"", service)
                return
            service.start()
        except Exception:
            log.exception(""Unable to start service %s"", service)
            self.failed.add(service)"
4500,"def start_class(self, class_):
        """"""
        Start all services of a given class. If this manager doesn't already
        have a service of that class, it constructs one and starts it.
        """"""
        matches = filter(lambda svc: isinstance(svc, class_), self)
        if not matches:
            svc = class_()
            self.register(svc)
            matches = [svc]
        map(self.start, matches)
        return matches"
4501,"def stop_class(self, class_):
        ""Stop all services of a given class""
        matches = filter(lambda svc: isinstance(svc, class_), self)
        map(self.stop, matches)"
4502,"def log_root(self):
        """"""
        Find a directory suitable for writing log files. It uses sys.prefix
        to use a path relative to the root. If sys.prefix is /usr, it's the
        system Python, so use /var/log.
        """"""
        var_log = (
            os.path.join(sys.prefix, 'var', 'log')
            .replace('/usr/var', '/var')
        )
        if not os.path.isdir(var_log):
            os.makedirs(var_log)
        return var_log"
4503,"def _get_more_data(self, file, timeout):
        """"""
        Return data from the file, if available. If no data is received
        by the timeout, then raise RuntimeError.
        """"""
        timeout = datetime.timedelta(seconds=timeout)
        timer = Stopwatch()
        while timer.split() < timeout:
            data = file.read()
            if data:
                return data
        raise RuntimeError(""Timeout"")"
4504,"def _run_env(self):
        """"""
        Augment the current environment providing the PYTHONUSERBASE.
        """"""
        env = dict(os.environ)
        env.update(
            getattr(self, 'env', {}),
            PYTHONUSERBASE=self.env_path,
            PIP_USER=""1"",
        )
        self._disable_venv(env)
        return env"
4505,"def _disable_venv(self, env):
        """"""
        Disable virtualenv and venv in the environment.
        """"""
        venv = env.pop('VIRTUAL_ENV', None)
        if venv:
            venv_path, sep, env['PATH'] = env['PATH'].partition(os.pathsep)"
4506,"def create_env(self):
        """"""
        Create a PEP-370 environment
        """"""
        root = path.Path(os.environ.get('SERVICES_ROOT', 'services'))
        self.env_path = (root / self.name).abspath()
        cmd = [
            self.python,
            '-c', 'import site; print(site.getusersitepackages())',
        ]
        out = subprocess.check_output(cmd, env=self._run_env)
        site_packages = out.decode().strip()
        path.Path(site_packages).makedirs_p()"
4507,"def create_states_geo_zone(cls, states_geo_zone, **kwargs):
        """"""Create StatesGeoZone

        Create a new StatesGeoZone
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_states_geo_zone(states_geo_zone, async=True)
        >>> result = thread.get()

        :param async bool
        :param StatesGeoZone states_geo_zone: Attributes of statesGeoZone to create (required)
        :return: StatesGeoZone
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_states_geo_zone_with_http_info(states_geo_zone, **kwargs)
        else:
            (data) = cls._create_states_geo_zone_with_http_info(states_geo_zone, **kwargs)
            return data"
4508,"def delete_states_geo_zone_by_id(cls, states_geo_zone_id, **kwargs):
        """"""Delete StatesGeoZone

        Delete an instance of StatesGeoZone by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_states_geo_zone_by_id(states_geo_zone_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str states_geo_zone_id: ID of statesGeoZone to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_states_geo_zone_by_id_with_http_info(states_geo_zone_id, **kwargs)
        else:
            (data) = cls._delete_states_geo_zone_by_id_with_http_info(states_geo_zone_id, **kwargs)
            return data"
4509,"def get_states_geo_zone_by_id(cls, states_geo_zone_id, **kwargs):
        """"""Find StatesGeoZone

        Return single instance of StatesGeoZone by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_states_geo_zone_by_id(states_geo_zone_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str states_geo_zone_id: ID of statesGeoZone to return (required)
        :return: StatesGeoZone
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_states_geo_zone_by_id_with_http_info(states_geo_zone_id, **kwargs)
        else:
            (data) = cls._get_states_geo_zone_by_id_with_http_info(states_geo_zone_id, **kwargs)
            return data"
4510,"def list_all_states_geo_zones(cls, **kwargs):
        """"""List StatesGeoZones

        Return a list of StatesGeoZones
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_states_geo_zones(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[StatesGeoZone]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_states_geo_zones_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_states_geo_zones_with_http_info(**kwargs)
            return data"
4511,"def replace_states_geo_zone_by_id(cls, states_geo_zone_id, states_geo_zone, **kwargs):
        """"""Replace StatesGeoZone

        Replace all attributes of StatesGeoZone
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_states_geo_zone_by_id(states_geo_zone_id, states_geo_zone, async=True)
        >>> result = thread.get()

        :param async bool
        :param str states_geo_zone_id: ID of statesGeoZone to replace (required)
        :param StatesGeoZone states_geo_zone: Attributes of statesGeoZone to replace (required)
        :return: StatesGeoZone
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_states_geo_zone_by_id_with_http_info(states_geo_zone_id, states_geo_zone, **kwargs)
        else:
            (data) = cls._replace_states_geo_zone_by_id_with_http_info(states_geo_zone_id, states_geo_zone, **kwargs)
            return data"
4512,"def update_states_geo_zone_by_id(cls, states_geo_zone_id, states_geo_zone, **kwargs):
        """"""Update StatesGeoZone

        Update attributes of StatesGeoZone
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_states_geo_zone_by_id(states_geo_zone_id, states_geo_zone, async=True)
        >>> result = thread.get()

        :param async bool
        :param str states_geo_zone_id: ID of statesGeoZone to update. (required)
        :param StatesGeoZone states_geo_zone: Attributes of statesGeoZone to update. (required)
        :return: StatesGeoZone
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_states_geo_zone_by_id_with_http_info(states_geo_zone_id, states_geo_zone, **kwargs)
        else:
            (data) = cls._update_states_geo_zone_by_id_with_http_info(states_geo_zone_id, states_geo_zone, **kwargs)
            return data"
4513,"def compaction(self, request_compaction=False):
        """"""Retrieve a report on, or request compaction for this instance.

        :param bool request_compaction: A boolean indicating whether or not to request compaction.
        """"""
        url = self._service_url + 'compaction/'

        if request_compaction:
            response = requests.post(url, **self._instances._default_request_kwargs)
        else:
            response = requests.get(url, **self._instances._default_request_kwargs)

        return response.json()"
4514,"def get_authenticated_connection(self, user, passwd, db='admin', ssl=True):
        """"""Get an authenticated connection to this instance.

        :param str user: The username to use for authentication.
        :param str passwd: The password to use for authentication.
        :param str db: The name of the database to authenticate against. Defaults to ``'Admin'``.
        :param bool ssl: Use SSL/TLS if available for this instance. Defaults to ``True``.
        :raises: :py:class:`pymongo.errors.OperationFailure` if authentication fails.
        """"""
        # Attempt to establish an authenticated connection.
        try:
            connection = self.get_connection(ssl=ssl)
            connection[db].authenticate(user, passwd)
            return connection

        # Catch exception here for logging, then just re-raise.
        except pymongo.errors.OperationFailure as ex:
            logger.exception(ex)
            raise"
4515,"def shards(self, add_shard=False):
        """"""Get a list of shards belonging to this instance.

        :param bool add_shard: A boolean indicating whether to add a new shard to the specified
            instance.
        """"""
        url = self._service_url + 'shards/'
        if add_shard:
            response = requests.post(url, **self._instances._default_request_kwargs)
        else:
            response = requests.get(url, **self._instances._default_request_kwargs)

        return response.json()"
4516,"def new_relic_stats(self):
        """"""
        Get stats for this instance.
        """"""
        if self._new_relic_stats is None:
            # if this is a sharded instance, fetch shard stats in parallel
            if self.type == 'mongodb_sharded':
                shards = [Shard(self.name, self._service_url + 'shards/',
                                self._client, shard_doc)
                          for shard_doc in self.shards().get('data')]
                fs = []
                with futures.ThreadPoolExecutor(len(shards)) as executor:
                    for shard in shards:
                        fs.append(executor.submit(shard.get_shard_stats))
                    futures.wait(fs, timeout=None, return_when=futures.ALL_COMPLETED)
                stats_this_second = self._rollup_shard_stats_to_instance_stats(
                    {shard.name: future.result() for (shard, future) in zip(shards, fs)})
                # power nap
                time.sleep(1)
                # fetch again
                fs = []
                with futures.ThreadPoolExecutor(len(shards)) as executor:
                    for shard in shards:
                        fs.append(executor.submit(shard.get_shard_stats))
                    futures.wait(fs, timeout=None, return_when=futures.ALL_COMPLETED)
                stats_next_second = self._rollup_shard_stats_to_instance_stats(
                    {shard.name: future.result() for (shard, future) in zip(shards, fs)})
                self._new_relic_stats = self._compile_new_relic_stats(stats_this_second, stats_next_second)
            else:
                # fetch stats like we did before (by hitting new_relic_stats API resource)
                response = requests.get('{}{}'.format(self._url,
                                        'new-relic-stats'),
                                        **self._instances._default_request_kwargs)
                self._new_relic_stats = json.loads(response.content).get(
                    'data') if response.status_code == 200 else {}
        return self._new_relic_stats"
4517,"def _rollup_shard_stats_to_instance_stats(self, shard_stats):
        """"""
        roll up all shard stats to instance level stats

        :param shard_stats: dict of {shard_name: shard level stats}
        """"""
        instance_stats = {}
        opcounters_per_node = []

        # aggregate replication_lag
        instance_stats['replication_lag'] = max(map(lambda s: s['replication_lag'], shard_stats.values()))

        aggregate_server_statistics = {}
        for shard_name, stats in shard_stats.items():
            for statistic_key in stats.get('shard_stats'):
                if statistic_key != 'connections' and statistic_key in aggregate_server_statistics:
                    aggregate_server_statistics[statistic_key] = util.sum_values(aggregate_server_statistics[statistic_key],
                                                                                 stats.get('shard_stats')[statistic_key])
                else:
                    aggregate_server_statistics[statistic_key] = stats.get('shard_stats')[statistic_key]

            # aggregate per_node_stats into opcounters_per_node
            opcounters_per_node.append({shard_name: {member: node_stats['opcounters']
                                                     for member, node_stats in stats.get('per_node_stats').items()}})

        instance_stats['opcounters_per_node'] = opcounters_per_node
        instance_stats['aggregate_server_statistics'] = aggregate_server_statistics
        return instance_stats"
4518,"def _compile_new_relic_stats(self, stats_this_second, stats_next_second):
        """"""
        from instance 'stats_this_second' and instance 'stats_next_second', compute some per
        second stats metrics and other aggregated metrics

        :param dict stats_this_second:
        :param dict stats_next_second:
        :return: compiled instance stats that has metrics

        {'opcounters_per_node_per_second': {...},
         'server_statistics_per_second': {...},
         'aggregate_server_statistics': {...},
         'replication_lag': 0.0,
         'aggregate_database_statistics': {}
         }
        """"""
        server_statistics_per_second = {}
        opcounters_per_node_per_second = []
        for subdoc in [""opcounters"", ""network""]:
            first_doc = stats_this_second['aggregate_server_statistics'][subdoc]
            second_doc = stats_next_second['aggregate_server_statistics'][subdoc]
            keys = set(first_doc.keys()) | set(second_doc.keys())
            server_statistics_per_second[subdoc] = {key: int(second_doc[key]) - int(first_doc[key]) for key in keys if isinstance(first_doc[key], int)}
        for node1, node2 in zip(stats_this_second['opcounters_per_node'], stats_next_second['opcounters_per_node']):
            node_opcounters_per_second = {}
            for repl, members in node2.items():
                node_opcounters_per_second[repl] = {}
                for member, ops in members.items():
                    node_opcounters_per_second[repl][member] = {}
                    for op, count in ops.items():
                        node_opcounters_per_second[repl][member][op] = count - node1[repl][member][op]
            opcounters_per_node_per_second.append(node_opcounters_per_second)

        return {'opcounters_per_node_per_second': opcounters_per_node_per_second,
                'server_statistics_per_second': server_statistics_per_second,
                'aggregate_server_statistics': stats_next_second.get('aggregate_server_statistics'),
                'replication_lag': stats_next_second.get('replication_lag'),
                'aggregate_database_statistics': self.get_aggregate_database_stats()}"
4519,"def get_stepdown_window(self):
        """"""Get information on this instance's stepdown window.""""""
        url = self._service_url + 'stepdown/'
        response = requests.get(url, **self._instances._default_request_kwargs)
        return response.json()"
4520,"def set_stepdown_window(self, start, end, enabled=True, scheduled=True, weekly=True):
        """"""Set the stepdown window for this instance.

        Date times are assumed to be UTC, so use UTC date times.

        :param datetime.datetime start: The datetime which the stepdown window is to open.
        :param datetime.datetime end: The datetime which the stepdown window is to close.
        :param bool enabled: A boolean indicating whether or not stepdown is to be enabled.
        :param bool scheduled: A boolean indicating whether or not to schedule stepdown.
        :param bool weekly: A boolean indicating whether or not to schedule compaction weekly.
        """"""
        # Ensure a logical start and endtime is requested.
        if not start < end:
            raise TypeError('Parameter ""start"" must occur earlier in time than ""end"".')

        # Ensure specified window is less than a week in length.
        week_delta = datetime.timedelta(days=7)
        if not ((end - start) <= week_delta):
            raise TypeError('Stepdown windows can not be longer than 1 week in length.')

        url = self._service_url + 'stepdown/'
        data = {
            'start': int(start.strftime('%s')),
            'end': int(end.strftime('%s')),
            'enabled': enabled,
            'scheduled': scheduled,
            'weekly': weekly,
        }

        response = requests.post(
            url,
            data=json.dumps(data),
            **self._instances._default_request_kwargs
        )
        return response.json()"
4521,"def _get_connection(self, ssl):
        """"""Get a live connection to this instance.""""""

        # Use SSL/TLS if requested and available.
        connect_string = self.connect_string
        if ssl and self.ssl_connect_string:
            connect_string = self.ssl_connect_string

        return pymongo.MongoClient(connect_string)"
4522,"def get_shard_stats(self):
        """"""
        :return: get stats for this mongodb shard
        """"""
        return requests.get(self._stats_url, params={'include_stats': True},
                            headers={'X-Auth-Token': self._client.auth._token}
                            ).json()['data']['stats']"
4523,"def brand(self, brand):
        """"""Sets the brand of this PaymentCard.


        :param brand: The brand of this PaymentCard.
        :type: str
        """"""
        allowed_values = [""visa"", ""mastercard"", ""americanExpress"", ""discover""]
        if brand is not None and brand not in allowed_values:
            raise ValueError(
                ""Invalid value for `brand` ({0}), must be one of {1}""
                .format(brand, allowed_values)
            )

        self._brand = brand"
4524,"def create_payment_card(cls, payment_card, **kwargs):
        """"""Create PaymentCard

        Create a new PaymentCard
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_payment_card(payment_card, async=True)
        >>> result = thread.get()

        :param async bool
        :param PaymentCard payment_card: Attributes of paymentCard to create (required)
        :return: PaymentCard
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_payment_card_with_http_info(payment_card, **kwargs)
        else:
            (data) = cls._create_payment_card_with_http_info(payment_card, **kwargs)
            return data"
4525,"def delete_payment_card_by_id(cls, payment_card_id, **kwargs):
        """"""Delete PaymentCard

        Delete an instance of PaymentCard by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_payment_card_by_id(payment_card_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str payment_card_id: ID of paymentCard to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_payment_card_by_id_with_http_info(payment_card_id, **kwargs)
        else:
            (data) = cls._delete_payment_card_by_id_with_http_info(payment_card_id, **kwargs)
            return data"
4526,"def get_payment_card_by_id(cls, payment_card_id, **kwargs):
        """"""Find PaymentCard

        Return single instance of PaymentCard by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_payment_card_by_id(payment_card_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str payment_card_id: ID of paymentCard to return (required)
        :return: PaymentCard
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_payment_card_by_id_with_http_info(payment_card_id, **kwargs)
        else:
            (data) = cls._get_payment_card_by_id_with_http_info(payment_card_id, **kwargs)
            return data"
4527,"def list_all_payment_cards(cls, **kwargs):
        """"""List PaymentCards

        Return a list of PaymentCards
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_payment_cards(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[PaymentCard]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_payment_cards_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_payment_cards_with_http_info(**kwargs)
            return data"
4528,"def replace_payment_card_by_id(cls, payment_card_id, payment_card, **kwargs):
        """"""Replace PaymentCard

        Replace all attributes of PaymentCard
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_payment_card_by_id(payment_card_id, payment_card, async=True)
        >>> result = thread.get()

        :param async bool
        :param str payment_card_id: ID of paymentCard to replace (required)
        :param PaymentCard payment_card: Attributes of paymentCard to replace (required)
        :return: PaymentCard
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_payment_card_by_id_with_http_info(payment_card_id, payment_card, **kwargs)
        else:
            (data) = cls._replace_payment_card_by_id_with_http_info(payment_card_id, payment_card, **kwargs)
            return data"
4529,"def update_payment_card_by_id(cls, payment_card_id, payment_card, **kwargs):
        """"""Update PaymentCard

        Update attributes of PaymentCard
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_payment_card_by_id(payment_card_id, payment_card, async=True)
        >>> result = thread.get()

        :param async bool
        :param str payment_card_id: ID of paymentCard to update. (required)
        :param PaymentCard payment_card: Attributes of paymentCard to update. (required)
        :return: PaymentCard
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_payment_card_by_id_with_http_info(payment_card_id, payment_card, **kwargs)
        else:
            (data) = cls._update_payment_card_by_id_with_http_info(payment_card_id, payment_card, **kwargs)
            return data"
4530,"def rec2csv(r, filename):
    """"""Export a recarray *r* to a CSV file *filename*""""""
    names = r.dtype.names
    def translate(x):
        if x is None or str(x).lower == ""none"":
            x = """"
        return str(x)
    with open(filename, ""w"") as csv:
        csv.write("","".join([str(x) for x in names])+""\n"")
        for data in r:
            csv.write("","".join([translate(x) for x in data])+""\n"")
    #print ""Wrote CSV table %r"" % filename
    return filename"
4531,"def latex_quote(s):
    """"""Quote special characters for LaTeX.

    (Incomplete, currently only deals with underscores, dollar and hash.)
    """"""
    special = {'_':r'\_', '$':r'\$', '#':r'\#'}
    s = str(s)
    for char,repl in special.items():
        new = s.replace(char, repl)
        s = new[:]
    return s"
4532,"def rec2latex(r, filename, empty=""""):
    """"""Export a recarray *r* to a LaTeX  table in *filename*""""""
    with open(filename, ""w"") as latex:
        latex.write(s_rec2latex(r, empty=empty))
    return filename"
4533,"def s_rec2latex(r, empty=""""):
    """"""Export a recarray *r* to a LaTeX  table in a string""""""
    latex = """"
    names = r.dtype.names
    def translate(x):
        if x is None or str(x).lower == ""none"":
            x = empty
        return latex_quote(x)
    latex += r""\begin{tabular}{%s}"" % ("""".join([""c""]*len(names)),) + ""\n""  # simple c columns
    latex += r""\hline""+""\n""
    latex += "" & "".join([latex_quote(x) for x in names])+r""\\""+""\n""
    latex += r""\hline""+""\n""
    for data in r:
        latex += "" & "".join([translate(x) for x in data])+r""\\""+""\n""
    latex += r""\hline""+""\n""
    latex += r""\end{tabular}""+""\n""
    return latex"
4534,"def on(self, type):
        '''Decorator function'''
        def decorator(self, func):
            '''decorated functions should be written as class methods
                @on('join')
                def on_join(self, channel):
                    print(""Joined channel %s"" % channel)
            '''
            self._handlers[type].append(func)
            return func

        return decorator"
4535,"def tree_to_file(tree:'BubbleTree', outfile:str):
    """"""Compute the bubble representation of given power graph,
    and push it into given file.""""""
    with open(outfile, 'w') as fd:
        fd.write(tree_to_bubble(tree))"
4536,"def lines_from_tree(tree, nodes_and_set:bool=False) -> iter:
    """"""Yield lines of bubble describing given BubbleTree""""""
    NODE = 'NODE\t{}'
    INCL = 'IN\t{}\t{}'
    EDGE = 'EDGE\t{}\t{}\t1.0'
    SET  = 'SET\t{}'

    if nodes_and_set:
        for node in tree.nodes():
            yield NODE.format(node)

        for node in tree.powernodes():
            yield SET.format(node)

    for node, includeds in tree.inclusions.items():
        for included in includeds:
            yield INCL.format(included, node)

    for node, succs in tree.edges.items():
        for succ in succs:
            yield EDGE.format(node, succ)"
4537,"def to_python(self):
        """"""The string ``'True'`` (case insensitive) will be converted
        to ``True``, as will any positive integers.

        """"""
        if isinstance(self.data, str):
            return self.data.strip().lower() == 'true'
        if isinstance(self.data, int):
            return self.data > 0
        return bool(self.data)"
4538,"def to_python(self):
        '''A :class:`datetime.datetime` object is returned.'''

        if self.data is None:
            return None

        # don't parse data that is already native
        if isinstance(self.data, datetime.datetime):
            return self.data
        elif self.use_int:
            return datetime.datetime.utcfromtimestamp(self.data / 1000)
        elif self.format is None:
            # parse as iso8601
            return PySO8601.parse(self.data)
        else:
            return datetime.datetime.strptime(self.data, self.format)"
4539,"def get_api_call_headers(app):
    """"""
    Генерирует заголовки для API запроса.
    Тут же подкладывается авторизация

    :type app: metasdk.MetaApp
    """"""
    headers = {
        ""content-type"": ""application/json;charset=UTF-8"",
        ""User-Agent"": app.user_agent,
    }
    if not app.developer_settings:
        raise AuthError({""message"": ""Для корректной работы SDK нужно установить настройки разработчика"", ""url"": ""https://apps.devision.io/page?a=63&p=3975""})
    headers.update(app.developer_settings.get('api_headers'))
    return headers"
4540,"def extract_filename_from_url(log, url):
    """"""
    *get the filename from a URL.*

    *Will return 'untitled.html', if no filename is found.*

    **Key Arguments:**
        - ``url`` -- the url to extract filename from

    Returns:
        - ``filename`` -- the filename

    **Usage:**
        .. code-block:: python 

            from fundamentals.download import extract_filename_from_url
            name = extract_filename_from_url(
                log=log,
                url=""https://en.wikipedia.org/wiki/Docstring""
            )
            print name
            # OUT: Docstring.html
    """"""
    ## > IMPORTS ##
    import re
    # EXTRACT THE FILENAME FROM THE URL
    try:
        log.debug(""extracting filename from url "" + url)
        reEoURL = re.compile('([\w\.]*)$')
        filename = reEoURL.findall(url)[0]
        # log.debug(filename)
        if(len(filename) == 0):
            filename = 'untitled.html'
        if not (re.search('\.', filename)):
            filename = filename + '.html'
    except Exception as e:
        filename = None
        # print url
        log.warning(""could not extracting filename from url : "" + str(e) + ""\n"")

    return filename"
4541,"def build_from_developer_settings(api_name: str, api_version: str):
        """"""
        :param api_name: Example hello
        :param api_version: Example v1, v2alpha
        :return: ApiClient
        """"""
        developer_settings = read_developer_settings()

        api_host = ""http://"" + api_name + "".apis.devision.io""
        return ApiClient(
            host=api_host,
            api_version=api_version,
            access_token=None,
            refresh_token=developer_settings['refreshToken'],
            client_id=developer_settings['clientId'],
            client_secret=developer_settings['clientSecret'],
        )"
4542,"def process_formdata(self, valuelist):
        """"""Join time string.""""""
        if valuelist:
            time_str = u' '.join(valuelist)
            try:
                timetuple = time.strptime(time_str, self.format)
                self.data = datetime.time(*timetuple[3:6])
            except ValueError:
                self.data = None
                raise"
4543,"def validate_csrf_token(self, field):
        """"""Disable CRSF proection during testing.""""""
        if current_app.testing:
            return
        super(InvenioBaseForm, self).validate_csrf_token(field)"
4544,"def load_exchange_word_vectors(
    filename                 = ""database.db"",
    maximum_number_of_events = None
    ):
    """"""
    Load exchange data and return dataset.
    """"""
    log.info(""load word vectors of database {filename}"".format(
        filename = filename
    ))
    # Ensure that the database exists.
    if not os.path.isfile(filename):
        log.info(""database {filename} nonexistent"".format(
            filename = filename
        ))
        program.terminate()
        raise Exception
    # Access the database.
    database = access_database(filename = filename)
    # Access or create the exchanges table.
    table_exchanges = database[""exchanges""]
    # Access exchanges.
    table_name = ""exchanges""
    # Create a datavision dataset.
    data = datavision.Dataset()
    # progress
    progress = shijian.Progress()
    progress.engage_quick_calculation_mode()
    number_of_entries = len(database[table_name])
    index = 0
    for index_entry, entry in enumerate(database[table_name].all()):
        if maximum_number_of_events is not None and\
            index >= int(maximum_number_of_events):
            log.info(
                ""loaded maximum requested number of events "" +
                ""({maximum_number_of_events})\r"".format(
                    maximum_number_of_events = maximum_number_of_events
                )
            )
            break
        #unique_identifier = str(entry[""id""])
        utteranceWordVector = str(entry[""utteranceWordVector""])
        responseWordVector = str(entry[""responseWordVector""])
        if utteranceWordVector != ""None"" and responseWordVector != ""None"":
            index += 1

            utteranceWordVector = eval(""np."" + utteranceWordVector.replace(""float32"", ""np.float32""))
            responseWordVector  = eval(""np."" + responseWordVector.replace(""float32"", ""np.float32""))
            data.variable(index = index, name = ""utteranceWordVector"", value = utteranceWordVector)
            data.variable(index = index, name = ""responseWordVector"",  value = responseWordVector )

            #utteranceWordVector = list(eval(""np."" + utteranceWordVector.replace(""float32"", ""np.float32"")))
            #responseWordVector  = list(eval(""np."" + responseWordVector.replace(""float32"", ""np.float32"")))
            #for index_component, component in enumerate(utteranceWordVector):
            #    data.variable(index = index, name = ""uwv"" + str(index_component), value = component)
            #for index_component, component in enumerate(responseWordVector):
            #    data.variable(index = index, name = ""rwv"" + str(index_component), value = component)

        print progress.add_datum(fraction = index_entry / number_of_entries),
    return data"
4545,"def access_SUSY_dataset_format_file(filename):
    """"""
    This function accesses a CSV file containing data of the form of the [SUSY
    dataset](https://archive.ics.uci.edu/ml/datasets/SUSY), i.e. with the first
    column being class labels and other columns being features.
    """"""
    # Load the CSV file to a list.
    with open(filename, ""rb"") as dataset_file:
        dataset_CSV = [row for row in csv.reader(dataset_file, delimiter = "","")]
        # Reorganise the data.
        return [
            i for i in itertools.chain(*[list((element[1:],
            [int(float(element[0]))])) for element in dataset_CSV])
        ]"
4546,"def load_HEP_data(
    ROOT_filename            = ""output.root"",
    tree_name                = ""nominal"",
    maximum_number_of_events = None
    ):
    """"""
    Load HEP data and return dataset.
    """"""
    ROOT_file        = open_ROOT_file(ROOT_filename)
    tree             = ROOT_file.Get(tree_name)
    number_of_events = tree.GetEntries()
    data             = datavision.Dataset()

    progress = shijian.Progress()
    progress.engage_quick_calculation_mode()
    # counters
    number_of_events_loaded = 0

    log.info("""")

    index = 0
    for event in tree:

        if maximum_number_of_events is not None and\
            number_of_events_loaded >= int(maximum_number_of_events):
            log.info(
                ""loaded maximum requested number of events "" +
                ""({maximum_number_of_events})\r"".format(
                    maximum_number_of_events = maximum_number_of_events
                )
            )
            break
        print progress.add_datum(fraction = (index + 2) / number_of_events),

        if select_event(event):
            index += 1
            #event.GetReadEntry()
            #data.variable(index = index, name = ""eventNumber"",        value = event.eventNumber)
            data.variable(index = index, name = ""el_1_pt"",            value = event.el_pt[0])
            #data.variable(index = index, name = ""el_1_eta"",           value = event.el_eta[0])
            #data.variable(index = index, name = ""el_1_phi"",           value = event.el_phi[0])
            ##data.variable(index = index, name = ""jet_1_pt"",           value = event.jet_pt[0])
            #data.variable(index = index, name = ""jet_1_eta"",          value = event.jet_eta[0])
            #data.variable(index = index, name = ""jet_1_phi"",          value = event.jet_phi[0])
            ##data.variable(index = index, name = ""jet_1_e"",            value = event.jet_e[0])
            ##data.variable(index = index, name = ""jet_2_pt"",           value = event.jet_pt[1])
            #data.variable(index = index, name = ""jet_2_eta"",          value = event.jet_eta[1])
            #data.variable(index = index, name = ""jet_2_phi"",          value = event.jet_phi[1])
            ##data.variable(index = index, name = ""jet_2_e"",            value = event.jet_e[1])
            #data.variable(index = index, name = ""nJets"",              value = event.nJets)
            ##data.variable(index = index, name = ""nBTags"",             value = event.nBTags)
            ##data.variable(index = index, name = ""nLjets"",             value = event.nLjets)
            ##data.variable(index = index, name = ""ljet_1_m"",           value = event.ljet_m[0])
            #data.variable(index = index, name = ""met"",                value = event.met_met)
            #data.variable(index = index, name = ""met_phi"",            value = event.met_phi)
            #data.variable(index = index, name = ""Centrality_all"",     value = event.Centrality_all)
            #data.variable(index = index, name = ""Mbb_MindR"",          value = event.Mbb_MindR)
            #data.variable(index = index, name = ""ljet_tau21"",         value = event.ljet_tau21),
            #data.variable(index = index, name = ""ljet_tau32"",         value = event.ljet_tau32),
            #data.variable(index = index, name = ""Aplan_bjets"",        value = event.Aplan_bjets),
            #data.variable(index = index, name = ""H4_all"",             value = event.H4_all),
            #data.variable(index = index, name = ""NBFricoNN_6jin4bin"", value = event.NBFricoNN_6jin4bin),
            #data.variable(index = index, name = ""NBFricoNN_6jin3bex"", value = event.NBFricoNN_6jin3bex),
            #data.variable(index = index, name = ""NBFricoNN_5jex4bin"", value = event.NBFricoNN_5jex4bin),
            #data.variable(index = index, name = ""NBFricoNN_3jex3bex"", value = event.NBFricoNN_3jex3bex),
            #data.variable(index = index, name = ""NBFricoNN_4jin3bex"", value = event.NBFricoNN_4jin3bex),
            #data.variable(index = index, name = ""NBFricoNN_4jin4bin"", value = event.NBFricoNN_4jin4bin)

            number_of_events_loaded += 1

    log.info("""")

    return data"
4547,"def select_event(
    event     = None,
    selection = ""ejets""
    ):
    """"""
    Select a HEP event.
    """"""
    if selection == ""ejets"":
        # Require single lepton.
        # Require >= 4 jets.
        if \
            0 < len(event.el_pt) < 2 and \
            len(event.jet_pt) >= 4 and \
            len(event.ljet_m) >= 1:
            return True
        else:
            return False"
4548,"def draw_neural_network(
    axes        = None,
    left        = None,
    right       = None,
    bottom      = None,
    top         = None,
    layer_sizes = None
    ):
    """"""
    # abstract

    This function draws a neural network representation diagram using
    matplotilb.

    # arguments

    |*argument* |*description*                                                 |
    |-----------|--------------------------------------------------------------|
    |axes       |matplotlib.axes.AxesSubplot: the axes on which to plot the    |
    |           |diagram (returned by matplotlib.pyplot.gca())                 |
    |left       |float: the position of the centers of the left nodes          |
    |right      |float: the position of the centers of the right nodes         |
    |bottom     |float: the position of the centers of the bottom nodes        |
    |top        |float: the position of the centers of the top nodes           |
    |layer_sizes|list of integers: list of layer sizes, including input and    |
    |           |output dimensionality                                         |

    # example

    ```Python
    figure = matplotlib.pyplot.figure(figsize = (12, 12))
    abstraction.draw_neural_network(
        axes        = figure.gca(),
        left        = .1,
        right       = .9,
        bottom      = .1,
        top         = .9,
        layer_sizes = [4, 7, 2]
    )
    figure.savefig(""neural_network_diagram.png"")
    ```
    """"""
    spacing_vertical   = (top - bottom) / float(max(layer_sizes))
    spacing_horizontal = (right - left) / float(len(layer_sizes) - 1)
    # nodes
    for n, layer_size in enumerate(layer_sizes):
        layer_top = spacing_vertical * (layer_size - 1)/2 + (top + bottom) / 2
        for m in xrange(layer_size):
            circle = matplotlib.pyplot.Circle(
                (
                    n * spacing_horizontal + left,
                    layer_top - m * spacing_vertical
                ),
                spacing_vertical / 4,
                color  = ""w"",
                ec     = ""k"",
                zorder = 4
            )
            axes.add_artist(circle)
    # edges
    for n, (layer_size_a, layer_size_b) in enumerate(zip(
        layer_sizes[:-1],
        layer_sizes[1:]
        )):
        layer_top_a =\
            spacing_vertical * (layer_size_a - 1) / 2 + (top + bottom) / 2
        layer_top_b =\
            spacing_vertical * (layer_size_b - 1) / 2 + (top + bottom) / 2
        for m in xrange(layer_size_a):
            for o in xrange(layer_size_b):
                line = matplotlib.pyplot.Line2D(
                    [
                        n * spacing_horizontal + left,
                        (n + 1) * spacing_horizontal + left
                    ],
                    [
                        layer_top_a - m * spacing_vertical,
                        layer_top_b - o * spacing_vertical
                    ],
                    c = ""k""
                )
                axes.add_artist(line)"
4549,"def sentiment(
    text       = None,
    confidence = False
    ):
    """"""
    This function accepts a string text input. It calculates the sentiment of
    the text, ""pos"" or ""neg"". By default, it returns this calculated sentiment.
    If selected, it returns a tuple of the calculated sentiment and the
    classificaton confidence.
    """"""
    try:
        words = text.split("" "")
        # Remove empty strings.
        words = [word for word in words if word]
        features = word_features(words)
        classification = classifier.classify(features)
        confidence_classification = classifier.prob_classify(features).prob(classification)
    except:
        classification = None
        confidence_classification = None
    if confidence:
        return (
            classification,
            confidence_classification
        )
    else:
        return classification"
4550,"def usernames(
        self
        ):
        """"""
        This function returns the list of unique usernames corresponding to the
        tweets stored in self.
        """"""
        try:
            return list(set([tweet.username for tweet in self]))
        except:
            log.error(""error -- possibly a problem with tweets stored"")"
4551,"def user_sentiments(
        self,
        username = None
        ):
        """"""
        This function returns a list of all sentiments of the tweets of a
        specified user.
        """"""
        try:
           return [tweet.sentiment for tweet in self if tweet.username == username]
        except:
            log.error(""error -- possibly no username specified"")
            return None"
4552,"def user_sentiments_most_frequent(
        self,
        username             = None,
        single_most_frequent = True
        ):
        """"""
        This function returns the most frequent calculated sentiments expressed
        in tweets of a specified user. By default, the single most frequent
        sentiment is returned. All sentiments with their corresponding
        frequencies can be returned also.
        """"""
        try:
            sentiment_frequencies = collections.Counter(self.user_sentiments(
                username = username
            ))
            if single_most_frequent:
                return sentiment_frequencies.most_common(1)[0][0]
            else:
                return dict(sentiment_frequencies)
        except:
            log.error(""error -- possibly no username specified"")
            return None"
4553,"def users_sentiments_single_most_frequent(
        self,
        usernames = None,
        ):
        """"""
        This function returns the single most frequent calculated sentiment
        expressed by all stored users or by a list of specified users as a
        dictionary.
        """"""
        users_sentiments_single_most_frequent = dict()
        if usernames is None:
            usernames = self.usernames()
        try:
            for username in usernames:
                sentiment = self.user_sentiments_most_frequent(
                    username             = username,
                    single_most_frequent = True
                )
                users_sentiments_single_most_frequent[username] = sentiment
            return users_sentiments_single_most_frequent
        except:
            log.error(""error -- possibly a problem with tweets stored"")
            return None"
4554,"def create_stripe_gateway(cls, stripe_gateway, **kwargs):
        """"""Create StripeGateway

        Create a new StripeGateway
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_stripe_gateway(stripe_gateway, async=True)
        >>> result = thread.get()

        :param async bool
        :param StripeGateway stripe_gateway: Attributes of stripeGateway to create (required)
        :return: StripeGateway
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_stripe_gateway_with_http_info(stripe_gateway, **kwargs)
        else:
            (data) = cls._create_stripe_gateway_with_http_info(stripe_gateway, **kwargs)
            return data"
4555,"def delete_stripe_gateway_by_id(cls, stripe_gateway_id, **kwargs):
        """"""Delete StripeGateway

        Delete an instance of StripeGateway by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_stripe_gateway_by_id(stripe_gateway_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str stripe_gateway_id: ID of stripeGateway to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_stripe_gateway_by_id_with_http_info(stripe_gateway_id, **kwargs)
        else:
            (data) = cls._delete_stripe_gateway_by_id_with_http_info(stripe_gateway_id, **kwargs)
            return data"
4556,"def get_stripe_gateway_by_id(cls, stripe_gateway_id, **kwargs):
        """"""Find StripeGateway

        Return single instance of StripeGateway by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_stripe_gateway_by_id(stripe_gateway_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str stripe_gateway_id: ID of stripeGateway to return (required)
        :return: StripeGateway
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_stripe_gateway_by_id_with_http_info(stripe_gateway_id, **kwargs)
        else:
            (data) = cls._get_stripe_gateway_by_id_with_http_info(stripe_gateway_id, **kwargs)
            return data"
4557,"def list_all_stripe_gateways(cls, **kwargs):
        """"""List StripeGateways

        Return a list of StripeGateways
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_stripe_gateways(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[StripeGateway]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_stripe_gateways_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_stripe_gateways_with_http_info(**kwargs)
            return data"
4558,"def replace_stripe_gateway_by_id(cls, stripe_gateway_id, stripe_gateway, **kwargs):
        """"""Replace StripeGateway

        Replace all attributes of StripeGateway
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_stripe_gateway_by_id(stripe_gateway_id, stripe_gateway, async=True)
        >>> result = thread.get()

        :param async bool
        :param str stripe_gateway_id: ID of stripeGateway to replace (required)
        :param StripeGateway stripe_gateway: Attributes of stripeGateway to replace (required)
        :return: StripeGateway
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_stripe_gateway_by_id_with_http_info(stripe_gateway_id, stripe_gateway, **kwargs)
        else:
            (data) = cls._replace_stripe_gateway_by_id_with_http_info(stripe_gateway_id, stripe_gateway, **kwargs)
            return data"
4559,"def update_stripe_gateway_by_id(cls, stripe_gateway_id, stripe_gateway, **kwargs):
        """"""Update StripeGateway

        Update attributes of StripeGateway
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_stripe_gateway_by_id(stripe_gateway_id, stripe_gateway, async=True)
        >>> result = thread.get()

        :param async bool
        :param str stripe_gateway_id: ID of stripeGateway to update. (required)
        :param StripeGateway stripe_gateway: Attributes of stripeGateway to update. (required)
        :return: StripeGateway
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_stripe_gateway_by_id_with_http_info(stripe_gateway_id, stripe_gateway, **kwargs)
        else:
            (data) = cls._update_stripe_gateway_by_id_with_http_info(stripe_gateway_id, stripe_gateway, **kwargs)
            return data"
4560,"def format_underline(s, char=""="", indents=0):
    """"""
    Traces a dashed line below string

    Args:
        s: string
        char:
        indents: number of leading intenting spaces

    Returns: list

    >>> print(""\\n"".join(format_underline(""Life of João da Silva"", ""^"", 2)))
      Life of João da Silva
      ^^^^^^^^^^^^^^^^^^^^^
    """"""

    n = len(s)
    ind = "" "" * indents
    return [""{}{}"".format(ind, s), ""{}{}"".format(ind, char*n)]"
4561,"def format_h1(s, format=""text"", indents=0):
    """"""
    Encloses string in format text

    Args:
        s: string
        format: string starting with ""text"", ""markdown"", or ""rest""
        indents: number of leading intenting spaces

    Returns: list

    >>> print(""\\n"".join(format_h2(""Header 1"", indents=10)))
              Header 1
              --------

    >>> print(""\\n"".join(format_h2(""Header 1"", ""markdown"", 0)))
    ## Header 1
    """"""

    _CHAR = ""=""
    if format.startswith(""text""):
        return format_underline(s, _CHAR, indents)
    elif format.startswith(""markdown""):
        return [""# {}"".format(s)]
    elif format.startswith(""rest""):
        return format_underline(s, _CHAR, 0)"
4562,"def format_h2(s, format=""text"", indents=0):
    """"""
    Encloses string in format text

    Args, Returns: see format_h1()

    >>> print(""\\n"".join(format_h2(""Header 2"", indents=2)))
      Header 2
      --------

    >>> print(""\\n"".join(format_h2(""Header 2"", ""markdown"", 2)))
    ## Header 2
    """"""

    _CHAR = ""-""
    if format.startswith(""text""):
        return format_underline(s, _CHAR, indents)
    elif format.startswith(""markdown""):
        return [""## {}"".format(s)]
    elif format.startswith(""rest""):
        return format_underline(s, _CHAR, 0)"
4563,"def format_h3(s, format=""text"", indents=0):
    """"""
    Encloses string in format text

    Args, Returns: see format_h1()
    """"""

    _CHAR = ""~""
    if format.startswith(""text""):
        return format_underline(s, _CHAR, indents)
    elif format.startswith(""markdown""):
        return [""### {}"".format(s)]
    elif format.startswith(""rest""):
        return format_underline(s, _CHAR, 0)"
4564,"def format_h4(s, format=""text"", indents=0):
    """"""
    Encloses string in format text

    Args, Returns: see format_h1()
    """"""

    _CHAR = ""^""
    if format.startswith(""text""):
        return format_underline(s, _CHAR, indents)
    elif format.startswith(""markdown""):
        return [""#### {}"".format(s)]
    elif format.startswith(""rest""):
        return format_underline(s, _CHAR, 0)"
4565,"def question(question, options, default=None):
    """"""Ask a question with case-insensitive options of answers

    Args:
        question: string **without** the question mark and without the options.
            Example: 'Commit changes'
        options_: string or sequence of strings. If string, options will be single-lettered.
            Examples: 'YNC', ['yes', 'no', 'cancel']. options are case-insensitive
        default: default option. If passed, default option will be shown in uppercase.

    Answers are case-insensitive, but options will be shown in lowercase, except for the default
    option.

    Returns:
        str: chosen option. Although the answer is case-insensitive, the result will be as informed
             in the 'options' argument.
    """"""

    # Make sure options is a list
    options_ = [x for x in options]

    if default is not None and default not in options_:
        raise ValueError(""Default option '{}' is not in options {}."".format(default, options))

    oto = ""/"".join([x.upper() if x == default else x.lower() for x in options_])  # to show
    ocomp = [x.lower() for x in options_]  # to be used in comparison

    while True:
        ans = input(""{} ({})? "".format(question, oto)).lower()
        if ans == """" and default is not None:
            ret = default
            break
        elif ans in ocomp:
            ret = options_[ocomp.index(ans)]
            break
    return ret"
4566,"def yesno(question, default=None):
    """"""Asks a yes/no question

    Args:
        question: string **without** the question mark and without the options.
            Example: 'Create links'
        default: default option. Accepted values are 'Y', 'YES', 'N', 'NO' or lowercase versions of
            these valus (this argument is case-insensitive)

    Returns:
        bool: True if user answered Yes, False otherwise
    """"""

    if default is not None:
        if isinstance(default, bool):
            pass
        else:
            default_ = default.upper()
            if default_ not in ('Y', 'YES', 'N', 'NO'):
                raise RuntimeError(""Invalid default value: '{}'"".format(default))
            default = default_ in ('Y', 'YES')

    while True:
        ans = input(""{} ({}/{})? "".format(question, ""Y"" if default == True else ""y"",
                                         ""N"" if default == False else ""n"")).upper()
        if ans == """" and default is not None:
            ret = default
            break
        elif ans in (""N"", ""NO""):
            ret = False
            break
        elif ans in (""Y"", ""YES""):
            ret = True
            break
    return ret"
4567,"def menu(title, options, cancel_label=""Cancel"", flag_allow_empty=False, flag_cancel=True, ch='.'):
  """"""Text menu.

  Arguments:
    title -- menu title, to appear at the top
    options -- sequence of strings
    cancel_label='Cancel' -- label to show at last ""zero"" option
    flag_allow_empty=0 -- Whether to allow empty option
    flag_cancel=True -- whether there is a ""0 - Cancel"" option
    ch=""."" -- character to use to draw frame around title

  Returns:
    option -- an integer: None; 0-Back/Cancel/etc; 1, 2, ...

  Adapted from irootlab menu.m""""""

  num_options, flag_ok = len(options), 0
  option = None  # result
  min_allowed = 0 if flag_cancel else 1  # minimum option value allowed (if option not empty)

  while True:
    print("""")
    for line in format_box(title, ch):
        print(""  ""+line)
    for i, s in enumerate(options):
      print((""  {0:d} - {1!s}"".format(i+1, s)))
    if flag_cancel: print((""  0 - << (*{0!s}*)"".format(cancel_label)))
    try:
        s_option = input('? ')
    except KeyboardInterrupt:
        raise
    except:
        print("""")

    n_try = 0
    while True:
      if n_try >= 10:
        print('You are messing up!')
        break

      if len(s_option) == 0 and flag_allow_empty:
        flag_ok = True
        break

      try:
        option = int(s_option)
        if min_allowed <= option <= num_options:
          flag_ok = True
          break
      except ValueError:
        print(""Invalid integer value!"")

      print((""Invalid option, range is [{0:d}, {1:d}]!"".format(0 if flag_cancel else 1, num_options)))

      n_try += 1
      s_option = input(""? "")

    if flag_ok:
      break
  return option"
4568,"def format_box(title, ch=""*""):
    """"""
    Encloses title in a box. Result is a list

    >>> for line in format_box(""Today's TODO list""):
    ...     print(line)
    *************************
    *** Today's TODO list ***
    *************************
    """"""
    lt = len(title)
    return [(ch * (lt + 8)),
            (ch * 3 + "" "" + title + "" "" + ch * 3),
            (ch * (lt + 8))
           ]"
4569,"def format_progress(i, n):
    """"""Returns string containing a progress bar, a percentage, etc.""""""
    if n == 0:
        fraction = 0
    else:
        fraction = float(i)/n
    LEN_BAR = 25
    num_plus = int(round(fraction*LEN_BAR))
    s_plus = '+'*num_plus
    s_point = '.'*(LEN_BAR-num_plus)
    return '[{0!s}{1!s}] {2:d}/{3:d} - {4:.1f}%'.format(s_plus, s_point, i, n, fraction*100)"
4570,"def _format_exe_info(py_len, exeinfo, format, indlevel):
    """"""Renders ExeInfo object in specified format""""""
    ret = []
    ind = "" "" * indlevel * NIND if format.startswith(""text"") else """"
    if format == ""markdown-list"":
        for si in exeinfo:
            ret.append(""  - `{0!s}`: {1!s}"".format(si.filename, si.description))
    if format == ""rest-list"":
        for si in exeinfo:
            ret.append(""* ``{0!s}``: {1!s}"".format(si.filename, si.description))
    elif format == ""markdown-table"":
        mask = ""%-{0:d}s | %s"".format(py_len+2 )
        ret.append(mask % (""Script name"", ""Purpose""))
        ret.append(""-"" * (py_len + 3) + ""|"" + ""-"" * 10)
        for si in exeinfo:
            ret.append(mask % (""`{0!s}`"".format(si.filename), si.description))
    elif format == ""text"":
        sbc = 1  # spaces between columns
        for si in exeinfo:
            ss = textwrap.wrap(si.description, 79 - py_len - sbc - indlevel*NIND)
            for i, s in enumerate(ss):
                if i == 0:
                    filecolumn = si.filename + "" "" + (""."" * (py_len - len(si.filename)))
                else:
                    filecolumn = "" "" * (py_len + 1)

                ret.append(""{}{}{}{}"".format(ind, filecolumn, "" ""*sbc, s))
    ret.append("""")
    return ret"
4571,"def format_exe_info(exeinfo, format=""text"", indlevel=0):
    """"""
    Generates listing of all Python scripts available as command-line programs.

    Args:
      exeinfo -- list of ExeInfo objects

      format -- One of the options below:
        ""text"" -- generates plain text for printing at the console
        ""markdown-list"" -- generates MarkDown as list
        ""markdown-table"" -- generates MarkDown as tables
        ""rest-list"" -- generates reStructuredText as lists

      indents -- indentation level (""text"" format only)

    Returns: (list of strings, maximum filename size)
      list of strings -- can be joined with a ""\n""
      maximum filename size
    """"""

    py_len = max([len(si.filename) for si in exeinfo])

    sisi_gra = [si for si in exeinfo if si.flag_gui == True]
    sisi_cmd = [si for si in exeinfo if si.flag_gui == False]
    sisi_none = [si for si in exeinfo if si.flag_gui is None]

    def get_title(x):
        return format_h4(x, format, indlevel*NIND) + [""""]

    ret = []
    if len(sisi_gra) > 0:
        ret.extend(get_title(""Graphical applications""))
        ret.extend(_format_exe_info(py_len, sisi_gra, format, indlevel + 1))
    if len(sisi_cmd) > 0:
        ret.extend(get_title(""Command-line tools"", ))
        ret.extend(_format_exe_info(py_len, sisi_cmd, format, indlevel + 1))
    if len(sisi_none) > 0:
        ret.extend(_format_exe_info(py_len, sisi_none, format, indlevel + 1))

    return ret, py_len"
4572,"def markdown_table(data, headers):
    """"""
    Creates MarkDown table. Returns list of strings

    Arguments:
      data -- [(cell00, cell01, ...), (cell10, cell11, ...), ...]
      headers -- sequence of strings: (header0, header1, ...)
    """"""

    maxx = [max([len(x) for x in column]) for column in zip(*data)]
    maxx = [max(ll) for ll in zip(maxx, [len(x) for x in headers])]
    mask = "" | "".join([""%-{0:d}s"".format(n) for n in maxx])

    ret = [mask % headers]

    ret.append("" | "".join([""-""*n for n in maxx]))
    for line in data:
        ret.append(mask % line)
    return ret"
4573,"def expand_multirow_data(data):
    """"""
    Converts multirow cells to a list of lists and informs the number of lines of each row.

    Returns:
         tuple: new_data, row_heights
    """"""

    num_cols = len(data[0]) # number of columns

    # calculates row heights
    row_heights = []
    for mlrow in data:
        row_height = 0
        for j, cell in enumerate(mlrow):
            row_height = max(row_height, 1 if not isinstance(cell, (list, tuple)) else len(cell))
        row_heights.append(row_height)
    num_lines = sum(row_heights) # line != row (rows are multiline)

    # rebuilds table data
    new_data = [[""""]*num_cols for i in range(num_lines)]
    i0 = 0
    for row_height, mlrow in zip(row_heights, data):
        for j, cell in enumerate(mlrow):
            if not isinstance(cell, (list, tuple)):
                cell = [cell]

            for incr, x in enumerate(cell):
                new_data[i0+incr][j] = x

        i0 += row_height

    return new_data, row_heights"
4574,"def rest_table(data, headers):
    """"""
    Creates reStructuredText table (grid format), allowing for multiline cells

    Arguments:
      data -- [((cell000, cell001, ...), (cell010, cell011, ...), ...), ...]
      headers -- sequence of strings: (header0, header1, ...)

    **Note** Tolerant to non-strings

    **Note** Cells may or may not be multiline

    >>> rest_table([[""Eric"", ""Idle""], [""Graham"", ""Chapman""], [""Terry"", ""Gilliam""]], [""Name"", ""Surname""])
    """"""

    num_cols = len(headers)
    new_data, row_heights = expand_multirow_data(data)
    new_data = [[str(x) for x in row] for row in new_data]
    col_widths = [max([len(x) for x in col]) for col in zip(*new_data)]
    col_widths = [max(cw, len(s)) for cw, s in zip(col_widths, headers)]

    if any([x == 0 for x in col_widths]):
        raise RuntimeError(""Column widths ({}) has at least one zero"".format(col_widths))

    num_lines = sum(row_heights) # line != row (rows are multiline)

    # horizontal lines
    hl0 = ""+""+""+"".join([""-""*(n+2) for n in col_widths])+""+""
    hl1 = ""+""+""+"".join([""=""*(n+2) for n in col_widths])+""+""

    frmtd = [""{0:{1}}"".format(x, width) for x, width in zip(headers, col_widths)]
    ret = [hl0, ""| ""+"" | "".join(frmtd)+"" |"", hl1]

    i0 = 0
    for i, row_height in enumerate(row_heights):
        if i > 0:
            ret.append(hl0)
        for incr in range(row_height):
            frmtd = [""{0:{1}}"".format(x, width) for x, width in zip(new_data[i0+incr], col_widths)]
            ret.append(""| ""+"" | "".join(frmtd)+"" |"")
        i0 += row_height

    ret.append(hl0)
    return ret"
4575,"def concept_adapter(obj, request):
    '''
    Adapter for rendering a :class:`skosprovider.skos.Concept` to json.

    :param skosprovider.skos.Concept obj: The concept to be rendered.
    :rtype: :class:`dict`
    '''
    p = request.skos_registry.get_provider(obj.concept_scheme.uri)
    language = request.params.get('language', request.locale_name)
    label = obj.label(language)
    return {
        'id': obj.id,
        'type': 'concept',
        'uri': obj.uri,
        'label': label.label if label else None,
        'concept_scheme': {
            'uri': obj.concept_scheme.uri,
            'labels': obj.concept_scheme.labels
        },
        'labels': obj.labels,
        'notes': obj.notes,
        'sources': obj.sources,
        'narrower': _map_relations(obj.narrower, p, language),
        'broader': _map_relations(obj.broader, p, language),
        'related': _map_relations(obj.related, p, language),
        'member_of': _map_relations(obj.member_of, p, language),
        'subordinate_arrays':  _map_relations(obj.subordinate_arrays, p, language),
        'matches': obj.matches
    }"
4576,"def collection_adapter(obj, request):
    '''
    Adapter for rendering a :class:`skosprovider.skos.Collection` to json.

    :param skosprovider.skos.Collection obj: The collection to be rendered.
    :rtype: :class:`dict`
    '''
    p = request.skos_registry.get_provider(obj.concept_scheme.uri)
    language = request.params.get('language', request.locale_name)
    label = obj.label(language)
    return {
        'id': obj.id,
        'type': 'collection',
        'uri': obj.uri,
        'label': label.label if label else None,
        'concept_scheme': {
            'uri': obj.concept_scheme.uri,
            'labels': obj.concept_scheme.labels
        },
        'labels': obj.labels,
        'notes': obj.notes,
        'sources': obj.sources,
        'members': _map_relations(obj.members, p, language),
        'member_of': _map_relations(obj.member_of, p, language),
        'superordinates':  _map_relations(obj.superordinates, p, language)
    }"
4577,"def _map_relations(relations, p, language='any'):
    '''
    :param: :class:`list` relations: Relations to be mapped. These are
        concept or collection id's.
    :param: :class:`skosprovider.providers.VocabularyProvider` p: Provider
        to look up id's.
    :param string language: Language to render the relations' labels in
    :rtype: :class:`list`
    '''
    ret = []
    for r in relations:
        c = p.get_by_id(r)
        if c:
            ret.append(_map_relation(c, language))
        else:
            log.warning(
                'A relation references a concept or collection %d in provider %s that can not be found. Please check the integrity of your data.' %
                (r, p.get_vocabulary_id())
            )
    return ret"
4578,"def _map_relation(c, language='any'):
    """"""
    Map related concept or collection, leaving out the relations.

    :param c: the concept or collection to map
    :param string language: Language to render the relation's label in
    :rtype: :class:`dict`
    """"""
    label = c.label(language)
    return {
        'id': c.id,
        'type': c.type,
        'uri': c.uri,
        'label': label.label if label else None
    }"
4579,"def note_adapter(obj, request):
    '''
    Adapter for rendering a :class:`skosprovider.skos.Note` to json.

    :param skosprovider.skos.Note obj: The note to be rendered.
    :rtype: :class:`dict`
    '''
    return {
        'note': obj.note,
        'type': obj.type,
        'language': obj.language,
        'markup': obj.markup
    }"
4580,"def tag(
        log,
        filepath,
        tags=False,
        rating=False,
        wherefrom=False):
    """"""Add tags and ratings to your macOS files and folders

    **Key Arguments:**
        - ``log`` -- logger
        - ``filepath`` -- the path to the file needing tagged
        - ``tags`` -- comma or space-separated string, or list of tags. Use `False` to leave file tags as they are. Use """" or [] to remove tags. Default *False*.
        - ``rating`` -- a rating to add to the file. Use 0 to remove rating or `False` to leave file rating as it is. Default *False*.
        - ``wherefrom`` -- add a URL to indicate where the file come from. Use `False` to leave file location as it is. Use """" to remove location. Default *False*.

    **Return:**
        - None

    **Usage:**

        To add any combination of tags, rating and a source URL to a file on macOS, use the following:

        .. code-block:: python 

            from fundamentals.files.tag import tag
            tag(
                log=log,
                filepath=""/path/to/my.file"",
                tags=""test,tags, fundamentals"",
                rating=3,
                wherefrom=""http://www.thespacedoctor.co.uk""
            )
    """"""
    log.debug('starting the ``tag`` function')

    if isinstance(tags, list):
        tags = ("" "").join(tags)

    if tags and len(tags):
        tags = tags.replace("","", "" "")
        tags = ""<string>"" + tags.replace(""  "", "" "").replace(
            ""  "", "" "").replace("" "", ""</string><string>"") + ""</string>""

    if tags != False:
        now = datetime.now()
        now = now.strftime(""%Y%m%dt%H%M%S%f"")
        tagPlist = ""/tmp/fund-%(now)s-tags.plist"" % locals()
        # GENERATE THE TAGS PLIST FILE
        try:
            writeFile = codecs.open(
                tagPlist, encoding='utf-8', mode='w')
        except IOError, e:
            message = 'could not open the file %s' % (tagPlist,)
            raise IOError(message)
        writeFile.write(""""""
<!DOCTYPE plist PUBLIC ""-//Apple//DTD PLIST 1.0//EN"" ""http://www.apple.com/DTDs/PropertyList-1.0.dtd"">
<plist version=""1.0"">
<array>
%(tags)s 
</array>
</plist>"""""" % locals())
        writeFile.close()

        # CONVERT PLIST TO BINARY
        cmd = """"""plutil -convert binary1 %(tagPlist)s"""""" % locals(
        )
        p = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True)
        stdout, stderr = p.communicate()
        log.debug('output: %(stdout)s' % locals())
        log.debug('output: %(stderr)s' % locals())

        # ASSIGN TAGS TO FILE
        cmd = 'xattr -wx ""com.apple.metadata:_kMDItemUserTags"" ""`xxd -ps %(tagPlist)s`"" ""%(filepath)s""' % locals(
        )
        p = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True)
        stdout, stderr = p.communicate()
        log.debug('output: %(stdout)s' % locals())
        log.debug('output: %(stderr)s' % locals())

        # DELETE PLIST
        os.remove(tagPlist)

    if rating != False:

        ratingsContainer = os.path.dirname(__file__) + ""/resources/ratings/""
        ratingPlist = ""%(ratingsContainer)s%(rating)s.plist"" % locals(
        )

        # ASSIGN RATING TO FILE
        cmd = 'xattr -wx ""com.apple.metadata:kMDItemStarRating"" ""`xxd -ps %(ratingPlist)s`"" ""%(filepath)s""' % locals(
        )
        p = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True)
        stdout, stderr = p.communicate()
        log.debug('output: %(stdout)s' % locals())
        log.debug('output: %(stderr)s' % locals())
        cmd = 'xattr -wx ""org.openmetainfo:kMDItemStarRating"" ""`xxd -ps %(ratingPlist)s`"" ""%(filepath)s""' % locals(
        )
        p = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True)
        stdout, stderr = p.communicate()
        log.debug('output: %(stdout)s' % locals())
        log.debug('output: %(stderr)s' % locals())

    if wherefrom != False:

        if len(wherefrom):
            wherefrom = ""<string>%(wherefrom)s</string>"" % locals()

        # DAYONE LINK
        now = datetime.now()
        now = now.strftime(""%Y%m%dt%H%M%S%f"")
        urlPlist = ""/tmp/fund-%(now)s-url.plist"" % locals()
        # GENERATE THE WHEREFROM PLIST FILE
        try:
            writeFile = codecs.open(
                urlPlist, encoding='utf-8', mode='w')
        except IOError, e:
            message = 'could not open the file %s' % (urlPlist,)
            raise IOError(message)
        writeFile.write(""""""
<!DOCTYPE plist PUBLIC ""-//Apple//DTD PLIST 1.0//EN"" ""http://www.apple.com/DTDs/PropertyList-1.0.dtd"">
<plist version=""1.0"">
%(wherefrom)s
</plist>"""""" % locals())
        writeFile.close()

        # ASSIGN WHEREFORM TO FILE
        cmd = 'xattr -wx ""com.apple.metadata:kMDItemURL"" ""`xxd -ps %(urlPlist)s`"" ""%(filepath)s""' % locals(
        )
        # cmd = 'xattr -wx ""com.apple.metadata:kMDItemURL"" ""`plutil -convert binary1 %(urlPlist)s -o - | xxd -p`"" ""%(filepath)s""' % locals()

        p = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True)
        stdout, stderr = p.communicate()
        log.debug('output URL: %(stdout)s' % locals())
        log.debug('output URL: %(stderr)s' % locals())

        now = datetime.now()
        now = now.strftime(""%Y%m%dt%H%M%S%f"")
        urlPlist = ""/tmp/fund-%(now)s-url.plist"" % locals()
        # GENERATE THE WHEREFROM PLIST FILE
        try:
            writeFile = codecs.open(
                urlPlist, encoding='utf-8', mode='w')
        except IOError, e:
            message = 'could not open the file %s' % (urlPlist,)
            raise IOError(message)
        writeFile.write(""""""
<!DOCTYPE plist PUBLIC ""-//Apple//DTD PLIST 1.0//EN"" ""http://www.apple.com/DTDs/PropertyList-1.0.dtd"">
<plist version=""1.0"">
<array>
%(wherefrom)s
</array>
</plist>"""""" % locals())
        writeFile.close()

        # ASSIGN WHEREFORM TO FILE
        cmd = 'xattr -wx ""com.apple.metadata:kMDItemWhereFroms"" ""`xxd -ps %(urlPlist)s`"" ""%(filepath)s""' % locals(
        )
        p = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True)
        stdout, stderr = p.communicate()
        log.debug('output URL: %(stdout)s' % locals())
        log.debug('output URL: %(stderr)s' % locals())

        # DELETE PLIST
        # os.remove(urlPlist)

    log.debug('completed the ``tag`` function')
    return None"
4581,"def add_indicators(self, indicators=list(), private=False, tags=list()):
        """"""Add indicators to the remote instance.""""""
        if len(indicators) == 0:
            raise Exception(""No indicators were identified."")
        self.logger.debug(""Checking {} indicators"".format(len(indicators)))
        cleaned = clean_indicators(indicators)
        self.logger.debug(""Cleaned {} indicators"".format(len(cleaned)))
        whitelisted = check_whitelist(cleaned)
        self.logger.debug(""Non-whitelisted {} indicators"".format(len(whitelisted)))
        indicators = prune_cached(whitelisted)
        hashed = hash_values(indicators)
        self.logger.debug(""Non-cached {} indicators"".format(len(indicators)))
        self.logger.debug(""Processing {} indicators"".format(len(indicators)))
        request_count = int(math.ceil(len(indicators)/100.0))
        if request_count == 0:
            mesg = ""[!] No indicators were left to process after ""
            mesg += ""cleaning, whitelisting and checking the cache.""
            return {'message': mesg}
        stats = {'success': 0, 'failure': 0, 'requests': request_count,
                 'written': 0}
        mesg = ""{} indicators found, making {} requests""
        self.logger.debug(mesg.format(len(indicators), request_count))

        if private:
            indicators = hashed

        if type(tags) == str:
            tags = [t.strip().lower() for t in tags.split(',')]

        start, end = (0, 100)
        for i, idx in enumerate(range(0, request_count)):
            if idx > 0:
                time.sleep(3)  # Ensure we never trip the limit
                self.logger.debug(""Waiting 3 seconds before next request."")
            to_send = {'indicators': indicators[start:end], 'tags': tags}
            r = self._send_data('POST', 'admin', 'add-indicators', to_send)
            start, end = (end, end + 100)
            if not r['success']:
                stats['failure'] += 1
                continue
            stats['success'] += 1
            stats['written'] += r['writeCount']
            cache_items(to_send['indicators'])
        msg = """"
        msg += ""{written} indicators written using {requests} requests: ""
        msg += ""{success} success, {failure} failure""
        stats['message'] = msg.format(**stats)
        return stats"
4582,"def get_indicators(self):
        """"""List indicators available on the remote instance.""""""
        response = self._get('', 'get-indicators')
        response['message'] = ""%i indicators:\n%s"" % (
            len(response['indicators']),
            ""\n"".join(response['indicators'])
        )
        return response"
4583,"def to_unicode(obj, encoding='utf-8'):
    """"""Convert obj to unicode (if it can be be converted)

    from http://farmdev.com/talks/unicode/""""""
    if isinstance(obj, basestring):
        if not isinstance(obj, unicode):
            obj = unicode(obj, encoding)
    return obj"
4584,"def besttype(x, encoding=""utf-8"", percentify=True):
    """"""Convert string x to the most useful type, i.e. int, float or unicode string.

    If x is a quoted string (single or double quotes) then the quotes are
    stripped and the enclosed string returned. The string can contain any
    number of quotes, it is only important that it begins and ends with either
    single or double quotes.

    *percentify* = ``True`` turns ""34.4%"" into the float 0.344.

    .. Note::

       Strings will be returned as Unicode strings (using
       :func:`unicode`), based on the *encoding* argument, which is
       utf-8 by default.

    """"""
    def unicodify(x):
        return to_unicode(x, encoding)
    def percent(x):
        try:
            if x.endswith(""%""):
                x = float(x[:-1]) / 100.
            else:
                raise ValueError
        except (AttributeError, ValueError):
            raise ValueError
        return x

    x = unicodify(x)  # make unicode as soon as possible
    try:
        x = x.strip()
    except AttributeError:
        pass
    m = re.match(r""""""(?P<quote>['""])(?P<value>.*)(?P=quote)$"""""", x)  # matches ""<value>"" or '<value>' where <value> COULD contain "" or '!
    if m is None:
        # not a quoted string, try different types
        for converter in int, float, percent, unicodify:   # try them in increasing order of lenience
            try:
                return converter(x)
            except ValueError:
                pass
    else:
        # quoted string
        x = unicodify(m.group('value'))
    return x"
4585,"def _onsuccess(cls, kmsg, result):
        """""" To execute on execution success

        :param kser.schemas.Message kmsg: Kafka message
        :param kser.result.Result result: Execution result
        :return: Execution result
        :rtype: kser.result.Result
        """"""
        logger.info(
            ""{}.Success: {}[{}]: {}"".format(
                cls.__name__, kmsg.entrypoint, kmsg.uuid, result
            ),
            extra=dict(
                kmsg=kmsg.dump(),
                kresult=ResultSchema().dump(result) if result else dict()
            )
        )
        return cls.onsuccess(kmsg, result)"
4586,"def _onerror(cls, kmsg, result):
        """""" To execute on execution failure

        :param kser.schemas.Message kmsg: Kafka message
        :param kser.result.Result result: Execution result
        :return: Execution result
        :rtype: kser.result.Result
        """"""
        logger.error(
            ""{}.Failed: {}[{}]: {}"".format(
                cls.__name__, kmsg.entrypoint, kmsg.uuid, result
            ),
            extra=dict(
                kmsg=kmsg.dump(),
                kresult=ResultSchema().dump(result) if result else dict()
            )
        )
        return cls.onerror(kmsg, result)"
4587,"def _onmessage(cls, kmsg):
        """""" Call on received message

        :param kser.schemas.Message kmsg: Kafka message
        :return: Kafka message
        :rtype: kser.schemas.Message
        """"""
        logger.debug(
            ""{}.ReceivedMessage {}[{}]"".format(
                cls.__name__, kmsg.entrypoint, kmsg.uuid
            ),
            extra=dict(kmsg=kmsg.dump())
        )
        return cls.onmessage(kmsg)"
4588,"def register(cls, name, entrypoint):
        """""" Register a new entrypoint

        :param str name: Key used by messages
        :param kser.entry.Entrypoint entrypoint: class to load
        :raises ValidationError: Invalid entry
        """"""
        if not issubclass(entrypoint, Entrypoint):
            raise ValidationError(
                ""Invalid type for entry '{}', MUST implement ""
                ""kser.entry.Entrypoint"".format(name),
                extra=dict(entrypoint=name)
            )
        cls.ENTRYPOINTS[name] = entrypoint
        logger.debug(""{}.Registered: {}"".format(cls.__name__, name))"
4589,"def run(cls, raw_data):
        """"""description of run""""""
        logger.debug(""{}.ReceivedFromKafka: {}"".format(
            cls.__name__, raw_data
        ))
        try:
            kmsg = cls._onmessage(cls.TRANSPORT.loads(raw_data))
        except Exception as exc:
            logger.error(
                ""{}.ImportError: Failed to load data from kafka: {}"".format(
                    cls.__name__, exc
                ),
                extra=dict(kafka_raw_data=raw_data)
            )
            return Result.from_exception(exc)

        try:
            cls.start_processing(kmsg)
            if kmsg.entrypoint not in cls.ENTRYPOINTS:
                raise ValidationError(
                    ""Entrypoint '{}' not registred"".format(kmsg.entrypoint),
                    extra=dict(
                        uuid=kmsg.uuid, entrypoint=kmsg.entrypoint,
                        allowed=list(cls.ENTRYPOINTS.keys())
                    )
                )

            result = cls.ENTRYPOINTS[kmsg.entrypoint].from_Message(
                kmsg
            ).execute()

        except Exception as exc:
            result = Result.from_exception(exc, kmsg.uuid)

        finally:
            cls.stop_processing()
            # noinspection PyUnboundLocalVariable
            if result and result.retcode < 300:
                return cls._onsuccess(kmsg=kmsg, result=result)
            else:
                return cls._onerror(kmsg=kmsg, result=result)"
4590,"def interval_condition(value, inf, sup, dist):
    """"""Checks if value belongs to the interval [inf - dist, sup + dist].
    """"""
    return (value > inf - dist and value < sup + dist)"
4591,"def nearest_point(query, root_id, get_properties, dist_fun=euclidean_dist):
    """"""Find the point in the tree that minimizes the distance to the query.

    This method implements the nearest_point query for any structure
    implementing a kd-tree. The only requirement is a function capable to
    extract the relevant properties from a node representation of the
    particular implementation.

    Args:
        query (:obj:`tuple` of float or int): Stores the position of the
            node.
        root_id (:obj): The identifier of the root in the kd-tree
            implementation.
        get_properties (:obj:`function`): The function to extract the
            relevant properties from a node, namely its point, region,
            axis, left child identifier, right child identifier and
            if it is active. If the implementation does not uses
            the active attribute the function should return always True.
        dist_fun (:obj:`function`, optional): The distance function,
            euclidean distance by default.

    Returns:
        :obj:`tuple`: Tuple of length 2, where the first element is the
            identifier of the nearest node, the second is the distance
            to the query.

    """"""

    k = len(query)
    dist = math.inf

    nearest_node_id = None

    # stack_node: stack of identifiers to nodes within a region that
    # contains the query.
    # stack_look: stack of identifiers to nodes within a region that
    # does not contains the query.
    stack_node = deque([root_id])
    stack_look = deque()

    while stack_node or stack_look:

        if stack_node:
            node_id = stack_node.pop()
            look_node = False
        else:
            node_id = stack_look.pop()
            look_node = True

        point, region, axis, active, left, right = get_properties(node_id)

        # Should consider this node?
        # As it is within a region that does not contains the query, maybe
        # there is no chance to find a closer node in this region
        if look_node:
            inside_region = True
            for i in range(k):
                inside_region &= interval_condition(query[i], region[i][0],
                                                    region[i][1], dist)
            if not inside_region:
                continue

        # Update the distance only if the node is active.
        if active:
            node_distance = dist_fun(query, point)
            if nearest_node_id is None or dist > node_distance:
                nearest_node_id = node_id
                dist = node_distance

        if query[axis] < point[axis]:
            side_node = left
            side_look = right
        else:
            side_node = right
            side_look = left

        if side_node is not None:
            stack_node.append(side_node)

        if side_look is not None:
            stack_look.append(side_look)

    return nearest_node_id, dist"
4592,"def deactivate(self, node_id):
        """"""Deactivate the node identified by node_id.

        Deactivates the node corresponding to node_id, which means that
        it can never be the output of a nearest_point query.

        Note:
            The node is not removed from the tree, its data is steel available.

        Args:
            node_id (int): The node identifier (given to the user after
                its insertion).

        """"""
        node = self.node_list[node_id]
        self.node_list[node_id] = node._replace(active=False)"
4593,"def insert(self, point, data=None):
        """"""Insert a new node in the tree.

        Args:
            point (:obj:`tuple` of float or int): Stores the position of the
                node.
            data (:obj, optional): The information stored by the node.

        Returns:
            int: The identifier of the new node.

        Example:
            >>> tree = Tree(4, 800)
            >>> point = (3, 7)
            >>> data = {'name': Fresnel, 'label': blue, 'speed': 98.2}
            >>> node_id = tree.insert(point, data)

        """"""
        assert len(point) == self.k

        if self.size == 0:
            if self.region is None:
                self.region = [[-math.inf, math.inf]] * self.k
            axis = 0
            return self.new_node(point, self.region, axis, data)

        # Iteratively descends to one leaf
        current_id = 0
        while True:
            parent_node = self.node_list[current_id]
            axis = parent_node.axis
            if point[axis] < parent_node.point[axis]:
                next_id, left = parent_node.left, True
            else:
                next_id, left = parent_node.right, False

            if next_id is None:
                break

            current_id = next_id

        # Get the region delimited by the parent node
        region = parent_node.region[:]
        region[axis] = parent_node.region[axis][:]

        # Limit to the child's region
        limit = parent_node.point[axis]

        # Update reference to the new node
        if left:
            self.node_list[current_id] = parent_node._replace(left=self.size)
            region[axis][1] = limit
        else:
            self.node_list[current_id] = parent_node._replace(right=self.size)
            region[axis][0] = limit

        return self.new_node(point, region, (axis + 1) % self.k, data)"
4594,"def find_nearest_point(self, query, dist_fun=euclidean_dist):
        """"""Find the point in the tree that minimizes the distance to the query.

        Args:
            query (:obj:`tuple` of float or int): Stores the position of the
                node.
            dist_fun (:obj:`function`, optional): The distance function,
                euclidean distance by default.

        Returns:
            :obj:`tuple`: Tuple of length 2, where the first element is the
                identifier of the nearest node, the second is the distance
                to the query.

        Example:
            >>> tree = Tree(2, 3)
            >>> tree.insert((0, 0))
            >>> tree.insert((3, 5))
            >>> tree.insert((-1, 7))
            >>> query = (-1, 8)
            >>> nearest_node_id, dist = tree.find_nearest_point(query)
            >>> dist
            1

        """"""
        def get_properties(node_id):
            return self.node_list[node_id][:6]

        return nearest_point(query, 0, get_properties, dist_fun)"
4595,"def set_to_public(self, request, queryset):
        """""" Set one or several releases to public """"""
        queryset.update(is_public=True, modified=now())"
4596,"def loads(cls, json_data):
        """"""description of load""""""
        try:
            return cls(**cls.MARSHMALLOW_SCHEMA.loads(json_data))
        except marshmallow.exceptions.ValidationError as exc:
            raise ValidationError(""Failed to load message"", extra=exc.args[0])"
4597,"def format(self, response):
        """""" Format the data.

        In derived classes, it is usually better idea to override
        ``_format_data()`` than this method.

        :param response: devil's ``Response`` object or the data
                         itself. May also be ``None``.
        :return: django's ``HttpResponse``

        todo: this shouldn't change the given response. only return the
        formatted response.
        """"""

        res = self._prepare_response(response)
        res.content = self._format_data(res.content, self.charset)
        return self._finalize_response(res)"
4598,"def parse(self, data, charset=None):
        """""" Parse the data.

        It is usually a better idea to override ``_parse_data()`` than
        this method in derived classes.

        :param charset: the charset of the data. Uses datamapper's
        default (``self.charset``) if not given.
        :returns:
        """"""

        charset = charset or self.charset
        return self._parse_data(data, charset)"
4599,"def _decode_data(self, data, charset):
        """""" Decode string data.

        :returns: unicode string
        """"""

        try:
            return smart_unicode(data, charset)
        except UnicodeDecodeError:
            raise errors.BadRequest('wrong charset')"
4600,"def _parse_data(self, data, charset):
        """""" Parse the data

        :param data: the data (may be None)
        """"""

        return self._decode_data(data, charset) if data else u''"
4601,"def _finalize_response(self, response):
        """""" Convert the ``Response`` object into django's ``HttpResponse``

        :return: django's ``HttpResponse``
        """"""

        res = HttpResponse(content=response.content,
                           content_type=self._get_content_type())
        # status_code is set separately to allow zero
        res.status_code = response.code
        return res"
4602,"def register_mapper(self, mapper, content_type, shortname=None):
        """""" Register new mapper.

        :param mapper: mapper object needs to implement ``parse()`` and
        ``format()`` functions.
        """"""

        self._check_mapper(mapper)
        cont_type_names = self._get_content_type_names(content_type, shortname)
        self._datamappers.update(dict([(name, mapper) for name in cont_type_names]))"
4603,"def select_formatter(self, request, resource):
        """""" Select appropriate formatter based on the request.

        :param request: the HTTP request
        :param resource: the invoked resource
        """"""

        # 1. get from resource
        if resource.mapper:
            return resource.mapper
        # 2. get from url
        mapper_name = self._get_name_from_url(request)
        if mapper_name:
            return self._get_mapper(mapper_name)
        # 3. get from accept header
        mapper_name = self._get_name_from_accept(request)
        if mapper_name:
            return self._get_mapper(mapper_name)
        # 4. use resource's default
        if resource.default_mapper:
            return resource.default_mapper
        # 5. use manager's default
        return self._get_default_mapper()"
4604,"def select_parser(self, request, resource):
        """""" Select appropriate parser based on the request.

        :param request: the HTTP request
        :param resource: the invoked resource
        """"""

        # 1. get from resource
        if resource.mapper:
            return resource.mapper
        # 2. get from content type
        mapper_name = self._get_name_from_content_type(request)
        if mapper_name:
            return self._get_mapper(mapper_name)
        # 3. get from url
        mapper_name = self._get_name_from_url(request)
        if mapper_name:
            return self._get_mapper(mapper_name)
        # 4. use resource's default
        if resource.default_mapper:
            return resource.default_mapper
        # 5. use manager's default
        return self._get_default_mapper()"
4605,"def get_mapper_by_content_type(self, content_type):
        """""" Returs mapper based on the content type. """"""

        content_type = util.strip_charset(content_type)
        return self._get_mapper(content_type)"
4606,"def _get_mapper(self, mapper_name):
        """""" Return the mapper based on the given name.

        :returns: the mapper based on the given ``mapper_name``
        :raises: NotAcceptable if we don't support the requested format.
        """"""

        if mapper_name in self._datamappers:
            # mapper found
            return self._datamappers[mapper_name]
        else:
            # unsupported format
            return self._unknown_format(mapper_name)"
4607,"def _get_name_from_content_type(self, request):
        """""" Get name from Content-Type header """"""

        content_type = request.META.get('CONTENT_TYPE', None)
        if content_type:
            # remove the possible charset-encoding info
            return util.strip_charset(content_type)
        return None"
4608,"def _get_name_from_accept(self, request):
        """""" Process the Accept HTTP header.

        Find the most suitable mapper that the client wants and we support.

        :returns: the preferred mapper based on the accept header or ``None``.
        """"""

        accepts = util.parse_accept_header(request.META.get(""HTTP_ACCEPT"", """"))
        if not accepts:
            return None

        for accept in accepts:
            if accept[0] in self._datamappers:
                return accept[0]
        raise errors.NotAcceptable()"
4609,"def _get_name_from_url(self, request):
        """""" Determine short name for the mapper based on the URL.

        Short name can be either in query string (e.g. ?format=json)
        or as an extension to the URL (e.g. myresource.json).

        :returns: short name of the mapper or ``None`` if not found.
        """"""

        format = request.GET.get('format', None)
        if not format:
            match = self._format_query_pattern.match(request.path)
            if match and match.group('format'):
                format = match.group('format')
        return format"
4610,"def _check_mapper(self, mapper):
        """""" Check that the mapper has valid signature. """"""
        if not hasattr(mapper, 'parse') or not callable(mapper.parse):
            raise ValueError('mapper must implement parse()')
        if not hasattr(mapper, 'format') or not callable(mapper.format):
            raise ValueError('mapper must implement format()')"
4611,"def setup_cluster(self, cluster, extra_args=tuple()):
        """"""
        Configure the cluster by running an Ansible playbook.

        The ElastiCluster configuration attribute `<kind>_groups`
        determines, for each node kind, what Ansible groups nodes of
        that kind are assigned to.

        :param cluster: cluster to configure
        :type cluster: :py:class:`elasticluster.cluster.Cluster`

        :param list extra_args:
          List of additional command-line arguments
          that are appended to each invocation of the setup program.

        :return: ``True`` on success, ``False`` otherwise. Please note, if nothing
                 has to be configured, then ``True`` is returned.

        :raises: `ConfigurationError` if the playbook can not be found
                 or is corrupt.
        """"""
        inventory_path = self._build_inventory(cluster)
        if inventory_path is None:
            # No inventory file has been created, maybe an
            # invalid class has been specified in config file? Or none?
            # assume it is fine.
            elasticluster.log.info(""No setup required for this cluster."")
            return True
        assert os.path.exists(inventory_path), (
                ""inventory file `{inventory_path}` does not exist""
                .format(inventory_path=inventory_path))

        # build list of directories to search for roles/include files
        ansible_roles_dirs = [
            # include Ansible default first ...
            '/etc/ansible/roles',
        ]
        for root_path in [
                # ... then ElastiCluster's built-in defaults
                resource_filename('elasticluster', 'share/playbooks'),
                # ... then wherever the playbook is
                os.path.dirname(self._playbook_path),
        ]:
            for path in [
                    root_path,
                    os.path.join(root_path, 'roles'),
            ]:
                if path not in ansible_roles_dirs and os.path.exists(path):
                    ansible_roles_dirs.append(path)


        # Use env vars to configure Ansible;
        # see all values in https://github.com/ansible/ansible/blob/devel/lib/ansible/constants.py
        #
        # Ansible does not merge keys in configuration files: rather
        # it uses the first configuration file found.  However,
        # environment variables can be used to selectively override
        # parts of the config; according to [1]: ""they are mostly
        # considered to be a legacy system as compared to the config
        # file, but are equally valid.""
        #
        # [1]: http://docs.ansible.com/ansible/intro_configuration.html#environmental-configuration
        #
        # Provide default values for important configuration variables...
        ansible_env = {
            'ANSIBLE_FORKS':             '10',
            'ANSIBLE_HOST_KEY_CHECKING': 'no',
            'ANSIBLE_PRIVATE_KEY_FILE':  cluster.user_key_private,
            'ANSIBLE_ROLES_PATH':        ':'.join(reversed(ansible_roles_dirs)),
            'ANSIBLE_SSH_PIPELINING':    'yes',
            'ANSIBLE_TIMEOUT':           '120',
        }
        # ...override them with key/values set in the config file(s)
        for k, v in self.extra_conf.items():
            if k.startswith('ansible_'):
                ansible_env[k.upper()] = str(v)
        # ...finally allow the environment have the final word
        ansible_env.update(os.environ)
        if __debug__:
            elasticluster.log.debug(
                ""Calling `ansible-playbook` with the following environment:"")
            for var, value in sorted(ansible_env.items()):
                elasticluster.log.debug(""- %s=%r"", var, value)

        elasticluster.log.debug(""Using playbook file %s."", self._playbook_path)

        # build `ansible-playbook` command-line
        cmd = shlex.split(self.extra_conf.get('ansible_command', 'ansible-playbook'))
        cmd += [
            os.path.realpath(self._playbook_path),
            ('--inventory=' + inventory_path),
        ] + list(extra_args)

        if self._sudo:
            cmd.extend([
                # force all plays to use `sudo` (even if not marked as such)
                '--become',
                # desired sudo-to user
                ('--become-user=' + self._sudo_user),
            ])

        # determine Ansible verbosity as a function of ElastiCluster's
        # log level (we cannot read `ElastiCluster().params.verbose`
        # here, still we can access the log configuration since it's
        # global).
        verbosity = (logging.WARNING - elasticluster.log.getEffectiveLevel()) / 10
        if verbosity > 0:
            cmd.append('-' + ('v' * verbosity))  # e.g., `-vv`

        # append any additional arguments provided by users
        ansible_extra_args = self.extra_conf.get('ansible_extra_args', None)
        if ansible_extra_args:
            cmd += shlex.split(ansible_extra_args)

        cmdline = ' '.join(cmd)
        elasticluster.log.debug(""Running Ansible command `%s` ..."", cmdline)

        rc = call(cmd, env=ansible_env, bufsize=1, close_fds=True)
        if rc == 0:
            elasticluster.log.info(""Cluster correctly configured."")
            return True
        else:
            elasticluster.log.error(
                ""Command `%s` failed with exit code %d."", cmdline, rc)
            elasticluster.log.error(
                ""Check the output lines above for additional information on this error."")
            elasticluster.log.error(
                ""The cluster has likely *not* been configured correctly.""
                "" You may need to re-run `elasticluster setup` or fix the playbooks."")
            return False"
4612,"def _build_inventory(self, cluster):
        """"""
        Builds the inventory for the given cluster and returns its path

        :param cluster: cluster to build inventory for
        :type cluster: :py:class:`elasticluster.cluster.Cluster`
        """"""
        inventory_data = defaultdict(list)
        for node in cluster.get_all_nodes():
            if node.kind not in self.groups:
                # FIXME: should this raise a `ConfigurationError` instead?
                warn(""Node kind `{0}` not defined in cluster!"".format(node.kind))
                continue
            extra_vars = ['ansible_user=%s' % node.image_user]
            # check for nonstandard port, either IPv4 or IPv6
            if node.preferred_ip and ':' in node.preferred_ip:
                match = IPV6_RE.match(node.preferred_ip)
                if match:
                    host_port = match.groups()[1]
                else:
                    _, _, host_port = node.preferred_ip.partition(':')
                if host_port:
                    extra_vars.append('ansible_port=%s' % host_port)

            if node.kind in self.environment:
                extra_vars.extend('%s=%s' % (k, v) for k, v in
                                  self.environment[node.kind].items())
            for group in self.groups[node.kind]:
                connection_ip = node.preferred_ip
                if connection_ip:
                    inventory_data[group].append(
                        (node.name, connection_ip, str.join(' ', extra_vars)))

        if not inventory_data:
            elasticluster.log.info(""No inventory file was created."")
            return None

        # create a temporary file to pass to ansible, since the
        # api is not stable yet...
        if self._storage_path_tmp:
            if not self._storage_path:
                self._storage_path = tempfile.mkdtemp()
            elasticluster.log.warning(
                ""Writing inventory file to tmp dir `%s`"", self._storage_path)

        inventory_path = os.path.join(
            self._storage_path, (cluster.name + '.inventory'))
        log.debug(""Writing Ansible inventory to file `%s` ..."", inventory_path)
        with open(inventory_path, 'w+') as inventory_file:
            for section, hosts in inventory_data.items():
                # Ansible throws an error ""argument of type 'NoneType' is not
                # iterable"" if a section is empty, so ensure we have something
                # to write in there
                if hosts:
                    inventory_file.write(""\n["" + section + ""]\n"")
                    for host in hosts:
                        # don't want port, makes it look like ipv6
                        if ':' in host[1]:
                            match = IPV6_RE.match(node.preferred_ip)
                            if match:
                                host = (host[0], match.groups()[0], host[2])
                            else:
                                host = (host[0], host[1].partition(':')[0],
                                        host[2])
                        hostline = ""%s ansible_host=%s %s\n"" % host
                        inventory_file.write(hostline)
        return inventory_path"
4613,"def cleanup(self, cluster):
        """"""Deletes the inventory file used last recently used.

        :param cluster: cluster to clear up inventory file for
        :type cluster: :py:class:`elasticluster.cluster.Cluster`
        """"""
        if self._storage_path and os.path.exists(self._storage_path):
            fname = '%s.%s' % (AnsibleSetupProvider.inventory_file_ending,
                               cluster.name)
            inventory_path = os.path.join(self._storage_path, fname)

            if os.path.exists(inventory_path):
                try:
                    os.unlink(inventory_path)
                    if self._storage_path_tmp:
                        if len(os.listdir(self._storage_path)) == 0:
                            shutil.rmtree(self._storage_path)
                except OSError as ex:
                    log.warning(
                        ""AnsibileProvider: Ignoring error while deleting ""
                        ""inventory file %s: %s"", inventory_path, ex)"
4614,"def await_task(self, task_id, service_id, callback_fn=None, sleep_sec=15):
        """"""
        Подождать выполнения задачи запускатора

        :param task_id: ID задачи, за которой нужно следить
        :param service_id: ID сервиса
        :param callback_fn: Функция обратного вызова, в нее будет передаваться task_info и is_finish как признак, что обработка завершена
        :param sleep_sec: задержка между проверкой по БД. Не рекомендуется делать меньше 10, так как это может очень сильно ударить по производительности БД
        :return: void
        """"""
        while True:
            import time
            time.sleep(sleep_sec)
            task_info = self.__metadb.one(""""""
                SELECT id, service_id, status, result_data 
                FROM job.task
                WHERE id=:task_id::uuid
                AND service_id=:service_id::job.service_id
                LIMIT 1
            """""", {
                ""task_id"": task_id,
                ""service_id"": service_id,
            })
            self.log.info(""Ждем выполнения задачи"", {
                ""task_info"": task_info
            })
            if task_info is None:
                break

            is_finish = task_info['status'] != 'NEW' and task_info['status'] != 'PROCESSING'

            if callback_fn:
                # Уведомляем вызывающего
                callback_fn(task_info, is_finish)

            if is_finish:
                break"
4615,"def submit(self, service_id: str, data: dict = None):
        """"""
        Отправить задачу в запускатор

        :param service_id: ID службы. Например ""meta.docs_generate""
        :param data: Полезная нагрузка задачи
        :return: dict
        """"""
        if self.__app.starter_api_url == 'http://STUB_URL':
            self.log.info('STARTER DEV. Задача условно поставлена', {
                ""service_id"": service_id,
                ""data"": data,
            })
            return

        task = {""serviceId"": service_id, ""data"": data}
        url = self.__app.starter_api_url + '/services/' + service_id + '/tasks'
        last_e = None
        for _idx in range(self.max_retries):
            try:
                resp = requests.post(
                    url=url,
                    data=json.dumps(task),
                    headers=self.headers,
                    timeout=15
                )
                try:
                    return json.loads(resp.text)
                except Exception:
                    raise IOError(""Starter response read error: "" + resp.text)
            except (requests.exceptions.ConnectionError, requests.exceptions.Timeout) as e:
                # При ошибках подключения пытаемся еще раз
                last_e = e
                sleep(3)
        raise last_e"
4616,"def parse_version_string(version_string):
    """"""
    Parse a version string into it's components.
    
    >>> parse_version_string(""0.1"")
    ([0, 1], 'jenkins', None)
    >>> parse_version_string(""0.3.2-jenkins-3447876"")
    ([0, 3, 2], 'jenkins', 3447876)
    """"""
    components = version_string.split('-') + [None, None]
    version = list(map(int, components[0].split('.')))
    build_tag = components[1] if components[1] else BUILD_TAG
    build_number = int(components[2]) if components[2] else components[2]

    return (version, build_tag, build_number)"
4617,"def format_version(version, build_number=None, build_tag=BUILD_TAG):
    """"""
    Format a version string for use in packaging.
    
    >>> format_version([0,3,5])
    '0.3.5'
    >>> format_version([8, 8, 9], 23676)
    '8.8.9-jenkins-23676'
    >>> format_version([8, 8, 9], 23676, 'koekjes')
    '8.8.9-koekjes-23676'
    """"""
    formatted_version = ""."".join(map(str, version))

    if build_number is not None:
        return ""{formatted_version}-{build_tag}-{build_number}"".format(**locals())
    
    return formatted_version"
4618,"def based_on(self, based_on):
        """"""Sets the based_on of this TaxRate.


        :param based_on: The based_on of this TaxRate.
        :type: str
        """"""
        allowed_values = [""shippingAddress"", ""billingAddress""]
        if based_on is not None and based_on not in allowed_values:
            raise ValueError(
                ""Invalid value for `based_on` ({0}), must be one of {1}""
                .format(based_on, allowed_values)
            )

        self._based_on = based_on"
4619,"def create_tax_rate(cls, tax_rate, **kwargs):
        """"""Create TaxRate

        Create a new TaxRate
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_tax_rate(tax_rate, async=True)
        >>> result = thread.get()

        :param async bool
        :param TaxRate tax_rate: Attributes of taxRate to create (required)
        :return: TaxRate
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_tax_rate_with_http_info(tax_rate, **kwargs)
        else:
            (data) = cls._create_tax_rate_with_http_info(tax_rate, **kwargs)
            return data"
4620,"def delete_tax_rate_by_id(cls, tax_rate_id, **kwargs):
        """"""Delete TaxRate

        Delete an instance of TaxRate by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_tax_rate_by_id(tax_rate_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str tax_rate_id: ID of taxRate to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_tax_rate_by_id_with_http_info(tax_rate_id, **kwargs)
        else:
            (data) = cls._delete_tax_rate_by_id_with_http_info(tax_rate_id, **kwargs)
            return data"
4621,"def get_tax_rate_by_id(cls, tax_rate_id, **kwargs):
        """"""Find TaxRate

        Return single instance of TaxRate by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_tax_rate_by_id(tax_rate_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str tax_rate_id: ID of taxRate to return (required)
        :return: TaxRate
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_tax_rate_by_id_with_http_info(tax_rate_id, **kwargs)
        else:
            (data) = cls._get_tax_rate_by_id_with_http_info(tax_rate_id, **kwargs)
            return data"
4622,"def list_all_tax_rates(cls, **kwargs):
        """"""List TaxRates

        Return a list of TaxRates
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_tax_rates(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[TaxRate]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_tax_rates_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_tax_rates_with_http_info(**kwargs)
            return data"
4623,"def replace_tax_rate_by_id(cls, tax_rate_id, tax_rate, **kwargs):
        """"""Replace TaxRate

        Replace all attributes of TaxRate
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_tax_rate_by_id(tax_rate_id, tax_rate, async=True)
        >>> result = thread.get()

        :param async bool
        :param str tax_rate_id: ID of taxRate to replace (required)
        :param TaxRate tax_rate: Attributes of taxRate to replace (required)
        :return: TaxRate
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_tax_rate_by_id_with_http_info(tax_rate_id, tax_rate, **kwargs)
        else:
            (data) = cls._replace_tax_rate_by_id_with_http_info(tax_rate_id, tax_rate, **kwargs)
            return data"
4624,"def update_tax_rate_by_id(cls, tax_rate_id, tax_rate, **kwargs):
        """"""Update TaxRate

        Update attributes of TaxRate
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_tax_rate_by_id(tax_rate_id, tax_rate, async=True)
        >>> result = thread.get()

        :param async bool
        :param str tax_rate_id: ID of taxRate to update. (required)
        :param TaxRate tax_rate: Attributes of taxRate to update. (required)
        :return: TaxRate
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_tax_rate_by_id_with_http_info(tax_rate_id, tax_rate, **kwargs)
        else:
            (data) = cls._update_tax_rate_by_id_with_http_info(tax_rate_id, tax_rate, **kwargs)
            return data"
4625,"def build_append_file_task(urllocation, filelocation):
    """"""Build a task to watch a specific remote url and
append that data to the file. This method should be used
when you would like to keep all of the information stored
on the local machine, but also append the new information
found at the url.

For instance, if the local file is:

```
foo
```

And the remote file is:

```
bar
```

The resulting file will contain:

```
foo
bar
```
    """"""

    config = file_utils.get_celcius_config()
    basename = filelocation.split('/')[-1]
    tmp_filelocation = filelocation.replace(basename, 'tmp_'+basename)
    new_filelocation = filelocation.replace(basename, 'new_'+basename)

    if config['retrieve_command'] == 'curl':
        download_cmd = curl.build_download_file_command(urllocation, tmp_filelocation)
    elif config['retrieve_command'] == 'wget':
        download_cmd = wget.build_download_file_command(urllocation, tmp_filelocation)
    else:
        print(""Invalid retrieve command!"")
        sys.exit(1)

    diff_cmd = diff.build_append_file_command(filelocation, tmp_filelocation)
    compare_cmd = concat.build_and_concat_commands([download_cmd, diff_cmd])
    redirect_cmd = redirect.redirect_output(compare_cmd, new_filelocation)
    full_cmd = concat.concat_commands([touch.touch(filelocation).build_command(), redirect_cmd, rm.build_force_rm_command(tmp_filelocation).build_command(), rm.build_force_rm_command(filelocation).build_command(), mv.mv(new_filelocation, filelocation).build_command()])

    return full_cmd"
4626,"def get_authentic_node_name(self, node_name: str) -> Optional[str]:
        """"""
        Returns the exact, authentic node name for the given node name if a node corresponding to
        the given name exists in the graph (maybe not locally yet) or `None` otherwise.

        By default, this method checks whether a node with the given name exists locally in the
        graph and return `node_name` if it does or `None` otherwise.

        In `Graph` extensions that are used by applications where the user can enter potentially
        incorrect node names, this method should be overridden to improve usability.

        Arguments:
            node_name (str): The node name to return the authentic node name for.

        Returns:
            The authentic name of the node corresponding to the given node name or
            `None` if no such node exists.
        """"""
        # Is there a node with the given name?
        vertex: IGraphVertex = None
        try:
            vertex: IGraphVertex = self._wrapped_graph.vs.find(node_name)
        except ValueError:
            pass

        # Is node_name a node index?
        if vertex is None:
            try:
                vertex: IGraphVertex = self._wrapped_graph.vs[int(node_name)]
            except ValueError:
                return None
            except IndexError:
                return None

        try:
            return vertex[""name""]
        except KeyError:
            return str(vertex.index)"
4627,"def _create_memory_database_interface(self) -> GraphDatabaseInterface:
        """"""
        Creates and returns the in-memory database interface the graph will use.
        """"""
        Base = declarative_base()
        engine = sqlalchemy.create_engine(""sqlite://"", poolclass=StaticPool)
        Session = sessionmaker(bind=engine)

        dbi: GraphDatabaseInterface = create_graph_database_interface(
            sqlalchemy, Session(), Base, sqlalchemy.orm.relationship
        )

        Base.metadata.drop_all(engine)
        Base.metadata.create_all(engine)

        return dbi"
4628,"def _load_neighbors_from_external_source(self) -> None:
        """"""
        Loads the neighbors of the node from the igraph `Graph` instance that is
        wrapped by the graph that has this node.
        """"""
        graph: IGraphWrapper = self._graph
        ig_vertex: IGraphVertex = graph.wrapped_graph.vs[self._igraph_index]
        ig_neighbors: List[IGraphVertex] = ig_vertex.neighbors()
        for ig_neighbor in ig_neighbors:
            try:
                name: str = ig_neighbor[""name""]
            except KeyError:
                name: str = str(ig_neighbor.index)

            try:
                external_id: Optional[str] = ig_neighbor[""external_id""]
            except KeyError:
                external_id: Optional[str] = None

            neighbor: IGraphNode = graph.nodes.get_node_by_name(name,
                                                                can_validate_and_load=True,
                                                                external_id=external_id)
            graph.add_edge(self, neighbor)"
4629,"def _create_node(self, index: int, name: str, external_id: Optional[str] = None) -> IGraphNode:
        """"""
        Returns a new `IGraphNode` instance with the given index and name.

        Arguments:
            index (int): The index of the node to create.
            name (str): The name of the node to create.
            external_id (Optional[str]): The external ID of the node.
        """"""
        return IGraphNode(graph=self._graph, index=index, name=name, external_id=external_id)"
4630,"def parse(self):
        """"""Parse the table data string into records.""""""

        self.parse_fields()
        records = []
        for line in self.t['data'].split('\n'):
            if EMPTY_ROW.match(line):
                continue
            row = [self.autoconvert(line[start_field:end_field+1])
                   for start_field, end_field in self.fields]
            records.append(tuple(row))
        self.records = records"
4631,"def recarray(self):
        """"""Return a recarray from the (parsed) string.""""""

        if self.records is None:
            self.parse()
        try:
            # simple (should this also be subjected to convert.to_int64() ?)
            return numpy.rec.fromrecords(self.records, names=self.names)
        except ValueError:
            # complicated because fromrecords cannot deal with records of lists
            # Quick hack: use objects for lists etc (instead of building the proper
            # data types (see docs for numpy.dtype , eg dtype('coord', (float, 3)) )

            D = numpy.empty(len(self.records[0]), dtype=object)    # number of fields from first record
            types = numpy.array([map(type, r) for r in self.records])  # types of all fields
            for icol, isSame in enumerate([numpy.all(col) for col in types.T]):
                if isSame:
                    D[icol] = types[0][icol]
                else:
                    D[icol] = object
            dtype = numpy.dtype(zip(self.names, D))
            # from numpy.rec.records
            # TODO: this is not working properly yet; for instance, text fields
            # are reduced to length 0 (<U0) and the final convert.to_int64 dies
            # with '<U0'*** TypeError: TypeError('data type not understood',)
            retval = numpy.array(self.records, dtype=dtype)
            res = retval.view(numpy.recarray)
            ## res.dtype = numpy.dtype((numpy.rec.record, res.dtype))  # fails -- ARGH, this makes it a recarray
            return convert.to_int64(res)"
4632,"def parse_fields(self):
        """"""Determine the start and end columns and names of the fields.""""""

        rule = self.t['toprule'].rstrip()  # keep leading space for correct columns!!
        if not (rule == self.t['midrule'].rstrip() and rule == self.t['botrule'].rstrip()):
            raise ParseError(""Table rules differ from each other (check white space)."")
        names = self.t['fields'].split()
        nfields = len(rule.split())
        if nfields != len(names):
            raise ParseError(""number of field names (%d) does not match number of fields (%d)""
                             % (nfields, len(names)))
        fields = []     #  list of tuples (first,last) column of the field
        ifield = 0
        is_field = rule.startswith('=')  # state
        len_rule = len(rule)
        start_field = 0
        end_field = 0
        for c in xrange(len_rule):
            char = rule[c]
            if not is_field and char == '=':
                start_field = c
                is_field = True
            if is_field and (char == ' ' or c == len_rule-1):
                # finished field
                fields.append((start_field, c))
                ifield += 1
                is_field = False
        self.names = names
        self.fields = fields"
4633,"def check_signature(object_name, reference_object, other_object):
    """"""
    Given a reference class or function check if an other class or function
    could be substituted without causing any instantiation/usage issues.

    :param object_name: the name of the object being checked.
    :type object_name: string
    :param reference_object: the reference class or function.
    :type reference_object: class/function
    :param other_object: the other class or function to be checked.
    :type other_object: class/function
    :raise AutodiscoveryCheckerError: in case the other object is not
        compatible with the reference object.
    """"""
    try:
        if inspect.isclass(reference_object):
            # if the reference_object is a class
            if inspect.isclass(other_object):
                # if the other_object is a class
                if issubclass(other_object, reference_object):
                    # if the other_object is derived from the reference we
                    # should check for all the method in the former that
                    # exists in the the latter, wethever they recursively have
                    # the same signature.
                    reference_object_map = dict(
                        inspect.getmembers(reference_object,
                                           inspect.isroutine))
                    for other_method_name, other_method_code in \
                            inspect.getmembers(other_object,
                                               inspect.isroutine):
                        if other_method_name in reference_object_map:
                            check_signature(
                                object_name,
                                reference_object_map[other_method_name],
                                other_method_code)
                else:
                    # if the other_object is not derived from the
                    # reference_object then all the method declared in the
                    # latter should exist in the former and they should
                    # recursively have the same signature.
                    other_object_map = dict(
                        inspect.getmembers(other_object, inspect.isroutine))
                    for reference_method_name, reference_method_code in \
                        inspect.getmembers(
                            reference_object, inspect.isroutine):
                        if reference_method_name in other_object_map:
                            check_signature(
                                object_name, reference_method_code,
                                other_method_code)
                        else:
                            raise AutodiscoveryCheckerError(
                                '""%s"", which'
                                ' exists in the reference class, does not'
                                ' exist in the other class, and the reference'
                                ' class is not an anchestor of the other' %
                                reference_method_name)
            else:
                # We are comparing apples and oranges!
                raise AutodiscoveryCheckerError(
                    ""%s (the reference object)""
                    "" is a class while %s (the other object) is not a class"" %
                    (reference_object, other_object))
        elif inspect.isroutine(reference_object):
            # if the reference_object is a function
            if inspect.isroutine(other_object):
                # if the other_object is a function we will compare the
                # reference_object and other_object function signautre i.e.
                # their parameters.
                reference_args, reference_varargs, reference_varkw, \
                    reference_defaults = inspect.getargspec(reference_object)
                other_args, other_varargs, other_varkw, \
                    other_defaults = inspect.getargspec(other_object)
                # We normalize the reference_defaults to be a list
                if reference_defaults is not None:
                    reference_defaults = list(reference_defaults)
                else:
                    reference_defaults = []

                # We normalize the other_defaults to be a list
                if other_defaults is not None:
                    other_defaults = list(other_defaults)
                else:
                    other_defaults = []

                # Check for presence of missing parameters in other function
                if not (other_varargs or other_varkw):
                    for reference_arg in reference_args:
                        if reference_arg not in other_args:
                            raise AutodiscoveryCheckerError(
                                'Argument ""%s""'
                                ' in reference function %s does not exist in'
                                ' the other function %s' %
                                (reference_arg, reference_object, other_object)
                            )

                # Check for presence of additional parameters in other
                # function
                if not (reference_varargs or reference_varkw):
                    for other_arg in other_args:
                        if other_arg not in reference_args:
                            raise AutodiscoveryCheckerError(
                                'Argument ""%s""'
                                ' in other function %s does not exist in the'
                                ' reference function %s' %
                                (other_arg, other_object, reference_object))

                # Check sorting of arguments
                for reference_arg, other_arg in map(
                        None, reference_args, other_args):
                    if not((reference_arg == other_arg) or
                           (reference_arg is None and
                            (reference_varargs or reference_varkw)) or
                           (other_arg is None and
                            (other_args or other_varargs))):
                        raise AutodiscoveryCheckerError(
                            'Argument ""%s"" in'
                            ' the other function is in the position of'
                            ' argument ""%s"" in the reference function, i.e.'
                            ' the order of arguments is not respected' %
                            (other_arg, reference_arg))

                if len(reference_defaults) != len(other_defaults) and not (
                        reference_args or reference_varargs or
                        other_args or other_varargs):
                    raise AutodiscoveryCheckerError(
                        ""Default parameters in""
                        "" the other function are not corresponding to the""
                        "" default of parameters of the reference function"")
            else:
                # We are comparing apples and oranges!
                raise AutodiscoveryCheckerError(
                    '%s (the reference object)'
                    ' is a function while %s (the other object) is not a'
                    ' function' % (reference_object, other_object))
    except AutodiscoveryCheckerError as err:
        try:
            sourcefile = inspect.getsourcefile(other_object)
            sourceline = inspect.getsourcelines(other_object)[1]
        except IOError:
            # other_object is not loaded from a real file
            sourcefile = 'N/A'
            sourceline = 'N/A'
        raise AutodiscoveryCheckerError(
            'Error in checking signature for'
            ' ""%s"" as defined at ""%s"" (line %s): %s' %
            (object_name, sourcefile, sourceline, err))"
4634,"def check_arguments_compatibility(the_callable, argd):
    """"""
    Check if calling the_callable with the given arguments would be correct
    or not.

    >>> def foo(arg1, arg2, arg3='val1', arg4='val2', *args, **argd):
    ...     pass
    >>> try: check_arguments_compatibility(foo, {'arg1': 'bla', 'arg2': 'blo'})
    ... except ValueError as err: print 'failed'
    ... else: print 'ok'
    ok
    >>> try: check_arguments_compatibility(foo, {'arg1': 'bla'})
    ... except ValueError as err: print 'failed'
    ... else: print 'ok'
    failed

    Basically this function is simulating the call:

    >>> the_callable(**argd)

    but it only checks for the correctness of the arguments, without
    actually calling the_callable.

    :param the_callable: the callable to be analyzed.
    :type the_callable: function/callable
    :param argd: the arguments to be passed.
    :type argd: dict
    :raise ValueError: in case of uncompatibility
    """"""
    if not argd:
        argd = {}
    args, dummy, varkw, defaults = inspect.getargspec(the_callable)
    tmp_args = list(args)
    optional_args = []
    args_dict = {}
    if defaults:
        defaults = list(defaults)
    else:
        defaults = []
    while defaults:
        arg = tmp_args.pop()
        optional_args.append(arg)
        args_dict[arg] = defaults.pop()

    while tmp_args:
        args_dict[tmp_args.pop()] = None

    for arg, dummy_value in iteritems(argd):
        if arg in args_dict:
            del args_dict[arg]
        elif not varkw:
            raise ValueError(
                'Argument %s not expected when calling callable '
                '""%s"" with arguments %s' % (
                    arg, get_callable_signature_as_string(the_callable), argd))

    for arg in args_dict.keys():
        if arg in optional_args:
            del args_dict[arg]

    if args_dict:
        raise ValueError(
            'Arguments %s not specified when calling callable '
            '""%s"" with arguments %s' % (
                ', '.join(args_dict.keys()),
                get_callable_signature_as_string(the_callable),
                argd))"
4635,"def create_enhanced_plugin_builder(compulsory_objects=None,
                                   optional_objects=None,
                                   other_data=None):
    """"""
    Creates a plugin builder function suitable to extract some specific
    objects (either compulsory or optional) and other simpler data

    >>> def dummy_needed_funct1(foo, bar):
    ...     pass
    >>> class dummy_needed_class1:
    ...     def __init__(self, baz):
    ...         pass
    >>> def dummy_optional_funct2(boo):
    ...     pass
    >>> create_enhanced_plugin_builder(
    ...    compulsory_objects={
    ...         'needed_funct1' : dummy_needed_funct1,
    ...         'needed_class1' : dummy_needed_class1
    ...     },
    ...     optional_objects={
    ...         'optional_funct2' : dummy_optional_funct2,
    ...     },
    ...     other_data={
    ...         'CFG_SOME_DATA' : (str, ''),
    ...         'CFG_SOME_INT' : (int, 0),
    ...     })
    <function plugin_builder at 0xb7812064>

    :param compulsory_objects: map of name of an object to look for inside
        the `plugin` and a *signature* for a class or callable. Every
        name specified in this map **must exists** in the plugin, otherwise
        the plugin will fail to load.
    :type compulsory_objects: dict
    :param optional_objects: map of name of an object to look for inside
        the C{plugin} and a I{signature} for a class or callable. Every
        name specified in this map must B{can exists} in the plugin.
    :type optional_objects: dict
    :param other_data: map of other simple data that can be loaded from
        the plugin. The map has the same format of the C{content}
        parameter of L{invenio_ext.legacy.handler.wash_urlargd}.
    :type other_data: dict
    :return: a I{plugin_builder} function that can be used with the
        map function. Such function will build the plugin
        in the form of a map, where every key is one of the keys inside
        the three maps provided as parameters and the corresponding value
        is the expected class or callable or simple data.
    """"""
    from invenio_utils.washers import wash_urlargd

    def plugin_builder(the_plugin):
        """"""
        Enhanced plugin_builder created by L{create_enhanced_plugin_builder}.

        :param plugin: the code of the module as just read from package.
        :return: the plugin in the form of a map.
        """"""
        plugin_name = the_plugin.__name__
        plugin = {}

        if compulsory_objects:
            for object_name, object_signature in \
                    iteritems(compulsory_objects):
                the_object = getattr(the_plugin, object_name, None)
                if the_object is None:
                    raise AutodiscoveryError(
                        'Plugin ""%s"" does not '
                        'contain compulsory object ""%s""' %
                        (plugin_name, object_name))
                try:
                    check_signature(object_name, the_object, object_signature)
                except AutodiscoveryError as err:
                    raise AutodiscoveryError(
                        'Plugin ""%s"" contains '
                        'object ""%s"" with a wrong signature: %s' %
                        (plugin_name, object_name, err))
                plugin[object_name] = the_object

        if optional_objects:
            for object_name, object_signature in iteritems(optional_objects):
                the_object = getattr(the_plugin, object_name, None)
                if the_object is not None:
                    try:
                        check_signature(
                            object_name,
                            the_object,
                            object_signature)
                    except AutodiscoveryError as err:
                        raise AutodiscoveryError(
                            'Plugin ""%s"" '
                            'contains object ""%s"" with a wrong signature: %s' %
                            (plugin_name, object_name, err))
                    plugin[object_name] = the_object

        if other_data:
            the_other_data = {}
            for data_name, (dummy, data_default) in iteritems(other_data):
                the_other_data[data_name] = getattr(the_plugin, data_name,
                                                    data_default)

            try:
                the_other_data = wash_urlargd(the_other_data, other_data)
            except Exception as err:
                raise AutodiscoveryError(
                    'Plugin ""%s"" contains other '
                    'data with problems: %s' %
                    (plugin_name, err))

            plugin.update(the_other_data)
        return plugin

    return plugin_builder"
4636,"def email_quoted_txt2html(text,
                          tabs_before=0,
                          indent_txt='>>',
                          linebreak_txt=""\n"",
                          indent_html=('<div class=""commentbox"">', ""</div>""),
                          linebreak_html='<br/>',
                          indent_block=True):
    """"""
    Takes a typical mail quoted text, e.g.::
        hello,
        you told me:
        >> Your mother was a hamster and your father smelt of elderberries
        I must tell you that I'm not convinced. Then in this discussion:
        >>>> Is there someone else up there we could talk to?
        >> No. Now, go away, or I shall taunt you a second time-a!
        I think we're not going to be friends!

    and return an html formatted output, e.g.::
        hello,<br/>
        you told me:<br/>
        <div>
          Your mother was a hamster and your father smelt of elderberries
        </div>
        I must tell you that I'm not convinced. Then in this discussion:
        <div>
          <div>
            Is there someone else up there we could talk to?
          </div>
          No. Now, go away, or I shall taunt you a second time-a!
        </div>
        I think we're not going to be friends!

    The behaviour is different when C{indent_block} is C{True} or C{False}.
    When C{True} the when C{indent_html} is only added at each change of
    level of indentation, while it is added for each line when C{False}.
    For eg::
        >> a
        >> b
        >>>> c

    would result in (if C{True})::
        <div class=""commentbox"">
            a<br/>
            b<br/>
            <div class=""commentbox"">
                c<br/>
            </div>
        </div>

    or would be (if C{False})::
        <div class=""commentbox""> a</div><br/>
        <div class=""commentbox""> b</div><br/>
        <div class=""commentbox""><div class=""commentbox""> c</div></div><br/>

    @param text: the text in quoted format
    @param tabs_before: number of tabulations before each line
    @param indent_txt: quote separator in email (default:'>>')
    @param linebreak_txt: line separator in email
    @param indent_html: tuple of (opening, closing) html tags.
                        default: ('<div class=""commentbox"">', ""</div>"")
    @param linebreak_html: line separator in html (default: '<br/>')
    @param indent_block: if indentation should be done per 'block'
                         i.e. only at changes of indentation level
                         (+1, -1) or at each line.
    @return: string containing html formatted output
    """"""
    washer = HTMLWasher()

    final_body = """"
    nb_indent = 0
    text = text.strip('\n')
    lines = text.split(linebreak_txt)
    for line in lines:
        new_nb_indent = 0
        while True:
            if line.startswith(indent_txt):
                new_nb_indent += 1
                line = line[len(indent_txt):]
            else:
                break
        if indent_block:
            if (new_nb_indent > nb_indent):
                for dummy in range(nb_indent, new_nb_indent):
                    final_body += tabs_before * ""\t"" + indent_html[0] + ""\n""
                    tabs_before += 1
            elif (new_nb_indent < nb_indent):
                for dummy in range(new_nb_indent, nb_indent):
                    tabs_before -= 1
                    final_body += (tabs_before) * ""\t"" + indent_html[1] + ""\n""
            else:
                final_body += (tabs_before) * ""\t""
        else:
            final_body += tabs_before * ""\t"" + new_nb_indent * indent_html[0]
        try:
            line = washer.wash(line)
        except HTMLParseError:
            # Line contained something like ""foo<bar""
            line = cgi.escape(line)
        if indent_block:
            final_body += tabs_before * ""\t""
        final_body += line
        if not indent_block:
            final_body += new_nb_indent * indent_html[1]
        final_body += linebreak_html + ""\n""
        nb_indent = new_nb_indent
    if indent_block:
        for dummy in range(0, nb_indent):
            tabs_before -= 1
            final_body += (tabs_before) * ""\t"" + ""</div>\n""
    return final_body"
4637,"def email_quote_txt(text,
                    indent_txt='>>',
                    linebreak_input=""\n"",
                    linebreak_output=""\n""):
    """"""
    Takes a text and returns it in a typical mail quoted format, e.g.::
        C'est un lapin, lapin de bois.
        >>Quoi?
        Un cadeau.
        >>What?
        A present.
        >>Oh, un cadeau.

    will return::
        >>C'est un lapin, lapin de bois.
        >>>>Quoi?
        >>Un cadeau.
        >>>>What?
        >>A present.
        >>>>Oh, un cadeau.

    @param text: the string to quote
    @param indent_txt: the string used for quoting (default: '>>')
    @param linebreak_input: in the text param, string used for linebreaks
    @param linebreak_output: linebreak used for output
    @return: the text as a quoted string
    """"""
    if (text == """"):
        return """"
    lines = text.split(linebreak_input)
    text = """"
    for line in lines:
        text += indent_txt + line + linebreak_output
    return text"
4638,"def escape_email_quoted_text(text, indent_txt='>>', linebreak_txt='\n'):
    """"""
    Escape text using an email-like indenting rule.
    As an example, this text::
        >>Brave Sir Robin ran away...
        <img src=""malicious_script />*No!*
        >>bravely ran away away...
        I didn't!*<script>malicious code</script>
        >>When danger reared its ugly head, he bravely turned his tail and fled.
        <form onload=""malicious""></form>*I never did!*

    will be escaped like this::
        >>Brave Sir Robin ran away...
        &lt;img src=""malicious_script /&gt;*No!*
        >>bravely ran away away...
        I didn't!*&lt;script&gt;malicious code&lt;/script&gt;
        >>When danger reared its ugly head, he bravely turned his tail and fled.
        &lt;form onload=""malicious""&gt;&lt;/form&gt;*I never did!*

    @param text: the string to escape
    @param indent_txt: the string used for quoting
    @param linebreak_txt: in the text param, string used for linebreaks
    """"""
    washer = HTMLWasher()
    lines = text.split(linebreak_txt)
    output = ''
    for line in lines:
        line = line.strip()
        nb_indent = 0
        while True:
            if line.startswith(indent_txt):
                nb_indent += 1
                line = line[len(indent_txt):]
            else:
                break
        output += (nb_indent * indent_txt) + washer.wash(line,
                                                         render_unallowed_tags=True) + linebreak_txt
        nb_indent = 0
    return output[:-1]"
4639,"def _print(self, text, color=None, **kwargs):
        """"""print text with given color to terminal
        """"""
        COLORS = {
            'red': '\033[91m{}\033[00m',
            'green': '\033[92m{}\033[00m',
            'yellow': '\033[93m{}\033[00m',
            'cyan': '\033[96m{}\033[00m'
        }
        _ = COLORS[color]
        six.print_(_.format(text), **kwargs)"
4640,"def _is_unique(self, name, path):
        """"""verify if there is a project with given name or path
        on the database
        """"""
        project = None
        try:
            project = Project.select().where(
                (Project.name == name) |
                (Project.path == path)
            )[0]
        except:
            pass

        return project is None"
4641,"def _path_is_valid(self, path):
        """"""validates if a given path is:
        - absolute,
        - exists on current machine
        - is a directory
        """"""
        VALIDATORS = [
            (os.path.isabs, self._ERROR_PATH_NOT_ABSOLUTE),
            (os.path.exists, self._ERROR_PATH_DOESNT_EXISTS),
            (os.path.isdir, self._ERROR_PATH_NOT_A_DIR),
        ]

        for validator in VALIDATORS:
            func, str_err = validator
            if not func(path):
                self._print(str_err.format(path), 'red')
                return
        return True"
4642,"def add(self, name, path=None, **kwargs):
        """"""add new project with given name and path to database
        if the path is not given, current working directory will be taken
        ...as default
        """"""
        path = path or kwargs.pop('default_path', None)

        if not self._path_is_valid(path):
            return

        if not self._is_unique(name, path):
            p = Project.select().where(
                (Project.name == name) |
                (Project.path == path)
            )[0]
            self._print(self._ERROR_PROJECT_EXISTS.format(name, p.path), 'red')
            return

        Project.create(name=name, path=path)
        self._print(self._SUCCESS_PROJECT_ADDED.format(name), 'green')"
4643,"def list(self, **kwargs):
        """"""displays all projects on database
        """"""
        projects = Project.select().order_by(Project.name)
        if len(projects) == 0:
            self._print('No projects available', 'yellow')
            return

        for project in projects:
            project_repr = self._PROJECT_ITEM.format(project.name, project.path)
            row = '- {}'.format(self._PROJECT_ITEM.format(project.name, project.path))
            six.print_(row)"
4644,"def parent_tags(self):
        """"""Provides tags of all parent HTML elements.""""""
        tags = set()

        for addr in self._addresses:
            if addr.attr == 'text':
                tags.add(addr.element.tag)
            tags.update(el.tag for el in addr.element.iterancestors())

        tags.discard(HTMLFragment._root_tag)
        return frozenset(tags)"
4645,"def involved_tags(self):
        """"""Provides all HTML tags directly involved in this string.""""""
        if len(self._addresses) < 2:
            # there can't be a tag boundary if there's only 1 or 0 characters
            return frozenset()

        # creating 'parent_sets' mapping, where the first item in tuple
        # is the address of character and the second is set
        # of character's parent HTML elements
        parent_sets = []

        # meanwhile we are creatingalso a set of common parents so we can
        # put them away later on (we're not interested in them as
        # they're only some global wrappers)
        common_parents = set()

        for addr in self._addresses:
            parents = set()
            if addr.attr == 'text':
                parents.add(addr.element)
            parents.update(addr.element.iterancestors())

            parent_sets.append((addr, parents))
            if not common_parents:
                common_parents = parents
            else:
                common_parents &= parents

        # constructing final set of involved tags
        involved_tags = set()
        prev_addr = None

        for addr, parents in parent_sets:
            parents = parents - common_parents
            involved_tags.update(p.tag for p in parents)

            # hidden tags - sometimes there are tags without text which
            # can hide between characters, but they actually break textflow
            is_tail_of_hidden = (
                prev_addr and
                addr.attr == 'tail' and
                prev_addr.element != addr.element
            )
            if is_tail_of_hidden:
                involved_tags.add(addr.element)

            prev_addr = addr

        return frozenset(involved_tags)"
4646,"def _parse(self, html):
        """"""Parse given string as HTML and return it's etree representation.""""""
        if self._has_body_re.search(html):
            tree = lxml.html.document_fromstring(html).find('.//body')
            self.has_body = True
        else:
            tree = lxml.html.fragment_fromstring(html,
                                                 create_parent=self._root_tag)

        if tree.tag != self._root_tag:
            # ensure the root element exists even if not really needed,
            # so the tree has always the same structure
            root = lxml.html.HtmlElement()
            root.tag = self._root_tag
            root.append(tree)
            return root
        return tree"
4647,"def _iter_texts(self, tree):
        """"""Iterates over texts in given HTML tree.""""""
        skip = (
            not isinstance(tree, lxml.html.HtmlElement)  # comments, etc.
            or tree.tag in self.skipped_tags
        )
        if not skip:
            if tree.text:
                yield Text(tree.text, tree, 'text')
            for child in tree:
                for text in self._iter_texts(child):
                    yield text
        if tree.tail:
            yield Text(tree.tail, tree, 'tail')"
4648,"def _analyze_tree(self, tree):
        """"""Analyze given tree and create mapping of indexes to character
        addresses.
        """"""
        addresses = []
        for text in self._iter_texts(tree):
            for i, char in enumerate(text.content):
                if char in whitespace:
                    char = ' '
                addresses.append(CharAddress(char, text.element, text.attr, i))

        # remove leading and trailing whitespace
        while addresses and addresses[0].char == ' ':
            del addresses[0]
        while addresses and addresses[-1].char == ' ':
            del addresses[-1]

        return addresses"
4649,"def _validate_index(self, index):
        """"""Validates given index, eventually raises errors.""""""
        if isinstance(index, slice):
            if index.step and index.step != 1:
                raise IndexError('Step is not allowed.')
            indexes = (index.start, index.stop)
        else:
            indexes = (index,)
        for index in indexes:
            if index is not None and index < 0:
                raise IndexError('Negative indexes are not allowed.')"
4650,"def _find_pivot_addr(self, index):
        """"""Inserting by slicing can lead into situation where no addresses are
        selected. In that case a pivot address has to be chosen so we know
        where to add characters.
        """"""
        if not self.addresses or index.start == 0:
            return CharAddress('', self.tree, 'text', -1)  # string beginning
        if index.start > len(self.addresses):
            return self.addresses[-1]
        return self.addresses[index.start]"
4651,"def apply_connectivity_changes(request, add_vlan_action, remove_vlan_action, logger=None):
    """"""
    Standard implementation for the apply_connectivity_changes operation
    This function will accept as an input the actions to perform for add/remove vlan. It implements
    the basic flow of decoding the JSON connectivity changes requests, and combining the results
    of the add/remove vlan functions into a result object.

    :param str request: json string sent from the CloudShell server describing the connectivity changes to perform
    :param Function -> ConnectivityActionResult remove_vlan_action: This action will be called for VLAN remove operations
    :param Function -> ConnectivityActionResult add_vlan_action: This action will be called for VLAN add operations
    :param logger: logger to use for the operation, if you don't provide a logger, a default Python logger will be used
    :return Returns a driver action result object, this can be returned to CloudShell server by the command result
    :rtype: DriverResponseRoot
    """"""

    if not logger:
        logger = logging.getLogger(""apply_connectivity_changes"")

    if request is None or request == '':
        raise Exception('ConnectivityOperations', 'request is None or empty')

    holder = connectivity_request_from_json(request)

    driver_response = DriverResponse()
    results = []
    driver_response_root = DriverResponseRoot()

    for action in holder.actions:
        logger.info('Action: ', action.__dict__)
        if action.type == ConnectivityActionRequest.SET_VLAN:
            action_result = add_vlan_action(action)

        elif action.type == ConnectivityActionRequest.REMOVE_VLAN:
            action_result = remove_vlan_action(action)

        else:
            continue
        results.append(action_result)

    driver_response.actionResults = results
    driver_response_root.driverResponse = driver_response
    return driver_response_root"
4652,"def check_api_key(email, api_key):
    """"""Check the API key of the user.""""""
    table = boto3.resource(""dynamodb"").Table(os.environ['people'])
    user = table.get_item(Key={'email': email})
    if not user:
        return False
    user = user.get(""Item"")
    if api_key != user.get('api_key', None):
        return False
    return user"
4653,"def lambda_handler(event, context):
    """"""Main handler.""""""
    email = event.get('email', None)
    api_key = event.get('api_key', None)
    if not (api_key or email):
        msg = ""Missing authentication parameters in your request""
        return {'success': False, 'message': msg}
    indicators = list(set(event.get('indicators', list())))
    if len(indicators) == 0:
        return {'success': False, 'message': ""No indicators sent in""}
    user = check_api_key(email, api_key)
    if not user:
        return {'success': False, 'message': ""Email or API key was invalid.""}
    role = check_role(user)
    if not role:
        return {'success': False, 'message': ""Account not approved to contribute.""}
    current_time = datetime.datetime.now().strftime(""%Y-%m-%d %H:%M:%S"")
    table = boto3.resource(""dynamodb"").Table(os.environ['database'])
    with table.batch_writer(overwrite_by_pkeys=['indicator']) as batch:
        for item in indicators:
            if item == """":
                continue
            if len(item) != 32:
                item = hashlib.md5(item).hexdigest()
            try:
                batch.put_item(Item={'indicator': item,
                                     'creator': user.get('email'),
                                     'datetime': current_time})
            except Exception as e:
                logger.error(str(e))

    msg = ""Wrote {} indicators"".format(len(indicators))
    return {'success': True, 'message': msg, 'writeCount': len(indicators)}"
4654,"def parse_email_url(url):
    """"""Parses an email URL.""""""

    conf = {}

    url = urlparse.urlparse(url)

    # Remove query strings
    path = url.path[1:]
    path = path.split('?', 2)[0]

    # Update with environment configuration
    conf.update({
        'EMAIL_FILE_PATH': path,
        'EMAIL_HOST_USER': url.username,
        'EMAIL_HOST_PASSWORD': url.password,
        'EMAIL_HOST': url.hostname,
        'EMAIL_PORT': url.port,
    })

    if url.scheme in EMAIL_SCHEMES:
        conf['EMAIL_BACKEND'] = EMAIL_SCHEMES[url.scheme]

    if url.scheme == 'smtps':
        conf['EMAIL_USE_TLS'] = True
    else:
        conf['EMAIL_USE_TLS'] = False

    return conf"
4655,"def config(name='EMAIL_URL', default='console://'):
    """"""Returns a dictionary with EMAIL_* settings from EMAIL_URL.""""""
    conf = {}
    s = env(name, default)
    if s:
        conf = parse_email_url(s)
    return conf"
4656,"def replace(html, replacements=None):
    """"""Performs replacements on given HTML string.""""""
    if not replacements:
        return html  # no replacements
    html = HTMLFragment(html)

    for r in replacements:
        r.replace(html)

    return unicode(html)"
4657,"def _is_replacement_allowed(self, s):
        """"""Tests whether replacement is allowed on given piece of HTML text.""""""
        if any(tag in s.parent_tags for tag in self.skipped_tags):
            return False
        if any(tag not in self.textflow_tags for tag in s.involved_tags):
            return False
        return True"
4658,"def replace(self, html):
        """"""Perform replacements on given HTML fragment.""""""
        self.html = html
        text = html.text()
        positions = []

        def perform_replacement(match):
            offset = sum(positions)
            start, stop = match.start() + offset, match.end() + offset

            s = self.html[start:stop]
            if self._is_replacement_allowed(s):
                repl = match.expand(self.replacement)
                self.html[start:stop] = repl
            else:
                repl = match.group()  # no replacement takes place

            positions.append(match.end())
            return repl

        while True:
            if positions:
                text = text[positions[-1]:]

            text, n = self.pattern.subn(perform_replacement, text, count=1)
            if not n:  # all is already replaced
                break"
4659,"def read_relative_file(filename, relative_to=None):
    """"""Returns contents of the given file, which path is supposed relative
    to this package.""""""
    if relative_to is None:
        relative_to = os.path.dirname(__file__)
    with open(os.path.join(os.path.dirname(relative_to), filename)) as f:
        return f.read()"
4660,"def get_events(self):
        """"""Get events from the cloud node.""""""
        to_send = {'limit': 50}
        response = self._send_data('POST', 'admin', 'get-events', to_send)

        output = {'message': """"}
        for event in response['events']:
            desc = ""Source IP: {ip}\n""
            desc += ""Datetime: {time}\n""
            desc += ""Indicator: {match}\n""
            desc += ""Method: {method}\n""
            desc += ""URL: {url}\n""
            desc += ""Request Type: {type}\n""
            desc += ""User-Agent: {userAgent}\n""
            desc += ""Contact: {contact}\n""
            desc += ""\n""
            output['message'] += desc.format(**event)

        return output"
4661,"def flush_events(self):
        """"""Flush events from the cloud node.""""""
        response = self._send_data('DELETE', 'admin', 'flush-events', {})

        if response['success']:
            msg = ""Events flushed""
        else:
            msg = ""Flushing of events failed""
        output = {'message': msg}

        return output"
4662,"def put(self):
        """"""Push the info represented by this ``Metric`` to CloudWatch.""""""
        try:
            self.cloudwatch.put_metric_data(
                    Namespace=self.namespace,
                    MetricData=[{
                        'MetricName': self.name,
                        'Value': self.value,
                        'Timestamp': self.timestamp
                    }]
            )
        except Exception:
            logging.exception(""Error pushing {0} to CloudWatch."".format(str(self)))"
4663,"def log(self, message, level=logging.INFO, *args, **kwargs):
        """""" Send log entry

        :param str message: log message
        :param int level: `Logging level <https://docs.python.org/3/library/logging.html#levels>`_
        :param list args: log record arguments
        :param dict kwargs: log record key argument
        """"""
        msg = ""{}.{}: {}[{}]: {}"".format(
            self.__class__.__name__, self.status, self.__class__.path,
            self.uuid, message
        )
        extra = kwargs.pop(""extra"", dict())
        extra.update(dict(kmsg=Message(
            self.uuid, entrypoint=self.__class__.path, params=self.params,
            metadata=self.metadata
        ).dump()))

        return logger.log(
            level=level, msg=msg, extra=extra, *args, **kwargs
        )"
4664,"def setFocus(self, reason=None):
        """"""Sets focus to first field. Note: reason is ignored.""""""
        self.formLayout.itemAt(0, QFormLayout.FieldRole).widget().setFocus()"
4665,"def _connect(self):
        """"""
        Connect to a RabbitMQ instance

        :returns: Boolean corresponding to success of connection
        :rtype: bool

        """"""
        logger.info(""Connecting to rabbit"")
        for url in self._urls:
            try:
                self._connection = pika.BlockingConnection(pika.URLParameters(url))
                self._channel = self._connection.channel()
                self._declare()
                if self._confirm_delivery:
                    self._channel.confirm_delivery()
                    logger.info(""Enabled delivery confirmation"")
                logger.debug(""Connected to rabbit"")
                return True

            except pika.exceptions.AMQPConnectionError:
                logger.exception(""Unable to connect to rabbit"")
                continue
            except Exception:
                logger.exception(""Unexpected exception connecting to rabbit"")
                continue

        raise pika.exceptions.AMQPConnectionError"
4666,"def _disconnect(self):
        """"""
        Cleanly close a RabbitMQ connection.

        :returns: None

        """"""
        try:
            self._connection.close()
            logger.debug(""Disconnected from rabbit"")
        except Exception:
            logger.exception(""Unable to close connection"")"
4667,"def publish_message(self, message, content_type=None, headers=None, mandatory=False, immediate=False):
        """"""
        Publish a response message to a RabbitMQ instance.

        :param message: Response message
        :param content_type: Pika BasicProperties content_type value
        :param headers: Message header properties
        :param mandatory: The mandatory flag
        :param immediate: The immediate flag

        :returns: Boolean corresponding to the success of publishing
        :rtype: bool

        """"""
        logger.debug(""Publishing message"")
        try:
            self._connect()
            return self._do_publish(mandatory=mandatory,
                                    immediate=immediate,
                                    content_type=content_type,
                                    headers=headers,
                                    message=message)
        except pika.exceptions.AMQPConnectionError:
            logger.error(""AMQPConnectionError occurred. Message not published."")
            raise PublishMessageError
        except NackError:
            # raised when a message published in publisher-acknowledgments mode
            # is returned via `Basic.Return` followed by `Basic.Ack`.
            logger.error(""NackError occurred. Message not published."")
            raise PublishMessageError
        except UnroutableError:
            # raised when a message published in publisher-acknowledgments
            # mode is returned via `Basic.Return` followed by `Basic.Ack`.
            logger.error(""UnroutableError occurred. Message not published."")
            raise PublishMessageError
        except Exception:
            logger.exception(""Unknown exception occurred. Message not published."")
            raise PublishMessageError"
4668,"def visit(folder, provenance_id, step_name, previous_step_id=None, config=None, db_url=None, is_organised=True):
    """"""Record all files from a folder into the database.

    Note:
    If a file has been copied from a previous processing step without any transformation, it will be detected and
    marked in the DB. The type of file will be detected and stored in the DB (NIFTI, DICOM, ...). If a files
    (e.g. a DICOM file) contains some meta-data, those will be stored in the DB.

    Arguments:
    :param folder: folder path.
    :param provenance_id: provenance label.
    :param step_name: Name of the processing step that produced the folder to visit.
    :param previous_step_id: (optional) previous processing step ID. If not defined, we assume this is the first
    processing step.
    :param config: List of flags:
        - boost: (optional) When enabled, we consider that all the files from a same folder share the same meta-data.
        When enabled, the processing is (about 2 times) faster. This option is enabled by default.
        - session_id_by_patient: Rarely, a data set might use study IDs which are unique by patient (not for the whole
        study).
        E.g.: LREN data. In such a case, you have to enable this flag. This will use PatientID + StudyID as a session
        ID.
        - visit_id_in_patient_id: Rarely, a data set might mix patient IDs and visit IDs. E.g. : LREN data. In such a
        case, you have to enable this flag. This will try to split PatientID into VisitID and PatientID.
        - visit_id_from_path: Enable this flag to get the visit ID from the folder hierarchy instead of DICOM meta-data
        (e.g. can be useful for PPMI).
        - repetition_from_path: Enable this flag to get the repetition ID from the folder hierarchy instead of DICOM
        meta-data (e.g. can be useful for PPMI).
    :param db_url: (optional) Database URL. If not defined, it looks for an Airflow configuration file.
    :param is_organised: (optional) Disable this flag when scanning a folder that has not been organised yet
    (should only affect nifti files).
    :return: return processing step ID.
    """"""
    config = config if config else []

    logging.info(""Visiting %s"", folder)
    logging.info(""-> is_organised=%s"", str(is_organised))
    logging.info(""-> config=%s"", str(config))

    logging.info(""Connecting to database..."")
    db_conn = connection.Connection(db_url)

    step_id = _create_step(db_conn, step_name, provenance_id, previous_step_id)

    previous_files_hash = _get_files_hash_from_step(db_conn, previous_step_id)

    checked = dict()

    def process_file(file_path):
        logging.debug(""Processing '%s'"" % file_path)
        file_type = _find_type(file_path)
        if ""DICOM"" == file_type:
            is_copy = _hash_file(file_path) in previous_files_hash
            leaf_folder = os.path.split(file_path)[0]
            if leaf_folder not in checked or 'boost' not in config:
                ret = dicom_import.dicom2db(file_path, file_type, is_copy, step_id, db_conn,
                                            'session_id_by_patient' in config, 'visit_id_in_patient_id' in config,
                                            'visit_id_in_patient_id' in config, 'repetition_from_path' in config)
                try:
                    checked[leaf_folder] = ret['repetition_id']
                except KeyError:
                    # TODO: Remove it when dicom2db will be more stable
                    logging.warning(""Cannot find repetition ID !"")
            else:
                dicom_import.extract_dicom(
                    file_path, file_type, is_copy, checked[leaf_folder], step_id)
        elif ""NIFTI"" == file_type and is_organised:
            is_copy = _hash_file(file_path) in previous_files_hash
            nifti_import.nifti2db(file_path, file_type, is_copy, step_id, db_conn, 'session_id_by_patient' in config,
                                  'visit_id_in_patient_id' in config)
        elif file_type:
            is_copy = _hash_file(file_path) in previous_files_hash
            others_import.others2db(
                file_path, file_type, is_copy, step_id, db_conn)

    if sys.version_info.major == 3 and sys.version_info.minor < 5:
        matches = []
        for root, dirnames, filenames in os.walk(folder):
            for filename in fnmatch.filter(filenames, '*'):
                matches.append(os.path.join(root, filename))
        for file_path in matches:
            process_file(file_path)
    else:
        for file_path in glob.iglob(os.path.join(folder, ""**/*""), recursive=True):
            process_file(file_path)

    logging.info(""Closing database connection..."")
    db_conn.close()

    return step_id"
4669,"def create_provenance(dataset, software_versions=None, db_url=None):
    """"""Create (or get if already exists) a provenance entity, store it in the database and get back a provenance ID.

    Arguments:
    :param dataset: Name of the data set.
    :param software_versions: (optional) Version of the software components used to get the data. It is a dictionary
    that accepts the following fields:
        - matlab_version
        - spm_version
        - spm_revision
        - fn_called
        - fn_version
        - others
    :param db_url: (optional) Database URL. If not defined, it looks for an Airflow configuration file.
    :return: Provenance ID.
    """"""
    logging.info(""Connecting to database..."")
    db_conn = connection.Connection(db_url)

    try:
        matlab_version = software_versions['matlab_version']
    except (KeyError, TypeError):
        matlab_version = None
    try:
        spm_version = software_versions['spm_version']
    except (KeyError, TypeError):
        spm_version = None
    try:
        spm_revision = software_versions['spm_revision']
    except (KeyError, TypeError):
        spm_revision = None
    try:
        fn_called = software_versions['fn_called']
    except (KeyError, TypeError):
        fn_called = None
    try:
        fn_version = software_versions['fn_version']
    except (KeyError, TypeError):
        fn_version = None
    try:
        others = software_versions['others']
    except (KeyError, TypeError):
        others = None

    provenance = db_conn.db_session.query(db_conn.Provenance).filter_by(
        dataset=dataset, matlab_version=matlab_version, spm_version=spm_version, spm_revision=spm_revision,
        fn_called=fn_called, fn_version=fn_version, others=others
    ).first()

    if not provenance:
        provenance = db_conn.Provenance(
            dataset=dataset, matlab_version=matlab_version, spm_version=spm_version, spm_revision=spm_revision,
            fn_called=fn_called, fn_version=fn_version, others=others
        )
        db_conn.db_session.merge(provenance)
        db_conn.db_session.commit()

        provenance = db_conn.db_session.query(db_conn.Provenance).filter_by(
            dataset=dataset, matlab_version=matlab_version, spm_version=spm_version, spm_revision=spm_revision,
            fn_called=fn_called, fn_version=fn_version, others=others
        ).first()

    provenance_id = provenance.id

    logging.info(""Closing database connection..."")
    db_conn.close()

    return provenance_id"
4670,"def check_sockets(self):
        '''
        Check for new messages on sockets and respond accordingly.


        .. versionchanged:: 0.11.3
            Update routes table by setting ``df_routes`` property of
            :attr:`parent.canvas_slave`.

        .. versionchanged:: 0.12
            Update ``dynamic_electrode_state_shapes`` layer of
            :attr:`parent.canvas_slave` when dynamic electrode actuation states
            change.

        .. versionchanged:: 0.13
            Update local global, electrode, and route command lists in response
            to ``microdrop.command_plugin`` messages.
        '''
        try:
            msg_frames = (self.command_socket
                          .recv_multipart(zmq.NOBLOCK))
        except zmq.Again:
            pass
        else:
            self.on_command_recv(msg_frames)

        try:
            msg_frames = (self.subscribe_socket
                          .recv_multipart(zmq.NOBLOCK))
            source, target, msg_type, msg_json = msg_frames

            if ((source == 'microdrop.device_info_plugin') and
                (msg_type == 'execute_reply')):
                msg = json.loads(msg_json)
                if msg['content']['command'] == 'get_device':
                    data = decode_content_data(msg)
                    if data is not None:
                        self.parent.on_device_loaded(data)
            elif ((source == 'microdrop.electrode_controller_plugin') and
                (msg_type == 'execute_reply')):
                msg = json.loads(msg_json)
                if msg['content']['command'] in ('set_electrode_state',
                                                 'set_electrode_states'):
                    data = decode_content_data(msg)
                    if data is None:
                        print msg
                    else:
                        #self.emit('electrode-states-updated', data)
                        self.parent.on_electrode_states_updated(data)
                elif msg['content']['command'] == 'get_channel_states':
                    data = decode_content_data(msg)
                    if data is None:
                        print msg
                    else:
                        #self.emit('electrode-states-set', data)
                        self.parent.on_electrode_states_set(data)
            elif ((source == 'droplet_planning_plugin') and
                  (msg_type == 'execute_reply')):
                msg = json.loads(msg_json)
                if msg['content']['command'] in ('add_route', ):
                    self.execute_async('droplet_planning_plugin',
                                       'get_routes')
                elif msg['content']['command'] in ('get_routes', ):
                    data = decode_content_data(msg)
                    self.parent.canvas_slave.df_routes = data
            elif ((source == 'microdrop.command_plugin') and
                  (msg_type == 'execute_reply')):
                msg = json.loads(msg_json)

                if msg['content']['command'] in ('get_commands',
                                                 'unregister_command',
                                                 'register_command'):
                    df_commands = decode_content_data(msg).set_index('namespace')

                    for group_i, df_i in df_commands.groupby('namespace'):
                        register = getattr(self.parent.canvas_slave,
                                           'register_%s_command' % group_i,
                                           None)
                        if register is None:
                            continue
                        else:
                            for j, command_ij in df_i.iterrows():
                                register(command_ij.command_name,
                                         title=command_ij.title,
                                         group=command_ij.plugin_name)
                                _L().debug('registered %s command: `%s`',
                                           group_i, command_ij)
            else:
                self.most_recent = msg_json
        except zmq.Again:
            pass
        except:
            logger.error('Error processing message from subscription '
                         'socket.', exc_info=True)

        return True"
4671,"def on_execute__set_video_config(self, request):
        '''
        .. versionchanged:: 0.12
            Accept empty video configuration as either `None` or an empty
            `pandas.Series`.
        '''
        data = decode_content_data(request)
        compare_fields = ['device_name', 'width', 'height', 'name', 'fourcc',
                          'framerate']
        if data['video_config'] is None or not data['video_config'].shape[0]:
            i = None
        else:
            for i, row in self.parent.video_mode_slave.configs.iterrows():
                if (row[compare_fields] ==
                        data['video_config'][compare_fields]).all():
                    break
            else:
                i = None
        if i is None:
            logger.error('Unsupported video config:\n%s', data['video_config'])
            logger.error('Video configs:\n%s',
                         self.parent.video_mode_slave.configs)
            self.parent.video_mode_slave.config_combo.set_active(0)
        else:
            logger.error('Set video config (%d):\n%s', i + 1,
                         data['video_config'])
            self.parent.video_mode_slave.config_combo.set_active(i + 1)"
4672,"def on_execute__set_surface_alphas(self, request):
        '''
        .. versionchanged:: 0.12
            Queue redraw after setting surface alphas.
        '''
        data = decode_content_data(request)
        logger.debug('[on_execute__set_surface_alphas] %s',
                     data['surface_alphas'])
        for name, alpha in data['surface_alphas'].iteritems():
            self.parent.canvas_slave.set_surface_alpha(name, alpha)
        self.parent.canvas_slave.render()
        gobject.idle_add(self.parent.canvas_slave.draw)"
4673,"def on_execute__set_dynamic_electrode_states(self, request):
        '''
        .. versionadded:: 0.15

        Set dynamic electrode states.
        '''
        data = decode_content_data(request)
        self.parent.on_dynamic_electrode_states_set(data['electrode_states'])"
4674,"def on_connect_button__clicked(self, event):
        '''
        Connect to Zero MQ plugin hub (`zmq_plugin.hub.Hub`) using the settings
        from the text entry fields (e.g., hub URI, plugin name).

        Emit `plugin-connected` signal with the new plugin instance after hub
        connection has been established.
        '''
        hub_uri = self.plugin_uri.get_text()
        ui_plugin_name = self.ui_plugin_name.get_text()

        plugin = self.create_plugin(ui_plugin_name, hub_uri)
        self.init_plugin(plugin)

        self.connect_button.set_sensitive(False)
        self.emit('plugin-connected', plugin)"
4675,"def create_quali_api_instance(context, logger):
    """"""
    Get needed attributes from context and create instance of QualiApiHelper
    :param context:
    :param logger:
    :return:
    """"""
    if hasattr(context, 'reservation') and context.reservation:
        domain = context.reservation.domain
    elif hasattr(context, 'remote_reservation') and context.remote_reservation:
        domain = context.remote_reservation.domain
    else:
        domain = None
    address = context.connectivity.server_address
    token = context.connectivity.admin_auth_token
    if token:
        instance = QualiAPIHelper(address, logger, token=token, domain=domain)
    else:
        instance = QualiAPIHelper(address, logger, username='admin', password='admin', domain=domain)
    return instance"
4676,"def login(self):
        """"""
        Login
        :return:
        """"""
        uri = 'API/Auth/Login'
        if self._token:
            json_data = {'token': self._token, 'domain': self._domain}
        else:
            json_data = {'username': self._username, 'password': self._password, 'domain': self._domain}
        result = self.__rest_client.request_put(uri, json_data)
        self.__rest_client.session.headers.update(authorization=""Basic {0}"".format(result.replace('""', '')))"
4677,"def run_migrations_offline():
    """"""Run migrations in 'offline' mode.

    This configures the context with just a URL
    and not an Engine, though an Engine is acceptable
    here as well.  By skipping the Engine creation
    we don't even need a DBAPI to be available.

    Calls to context.execute() here emit the given string to the
    script output.

    """"""
    url = winchester_config['database']['url']
    context.configure(url=url)

    with context.begin_transaction():
        context.run_migrations()"
4678,"def run_migrations_online():
    """"""Run migrations in 'online' mode.

    In this scenario we need to create an Engine
    and associate a connection with the context.

    """"""
    engine = engine_from_config(
        winchester_config['database'],
        prefix='',
        poolclass=pool.NullPool)

    connection = engine.connect()
    context.configure(
        connection=connection,
        target_metadata=target_metadata
    )

    try:
        with context.begin_transaction():
            context.run_migrations()
    finally:
        connection.close()"
4679,"def follow_cf(save, Uspan, target_cf, nup, n_tot=5.0, slsp=None):
    """"""Calculates the quasiparticle weight in single
       site spin hamiltonian under with N degenerate half-filled orbitals """"""

    if slsp == None:
        slsp = Spinon(slaves=6, orbitals=3, avg_particles=n_tot,
                       hopping=[0.5]*6, populations = np.asarray([n_tot]*6)/6)

    zet, lam, mu, mean_f = [], [], [], []

    for co in Uspan:
        print('U=', co, 'del=', target_cf)
        res=root(targetpop, nup[-1],(co,target_cf,slsp, n_tot))
        print(res.x)
        if res.x>nup[-1]: break

        nup.append(res.x)
        slsp.param['populations']=population_distri(nup[-1])
        mean_f.append(slsp.mean_field())
        zet.append(slsp.quasiparticle_weight())
        lam.append(slsp.param['lambda'])
        mu.append(orbital_energies(slsp.param, zet[-1]))

#    plt.plot(np.asarray(zet)[:,0], label='d={}, zl'.format(str(target_cf)))
#    plt.plot(np.asarray(zet)[:,5], label='d={}, zh'.format(str(target_cf)))

    case = save.createGroup('cf={}'.format(target_cf))
    varis = st.setgroup(case)
    st.storegroup(varis, Uspan[:len(zet)], zet, lam, mu, nup[1:],target_cf,mean_f)"
4680,"def targetpop(upper_density, coul, target_cf, slsp, n_tot):
    """"""restriction on finding the right populations that leave the crystal
    field same""""""
    if upper_density < 0.503: return 0.
    trypops=population_distri(upper_density, n_tot)
    slsp.set_filling(trypops)
    slsp.selfconsistency(coul,0)
    efm_free = dos_bethe_find_crystalfield(trypops, slsp.param['hopping'])
    orb_ener = slsp.param['lambda']+ slsp.quasiparticle_weight()*efm_free
    obtained_cf = orb_ener[5] - orb_ener[0]
    return target_cf - obtained_cf"
4681,"def produce_pdf(rst_content=None, doctree_content=None, filename=None):
    """"""produce a pdf content based of a given rst content

    If filename is given, it will store the result using the given filename
    if no filename is given, it will generate a pdf in /tmp/ with a random
    name
    """"""
    if filename is None:
        filename = os.path.join(
            ""/tmp"", ''.join([random.choice(string.ascii_letters +
            string.digits) for n in range(15)]) + '.pdf')
    r2p = RstToPdf(stylesheets=['pdf.style'],
                   style_path=[os.path.join(os.path.dirname(__file__),
                                            'styles')],
                   breaklevel=0,
                   splittables=True,
                   footer=""""""###Title### - ###Page###/###Total###"""""")
    r2p.createPdf(text=rst_content,
                  doctree=doctree_content,
                  output=filename)
    return filename"
4682,"def load(self, filename=None):
        """"""Method was overriden to set spectrum.filename as well""""""
        DataFile.load(self, filename)
        self.spectrum.filename = filename"
4683,"def _do_save_as(self, filename):
        """"""Saves spectrum back to FITS file.""""""

        if len(self.spectrum.x) < 2:
            raise RuntimeError(""Spectrum must have at least two points"")
        if os.path.isfile(filename):
            os.unlink(filename)  # PyFITS does not overwrite file

        hdu = self.spectrum.to_hdu()
        overwrite_fits(hdu, filename)"
4684,"def alternator(*pipes):
    ''' a lot like zip, just instead of:
            (a,b),(a,b),(a,b)
        it works more like:
            a,b,a,b,a,b,a
        until one of the pipes ends '''
    try:
        for p in cycle(map(iter, pipes)):
            yield next(p)
    except StopIteration:
        pass"
4685,"def matches():
    """"""This resource returns a list of the currently running WvW matches, with
    the participating worlds included in the result. Further details about a
    match can be requested using the ``match_details`` function.

    The response is a list of match objects, each of which contains the
    following properties:

    wvw_match_id (string):
        The WvW match id.

    red_world_id (number):
        The world id of the red world.

    blue_world_id (number):
        The world id of the blue world.

    green_world_id (number):
        The world id of the green world.

    start_time (datetime):
        A timestamp of when the match started.

    end_time (datetime):
        A timestamp of when the match ends.

    """"""
    wvw_matches = get_cached(""wvw/matches.json"", False).get(""wvw_matches"")
    for match in wvw_matches:
        match[""start_time""] = parse_datetime(match[""start_time""])
        match[""end_time""] = parse_datetime(match[""end_time""])
    return wvw_matches"
4686,"def objective_names(lang=""en""):
    """"""This resource returns a list of the localized WvW objective names for
    the specified language.

    :param lang: The language to query the names for.
    :return: A dictionary mapping the objective Ids to the names.

    *Note that these are not the names displayed in the game, but rather the
    abstract type.*

    """"""
    params = {""lang"": lang}
    cache_name = ""objective_names.%(lang)s.json"" % params
    data = get_cached(""wvw/objective_names.json"", cache_name, params=params)
    return dict([(objective[""id""], objective[""name""]) for objective in data])"
4687,"def _parse_data(self, data, charset):
        """""" Parse the xml data into dictionary. """"""

        builder = TreeBuilder(numbermode=self._numbermode)
        if isinstance(data,basestring):
            xml.sax.parseString(data, builder)
        else:
            xml.sax.parse(data, builder)
        return builder.root[self._root_element_name()]"
4688,"def _format_data(self, data, charset):
        """""" Format data into XML. """"""

        if data is None or data == '':
            return u''

        stream = StringIO.StringIO()
        xml = SimplerXMLGenerator(stream, charset)
        xml.startDocument()
        xml.startElement(self._root_element_name(), {})
        self._to_xml(xml, data)
        xml.endElement(self._root_element_name())
        xml.endDocument()
        return stream.getvalue()"
4689,"def _to_xml(self, xml, data, key=None):
        """""" Recursively convert the data into xml.

        This function was originally copied from the
        `Piston project <https://bitbucket.org/jespern/django-piston/>`_
        It has been modified since.

        :param xml: the xml document
        :type xml: SimplerXMLGenerator
        :param data: data to be formatted
        :param key: name of the parent element (for root this is ``None``)
        """"""

        if isinstance(data, (list, tuple)):
            for item in data:
                elemname = self._list_item_element_name(key)
                xml.startElement(elemname, {})
                self._to_xml(xml, item)
                xml.endElement(elemname)
        elif isinstance(data, dict):
            for key, value in data.iteritems():
                xml.startElement(key, {})
                self._to_xml(xml, value, key)
                xml.endElement(key)
        else:
            xml.characters(smart_unicode(data))"
4690,"def startElement(self, name, attrs):
        """""" Initialize new node and store current node into stack. """"""
        self.stack.append((self.current, self.chardata))
        self.current = {}
        self.chardata = []"
4691,"def endElement(self, name):
        """""" End current xml element, parse and add to to parent node. """"""
        if self.current:
            # we have nested elements
            obj = self.current
        else:
            # text only node
            text = ''.join(self.chardata).strip()
            obj = self._parse_node_data(text)
        newcurrent, self.chardata = self.stack.pop()
        self.current = self._element_to_node(newcurrent, name, obj)"
4692,"def _parse_node_data(self, data):
        """""" Parse the value of a node. Override to provide your own parsing. """"""
        data = data or ''
        if self.numbermode == 'basic':
            return self._try_parse_basic_number(data)
        elif self.numbermode == 'decimal':
            return self._try_parse_decimal(data)
        else:
            return data"
4693,"def _try_parse_basic_number(self, data):
        """""" Try to convert the data into ``int`` or ``float``.

        :returns: ``Decimal`` or ``data`` if conversion fails.
        """"""

        # try int first
        try:
            return int(data)
        except ValueError:
            pass
        # try float next
        try:
            return float(data)
        except ValueError:
            pass
        # no luck, return data as it is
        return data"
4694,"def _element_to_node(self, node, name, value):
        """""" Insert the parsed element (``name``, ``value`` pair) into the node.

        You should always use the returned node and forget the one
        that was given in parameter.

        :param node: the node where the is added to
        :returns: the node. Note that this may be a new node instance.
        """"""

        # is the target node a list?
        try:
            node.append(value)
        except AttributeError:
            pass
        else:
            return node

        # target node is a dict
        if name in node:
            # there's already an element with same name -> convert the node into list
            node = node.values() + [value]
        else:
            # just add the value into the node
            node[name] = value
        return node"
4695,"def _get_programs_dict(pkgname_only, flag_protected, flag_no_pfant=False):
    """"""Returns dictionary {(package description): [ExeInfo0, ...], ...}""""""

    allinfo = f311.get_programs_dict(pkgname_only, flag_protected)
    if not flag_no_pfant and ""pyfant"" in allinfo:
        _add_PFANT(allinfo)
    return allinfo"
4696,"def apize_raw(url, method='GET'):
	""""""
	Convert data and params dict -> json.
	""""""
	def decorator(func):
		def wrapper(*args, **kwargs):
			elem = func(*args, **kwargs)

			if type(elem) is not dict:
				raise BadReturnVarType(func.__name__)

			response = send_request(url, method, 
				elem.get('data', {}),
				elem.get('args', {}),
				elem.get('params', {}),
				elem.get('headers', {}),
				elem.get('cookies', {}),
				elem.get('timeout', 8),
				elem.get('is_json', False),
				elem.get('verify_cert', True)
			)

			return response
		return wrapper

	return decorator"
4697,"def extract_version(path):
    """"""
    Reads the file at the specified path and returns the version contained in it.

    This is meant for reading the __init__.py file inside a package, and so it
    expects a version field like:

    __version__ = '1.0.0'

    :param path: path to the Python file
    :return: the version inside the file
    """"""

    # Regular expression for the version
    _version_re = re.compile(r'__version__\s+=\s+(.*)')

    with open(path + '__init__.py', 'r', encoding='utf-8') as f:
        version = f.read()

    if version:
        version = _version_re.search(version)
        if version:
            version = version.group(1)
            version = str(ast.literal_eval(version.rstrip()))
            extracted = version
        else:
            extracted = None
    else:
        extracted = None

    return extracted"
4698,"def _make_connect(module, args, kwargs):
    """"""
    Returns a function capable of making connections with a particular
    driver given the supplied credentials.
    """"""
    # pylint: disable-msg=W0142
    return functools.partial(module.connect, *args, **kwargs)"
4699,"def connect(module, *args, **kwargs):
    """"""
    Connect to a database using the given DB-API driver module. Returns
    a database context representing that connection. Any arguments or
    keyword arguments are passed the module's :py:func:`connect` function.
    """"""
    mdr = SingleConnectionMediator(
        module, _make_connect(module, args, kwargs))
    return Context(module, mdr)"
4700,"def create_pool(module, max_conns, *args, **kwargs):
    """"""
    Create a connection pool appropriate to the driver module's capabilities.
    """"""
    if not hasattr(module, 'threadsafety'):
        raise NotSupported(""Cannot determine driver threadsafety."")
    if max_conns < 1:
        raise ValueError(""Minimum number of connections is 1."")
    if module.threadsafety >= 2:
        return Pool(module, max_conns, *args, **kwargs)
    if module.threadsafety >= 1:
        return DummyPool(module, *args, **kwargs)
    raise ValueError(""Bad threadsafety level: %d"" % module.threadsafety)"
4701,"def transactional(wrapped):
    """"""
    A decorator to denote that the content of the decorated function or
    method is to be ran in a transaction.

    The following code is equivalent to the example for
    :py:func:`dbkit.transaction`::

        import sqlite3
        import sys
        from dbkit import connect, transactional, query_value, execute

        # ...do some stuff...

        with connect(sqlite3, '/path/to/my.db') as ctx:
            try:
                change_ownership(page_id, new_owner_id)
            catch ctx.IntegrityError:
                print >> sys.stderr, ""Naughty!""

        @transactional
        def change_ownership(page_id, new_owner_id):
            old_owner_id = query_value(
                ""SELECT owner_id FROM pages WHERE page_id = ?"",
                (page_id,))
            execute(
                ""UPDATE users SET owned = owned - 1 WHERE id = ?"",
                (old_owner_id,))
            execute(
                ""UPDATE users SET owned = owned + 1 WHERE id = ?"",
                (new_owner_id,))
            execute(
                ""UPDATE pages SET owner_id = ? WHERE page_id = ?"",
                (new_owner_id, page_id))
    """"""
    # pylint: disable-msg=C0111
    def wrapper(*args, **kwargs):
        with Context.current().transaction():
            return wrapped(*args, **kwargs)
    return functools.update_wrapper(wrapper, wrapped)"
4702,"def execute(stmt, args=()):
    """"""
    Execute an SQL statement. Returns the number of affected rows.
    """"""
    ctx = Context.current()
    with ctx.mdr:
        cursor = ctx.execute(stmt, args)
        row_count = cursor.rowcount
        _safe_close(cursor)
    return row_count"
4703,"def query(stmt, args=(), factory=None):
    """"""
    Execute a query. This returns an iterator of the result set.
    """"""
    ctx = Context.current()
    factory = ctx.default_factory if factory is None else factory
    with ctx.mdr:
        return factory(ctx.execute(stmt, args), ctx.mdr)"
4704,"def query_row(stmt, args=(), factory=None):
    """"""
    Execute a query. Returns the first row of the result set, or `None`.
    """"""
    for row in query(stmt, args, factory):
        return row
    return None"
4705,"def query_value(stmt, args=(), default=None):
    """"""
    Execute a query, returning the first value in the first row of the
    result set. If the query returns no result set, a default value is
    returned, which is `None` by default.
    """"""
    for row in query(stmt, args, TupleFactory):
        return row[0]
    return default"
4706,"def execute_proc(procname, args=()):
    """"""
    Execute a stored procedure. Returns the number of affected rows.
    """"""
    ctx = Context.current()
    with ctx.mdr:
        cursor = ctx.execute_proc(procname, args)
        row_count = cursor.rowcount
        _safe_close(cursor)
    return row_count"
4707,"def query_proc(procname, args=(), factory=None):
    """"""
    Execute a stored procedure. This returns an iterator of the result set.
    """"""
    ctx = Context.current()
    factory = ctx.default_factory if factory is None else factory
    with ctx.mdr:
        return factory(ctx.execute_proc(procname, args), ctx.mdr)"
4708,"def query_proc_row(procname, args=(), factory=None):
    """"""
    Execute a stored procedure. Returns the first row of the result set,
    or `None`.
    """"""
    for row in query_proc(procname, args, factory):
        return row
    return None"
4709,"def query_proc_value(procname, args=(), default=None):
    """"""
    Execute a stored procedure, returning the first value in the first row
    of the result set. If it returns no result set, a default value is
    returned, which is `None` by default.
    """"""
    for row in query_proc(procname, args, TupleFactory):
        return row[0]
    return default"
4710,"def make_placeholders(seq, start=1):
    """"""
    Generate placeholders for the given sequence.
    """"""
    if len(seq) == 0:
        raise ValueError('Sequence must have at least one element.')
    param_style = Context.current().param_style
    placeholders = None
    if isinstance(seq, dict):
        if param_style in ('named', 'pyformat'):
            template = ':%s' if param_style == 'named' else '%%(%s)s'
            placeholders = (template % key
                            for key in six.iterkeys(seq))
    elif isinstance(seq, (list, tuple)):
        if param_style == 'numeric':
            placeholders = (':%d' % i
                            for i in xrange(start, start + len(seq)))
        elif param_style in ('qmark', 'format', 'pyformat'):
            placeholders = itertools.repeat(
                '?' if param_style == 'qmark' else '%s',
                len(seq))
    if placeholders is None:
        raise NotSupported(
            ""Param style '%s' does not support sequence type '%s'"" % (
                param_style, seq.__class__.__name__))
    return ', '.join(placeholders)"
4711,"def make_file_object_logger(fh):
    """"""
    Make a logger that logs to the given file object.
    """"""
    def logger_func(stmt, args, fh=fh):
        """"""
        A logger that logs everything sent to a file object.
        """"""
        now = datetime.datetime.now()
        six.print_(""Executing (%s):"" % now.isoformat(), file=fh)
        six.print_(textwrap.dedent(stmt), file=fh)
        six.print_(""Arguments:"", file=fh)
        pprint.pprint(args, fh)
    return logger_func"
4712,"def current(cls, with_exception=True):
        """"""
        Returns the current database context.
        """"""
        if with_exception and len(cls.stack) == 0:
            raise NoContext()
        return cls.stack.top()"
4713,"def transaction(self):
        """"""
        Sets up a context where all the statements within it are ran within
        a single database transaction. For internal use only.
        """"""
        # The idea here is to fake the nesting of transactions. Only when
        # we've gotten back to the topmost transaction context do we actually
        # commit or rollback.
        with self.mdr:
            try:
                self._depth += 1
                yield self
                self._depth -= 1
            except self.mdr.OperationalError:
                # We've lost the connection, so there's no sense in
                # attempting to roll back back the transaction.
                self._depth -= 1
                raise
            except:
                self._depth -= 1
                if self._depth == 0:
                    self.mdr.rollback()
                raise
            if self._depth == 0:
                self.mdr.commit()"
4714,"def cursor(self):
        """"""
        Get a cursor for the current connection. For internal use only.
        """"""
        cursor = self.mdr.cursor()
        with self.transaction():
            try:
                yield cursor
                if cursor.rowcount != -1:
                    self.last_row_count = cursor.rowcount
                self.last_row_id = getattr(cursor, 'lastrowid', None)
            except:
                self.last_row_count = None
                self.last_row_id = None
                _safe_close(cursor)
                raise"
4715,"def execute(self, stmt, args):
        """"""
        Execute a statement, returning a cursor. For internal use only.
        """"""
        self.logger(stmt, args)
        with self.cursor() as cursor:
            cursor.execute(stmt, args)
            return cursor"
4716,"def execute_proc(self, procname, args):
        """"""
        Execute a stored procedure, returning a cursor. For internal use
        only.
        """"""
        self.logger(procname, args)
        with self.cursor() as cursor:
            cursor.callproc(procname, args)
            return cursor"
4717,"def close(self):
        """"""
        Close the connection this context wraps.
        """"""
        self.logger = None
        for exc in _EXCEPTIONS:
            setattr(self, exc, None)
        try:
            self.mdr.close()
        finally:
            self.mdr = None"
4718,"def connect(self):
        """"""
        Returns a context that uses this pool as a connection source.
        """"""
        ctx = Context(self.module, self.create_mediator())
        ctx.logger = self.logger
        ctx.default_factory = self.default_factory
        return ctx"
4719,"def close(self):
        """"""
        Release all resources associated with this factory.
        """"""
        if self.mdr is None:
            return
        exc = (None, None, None)
        try:
            self.cursor.close()
        except:
            exc = sys.exc_info()
        try:
            if self.mdr.__exit__(*exc):
                exc = (None, None, None)
        except:
            exc = sys.exc_info()
        self.mdr = None
        self.cursor = None
        if exc != (None, None, None):
            six.reraise(*exc)"
4720,"def add_item(cls, item, **kwargs):
        """"""Add item.

        Add new item to the shopping cart.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_item(item, async=True)
        >>> result = thread.get()

        :param async bool
        :param LineItem item: Line item to add to cart (required)
        :return: ShoppingCart
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._add_item_with_http_info(item, **kwargs)
        else:
            (data) = cls._add_item_with_http_info(item, **kwargs)
            return data"
4721,"def checkout(cls, order, **kwargs):
        """"""Checkout cart.

        Checkout cart, Making an order.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.checkout(order, async=True)
        >>> result = thread.get()

        :param async bool
        :param Order order: Required order details. (required)
        :return: Order
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._checkout_with_http_info(order, **kwargs)
        else:
            (data) = cls._checkout_with_http_info(order, **kwargs)
            return data"
4722,"def delete_item(cls, item_id, **kwargs):
        """"""Remove item.

        Remove item from shopping cart
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_item(item_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str item_id: Item ID to delete. (required)
        :return: ShoppingCart
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_item_with_http_info(item_id, **kwargs)
        else:
            (data) = cls._delete_item_with_http_info(item_id, **kwargs)
            return data"
4723,"def empty(cls, **kwargs):
        """"""Empty cart.

        Empty the shopping cart.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.empty(async=True)
        >>> result = thread.get()

        :param async bool
        :return: ShoppingCart
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._empty_with_http_info(**kwargs)
        else:
            (data) = cls._empty_with_http_info(**kwargs)
            return data"
4724,"def get(cls, **kwargs):
        """"""Get cart.

        Retrieve the shopping cart of the current session.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get(async=True)
        >>> result = thread.get()

        :param async bool
        :return: ShoppingCart
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_with_http_info(**kwargs)
        else:
            (data) = cls._get_with_http_info(**kwargs)
            return data"
4725,"def update_item(cls, item_id, item, **kwargs):
        """"""Update cart.

        Update cart item.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_item(item_id, item, async=True)
        >>> result = thread.get()

        :param async bool
        :param str item_id: Item ID to update. (required)
        :param LineItem item: Line item to update. (required)
        :return: ShoppingCart
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_item_with_http_info(item_id, item, **kwargs)
        else:
            (data) = cls._update_item_with_http_info(item_id, item, **kwargs)
            return data"
4726,"def get_perm_names(cls, resource):
        """""" Return all permissions supported by the resource.

        This is used for auto-generating missing permissions rows into
        database in syncdb.
        """"""

        return [cls.get_perm_name(resource, method) for method in cls.METHODS]"
4727,"def get_perm_name(cls, resource, method):
        """""" Compose permission name

        @param resource the resource
        @param method the request method (case doesn't matter).
        """"""

        return '%s_%s_%s' % (
            cls.PREFIX,
            cls._get_resource_name(resource),
            method.lower())"
4728,"def check_perm(self, request, resource):
        """""" Check permission

        @param request the HTTP request
        @param resource the requested resource
        @raise Forbidden if the user doesn't have access to the resource
        """"""

        perm_name = self.get_perm_name(resource, request.method)
        if not self._has_perm(request.user, perm_name):
            raise errors.Forbidden()"
4729,"def _has_perm(self, user, permission):
        """""" Check whether the user has the given permission

        @return True if user is granted with access, False if not.
        """"""

        if user.is_superuser:
            return True
        if user.is_active:
            perms = [perm.split('.')[1] for perm in user.get_all_permissions()]
            return permission in perms
        return False"
4730,"def wash_url_argument(var, new_type):
    """"""
    Wash argument into 'new_type', that can be 'list', 'str',
                                               'int', 'tuple' or 'dict'.
    If needed, the check 'type(var) is not None' should be done before
    calling this function.
    @param var: variable value
    @param new_type: variable type, 'list', 'str', 'int', 'tuple' or 'dict'
    @return: as much as possible, value var as type new_type
            If var is a list, will change first element into new_type.
            If int check unsuccessful, returns 0
    """"""
    out = []
    if new_type == 'list':  # return lst
        if isinstance(var, list):
            out = var
        else:
            out = [var]
    elif new_type == 'str':  # return str
        if isinstance(var, list):
            try:
                out = ""%s"" % var[0]
            except:
                out = """"
        elif isinstance(var, str):
            out = var
        else:
            out = ""%s"" % var
    elif new_type == 'int':  # return int
        if isinstance(var, list):
            try:
                out = int(var[0])
            except:
                out = 0
        elif isinstance(var, (int, long)):
            out = var
        elif isinstance(var, str):
            try:
                out = int(var)
            except:
                out = 0
        else:
            out = 0
    elif new_type == 'tuple':  # return tuple
        if isinstance(var, tuple):
            out = var
        else:
            out = (var, )
    elif new_type == 'dict':  # return dictionary
        if isinstance(var, dict):
            out = var
        else:
            out = {0: var}
    return out"
4731,"def is_local_url(target):
    """"""Determine if URL is a local.""""""
    ref_url = urlparse(cfg.get('CFG_SITE_SECURE_URL'))
    test_url = urlparse(urljoin(cfg.get('CFG_SITE_SECURE_URL'), target))
    return test_url.scheme in ('http', 'https') and \
        ref_url.netloc == test_url.netloc"
4732,"def get_safe_redirect_target(arg='next'):
    """"""Get URL to redirect to and ensure that it is local.""""""
    for target in request.args.get(arg), request.referrer:
        if not target:
            continue
        if is_local_url(target):
            return target
    return None"
4733,"def redirect_to_url(req, url, redirection_type=None, norobot=False):
    """"""
    Redirect current page to url.
    @param req: request as received from apache
    @param url: url to redirect to
    @param redirection_type: what kind of redirection is required:
    e.g.: apache.HTTP_MULTIPLE_CHOICES             = 300
          apache.HTTP_MOVED_PERMANENTLY            = 301
          apache.HTTP_MOVED_TEMPORARILY            = 302
          apache.HTTP_SEE_OTHER                    = 303
          apache.HTTP_NOT_MODIFIED                 = 304
          apache.HTTP_USE_PROXY                    = 305
          apache.HTTP_TEMPORARY_REDIRECT           = 307
    The default is apache.HTTP_MOVED_TEMPORARILY
    @param norobot: wether to instruct crawlers and robots such as GoogleBot
        not to index past this point.
    @see: http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3
    """"""
    url = url.strip()
    if redirection_type is None:
        redirection_type = apache.HTTP_MOVED_TEMPORARILY

    from flask import redirect
    r = redirect(url, code=redirection_type)
    raise apache.SERVER_RETURN(r)
    # FIXME enable code bellow

    del req.headers_out[""Cache-Control""]
    req.headers_out[""Cache-Control""] = ""no-cache, private, no-store, "" \
        ""must-revalidate, post-check=0, pre-check=0, max-age=0""
    req.headers_out[""Pragma""] = ""no-cache""

    if norobot:
        req.headers_out[
            ""X-Robots-Tag""] = ""noarchive, nosnippet, noindex, nocache""

    user_agent = req.headers_in.get('User-Agent', '')
    if 'Microsoft Office Existence Discovery' in user_agent or 'ms-office' in user_agent:
        # HACK: this is to workaround Microsoft Office trying to be smart
        # when users click on URLs in Office documents that require
        # authentication. Office will check the validity of the URL
        # but will pass the browser the redirected URL rather than
        # the original one. This is incompatible with e.g. Shibboleth
        # based SSO since the referer would be lost.
        # See: http://support.microsoft.com/kb/899927
        req.status = 200
        req.content_type = 'text/html'
        if req.method != 'HEAD':
            req.write(""""""
<html>
    <head>
        <title>Intermediate page for URLs clicked on MS Office Documents</title>
        <meta http-equiv=""REFRESH"" content=""5;url=%(url)s""></meta>
    </head>
    <body>
        <p>You are going to be redirected to the desired content within 5 seconds. If the redirection does not happen automatically please click on <a href=""%(url)s"">%(url_ok)s</a>.</p>
    </body>
</html>"""""" % {
                'url': escape(req.unparsed_uri, True),
                'url_ok': escape(req.unparsed_uri)
            })
        raise apache.SERVER_RETURN(apache.DONE)

    req.headers_out[""Location""] = url

    if req.response_sent_p:
        raise IOError(""Cannot redirect after headers have already been sent."")

    req.status = redirection_type
    req.write('<p>Please go to <a href=""%s"">here</a></p>\n' % url)

    raise apache.SERVER_RETURN(apache.DONE)"
4734,"def rewrite_to_secure_url(url, secure_base=None):
    """"""
    Rewrite URL to a Secure URL

    @param url URL to be rewritten to a secure URL.
    @param secure_base: Base URL of secure site (defaults to CFG_SITE_SECURE_URL).
    """"""
    if secure_base is None:
        secure_base = cfg.get('CFG_SITE_SECURE_URL')
    url_parts = list(urlparse(url))
    url_secure_parts = urlparse(secure_base)
    url_parts[0] = url_secure_parts[0]
    url_parts[1] = url_secure_parts[1]
    return urlunparse(url_parts)"
4735,"def get_referer(req, replace_ampersands=False):
    """""" Return the referring page of a request.
    Referer (wikipedia): Referer is a common misspelling of the word
    ""referrer""; so common, in fact, that it made it into the official
    specification of HTTP. When visiting a webpage, the referer or
    referring page is the URL of the previous webpage from which a link was
    followed.
    @param req: request
    @param replace_ampersands: if 1, replace & by &amp; in url
                               (correct HTML cannot contain & characters alone)
    """"""
    try:
        referer = req.headers_in['Referer']
        if replace_ampersands == 1:
            return referer.replace('&', '&amp;')
        return referer
    except KeyError:
        return ''"
4736,"def make_canonical_urlargd(urlargd, default_urlargd):
    """""" Build up the query part of an URL from the arguments passed in
    the 'urlargd' dictionary. 'default_urlargd' is a secondary dictionary which
    contains tuples of the form (type, default value) for the query
    arguments (this is the same dictionary as the one you can pass to
    webinterface_handler.wash_urlargd).

    When a query element has its default value, it is discarded, so
    that the simplest (canonical) url query is returned.

    The result contains the initial '?' if there are actual query
    items remaining.
    """"""

    canonical = drop_default_urlargd(urlargd, default_urlargd)

    if canonical:
        return '?' + urlencode(canonical, doseq=True)
        # FIXME double escaping of '&'? .replace('&', '&amp;')

    return ''"
4737,"def create_html_link(urlbase, urlargd, link_label, linkattrd=None,
                     escape_urlargd=True, escape_linkattrd=True,
                     urlhash=None):
    """"""Creates a W3C compliant link.
    @param urlbase: base url (e.g. config.CFG_SITE_URL/search)
    @param urlargd: dictionary of parameters. (e.g. p={'recid':3, 'of'='hb'})
    @param link_label: text displayed in a browser (has to be already escaped)
    @param linkattrd: dictionary of attributes (e.g. a={'class': 'img'})
    @param escape_urlargd: boolean indicating if the function should escape
                           arguments (e.g. < becomes &lt; or "" becomes &quot;)
    @param escape_linkattrd: boolean indicating if the function should escape
                           attributes (e.g. < becomes &lt; or "" becomes &quot;)
    @param urlhash: hash string to add at the end of the link
    """"""
    attributes_separator = ' '
    output = '<a href=""' + \
             create_url(urlbase, urlargd, escape_urlargd, urlhash) + '""'
    if linkattrd:
        output += ' '
        if escape_linkattrd:
            attributes = [escape(str(key), quote=True) + '=""' +
                          escape(str(linkattrd[key]), quote=True) + '""'
                          for key in linkattrd.keys()]
        else:
            attributes = [str(key) + '=""' + str(linkattrd[key]) + '""'
                          for key in linkattrd.keys()]
        output += attributes_separator.join(attributes)
    output = wash_for_utf8(output)
    output += '>' + wash_for_utf8(link_label) + '</a>'
    return output"
4738,"def create_html_mailto(
        email,
        subject=None,
        body=None,
        cc=None,
        bcc=None,
        link_label=""%(email)s"",
        linkattrd=None,
        escape_urlargd=True,
        escape_linkattrd=True,
        email_obfuscation_mode=None):
    """"""Creates a W3C compliant 'mailto' link.

    Encode/encrypt given email to reduce undesired automated email
    harvesting when embedded in a web page.

    NOTE: there is no ultimate solution to protect against email
    harvesting. All have drawbacks and can more or less be
    circumvented. There are other techniques to protect email
    addresses. We implement the less annoying one for users.

    @param email: the recipient of the email
    @param subject: a default subject for the email (must not contain
                    line feeds)
    @param body: a default body for the email
    @param cc: the co-recipient(s) of the email
    @param bcc: the hidden co-recpient(s) of the email
    @param link_label: the label of this mailto link. String
                       replacement is performed on key %(email)s with
                       the email address if needed.
    @param linkattrd: dictionary of attributes (e.g. a={'class': 'img'})
    @param escape_urlargd: boolean indicating if the function should escape
                           arguments (e.g. < becomes &lt; or "" becomes &quot;)
    @param escape_linkattrd: boolean indicating if the function should escape
                           attributes (e.g. < becomes &lt; or "" becomes &quot;)
    @param email_obfuscation_mode: the protection mode. See below:

    You can choose among several modes to protect emails. It is
    advised to keep the default
    CFG_MISCUTIL_EMAIL_HARVESTING_PROTECTION value, so that it is
    possible for an admin to change the policy globally.

    Available modes ([t] means ""transparent"" for the user):

         -1: hide all emails, excepted CFG_SITE_ADMIN_EMAIL and
             CFG_SITE_SUPPORT_EMAIL.

      [t] 0 : no protection, email returned as is.
                foo@example.com => foo@example.com

          1 : basic email munging: replaces @ by [at] and . by [dot]
                foo@example.com => foo [at] example [dot] com

      [t] 2 : transparent name mangling: characters are replaced by
              equivalent HTML entities.
                foo@example.com => &#102;&#111;&#111;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;

      [t] 3 : javascript insertion. Requires Javascript enabled on client side.

          4 : replaces @ and . characters by gif equivalents.
                foo@example.com => foo<img src=""at.gif"" alt="" [at] "">example<img src=""dot.gif"" alt="" [dot] "">com
    """"""
    # TODO: implement other protection modes to encode/encript email:
    #
    # [t] 5 : form submission. User is redirected to a form that he can
    # fills in to send the email (??Use webmessage??).
    # Depending on WebAccess, ask to answer a question.
    ##
    # [t] 6 : if user can see (controlled by WebAccess), display. Else
    # ask to login to see email. If user cannot see, display
    # form submission.

    if email_obfuscation_mode is None:
        email_obfuscation_mode = cfg.get(
            'CFG_WEBSTYLE_EMAIL_ADDRESSES_OBFUSCATION_MODE')

    if linkattrd is None:
        linkattrd = {}

    parameters = {}
    if subject:
        parameters[""subject""] = subject
    if body:
        parameters[""body""] = body.replace('\r\n', '\n').replace('\n', '\r\n')
    if cc:
        parameters[""cc""] = cc
    if bcc:
        parameters[""bcc""] = bcc

    # Preprocessing values for some modes
    if email_obfuscation_mode == 1:
        # Basic Munging
        email = email.replace(""@"", "" [at] "").replace(""."", "" [dot] "")
    elif email_obfuscation_mode == 2:
        # Transparent name mangling
        email = string_to_numeric_char_reference(email)

    if '%(email)s' in link_label:
        link_label = link_label % {'email': email}

    mailto_link = create_html_link('mailto:' + email, parameters,
                                   link_label, linkattrd,
                                   escape_urlargd, escape_linkattrd)

    if email_obfuscation_mode == 0:
        # Return ""as is""
        return mailto_link
    elif email_obfuscation_mode == 1:
        # Basic Munging
        return mailto_link
    elif email_obfuscation_mode == 2:
        # Transparent name mangling
        return mailto_link
    elif email_obfuscation_mode == 3:
        # Javascript-based
        return '''<script language=""JavaScript"" ''' \
            '''type=""text/javascript"">''' \
            '''document.write('%s'.split("""").reverse().join(""""))''' \
            '''</script>''' % \
               mailto_link[::-1].replace(""'"", ""\\'"")
    elif email_obfuscation_mode == 4:
        # GIFs-based
        email = email.replace(
            '.', '<img src=""%s/img/dot.gif"" alt="" [dot] "" '
            'style=""vertical-align:bottom""  />' %
            cfg.get('CFG_SITE_URL'))
        email = email.replace(
            '@', '<img src=""%s/img/at.gif"" alt="" [at] "" '
            'style=""vertical-align:baseline"" />' %
            cfg.get('CFG_SITE_URL'))
        return email

    # All other cases, including mode -1:
    return """""
4739,"def string_to_numeric_char_reference(string):
    """"""
    Encode a string to HTML-compatible numeric character reference.
    Eg: encode_html_entities(""abc"") == '&#97;&#98;&#99;'
    """"""
    out = """"
    for char in string:
        out += ""&#"" + str(ord(char)) + "";""
    return out"
4740,"def get_canonical_and_alternates_urls(
        url,
        drop_ln=True,
        washed_argd=None,
        quote_path=False):
    """"""
    Given an Invenio URL returns a tuple with two elements. The first is the
    canonical URL, that is the original URL with CFG_SITE_URL prefix, and
    where the ln= argument stripped. The second element element is mapping,
    language code -> alternate URL

    @param quote_path: if True, the path section of the given C{url}
                       is quoted according to RFC 2396
    """"""
    dummy_scheme, dummy_netloc, path, dummy_params, query, fragment = urlparse(
        url)
    canonical_scheme, canonical_netloc = urlparse(cfg.get('CFG_SITE_URL'))[0:2]
    parsed_query = washed_argd or parse_qsl(query)
    no_ln_parsed_query = [(key, value)
                          for (key, value) in parsed_query if key != 'ln']
    if drop_ln:
        canonical_parsed_query = no_ln_parsed_query
    else:
        canonical_parsed_query = parsed_query
    if quote_path:
        path = urllib.quote(path)
    canonical_query = urlencode(canonical_parsed_query)
    canonical_url = urlunparse(
        (canonical_scheme,
         canonical_netloc,
         path,
         dummy_params,
         canonical_query,
         fragment))
    alternate_urls = {}
    for ln in cfg.get('CFG_SITE_LANGS'):
        alternate_query = urlencode(no_ln_parsed_query + [('ln', ln)])
        alternate_url = urlunparse(
            (canonical_scheme,
             canonical_netloc,
             path,
             dummy_params,
             alternate_query,
             fragment))
        alternate_urls[ln] = alternate_url
    return canonical_url, alternate_urls"
4741,"def create_url(urlbase, urlargd, escape_urlargd=True, urlhash=None):
    """"""Creates a W3C compliant URL. Output will look like this:
    'urlbase?param1=value1&amp;param2=value2'
    @param urlbase: base url (e.g. config.CFG_SITE_URL/search)
    @param urlargd: dictionary of parameters. (e.g. p={'recid':3, 'of'='hb'}
    @param escape_urlargd: boolean indicating if the function should escape
                           arguments (e.g. < becomes &lt; or "" becomes &quot;)
    @param urlhash: hash string to add at the end of the link
    """"""
    separator = '&amp;'
    output = urlbase
    if urlargd:
        output += '?'
        if escape_urlargd:
            arguments = [escape(quote(str(key)), quote=True) + '=' +
                         escape(quote(str(urlargd[key])), quote=True)
                         for key in urlargd.keys()]
        else:
            arguments = [str(key) + '=' + str(urlargd[key])
                         for key in urlargd.keys()]
        output += separator.join(arguments)
    if urlhash:
        output += ""#"" + escape(quote(str(urlhash)))
    return output"
4742,"def same_urls_p(a, b):
    """""" Compare two URLs, ignoring reorganizing of query arguments """"""

    ua = list(urlparse(a))
    ub = list(urlparse(b))

    ua[4] = parse_qs(ua[4])
    ub[4] = parse_qs(ub[4])

    return ua == ub"
4743,"def urlargs_replace_text_in_arg(urlargs, regexp_argname, text_old, text_new):
    """"""Analyze `urlargs' (URL CGI GET query arguments in string form)
       and for each occurrence of argument matching `regexp_argname'
       replace every substring `text_old' by `text_new'.  Return the
       resulting new URL.

       Used to be used for search engine's create_nearest_terms_box,
       now it is not used there anymore.  It is left here in case it
       will become possibly useful later.
    """"""
    out = """"
    # parse URL arguments into a dictionary:
    urlargsdict = parse_qs(urlargs)
    # construct new URL arguments:
    urlargsdictnew = {}
    for key in urlargsdict.keys():
        if re.match(regexp_argname, key):  # replace `arg' by new values
            urlargsdictnew[key] = []
            for parg in urlargsdict[key]:
                urlargsdictnew[key].append(parg.replace(text_old, text_new))
        else:  # keep old values
            urlargsdictnew[key] = urlargsdict[key]
    # build new URL for this word:
    for key in urlargsdictnew.keys():
        for val in urlargsdictnew[key]:
            out += ""&amp;"" + key + ""="" + quote_plus(val, '')
    if out.startswith(""&amp;""):
        out = out[5:]
    return out"
4744,"def make_user_agent_string(component=None):
    """"""
    Return a nice and uniform user-agent string to be used when Invenio
    act as a client in HTTP requests.
    """"""
    ret = ""Invenio-%s (+%s; \""%s\"")"" % (cfg.get('CFG_VERSION'),
                                        cfg.get('CFG_SITE_URL'), cfg.get('CFG_SITE_NAME'))
    if component:
        ret += "" %s"" % component
    return ret"
4745,"def make_invenio_opener(component=None):
    """"""
    Return an urllib2 opener with the useragent already set in the appropriate
    way.
    """"""
    opener = urllib2.build_opener()
    opener.addheaders = [('User-agent', make_user_agent_string(component))]
    return opener"
4746,"def create_AWS_request_url(base_url, argd, _amazon_secret_access_key,
                           _timestamp=None):
    """"""
    Create a signed AWS (Amazon Web Service) request URL corresponding
    to the given parameters.

    Example:
    >> create_AWS_request_url(""http://ecs.amazon.com/onca/xml"",
                             {'AWSAccessKeyID': '0000000000',
                              'Service': 'AWSECommerceService',
                              'Operation': 'ItemLookup',
                              'ItemID': '0679722769',
                              'ResponseGroup': 'ItemAttributes,Offers,Images,Review'},
                             ""1234567890"")

    @param base_url: Service URL of the Amazon store to query
    @param argd: dictionary of arguments defining the query
    @param _amazon_secret_access_key: your Amazon secret key
    @param _timestamp: for testing purpose only (default: current timestamp)

    @type base_url: string
    @type argd: dict
    @type _amazon_secret_access_key: string
    @type _timestamp: string

    @return signed URL of the request (string)
    """"""

    # First define a few util functions

    def get_AWS_signature(argd, _amazon_secret_access_key,
                          method=""GET"", request_host=""webservices.amazon.com"",
                          request_uri=""/onca/xml"",
                          _timestamp=None):
        """"""
        Returns the signature of an Amazon request, based on the
        arguments of the request.

        @param argd: dictionary of arguments defining the query
        @param _amazon_secret_access_key: your Amazon secret key
        @param method: method of the request POST or GET
        @param request_host: host contacted for the query. To embed in the signature.
        @param request_uri: uri contacted at 'request_host'. To embed in the signature.
        @param _timestamp: for testing purpose only (default: current timestamp)

        @type argd: dict
        @type _amazon_secret_access_key: string
        @type method: string
        @type host_header: string
        @type http_request_uri: string
        @type _timestamp: string

        @return signature of the request (string)
        """"""

        # Add timestamp
        if not _timestamp:
            argd[""Timestamp""] = time.strftime(""%Y-%m-%dT%H:%M:%SZ"",
                                              time.gmtime())
        else:
            argd[""Timestamp""] = _timestamp

        # Order parameter keys by byte value
        parameter_keys = sorted(argd.keys())

        # Encode arguments, according to RFC 3986. Make sure we
        # generate a list which is ordered by byte value of the keys
        arguments = [quote(str(key), safe=""~/"") + ""="" +
                     quote(str(argd[key]), safe=""~/"")
                     for key in parameter_keys]

        # Join
        parameters_string = ""&"".join(arguments)

        # Prefix
        parameters_string = method.upper() + ""\n"" + \
            request_host.lower() + ""\n"" + \
            (request_uri or ""/"") + ""\n"" + \
            parameters_string

        # Sign and return
        return calculate_RFC2104_HMAC(parameters_string,
                                      _amazon_secret_access_key)

    def calculate_RFC2104_HMAC(data, _amazon_secret_access_key):
        """"""
        Computes a RFC 2104 compliant HMAC Signature and then Base64
        encodes it.

        Module hashlib must be installed if Python < 2.5
        <http://pypi.python.org/pypi/hashlib/20081119>

        @param data: data to sign
        @param _amazon_secret_access_key: your Amazon secret key

        @type data: string
        @type _amazon_secret_access_key: string. Empty if hashlib module not installed
        """"""
        if not HASHLIB_IMPORTED:
            current_app.logger.warning(
                ""Module hashlib not installed. Please install it.""
            )
            return """"
        else:
            if sys.version_info < (2, 5):
                # compatibility mode for Python < 2.5 and hashlib
                my_digest_algo = _MySHA256(sha256())
            else:
                my_digest_algo = sha256

        return base64.encodestring(
            hmac.new(
                _amazon_secret_access_key,
                data,
                my_digest_algo).digest()).strip()
    # End util functions

    parsed_url = urlparse(base_url)
    signature = get_AWS_signature(argd, _amazon_secret_access_key,
                                  request_host=parsed_url[1],
                                  request_uri=parsed_url[2],
                                  _timestamp=_timestamp)
    if signature:
        argd[""Signature""] = signature
    return base_url + ""?"" + urlencode(argd)"
4747,"def create_Indico_request_url(
        base_url,
        indico_what,
        indico_loc,
        indico_id,
        indico_type,
        indico_params,
        indico_key,
        indico_sig,
        _timestamp=None):
    """"""
    Create a signed Indico request URL to access Indico HTTP Export APIs.

    See U{http://indico.cern.ch/ihelp/html/ExportAPI/index.html} for more
    information.

    Example:
    >> create_Indico_request_url(""https://indico.cern.ch"",
                                 ""categ"",
                                 """",
                                 [1, 7],
                                 ""xml"",
                                 {'onlypublic': 'yes',
                                  'order': 'title',
                                  'from': 'today',
                                  'to': 'tomorrow'},
                                 '00000000-0000-0000-0000-000000000000',
                                 '00000000-0000-0000-0000-000000000000')

    @param base_url: Service base URL of the Indico instance to query
    @param indico_what: element to export
    @type indico_what: one of the strings: C{categ}, C{event}, C{room}, C{reservation}
    @param indico_loc: location of the element(s) specified by ID (only used for some elements)
    @param indico_id: ID of the element to be exported
    @type indico_id: a string or a list/tuple of strings
    @param indico_type: output format
    @type indico_type: one of the strings: C{json}, C{jsonp}, C{xml}, C{html}, C{ics}, C{atom}
    @param indico_params: parameters of the query. See U{http://indico.cern.ch/ihelp/html/ExportAPI/common.html}
    @param indico_key: API key provided for the given Indico instance
    @param indico_sig: API secret key (signature) provided for the given Indico instance
    @param _timestamp: for testing purpose only (default: current timestamp)

    @return signed URL of the request (string)
    """"""

    url = '/export/' + indico_what + '/'
    if indico_loc:
        url += indico_loc + '/'
    if type(indico_id) in (list, tuple):
        # dash separated list of values
        indico_id = '-'.join([str(x) for x in indico_id])
    url += indico_id + '.' + str(indico_type)

    if hasattr(indico_params, 'items'):
        items = indico_params.items()
    else:
        items = list(indico_params)
    if indico_key:
        items.append(('apikey', indico_key))
    if indico_sig and HASHLIB_IMPORTED:
        if _timestamp:
            items.append(('timestamp', str(_timestamp)))
        else:
            items.append(('timestamp', str(int(time.time()))))
        items = sorted(items, key=lambda x: x[0].lower())
        url_to_sign = '%s?%s' % (url, urlencode(items))
        if sys.version_info < (2, 5):
            # compatibility mode for Python < 2.5 and hashlib
            my_digest_algo = _MySHA1(sha1())
        else:
            my_digest_algo = sha1
        signature = hmac.new(indico_sig, url_to_sign,
                             my_digest_algo).hexdigest()
        items.append(('signature', signature))
    elif not HASHLIB_IMPORTED:
        current_app.logger.warning(
            ""Module hashlib not installed. Please install it.""
        )
    if not items:
        return url

    url = '%s%s?%s' % (base_url.strip('/'), url, urlencode(items))
    return url"
4748,"def auto_version_url(file_path):
    """""" Appends modification time of the file to the request URL in order for the
        browser to refresh the cache when file changes

        @param file_path: path to the file, e.g js/foo.js
        @return: file_path with modification time appended to URL
    """"""
    file_md5 = """"
    try:
        file_md5 = md5(open(cfg.get('CFG_WEBDIR') +
                            os.sep + file_path).read()).hexdigest()
    except IOError:
        pass
    return file_path + ""?%s"" % file_md5"
4749,"def get_relative_url(url):
    """"""
    Returns the relative URL from a URL. For example:

    'http://web.net' -> ''
    'http://web.net/' -> ''
    'http://web.net/1222' -> '/1222'
    'http://web.net/wsadas/asd' -> '/wsadas/asd'

    It will never return a trailing ""/"".

    @param url: A url to transform
    @type url: str

    @return: relative URL
    """"""
    # remove any protocol info before
    stripped_site_url = url.replace(""://"", """")
    baseurl = ""/"" + ""/"".join(stripped_site_url.split(""/"")[1:])

    # remove any trailing slash (""/"")
    if baseurl[-1] == ""/"":
        return baseurl[:-1]
    else:
        return baseurl"
4750,"def function_arg_count(fn):
    """""" returns how many arguments a funciton has """"""
    assert callable(fn), 'function_arg_count needed a callable function, not {0}'.format(repr(fn))
    if hasattr(fn, '__code__') and hasattr(fn.__code__, 'co_argcount'):
        return fn.__code__.co_argcount
    else:
        return 1"
4751,"def map(*args):
    """""" this map works just like the builtin.map, except, this one you can also:
        - give it multiple functions to map over an iterable
        - give it a single function with multiple arguments to run a window
          based map operation over an iterable
    """"""

    functions_to_apply = [i for i in args if callable(i)]
    iterables_to_run = [i for i in args if not callable(i)]
    #print('functions_to_apply:',functions_to_apply)
    #print('iterables_to_run:',iterables_to_run)

    assert len(functions_to_apply)>0, 'at least one function needs to be given to map'
    assert len(iterables_to_run)>0, 'no iterables were given to map'

    # check for native map usage
    if len(functions_to_apply) == 1 and len(iterables_to_run) >= 1 and function_arg_count(*functions_to_apply)==1:
        if hasattr(iter([]), '__next__'): # if python 3
            return __builtins__.map(functions_to_apply[0], *iterables_to_run)
        else:
            return iter(__builtins__.map(functions_to_apply[0], *iterables_to_run))
    # ---------------------------- new logic below ----------------------------
    # logic for a single function
    elif len(functions_to_apply) == 1:
        fn = functions_to_apply[0]
        # if there is a single iterable, chop it up
        if len(iterables_to_run) == 1:
            return (fn(*i) for i in window(iterables_to_run[0], function_arg_count(functions_to_apply[0])))
    # logic for more than 1 function
    elif len(functions_to_apply) > 1 and len(iterables_to_run) == 1:
        return multi_ops(*(iterables_to_run + functions_to_apply))
    else:
        raise ValueError('invalid usage of map()')"
4752,"def merge(left, right, how='inner', key=None, left_key=None, right_key=None,
          left_as='left', right_as='right'):
    """""" Performs a join using the union join function. """"""
    return join(left, right, how, key, left_key, right_key,
                join_fn=make_union_join(left_as, right_as))"
4753,"def join(left, right, how='inner', key=None, left_key=None, right_key=None,
         join_fn=tuple_join):
    """"""
    :param left: left iterable to be joined
    :param right: right iterable to be joined
    :param str | function key: either an attr name, dict key, or function that produces hashable value
    :param how: 'inner', 'left', 'right', or 'outer'
    :param join_fn: function called on joined left and right iterable items to complete join
    :rtype: list
    """"""
    if key is None and (left_key is None or right_key is None):
        raise ValueError(""Must provide either key param or both left_key and right_key"")

    if key is not None:
        lkey = rkey = key if callable(key) else make_key_fn(key)
    else:
        lkey = left_key if callable(left_key) else make_key_fn(left_key)
        rkey = right_key if callable(right_key) else make_key_fn(right_key)

    try:
        join_impl = {
            ""left"": _left_join,
            ""right"": _right_join,
            ""inner"": _inner_join,
            ""outer"": _outer_join,
        }[how]
    except KeyError:
        raise ValueError(""Invalid value for how: {}, must be left, right, ""
                         ""inner, or outer."".format(str(how)))
    else:
        return join_impl(left, right, lkey, rkey, join_fn)"
4754,"def _inner_join(left, right, left_key_fn, right_key_fn, join_fn=union_join):
    """""" Inner join using left and right key functions

    :param left: left iterable to be joined
    :param right: right iterable to be joined
    :param function left_key_fn: function that produces hashable value from left objects
    :param function right_key_fn: function that produces hashable value from right objects
    :param join_fn: function called on joined left and right iterable items to complete join
    :rtype: list
    """"""
    joiner = defaultdict(list)
    for ele in right:
        joiner[right_key_fn(ele)].append(ele)
    joined = []
    for ele in left:
        for other in joiner[left_key_fn(ele)]:
            joined.append(join_fn(ele, other))
    return joined"
4755,"def _right_join(left, right, left_key_fn, right_key_fn, join_fn=union_join):
    """"""
    :param left: left iterable to be joined
    :param right: right iterable to be joined
    :param function left_key_fn: function that produces hashable value from left objects
    :param function right_key_fn: function that produces hashable value from right objects
    :param join_fn: function called on joined left and right iterable items to complete join
    :rtype: list
    """"""
    def reversed_join_fn(left_ele, right_ele):
        return join_fn(right_ele, left_ele)
    return _left_join(right, left, right_key_fn, left_key_fn, reversed_join_fn)"
4756,"def _outer_join(left, right, left_key_fn, right_key_fn, join_fn=union_join):
    """"""
    :param left: left iterable to be joined
    :param right: right iterable to be joined
    :param function left_key_fn: function that produces hashable value from left objects
    :param function right_key_fn: function that produces hashable value from right objects
    :param join_fn: function called on joined left and right iterable items to complete join
    :rtype: list
    """"""
    left_joiner = defaultdict(list)
    for ele in left:
        left_joiner[left_key_fn(ele)].append(ele)
    right_joiner = defaultdict(list)
    for ele in right:
        right_joiner[right_key_fn(ele)].append(ele)
    keys = set(left_joiner.keys()).union(set(right_joiner.keys()))

    def iter_join(l, r, join_keys):
        for join_key in join_keys:
            for ele in l.get(join_key, [None]):
                for other in r.get(join_key, [None]):
                    yield join_fn(ele, other)

    return list(iter_join(left_joiner, right_joiner, keys))"
4757,"def group(iterable, key=lambda ele: ele):
    """""" Groups an iterable by a specified attribute, or using a specified key access function.  Returns tuples of grouped elements.

    >>> dogs = [Dog('gatsby', 'Rruff!', 15), Dog('william', 'roof', 12), Dog('edward', 'hi', 15)]
    >>> groupby(dogs, 'weight')
    [(Dog('gatsby', 'Rruff!', 15), Dog('edward', 'hi', 15)), (Dog('william', 'roof', 12), )]

    :param iterable: iterable to be grouped
    :param key: a key-access function or attr name to be used as a group key
    """"""
    if callable(key):
        return _group(iterable, key)
    else:
        return _group(iterable, make_key_fn(key))"
4758,"def trigger_keyphrases(
    text                          = None,  # input text to parse
    keyphrases                    = None,  # keyphrases for parsing input text
    response                      = None,  # optional text response on trigger
    function                      = None,  # optional function on trigger
    kwargs                        = None,  # optional function keyword arguments
    confirm                       = False, # optional return of confirmation
    confirmation_prompt           = ""Do you want to continue? (y/n)"",
    confirmation_feedback_confirm = ""confirm"",
    confirmation_feedback_deny    = ""deny""
    ):
    """"""
    Parse input text for keyphrases. If any keyphrases are found, respond with
    text or by seeking confirmation or by engaging a function with optional
    keyword arguments. Return text or True if triggered and return False if not
    triggered. If confirmation is required, a confirmation object is returned,
    encapsulating a function and its optional arguments.
    """"""
    if any(pattern in text for pattern in keyphrases):
        if confirm:
            return confirmation(
                prompt           = confirmation_prompt,
                feedback_confirm = confirmation_feedback_confirm,
                feedback_deny    = confirmation_feedback_deny,
                function         = function,
                kwargs           = kwargs
            )
        if function and not kwargs:
            result = function()
        elif function and kwargs:
            result = function(**kwargs)
        else:
            result = None
        if response:
            return response
        elif not response and result:
            return str(result)
        else:
            return True
    else:
        return False"
4759,"def parse(
    text   = None,
    humour = 75
    ):
    """"""
    Parse input text using various triggers, some returning text and some for
    engaging functions. If triggered, a trigger returns text or True if and if
    not triggered, returns False. If no triggers are triggered, return False, if
    one trigger is triggered, return the value returned by that trigger, and if
    multiple triggers are triggered, return a list of the values returned by
    those triggers.

    Options such as humour engage or disengage various triggers.
    """"""
    triggers = []

    # general

    if humour >= 75:
        triggers.extend([
            trigger_keyphrases(
                text       = text,
                keyphrases = [
                             ""image""
                             ],
                response   = ""http://i.imgur.com/MiqrlTh.jpg""
            ),
            trigger_keyphrases(
                text       = text,
                keyphrases = [
                             ""sup"",
                             ""hi""
                             ],
                response   = ""sup home bean""
            ),
            trigger_keyphrases(
                text       = text,
                keyphrases = [
                             ""thanks"",
                             ""thank you""
                             ],
                response   = ""you're welcome, boo ;)""
            )
        ])

    # information

    triggers.extend([
        trigger_keyphrases(
            text       = text,
            keyphrases = [
                         ""where are you"",
                         ""IP"",
                         ""I.P."",
                         ""IP address"",
                         ""I.P. address"",
                         ""ip address""
                         ],
            function   = report_IP
        ),
        trigger_keyphrases(
            text       = text,
            keyphrases = [
                         ""how are you"",
                         ""are you well"",
                         ""status""
                         ],
            function   = report_system_status,
            kwargs     = {""humour"": humour}
        ),
        trigger_keyphrases(
            text       = text,
            keyphrases = [
                         ""heartbeat""
                         ],
            function   = heartbeat_message
        ),
        trigger_keyphrases(
            text       = text,
            keyphrases = [
                         ""METAR""
                         ],
            function   = report_METAR,
            kwargs     = {""text"": text}
        ),
        trigger_keyphrases(
            text       = text,
            keyphrases = [
                         ""TAF""
                         ],
            response   = report_TAF,
            kwargs     = {""text"": text}
        ),
        trigger_keyphrases(
            text       = text,
            keyphrases = [
                         ""rain""
                         ],
            response   = report_rain_times,
            kwargs     = {""text"": text}
        )
    ])

    # actions

    triggers.extend([
        trigger_keyphrases(
            text       = text,
            keyphrases = [
                         ""command"",
                         ""run command"",
                         ""engage command"",
                         ""execute command""
                         ],
            response   = command()
        ),
        trigger_keyphrases(
            text                          = text,
            keyphrases                    = [
                                            ""restart""
                                            ],
            function                      = restart,
            confirm                       = True,
            confirmation_prompt           = ""Do you want to restart this ""
                                            ""program? (y/n)"",
            confirmation_feedback_confirm = ""confirm restart"",
            confirmation_feedback_deny    = ""deny restart""
        )
    ])

    if any(triggers):
        responses = [response for response in triggers if response]
        if len(responses) > 1:
            return responses
        else:
            return responses[0]
    else:
        return False"
4760,"def parse_networking(
    text    = None
    ):
    """"""
    Access address and port parameters via the builtins or __builtin__ module.
    Relish the nonsense.
    """"""
    try:
        address = _builtins.address
        port    = _builtins.port
    except:
        address = None
        port    = None
    triggers = []
    if address and port:
        triggers.extend([
            trigger_keyphrases(
                text                          = text,
                keyphrases                    = [
                                                ""reverse SSH"",
                                                ""reverse ssh""
                                                ],
                function                      = engage_command,
                kwargs                        = {""command"": ""ssh -R "" + str(port) + "":localhost:22 "" + address},
                confirm                       = True,
                confirmation_prompt           = ""Do you want to reverse SSH ""
                                                ""connect? (y/n)"",
                confirmation_feedback_confirm = ""confirm reverse SSH connect: ""
                                                ""ssh localhost -p "" + str(port),
                confirmation_feedback_deny    = ""deny reverse SSH connect""
            )
        ])
    if any(triggers):
        responses = [response for response in triggers if response]
        if len(responses) > 1:
            return responses
        else:
            return responses[0]
    else:
        return False"
4761,"def multiparse(
    text         = None,
    parsers      = [parse],
    help_message = None
    ):
    """"""
    Parse input text by looping over a list of multiple parsers. If one trigger
    is triggered, return the value returned by that trigger, if multiple
    triggers are triggered, return a list of the values returned by those
    triggers. If no triggers are triggered, return False or an optional help
    message.
    """"""
    responses = []
    for _parser in parsers:
        response = _parser(text = text)
        if response is not False:
            responses.extend(response if response is list else [response])
    if not any(responses):
        if help_message:
            return help_message
        else:
            return False
    else:
        if len(responses) > 1:
            return responses
        else:
            return responses[0]"
4762,"def run(
        self
        ):
        """"""
        Engage contained function with optional keyword arguments.
        """"""
        if self._function and not self._kwargs:
            return self._function()
        if self._function and self._kwargs:
            return self._function(**self._kwargs)"
4763,"def tax_class_based_on(self, tax_class_based_on):
        """"""Sets the tax_class_based_on of this TaxSettings.


        :param tax_class_based_on: The tax_class_based_on of this TaxSettings.
        :type: str
        """"""
        allowed_values = [""shippingAddress"", ""billingAddress""]  # noqa: E501
        if tax_class_based_on is not None and tax_class_based_on not in allowed_values:
            raise ValueError(
                ""Invalid value for `tax_class_based_on` ({0}), must be one of {1}""  # noqa: E501
                .format(tax_class_based_on, allowed_values)
            )

        self._tax_class_based_on = tax_class_based_on"
4764,"def writequery(
    log,
    sqlQuery,
    dbConn,
    Force=False,
    manyValueList=False
):
    """"""*Execute a MySQL write command given a sql query*

    **Key Arguments:**
        - ``sqlQuery`` -- the MySQL command to execute
        - ``dbConn`` -- the db connection
        - ``Force`` -- do not exit code if error occurs, move onto the next command
        - ``manyValueList`` -- a list of value tuples if executing more than one insert

    **Return:**
        - ``message`` -- error/warning message

    **Usage:**

        Here's an example of how to create a table using the database connection passed to the function:

        .. code-block:: python 

            from fundamentals.mysql import writequery
            sqlQuery = ""CREATE TABLE `testing_table` (`id` INT NOT NULL, PRIMARY KEY (`id`))""
            message = writequery(
                log=log,
                sqlQuery=sqlQuery,
                dbConn=dbConn,
                Force=False,
                manyValueList=False
            )

        Here's a many value insert example:

        .. code-block:: python 

            from fundamentals.mysql import writequery
            sqlQuery = ""INSERT INTO testing_table (id) values (%s)""
            message = writequery(
                log=log,
                sqlQuery=sqlQuery,
                dbConn=dbConn,
                Force=False,
                manyValueList=[(1,), (2,), (3,), (4,), (5,), (6,), (7,),
                               (8,), (9,), (10,), (11,), (12,), ]
            )

    """"""
    log.debug('starting the ``writequery`` function')
    import pymysql
    import warnings
    warnings.filterwarnings('error', category=pymysql.Warning)
    message = """"
    try:
        cursor = dbConn.cursor(pymysql.cursors.DictCursor)
    except Exception as e:
        log.error('could not create the database cursor.')
    # EXECUTE THE SQL COMMAND

    try:
        if manyValueList == False:
            cursor.execute(sqlQuery)
        else:
            # cursor.executemany(sqlQuery, manyValueList)
            # INSET LARGE LISTS IN BATCHES TO STOP MYSQL SERVER BARFING
            batch = 100000
            offset = 0
            stop = 0

            while stop == 0:
                thisList = manyValueList[offset:offset + batch]
                offset += batch
                a = len(thisList)
                cursor.executemany(sqlQuery, thisList)
                dbConn.commit()
                if len(thisList) < batch:
                    stop = 1

    except pymysql.Error as e:
        if e[0] == 1050 and 'already exists' in e[1]:
            log.info(str(e) + '\n')
        elif e[0] == 1062:
                           # Duplicate Key error
            log.debug('Duplicate Key error: %s\n' % (str(e), ))
            message = ""duplicate key error""
        elif e[0] == 1061:
                           # Duplicate Key error
            log.debug('index already exists: %s\n' % (str(e), ))
            message = ""index already exists""
        elif ""Duplicate entry"" in str(e):
            log.debug('Duplicate Key error: %s\n' % (str(e), ))
            message = ""duplicate key error""
        elif ""Deadlock"" in str(e):
            i = 0
            while i < 10:
                time.sleep(1)
                i += 1
                try:
                    if manyValueList == False:
                        cursor.execute(sqlQuery)
                    else:
                        # cursor.executemany(sqlQuery, manyValueList)
                        # INSET LARGE LISTS IN BATCHES TO STOP MYSQL SERVER
                        # BARFING
                        batch = 100000
                        offset = 0
                        stop = 0

                        while stop == 0:
                            thisList = manyValueList[offset:offset + batch]
                            offset += batch
                            a = len(thisList)
                            cursor.executemany(sqlQuery, thisList)
                            dbConn.commit()
                            if len(thisList) < batch:
                                stop = 1
                    i = 20
                except:
                    pass
            if i == 10:
                log.error('Deadlock: %s\n' % (str(e), ))
                message = ""Deadlock error""
                raise

        else:
            sqlQueryTrim = sqlQuery[:1000]
            message = 'MySQL write command not executed for this query: << %s >>\nThe error was: %s \n' % (sqlQuery,
                                                                                                           str(e))
            if Force == False:
                log.error(message)
                raise
            else:
                log.info(message)
                return -1
    except pymysql.Warning as e:
        log.info(str(e))
    except Exception as e:
        if ""truncated"" in str(e):
            log.error('%s\n Here is the sqlquery:\n%s\n' % (str(e), sqlQuery))
            if manyValueList:
                log.error('... and the values:\n%s\n' % (thisList, ))
        elif ""Duplicate entry"" in str(e):
            log.warning('Duplicate Key error: %s\n' % (str(e), ))
            message = ""duplicate key error""
        else:
            sqlQuery = sqlQuery[:2000]
            log.error(
                'MySQL write command not executed for this query: << %s >>\nThe error was: %s \n' %
                (sqlQuery, str(e)))
            if Force == False:
                sys.exit(0)
            return -1
    dbConn.commit()
    # CLOSE THE CURSOR
    cOpen = True
    count = 0
    while cOpen:
        try:
            cursor.close()
            cOpen = False
        except Exception as e:
            time.sleep(1)
            count += 1
            if count == 10:
                log.warning('could not close the db cursor ' + str(e) + '\n')
                raise e
                count = 0

    log.debug('completed the ``writequery`` function')
    return message"
4765,"def create_fixed_rate_shipping(cls, fixed_rate_shipping, **kwargs):
        """"""Create FixedRateShipping

        Create a new FixedRateShipping
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_fixed_rate_shipping(fixed_rate_shipping, async=True)
        >>> result = thread.get()

        :param async bool
        :param FixedRateShipping fixed_rate_shipping: Attributes of fixedRateShipping to create (required)
        :return: FixedRateShipping
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_fixed_rate_shipping_with_http_info(fixed_rate_shipping, **kwargs)
        else:
            (data) = cls._create_fixed_rate_shipping_with_http_info(fixed_rate_shipping, **kwargs)
            return data"
4766,"def delete_fixed_rate_shipping_by_id(cls, fixed_rate_shipping_id, **kwargs):
        """"""Delete FixedRateShipping

        Delete an instance of FixedRateShipping by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_fixed_rate_shipping_by_id(fixed_rate_shipping_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str fixed_rate_shipping_id: ID of fixedRateShipping to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_fixed_rate_shipping_by_id_with_http_info(fixed_rate_shipping_id, **kwargs)
        else:
            (data) = cls._delete_fixed_rate_shipping_by_id_with_http_info(fixed_rate_shipping_id, **kwargs)
            return data"
4767,"def get_fixed_rate_shipping_by_id(cls, fixed_rate_shipping_id, **kwargs):
        """"""Find FixedRateShipping

        Return single instance of FixedRateShipping by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_fixed_rate_shipping_by_id(fixed_rate_shipping_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str fixed_rate_shipping_id: ID of fixedRateShipping to return (required)
        :return: FixedRateShipping
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_fixed_rate_shipping_by_id_with_http_info(fixed_rate_shipping_id, **kwargs)
        else:
            (data) = cls._get_fixed_rate_shipping_by_id_with_http_info(fixed_rate_shipping_id, **kwargs)
            return data"
4768,"def list_all_fixed_rate_shippings(cls, **kwargs):
        """"""List FixedRateShippings

        Return a list of FixedRateShippings
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_fixed_rate_shippings(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[FixedRateShipping]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_fixed_rate_shippings_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_fixed_rate_shippings_with_http_info(**kwargs)
            return data"
4769,"def replace_fixed_rate_shipping_by_id(cls, fixed_rate_shipping_id, fixed_rate_shipping, **kwargs):
        """"""Replace FixedRateShipping

        Replace all attributes of FixedRateShipping
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_fixed_rate_shipping_by_id(fixed_rate_shipping_id, fixed_rate_shipping, async=True)
        >>> result = thread.get()

        :param async bool
        :param str fixed_rate_shipping_id: ID of fixedRateShipping to replace (required)
        :param FixedRateShipping fixed_rate_shipping: Attributes of fixedRateShipping to replace (required)
        :return: FixedRateShipping
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_fixed_rate_shipping_by_id_with_http_info(fixed_rate_shipping_id, fixed_rate_shipping, **kwargs)
        else:
            (data) = cls._replace_fixed_rate_shipping_by_id_with_http_info(fixed_rate_shipping_id, fixed_rate_shipping, **kwargs)
            return data"
4770,"def update_fixed_rate_shipping_by_id(cls, fixed_rate_shipping_id, fixed_rate_shipping, **kwargs):
        """"""Update FixedRateShipping

        Update attributes of FixedRateShipping
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_fixed_rate_shipping_by_id(fixed_rate_shipping_id, fixed_rate_shipping, async=True)
        >>> result = thread.get()

        :param async bool
        :param str fixed_rate_shipping_id: ID of fixedRateShipping to update. (required)
        :param FixedRateShipping fixed_rate_shipping: Attributes of fixedRateShipping to update. (required)
        :return: FixedRateShipping
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_fixed_rate_shipping_by_id_with_http_info(fixed_rate_shipping_id, fixed_rate_shipping, **kwargs)
        else:
            (data) = cls._update_fixed_rate_shipping_by_id_with_http_info(fixed_rate_shipping_id, fixed_rate_shipping, **kwargs)
            return data"
4771,"def create_wish_list(cls, wish_list, **kwargs):
        """"""Create WishList

        Create a new WishList
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_wish_list(wish_list, async=True)
        >>> result = thread.get()

        :param async bool
        :param WishList wish_list: Attributes of wishList to create (required)
        :return: WishList
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_wish_list_with_http_info(wish_list, **kwargs)
        else:
            (data) = cls._create_wish_list_with_http_info(wish_list, **kwargs)
            return data"
4772,"def delete_wish_list_by_id(cls, wish_list_id, **kwargs):
        """"""Delete WishList

        Delete an instance of WishList by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_wish_list_by_id(wish_list_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str wish_list_id: ID of wishList to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_wish_list_by_id_with_http_info(wish_list_id, **kwargs)
        else:
            (data) = cls._delete_wish_list_by_id_with_http_info(wish_list_id, **kwargs)
            return data"
4773,"def get_wish_list_by_id(cls, wish_list_id, **kwargs):
        """"""Find WishList

        Return single instance of WishList by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_wish_list_by_id(wish_list_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str wish_list_id: ID of wishList to return (required)
        :return: WishList
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_wish_list_by_id_with_http_info(wish_list_id, **kwargs)
        else:
            (data) = cls._get_wish_list_by_id_with_http_info(wish_list_id, **kwargs)
            return data"
4774,"def list_all_wish_lists(cls, **kwargs):
        """"""List WishLists

        Return a list of WishLists
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_wish_lists(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[WishList]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_wish_lists_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_wish_lists_with_http_info(**kwargs)
            return data"
4775,"def replace_wish_list_by_id(cls, wish_list_id, wish_list, **kwargs):
        """"""Replace WishList

        Replace all attributes of WishList
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_wish_list_by_id(wish_list_id, wish_list, async=True)
        >>> result = thread.get()

        :param async bool
        :param str wish_list_id: ID of wishList to replace (required)
        :param WishList wish_list: Attributes of wishList to replace (required)
        :return: WishList
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_wish_list_by_id_with_http_info(wish_list_id, wish_list, **kwargs)
        else:
            (data) = cls._replace_wish_list_by_id_with_http_info(wish_list_id, wish_list, **kwargs)
            return data"
4776,"def update_wish_list_by_id(cls, wish_list_id, wish_list, **kwargs):
        """"""Update WishList

        Update attributes of WishList
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_wish_list_by_id(wish_list_id, wish_list, async=True)
        >>> result = thread.get()

        :param async bool
        :param str wish_list_id: ID of wishList to update. (required)
        :param WishList wish_list: Attributes of wishList to update. (required)
        :return: WishList
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_wish_list_by_id_with_http_info(wish_list_id, wish_list, **kwargs)
        else:
            (data) = cls._update_wish_list_by_id_with_http_info(wish_list_id, wish_list, **kwargs)
            return data"
4777,"def task(arg = None):
	"""""" Task decorator """"""

	# make sure stdout is patched
	if not hasattr(sys.stdout, 'indent_level'):
		sys.stdout = IndentedFile(sys.stdout)

	def decorator(base):
		info = ': ' + arg if type(arg) is str else ''
		header = fore.green('** ' + fore.cyan(base.__name__) + info)

		def func(*args, **kwargs):
			sys.stdout.indent_level += 1

			puts(header)
			base(*args, **kwargs)

			sys.stdout.indent_level -= 1

		params = inspect.formatargspec(*inspect.getargspec(base))[1:-1]
		specformat = fore.cyan('%s') + ' ' + fore.white('%s')

		func._task = True
		func._spec = specformat % (base.__name__, params)
		func._desc = re.sub('\s+', ' ', inspect.getdoc(base) or '')
		return func

	if type(arg) == types.FunctionType:
		return decorator(arg)
	else:
		return decorator"
4778,"def recurse_up(directory, filename):
	""""""
	Recursive walk a directory up to root until it contains `filename`
	""""""

	directory = osp.abspath(directory)

	while True:
		searchfile = osp.join(directory, filename)

		if osp.isfile(searchfile):
			return directory

		if directory == '/': break
		else: directory = osp.dirname(directory)
	return False"
4779,"def etree_to_dict(tree):
    """"""Translate etree into dictionary.

    :param tree: etree dictionary object
    :type tree: <http://lxml.de/api/lxml.etree-module.html>

    """"""
    d = {tree.tag.split('}')[1]: map(
        etree_to_dict, tree.iterchildren()
    ) or tree.text}

    return d"
4780,"def csv(
        self,
        filepath=None
    ):
        """"""*Render the data in CSV format*

        **Key Arguments:**
            - ``filepath`` -- path to the file to write the csv content to. Default *None*

        **Return:**
            - ``renderedData`` -- the data rendered in csv format

        **Usage:**

            To render the data set as csv:

            .. code-block:: python

                print dataSet.csv()

            .. code-block:: text

                owner,pet,address
                daisy,dog,""belfast, uk""
                john,snake,the moon
                susan,crocodile,larne

            and to save the csv rendering to file:

            .. code-block:: python

                dataSet.csv(""/path/to/myfile.csv"")
        """"""
        self.log.debug('starting the ``csv`` method')

        renderedData = self._list_of_dictionaries_to_csv(""machine"")

        if filepath and renderedData != ""NO MATCH"":

            # RECURSIVELY CREATE MISSING DIRECTORIES
            if not os.path.exists(os.path.dirname(filepath)):
                os.makedirs(os.path.dirname(filepath))

            writeFile = codecs.open(filepath, encoding='utf-8', mode='w')
            writeFile.write(renderedData)
            writeFile.close()

        self.log.debug('completed the ``csv`` method')
        return renderedData"
4781,"def json(
        self,
        filepath=None
    ):
        """"""*Render the data in json format*

        **Key Arguments:**
            - ``filepath`` -- path to the file to write the json content to. Default *None*

        **Return:**
            - ``renderedData`` -- the data rendered as json

        **Usage:**

            To render the data set as json:

            .. code-block:: python

                print dataSet.json()

            .. code-block:: json

                [
                    {
                        ""address"": ""belfast, uk"",
                        ""owner"": ""daisy"",
                        ""pet"": ""dog""
                    },
                    {
                        ""address"": ""the moon"",
                        ""owner"": ""john"",
                        ""pet"": ""snake""
                    },
                    {
                        ""address"": ""larne"",
                        ""owner"": ""susan"",
                        ""pet"": ""crocodile""
                    }
                ]

            and to save the json rendering to file:

            .. code-block:: python

                dataSet.json(""/path/to/myfile.json"")
        """"""
        self.log.debug('starting the ``json`` method')

        dataCopy = copy.deepcopy(self.listOfDictionaries)
        for d in dataCopy:
            for k, v in d.iteritems():
                if isinstance(v,  datetime):
                    d[k] = v.strftime(""%Y%m%dt%H%M%S"")

        renderedData = json.dumps(
            dataCopy,
            separators=(',', ': '),
            sort_keys=True,
            indent=4
        )

        if filepath and len(self.listOfDictionaries):

            # RECURSIVELY CREATE MISSING DIRECTORIES
            if not os.path.exists(os.path.dirname(filepath)):
                os.makedirs(os.path.dirname(filepath))

            writeFile = codecs.open(filepath, encoding='utf-8', mode='w')
            writeFile.write(renderedData)
            writeFile.close()

        self.log.debug('completed the ``json`` method')
        return renderedData"
4782,"def yaml(
        self,
        filepath=None
    ):
        """"""*Render the data in yaml format*

        **Key Arguments:**
            - ``filepath`` -- path to the file to write the yaml content to. Default *None*

        **Return:**
            - ``renderedData`` -- the data rendered as yaml

        **Usage:**

            To render the data set as yaml:

            .. code-block:: python

                print dataSet.yaml()

            .. code-block:: yaml

                - address: belfast, uk
                  owner: daisy
                  pet: dog
                - address: the moon
                  owner: john
                  pet: snake
                - address: larne
                  owner: susan
                  pet: crocodile

            and to save the yaml rendering to file:

            .. code-block:: python

                dataSet.json(""/path/to/myfile.yaml"")
        """"""
        self.log.debug('starting the ``yaml`` method')

        dataCopy = []
        dataCopy[:] = [dict(l) for l in self.listOfDictionaries]
        renderedData = yaml.dump(dataCopy, default_flow_style=False)

        if filepath and len(self.listOfDictionaries):

            # RECURSIVELY CREATE MISSING DIRECTORIES
            if not os.path.exists(os.path.dirname(filepath)):
                os.makedirs(os.path.dirname(filepath))

            stream = file(filepath, 'w')
            yaml.dump(dataCopy, stream, default_flow_style=False)
            stream.close()

        self.log.debug('completed the ``yaml`` method')
        return renderedData"
4783,"def mysql(
        self,
        tableName,
        filepath=None,
        createStatement=None
    ):
        """"""*Render the dataset as a series of mysql insert statements*

        **Key Arguments:**
            - ``tableName`` -- the name of the mysql db table to assign the insert statements to.
            - ``filepath`` -- path to the file to write the mysql inserts content to. Default *None*
            createStatement

        **Return:**
            - ``renderedData`` -- the data rendered mysql insert statements (string format)

        **Usage:**

            .. code-block:: python

                print dataSet.mysql(""testing_table"")

            this output the following:

            .. code-block:: plain

                INSERT INTO `testing_table` (address,dateCreated,owner,pet) VALUES (""belfast, uk"" ,""2016-09-14T16:21:36"" ,""daisy"" ,""dog"")  ON DUPLICATE KEY UPDATE  address=""belfast, uk"", dateCreated=""2016-09-14T16:21:36"", owner=""daisy"", pet=""dog"" ;
                INSERT INTO `testing_table` (address,dateCreated,owner,pet) VALUES (""the moon"" ,""2016-09-14T16:21:36"" ,""john"" ,""snake"")  ON DUPLICATE KEY UPDATE  address=""the moon"", dateCreated=""2016-09-14T16:21:36"", owner=""john"", pet=""snake"" ;
                INSERT INTO `testing_table` (address,dateCreated,owner,pet) VALUES (""larne"" ,""2016-09-14T16:21:36"" ,""susan"" ,""crocodile"")  ON DUPLICATE KEY UPDATE  address=""larne"", dateCreated=""2016-09-14T16:21:36"", owner=""susan"", pet=""crocodile"" ;

            To save this rendering to file use:

            .. code-block:: python

                dataSet.mysql(""testing_table"", ""/path/to/myfile.sql"")

        """"""
        self.log.debug('starting the ``csv`` method')

        import re
        if createStatement and ""create table if not exists"" not in createStatement.lower():
            regex = re.compile(r'^\s*CREATE TABLE ', re.I | re.S)
            createStatement = regex.sub(
                ""CREATE TABLE IF NOT EXISTS "", createStatement)

        renderedData = self._list_of_dictionaries_to_mysql_inserts(
            tableName=tableName,
            createStatement=createStatement
        )

        if filepath and len(self.listOfDictionaries):

            # RECURSIVELY CREATE MISSING DIRECTORIES
            if not os.path.exists(os.path.dirname(filepath)):
                os.makedirs(os.path.dirname(filepath))

            writeFile = codecs.open(filepath, encoding='utf-8', mode='w')
            writeFile.write(renderedData)
            writeFile.close()

        self.log.debug('completed the ``csv`` method')
        return renderedData"
4784,"def _list_of_dictionaries_to_csv(
            self,
            csvType=""human""):
        """"""Convert a python list of dictionaries to pretty csv output

        **Key Arguments:**
            - ``csvType`` -- human, machine or reST

        **Return:**
            - ``output`` -- the contents of a CSV file
        """"""
        self.log.debug(
            'starting the ``_list_of_dictionaries_to_csv`` function')

        if not len(self.listOfDictionaries):
            return ""NO MATCH""

        dataCopy = copy.deepcopy(self.listOfDictionaries)

        tableColumnNames = dataCopy[0].keys()
        columnWidths = []
        columnWidths[:] = [len(tableColumnNames[i])
                           for i in range(len(tableColumnNames))]

        output = io.BytesIO()
        # setup csv styles
        if csvType == ""machine"":
            delimiter = "",""
        elif csvType in [""human"", ""markdown""]:
            delimiter = ""|""
        elif csvType in [""reST""]:
            delimiter = ""|""
        if csvType in [""markdown""]:
            writer = csv.writer(output, delimiter=delimiter,
                                quoting=csv.QUOTE_NONE, doublequote=False, quotechar='""', escapechar=""\\"", lineterminator=""\n"")
        else:
            writer = csv.writer(output, dialect='excel', delimiter=delimiter,
                                quotechar='""', quoting=csv.QUOTE_MINIMAL, lineterminator=""\n"")

        if csvType in [""markdown""]:
            dividerWriter = csv.writer(
                output, delimiter=""|"", quoting=csv.QUOTE_NONE, doublequote=False, quotechar='""', escapechar=""\\"", lineterminator=""\n"")
        else:
            dividerWriter = csv.writer(output, dialect='excel', delimiter=""+"",
                                       quotechar='""', quoting=csv.QUOTE_MINIMAL, lineterminator=""\n"")
        # add column names to csv
        header = []
        divider = []
        rstDivider = []
        allRows = []

        # clean up data
        for row in dataCopy:
            for c in tableColumnNames:
                if isinstance(row[c], float) or isinstance(row[c], Decimal):
                    row[c] = ""%0.9g"" % row[c]
                elif isinstance(row[c], datetime):
                    thisDate = str(row[c])[:10]
                    row[c] = ""%(thisDate)s"" % locals()

        # set the column widths
        for row in dataCopy:
            for i, c in enumerate(tableColumnNames):
                if len(unicode(row[c])) > columnWidths[i]:
                    columnWidths[i] = len(unicode(row[c]))

        # table borders for human readable
        if csvType in [""human"", ""markdown"", ""reST""]:
            header.append("""")
            divider.append("""")
            rstDivider.append("""")

        for i, c in enumerate(tableColumnNames):
            if csvType == ""machine"":
                header.append(c)
            elif csvType in [""human"", ""markdown"", ""reST""]:
                header.append(
                    c.ljust(columnWidths[i] + 2).rjust(columnWidths[i] + 3))
                divider.append('-' * (columnWidths[i] + 3))
                rstDivider.append('=' * (columnWidths[i] + 3))

        # table border for human readable
        if csvType in [""human"", ""markdown"", ""reST""]:
            header.append("""")
            divider.append("""")
            rstDivider.append("""")

        # fill in the data
        for row in dataCopy:
            thisRow = []
            # table border for human readable
            if csvType in [""human"", ""markdown"", ""reST""]:
                thisRow.append("""")

            for i, c in enumerate(tableColumnNames):
                if csvType in [""human"", ""markdown"", ""reST""]:
                    if row[c] == None:
                        row[c] = """"
                    row[c] = unicode(unicode(row[c]).ljust(columnWidths[i] + 2)
                                     .rjust(columnWidths[i] + 3))
                thisRow.append(row[c])
            # table border for human readable
            if csvType in [""human"", ""markdown"", ""reST""]:
                thisRow.append("""")
            allRows.append(thisRow)
            if csvType in [""reST""]:
                allRows.append(divider)

        if csvType == ""machine"":
            writer.writerow(header)
        if csvType in [""reST""]:
            dividerWriter.writerow(divider)
            writer.writerow(header)
            dividerWriter.writerow(rstDivider)
        if csvType in [""human""]:
            dividerWriter.writerow(divider)
            writer.writerow(header)
            dividerWriter.writerow(divider)
        elif csvType in [""markdown""]:
            writer.writerow(header)
            dividerWriter.writerow(divider)

        # write out the data
        writer.writerows(allRows)
        # table border for human readable
        if csvType in [""human""]:
            dividerWriter.writerow(divider)

        output = output.getvalue()
        output = output.strip()

        if csvType in [""markdown""]:
            output = output.replace(""|--"", ""|:-"")
        if csvType in [""reST""]:
            output = output.replace(""|--"", ""+--"").replace(""--|"", ""--+"")

        self.log.debug(
            'completed the ``_list_of_dictionaries_to_csv`` function')

        return output"
4785,"def _list_of_dictionaries_to_mysql_inserts(
            self,
            tableName,
            createStatement=None):
        """"""Convert a python list of dictionaries to pretty csv output

        **Key Arguments:**
            - ``tableName`` -- the name of the table to create the insert statements for
            - ``createStatement`` -- add this create statement to the top of the file. Will only be executed if no table of that name exists in database. Default *None*

        **Return:**
            - ``output`` -- the mysql insert statements (as a string)
        """"""
        self.log.debug(
            'completed the ````_list_of_dictionaries_to_mysql_inserts`` function')

        if not len(self.listOfDictionaries):
            return ""NO MATCH""

        dataCopy = copy.deepcopy(self.listOfDictionaries)

        if createStatement:
            output = createStatement + ""\n""
        else:
            output = """"

        inserts = []

        inserts = []
        inserts[:] = [convert_dictionary_to_mysql_table(log=self.log, dictionary=d, dbTableName=tableName, uniqueKeyList=[
        ], dateModified=False, returnInsertOnly=True, replace=True, batchInserts=False, reDatetime=self.reDatetime) for d in dataCopy]
        output += "";\n"".join(inserts) + "";""

        self.log.debug(
            'completed the ``_list_of_dictionaries_to_mysql_inserts`` function')
        return output"
4786,"def create_payment_token(cls, payment_token, **kwargs):
        """"""Create PaymentToken

        Create a new PaymentToken
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_payment_token(payment_token, async=True)
        >>> result = thread.get()

        :param async bool
        :param PaymentToken payment_token: Attributes of paymentToken to create (required)
        :return: PaymentToken
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_payment_token_with_http_info(payment_token, **kwargs)
        else:
            (data) = cls._create_payment_token_with_http_info(payment_token, **kwargs)
            return data"
4787,"def delete_payment_token_by_id(cls, payment_token_id, **kwargs):
        """"""Delete PaymentToken

        Delete an instance of PaymentToken by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_payment_token_by_id(payment_token_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str payment_token_id: ID of paymentToken to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_payment_token_by_id_with_http_info(payment_token_id, **kwargs)
        else:
            (data) = cls._delete_payment_token_by_id_with_http_info(payment_token_id, **kwargs)
            return data"
4788,"def get_payment_token_by_id(cls, payment_token_id, **kwargs):
        """"""Find PaymentToken

        Return single instance of PaymentToken by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_payment_token_by_id(payment_token_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str payment_token_id: ID of paymentToken to return (required)
        :return: PaymentToken
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_payment_token_by_id_with_http_info(payment_token_id, **kwargs)
        else:
            (data) = cls._get_payment_token_by_id_with_http_info(payment_token_id, **kwargs)
            return data"
4789,"def list_all_payment_tokens(cls, **kwargs):
        """"""List PaymentTokens

        Return a list of PaymentTokens
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_payment_tokens(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[PaymentToken]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_payment_tokens_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_payment_tokens_with_http_info(**kwargs)
            return data"
4790,"def replace_payment_token_by_id(cls, payment_token_id, payment_token, **kwargs):
        """"""Replace PaymentToken

        Replace all attributes of PaymentToken
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_payment_token_by_id(payment_token_id, payment_token, async=True)
        >>> result = thread.get()

        :param async bool
        :param str payment_token_id: ID of paymentToken to replace (required)
        :param PaymentToken payment_token: Attributes of paymentToken to replace (required)
        :return: PaymentToken
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_payment_token_by_id_with_http_info(payment_token_id, payment_token, **kwargs)
        else:
            (data) = cls._replace_payment_token_by_id_with_http_info(payment_token_id, payment_token, **kwargs)
            return data"
4791,"def update_payment_token_by_id(cls, payment_token_id, payment_token, **kwargs):
        """"""Update PaymentToken

        Update attributes of PaymentToken
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_payment_token_by_id(payment_token_id, payment_token, async=True)
        >>> result = thread.get()

        :param async bool
        :param str payment_token_id: ID of paymentToken to update. (required)
        :param PaymentToken payment_token: Attributes of paymentToken to update. (required)
        :return: PaymentToken
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_payment_token_by_id_with_http_info(payment_token_id, payment_token, **kwargs)
        else:
            (data) = cls._update_payment_token_by_id_with_http_info(payment_token_id, payment_token, **kwargs)
            return data"
4792,"def split_in_columns(filterform, fields_per_column=None):
    '''
    Return iterator that yields a column (iterator too).

    By default, flat field list is divided in columns with
    fields_per_column elements in each (fields_per_column is a
    class attribute).
    '''
    nfields = len(filterform.fields)
    if fields_per_column is None:
        fields_per_column = filterform.fields_per_column

    ncolumns, tail = divmod(nfields, fields_per_column)
    if tail > 0:
        ncolumns += 1

    itr = iter(filterform)

    for _i in range(ncolumns):
        yield itertools.islice(itr, fields_per_column)"
4793,"def dispatch_event(self, event: ""Event"") -> None:
        """"""
        Dispatches the given event.

        It is the duty of this method to set the target of the dispatched event by calling
        `event.set_target(self)`.

        Args:
            event (Event): The event to dispatch. Must not be `None`.

        Raises:
            TypeError: If the event is `None` or its type is incorrect.
        """"""
        # Set the target of the event if it doesn't have one already. It could happen that
        # we are simply redispatching an event.
        if event.target is None:
            event.set_target(self)

        listeners: dict[types.MethodType, bool] = self._registered_listeners.get(event.type)
        if listeners is None:
            return

        for listener in listeners:
            listener(event)"
4794,"def remove_event_listener(self, event_type: str, event_handler: types.MethodType) -> None:
        """"""
        Removes the given event listener registered on the dispatcher for the given event type.

        Args:
            event_type (str): The type of the event to remove the event handler from.
                              Must not be `None` or empty string.
            event_handler (types.MethodType): The event handler to remove from the given event
                                              type of the dispatcher. Must not be `None`.

        Raises:
            ValueError: If any of the parameters are invalid.
        """"""
        # TODO: we should also accept types.FunctionType,
        # don't forget the documentation here and in the interface.
        if not isinstance(event_type, str) or event_type == """" or\
           not isinstance(event_handler, types.MethodType):
            raise ValueError(""Invalid arguments: {}, {}"".format(event_type, event_handler))

        listeners: dict[types.MethodType, bool] = self._registered_listeners.get(event_type)
        listener: types.MethodType = None if listeners is None else listeners.get(event_handler)
        if listener is not None:
            del listeners[event_handler]"
4795,"def set_target(self, target: EventDispatcherBase) -> None:
        """"""
        This method should be called by the event dispatcher that dispatches this event
        to set its target property.

        Args:
            target (EventDispatcherBase): The event dispatcher that will dispatch this event.

        Raises:
            PermissionError: If the target property of the event has already been set.
            TypeError: If `target` is not an `EventDispatcherBase` instance.
        """"""
        if self._target is not None:
            raise PermissionError(""The target property already has a valid value."")

        if not isinstance(target, EventDispatcherBase):
            raise TypeError(""Invalid target type: {}"".format(target))

        self._target = target"
4796,"def download_url(url, content_type=None, download_to_file=None,
                 retry_count=10, timeout=10.0):
    """"""
    Will download a file from given URL (either local or external) to the
    desired path (or generate one if none is given). Local files are copied
    directly.

    The function will retry a number of times based on retry_count (default 10)
    parameter and sleeps a number of seconds based on given timeout
    (default 10.0 sec) after each failed request.

    Returns the path to the downloaded file if successful.
    Otherwise an exception is raised.

    Given a content_type and an external URL, the function will make sure
    that the desired content_type is equal to the content-type of returned
    file.

    @param url: where the file lives on the interwebs
    @type url: string

    @param content_type: desired content_type to check for in external URLs.
                         (optional)
    @type content_type: string

    @param download_to_file: where the file should live after download.
                             (optional)
    @type download_to_file: string

    @param retry_count: number of times to retry. Defaults to 10.
                        (optional)
    @type retry_count: int

    @param timeout: number of seconds to sleep between attempts.
                    Defaults to 10.0 seconds. (optional)
    @type timeout: float

    @return: the path of the downloaded/copied file
    @raise InvenioFileDownloadError: raised upon URL/HTTP errors, file errors or wrong format
    """"""
    if not download_to_file:
        download_to_file = safe_mkstemp(suffix="".tmp"",
                                        prefix=""filedownloadutils_"")

    try:
        if is_url_a_local_file(url):
            downloaded_file = download_local_file(url,
                                                  download_to_file)
        else:
            downloaded_file = download_external_url(url,
                                                    download_to_file,
                                                    content_type=content_type,
                                                    retry_count=retry_count,
                                                    timeout=timeout)
    except InvenioFileDownloadError:
        raise

    return downloaded_file"
4797,"def download_external_url(url, download_to_file, content_type=None,
                          retry_count=10, timeout=10.0, verbose=False):
    """"""
    Download a url (if it corresponds to a remote file) and return a
    local url to it. If format is specified, a check will be performed
    in order to make sure that the format of the downloaded file is equal
    to the expected format.

    @param url: the URL to download
    @type url: string

    @param download_to_file: the path to download the file to
    @type download_to_file: string

    @param content_type: the content_type of the file (optional)
    @type content_type: string

    @param retry_count: max number of retries for downloading the file
    @type retry_count: int

    @param timeout: time to sleep in between attemps
    @type timeout: int

    @return: the path to the download local file
    @rtype: string
    @raise StandardError: if the download failed
    """"""
    error_str = """"
    error_code = None
    retry_attempt = 0

    while retry_attempt < retry_count:
        try:
            # Attempt to download the external file
            request = open_url(url)
            if request.code == 200 and ""Refresh"" in request.headers:
                # PDF is being generated, they ask us to wait for
                # n seconds.
                # New arxiv responses, we are not sure if the old ones are
                # deactivated
                try:
                    retry_after = int(request.headers[""Refresh""])
                    # We make sure that we do not retry too often even if
                    # they tell us to retry after 1s
                    retry_after = max(retry_after, timeout)
                except ValueError:
                    retry_after = timeout
                if verbose:
                    msg = ""retrying after %ss"" % (retry_after,)
                    print >> sys.stderr, msg
                time.sleep(retry_after)
                retry_attempt += 1
                continue
        except urllib2.HTTPError as e:
            error_code = e.code
            error_str = str(e)
            retry_after = timeout
            # This handling is the same as OAI queries.
            # We are getting 503 errors when PDFs are being generated
            if e.code == 503 and ""Retry-After"" in e.headers:
                # PDF is being generated, they ask us to wait for n seconds
                try:
                    retry_after = int(e.headers[""Retry-After""])
                    # We make sure that we do not retry too often even if
                    # they tell us to retry after 1s
                    retry_after = max(retry_after, timeout)
                except ValueError:
                    pass
            if verbose:
                msg = ""retrying after %ss"" % (retry_after,)
                print >> sys.stderr, msg
            time.sleep(retry_after)
            retry_attempt += 1
        except (urllib2.URLError,
                socket.timeout,
                socket.gaierror,
                socket.error) as e:
            if verbose:
                error_str = str(e)
                msg = ""socket error, retrying after %ss"" % (timeout,)
                print >> sys.stderr, msg
            time.sleep(timeout)
            retry_attempt += 1
        else:
            # When we get here, it means that the download was a success.
            try:
                finalize_download(url, download_to_file, content_type, request)
            finally:
                request.close()
            return download_to_file

    # All the attempts were used, but no successfull download - so raise error
    msg = 'URL could not be opened: %s' % (error_str,)
    raise InvenioFileDownloadError(msg, code=error_code)"
4798,"def finalize_download(url, download_to_file, content_type, request):
    """"""
    Finalizes the download operation by doing various checks, such as format
    type, size check etc.
    """"""
    # If format is given, a format check is performed.
    if content_type and content_type not in request.headers['content-type']:
        msg = 'The downloaded file is not of the desired format'
        raise InvenioFileDownloadError(msg)

    # Save the downloaded file to desired or generated location.
    to_file = open(download_to_file, 'w')
    try:
        try:
            while True:
                block = request.read(CFG_FILEUTILS_BLOCK_SIZE)
                if not block:
                    break
                to_file.write(block)
        except Exception as e:
            msg = ""Error when downloading %s into %s: %s"" % \
                  (url, download_to_file, e)
            raise InvenioFileDownloadError(msg)
    finally:
        to_file.close()

    # Check Size
    filesize = os.path.getsize(download_to_file)
    if filesize == 0:
        raise InvenioFileDownloadError(""%s seems to be empty"" % (url,))

    # download successful, return the new path
    return download_to_file"
4799,"def download_local_file(filename, download_to_file):
    """"""
    Copies a local file to Invenio's temporary directory.

    @param filename: the name of the file to copy
    @type filename: string

    @param download_to_file: the path to save the file to
    @type download_to_file: string

    @return: the path of the temporary file created
    @rtype: string
    @raise StandardError: if something went wrong
    """"""
    # Try to copy.
    try:
        path = urllib2.urlparse.urlsplit(urllib.unquote(filename))[2]
        if os.path.abspath(path) != path:
            msg = ""%s is not a normalized path (would be %s)."" \
                  % (path, os.path.normpath(path))
            raise InvenioFileCopyError(msg)

        allowed_path_list = current_app.config.get(
            'CFG_BIBUPLOAD_FFT_ALLOWED_LOCAL_PATHS', []
        )
        allowed_path_list.append(current_app.config['CFG_TMPSHAREDDIR'])
        for allowed_path in allowed_path_list:
            if path.startswith(allowed_path):
                shutil.copy(path, download_to_file)
                if os.path.getsize(download_to_file) == 0:
                    os.remove(download_to_file)
                    msg = ""%s seems to be empty"" % (filename,)
                    raise InvenioFileCopyError(msg)
                break
        else:
            msg = ""%s is not in one of the allowed paths."" % (path,)
            raise InvenioFileCopyError()
    except Exception as e:
        msg = ""Impossible to copy the local file '%s' to %s: %s"" % \
              (filename, download_to_file, str(e))
        raise InvenioFileCopyError(msg)

    return download_to_file"
4800,"def safe_mkstemp(suffix, prefix='filedownloadutils_'):
    """"""Create a temporary filename that don't have any '.' inside a part
    from the suffix.""""""
    tmpfd, tmppath = tempfile.mkstemp(
        suffix=suffix,
        prefix=prefix,
        dir=current_app.config['CFG_TMPSHAREDDIR']
    )
    # Close the file and leave the responsability to the client code to
    # correctly open/close it.
    os.close(tmpfd)

    if '.' not in suffix:
        # Just in case format is empty
        return tmppath
    while '.' in os.path.basename(tmppath)[:-len(suffix)]:
        os.remove(tmppath)
        tmpfd, tmppath = tempfile.mkstemp(
            suffix=suffix,
            prefix=prefix,
            dir=current_app.config['CFG_TMPSHAREDDIR']
        )
        os.close(tmpfd)
    return tmppath"
4801,"def open_url(url, headers=None):
    """"""
    Opens a URL. If headers are passed as argument, no check is performed and
    the URL will be opened.

    @param url: the URL to open
    @type url: string

    @param headers: the headers to use
    @type headers: dictionary

    @return: a file-like object as returned by urllib2.urlopen.
    """"""
    request = urllib2.Request(url)
    if headers:
        for key, value in headers.items():
            request.add_header(key, value)
    return URL_OPENER.open(request)"
4802,"def bulk_log(self, log_message=u""Еще одна пачка обработана"", total=None, part_log_time_minutes=5):
        """"""
        Возвращает инстант логгера для обработки списокв данных
        :param log_message: То, что будет написано, когда время придет
        :param total: Общее кол-во объектов, если вы знаете его
        :param part_log_time_minutes: Раз в какое кол-во минут пытаться писать лог
        :return: BulkLogger
        """"""
        return BulkLogger(log=self.log, log_message=log_message, total=total, part_log_time_minutes=part_log_time_minutes)"
4803,"def db(self, db_alias, shard_key=None):
        """"""
        Получить экземпляр работы с БД
        :type db_alias: basestring Альяс БД из меты
        :type shard_key: Любой тип. Некоторый идентификатор, который поможет мете найти нужную шарду. Тип зависи от принимающей стороны
        :rtype: DbQueryService
        """"""
        if shard_key is None:
            shard_key = ''

        db_key = db_alias + '__' + str(shard_key)
        if db_key not in self.__db_list:
            self.__db_list[db_key] = DbQueryService(self, self.__default_headers, {""db_alias"": db_alias, ""dbAlias"": db_alias, ""shard_find_key"": shard_key, ""shardKey"": shard_key})
        return self.__db_list[db_key]"
4804,"def __read_developer_settings(self):
        """"""
        Читает конфигурации разработчика с локальной машины или из переменных окружения
        При этом переменная окружения приоритетнее
        :return:
        """"""
        self.developer_settings = read_developer_settings()
        if not self.developer_settings:
            self.log.warning(""НЕ УСТАНОВЛЕНЫ настройки разработчика, это может приводить к проблемам в дальнейшей работе!"")"
4805,"def api_call(self, service, method, data, options):
        """"""
        :type app: metasdk.MetaApp
        """"""
        if 'self' in data:
            # может не быть, если вызывается напрямую из кода,
            # а не из прослоек типа DbQueryService
            data.pop(""self"")

        if options:
            data.update(options)

        _headers = dict(self.__default_headers)

        if self.auth_user_id:
            _headers['X-META-AuthUserID'] = str(self.auth_user_id)

        request = {
            ""url"": self.meta_url + ""/api/v1/adptools/"" + service + ""/"" + method,
            ""data"": json.dumps(data),
            ""headers"": _headers,
            ""timeout"": (60, 1800)
        }

        for _try_idx in range(20):
            try:
                resp = requests.post(**request)
                if resp.status_code == 200:
                    decoded_resp = json.loads(resp.text)
                    if 'data' in decoded_resp:
                        return decoded_resp['data'][method]
                    if 'error' in decoded_resp:
                        if 'details' in decoded_resp['error']:
                            eprint(decoded_resp['error']['details'])
                        raise DbQueryError(decoded_resp['error'])
                    raise UnexpectedError()
                else:
                    process_meta_api_error_code(resp.status_code, request, resp.text)
            except (requests.exceptions.ConnectionError, ConnectionError, TimeoutError) as e:
                self.log.warning('META API Connection Error. Sleep...', {""e"": e})
                time.sleep(15)
            except Exception as e:
                if 'Служба частично или полностью недоступна' in str(e):
                    self.log.warning('META API Connection Error. Sleep...', {""e"": e})
                    time.sleep(15)
                else:
                    raise e

        raise ServerError(request)"
4806,"def native_api_call(self, service, method, data, options, multipart_form=False, multipart_form_data=None, stream=False, http_path=""/api/meta/v1/"", http_method='POST',
                        get_params=None, connect_timeout_sec=60):
        """"""
        :type app: metasdk.MetaApp
        :rtype: requests.Response
        """"""
        if get_params is None:
            get_params = {}
        if 'self' in data:
            # может не быть, если вызывается напрямую из кода,
            # а не из прослоек типа DbQueryService
            data.pop(""self"")

        if options:
            data.update(options)

        _headers = dict(self.__default_headers)

        if self.auth_user_id:
            _headers['X-META-AuthUserID'] = str(self.auth_user_id)

        request = {
            ""url"": self.meta_url + http_path + service + ""/"" + method,
            ""timeout"": (connect_timeout_sec, 1800),
            ""stream"": stream,
            ""params"": get_params,
        }

        if multipart_form:
            if multipart_form_data:
                request['files'] = multipart_form_data
            request['data'] = data
            _headers.pop('content-type', None)
        else:
            request['data'] = json.dumps(data)
        request['headers'] = _headers

        for _try_idx in range(20):
            try:
                resp = requests.request(http_method, **request)
                if resp.status_code == 200:
                    return resp
                else:
                    process_meta_api_error_code(resp.status_code, request, resp.text)
            except (requests.exceptions.ConnectionError, ConnectionError, TimeoutError) as e:
                self.log.warning('META API Connection Error. Sleep...', {""e"": e})
                time.sleep(15)
            except Exception as e:
                if 'Служба частично или полностью недоступна' in str(e):
                    self.log.warning('META API Service Temporarily Unavailable. Sleep...', {""e"": e})
                    time.sleep(15)
                else:
                    raise e

        raise ServerError(request)"
4807,"async def get_json(self, url, timeout=30, astext=False, exceptions=False):
        """"""Get URL and parse JSON from text.""""""
        try:
            with async_timeout.timeout(timeout):
                res = await self._aio_session.get(url)
                if res.status != 200:
                    _LOGGER.error(""QSUSB returned %s [%s]"", res.status, url)
                    return None
                res_text = await res.text()
        except (aiohttp.client_exceptions.ClientError,
                asyncio.TimeoutError) as exc:
            if exceptions:
                raise exc
            return None

        if astext:
            return res_text

        try:
            return json.loads(res_text)
        except json.decoder.JSONDecodeError:
            if res_text.strip("" "") == """":
                return None
            _LOGGER.error(""Could not decode %s [%s]"", res_text, url)"
4808,"def stop(self):
        """"""Stop listening.""""""
        self._running = False
        if self._sleep_task:
            self._sleep_task.cancel()
            self._sleep_task = None"
4809,"def version(self):
        """"""Get the QS Mobile version.""""""
        return self.get_json(URL_VERSION.format(self._url), astext=True)"
4810,"def listen(self, callback=None):
        """"""Start the &listen long poll and return immediately.""""""
        self._running = True
        self.loop.create_task(self._async_listen(callback))"
4811,"async def _async_listen(self, callback=None):
        """"""Listen loop.""""""
        while True:
            if not self._running:
                return

            try:
                packet = await self.get_json(
                    URL_LISTEN.format(self._url), timeout=30, exceptions=True)
            except asyncio.TimeoutError:
                continue
            except aiohttp.client_exceptions.ClientError as exc:
                _LOGGER.warning(""ClientError: %s"", exc)
                self._sleep_task = self.loop.create_task(asyncio.sleep(30))
                try:
                    await self._sleep_task
                except asyncio.CancelledError:
                    pass
                self._sleep_task = None
                continue

            if isinstance(packet, dict) and QS_CMD in packet:
                _LOGGER.debug(""callback( %s )"", packet)
                try:
                    callback(packet)
                except Exception as err:  # pylint: disable=broad-except
                    _LOGGER.error(""Exception in callback\nType: %s: %s"",
                                  type(err), err)
            else:
                _LOGGER.debug(""unknown packet? %s"", packet)"
4812,"def set_qs_value(self, qsid, val, success_cb):
        """"""Push state to QSUSB, retry with backoff.""""""
        self.loop.create_task(self.async_set_qs_value(qsid, val, success_cb))"
4813,"async def async_set_qs_value(self, qsid, val, success_cb=None):
        """"""Push state to QSUSB, retry with backoff.""""""
        set_url = URL_SET.format(self._url, qsid, val)
        for _repeat in range(1, 6):
            set_result = await self.get_json(set_url, 2)
            if set_result and set_result.get('data', 'NO REPLY') != 'NO REPLY':
                if success_cb:
                    success_cb()
                return True
            await asyncio.sleep(0.01 * _repeat)
        _LOGGER.error(""Unable to set %s"", set_url)
        return False"
4814,"async def update_from_devices(self):
        """"""Retrieve a list of &devices and values.""""""
        res = await self.get_json(URL_DEVICES.format(self._url))
        if res:
            self.devices.update_devices(res)
            return True
        return False"
4815,"def multi_ops(data_stream, *funcs):
    """""" fork a generator with multiple operations/functions

        data_stream  -  an iterable data structure (ie: list/generator/tuple)
        funcs        -  every function that will be applied to the data_stream """"""

    assert all(callable(func) for func in funcs), 'multi_ops can only apply functions to the first argument'
    assert len(funcs), 'multi_ops needs at least one function to apply to data_stream'

    for i in data_stream:
        if len(funcs) > 1:
            yield tuple(func(i) for func in funcs)
        elif len(funcs) == 1:
            yield funcs[0](i)"
4816,"def attowiki_distro_path():
    """"""return the absolute complete path where attowiki is located

    .. todo:: use pkg_resources ?
    """"""
    attowiki_path = os.path.abspath(__file__)
    if attowiki_path[-1] != '/':
        attowiki_path = attowiki_path[:attowiki_path.rfind('/')]
    else:
        attowiki_path = attowiki_path[:attowiki_path[:-1].rfind('/')]
    return attowiki_path"
4817,"def build_command(self):
        """"""Build out the crontab command""""""
        return cron_utils.cronify(""crontab -l | {{ cat; echo \""{} {} {} {} {} CJOBID='{}' MAILTO='' {}\""; }} | crontab - > /dev/null"".format(self._minute, self._hour, self._day_of_month, self._month_of_year, self._day_of_week, self._jobid, self._command))"
4818,"def read_environment_file(envfile=None):
    """"""
    Read a .env file into os.environ.

    If not given a path to a envfile path, does filthy magic stack backtracking
    to find manage.py and then find the envfile.
    """"""
    if envfile is None:
        frame = sys._getframe()
        envfile = os.path.join(os.path.dirname(frame.f_back.f_code.co_filename), '.env')
        if not os.path.exists(envfile):
            warnings.warn(""not reading %s - it doesn't exist."" % envfile)
            return
    for k, v in parse_environment_file(envfile):
        os.environ.setdefault(k, v)"
4819,"def infer_format(filename:str) -> str:
    """"""Return extension identifying format of given filename""""""
    _, ext = os.path.splitext(filename)
    return ext"
4820,"def reversed_graph(graph:dict) -> dict:
    """"""Return given graph reversed""""""
    ret = defaultdict(set)
    for node, succs in graph.items():
        for succ in succs:
            ret[succ].add(node)
    return dict(ret)"
4821,"def walk(start:list, graphs:iter) -> iter:
    """"""walk on given graphs, beginning on start.
    Yield all found nodes, including start.

    All graph are understood as a single one,
    with merged keys and values.

    """"""
    walked = set([start])
    stack = [start]
    while len(stack) > 0:
        *stack, curr = stack
        yield curr
        succs = it.chain.from_iterable(graph.get(curr, ()) for graph in graphs)
        for succ in succs:
            if succ not in walked:
                walked.add(curr)
                stack.append(succ)"
4822,"def have_cycle(graph:dict) -> frozenset:
    """"""Perform a topologic sort to detect any cycle.

    Return the set of unsortable nodes. If at least one item,
    then there is cycle in given graph.

    """"""
    # topological sort
    walked = set()  # walked nodes
    nodes = frozenset(it.chain(it.chain.from_iterable(graph.values()), graph.keys()))  # all nodes of the graph
    preds = reversed_graph(graph)  # succ: preds
    last_walked_len = -1
    while last_walked_len != len(walked):
        last_walked_len = len(walked)
        for node in nodes - walked:
            if len(preds.get(node, set()) - walked) == 0:
                walked.add(node)
    return frozenset(nodes - walked)"
4823,"def file_lines(bblfile:str) -> iter:
    """"""Yield lines found in given file""""""
    with open(bblfile) as fd:
        yield from (line.rstrip() for line in fd if line.rstrip())"
4824,"def line_type(line:str) -> str:
    """"""Give type of input line, as defined in LINE_TYPES

    >>> line_type('IN\\ta\\tb')
    'IN'
    >>> line_type('')
    'EMPTY'

    """"""
    for regex, ltype in LINE_TYPES.items():
        if re.fullmatch(regex, line):
            return ltype
    raise ValueError(""Input line \""{}\"" is not bubble formatted"".format(line))"
4825,"def line_data(line:str) -> tuple:
    """"""Return groups found in given line

    >>> line_data('IN\\ta\\tb')
    ('IN', 'a', 'b')
    >>> line_data('')
    ()

    """"""
    for regex, _ in LINE_TYPES.items():
        match = re.fullmatch(regex, line)
        if match:
            return match.groups()
    raise ValueError(""Input line \""{}\"" is not bubble formatted"".format(line))"
4826,"def _catchCurrentViewContent(self):
        """"""!
        \~english
        Catch the current view content
        @return: a PIL Image
        @note 
            Automatically converts the cache color mode and at the 
            same time rotates the captured image data according to 
            the screen angle

        \~chinese
        从缓存中抓取当前视图大小的数据
        @return: PIL Image 对象
        @note 自动转换缓存色彩模式，同时根据屏幕角度设定旋转所抓取的图像数据
        """"""
        viewContent = None
        if self._buffer_color_mode != self._display_color_mode:
            viewContent = self._buffer.crop( self.View.rectToArray() ) .convert( self._display_color_mode )
        else:
            viewContent = self._buffer.crop( self.View.rectToArray() )

        # Rotate for display direction
        if self._display_direction == 0:
            return viewContent
        else:
            return viewContent.rotate( angle = self._display_direction, expand=True )"
4827,"def _initBuffer(self, bufferColorMode, bufferSize):
        """"""!
        \~english
        Initialize the buffer object instance, use PIL Image as for buffer
        @param bufferColorMode: ""RGB"" or ""1""
        @param bufferSize: (width, height)
        \~chinese
        初始化缓冲区对象实例，使用PIL Image作为缓冲区
        @param bufferColorMode: 色彩模式, 取值： ""RGB"" 或 ""1""
        @param bufferSize: 缓存大小 (width, height)，例如： (128, 64)
        """"""
        # super(SSScreenBase)._initBuffer(bufferColorMode, bufferSize)
        self._buffer_color_mode = bufferColorMode

        #create screen image buffer and canvas
        if bufferSize==None:
            self._buffer = Image.new( bufferColorMode , self._display_size )
        else:
            self._buffer = Image.new( bufferColorMode , bufferSize )        
        self.Canvas = ImageDraw.Draw( self._buffer )

        #creare screen view
        self.View = SSRect( 0, 0, self._display_size[0], self._display_size[1] )"
4828,"def clearCanvas(self, fillColor = 0 ):
        """"""!
        \~engliash
        Clear up canvas and fill color at same time
        @param fillColor:  a color value
        @note 
            The fillColor value range depends on the setting of _buffer_color_mode.
            * If it is SS_COLOR_MODE_MONO (""1"") monochrome mode, it can only select 0: black and 1: white
            * If it is SS_COLOR_MODE_RGB (""RGB"") color mode, RGB color values can be used
        \~chinese
        清除画布并同时填充颜色
        @param fillColor: 颜色值
        @note 
            fillColor 取值范围取决于 _buffer_color_mode 的设定。
            * 如果是 SS_COLOR_MODE_MONO (""1"") 单色模式，只能选择 0:黑色 和 1:白色 
            * 如果是 SS_COLOR_MODE_RGB (""RGB"") 彩色模式，可以使用 RGB 色彩值
        """"""
        self.Canvas.rectangle((0, 0, self._display_size[0], self._display_size[1]), outline=0, fill=fillColor)"
4829,"def clearView(self, fillColor = 0 ):
        """"""!
        \~english
        Clear up canvas with view size
        @param fillColor: a color value
        @note 
            The fillColor value range depends on the setting of _buffer_color_mode.
            * If it is SS_COLOR_MODE_MONO (""1"") monochrome mode, it can only select 0: black and 1: white
            * If it is SS_COLOR_MODE_RGB (""RGB"") color mode, RGB color values can be used

        \~chinese
        清除画布中当前视图大小的区域同时填充颜色
        @param fillColor: 颜色值
        @note 
            fillColor 取值范围取决于 _buffer_color_mode 的设定。
            * 如果是 SS_COLOR_MODE_MONO (""1"") 单色模式，只能选择 0:黑色 和 1:白色 
            * 如果是 SS_COLOR_MODE_RGB (""RGB"") 彩色模式，可以使用 RGB 色彩值
        """"""
        self.Canvas.rectangle(self.View.rectToArray(), outline=0, fill=fillColor)"
4830,"def redefineBuffer(self, newBuffer ):
        """"""!
        \~english 
        Redefine frame of Screen
        @param newFrame: a new fram data
        @note
            newFrame can be:
            * PIL Image
            * PIL ImageFile
            * Dictionary, eg. { ""size"":(width, height), ""color_mode"":""1"" } or { ""size"":(width, height), ""color_mode"":""RGB"" }

        \~chinese
        重新定义缓存数据
        @param newFrame: 新缓存数据 \n
            newFrame 可以为下面值:
            * PIL Image
            * PIL ImageFile
            * 字典, eg. { ""size"":(width, height), ""color_mode"":""1"" } or { ""size"":(width, height), ""color_mode"":""RGB"" } 
        """"""
        # Redefine Frame from an image object
        if type(self._buffer) == type(newBuffer):
            self._buffer = newBuffer
            self.Canvas = ImageDraw.Draw( self._buffer )
#             self.View.resize(newBuffer.width, newBuffer.height)
            return True

        # Redefine Frame from an <PIL.ImageFile.ImageFile>
        if type(newBuffer).__name__.find(PIL.ImageFile.ImageFile.__name__) != -1:        
            self._buffer = self._buffer.resize((newBuffer.width, newBuffer.height))
            self._buffer.paste( newBuffer, (0,0))
#             self.View.resize(newBuffer.width, newBuffer.height)
            return True

        # Recreated a new frame from dict of frame
        if isinstance(newBuffer, dict):
            self._buffer = Image.new( newBuffer[""color_mode""] , newBuffer[""size""] )
            self.Canvas = ImageDraw.Draw( self._buffer )
            return True
        pass"
4831,"def write(self, text="""", xy=(0,0), align=""left"", font=None, fontName=None, fontSize = 10, fill = 1, spacing = 0, screenCenter = False):
        """"""!
        \~english 
        Print one line text or multi-line text on the screen
        @param text: Text to be drawn. eg. ""Hello World!"" or ""Hello/nWorld!""
        @param xy: Top left corner of the text. defaule: (0,0)
        @param align: ""left"", ""center"" or ""right"". defaule: ""left""
        @param fontName: Name of font or font instance. defaule: None (use default font) 
        @param fontSize: Font size. default: 10
        @param fill: Color to use for the text. default: 1 (white)
        @param spacing: The number of pixels between lines. default: 0
        @param screenCenter： Keep the text center of screen. default: False
        
        @note
        How to use screenCenter?
        1. align=""left""; screenCenter=False
        <pre>
        +---------------------------------+
        |  Simple text line1              |
        |  Simple line2                   |
        |  Simple                         |
        |                                 |
        +---------------------------------+
        </pre>
        
        2. align=""left""; screenCenter=True
        <pre>
        +---------------------------------+
        |        Simple text line1        |
        |        Simple line2             |
        |        Simple                   |
        |                                 |
        +---------------------------------+
        </pre>

        \~chinese
        在屏幕上打印一行文字或多行文字        
        @param text: 要输出的文字，可以单行也可以多行。例如： ""Hello World!""  或 ""Hello/nWorld!""
        @param xy: 文字输出的坐标点。默认： (0,0)
        @param align: 多行文字对齐方式，可选： ""left"", ""center"" 或 ""right"". 默认： ""left""
        @param fontName: 字体名或字体对象实例。默认：None（使用系统默认的字体） 
        @param fontSize: 字体大小。默认：10
        @param fill: 文字颜色。默认： 1 （白色）
        @param spacing: 行间距。默认：0
        @param screenCenter： 让文本居中屏幕。
        
        @note
        screenCenter 效果示例：
        1. align=""left""; screenCenter=False
        <pre>
        +---------------------------------+
        |  Simple text line1              |
        |  Simple line2                   |
        |  Simple                         |
        |                                 |
        +---------------------------------+
        </pre>
        
        2. align=""left""; screenCenter=True
        <pre>
        +---------------------------------+
        |        Simple text line1        |
        |        Simple line2             |
        |        Simple                   |
        |                                 |
        +---------------------------------+
        </pre>
        """"""
        tx = xy[0]
        
        try:
            dwFont = font if font != None else DEF_SCR_FRONT if fontName==None else ImageFont.truetype(fontName, fontSize)
        except:
            dwFont = DEF_SCR_FRONT

        try:
            if screenCenter == True:
                (fw, fh) = self.Canvas.multiline_textsize( text, font )
                tx = xy[0] + (self._display_size[0]-fw)/2
            self.Canvas.multiline_text( (tx, xy[1]) , text, font = dwFont, align=align, fill=fill, spacing=spacing)
        except:
            print(""ERROR: canvas write error"")"
4832,"def resize(self, newWidth = 0, newHeight = 0):
        """"""!
        \~english 
        Resize width and height of rectangles
        @param newWidth: new width value
        @param newHeight: new height value
        \~chinese 
        重新设定矩形高宽
        @param newWidth: 新宽度
        @param newHeight: 新高度
        """"""
        self.height = newHeight
        self.width = newWidth"
4833,"def adjuestSize(self, offsetWidth = 0, offsetHeight = 0):
        """"""!
        \~english 
        Adjuest width and height of rectangles
        @param offsetWidth: adjust the width. Negative numbers are smaller, Positive number is increased
        @param offsetHeight: adjust the height. Negative numbers are smaller, Positive number is increased
        
        @note The negative numbers are smaller, positive number is increased，0 remains unchanged.
        
        \~chinese
        调整矩形高宽数据
        @param offsetWidth: 调整宽度。 负数较小，正数增加
        @param offsetHeight: 调整高度。 负数较小，正数增加

        @note 负数较小，正数增加，0保持不变。
        """"""
        self.height += offsetHeight
        self.width += offsetWidth"
4834,"def moveTo(self, newX=0, newY=0):
        """"""!
        \~english 
        Move vertex of rectangles to new point (x,y)
        @param newX: Coordinated X value
        @param newY: Coordinated Y value
        \~chinese
        移动矩形到新坐标点 (x,y)
        @param newX: 坐标 X
        @param newY: 坐标 Y
        """"""
        self.x = newX
        self.y = newY"
4835,"def moveOffset(self, offsetX=0, offsetY=0):
        """"""!
        \~english 
        Offset vertex of rectangles to new point (x,y)
        @param offsetX: offset X value
        @param offsetY: offset Y value
        @note The negative numbers are left or up move , positive number is right or down move，0 remains unchanged.
        \~chinese
        平移矩形指定的距离 (x,y)
        @param offsetX: 平移 X
        @param offsetY: 平移 Y
        @note 负数是左移( X )或上移( Y )，正数是右移( X )或下移( Y )，0 保持不变。
        """"""
        self.x += offsetX
        self.y += offsetY"
4836,"def swapWH(self):
        """"""!
        \~english Swap width and height of rectangles
        \~chinese 交换矩形高宽边数据
        """"""
        width = self.width
        self.width = self.height
        self.height = width"
4837,"def rectToArray(self, swapWH = False):
        """"""!
        \~english
        Rectangles converted to array of coordinates
        @return: an array of rect points. eg. (x1,y1,x2,y2)

        \~chinese
        矩形数据转换为矩形坐标数组
        @return: 矩形座标数组, 例如: ( x1,y1,x2,y2 )
        """"""
        if swapWH == False:
            return [self.x, self.y, self.x + self.width, self.y + self.height]
        else:
            return [self.x, self.y, self.x + self.height, self.y + self.width]"
4838,"def _needSwapWH(self, oldDirection, newDirection ):
        """"""!
        \~english
        return screen direction status
        @return Boolean
        @note No need to rotate if the screen orientation is 0 degrees and 180 degrees

        \~chinese
        返回屏幕方向状态
        @return 布尔值
        @note 如果屏幕方向是0度和180度就不需要旋转
        """"""
        if abs(newDirection - oldDirection) == 0: return False
        if abs(newDirection - oldDirection) % 180 == 0: return False
        if abs(newDirection - oldDirection) % 90 == 0: return True
        return False"
4839,"def rotateDirection(self, displayDirection):
        """"""!
        \~english rotate screen direction
        @param displayDirection: Screen Direction. value can be chosen: 0, 90, 180, 270
        \~chinese 旋转显示屏方向
        @param displayDirection: 显示屏方向。可选值： 0, 90, 180, 270
        
        \~
        @note
        \~english after rotate the View resize to screen size 
        \~chinese 改变方向后，默认的 View 大小会更新为当前 Screen 的大小
        \~\n
        """"""
        if self._needSwapWH(self._display_direction, displayDirection):
            self._display_size = ( self._display_size[1], self._display_size[0] )
            if self.redefineBuffer( { ""size"":self._display_size, ""color_mode"":self._buffer_color_mode } ):
                self.View.resize(self._display_size[0], self._display_size[1])
        self._display_direction = displayDirection"
4840,"def create_tax_class(cls, tax_class, **kwargs):
        """"""Create TaxClass

        Create a new TaxClass
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_tax_class(tax_class, async=True)
        >>> result = thread.get()

        :param async bool
        :param TaxClass tax_class: Attributes of taxClass to create (required)
        :return: TaxClass
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_tax_class_with_http_info(tax_class, **kwargs)
        else:
            (data) = cls._create_tax_class_with_http_info(tax_class, **kwargs)
            return data"
4841,"def delete_tax_class_by_id(cls, tax_class_id, **kwargs):
        """"""Delete TaxClass

        Delete an instance of TaxClass by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_tax_class_by_id(tax_class_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str tax_class_id: ID of taxClass to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_tax_class_by_id_with_http_info(tax_class_id, **kwargs)
        else:
            (data) = cls._delete_tax_class_by_id_with_http_info(tax_class_id, **kwargs)
            return data"
4842,"def get_tax_class_by_id(cls, tax_class_id, **kwargs):
        """"""Find TaxClass

        Return single instance of TaxClass by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_tax_class_by_id(tax_class_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str tax_class_id: ID of taxClass to return (required)
        :return: TaxClass
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_tax_class_by_id_with_http_info(tax_class_id, **kwargs)
        else:
            (data) = cls._get_tax_class_by_id_with_http_info(tax_class_id, **kwargs)
            return data"
4843,"def list_all_tax_classes(cls, **kwargs):
        """"""List TaxClasses

        Return a list of TaxClasses
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_tax_classes(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[TaxClass]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_tax_classes_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_tax_classes_with_http_info(**kwargs)
            return data"
4844,"def replace_tax_class_by_id(cls, tax_class_id, tax_class, **kwargs):
        """"""Replace TaxClass

        Replace all attributes of TaxClass
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_tax_class_by_id(tax_class_id, tax_class, async=True)
        >>> result = thread.get()

        :param async bool
        :param str tax_class_id: ID of taxClass to replace (required)
        :param TaxClass tax_class: Attributes of taxClass to replace (required)
        :return: TaxClass
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_tax_class_by_id_with_http_info(tax_class_id, tax_class, **kwargs)
        else:
            (data) = cls._replace_tax_class_by_id_with_http_info(tax_class_id, tax_class, **kwargs)
            return data"
4845,"def update_tax_class_by_id(cls, tax_class_id, tax_class, **kwargs):
        """"""Update TaxClass

        Update attributes of TaxClass
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_tax_class_by_id(tax_class_id, tax_class, async=True)
        >>> result = thread.get()

        :param async bool
        :param str tax_class_id: ID of taxClass to update. (required)
        :param TaxClass tax_class: Attributes of taxClass to update. (required)
        :return: TaxClass
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_tax_class_by_id_with_http_info(tax_class_id, tax_class, **kwargs)
        else:
            (data) = cls._update_tax_class_by_id_with_http_info(tax_class_id, tax_class, **kwargs)
            return data"
4846,"def autodiscover_modules(packages, related_name_re='.+',
                         ignore_exceptions=False):
    """"""Autodiscover function follows the pattern used by Celery.

    :param packages: List of package names to auto discover modules in.
    :type packages: list of str
    :param related_name_re: Regular expression used to match modules names.
    :type related_name_re: str
    :param ignore_exceptions: Ignore exception when importing modules.
    :type ignore_exceptions: bool
    """"""
    warnings.warn('autodiscover_modules has been deprecated. '
                  'Use Flask-Registry instead.', DeprecationWarning)
    global _RACE_PROTECTION

    if _RACE_PROTECTION:
        return []
    _RACE_PROTECTION = True
    modules = []
    try:
        tmp = [find_related_modules(pkg, related_name_re, ignore_exceptions)
               for pkg in packages]

        for l in tmp:
            for m in l:
                if m is not None:
                    modules.append(m)
    # Workaround for finally-statement
    except:
        _RACE_PROTECTION = False
        raise
    _RACE_PROTECTION = False
    return modules"
4847,"def find_related_modules(package, related_name_re='.+',
                         ignore_exceptions=False):
    """"""Find matching modules using a package and a module name pattern.""""""
    warnings.warn('find_related_modules has been deprecated.',
                  DeprecationWarning)
    package_elements = package.rsplit(""."", 1)
    try:
        if len(package_elements) == 2:
            pkg = __import__(package_elements[0], globals(), locals(), [
                             package_elements[1]])
            pkg = getattr(pkg, package_elements[1])
        else:
            pkg = __import__(package_elements[0], globals(), locals(), [])
        pkg_path = pkg.__path__
    except AttributeError:
        return []

    # Find all modules named according to related_name
    p = re.compile(related_name_re)
    modules = []

    for name in find_modules(package, include_packages=True):
        if p.match(name.split('.')[-1]):
            try:
                modules.append(import_string(name, silent=ignore_exceptions))
            except Exception as e:
                if not ignore_exceptions:
                    raise e

    return modules"
4848,"def import_related_module(package, pkg_path, related_name,
                          ignore_exceptions=False):
    """"""Import module from given path.""""""
    try:
        imp.find_module(related_name, pkg_path)
    except ImportError:
        return

    try:
        return getattr(
            __import__('%s' % (package), globals(), locals(), [related_name]),
            related_name
        )
    except Exception as e:
        if ignore_exceptions:
            current_app.logger.exception(
                'Can not import ""{}"" package'.format(package)
            )
        else:
            raise e"
4849,"def ansi(string, *args):
	"""""" Convenience function to chain multiple ColorWrappers to a string """"""

	ansi = ''

	for arg in args:
		arg = str(arg)
		if not re.match(ANSI_PATTERN, arg):
			raise ValueError('Additional arguments must be ansi strings')

		ansi += arg
	
	return ansi + string + colorama.Style.RESET_ALL"
4850,"def puts(*args, **kwargs):
	""""""
	Full feature printing function featuring
	trimming and padding for both files and ttys
	""""""

	# parse kwargs
	trim    = kwargs.pop('trim', False)
	padding = kwargs.pop('padding', None)
	stream  = kwargs.pop('stream', sys.stdout)

	# HACK: check if stream is IndentedFile
	indent = getattr(stream, 'indent', 0)

	# stringify args
	args = [str(i) for i in args]

	# helpers
	def trimstr(ansi, width):
		string = ''; size = 0; i = 0

		while i < len(ansi):
			mobj = re.match(ANSI_PATTERN, ansi[i:])
			if mobj:
				# append ansi code
				string = string + mobj.group(0)
				i += len(mobj.group(0))
			else:
				# loop for more ansi codes even at max width
				size += 1
				if size > width: break

				# append normal char
				string = string + ansi[i]
				i += 1
		return (string, size)

	# process strings
	if not stream.isatty():
		# remove ansi codes and print
		for string in args:
			stream.write(re.sub(ANSI_PATTERN, '', string) + '\n')
	else:
		# get terminal width
		try: curses.setupterm()
		except:
			trim = False
			padding = None
		else:
			width = curses.tigetnum('cols') - indent

		for string in args:
			if trim or padding:
				trimmed, size = trimstr(string, width)

			# trim string
			if trim:
				if len(trimmed) < len(string):
					trimmed = trimstr(string, width - 3)[0] + colorama.Style.RESET_ALL + '...'
				string = trimmed

			# add padding
			if padding:
				string += padding * (width - size)

			# print final string
			stream.write(string + '\n')"
4851,"def _restore_tree_for(root, translate):
    # type: (Any, Dict[Type[Nonterminal], Type[Rule]]) -> Union[Nonterminal, Terminal]
    """"""
    Create part of AST that generate epsilon.
    :param root: Symbol in the original rule that results in epsilon.
    Can be Nonterminal or epsilon itself.
    :param translate: Dictionary where key is nonterminal and value is rule which is next to generate epsilon.
    :return: Nonterminal instance with part of AST generating epsilon.
    """"""
    # the symbol is epsilon directly, just return Terminal.
    if root is EPSILON:
        return Terminal(EPSILON)
    # create nonterminal
    created_nonterm = root()  # type: Nonterminal
    created_rule = translate[root]()  # type: Rule
    created_nonterm._set_to_rule(created_rule)
    created_rule._from_symbols.append(created_nonterm)
    # all symbols from the right are rewritable to epsilon, so we need to restore them as well
    for ch in created_rule.right:
        p = _restore_tree_for(ch, translate)  # type: Nonterminal
        p._set_from_rule(created_rule)
        created_rule._to_symbols.append(p)
    return created_nonterm"
4852,"def epsilon_rules_restore(root):
    # type: (Nonterminal) -> Nonterminal
    """"""
    Transform parsed tree to contain epsilon rules originally removed from the grammar.
    :param root: Root of the parsed tree.
    :return: Modified tree including epsilon rules.
    """"""
    items = Traversing.post_order(root)
    items = filter(lambda x: isinstance(x, EpsilonRemovedRule), items)
    for rule in items:
        # create original rule
        created_rule = rule.from_rule()  # type: Rule
        # attach parrents parents
        for s in rule.from_symbols:  # type: Nonterminal
            s._set_to_rule(created_rule)
            created_rule._from_symbols.append(s)
        # attach children up to replace index (that will contain epsilon)
        for i in range(rule.replace_index):
            ch = rule.to_symbols[i]  # type: Nonterminal
            ch._set_from_rule(created_rule)
            created_rule._to_symbols.append(ch)
        # add symbols originally rewrote to epsilon
        symb = _restore_tree_for(created_rule.right[rule.replace_index], rule.backtrack)  # type: Nonterminal
        created_rule._to_symbols.append(symb)
        symb._set_from_rule(created_rule)
        # attach rest of children
        for i in range(rule.replace_index, len(rule.to_symbols)):
            ch = rule.to_symbols[i]  # type: Nonterminal
            ch._set_from_rule(created_rule)
            created_rule._to_symbols.append(ch)
    return root"
4853,"def char_on_predicate(compiler, cont, test):
  '''return current char and step if @test succeed, where 
  @test: a python function with one argument, which tests on one char and return True or False
         @test must be registered with register_function'''
  test = test.interlang()
  text = compiler.new_var(il.ConstLocalVar('text'))
  pos = compiler.new_var(il.ConstLocalVar('pos'))
  if not isinstance(test, il.PyFunction):
    raise DaoCompileTypeError(test)
  return il.Begin((
    il.AssignFromList(text, pos, il.parse_state),
    il.If(il.Ge(pos,il.Len(text)), 
      il.failcont(il.FALSE),
      il.If(il.Call(test, il.GetItem(text, pos)),
        il.begin(
          il.SetParseState(il.Tuple(text, il.add(pos, il.Integer(1)))),
          il.append_failcont(compiler, 
                             il.SetParseState(il.Tuple(text, pos))),
          cont(il.GetItem(text, pos))),
        il.failcont(il.FALSE)))))"
4854,"def char_between(lower, upper, func_name): 
  '''return current char and step if char is between lower and upper, where 
   @test: a python function with one argument, which tests on one char and return True or False
          @test must be registered with register_function'''
  function = register_function(func_name, 
                      lambda char: lower<=char<=upper)
  return char_on_predicate(function)"
4855,"def char_in(string, func_name): 
  '''return current char and step if char is in string, where 
   @test: a python function with one argument, which tests on one char and return True or False
          @test must be registered with register_function'''
  function = register_function(func_name, 
                      lambda char: char in string)
  return char_on_predicate(function)"
4856,"def string_on_predicate0(compiler, cont, test):
  '''return current char and step if @test succeed, where 
   @test: a python function with one argument, which tests on one char and return True or False
          @test must be registered with register_function'''
  test = test.interlang()
  text = compiler.new_var(il.ConstLocalVar('text'))
  pos = compiler.new_var(il.ConstLocalVar('pos'))
  length = compiler.new_var(il.ConstLocalVar('length'))
  p = compiler.new_var(il.LocalVar('p'))
  if not isinstance(test, il.PyFunction):
    raise DaoCompileTypeError(test)
  return il.Begin((
    il.AssignFromList(text, pos, il.parse_state),
    il.Assign(length, il.Len(text)),
    il.If(il.Ge(pos,il.Len(text)), 
      cont(il.String('')),
      il.begin(
        il.Assign(p, pos),
        il.While(il.And(il.Lt(p, length), il.Call(test, il.GetItem(text, p))),
               il.AddAssign(p, il.Integer(1))),
        il.SetParseState(il.Tuple(text, p)),
        il.append_failcont(compiler, 
                           il.SetParseState(il.Tuple(text, pos))),
        cont(il.GetItem(text, il.Slice2(pos, p)))))))"
4857,"def word(compiler, cont, arg):
  'word of letters'
  text = compiler.new_var(il.ConstLocalVar('text'))
  pos = compiler.new_var(il.ConstLocalVar('pos'))
  p = compiler.new_var(il.LocalVar('p'))
  length = compiler.new_var(il.ConstLocalVar('length'))
  if isinstance(arg, Var):
    arg = arg.interlang()
    x = compiler.new_var(il.ConstLocalVar('x'))
    return il.Begin((
      il.AssignFromList(text, pos, il.parse_state),
      il.Assign(length, il.Len(text)),
      il.If(il.Ge(pos, length),
        il.failcont(il.FALSE),
          il.If(il.And(il.Not(il.Cle(il.String('a'), il.GetItem(text, pos), il.String('z'))), 
                       il.Not(il.Cle(il.String('A'), il.GetItem(text, pos), il.String('Z')))), 
            il.failcont(il.FALSE),
            il.Begin((
              il.Assign(p, il.add(pos, il.Integer(1))),
              il.while_(il.And(il.Lt(p, length), 
                              il.Or(il.Cle(il.String('a'), il.GetItem(text, p), il.String('z')), 
                                    il.Cle(il.String('A'),il.GetItem(text, p),il.String('Z')))), 
                       il.AddAssign(p, il.Integer(1))),
              il.Assign(x, il.Deref(arg)),
              il.If(il.IsLogicVar(x),
                    il.begin(il.SetParseState(il.Tuple(text, p)),
                                   il.SetBinding(x, il.GetItem(text, il.Slice2(pos, p))),
                                   il.append_failcont(compiler, 
                                      il.SetParseState(il.Tuple(text, pos)),
                                      il.DelBinding(x)),
                                   cont(il.GetItem(text, pos))),
                    il.If(il.Isinstance(x, il.String('str')),
                          il.If(il.Eq(x, il.GetItem(text, il.Slice2(pos, p))),
                                il.begin(il.append_failcont(compiler, 
                                  il.SetParseState(il.Tuple(text, pos))),
                                  il.SetParseState(il.Tuple(text, p)),
                                  cont(il.GetItem(text, pos))),
                                il.failcont(il.NONE)),
                          il.RaiseTypeError(x)))))))))
  elif isinstance(arg, String):
    arg = arg.interlang()
    return il.Begin((
      il.AssignFromList(text, pos, il.parse_state),
      il.Assign(length, il.Len(text)),
      il.If(il.Ge(pos, length), 
        il.failcont(il.FALSE),
        il.If(il.And(il.Not(il.Cle(il.String('a'), il.GetItem(text, pos), il.String('z'))), 
                     il.Not(il.Cle(il.String('A'), il.GetItem(text, pos), il.String('Z')))), 
          il.failcont(il.FALSE),
        il.Begin((
          il.Assign(p, il.add(pos, il.Integer(1))),
          il.while_(il.And(il.Lt(p, length), 
                          il.Or(il.Cle(il.String('a'), il.GetItem(text, p), il.String('z')), 
                                il.Cle(il.String('A'),il.GetItem(text, p), il.String('Z')))), 
                  il.AddAssign(p, il.Integer(1))),
          il.If(il.Eq(arg, il.GetItem(text, il.Slice2(pos, p))),
                il.begin(il.append_failcont(compiler, 
                  il.SetParseState(il.Tuple(text, pos))),
                  il.SetParseState(il.Tuple(text, p)),
                  cont(arg)),
                il.failcont(il.NONE))))))))
  else:
    raise CompileTypeError"
4858,"def literal(compiler, cont, arg):
  '''any given instance string'''
  text = compiler.new_var(il.ConstLocalVar('text'))
  pos = compiler.new_var(il.ConstLocalVar('pos'))
  p = compiler.new_var(il.LocalVar('p'))
  i = compiler.new_var(il.LocalVar('i'))
  x = compiler.new_var(il.ConstLocalVar('x'))
  length = compiler.new_var(il.ConstLocalVar('length'))  
  length2 = compiler.new_var(il.ConstLocalVar('length2'))  
  if isinstance(arg, Var):
    return il.Begin((
      il.Assign(x, il.Deref(arg)),
      il.AssignFromList(text, pos, il.parse_state),
      il.Assign(length, il.Len(text)),
      il.Assign(length, il.Len(x)),
      il.Assign(i, il.Integer(0)),
      il.Assign(p, pos),
      il.while_(il.and_(il.Lt(i, length2), il.Lt(p, length), il.Eq(il.GetItem(text, p), il.GetItem(x, i))), 
        il.AddAssign(p, il.Integer(1))),
      il.If(il.Lt(i, length2), 
        il.failcont(il.NONE),
        il.begin(il.append_failcont(compiler, 
          il.SetParseState(il.Tuple(text, pos))),
          il.SetParseState(il.Tuple(text, p)),
          cont(arg)))))
  elif isinstance(arg, String):
    arg = arg.interlang()
    return il.Begin((
      il.AssignFromList(text, pos, il.parse_state),
      il.Assign(length, il.Len(text)),
      il.Assign(length2, il.Len(arg)),
      il.Assign(i, il.Integer(0)),
      il.Assign(p, pos),
      il.while_(il.and_(il.Lt(i, length2), il.Lt(p, length), il.Eq(il.GetItem(text, p), il.GetItem(arg, i))), 
        il.AddAssign(p, il.Integer(1)),
        il.AddAssign(i, il.Integer(1)),
        ),
      il.If(il.Lt(i, length2), 
        il.failcont(il.NONE),
        il.begin(il.append_failcont(compiler, 
          il.SetParseState(il.Tuple(text, pos))),
          il.SetParseState(il.Tuple(text, p)),
          cont(arg)))))
  else:
    raise CompileTypeError"
4859,"def update_version(self, version, step=1):
        ""Compute an new version and write it as a tag""

        # update the version based on the flags passed.
        if self.config.patch:
            version.patch += step
        if self.config.minor:
            version.minor += step
        if self.config.major:
            version.major += step
        if self.config.build:
            version.build_number += step
        if self.config.build_number:
            version.build_number = self.config.build_number

        # create a new tag in the repo with the new version.
        if self.config.dry_run:
            log.info('Not updating repo to version {0}, because of --dry-run'.format(version))
        else:
            version = self.call_plugin_function('set_version', version)

        return version"
4860,"def row(self):
        """"""Returns current data row: MyDBRow object, or None""""""
        ret = None
        i = self.tableWidget.currentRow()
        if i >= 0:
            ret = self._data[i]
        return ret"
4861,"def _find_id(self, id_):
        """"""Moves to row where formula is (if found, otherwise does nothing)""""""
        for i, row in enumerate(self._data):
            if row[""id""] == id_:
                t = self.tableWidget
                # idx = t.itemFromIndex()
                t.setCurrentCell(i, 0)
                break"
4862,"def _wanna_emit_id_changed(self):
        """"""Filters intentions to emit the id_changed signal (only does if id really changed)""""""
        if self._last_id != self._get_id():
            self._last_id = self._get_id()
            self.id_changed.emit()"
4863,"def _get_id(self):
        """"""Getter because using the id property from within was not working""""""
        ret = None
        row = self.row
        if row:
            ret = row[""id""]
        return ret"
4864,"def time_pipeline(iterable, *steps):
    '''
This times the steps in a pipeline. Give it an iterable to test against
followed by the steps of the pipeline seperated in individual functions.

Example Usage:
```
    from random import choice, randint

    l = [randint(0,50) for i in range(100)]

    step1 = lambda iterable:(i for i in iterable if i%5==0)
    step2 = lambda iterable:(i for i in iterable if i%8==3)
    step3 = lambda iterable:sorted((1.0*i)/50 for i in iterable)
    step4 = lambda iterable:(float(float(float(float(i*3)))) for i in iterable)

    print('filter first')
    time_pipeline(l, step1, step2, step3, step4)
    print('process first')
    time_pipeline(l, step3, step4, step1, step2)
    print('filter, process, filter, process')
    time_pipeline(l, step1, step3, step2, step4)
``` 

Outputs:
    filter first
    step 1 | 2.0427s | step1 = lambda iterable:(i for i in iterable if i%5==0)
    step 2 | 2.0510s | step2 = lambda iterable:(i for i in iterable if i%8==3)
    step 3 | 2.4839s | step3 = lambda iterable:sorted((1.0*i)/50 for i in iterable)
    step 4 | 2.8446s | step4 = lambda iterable:(float(float(float(float(i*3)))) for i in iterable)
    process first
    step 1 | 7.5291s | step3 = lambda iterable:sorted((1.0*i)/50 for i in iterable)
    step 2 | 20.6732s | step4 = lambda iterable:(float(float(float(float(i*3)))) for i in iterable)
    step 3 | 16.8470s | step1 = lambda iterable:(i for i in iterable if i%5==0)
    step 4 | 16.8269s | step2 = lambda iterable:(i for i in iterable if i%8==3)
    filter, process, filter, process
    step 1 | 2.0528s | step1 = lambda iterable:(i for i in iterable if i%5==0)
    step 2 | 3.3039s | step3 = lambda iterable:sorted((1.0*i)/50 for i in iterable)
    step 3 | 3.1385s | step2 = lambda iterable:(i for i in iterable if i%8==3)
    step 4 | 3.1489s | step4 = lambda iterable:(float(float(float(float(i*3)))) for i in iterable)
'''
    if callable(iterable):
        try:
            iter(iterable())
            callable_base = True
        except:
            raise TypeError('time_pipeline needs the first argument to be an iterable or a function that produces an iterable.')
    else:
        try:
            iter(iterable)
            callable_base = False
        except:
            raise TypeError('time_pipeline needs the first argument to be an iterable or a function that produces an iterable.')
    # if iterable is not a function, load the whole thing
    # into a list so it can be ran over multiple times
    if not callable_base:
        iterable = tuple(iterable)
    # these store timestamps for time calculations
    durations = []
    results = []
    for i,_ in enumerate(steps):
        current_tasks = steps[:i+1]
        #print('testing',current_tasks)
        duration = 0.0
        # run this test x number of times
        for t in range(100000):
            # build the generator
            test_generator = iter(iterable()) if callable_base else iter(iterable)
            # time its execution
            start = ts()
            for task in current_tasks:
                test_generator = task(test_generator)
            for i in current_tasks[-1](test_generator):
                pass
            duration += ts() - start
        durations.append(duration)
        if len(durations) == 1:
            results.append(durations[0])
            #print(durations[0],durations[0])
        else:
            results.append(durations[-1]-durations[-2])
            #print(durations[-1]-durations[-2],durations[-1])
    #print(results)
    #print(durations)
    assert sum(results) > 0
    resultsum = sum(results)
    ratios = [i/resultsum for i in results]
    #print(ratios)
    for i in range(len(ratios)):
        try:
            s = getsource(steps[i]).splitlines()[0].strip()
        except:
            s = repr(steps[i]).strip()
        print('step {} | {:2.4f}s | {}'.format(i+1, durations[i], s))"
4865,"def runs_per_second(generator, seconds=3):
    ''' 
use this function as a profiler for both functions and generators
to see how many iterations or cycles they can run per second 

Example usage for timing simple operations/functions:

``` 
    print(runs_per_second(lambda:1+2))
    # 2074558
    print(runs_per_second(lambda:1-2))
    # 2048523
    print(runs_per_second(lambda:1/2))
    # 2075186
    print(runs_per_second(lambda:1*2))
    # 2101722
    print(runs_per_second(lambda:1**2))
    # 2104572
```

Example usage for timing iteration speed of generators:
  
``` 
    def counter():
        c = 0
        while 1:
            yield c
            c+=1

    print(runs_per_second(counter()))
    # 1697328
    print(runs_per_second((i for i in range(2000))))
    # 1591301
``` 
'''
    assert isinstance(seconds, int), 'runs_per_second needs seconds to be an int, not {}'.format(repr(seconds))
    assert seconds>0, 'runs_per_second needs seconds to be positive, not {}'.format(repr(seconds))
    # if generator is a function, turn it into a generator for testing
    if callable(generator) and not any(i in ('next', '__next__', '__iter__') for i in dir(generator)):
        try:
            # get the output of the function
            output = generator()
        except:
            # if the function crashes without any arguments
            raise Exception('runs_per_second needs a working function that accepts no arguments')
        else:
            # this usage of iter infinitely calls a function until the second argument is the output
            # so I set the second argument to something that isnt what output was.
            generator = iter(generator, (1 if output is None else None))
            del output
    c=0  # run counter, keep this one short for performance reasons
    entire_test_time_used = False
    start = ts()
    end = start+seconds
    for _ in generator:
        if ts()>end:
            entire_test_time_used = True
            break
        else:
            c += 1
    duration = (ts())-start  # the ( ) around ts ensures that it will be the first thing calculated
    return int(c/(seconds if entire_test_time_used else duration))"
4866,"def remove_unreachable_symbols(grammar, inplace=False):
    # type: (Grammar, bool) -> Grammar
    """"""
    Remove unreachable symbols from the gramar
    :param grammar: Grammar where to symbols remove
    :param inplace: True if transformation should be performed in place. False by default.
    :return: Grammar without unreachable symbols.
    """"""
    # copy if required
    if inplace is False:
        grammar = copy(grammar)
    # check if start symbol is set
    if grammar.start is None:
        raise StartSymbolNotSetException()
    # create process sets
    reachable = {grammar.start}
    rules = grammar.rules.copy()
    # begin iterations
    while True:
        # create sets for current iteration
        active = reachable.copy()
        # loop the working rules
        for rule in rules.copy():
            # lf left part of rule already in reachable symbols
            if rule.fromSymbol in reachable:
                # set symbols on the right as reachable
                for symbol in rule.right:
                    active.add(symbol)
                # remove rule from the next iteration
                rules.remove(rule)
            # end of rules loop
        # if current and previous iterations are same, we are done
        if active == reachable:
            break
        # otherwise swap the sets
        reachable = active
    # remove the symbols
    nonterminals_to_remove = grammar.nonterminals.difference(reachable)
    terminals_to_remove = grammar.terminals.difference(reachable)
    grammar.nonterminals.remove(*nonterminals_to_remove)
    grammar.terminals.remove(*terminals_to_remove)
    # return grammar
    return grammar"
4867,"def fermion_avg(efermi, norm_hopping, func):
    """"""calcules for every slave it's average over the desired observable""""""
    if func == 'ekin':
        func = bethe_ekin_zeroT
    elif func == 'ocupation':
        func = bethe_filling_zeroT

    return np.asarray([func(ef, tz) for ef, tz in zip(efermi, norm_hopping)])"
4868,"def spinflipandhop(slaves):
    """"""Calculates the interaction term of a spin flip and pair hopping""""""

    Sdw = [csr_matrix(spin_gen(slaves, i, 0)) for i in range(slaves)]
    Sup = [mat.T for mat in Sdw]

    sfh = np.zeros_like(Sup[0])
    orbitals = slaves//2
    for n in range(orbitals):
        for m in range(n+1, orbitals):
            sfh += Sup[2*n  ] * Sdw[2*n + 1] * Sup[2*m + 1] * Sdw[2*m  ]
            sfh += Sup[2*n+1] * Sdw[2*n    ] * Sup[2*m    ] * Sdw[2*m+1]

            sfh += Sup[2*n] * Sup[2*n + 1] * Sdw[2*m] * Sdw[2*m+1]
            sfh += Sup[2*m] * Sup[2*m + 1] * Sdw[2*n] * Sdw[2*n+1]

    return sfh"
4869,"def spin_z_op(param, oper):
    """"""Generates the required Sz operators, given the system parameter setup
       and the operator dictionary""""""
    slaves = param['slaves']
    oper['Sz'] = np.array([spin_z(slaves, spin) for spin in range(slaves)])
    oper['Sz+1/2'] = oper['Sz'] + 0.5*np.eye(2**slaves)
    oper['sumSz2'] = oper['Sz'].sum(axis=0)**2  # because Sz is diagonal
    Sz_mat_shape = oper['Sz'].reshape(param['orbitals'], 2, 2**slaves, 2**slaves)
    oper['sumSz-sp2'] = (Sz_mat_shape.sum(axis=1)**2).sum(axis=0)
    oper['sumSz-or2'] = (Sz_mat_shape.sum(axis=0)**2).sum(axis=0)"
4870,"def spin_gen_op(oper, gauge):
    """"""Generates the generic spin matrices for the system""""""
    slaves = len(gauge)
    oper['O'] = np.array([spin_gen(slaves, i, c) for i, c in enumerate(gauge)])
    oper['O_d'] = np.transpose(oper['O'], (0, 2, 1))
    oper['O_dO'] = np.einsum('...ij,...jk->...ik', oper['O_d'], oper['O'])
    oper['Sfliphop'] = spinflipandhop(slaves)"
4871,"def set_filling(self, populations):
        """"""Sets the orbital enenergies for on the reference of the free case.
          By setting the desired local populations on every orbital.
          Then generate the necesary operators to respect such configuraion""""""
        populations = np.asarray(populations)
#
#        self.param['orbital_e'] -= bethe_findfill_zeroT( \
#                                        self.param['avg_particles'],
#                                        self.param['orbital_e'],
#                                        self.param['hopping'])
        efermi = - bethe_find_crystalfield(
                            populations, self.param['hopping'])
        self.param['populations'] = populations
#        fermion_avg(efermi, self.param['hopping'], 'ocupation')
        self.param['ekin'] = fermion_avg(efermi, self.param['hopping'], 'ekin')

        spin_gen_op(self.oper, estimate_gauge(populations))"
4872,"def reset(self, populations, lag, mu, u_int, j_coup, mean_f):
        """"""Resets the system into the last known state as given by the input
           values""""""

        self.set_filling(populations)
        self.param['lambda'] = lag
        self.param['orbital_e'] = mu
        self.selfconsistency(u_int, j_coup, mean_f)"
4873,"def update_H(self, mean_field, l):
        """"""Updates the spin hamiltonian and recalculates its eigenbasis""""""

        self.H_s = self.spin_hamiltonian(mean_field, l)
        try:
            self.eig_energies, self.eig_states = diagonalize(self.H_s)
        except np.linalg.linalg.LinAlgError:
            np.savez('errorhamil', H=self.H_s, fiel=mean_field, lamb=l)
            raise
        except ValueError:
            np.savez('errorhamil', H=self.H_s, fiel=mean_field, lamb=l)
            print(mean_field, l)
            raise"
4874,"def spin_hamiltonian(self, h, l):
        """"""Constructs the single site spin Hamiltonian""""""
        h_spin  = np.einsum('i,ijk', h[1], self.oper['O'])
        h_spin += np.einsum('i,ijk', h[0], self.oper['O_d'])
        h_spin += np.einsum('i,ijk', l, self.oper['Sz+1/2'])

        h_spin += self.oper['Hint']
        return h_spin"
4875,"def inter_spin_hamiltonian(self, u_int, J_coup):
        """"""Calculates the interaction Hamiltonian. The Hund coupling is a
           fraction of the coulom interaction""""""
        J_coup *= u_int
        h_int  = (u_int - 2*J_coup)/2.*self.oper['sumSz2']
        h_int += J_coup*self.oper['sumSz-sp2']
        h_int -= J_coup/2.*self.oper['sumSz-or2']
        h_int -= J_coup*self.oper['Sfliphop']

        return h_int"
4876,"def expected(self, observable, beta=1e5):
        """"""Wrapper to the expected_value function to fix the eigenbasis""""""
        return expected_value(observable,
                         self.eig_energies,
                         self.eig_states,
                         beta)"
4877,"def quasiparticle_weight(self):
        """"""Calculates quasiparticle weight""""""
        return np.array([self.expected(op)**2 for op in self.oper['O']])"
4878,"def mean_field(self):
        """"""Calculates mean field""""""
        mean_field = []
        for sp_oper in [self.oper['O'], self.oper['O_d']]:
            avgO = np.array([self.expected(op) for op in sp_oper])
            avgO[abs(avgO) < 1e-10] = 0.
            mean_field.append(avgO*self.param['ekin'])

        return np.array(mean_field)"
4879,"def selfconsistency(self, u_int, J_coup, mean_field_prev=None):
        """"""Iterates over the hamiltonian to get the stable selfcosistent one""""""
        if mean_field_prev is None:
            mean_field_prev = np.array([self.param['ekin']]*2)
        hlog = [mean_field_prev]

        self.oper['Hint'] = self.inter_spin_hamiltonian(u_int, J_coup)
        converging = True
        half_fill = (self.param['populations'] == 0.5).all()
        while converging:
            if half_fill:
                self.update_H(hlog[-1], self.param['lambda'])
            else:
                res = root(self.restriction, self.param['lambda'], (hlog[-1]))#, method='lm')
                if not res.success:
                    res.x = res.x * 0.5 + 0.5*self.param['lambda']
                    self.update_H(self.mean_field()*0.5 + 0.5*hlog[-1], res.x)
                    print('fail', self.param['populations'][3:5])
                if (self.quasiparticle_weight() < 0.001).all():
                    return hlog
                self.param['lambda'] = res.x

            hlog.append(self.mean_field())
            converging = (abs(hlog[-1] - hlog[-2]) > self.param['tol']).all() \
                    or (abs(self.restriction(self.param['lambda'], hlog[-1])) > self.param['tol']).all()

        return hlog"
4880,"def restriction(self, lam, mean_field):
        """"""Lagrange multiplier in lattice slave spin""""""
        self.update_H(mean_field, lam)
        restric = np.array([self.expected(op) - n for op, n in zip(self.oper['Sz+1/2'], self.param['populations'])])
        return restric"
4881,"def others2db(file_path, file_type, is_copy, step_id, db_conn):
    """"""Extract some meta-data from files (actually mostly from their paths) and stores it in a DB.

    Arguments:
    :param file_path: File path.
    :param file_type: File type.
    :param is_copy: Indicate if this file is a copy.
    :param step_id: Step ID.
    :param db_conn: Database connection.
    :return:
    """"""
    logging.info(""Processing '%s'"" % file_path)

    df = db_conn.db_session.query(db_conn.DataFile).filter_by(path=file_path).one_or_none()

    if not df:
        df = db_conn.DataFile(
            path=file_path,
            type=file_type,
            is_copy=is_copy,
            processing_step_id=step_id
        )
        db_conn.db_session.merge(df)
        db_conn.db_session.commit()
    else:
        if file_type not in [None, '', df.type]:
            df.type = file_type
            db_conn.db_session.commit()
        if is_copy not in [None, df.is_copy]:
            df.is_copy = is_copy
            db_conn.db_session.commit()
        if step_id not in [None, df.processing_step_id]:
            df.processing_step_id = step_id
            db_conn.db_session.commit()"
4882,"def create_currency(cls, currency, **kwargs):
        """"""Create Currency

        Create a new Currency
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_currency(currency, async=True)
        >>> result = thread.get()

        :param async bool
        :param Currency currency: Attributes of currency to create (required)
        :return: Currency
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_currency_with_http_info(currency, **kwargs)
        else:
            (data) = cls._create_currency_with_http_info(currency, **kwargs)
            return data"
4883,"def delete_currency_by_id(cls, currency_id, **kwargs):
        """"""Delete Currency

        Delete an instance of Currency by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_currency_by_id(currency_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str currency_id: ID of currency to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_currency_by_id_with_http_info(currency_id, **kwargs)
        else:
            (data) = cls._delete_currency_by_id_with_http_info(currency_id, **kwargs)
            return data"
4884,"def get_currency_by_id(cls, currency_id, **kwargs):
        """"""Find Currency

        Return single instance of Currency by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_currency_by_id(currency_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str currency_id: ID of currency to return (required)
        :return: Currency
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_currency_by_id_with_http_info(currency_id, **kwargs)
        else:
            (data) = cls._get_currency_by_id_with_http_info(currency_id, **kwargs)
            return data"
4885,"def list_all_currencies(cls, **kwargs):
        """"""List Currencies

        Return a list of Currencies
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_currencies(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[Currency]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_currencies_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_currencies_with_http_info(**kwargs)
            return data"
4886,"def replace_currency_by_id(cls, currency_id, currency, **kwargs):
        """"""Replace Currency

        Replace all attributes of Currency
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_currency_by_id(currency_id, currency, async=True)
        >>> result = thread.get()

        :param async bool
        :param str currency_id: ID of currency to replace (required)
        :param Currency currency: Attributes of currency to replace (required)
        :return: Currency
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_currency_by_id_with_http_info(currency_id, currency, **kwargs)
        else:
            (data) = cls._replace_currency_by_id_with_http_info(currency_id, currency, **kwargs)
            return data"
4887,"def update_currency_by_id(cls, currency_id, currency, **kwargs):
        """"""Update Currency

        Update attributes of Currency
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_currency_by_id(currency_id, currency, async=True)
        >>> result = thread.get()

        :param async bool
        :param str currency_id: ID of currency to update. (required)
        :param Currency currency: Attributes of currency to update. (required)
        :return: Currency
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_currency_by_id_with_http_info(currency_id, currency, **kwargs)
        else:
            (data) = cls._update_currency_by_id_with_http_info(currency_id, currency, **kwargs)
            return data"
4888,"def run_cmd(cmd, out=os.path.devnull, err=os.path.devnull):
    """"""Runs an external command

    :param list cmd: Command to run.
    :param str out: Output file
    :param str err: Error file
    :raises: RuntimeError
    """"""

    logger.debug(' '.join(cmd))
    with open(out, 'w') as hout:
        proc = subprocess.Popen(cmd, stdout=hout, stderr=subprocess.PIPE)
        err_msg = proc.communicate()[1].decode()
    with open(err, 'w') as herr:
        herr.write(str(err_msg))
    msg = '({}) {}'.format(' '.join(cmd), err_msg)
    if proc.returncode != 0:
        logger.error(msg)
        raise RuntimeError(msg)"
4889,"def run_cmd_if_file_missing(cmd, fname, out=os.path.devnull, err=os.path.devnull):
    """"""Runs an external command if file is absent.

    :param list cmd: Command to run.
    :param str fname: Path to the file, which existence is being checked.
    :param str out: Output file
    :param str err: Error file
    :return: True if cmd was executed, False otherwise
    :rtype: boolean
    """"""

    if fname is None or not os.path.exists(fname):
        run_cmd(cmd, out, err)
        return True
    else:
        return False"
4890,"def merge_files(sources, destination):
    """"""Copy content of multiple files into a single file.

    :param list(str) sources: source file names (paths)
    :param str destination: destination file name (path)
    :return:
    """"""

    with open(destination, 'w') as hout:
        for f in sources:
            if os.path.exists(f):
                with open(f) as hin:
                    shutil.copyfileobj(hin, hout)
            else:
                logger.warning('File is missing: {}'.format(f))"
4891,"def add_path(self, path):
        """""" Adds a new path to the list of searchable paths

        :param path: new path
        """"""

        if os.path.exists(path):
            self.paths.add(path)
            return path
        else:
            #logger.debug('Path {} doesn\'t exist'.format(path))
            return None"
4892,"def get(self, name):
        """""" Looks for a name in the path.

        :param name: file name
        :return: path to the file
        """"""

        for d in self.paths:
            if os.path.exists(d) and name in os.listdir(d):
                return os.path.join(d, name)
        logger.debug('File not found {}'.format(name))
        return None"
4893,"def overwrite_fits(hdulist, filename):
    """"""
    Saves a FITS file. Combined file rename, save new, delete renamed for FITS files
    Why: HDUlist.writeto() does not overwrite existing files
    Why(2): It is also a standardized way to save FITS files
    """"""

    assert isinstance(hdulist, (fits.HDUList, fits.PrimaryHDU))
    temp_name = None
    flag_delete_temp = False
    if os.path.isfile(filename):
        # PyFITS does not overwrite file
        temp_name = a99.rename_to_temp(filename)
    try:
        hdulist.writeto(filename, output_verify='warn')
        flag_delete_temp = temp_name is not None
    except:
        # Writing failed, reverts renaming
        os.rename(temp_name, filename)
        raise

    if flag_delete_temp:
        os.unlink(temp_name)"
4894,"def load_conf(yml_file, conf={}):
    """"""
    To load the config
    :param yml_file: the config file path
    :param conf: dict, to override global config
    :return: dict
    """"""
    with open(yml_file) as f:
        data = yaml.load(f)
        if conf:
            data.update(conf)
        return dictdot(data)"
4895,"def table_exists(
        dbConn,
        log,
        dbTableName):
    """"""*Probe a database to determine if a given table exists*

    **Key Arguments:**
        - ``dbConn`` -- mysql database connection
        - ``log`` -- logger
        - ``dbTableName`` -- the database tablename

    **Return:**
        - ``tableExists`` -- True or False

    **Usage:**

        To test if a table exists in a database:

        .. code-block:: python 

            from fundamentals.mysql import table_exists
            exists = table_exists(
                dbConn=dbConn,
                log=log,
                dbTableName=""stupid_named_table""
            )

            print exists

            # OUTPUT: False
    """"""
    log.debug('starting the ``table_exists`` function')

    sqlQuery = u""""""
        SELECT count(*)
        FROM information_schema.tables
        WHERE table_name = '%(dbTableName)s'
    """""" % locals()
    tableExists = readquery(
        log=log,
        sqlQuery=sqlQuery,
        dbConn=dbConn,
        quiet=False
    )

    if tableExists[0][""count(*)""] == 0:
        tableExists = False
    else:
        tableExists = True

    log.debug('completed the ``table_exists`` function')
    return tableExists"
4896,"def __handle_request(self, request, *args, **kw):
        """""" Intercept the request and response.

        This function lets `HttpStatusCodeError`s fall through. They
        are caught and transformed into HTTP responses by the caller.

        :return: ``HttpResponse``
        """"""

        self._authenticate(request)
        self._check_permission(request)
        method = self._get_method(request)
        data = self._get_input_data(request)
        data = self._clean_input_data(data, request)
        response = self._exec_method(method, request, data, *args, **kw)
        return self._process_response(response, request)"
4897,"def _exec_method(self, method, request, data, *args, **kw):
        """""" Execute appropriate request handler. """"""
        if self._is_data_method(request):
            return method(data, request, *args, **kw)
        else:
            return method(request, *args, **kw)"
4898,"def _process_response(self, response, request):
        """""" Process the response.

        If the response is ``HttpResponse``, does nothing. Otherwise,
        serializes, formats and validates the response.

        :param response: resource's response. This can be
           - ``None``,
           - django's ``HttpResponse``
           - devil's ``Response``
           - dictionary (or list of dictionaries)
           - object (or list of objects) that are first serialized into dict
             using ``self.factory``.
           - plaintext
        :returns: Django's ``HttpResponse``
        """"""

        def coerce_response():
            """""" Coerce the response object into devil structure. """"""
            if not isinstance(response, Response):
                return Response(0, response)
            return response

        if isinstance(response, HttpResponse):
            # we don't do anything if resource returns django's http response
            return response

        devil_res = coerce_response()
        if devil_res.content and devil_res.get_code_num() in (0, 200, 201):
            # serialize, format and validate
            serialized_res = devil_res.content = self._serialize_object(devil_res.content, request)
            formatted_res = self._format_response(request, devil_res)
            self._validate_output_data(response, serialized_res, formatted_res, request)
        else:
            # no data -> format only
            formatted_res = self._format_response(request, devil_res)
        return formatted_res"
4899,"def _format_response(self, request, response):
        """""" Format response using appropriate datamapper.

        Take the devil response and turn it into django response, ready to
        be returned to the client.
        """"""

        res = datamapper.format(request, response, self)
        # data is now formatted, let's check if the status_code is set
        if res.status_code is 0:
            res.status_code = 200
        # apply headers
        self._add_resposne_headers(res, response)
        return res"
4900,"def _add_resposne_headers(self, django_response, devil_response):
        """""" Add response headers.

        Add HTTP headers from devil's response to django's response.
        """"""

        try:
            headers = devil_response.headers
        except AttributeError:
            # ok, there was no devil_response
            pass
        else:
            for k, v in headers.items():
                django_response[k] = v
        return django_response"
4901,"def _get_input_data(self, request):
        """""" If there is data, parse it, otherwise return None. """"""
        # only PUT and POST should provide data
        if not self._is_data_method(request):
            return None

        content = [row for row in request.read()]
        content = ''.join(content) if content else None
        return self._parse_input_data(content, request) if content else None"
4902,"def _clean_input_data(self, data, request):
        """""" Clean input data. """"""

        # sanity check
        if not self._is_data_method(request):
            # this is not PUT or POST -> return
            return data

        # do cleaning
        try:
            if self.representation:
                # representation defined -> perform validation
                self._validate_input_data(data, request)
            if self.factory:
                # factory defined -> create object
                return self._create_object(data, request)
            else:
                # no factory nor representation -> return the same data back
                return data
        except ValidationError, exc:
            return self._input_validation_failed(exc, data, request)"
4903,"def _get_input_validator(self, request):
        """""" Return appropriate input validator.

        For POST requests, ``self.post_representation`` is returned
        if it is present, ``self.representation`` otherwise.
        """"""

        method = request.method.upper()
        if method != 'POST':
            return self.representation
        elif self.post_representation:
            return self.post_representation
        else:
            return self.representation"
4904,"def _validate_input_data(self, data, request):
        """""" Validate input data.

        :param request: the HTTP request
        :param data: the parsed data
        :return: if validation is performed and succeeds the data is converted
                 into whatever format the validation uses (by default Django's
                 Forms) If not, the data is returned unchanged.
        :raises: HttpStatusCodeError if data is not valid
        """"""

        validator = self._get_input_validator(request)
        if isinstance(data, (list, tuple)):
            return map(validator.validate, data)
        else:
            return validator.validate(data)"
4905,"def _validate_output_data(
        self, original_res, serialized_res, formatted_res, request):
        """""" Validate the response data.

        :param response: ``HttpResponse``
        :param data: payload data. This implementation assumes
                     dict or list of dicts.
        :raises: `HttpStatusCodeError` if data is not valid
        """"""

        validator = self.representation

        # when not to validate...
        if not validator:
            return

        try:
            if isinstance(serialized_res, (list, tuple)):
                map(validator.validate, serialized_res)
            else:
                validator.validate(serialized_res)
        except ValidationError, exc:
            self._output_validation_failed(exc, serialized_res, request)"
4906,"def _create_object(self, data, request):
        """""" Create a python object from the given data.

        This will use ``self.factory`` object's ``create()`` function to
        create the data.

        If no factory is defined, this will simply return the same data
        that was given.
        """"""

        if request.method.upper() == 'POST' and self.post_factory:
            fac_func = self.post_factory.create
        else:
            fac_func = self.factory.create

        if isinstance(data, (list, tuple)):
            return map(fac_func, data)
        else:
            return fac_func(data)"
4907,"def _serialize_object(self, response_data, request):
        """""" Create a python datatype from the given python object.

        This will use ``self.factory`` object's ``serialize()`` function
        to convert the object into dictionary.

        If no factory is defined, this will simply return the same data
        that was given.

        :param response_data: data returned by the resource
        """"""

        if not self.factory:
            return response_data
        if isinstance(response_data, (list, tuple)):
            return map(
                lambda item: self.factory.serialize(item, request),
                response_data)
        else:
            return self.factory.serialize(response_data, request)"
4908,"def _get_unknown_error_response(self, request, exc):
        """""" Generate HttpResponse for unknown exceptions.

        todo: this should be more informative..
        """"""

        logging.getLogger('devil').error(
            'while doing %s on %s with [%s], devil caught: %s' % (
                request.method, request.path_info, str(request.GET), str(exc)), exc_info=True)

        if settings.DEBUG:
            raise
        else:
            return HttpResponse(status=codes.INTERNAL_SERVER_ERROR[1])"
4909,"def _get_error_response(self, exc):
        """""" Generate HttpResponse based on the HttpStatusCodeError. """"""
        if exc.has_code(codes.UNAUTHORIZED):
            return self._get_auth_challenge(exc)
        else:
            if exc.has_code(codes.INTERNAL_SERVER_ERROR):
                logging.getLogger('devil').error('devil caught http error: ' + str(exc), exc_info=True)
            else:
                logging.getLogger('devil').error('devil caught http error: ' + str(exc))
            content = exc.content or ''
            return HttpResponse(content=content, status=exc.get_code_num())"
4910,"def _get_auth_challenge(self, exc):
        """""" Returns HttpResponse for the client. """"""
        response = HttpResponse(content=exc.content, status=exc.get_code_num())
        response['WWW-Authenticate'] = 'Basic realm=""%s""' % REALM
        return response"
4911,"def _get_method(self, request):
        """""" Figure out the requested method and return the callable. """"""
        methodname = request.method.lower()
        method = getattr(self, methodname, None)
        if not method or not callable(method):
            raise errors.MethodNotAllowed()
        return method"
4912,"def _authenticate(self, request):
        """""" Perform authentication. """"""

        def ensure_user_obj():
            """""" Make sure that request object has user property.

            If `request.user` is not present or is `None`, it is
            created and initialized with `AnonymousUser`.
            """"""

            try:
                if request.user:
                    return
            except AttributeError:
                pass

            request.user = AnonymousUser()

        def anonymous_access(exc_obj):
            """""" Determine what to do with unauthenticated requests.

            If the request has already been authenticated, does
            nothing.

            :param exc_obj: exception object to be thrown if anonymous
            access is not permitted.
            """"""

            if request.user and request.user.is_authenticated():
                # request is already authenticated
                pass
            elif self.allow_anonymous:
                request.user = AnonymousUser()
            else:
                raise exc_obj

        # first, make sure that the request carries `user` attribute
        ensure_user_obj()
        if self.authentication:
            # authentication handler is configured
            try:
                self.authentication.authenticate(request)
            except errors.Unauthorized, exc:
                # http request doesn't carry any authentication information
                anonymous_access(exc)
        else:
            # no authentication configured
            anonymous_access(errors.Forbidden())"
4913,"def _check_permission(self, request):
        """""" Check user permissions.

        :raises: Forbidden, if user doesn't have access to the resource.
        """"""

        if self.access_controller:
            self.access_controller.check_perm(request, self)"
4914,"def print_devices_change_callback(devices, key, new):
    """"""Print the reply from &devices() and highlight errors.""""""
    dev = devices[key]
    print('- ', new, ' ', dev)
    if dev['type'] == QSType.unknown:
        print("" ERR decoding"")
    elif dev['value'] == -1:
        dev("" ERR decoding: -1?"")
    qcord = pyqwikswitch.decode_qwikcord(dev['data'][pyqwikswitch.QS_VALUE])
    if qcord is not None:
        print(' qwikcord (CTAVG, CTsum) = ' + str(qcord))"
4915,"def print_item_callback(item):
    """"""Print an item callback, used by &listen.""""""
    print('&listen [{}, {}={}]'.format(
        item.get('cmd', ''),
        item.get('id', ''),
        item.get('data', '')))"
4916,"def main():
    """"""Quick test for QSUsb class.""""""
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('--url', help='QSUSB URL [http://127.0.0.1:2020]',
                        default='http://127.0.0.1:2020')
    parser.add_argument('--file', help='a test file from /&devices')
    parser.add_argument('--test_ids', help='List of test IDs',
                        default='@0c2700,@0ac2f0')
    args = parser.parse_args()

    if args.file:
        with open(args.file) as data_file:
            data = json.load(data_file)
        qsusb = pyqwikswitch.QSDevices(
            print_devices_change_callback, print_devices_change_callback)
        print_bad_data(data)
        qsusb.set_qs_values(data)
        return

    print('Execute a basic test on server: {}\n'.format(args.url))

    def qs_to_value(key, new):
        print("" --> New value: {}={}"".format(key, new))

    qsusb = QSUsb(args.url, 1, qs_to_value)
    print('Version: ' + qsusb.version())
    qsusb.set_qs_values()

    qsusb.listen(print_item_callback, timeout=5)
    print(""Started listening"")
    try:
        # Do some test while listening
        if args.test_ids and len(args.test_ids) > 0:
            test_devices_set(qsusb.devices, args.test_ids.split(','))

        print(""\n\nListening for 60 seconds (test buttons now)\n"")
        sleep(60)
    except KeyboardInterrupt:
        pass
    finally:
        qsusb.stop()  # Close all threads
        print(""Stopped listening"")"
4917,"def get(self):
        """"""Called to get the asset values and if it is valid
        """"""
        with self._lock:
            now = datetime.now()
            active = []
            for i, vef in enumerate(self.futures):
                # has expired
                if (vef[1] or datetime.max) <= now:
                    self.futures.pop(i)
                    continue
                # in future
                elif (vef[2] or datetime.min) >= now:
                    continue
                else:
                    active.append(i)

            if active:
                # this will evict values old values
                # because new ones are ""more recent"" via future
                value, _e, _f = self.futures[active[-1]]
                for i in active[:-1]:
                    self.futures.pop(i)
                return value

            raise ValueError(""dicttime: no current value, however future has (%d) values"" % len(self.futures))"
4918,"def add_node(node, **kwds):
    """"""add_node from Sphinx
    """"""
    nodes._add_node_class_names([node.__name__])
    for key, val in kwds.iteritems():
        try:
            visit, depart = val
        except ValueError:
            raise ValueError('Value for key %r must be a '
                                 '(visit, depart) function tuple' % key)
        if key == 'html':
            from docutils.writers.html4css1 import HTMLTranslator as translator
        elif key == 'latex':
            from docutils.writers.latex2e import LaTeXTranslator as translator
        else:
            # ignore invalid keys for compatibility
            continue
        setattr(translator, 'visit_'+node.__name__, visit)
        if depart:
            setattr(translator, 'depart_'+node.__name__, depart)"
4919,"def _lookup(self, bearer, target=None, permission=None):
        """"""Lookup the proper registry for this permission.
        Returns (<registry>, <key>) where registry is the proper lookup
        and key is the generated key to use for the permission.""""""

        if target is None:
            key = (bearer, permission)
            lookup = self.bearer

        elif permission is None:
            key = (bearer, target)
            lookup = self.target

        else:
            key = (bearer, target, permission)
            lookup = self

        return lookup, key"
4920,"def retrieve(self, *args, **kwargs):
        """"""Retrieve the permsission function for the provided things.
        """"""

        lookup, key = self._lookup(*args, **kwargs)

        return lookup[key]"
4921,"def __api_proxy_call(self, engine, payload, method, analyze_json_error_param, retry_request_substr_variants,
                         stream=False):
        """"""
        :param engine: Система
        :param payload: Данные для запроса
        :param method: string Может содержать native_call | tsv | json_newline
        :param analyze_json_error_param: Нужно ли производить анализ параметра error в ответе прокси
        :param retry_request_substr_variants: Список подстрок, при наличии которых в ответе будет происходить перезапрос
        :param stream:
        :return:
        """"""
        log_ctx = {
            ""engine"": engine,
            ""method"": payload.get('method'),
            ""method_params"": payload.get('method_params')
        }
        self.__app.log.info(""Call api proxy"", log_ctx)
        body = {
            ""engine"": engine,
            ""payload"": payload
        }
        for _try_idx in range(20):
            try:
                # 1h таймаут, так как бывают большие долгие данные, а лимит хоть какой-то нужен
                body_str = json.dumps(body)
                headers = {
                    ""User-Agent"": self.__app.user_agent,
                    ""X-App"": ""META"",
                    ""X-Worker"": self.__app.service_id,
                    ""X-ObjectLocator"": LOGGER_ENTITY.get(""objectLocator"")
                }
                resp = requests.post(self.__app.api_proxy_url + ""/"" + method, body_str, timeout=3600, stream=stream,
                                     headers=headers)

                self.check_err(resp, analyze_json_error_param=analyze_json_error_param,
                               retry_request_substr_variants=retry_request_substr_variants)
                return resp
            except (RetryHttpRequestError, RateLimitError, ConnectionError) as e:
                self.__app.log.warning(""Sleep retry query: "" + str(e), log_ctx)
                sleep_time = 20

                if e.__class__.__name__ == ""RateLimitError"":
                    sleep_time = e.waiting_time

                time.sleep(sleep_time)

        raise EndOfTriesError(""Api of api proxy tries request"")"
4922,"def call_proxy_with_paging(self, engine, payload, method, analyze_json_error_param, retry_request_substr_variants,
                               max_pages=MAX_PAGES):
        """"""
        Постраничный запрос
        :param engine: Система
        :param payload: Данные для запроса
        :param method: string Может содержать native_call | tsv | json_newline
        :param analyze_json_error_param: Нужно ли производить анализ параметра error в ответе прокси
        :param retry_request_substr_variants: Список подстрок, при наличии которых в ответе будет происходить перезапрос
        :param max_pages: Максимальное количество страниц в запросе
        :return: объект генератор
        """"""
        copy_payload = copy.deepcopy(payload)

        idx = 0
        for idx in range(max_pages):
            resp = self.__api_proxy_call(engine, copy_payload, method, analyze_json_error_param,
                                         retry_request_substr_variants)
            yield resp

            paging_resp = resp.json().get(""paging"")
            if not paging_resp:
                break
            copy_payload[""paging""] = paging_resp

        if idx >= max_pages:
            self.__app.log.warning(""Достигнут максимальный предел страниц"", {""max_pages"": max_pages})"
4923,"def call_proxy(self, engine, payload, method, analyze_json_error_param, retry_request_substr_variants,
                   stream=False):
        """"""
        :param engine: Система
        :param payload: Данные для запроса
        :param method: string Может содержать native_call | tsv | json_newline
        :param analyze_json_error_param: Нужно ли производить анализ параметра error в ответе прокси
        :param retry_request_substr_variants: Список подстрок, при наличии которых в ответе будет происходить перезапрос
        :param stream:
        :return:
        """"""
        return self.__api_proxy_call(engine, payload, method, analyze_json_error_param, retry_request_substr_variants,
                                     stream)"
4924,"def check_err(resp, analyze_json_error_param=False, retry_request_substr_variants=None):
        """"""
        :type retry_request_substr_variants: list Список вхождений строк, при налиции которых в ошибке апи будет произведен повторный запрос к апи
        """"""
        if retry_request_substr_variants is None:
            retry_request_substr_variants = []

        # РКН блокировки вызывают ошибку SSL
        retry_request_substr_variants.append(""TLSV1_ALERT_ACCESS_DENIED"")

        if resp.status_code in [502, 503, 504]:
            raise RetryHttpRequestError(resp.text)

        if resp.status_code >= 400:
            rtext = resp.text
            for v_ in retry_request_substr_variants:
                if v_ in rtext:
                    raise RetryHttpRequestError(rtext)
            raise UnexpectedError(""HTTP request failed: {} {}"".format(resp.status_code, rtext))
        if analyze_json_error_param:
            data_ = resp.json()
            if 'error' in data_ and data_.get('error'):
                error = data_.get('error')
                full_err_ = json.dumps(error)

                if error.get(""type"") == ""RateLimitError"":
                    raise RateLimitError(error.get(""message""), waiting_time=error.get(""waiting_time""))

                for v_ in retry_request_substr_variants:
                    if v_ in full_err_:
                        raise RetryHttpRequestError(full_err_)
                raise ApiProxyError(full_err_)
        return resp"
4925,"def has_rabf_motif(self):
        """"""Checks if the sequence has enough RabF motifs within the G domain

        If there exists more than one G domain in the sequence enough RabF motifs is required in at least one
        of those domains to classify the sequence as a Rab.
        """"""

        if self.rabf_motifs:
            for gdomain in self.gdomain_regions:
                beg, end = map(int, gdomain.split('-'))
                motifs = [x for x in self.rabf_motifs if x[1] >= beg and x[2] <= end]
                if motifs:
                    matches = int(pairwise2.align.globalxx('12345', ''.join(str(x[0]) for x in motifs))[0][2])
                    if matches >= self.motif_number:
                        return True
        return False"
4926,"def summarize(self):
        """""" G protein annotation summary in a text format

        :return: A string summary of the annotation
        :rtype: str
        """"""
        data = [
            ['Sequence ID', self.seqrecord.id],
            ['G domain', ' '.join(self.gdomain_regions) if self.gdomain_regions else None],
            ['E-value vs rab db', self.evalue_bh_rabs],
            ['E-value vs non-rab db', self.evalue_bh_non_rabs],
            ['RabF motifs', ' '.join(map(str, self.rabf_motifs)) if self.rabf_motifs else None],
            ['Is Rab?', self.is_rab()]
        ]
        summary = ''
        for name, value in data:
            summary += '{:25s}{}\n'.format(name, value)
        if self.is_rab():
            summary += '{:25s}{}\n'.format('Top 5 subfamilies',
                                           ', '.join('{:s} ({:.2g})'.format(name, score) for name, score
                                                     in self.rab_subfamily_top5))
        return summary"
4927,"def write(self):
        """"""Write sequences predicted to be Rabs as a fasta file.

        :return: Number of written sequences
        :rtype: int
        """"""

        rabs = [x.seqrecord for x in self.gproteins.values() if x.is_rab()]
        return SeqIO.write(rabs, self.tmpfname + '.phase2', 'fasta')"
4928,"def check(self):
        """""" Check if data and third party tools, necessary to run the classification, are available

        :raises: RuntimeError
        """"""

        pathfinder = Pathfinder(True)
        if pathfinder.add_path(pathfinder['superfamily']) is None:
            raise RuntimeError(""'superfamily' data directory is missing"")

        for tool in ('hmmscan', 'phmmer', 'mast', 'blastp', 'ass3.pl', 'hmmscan.pl'):
            if not pathfinder.exists(tool):
                raise RuntimeError('Dependency {} is missing'.format(tool))"
4929,"def create_brand(cls, brand, **kwargs):
        """"""Create Brand

        Create a new Brand
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_brand(brand, async=True)
        >>> result = thread.get()

        :param async bool
        :param Brand brand: Attributes of brand to create (required)
        :return: Brand
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_brand_with_http_info(brand, **kwargs)
        else:
            (data) = cls._create_brand_with_http_info(brand, **kwargs)
            return data"
4930,"def delete_brand_by_id(cls, brand_id, **kwargs):
        """"""Delete Brand

        Delete an instance of Brand by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_brand_by_id(brand_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str brand_id: ID of brand to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_brand_by_id_with_http_info(brand_id, **kwargs)
        else:
            (data) = cls._delete_brand_by_id_with_http_info(brand_id, **kwargs)
            return data"
4931,"def get_brand_by_id(cls, brand_id, **kwargs):
        """"""Find Brand

        Return single instance of Brand by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_brand_by_id(brand_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str brand_id: ID of brand to return (required)
        :return: Brand
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_brand_by_id_with_http_info(brand_id, **kwargs)
        else:
            (data) = cls._get_brand_by_id_with_http_info(brand_id, **kwargs)
            return data"
4932,"def list_all_brands(cls, **kwargs):
        """"""List Brands

        Return a list of Brands
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_brands(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[Brand]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_brands_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_brands_with_http_info(**kwargs)
            return data"
4933,"def replace_brand_by_id(cls, brand_id, brand, **kwargs):
        """"""Replace Brand

        Replace all attributes of Brand
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_brand_by_id(brand_id, brand, async=True)
        >>> result = thread.get()

        :param async bool
        :param str brand_id: ID of brand to replace (required)
        :param Brand brand: Attributes of brand to replace (required)
        :return: Brand
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_brand_by_id_with_http_info(brand_id, brand, **kwargs)
        else:
            (data) = cls._replace_brand_by_id_with_http_info(brand_id, brand, **kwargs)
            return data"
4934,"def update_brand_by_id(cls, brand_id, brand, **kwargs):
        """"""Update Brand

        Update attributes of Brand
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_brand_by_id(brand_id, brand, async=True)
        >>> result = thread.get()

        :param async bool
        :param str brand_id: ID of brand to update. (required)
        :param Brand brand: Attributes of brand to update. (required)
        :return: Brand
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_brand_by_id_with_http_info(brand_id, brand, **kwargs)
        else:
            (data) = cls._update_brand_by_id_with_http_info(brand_id, brand, **kwargs)
            return data"
4935,"def filter_(*permissions, **kwargs):
    """"""
    Constructs a clause to filter all bearers or targets for a given
    berarer or target.
    """"""
    bearer = kwargs['bearer']
    target = kwargs.get('target')
    bearer_cls = type_for(bearer)

    # We need a query object.  There are many ways to get one,  Either we can
    # be passed one, or we can make one from the session.  We can either be
    # passed the session, or we can grab the session from the bearer passed.

    if 'query' in kwargs:
        query = kwargs['query']
    elif 'session' in kwargs:
        query = kwargs['session'].query(target)
    else:
        query = object_session(bearer).query(target)

    getter = functools.partial(
        registry.retrieve,
        bearer=bearer_cls,
        target=target)

    try:
        # Generate a hash of {rulefn: permission} that we can use later
        # to collect all of the rules.
        if len(permissions):
            rules = {getter(permission=x): x for x in permissions}
        else:
            rules = {getter(): None}
    except KeyError:
        # No rules defined.  Default to no permission.
        return query.filter(sql.false())

    # Invoke all the rules and collect the results

    # Abusing reduce here to invoke each rule and send the return value (query)
    # from one rule to the next one.  In this way the query becomes
    # increasingly decorated as it marches through the system.

    # q == query
    # r = (rulefn, permission)
    reducer = lambda q, r: r[0](permission=r[1], query=q, bearer=bearer)

    return reduce(reducer, six.iteritems(rules), query)"
4936,"def has(*permissions, **kwargs):
    """"""
    Checks if the passed bearer has the passed permissions (optionally on
    the passed target).
    """"""

    target = kwargs['target']

    kwargs['target'] = type_for(target)

    # TODO: Predicate evaluation?
    return target in filter_(*permissions, **kwargs)"
4937,"def get_now_datetime_filestamp(longTime=False):
    """"""
    *A datetime stamp to be appended to the end of filenames: ``YYYYMMDDtHHMMSS``*

    **Key Arguments:**
        - ``longTime`` -- make time string longer (more change of filenames being unique)

    **Return:**
        - ``now`` -- current time and date in filename format

    **Usage:**
        .. code-block:: python 

            from fundamentals.download import get_now_datetime_filestamp
            get_now_datetime_filestamp(longTime=False)
            #Out: '20160316t154635'

            get_now_datetime_filestamp(longTime=True)
            #Out: '20160316t154644133638' 
    """"""
    ## > IMPORTS ##
    from datetime import datetime, date, time
    now = datetime.now()
    if longTime:
        now = now.strftime(""%Y%m%dt%H%M%S%f"")
    else:
        now = now.strftime(""%Y%m%dt%H%M%S"")

    return now"
4938,"def create_app(application, request_class=Request):
    """"""
    Create a WSGI application out of the given Minion app.

    Arguments:

        application (Application):

            a minion app

        request_class (callable):

            a class to use for constructing incoming requests out of the WSGI
            environment. It will be passed a single arg, the environ.

            By default, this is :class:`minion.request.WSGIRequest` if
            unprovided.
    """"""

    def wsgi(environ, start_response):
        response = application.serve(
            request=request_class(environ),
            path=environ.get(""PATH_INFO"", """"),
        )
        start_response(
            response.status, [
                (name, b"","".join(values))
                for name, values in response.headers.canonicalized()
            ],
        )
        return [response.content]
    return wsgi"
4939,"def get_store_profile_by_id(cls, store_profile_id, **kwargs):
        """"""Find StoreProfile

        Return single instance of StoreProfile by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_store_profile_by_id(store_profile_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str store_profile_id: ID of storeProfile to return (required)
        :return: StoreProfile
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_store_profile_by_id_with_http_info(store_profile_id, **kwargs)
        else:
            (data) = cls._get_store_profile_by_id_with_http_info(store_profile_id, **kwargs)
            return data"
4940,"def replace_store_profile_by_id(cls, store_profile_id, store_profile, **kwargs):
        """"""Replace StoreProfile

        Replace all attributes of StoreProfile
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_store_profile_by_id(store_profile_id, store_profile, async=True)
        >>> result = thread.get()

        :param async bool
        :param str store_profile_id: ID of storeProfile to replace (required)
        :param StoreProfile store_profile: Attributes of storeProfile to replace (required)
        :return: StoreProfile
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_store_profile_by_id_with_http_info(store_profile_id, store_profile, **kwargs)
        else:
            (data) = cls._replace_store_profile_by_id_with_http_info(store_profile_id, store_profile, **kwargs)
            return data"
4941,"def update_store_profile_by_id(cls, store_profile_id, store_profile, **kwargs):
        """"""Update StoreProfile

        Update attributes of StoreProfile
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_store_profile_by_id(store_profile_id, store_profile, async=True)
        >>> result = thread.get()

        :param async bool
        :param str store_profile_id: ID of storeProfile to update. (required)
        :param StoreProfile store_profile: Attributes of storeProfile to update. (required)
        :return: StoreProfile
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_store_profile_by_id_with_http_info(store_profile_id, store_profile, **kwargs)
        else:
            (data) = cls._update_store_profile_by_id_with_http_info(store_profile_id, store_profile, **kwargs)
            return data"
4942,"def get_documentation(self, request, *args, **kw):
        """""" Generate the documentation. """"""
        ret = dict()
        ret['resource'] = self.name()
        ret['urls'] = self._get_url_doc()
        ret['description'] = self.__doc__
        ret['representation'] = self._get_representation_doc()
        ret['methods'] = self._get_method_doc()
        return ret"
4943,"def _serialize_object(self, response_data, request):
        """""" Override to not serialize doc responses. """"""
        if self._is_doc_request(request):
            return response_data
        else:
            return super(DocumentedResource, self)._serialize_object(
                response_data, request)"
4944,"def _validate_output_data(
        self, original_res, serialized_res, formatted_res, request):
        """""" Override to not validate doc output. """"""
        if self._is_doc_request(request):
            return
        else:
            return super(DocumentedResource, self)._validate_output_data(
                original_res, serialized_res, formatted_res, request)"
4945,"def _get_method(self, request):
        """""" Override to check if this is a documentation request. """"""
        if self._is_doc_request(request):
            return self.get_documentation
        else:
            return super(DocumentedResource, self)._get_method(request)"
4946,"def _get_representation_doc(self):
        """""" Return documentation for the representation of the resource. """"""
        if not self.representation:
            return 'N/A'
        fields = {}
        for name, field in self.representation.fields.items():
            fields[name] = self._get_field_doc(field)
        return fields"
4947,"def _get_field_doc(self, field):
        """""" Return documentation for a field in the representation. """"""
        fieldspec = dict()
        fieldspec['type'] = field.__class__.__name__
        fieldspec['required'] = field.required
        fieldspec['validators'] = [{validator.__class__.__name__: validator.__dict__} for validator in field.validators]
        return fieldspec"
4948,"def _get_url_doc(self):
        """""" Return a list of URLs that map to this resource. """"""
        resolver = get_resolver(None)
        possibilities = resolver.reverse_dict.getlist(self)
        urls = [possibility[0] for possibility in possibilities]
        return urls"
4949,"def _get_method_doc(self):
        """""" Return method documentations. """"""
        ret = {}
        for method_name in self.methods:
            method = getattr(self, method_name, None)
            if method:
                ret[method_name] = method.__doc__
        return ret"
4950,"def clean(df,error_rate = 0):
    """""" Superficially cleans data, i.e. changing simple things about formatting.
    Parameters:
    df - DataFrame
        DataFrame to clean
    error_rate - float {0 <= error_rate <= 1}, default 0
        Maximum amount of errors/inconsistencies caused explicitly by cleaning, expressed
        as a percentage of total dataframe rows (0 = 0%, .5 = 50%, etc.)
        Ex: na values from coercing a column of data to numeric
    """"""
    df = df.copy()
    
    # Change colnames
    basics.clean_colnames(df)
    # Eventually use a more advanced function to clean colnames
    print('Changed colnames to {}'.format(df.columns))
    
    # Remove extra whitespace
    obj_col_list = df.select_dtypes(include = 'object').columns
    for col_name in obj_col_list:
        df[col_name] = basics.col_strip(df,col_name)
        print(""Stripped extra whitespace from '{}'"".format(col_name))
    
    # Coerce columns if possible
    for col_name in obj_col_list:
        new_dtype = coerce_col(df,col_name,error_rate)
        if new_dtype is not None:
            print(""Coerced '{}' to datatype '{}'"".format(col_name, new_dtype))

    # Scrub columns
    obj_col_list = df.select_dtypes(include = 'object').columns
    for col_name in obj_col_list:
        scrubf, scrubb = smart_scrub(df,col_name,1-error_rate)
        if scrubf is not None or scrubb is not None:
            print(""Scrubbed '{}' from the front and '{}' from the back of column '{}'"" \
                  .format(scrubf,scrubb,col_name))
    
    # Coerice columns if possible
    for col_name in obj_col_list:
        new_dtype = coerce_col(df,col_name,error_rate)
        if new_dtype is not None:
            print(""Coerced '{}' to datatype '{}'"".format(col_name, new_dtype))  
    return df"
4951,"def create_process(self, command, shell=True, stdout=None, stderr=None,
                       env=None):
        """"""
        Execute a process using subprocess.Popen, setting the backend's DISPLAY
        """"""
        env = env if env is not None else dict(os.environ)
        env['DISPLAY'] = self.display
        return subprocess.Popen(command, shell=shell,
                                stdout=stdout, stderr=stderr,
                                env=env)"
4952,"def pause(self, instance_id, keep_provisioned=True):
        """"""shuts down the instance without destroying it.

        The AbstractCloudProvider class uses 'stop' to refer to destroying
        a VM, so use 'pause' to mean powering it down while leaving it
        allocated.

        :param str instance_id: instance identifier

        :return: None
        """"""
        try:
            if self._paused:
                log.debug(""node %s is already paused"", instance_id)
                return
            self._paused = True
            post_shutdown_action = 'Stopped' if keep_provisioned else \
                'StoppedDeallocated'
            result = self._subscription._sms.shutdown_role(
                service_name=self._cloud_service._name,
                deployment_name=self._cloud_service._name,
                role_name=self._qualified_name,
                post_shutdown_action=post_shutdown_action)
            self._subscription._wait_result(result)
        except Exception as exc:
            log.error(""error pausing instance %s: %s"", instance_id, exc)
            raise
        log.debug('paused instance(instance_id=%s)', instance_id)"
4953,"def restart(self, instance_id):
        """"""restarts a paused instance.

        :param str instance_id: instance identifier

        :return: None
        """"""
        try:
            if not self._paused:
                log.debug(""node %s is not paused, can't restart"", instance_id)
                return
            self._paused = False
            result = self._subscription._sms.start_role(
                service_name=self._cloud_service._name,
                deployment_name=self._cloud_service._name,
                role_name=instance_id)
            self._subscription._wait_result(result)
        except Exception as exc:
            log.error('error restarting instance %s: %s', instance_id, exc)
            raise
        log.debug('restarted instance(instance_id=%s)', instance_id)"
4954,"def start_instance(
            self,
            key_name,
            public_key_path,
            private_key_path,
            security_group,
            flavor,
            image,
            image_userdata,
            location=None,
            base_name=None,
            username=None,
            node_name=None,
            host_name=None,
            use_public_ips=None,
            wait_timeout=None,
            use_short_vm_names=None,
            n_cloud_services=None,
            n_storage_accounts=None,
            **kwargs):
        """"""Starts a new instance on the cloud using the given properties.
        Multiple instances might be started in different threads at the same
        time. The implementation should handle any problems regarding this
        itself.
        :return: str - instance id of the started instance
        """"""

        if self._start_failed:
            raise Exception('start_instance for node %s: failing due to'
                            ' previous errors.' % node_name)

        index = None
        with self._resource_lock:
            # it'd be nice if elasticluster called something like
            # init_cluster() with all the args that will be the
            # same for every node created. But since it doesn't, handle that on
            # first start_instance call.
            if not self._cluster_prep_done:
                self._times['CLUSTER_START'] = time.time()
                self._config.setup(
                    key_name,
                    public_key_path,
                    private_key_path,
                    security_group,
                    location,
                    base_name=base_name,
                    username=username,
                    use_public_ips=use_public_ips,
                    wait_timeout=wait_timeout,
                    use_short_vm_names=use_short_vm_names,
                    n_cloud_services=n_cloud_services,
                    n_storage_accounts=n_storage_accounts,
                    **kwargs)
                # we know we're starting the first node, so create global
                # requirements now
                self._create_global_reqs()
                if self._start_failed:
                    return None
                # this will allow vms to be created
                self._times['SETUP_DONE'] = time.time()
                self._cluster_prep_done = True

            # absolute node index in cluster (0..n-1) determines what
            # subscription, cloud service, storage
            # account, etc. this VM will use. Create the vm and add it to
            # its cloud service, then try to start it.
            index = self._n_instances

            v_m = AzureVM(
                self._config,
                index,
                flavor=flavor,
                image=image,
                node_name=node_name,
                host_name=host_name,
                image_userdata=image_userdata)
            v_m._cloud_service._instances[v_m._qualified_name] = v_m

        try:
            v_m._cloud_service._start_vm(v_m)
        except Exception:
            log.error(traceback.format_exc())
            log.error(""setting start_failed flag. Will not ""
                      ""try to start further nodes."")
            self._start_failed = True
            return None
        log.debug('started instance %s', v_m._qualified_name)
        if index == self._config._n_vms_requested - 1:
            # all nodes started
            self._times['NODES_STARTED'] = time.time()
            self._times['SETUP_ELAPSED'] = self._times['SETUP_DONE'] - \
                self._times['CLUSTER_START']
            self._times['NODE_START_ELAPSED'] = self._times['NODES_STARTED']\
                - self._times['SETUP_DONE']
            self._times['CLUSTER_START_ELAPSED'] = \
                self._times['SETUP_ELAPSED'] + \
                self._times['NODE_START_ELAPSED']

            log.debug(""setup time: %.1f sec"", self._times['SETUP_ELAPSED'])
            log.debug(""node start time: %.1f sec (%.1f sec per vm)"",
                      self._times['NODE_START_ELAPSED'],
                      self._times['NODE_START_ELAPSED'] /
                      self._config._n_vms_requested)
            log.debug(""total cluster start time: %.1f sec (%.1f sec per vm)"",
                      self._times['CLUSTER_START_ELAPSED'],
                      self._times['CLUSTER_START_ELAPSED'] /
                      self._config._n_vms_requested)
            # pause here to try to address the fact that Ansible setup fails
            # more often on the first try than subsequent tries
            time.sleep(_retry_sleep())
        self._save_or_update()  # store our state
        return v_m._qualified_name"
4955,"def stop_instance(self, instance_id):
        """"""Stops the instance gracefully.

        :param str instance_id: instance identifier

        :return: None
        """"""
        self._restore_from_storage(instance_id)
        if self._start_failed:
            raise Exception('stop_instance for node %s: failing due to'
                            ' previous errors.' % instance_id)

        with self._resource_lock:
            try:
                v_m = self._qualified_name_to_vm(instance_id)
                if not v_m:
                    err = ""stop_instance: can't find instance %s"" % instance_id
                    log.error(err)
                    raise Exception(err)
                v_m._cloud_service._stop_vm(v_m)
                # note: self._n_instances is a derived property, doesn't need
                # to be updated
                if self._n_instances == 0:
                    log.debug('last instance deleted, destroying '
                              'global resources')
                    self._delete_global_reqs()
                    self._delete_cloud_provider_storage()
            except Exception as exc:
                log.error(traceback.format_exc())
                log.error(""error stopping instance %s: %s"", instance_id, exc)
                raise
        log.debug('stopped instance %s', instance_id)"
4956,"def get_ips(self, instance_id):
        """"""Retrieves the private and public ip addresses for a given instance.
        Note: Azure normally provides access to vms from a shared load
        balancer IP and
        mapping of ssh ports on the vms. So by default, the Azure provider
        returns strings
        of the form 'ip:port'. However, 'stock' elasticluster and ansible
        don't support this,
        so _use_public_ips uses Azure PublicIPs to expose each vm on the
        internet with its own IP
        and using the standard SSH port.

        :return: list (IPs)
        """"""
        self._restore_from_storage(instance_id)
        if self._start_failed:
            raise Exception('get_ips for node %s: failing due to'
                            ' previous errors.' % instance_id)

        ret = list()
        v_m = self._qualified_name_to_vm(instance_id)
        if not v_m:
            raise Exception(""Can't find instance_id %s"" % instance_id)
        if self._config._use_public_ips:
            ret.append(v_m._public_ip)
        else:
            ret.append(""%s:%s"" % (v_m._public_ip, v_m._ssh_port))

        log.debug('get_ips (instance %s) returning %s',
                  instance_id, ', '.join(ret))
        return ret"
4957,"def is_instance_running(self, instance_id):
        """"""Checks if the instance is up and running.

        :param str instance_id: instance identifier

        :return: bool - True if running, False otherwise
        """"""
        self._restore_from_storage(instance_id)
        if self._start_failed:
            raise Exception('is_instance_running for node %s: failing due to'
                            ' previous errors.' % instance_id)
        try:
            v_m = self._qualified_name_to_vm(instance_id)
            if not v_m:
                raise Exception(""Can't find instance_id %s"" % instance_id)
        except Exception:
            log.error(traceback.format_exc())
            raise
        return v_m._power_state == 'Started'"
4958,"def _save_or_update(self):
        """"""Save or update the private state needed by the cloud provider.
        """"""
        with self._resource_lock:
            if not self._config or not self._config._storage_path:
                raise Exception(""self._config._storage path is undefined"")
            if not self._config._base_name:
                raise Exception(""self._config._base_name is undefined"")
            if not os.path.exists(self._config._storage_path):
                os.makedirs(self._config._storage_path)
            path = self._get_cloud_provider_storage_path()
            with open(path, 'wb') as storage:
                pickle.dump(self._config, storage, pickle.HIGHEST_PROTOCOL)
                pickle.dump(self._subscriptions, storage,
                            pickle.HIGHEST_PROTOCOL)"
4959,"def split_iter(src, sep=None, maxsplit=None):
    """"""Splits an iterable based on a separator, *sep*, a max of
    *maxsplit* times (no max by default). *sep* can be:

      * a single value
      * an iterable of separators
      * a single-argument callable that returns True when a separator is
        encountered

    ``split_iter()`` yields lists of non-separator values. A separator will
    never appear in the output.

    >>> list(split_iter(['hi', 'hello', None, None, 'sup', None, 'soap', None]))
    [['hi', 'hello'], ['sup'], ['soap']]

    Note that ``split_iter`` is based on :func:`str.split`, so if
    *sep* is ``None``, ``split()`` **groups** separators. If empty lists
    are desired between two contiguous ``None`` values, simply use
    ``sep=[None]``:

    >>> list(split_iter(['hi', 'hello', None, None, 'sup', None]))
    [['hi', 'hello'], ['sup']]
    >>> list(split_iter(['hi', 'hello', None, None, 'sup', None], sep=[None]))
    [['hi', 'hello'], [], ['sup'], []]

    Using a callable separator:

    >>> falsy_sep = lambda x: not x
    >>> list(split_iter(['hi', 'hello', None, '', 'sup', False], falsy_sep))
    [['hi', 'hello'], [], ['sup'], []]

    See :func:`split` for a list-returning version.

    """"""
    if not is_iterable(src):
        raise TypeError('expected an iterable')

    if maxsplit is not None:
        maxsplit = int(maxsplit)
        if maxsplit == 0:
            yield [src]
            return

    if callable(sep):
        sep_func = sep
    elif not is_scalar(sep):
        sep = frozenset(sep)
        sep_func = lambda x: x in sep
    else:
        sep_func = lambda x: x == sep

    cur_group = []
    split_count = 0
    for s in src:
        if maxsplit is not None and split_count >= maxsplit:
            sep_func = lambda x: False
        if sep_func(s):
            if sep is None and not cur_group:
                # If sep is none, str.split() ""groups"" separators
                # check the str.split() docs for more info
                continue
            split_count += 1
            yield cur_group
            cur_group = []
        else:
            cur_group.append(s)

    if cur_group or sep is not None:
        yield cur_group
    return"
4960,"def chunked(src, size, count=None, **kw):
    """"""Returns a list of *count* chunks, each with *size* elements,
    generated from iterable *src*. If *src* is not evenly divisible by
    *size*, the final chunk will have fewer than *size* elements.
    Provide the *fill* keyword argument to provide a pad value and
    enable padding, otherwise no padding will take place.

    >>> chunked(range(10), 3)
    [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]
    >>> chunked(range(10), 3, fill=None)
    [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, None, None]]
    >>> chunked(range(10), 3, count=2)
    [[0, 1, 2], [3, 4, 5]]

    See :func:`chunked_iter` for more info.
    """"""
    chunk_iter = chunked_iter(src, size, **kw)
    if count is None:
        return list(chunk_iter)
    else:
        return list(itertools.islice(chunk_iter, count))"
4961,"def chunked_iter(src, size, **kw):
    """"""Generates *size*-sized chunks from *src* iterable. Unless the
    optional *fill* keyword argument is provided, iterables not even
    divisible by *size* will have a final chunk that is smaller than
    *size*.

    >>> list(chunked_iter(range(10), 3))
    [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]
    >>> list(chunked_iter(range(10), 3, fill=None))
    [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, None, None]]

    Note that ``fill=None`` in fact uses ``None`` as the fill value.
    """"""
    # TODO: add count kwarg?
    if not is_iterable(src):
        raise TypeError('expected an iterable')
    size = int(size)
    if size <= 0:
        raise ValueError('expected a positive integer chunk size')
    do_fill = True
    try:
        fill_val = kw.pop('fill')
    except KeyError:
        do_fill = False
        fill_val = None
    if kw:
        raise ValueError('got unexpected keyword arguments: %r' % kw.keys())
    if not src:
        return
    postprocess = lambda chk: chk
    if isinstance(src, basestring):
        postprocess = lambda chk, _sep=type(src)(): _sep.join(chk)
    src_iter = iter(src)
    while True:
        cur_chunk = list(itertools.islice(src_iter, size))
        if not cur_chunk:
            break
        lc = len(cur_chunk)
        if lc < size and do_fill:
            cur_chunk[lc:] = [fill_val] * (size - lc)
        yield postprocess(cur_chunk)
    return"
4962,"def windowed_iter(src, size):
    """"""Returns tuples with length *size* which represent a sliding
    window over iterable *src*.

    >>> list(windowed_iter(range(7), 3))
    [(0, 1, 2), (1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6)]

    If the iterable is too short to make a window of length *size*,
    then no window tuples are returned.

    >>> list(windowed_iter(range(3), 5))
    []
    """"""
    # TODO: lists? (for consistency)
    tees = itertools.tee(src, size)
    try:
        for i, t in enumerate(tees):
            for _ in xrange(i):
                next(t)
    except StopIteration:
        return izip([])
    return izip(*tees)"
4963,"def xfrange(stop, start=None, step=1.0):
    """"""Same as :func:`frange`, but generator-based instead of returning a
    list.

    >>> tuple(xfrange(1, 3, step=0.75))
    (1.0, 1.75, 2.5)

    See :func:`frange` for more details.
    """"""
    if not step:
        raise ValueError('step must be non-zero')
    if start is None:
        start, stop = 0.0, stop * 1.0
    else:
        # swap when all args are used
        stop, start = start * 1.0, stop * 1.0
    cur = start
    while cur < stop:
        yield cur
        cur += step"
4964,"def frange(stop, start=None, step=1.0):
    """"""A :func:`range` clone for float-based ranges.

    >>> frange(5)
    [0.0, 1.0, 2.0, 3.0, 4.0]
    >>> frange(6, step=1.25)
    [0.0, 1.25, 2.5, 3.75, 5.0]
    >>> frange(100.5, 101.5, 0.25)
    [100.5, 100.75, 101.0, 101.25]
    >>> frange(5, 0)
    []
    >>> frange(5, 0, step=-1.25)
    [5.0, 3.75, 2.5, 1.25]
    """"""
    if not step:
        raise ValueError('step must be non-zero')
    if start is None:
        start, stop = 0.0, stop * 1.0
    else:
        # swap when all args are used
        stop, start = start * 1.0, stop * 1.0
    count = int(math.ceil((stop - start) / step))
    ret = [None] * count
    if not ret:
        return ret
    ret[0] = start
    for i in xrange(1, count):
        ret[i] = ret[i - 1] + step
    return ret"
4965,"def backoff(start, stop, count=None, factor=2.0, jitter=False):
    """"""Returns a list of geometrically-increasing floating-point numbers,
    suitable for usage with `exponential backoff`_. Exactly like
    :func:`backoff_iter`, but without the ``'repeat'`` option for
    *count*. See :func:`backoff_iter` for more details.

    .. _exponential backoff: https://en.wikipedia.org/wiki/Exponential_backoff

    >>> backoff(1, 10)
    [1.0, 2.0, 4.0, 8.0, 10.0]
    """"""
    if count == 'repeat':
        raise ValueError(""'repeat' supported in backoff_iter, not backoff"")
    return list(backoff_iter(start, stop, count=count,
                             factor=factor, jitter=jitter))"
4966,"def backoff_iter(start, stop, count=None, factor=2.0, jitter=False):
    """"""Generates a sequence of geometrically-increasing floats, suitable
    for usage with `exponential backoff`_. Starts with *start*,
    increasing by *factor* until *stop* is reached, optionally
    stopping iteration once *count* numbers are yielded. *factor*
    defaults to 2. In general retrying with properly-configured
    backoff creates a better-behaved component for a larger service
    ecosystem.

    .. _exponential backoff: https://en.wikipedia.org/wiki/Exponential_backoff

    >>> list(backoff_iter(1.0, 10.0, count=5))
    [1.0, 2.0, 4.0, 8.0, 10.0]
    >>> list(backoff_iter(1.0, 10.0, count=8))
    [1.0, 2.0, 4.0, 8.0, 10.0, 10.0, 10.0, 10.0]
    >>> list(backoff_iter(0.25, 100.0, factor=10))
    [0.25, 2.5, 25.0, 100.0]

    A simplified usage example:

    .. code-block:: python

      for timeout in backoff_iter(0.25, 5.0):
          try:
              res = network_call()
              break
          except Exception as e:
              log(e)
              time.sleep(timeout)

    An enhancement for large-scale systems would be to add variation,
    or *jitter*, to timeout values. This is done to avoid a thundering
    herd on the receiving end of the network call.

    Finally, for *count*, the special value ``'repeat'`` can be passed to
    continue yielding indefinitely.

    Args:

        start (float): Positive number for baseline.
        stop (float): Positive number for maximum.
        count (int): Number of steps before stopping
            iteration. Defaults to the number of steps between *start* and
            *stop*. Pass the string, `'repeat'`, to continue iteration
            indefinitely.
        factor (float): Rate of exponential increase. Defaults to `2.0`,
            e.g., `[1, 2, 4, 8, 16]`.
        jitter (float): A factor between `-1.0` and `1.0`, used to
            uniformly randomize and thus spread out timeouts in a distributed
            system, avoiding rhythm effects. Positive values use the base
            backoff curve as a maximum, negative values use the curve as a
            minimum. Set to 1.0 or `True` for a jitter approximating
            Ethernet's time-tested backoff solution. Defaults to `False`.

    """"""
    start = float(start)
    stop = float(stop)
    factor = float(factor)
    if start < 0.0:
        raise ValueError('expected start >= 0, not %r' % start)
    if factor < 1.0:
        raise ValueError('expected factor >= 1.0, not %r' % factor)
    if stop == 0.0:
        raise ValueError('expected stop >= 0')
    if stop < start:
        raise ValueError('expected stop >= start, not %r' % stop)
    if count is None:
        denom = start if start else 1
        count = 1 + math.ceil(math.log(stop/denom, factor))
        count = count if start else count + 1
    if count != 'repeat' and count < 0:
        raise ValueError('count must be positive or ""repeat"", not %r' % count)
    if jitter:
        jitter = float(jitter)
        if not (-1.0 <= jitter <= 1.0):
            raise ValueError('expected jitter -1 <= j <= 1, not: %r' % jitter)

    cur, i = start, 0
    while count == 'repeat' or i < count:
        if not jitter:
            cur_ret = cur
        elif jitter:
            cur_ret = cur - (cur * jitter * random.random())
        yield cur_ret
        i += 1
        if cur == 0:
            cur = 1
        elif cur < stop:
            cur *= factor
        if cur > stop:
            cur = stop
    return"
4967,"def bucketize(src, key=None, value_transform=None, key_filter=None):
    """"""Group values in the *src* iterable by the value returned by *key*,
    which defaults to :class:`bool`, grouping values by truthiness.

    >>> bucketize(range(5))
    {False: [0], True: [1, 2, 3, 4]}
    >>> is_odd = lambda x: x % 2 == 1
    >>> bucketize(range(5), is_odd)
    {False: [0, 2, 4], True: [1, 3]}

    Value lists are not deduplicated:

    >>> bucketize([None, None, None, 'hello'])
    {False: [None, None, None], True: ['hello']}

    Bucketize into more than 3 groups

    >>> bucketize(range(10), lambda x: x % 3)
    {0: [0, 3, 6, 9], 1: [1, 4, 7], 2: [2, 5, 8]}

    ``bucketize`` has a couple of advanced options useful in certain
    cases.  *value_transform* can be used to modify values as they are
    added to buckets, and *key_filter* will allow excluding certain
    buckets from being collected.

    >>> bucketize(range(5), value_transform=lambda x: x*x)
    {False: [0], True: [1, 4, 9, 16]}

    >>> bucketize(range(10), key=lambda x: x % 3, key_filter=lambda k: k % 3 != 1)
    {0: [0, 3, 6, 9], 2: [2, 5, 8]}

    Note in some of these examples there were at most two keys, ``True`` and
    ``False``, and each key present has a list with at least one
    item. See :func:`partition` for a version specialized for binary
    use cases.

    """"""
    if not is_iterable(src):
        raise TypeError('expected an iterable')
    if key is None:
        key = bool
    if not callable(key):
        raise TypeError('expected callable key function')
    if value_transform is None:
        value_transform = lambda x: x
    if not callable(value_transform):
        raise TypeError('expected callable value transform function')

    ret = {}
    for val in src:
        key_of_val = key(val)
        if key_filter is None or key_filter(key_of_val):
            ret.setdefault(key_of_val, []).append(value_transform(val))
    return ret"
4968,"def partition(src, key=None):
    """"""No relation to :meth:`str.partition`, ``partition`` is like
    :func:`bucketize`, but for added convenience returns a tuple of
    ``(truthy_values, falsy_values)``.

    >>> nonempty, empty = partition(['', '', 'hi', '', 'bye'])
    >>> nonempty
    ['hi', 'bye']

    *key* defaults to :class:`bool`, but can be carefully overridden to
    use any function that returns either ``True`` or ``False``.

    >>> import string
    >>> is_digit = lambda x: x in string.digits
    >>> decimal_digits, hexletters = partition(string.hexdigits, is_digit)
    >>> ''.join(decimal_digits), ''.join(hexletters)
    ('0123456789', 'abcdefABCDEF')
    """"""
    bucketized = bucketize(src, key)
    return bucketized.get(True, []), bucketized.get(False, [])"
4969,"def unique_iter(src, key=None):
    """"""Yield unique elements from the iterable, *src*, based on *key*,
    in the order in which they first appeared in *src*.

    >>> repetitious = [1, 2, 3] * 10
    >>> list(unique_iter(repetitious))
    [1, 2, 3]

    By default, *key* is the object itself, but *key* can either be a
    callable or, for convenience, a string name of the attribute on
    which to uniqueify objects, falling back on identity when the
    attribute is not present.

    >>> pleasantries = ['hi', 'hello', 'ok', 'bye', 'yes']
    >>> list(unique_iter(pleasantries, key=lambda x: len(x)))
    ['hi', 'hello', 'bye']
    """"""
    if not is_iterable(src):
        raise TypeError('expected an iterable, not %r' % type(src))
    if key is None:
        key_func = lambda x: x
    elif callable(key):
        key_func = key
    elif isinstance(key, basestring):
        key_func = lambda x: getattr(x, key, x)
    else:
        raise TypeError('""key"" expected a string or callable, not %r' % key)
    seen = set()
    for i in src:
        k = key_func(i)
        if k not in seen:
            seen.add(k)
            yield i
    return"
4970,"def one(src, default=None, key=None):
    """"""Along the same lines as builtins, :func:`all` and :func:`any`, and
    similar to :func:`first`, ``one()`` returns the single object in
    the given iterable *src* that evaluates to ``True``, as determined
    by callable *key*. If unset, *key* defaults to :class:`bool`. If
    no such objects are found, *default* is returned. If *default* is
    not passed, ``None`` is returned.

    If *src* has more than one object that evaluates to ``True``, or
    if there is no object that fulfills such condition, return
    *default*. It's like an `XOR`_ over an iterable.

    >>> one((True, False, False))
    True
    >>> one((True, False, True))
    >>> one((0, 0, 'a'))
    'a'
    >>> one((0, False, None))
    >>> one((True, True), default=False)
    False
    >>> bool(one(('', 1)))
    True
    >>> one((10, 20, 30, 42), key=lambda i: i > 40)
    42

    See `Martín Gaitán's original repo`_ for further use cases.

    .. _Martín Gaitán's original repo: https://github.com/mgaitan/one
    .. _XOR: https://en.wikipedia.org/wiki/Exclusive_or

    """"""
    ones = list(itertools.islice(filter(key, src), 2))
    return ones[0] if len(ones) == 1 else default"
4971,"def same(iterable, ref=_UNSET):
    """"""``same()`` returns ``True`` when all values in *iterable* are
    equal to one another, or optionally a reference value,
    *ref*. Similar to :func:`all` and :func:`any` in that it evaluates
    an iterable and returns a :class:`bool`. ``same()`` returns
    ``True`` for empty iterables.

    >>> same([])
    True
    >>> same([1])
    True
    >>> same(['a', 'a', 'a'])
    True
    >>> same(range(20))
    False
    >>> same([[], []])
    True
    >>> same([[], []], ref='test')
    False

    """"""
    iterator = iter(iterable)
    if ref is _UNSET:
        ref = next(iterator, ref)
    return all(val == ref for val in iterator)"
4972,"def remap(root, visit=default_visit, enter=default_enter, exit=default_exit,
          **kwargs):
    """"""The remap (""recursive map"") function is used to traverse and
    transform nested structures. Lists, tuples, sets, and dictionaries
    are just a few of the data structures nested into heterogenous
    tree-like structures that are so common in programming.
    Unfortunately, Python's built-in ways to manipulate collections
    are almost all flat. List comprehensions may be fast and succinct,
    but they do not recurse, making it tedious to apply quick changes
    or complex transforms to real-world data.

    remap goes where list comprehensions cannot.

    Here's an example of removing all Nones from some data:

    >>> from pprint import pprint
    >>> reviews = {'Star Trek': {'TNG': 10, 'DS9': 8.5, 'ENT': None},
    ...            'Babylon 5': 6, 'Dr. Who': None}
    >>> pprint(remap(reviews, lambda p, k, v: v is not None))
    {'Babylon 5': 6, 'Star Trek': {'DS9': 8.5, 'TNG': 10}}

    Notice how both Nones have been removed despite the nesting in the
    dictionary. Not bad for a one-liner, and that's just the beginning.
    See `this remap cookbook`_ for more delicious recipes.

    .. _this remap cookbook: http://sedimental.org/remap.html

    remap takes four main arguments: the object to traverse and three
    optional callables which determine how the remapped object will be
    created.

    Args:

        root: The target object to traverse. By default, remap
            supports iterables like :class:`list`, :class:`tuple`,
            :class:`dict`, and :class:`set`, but any object traversable by
            *enter* will work.
        visit (callable): This function is called on every item in
            *root*. It must accept three positional arguments, *path*,
            *key*, and *value*. *path* is simply a tuple of parents'
            keys. *visit* should return the new key-value pair. It may
            also return ``True`` as shorthand to keep the old item
            unmodified, or ``False`` to drop the item from the new
            structure. *visit* is called after *enter*, on the new parent.

            The *visit* function is called for every item in root,
            including duplicate items. For traversable values, it is
            called on the new parent object, after all its children
            have been visited. The default visit behavior simply
            returns the key-value pair unmodified.
        enter (callable): This function controls which items in *root*
            are traversed. It accepts the same arguments as *visit*: the
            path, the key, and the value of the current item. It returns a
            pair of the blank new parent, and an iterator over the items
            which should be visited. If ``False`` is returned instead of
            an iterator, the value will not be traversed.

            The *enter* function is only called once per unique value. The
            default enter behavior support mappings, sequences, and
            sets. Strings and all other iterables will not be traversed.
        exit (callable): This function determines how to handle items
            once they have been visited. It gets the same three
            arguments as the other functions -- *path*, *key*, *value*
            -- plus two more: the blank new parent object returned
            from *enter*, and a list of the new items, as remapped by
            *visit*.

            Like *enter*, the *exit* function is only called once per
            unique value. The default exit behavior is to simply add
            all new items to the new parent, e.g., using
            :meth:`list.extend` and :meth:`dict.update` to add to the
            new parent. Immutable objects, such as a :class:`tuple` or
            :class:`namedtuple`, must be recreated from scratch, but
            use the same type as the new parent passed back from the
            *enter* function.
        reraise_visit (bool): A pragmatic convenience for the *visit*
            callable. When set to ``False``, remap ignores any errors
            raised by the *visit* callback. Items causing exceptions
            are kept. See examples for more details.

    remap is designed to cover the majority of cases with just the
    *visit* callable. While passing in multiple callables is very
    empowering, remap is designed so very few cases should require
    passing more than one function.

    When passing *enter* and *exit*, it's common and easiest to build
    on the default behavior. Simply add ``from boltons.iterutils import
    default_enter`` (or ``default_exit``), and have your enter/exit
    function call the default behavior before or after your custom
    logic. See `this example`_.

    Duplicate and self-referential objects (aka reference loops) are
    automatically handled internally, `as shown here`_.

    .. _this example: http://sedimental.org/remap.html#sort_all_lists
    .. _as shown here: http://sedimental.org/remap.html#corner_cases

    """"""
    # TODO: improve argument formatting in sphinx doc
    # TODO: enter() return (False, items) to continue traverse but cancel copy?
    if not callable(visit):
        raise TypeError('visit expected callable, not: %r' % visit)
    if not callable(enter):
        raise TypeError('enter expected callable, not: %r' % enter)
    if not callable(exit):
        raise TypeError('exit expected callable, not: %r' % exit)
    reraise_visit = kwargs.pop('reraise_visit', True)
    if kwargs:
        raise TypeError('unexpected keyword arguments: %r' % kwargs.keys())

    path, registry, stack = (), {}, [(None, root)]
    new_items_stack = []
    while stack:
        key, value = stack.pop()
        id_value = id(value)
        if key is _REMAP_EXIT:
            key, new_parent, old_parent = value
            id_value = id(old_parent)
            path, new_items = new_items_stack.pop()
            value = exit(path, key, old_parent, new_parent, new_items)
            registry[id_value] = value
            if not new_items_stack:
                continue
        elif id_value in registry:
            value = registry[id_value]
        else:
            res = enter(path, key, value)
            try:
                new_parent, new_items = res
            except TypeError:
                # TODO: handle False?
                raise TypeError('enter should return a tuple of (new_parent,'
                                ' items_iterator), not: %r' % res)
            if new_items is not False:
                # traverse unless False is explicitly passed
                registry[id_value] = new_parent
                new_items_stack.append((path, []))
                if value is not root:
                    path += (key,)
                stack.append((_REMAP_EXIT, (key, new_parent, value)))
                if new_items:
                    stack.extend(reversed(list(new_items)))
                continue
        if visit is _orig_default_visit:
            # avoid function call overhead by inlining identity operation
            visited_item = (key, value)
        else:
            try:
                visited_item = visit(path, key, value)
            except Exception:
                if reraise_visit:
                    raise
                visited_item = True
            if visited_item is False:
                continue  # drop
            elif visited_item is True:
                visited_item = (key, value)
                # TODO: typecheck?
                #    raise TypeError('expected (key, value) from visit(),'
                #                    ' not: %r' % visited_item)
        try:
            new_items_stack[-1][1].append(visited_item)
        except IndexError:
            raise TypeError('expected remappable root, not: %r' % root)
    return value"
4973,"def get_path(root, path, default=_UNSET):
    """"""Retrieve a value from a nested object via a tuple representing the
    lookup path.

    >>> root = {'a': {'b': {'c': [[1], [2], [3]]}}}
    >>> get_path(root, ('a', 'b', 'c', 2, 0))
    3

    The path format is intentionally consistent with that of
    :func:`remap`.

    One of get_path's chief aims is improved error messaging. EAFP is
    great, but the error messages are not.

    For instance, ``root['a']['b']['c'][2][1]`` gives back
    ``IndexError: list index out of range``

    What went out of range where? get_path currently raises
    ``PathAccessError: could not access 2 from path ('a', 'b', 'c', 2,
    1), got error: IndexError('list index out of range',)``, a
    subclass of IndexError and KeyError.

    You can also pass a default that covers the entire operation,
    should the lookup fail at any level.

    Args:
       root: The target nesting of dictionaries, lists, or other
          objects supporting ``__getitem__``.
       path (tuple): A list of strings and integers to be successively
          looked up within *root*.
       default: The value to be returned should any
          ``PathAccessError`` exceptions be raised.
    """"""
    if isinstance(path, basestring):
        path = path.split('.')
    cur = root
    try:
        for seg in path:
            try:
                cur = cur[seg]
            except (KeyError, IndexError) as exc:
                raise PathAccessError(exc, seg, path)
            except TypeError as exc:
                # either string index in a list, or a parent that
                # doesn't support indexing
                try:
                    seg = int(seg)
                    cur = cur[seg]
                except (ValueError, KeyError, IndexError, TypeError):
                    if not is_iterable(cur):
                        exc = TypeError('%r object is not indexable'
                                        % type(cur).__name__)
                    raise PathAccessError(exc, seg, path)
    except PathAccessError:
        if default is _UNSET:
            raise
        return default
    return cur"
4974,"def research(root, query=lambda p, k, v: True, reraise=False):
    """"""The :func:`research` function uses :func:`remap` to recurse over
    any data nested in *root*, and find values which match a given
    criterion, specified by the *query* callable.

    Results are returned as a list of ``(path, value)`` pairs. The
    paths are tuples in the same format accepted by
    :func:`get_path`. This can be useful for comparing values nested
    in two or more different structures.

    Here's a simple example that finds all integers:

    >>> root = {'a': {'b': 1, 'c': (2, 'd', 3)}, 'e': None}
    >>> res = research(root, query=lambda p, k, v: isinstance(v, int))
    >>> print(sorted(res))
    [(('a', 'b'), 1), (('a', 'c', 0), 2), (('a', 'c', 2), 3)]

    Note how *query* follows the same, familiar ``path, key, value``
    signature as the ``visit`` and ``enter`` functions on
    :func:`remap`, and returns a :class:`bool`.

    Args:
       root: The target object to search. Supports the same types of
          objects as :func:`remap`, including :class:`list`,
          :class:`tuple`, :class:`dict`, and :class:`set`.
       query (callable): The function called on every object to
          determine whether to include it in the search results. The
          callable must accept three arguments, *path*, *key*, and
          *value*, commonly abbreviated *p*, *k*, and *v*, same as
          *enter* and *visit* from :func:`remap`.
       reraise (bool): Whether to reraise exceptions raised by *query*
          or to simply drop the result that caused the error.


    With :func:`research` it's easy to inspect the details of a data
    structure, like finding values that are at a certain depth (using
    ``len(p)``) and much more. If more advanced functionality is
    needed, check out the code and make your own :func:`remap`
    wrapper, and consider `submitting a patch`_!

    .. _submitting a patch: https://github.com/mahmoud/boltons/pulls
    """"""
    ret = []

    if not callable(query):
        raise TypeError('query expected callable, not: %r' % query)

    def enter(path, key, value):
        try:
            if query(path, key, value):
                ret.append((path + (key,), value))
        except Exception:
            if reraise:
                raise
        return default_enter(path, key, value)

    remap(root, enter=enter)
    return ret"
4975,"def unflatten(data, separator='.', replace=True):
    '''
    Expand all compound keys (at any depth) into nested dicts

        In [13]: d  = {'test.test2': {'k1.k2': 'val'}}
        In [14]: flange.expand(d)
        Out[14]: {'test.test2': {'k1': {'k2': 'val'}}}

    :param data: input dict
    :param separator: separator in compound keys
    :param replace: if true, remove the compound key. Otherwise the value will
    exist under the compound and expanded key
    :return: copy of input dict with expanded keys
    '''
    if not separator:
        return data
    return remap({'temp':data}, visit=lambda p, k, v: __expand_keys(k, v, separator, replace))['temp']"
4976,"def __query(p, k, v, accepted_keys=None, required_values=None, path=None, exact=True):
    """"""
    Query function given to visit method

    :param p: visited path in tuple form
    :param k: visited key
    :param v: visited value
    :param accepted_keys: list of keys where one must match k to satisfy query.
    :param required_values: list of values where one must match v to satisfy query
    :param path: exact path in tuple form that must match p to satisfy query
    :param exact: if True then key and value match uses contains function instead of ==
    :return: True if all criteria are satisfied, otherwise False
    """"""

    # if not k:
    #     print '__query p k:', p, k
    # print p, k, accepted_keys, required_values, path, exact
    def as_values_iterable(v):
        if isinstance(v, dict):
            return v.values()
        elif isinstance(v, six.string_types):
            return [v]
        else:
            # assume is already some iterable type
            return v

    if path and path != p:
        return False

    if accepted_keys:
        if isinstance(accepted_keys, six.string_types):
            accepted_keys = [accepted_keys]
        if len([akey for akey in accepted_keys if akey == k or (not exact and akey in k)]) == 0:
            return False

    if required_values:
        if isinstance(required_values, six.string_types):
            required_values = [required_values]
        # Find all terms in the vfilter that have a match somewhere in the values of the v dict. If the
        # list is shorter than vfilter then some terms did not match and this v fails the test.
        if len(required_values) > len([term for term in required_values for nv in as_values_iterable(v) if term == nv or (not exact and term in nv)]):
            return False

    return True"
4977,"def create_customer_group(cls, customer_group, **kwargs):
        """"""Create CustomerGroup

        Create a new CustomerGroup
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_customer_group(customer_group, async=True)
        >>> result = thread.get()

        :param async bool
        :param CustomerGroup customer_group: Attributes of customerGroup to create (required)
        :return: CustomerGroup
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_customer_group_with_http_info(customer_group, **kwargs)
        else:
            (data) = cls._create_customer_group_with_http_info(customer_group, **kwargs)
            return data"
4978,"def delete_customer_group_by_id(cls, customer_group_id, **kwargs):
        """"""Delete CustomerGroup

        Delete an instance of CustomerGroup by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_customer_group_by_id(customer_group_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str customer_group_id: ID of customerGroup to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_customer_group_by_id_with_http_info(customer_group_id, **kwargs)
        else:
            (data) = cls._delete_customer_group_by_id_with_http_info(customer_group_id, **kwargs)
            return data"
4979,"def get_customer_group_by_id(cls, customer_group_id, **kwargs):
        """"""Find CustomerGroup

        Return single instance of CustomerGroup by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_customer_group_by_id(customer_group_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str customer_group_id: ID of customerGroup to return (required)
        :return: CustomerGroup
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_customer_group_by_id_with_http_info(customer_group_id, **kwargs)
        else:
            (data) = cls._get_customer_group_by_id_with_http_info(customer_group_id, **kwargs)
            return data"
4980,"def list_all_customer_groups(cls, **kwargs):
        """"""List CustomerGroups

        Return a list of CustomerGroups
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_customer_groups(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[CustomerGroup]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_customer_groups_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_customer_groups_with_http_info(**kwargs)
            return data"
4981,"def replace_customer_group_by_id(cls, customer_group_id, customer_group, **kwargs):
        """"""Replace CustomerGroup

        Replace all attributes of CustomerGroup
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_customer_group_by_id(customer_group_id, customer_group, async=True)
        >>> result = thread.get()

        :param async bool
        :param str customer_group_id: ID of customerGroup to replace (required)
        :param CustomerGroup customer_group: Attributes of customerGroup to replace (required)
        :return: CustomerGroup
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_customer_group_by_id_with_http_info(customer_group_id, customer_group, **kwargs)
        else:
            (data) = cls._replace_customer_group_by_id_with_http_info(customer_group_id, customer_group, **kwargs)
            return data"
4982,"def update_customer_group_by_id(cls, customer_group_id, customer_group, **kwargs):
        """"""Update CustomerGroup

        Update attributes of CustomerGroup
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_customer_group_by_id(customer_group_id, customer_group, async=True)
        >>> result = thread.get()

        :param async bool
        :param str customer_group_id: ID of customerGroup to update. (required)
        :param CustomerGroup customer_group: Attributes of customerGroup to update. (required)
        :return: CustomerGroup
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_customer_group_by_id_with_http_info(customer_group_id, customer_group, **kwargs)
        else:
            (data) = cls._update_customer_group_by_id_with_http_info(customer_group_id, customer_group, **kwargs)
            return data"
4983,"def _connect(self):
        """"""Connects to the cloud web services. If this is the first
        authentication, a web browser will be started to authenticate
        against google and provide access to elasticluster.

        :return: A Resource object with methods for interacting with the
                 service.
        """"""
        # check for existing connection
        with GoogleCloudProvider.__gce_lock:
            if self._gce:
                return self._gce

            flow = OAuth2WebServerFlow(self._client_id, self._client_secret,
                                       GCE_SCOPE)
            # The `Storage` object holds the credentials that your
            # application needs to authorize access to the user's
            # data. The name of the credentials file is provided. If the
            # file does not exist, it is created. This object can only
            # hold credentials for a single user. It stores the access
            # priviledges for the application, so a user only has to grant
            # access through the web interface once.
            storage_path = os.path.join(self._storage_path,
                                        self._client_id + '.oauth.dat')
            storage = Storage(storage_path)

            credentials = storage.get()
            if credentials is None or credentials.invalid:
                args = argparser.parse_args([])
                args.noauth_local_webserver = self._noauth_local_webserver
                # try to start a browser to have the user authenticate with Google
                # TODO: what kind of exception is raised if the browser
                #       cannot be started?
                try:
                    credentials = run_flow(flow, storage, flags=args)
                except:
                    import sys
                    print ""Unexpected error:"", sys.exc_info()[0]
                    raise

            http = httplib2.Http()
            self._auth_http = credentials.authorize(http)

            self._gce = build(GCE_API_NAME, GCE_API_VERSION, http=http)

            return self._gce"
4984,"def start_instance(self,
                       # these are common to any
                       # CloudProvider.start_instance() call
                       key_name, public_key_path, private_key_path,
                       security_group, flavor, image_id, image_userdata,
                       username=None,
                       # these params are specific to the
                       # GoogleCloudProvider
                       node_name=None,
                       boot_disk_type='pd-standard',
                       boot_disk_size=10,
                       tags=None,
                       scheduling=None,
                       **kwargs):
        """"""Starts a new instance with the given properties and returns
        the instance id.

        :param str key_name: name of the ssh key to connect
        :param str public_key_path: path to ssh public key
        :param str private_key_path: path to ssh private key
        :param str security_group: firewall rule definition to apply on the
                                   instance
        :param str flavor: machine type to use for the instance
        :param str image_id: image type (os) to use for the instance
        :param str image_userdata: command to execute after startup
        :param str username: username for the given ssh key, default None
        :param str node_name: name of the instance
        :param str tags: comma-separated list of ""tags"" to label the instance
        :param str scheduling: scheduling option to use for the instance (""preemptible"")
        :param str|Sequence tags: ""Tags"" to label the instance.

        Can be either a single string (individual tags are comma-separated),
        or a sequence of strings (each string being a single tag).

        :return: str - instance id of the started instance
        """"""
        # construct URLs
        project_url = '%s%s' % (GCE_URL, self._project_id)
        machine_type_url = '%s/zones/%s/machineTypes/%s' \
                           % (project_url, self._zone, flavor)
        boot_disk_type_url = '%s/zones/%s/diskTypes/%s' \
                           % (project_url, self._zone, boot_disk_type)
        # FIXME: `conf.py` should ensure that `boot_disk_size` has the right
        # type, so there would be no need to convert here
        boot_disk_size_gb = int(boot_disk_size)
        network_url = '%s/global/networks/%s' % (project_url, self._network)
        if image_id.startswith('http://') or image_id.startswith('https://'):
            image_url = image_id
        else:
            # The image names and full resource URLs for several Google-
            # provided images (debian, centos, etc.) follow a consistent
            # pattern, and so elasticluster supports a short-hand of just
            # an image name, such as
            #   ""debian-7-wheezy-v20150526"".
            # The cloud project in this case is then ""debian-cloud"".
            #
            # Several images do not follow this convention, and so are
            # special-cased here:
            #   backports-debian -> debian-cloud
            #   ubuntu           -> ubuntu-os-cloud
            #   containter-vm    -> google-containers
            if image_id.startswith('container-vm-'):
              os_cloud = 'google-containers'
            elif image_id.startswith('backports-debian-'):
              os_cloud = 'debian-cloud'
            elif image_id.startswith('ubuntu-'):
              os_cloud = 'ubuntu-os-cloud'
            else:
              os = image_id.split(""-"")[0]
              os_cloud = ""%s-cloud"" % os

            image_url = '%s%s/global/images/%s' % (
                GCE_URL, os_cloud, image_id)

        if scheduling is None:
            # use GCE's default
            scheduling_option = {}
        elif scheduling == 'preemptible':
            scheduling_option = {
              'preemptible': True
            }
        else:
            raise InstanceError(""Unknown scheduling option: '%s'"" % scheduling)

        if isinstance(tags, types.StringTypes):
            tags = tags.split(',')
        elif isinstance(tags, collections.Sequence):
            # ok, nothing to do
            pass
        elif tags is not None:
            raise TypeError(
                ""The `tags` argument to `gce.start_instance`""
                "" should be a string or a list, got {T} instead""
                .format(T=type(tags)))

        # construct the request body
        if node_name:
            instance_id = node_name.lower().replace('_', '-')  # GCE doesn't allow ""_""
        else:
            instance_id = 'elasticluster-%s' % uuid.uuid4()

        with open(public_key_path, 'r') as f:
            public_key_content = f.read()

        instance = {
            'name': instance_id,
            'machineType': machine_type_url,
            'tags': {
              'items': tags,
            },
            'scheduling': scheduling_option,
            'disks': [{
                'autoDelete': 'true',
                'boot': 'true',
                'type': 'PERSISTENT',
                'initializeParams' : {
                    'diskName': ""%s-disk"" % instance_id,
                    'diskType': boot_disk_type_url,
                    'diskSizeGb': boot_disk_size_gb,
                    'sourceImage': image_url
                    }
                }],
            'networkInterfaces': [
                {'accessConfigs': [
                    {'type': 'ONE_TO_ONE_NAT',
                     'name': 'External NAT'
                    }],
                 'network': network_url
                }],
            'serviceAccounts': [
                {'email': self._email,
                 'scopes': GCE_DEFAULT_SCOPES
                }],
            ""metadata"": {
                ""kind"": ""compute#metadata"",
                ""items"": [
                    {
                        ""key"": ""sshKeys"",
                        ""value"": ""%s:%s"" % (username, public_key_content)
                    }
                ]
            }
        }

        # create the instance
        gce = self._connect()
        request = gce.instances().insert(
            project=self._project_id, body=instance, zone=self._zone)
        try:
            response = self._execute_request(request)
            response = self._wait_until_done(response)
            self._check_response(response)
            return instance_id
        except (HttpError, CloudProviderError) as e:
            log.error(""Error creating instance `%s`"" % e)
            raise InstanceError(""Error creating instance `%s`"" % e)"
4985,"def _get_image_url(self, image_id):
        """"""Gets the url for the specified image. Unfortunatly this only works
        for images uploaded by the user. The images provided by google will
        not be found.

        :param str image_id: image identifier
        :return: str - api url of the image
        """"""
        gce = self._connect()
        filter = ""name eq %s"" % image_id
        request = gce.images().list(project=self._project_id, filter=filter)
        response = self._execute_request(request)
        response = self._wait_until_done(response)

        image_url = None
        if ""items"" in response:
            image_url = response[""items""][0][""selfLink""]

        if image_url:
            return image_url
        else:
            raise ImageError(""Could not find given image id `%s`"" % image_id)"
4986,"def select_event(
    event                             = None,
    selection                         = ""all"",
    required_variables                = None,
    ensure_required_variables_present = False,
    verbose                           = True
    ):

    """"""
    Select a HEP event.
    """"""

    if required_variables is None:
        required_variables = [
            ""Aplan_bjets"",
            ""Aplan_jets"",
            ""Centrality_all"",
            ""ClassifBDTOutput_6jsplit"",
            ""ClassifBDTOutput_basic"",
            ""ClassifBDTOutput_withReco_6jsplit"",
            ""ClassifBDTOutput_withReco_basic"",
            ""ClassifHPLUS_Semilep_HF_BDT200_Output"",
            ""dEtajj_MaxdEta"",
            ""dRbb_avg"",
            ""dRbb_MaxM"",
            ""dRbb_MaxPt"",
            ""dRbb_min"",
            ""dRbj_Wmass"",
            ""dRHl_MaxdR"",
            ""dRHl_MindR"",
            ""dRjj_min"",
            ""dRlepbb_MindR"",
            ""dRlj_MindR"",
            ""dRuu_MindR"",
            ""H1_all"",
            ""H4_all"",
            ""HhadT_nJets"",
            ""HiggsbbM"",
            ""HiggsjjM"",
            ""HT_all"",
            ""HT_jets"",
            ""Mbb_MaxM"",
            ""Mbb_MaxPt"",
            ""Mbb_MindR"",
            ""Mbj_MaxPt"",
            ""Mbj_MindR"",
            ""Mbj_Wmass"",
            ""met_met"",
            ""met_phi"",
            ""MHiggs"",
            ""Mjj_HiggsMass"",
            ""Mjjj_MaxPt"",
            ""Mjj_MaxPt"",
            ""Mjj_MindR"",
            ""Mjj_MinM"",
            ""mu"",
            ""Muu_MindR"",
            ""NBFricoNN_dil"",
            ""nBTags"",
            ""nBTags30"",
            ""nBTags50"",
            ""nBTags60"",
            ""nBTags70"",
            ""nBTags77"",
            ""nBTags80"",
            ""nBTags85"",
            ""nBTags90"",
            ""nBTagsFlatBEff_30"",
            ""nBTagsFlatBEff_40"",
            ""nBTagsFlatBEff_50"",
            ""nBTagsFlatBEff_60"",
            ""nBTagsFlatBEff_70"",
            ""nBTagsFlatBEff_77"",
            ""nBTagsFlatBEff_85"",
            ""nElectrons"",
            ""nHFJets"",
            ""NHiggs_30"",
            ""Njet_pt40"",
            ""Njet_pt40"",
            ""nJets"",
            ""nMuons"",
            ""nPrimaryVtx"",
            ""pT_jet3"",
            ""pT_jet5"",
            ""pTuu_MindR"",
            ""semilepMVAreco_b1higgsbhadtop_dR"",
            ""semilepMVAreco_bbhiggs_dR"",
            ""semilepMVAreco_BDT_output"",
            ""semilepMVAreco_BDT_output_6jsplit"",
            ""semilepMVAreco_BDT_output_truthMatchPattern"",
            ""semilepMVAreco_BDT_withH_output"",
            ""semilepMVAreco_BDT_withH_output_6jsplit"",
            ""semilepMVAreco_BDT_withH_output_truthMatchPattern"",
            ""semilepMVAreco_hadWb1Higgs_mass"",
            ""semilepMVAreco_higgsbhadtop_withH_dR"",
            ""semilepMVAreco_higgsbleptop_mass"",
            ""semilepMVAreco_higgsbleptop_withH_dR"",
            ""semilepMVAreco_higgslep_dR"",
            ""semilepMVAreco_higgsleptop_dR"",
            ""semilepMVAreco_higgs_mass"",
            ""semilepMVAreco_higgsq1hadW_mass"",
            ""semilepMVAreco_higgsttbar_withH_dR"",
            ""semilepMVAreco_leptophadtop_dR"",
            ""semilepMVAreco_leptophadtop_withH_dR"",
            ""semilepMVAreco_Ncombinations"",
            ""semilepMVAreco_nuApprox_recoBDT"",
            ""semilepMVAreco_nuApprox_recoBDT_6jsplit"",
            ""semilepMVAreco_nuApprox_recoBDT_withH"",
            ""semilepMVAreco_nuApprox_recoBDT_withH_6jsplit"",
            ""semilepMVAreco_ttH_Ht_withH"",
            #""ttHF_mva_discriminant"",
            ""el_d0sig[0]"",
            ""el_delta_z0_sintheta[0]"",
            ""el_e[0]"",
            ""el_eta[0]"",
            ""el_phi[0]"",
            ""el_pt[0]"",
            ""el_topoetcone20[0]"",
            #""mu_d0sig[0]"",
            #""mu_delta_z0_sintheta[0]"",
            #""mu_e[0]"",
            #""mu_eta[0]"",
            #""mu_phi[0]"",
            #""mu_pt[0]"",
            ""mu_topoetcone20[0]"",
            ""jet_e[0]"",
            ""jet_eta[0]"",
            ""jet_jvt[0]"",
            ""jet_mv2c10[0]"",
            ""jet_mv2c20[0]"",
            ""jet_phi[0]"",
            ""jet_pt[0]"",
            ""jet_semilepMVAreco_recoBDT_cand[0]"",
            ""jet_semilepMVAreco_recoBDT_cand_6jsplit[0]"",
            ""jet_semilepMVAreco_recoBDT_withH_cand[0]"",
            ""jet_semilepMVAreco_recoBDT_withH_cand_6jsplit[0]"",
            ""jet_e[1]"",
            ""jet_eta[1]"",
            ""jet_jvt[1]"",
            ""jet_mv2c10[1]"",
            ""jet_mv2c20[1]"",
            ""jet_phi[1]"",
            ""jet_pt[1]"",
            ""jet_semilepMVAreco_recoBDT_cand[1]"",
            ""jet_semilepMVAreco_recoBDT_cand_6jsplit[1]"",
            ""jet_semilepMVAreco_recoBDT_withH_cand[1]"",
            ""jet_semilepMVAreco_recoBDT_withH_cand_6jsplit[1]"",
            ""jet_e[2]"",
            ""jet_eta[2]"",
            ""jet_jvt[2]"",
            ""jet_mv2c10[2]"",
            ""jet_mv2c20[2]"",
            ""jet_phi[2]"",
            ""jet_pt[2]"",
            ""jet_semilepMVAreco_recoBDT_cand[2]"",
            ""jet_semilepMVAreco_recoBDT_cand_6jsplit[2]"",
            ""jet_semilepMVAreco_recoBDT_withH_cand[2]"",
            ""jet_semilepMVAreco_recoBDT_withH_cand_6jsplit[2]"",
            ""jet_e[3]"",
            ""jet_eta[3]"",
            ""jet_jvt[3]"",
            ""jet_mv2c10[3]"",
            ""jet_mv2c20[3]"",
            ""jet_phi[3]"",
            ""jet_pt[3]"",
            ""jet_semilepMVAreco_recoBDT_cand[3]"",
            ""jet_semilepMVAreco_recoBDT_cand_6jsplit[3]"",
            ""jet_semilepMVAreco_recoBDT_withH_cand[3]"",
            ""jet_semilepMVAreco_recoBDT_withH_cand_6jsplit[3]""
        ]

    if ensure_required_variables_present and not all([hasattr(event, variable) for variable in required_variables]):

        return False

    #for variable in required_variables:
    #    if not hasattr(event, variable):
    #        print(""missing {variable}"".format(variable = variable))

    # By default, do not pass.
    conditions = [False]

    if selection == ""ejets"":

        conditions = [
            event.nElectrons == 1,                      # Require 1 electron.
            event.nJets >= 4,                           # Require >= 4 jets.
            #event.nLjets >= 1                          # Require a single large-R jet.
        ]

    elif selection == ""mujets"":

        conditions = [
            event.nMuons == 1,                          # Require 1 muon.
            event.nJets >= 4,                           # Require >= 4 jets.
            #event.nLjets >= 1                          # Require a single large-R jet.
        ]

    if selection == ""ejets_5JE4BI"":

        conditions = [
            event.nElectrons == 1,                      # Require 1 electron.
            event.nJets == 5,                           # Require 5 jets.
            event.nBTags >= 4                           # Require >= 4 b tags.
            #event.nLjets >= 1                          # Require a single large-R jet.
        ]

    if selection == ""ejets_6JI4BI"":

        conditions = [
            event.nElectrons == 1,                      # Require 1 electron.
            event.nJets >= 6,                           # Require >=6 jets.
            event.nBTags >= 4                           # Require >= 4 b tags.
            #event.nLjets >= 1                          # Require a single large-R jet.
        ]

    elif selection == ""all"":

        conditions = [
            event.nElectrons == 1 or event.nMuons == 1, # Require 1 electron or 1 muon.
            event.nJets >= 4,                           # Require >= 4 jets.
            #event.nLjets >= 1                          # Require a single large-R jet.
        ]

    if all(conditions):

        if verbose:
            log.info(""event number {event_number} passed selection {selection}"".format(
                event_number = event.eventNumber,
                selection    = selection
            ))

        return True

    else:

        return False"
4987,"def create_free_shipping(cls, free_shipping, **kwargs):
        """"""Create FreeShipping

        Create a new FreeShipping
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_free_shipping(free_shipping, async=True)
        >>> result = thread.get()

        :param async bool
        :param FreeShipping free_shipping: Attributes of freeShipping to create (required)
        :return: FreeShipping
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._create_free_shipping_with_http_info(free_shipping, **kwargs)
        else:
            (data) = cls._create_free_shipping_with_http_info(free_shipping, **kwargs)
            return data"
4988,"def delete_free_shipping_by_id(cls, free_shipping_id, **kwargs):
        """"""Delete FreeShipping

        Delete an instance of FreeShipping by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_free_shipping_by_id(free_shipping_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str free_shipping_id: ID of freeShipping to delete. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._delete_free_shipping_by_id_with_http_info(free_shipping_id, **kwargs)
        else:
            (data) = cls._delete_free_shipping_by_id_with_http_info(free_shipping_id, **kwargs)
            return data"
4989,"def get_free_shipping_by_id(cls, free_shipping_id, **kwargs):
        """"""Find FreeShipping

        Return single instance of FreeShipping by its ID.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.get_free_shipping_by_id(free_shipping_id, async=True)
        >>> result = thread.get()

        :param async bool
        :param str free_shipping_id: ID of freeShipping to return (required)
        :return: FreeShipping
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._get_free_shipping_by_id_with_http_info(free_shipping_id, **kwargs)
        else:
            (data) = cls._get_free_shipping_by_id_with_http_info(free_shipping_id, **kwargs)
            return data"
4990,"def list_all_free_shippings(cls, **kwargs):
        """"""List FreeShippings

        Return a list of FreeShippings
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.list_all_free_shippings(async=True)
        >>> result = thread.get()

        :param async bool
        :param int page: page number
        :param int size: page size
        :param str sort: page order
        :return: page[FreeShipping]
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._list_all_free_shippings_with_http_info(**kwargs)
        else:
            (data) = cls._list_all_free_shippings_with_http_info(**kwargs)
            return data"
4991,"def replace_free_shipping_by_id(cls, free_shipping_id, free_shipping, **kwargs):
        """"""Replace FreeShipping

        Replace all attributes of FreeShipping
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_free_shipping_by_id(free_shipping_id, free_shipping, async=True)
        >>> result = thread.get()

        :param async bool
        :param str free_shipping_id: ID of freeShipping to replace (required)
        :param FreeShipping free_shipping: Attributes of freeShipping to replace (required)
        :return: FreeShipping
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._replace_free_shipping_by_id_with_http_info(free_shipping_id, free_shipping, **kwargs)
        else:
            (data) = cls._replace_free_shipping_by_id_with_http_info(free_shipping_id, free_shipping, **kwargs)
            return data"
4992,"def update_free_shipping_by_id(cls, free_shipping_id, free_shipping, **kwargs):
        """"""Update FreeShipping

        Update attributes of FreeShipping
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_free_shipping_by_id(free_shipping_id, free_shipping, async=True)
        >>> result = thread.get()

        :param async bool
        :param str free_shipping_id: ID of freeShipping to update. (required)
        :param FreeShipping free_shipping: Attributes of freeShipping to update. (required)
        :return: FreeShipping
                 If the method is called asynchronously,
                 returns the request thread.
        """"""
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return cls._update_free_shipping_by_id_with_http_info(free_shipping_id, free_shipping, **kwargs)
        else:
            (data) = cls._update_free_shipping_by_id_with_http_info(free_shipping_id, free_shipping, **kwargs)
            return data"
4993,"def publish(dataset_uri):
    """"""Return access URL to HTTP enabled (published) dataset.

    Exits with error code 1 if the dataset_uri is not a dataset.
    Exits with error code 2 if the dataset cannot be HTTP enabled.
    """"""

    try:
        dataset = dtoolcore.DataSet.from_uri(dataset_uri)
    except dtoolcore.DtoolCoreTypeError:
        print(""Not a dataset: {}"".format(dataset_uri))
        sys.exit(1)

    try:
        access_uri = dataset._storage_broker.http_enable()
    except AttributeError:
        print(
            ""Datasets of type '{}' cannot be published using HTTP"".format(
                dataset._storage_broker.key)
        )
        sys.exit(2)

    return access_uri"
4994,"def cli():
    """"""Command line utility to HTTP enable (publish) a dataset.""""""
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        ""dataset_uri"",
        help=""Dtool dataset URI""
    )
    parser.add_argument(
        ""-q"",
        ""--quiet"",
        action=""store_true"",
        help=""Only return the http URI""
    )
    args = parser.parse_args()
    access_uri = publish(args.dataset_uri)

    if args.quiet:
        print(access_uri)
    else:
        print(""Dataset accessible at: {}"".format(access_uri))"
4995,"def execute(self):
        """"""
        Load the cluster and build a GC3Pie configuration snippet.
        """"""
        creator = make_creator(self.params.config,
                               storage_path=self.params.storage)
        cluster_name = self.params.cluster
        try:
            cluster = creator.load_cluster(cluster_name)
        except (ClusterNotFound, ConfigurationError) as ex:
            log.error(""Listing nodes from cluster %s: %s\n"" %
                      (cluster_name, ex))
            return

        from elasticluster.gc3pie_config import create_gc3pie_config_snippet

        if self.params.append:
            path = os.path.expanduser(self.params.append)
            try:
                fd = open(path, 'a')
                fd.write(create_gc3pie_config_snippet(cluster))
                fd.close()
            except IOError as ex:
                log.error(""Unable to write configuration to file %s: %s"",
                          path, ex)
        else:
            print(create_gc3pie_config_snippet(cluster))"
4996,"def write_xml(self, outfile, encoding=""UTF-8""):
        """"""Write the Media RSS Feed's XML representation to the given file.""""""
        # we add the media namespace if we see any media items
        if any([key for item in self.items for key in vars(item) if
                key.startswith('media_') and getattr(item, key)]):
            self.rss_attrs[""xmlns:media""] = ""http://search.yahoo.com/mrss/""
        self.generator = _generator_name
        super(MediaRSS2, self).write_xml(outfile, encoding)"
4997,"def _add_attribute(self, name, value, allowed_values=None):
        """"""Add an attribute to the MediaContent element.""""""
        if value and value != 'none':

            if isinstance(value, (int, bool)):
                value = str(value)

            if allowed_values and value not in allowed_values:
                raise TypeError(
                    ""Attribute '"" + name + ""' must be one of "" + str(
                        allowed_values) + "" but is '"" + str(value) + ""'"")

            self.element_attrs[name] = value"
4998,"def check_complicance(self):
        """"""Check compliance with Media RSS Specification, Version 1.5.1.

        see http://www.rssboard.org/media-rss
        Raises AttributeError on error.
        """"""
        # check Media RSS requirement: one of the following elements is
        # required: media_group | media_content | media_player | media_peerLink
        # | media_location. We do the check only if any media_... element is
        # set to allow non media feeds
        if(any([ma for ma in vars(self)
                if ma.startswith('media_') and getattr(self, ma)])
           and not self.media_group
           and not self.media_content
           and not self.media_player
           and not self.media_peerLink
           and not self.media_location
           ):
            raise AttributeError(
                ""Using media elements requires the specification of at least ""
                ""one of the following elements: 'media_group', ""
                ""'media_content', 'media_player', 'media_peerLink' or ""
                ""'media_location'."")

        # check Media RSS requirement: if media:player is missing all
        # media_content elements need to have url attributes.
        if not self.media_player:
            if self.media_content:
                # check if all media_content elements have a URL set
                if isinstance(self.media_content, list):
                    if not all([False for mc in self.media_content if
                                'url' not in mc.element_attrs]):
                        raise AttributeError(
                            ""MediaRSSItems require a media_player attribute ""
                            ""if a media_content has no url set."")
                else:
                    if not self.media_content.element_attrs['url']:
                        raise AttributeError(
                            ""MediaRSSItems require a media_player attribute ""
                            ""if a media_content has no url set."")
                pass
            elif self.media_group:
                # check media groups without player if its media_content
                # elements have a URL set
                raise NotImplementedError(
                    ""MediaRSSItem: media_group check not implemented yet."")"
4999,"def publish_extensions(self, handler):
        """"""Publish the Media RSS Feed elements as XML.""""""
        if isinstance(self.media_content, list):
            [PyRSS2Gen._opt_element(handler, ""media:content"", mc_element) for
             mc_element in self.media_content]
        else:
            PyRSS2Gen._opt_element(handler, ""media:content"",
                                   self.media_content)

        if hasattr(self, 'media_title'):
            PyRSS2Gen._opt_element(handler, ""media:title"", self.media_title)

        if hasattr(self, 'media_text'):
            PyRSS2Gen._opt_element(handler, ""media:text"", self.media_text)"