Instruction:
Create a Python 3 function for
inserting a column before index in the table.

Response:
def insert_column(self, index, header, column):
        """Insert a column before `index` in the table.

        If length of column is bigger than number of rows, lets say
        `k`, only the first `k` values of `column` is considered.
        If column is shorter than 'k', ValueError is raised.

        Note that Table remains in consistent state even if column
        is too short. Any changes made by this method is rolled back
        before raising the exception.

        Parameters
        ----------
        index : int
            List index rules apply.

        header : str
            Title of the column.

        column : iterable
            Any iterable of appropriate length.

        Raises
        ------
        TypeError:
            If `header` is not of type `str`.

        ValueError:
            If length of `column` is shorter than number of rows.
        """
        if self._column_count == 0:
            self.column_headers = HeaderData(self, [header])
            self._table = [RowData(self, [i]) for i in column]
        else:
            if not isinstance(header, basestring):
                raise TypeError("header must be of type str")
            column_length = 0
            for i, (row, new_item) in enumerate(zip(self._table, column)):
                row._insert(index, new_item)
                column_length = i
            if column_length == len(self._table) - 1:
                self._column_count += 1
                self._column_headers._insert(index, header)
                self._column_alignments._insert(index, self.default_alignment)
                self._column_widths._insert(index, 0)
                self._left_padding_widths._insert(index, self.default_padding)
                self._right_padding_widths._insert(index, self.default_padding)
            else:
                # Roll back changes so that table remains in consistent state
                for j in range(column_length, -1, -1):
                    self._table[j]._pop(index)
                raise ValueError(("length of 'column' should be atleast {}, "
                                  "got {}").format(len(self._table),
                                                   column_length + 1))


Instruction:
Can you write a function in Python 3 where it
appends a column to the end of the table.

Response:
def append_column(self, header, column):
        """Append a column to end of the table.

        Parameters
        ----------
        header : str
            Title of the column

        column : iterable
            Any iterable of appropriate length.
        """
        self.insert_column(self._column_count, header, column)


Instruction:
Can you tell what is the following Python 3 function doing
def _get_horizontal_line(self, char, intersect_left,
                             intersect_mid, intersect_right):
        """Get a horizontal line for the table.

        Internal method used to actually get all horizontal lines in the table.
        Column width should be set prior to calling this method. This method
        detects intersection and handles it according to the values of
        `intersect_*_*` attributes.

        Parameters
        ----------
        char : str
            Character used to draw the line.

        Returns
        -------
        str
            String which will be printed as the Top border of the table.
        """
        width = self.get_table_width()

        try:
            line = list(char * (int(width/termwidth(char)) + 1))[:width]
        except ZeroDivisionError:
            line = [' '] * width

        if len(line) == 0:
            return ''

        # Only if Special Intersection is enabled and horizontal line is
        # visible
        if not char.isspace():
            # If left border is enabled and it is visible
            visible_junc = not intersect_left.isspace()
            if termwidth(self.left_border_char) > 0:
                if not (self.left_border_char.isspace() and visible_junc):
                    length = min(termwidth(self.left_border_char),
                                 termwidth(intersect_left))
                    for i in range(length):
                        line[i] = intersect_left[i]
            visible_junc = not intersect_right.isspace()
            # If right border is enabled and it is visible
            if termwidth(self.right_border_char) > 0:
                if not (self.right_border_char.isspace() and visible_junc):
                    length = min(termwidth(self.right_border_char),
                                 termwidth(intersect_right))
                    for i in range(length):
                        line[-i-1] = intersect_right[-i-1]
            visible_junc = not intersect_mid.isspace()
            # If column separator is enabled and it is visible
            if termwidth(self.column_separator_char):
                if not (self.column_separator_char.isspace() and visible_junc):
                    index = termwidth(self.left_border_char)
                    for i in range(self._column_count-1):
                        index += (self._column_widths[i])
                        length = min(termwidth(self.column_separator_char),
                                     termwidth(intersect_mid))
                        for i in range(length):
                            line[index+i] = intersect_mid[i]
                        index += termwidth(self.column_separator_char)

        return ''.join(line)

Response: Returns a string that will be printed as the horizontal line of the table.


Instruction:
Given the following Python 3 function, write the documentation
def get_table_width(self):
        if self.column_count == 0:
            return 0
        width = sum(self._column_widths)
        width += ((self._column_count - 1)
                  * termwidth(self.column_separator_char))
        width += termwidth(self.left_border_char)
        width += termwidth(self.right_border_char)
        return width

Response: Returns the width of the table as number of characters.


Instruction:
How would you explain what the following Python 3 function does
def get_string(self, recalculate_width=True):
        # Empty table. returning empty string.
        if len(self._table) == 0:
            return ''

        if self.serialno and self.column_count > 0:
            self.insert_column(0, self.serialno_header,
                               range(1, len(self) + 1))

        # Should widths of column be recalculated
        if recalculate_width or sum(self._column_widths) == 0:
            self._calculate_column_widths()

        string_ = []

        # Drawing the top border
        if self.top_border_char:
            string_.append(
                self._get_top_border())

        # Print headers if not empty or only spaces
        if ''.join(self._column_headers).strip():
            headers = to_unicode(self._column_headers)
            string_.append(headers)

            if self.header_separator_char:
                string_.append(
                    self._get_header_separator())

        # Printing rows
        first_row_encountered = False
        for row in self._table:
            if first_row_encountered and self.row_separator_char:
                string_.append(
                    self._get_row_separator())
            first_row_encountered = True
            content = to_unicode(row)
            string_.append(content)

        # Drawing the bottom border
        if self.bottom_border_char:
            string_.append(
                self._get_bottom_border())

        if self.serialno and self.column_count > 0:
            self.pop_column(0)

        return '\n'.join(string_)

Response: Get the table as a string.


Instruction:
Can you tell what is the following Python 3 function doing
def get_output_str(item, detect_numerics, precision, sign_value):
    if detect_numerics:
        item = _convert_to_numeric(item)
    if isinstance(item, float):
        item = round(item, precision)
    try:
        item = '{:{sign}}'.format(item, sign=sign_value)
    except (ValueError, TypeError):
        pass
    return to_unicode(item)

Response: Returns the final string which should be displayed


Instruction:
How would you explain what the following Python 3 function does
def _get_row_within_width(self, row):
        table = self._table
        lpw, rpw = table.left_padding_widths, table.right_padding_widths
        wep = table.width_exceed_policy

        list_of_rows = []

        if (wep is WidthExceedPolicy.WEP_STRIP or
                wep is WidthExceedPolicy.WEP_ELLIPSIS):

            # Let's strip the row
            delimiter = '' if wep is WidthExceedPolicy.WEP_STRIP else '...'
            row_item_list = []
            for index, row_item in enumerate(row):
                left_pad = table._column_pad * lpw[index]
                right_pad = table._column_pad * rpw[index]
                clmp_str = (left_pad
                            + self._clamp_string(row_item, index, delimiter)
                            + right_pad)
                row_item_list.append(clmp_str)
            list_of_rows.append(row_item_list)
        elif wep is WidthExceedPolicy.WEP_WRAP:

            # Let's wrap the row
            string_partition = []

            for index, row_item in enumerate(row):
                width = table.column_widths[index] - lpw[index] - rpw[index]
                string_partition.append(textwrap(row_item, width))

            for row_items in zip_longest(*string_partition, fillvalue=''):
                row_item_list = []
                for index, row_item in enumerate(row_items):
                    left_pad = table._column_pad * lpw[index]
                    right_pad = table._column_pad * rpw[index]
                    row_item_list.append(left_pad + row_item + right_pad)
                list_of_rows.append(row_item_list)

        if len(list_of_rows) == 0:
            return [[''] * table.column_count]
        else:
            return list_of_rows

Response: Process a row so that it is clamped by column_width.


Instruction:
Can you write a function in Python 3 where it
clamps the string to fit in the column referred by column_index.

Response:
def _clamp_string(self, row_item, column_index, delimiter=''):
        """Clamp `row_item` to fit in column referred by column_index.

        This method considers padding and appends the delimiter if `row_item`
        needs to be truncated.

        Parameters
        ----------
        row_item: str
            String which should be clamped.

        column_index: int
            Index of the column `row_item` belongs to.

        delimiter: str
            String which is to be appended to the clamped string.

        Returns
        -------
        str
            The modified string which fits in it's column.
        """
        width = (self._table.column_widths[column_index]
                 - self._table.left_padding_widths[column_index]
                 - self._table.right_padding_widths[column_index])

        if termwidth(row_item) <= width:
            return row_item
        else:
            if width - len(delimiter) >= 0:
                clamped_string = (textwrap(row_item, width-len(delimiter))[0]
                                  + delimiter)
            else:
                clamped_string = delimiter[:width]
            return clamped_string


Instruction:
Write a Python 3 script for
sending text message to target user.

Response:
def send_im(self, target, message, mentions=None, parse=None, update_msg_id=None, wrap_length=5000):
        """
        Send text message.

        :param target: Target user UIN or chat ID.
        :param message: Message text.
        :param mentions: Iterable with UINs to mention in message.
        :param parse: Iterable with several values from :class:`icq.constant.MessageParseType` specifying which message
            items should be parsed by target client (making preview, snippets, etc.). Specify empty iterable to avoid
            parsing message at target client. By default all types are included.
        :param update_msg_id: Message ID to update.
        :param wrap_length: Maximum length of symbols in one message. Text exceeding this length will be sent in several
            messages.

        :return: Tuple of HTTP responses.
        """
        try:
            responses = set()
            for text in wrap(string=str(message), length=wrap_length):
                response = self.http_session.post(
                    url="{}/im/sendIM".format(self.api_base_url),
                    data={
                        "r": uuid.uuid4(),
                        "aimsid": self.token,
                        "t": target,
                        "message": text,
                        "mentions": (
                            mentions if isinstance(mentions, six.string_types) or not hasattr(mentions, "__iter__")
                            else ",".join(mentions)
                        ),
                        "parse": json.dumps([p.value for p in parse]) if parse is not None else None,
                        "updateMsgId": update_msg_id
                    },
                    timeout=self.timeout_s
                )

                try:
                    self.__sent_im_cache[response.json()["response"]["data"]["msgId"]] = text
                except (LookupError, TypeError):
                    self.log.exception("Error while getting 'msgId'!")

                responses.add(response)
            return tuple(responses)
        except ReadTimeout:
            self.log.exception("Timeout while sending request!")


Instruction:
Here you have a function in Python 3, explain what it does
def random_choice(sequence):
    return random.choice(tuple(sequence) if isinstance(sequence, set) else sequence)

Response: Same as random. choice but supports set type.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def render_markdown(text, context=None):
    if context is None or not isinstance(context, dict):
        context = {}
    markdown_html = _transform_markdown_into_html(text)
    sanitised_markdown_html = _sanitise_markdown_html(markdown_html)
    return mark_safe(sanitised_markdown_html)

Response: Render markdown into HTML.


Instruction:
Implement a function in Python 3 to
deprecate call to render_markdown.

Response:
def render(text, context=None):
    """
    Depreceated call to render_markdown().
    """
    warning = (
        "wagtailmarkdown.utils.render() is deprecated. Use "
        "wagtailmarkdown.utils.render_markdown() instead."
    )
    warnings.warn(warning, WagtailMarkdownDeprecationWarning, stacklevel=2)
    return render_markdown(text, context)


Instruction:
Write a Python 3 function for
parsing a table block and build a table.

Response:
def run(self, parent, blocks):
        """ Parse a table block and build table. """
        block = blocks.pop(0).split('\n')
        header = block[0].strip()
        seperator = block[1].strip()
        rows = block[2:]
        # Get format type (bordered by pipes or not)
        border = False
        if header.startswith('|'):
            border = True
        # Get alignment of columns
        align = []
        for c in self._split_row(seperator, border):
            if c.startswith(':') and c.endswith(':'):
                align.append('center')
            elif c.startswith(':'):
                align.append('left')
            elif c.endswith(':'):
                align.append('right')
            else:
                align.append(None)
        # Build table
        table = etree.SubElement(parent, 'table')
        table.set('class', 'wftable')
        thead = etree.SubElement(table, 'thead')
        self._build_row(header, thead, align, border)
        tbody = etree.SubElement(table, 'tbody')
        for row in rows:
            self._build_row(row.strip(), tbody, align, border)


Instruction:
Can you create a Python 3 function that
gives a row of text build table cells.

Response:
def _build_row(self, row, parent, align, border):
        """ Given a row of text, build table cells. """
        tr = etree.SubElement(parent, 'tr')
        tag = 'td'
        if parent.tag == 'thead':
            tag = 'th'
        cells = self._split_row(row, border)
        # We use align here rather than cells to ensure every row
        # contains the same number of columns.
        for i, a in enumerate(align):
            c = etree.SubElement(tr, tag)
            try:
                c.text = cells[i].strip()
            except IndexError:
                c.text = ""
            if a:
                c.set('align', a)


Instruction:
Given the following Python 3 function, write the documentation
def _split_row(self, row, border):
        if border:
            if row.startswith('|'):
                row = row[1:]
            if row.endswith('|'):
                row = row[:-1]
        return row.split('|')

Response: split a row of text into list of cells.


Instruction:
Make a summary of the following Python 3 code
def extendMarkdown(self, md, md_globals):
        md.parser.blockprocessors.add('table',
                                      TableProcessor(md.parser),
                                      '<hashheader')

Response: Add an instance of TableProcessor to BlockParser.


Instruction:
Write a Python 3 script for
getting all the static files directories found by STATICFILES_FINDERS

Response:
def get_all_static():
    """
    Get all the static files directories found by ``STATICFILES_FINDERS``

    :return: set of paths (top-level folders only)
    """
    static_dirs = set()

    for finder in settings.STATICFILES_FINDERS:
        finder = finders.get_finder(finder)

        if hasattr(finder, 'storages'):
            for storage in finder.storages.values():
                static_dirs.add(storage.location)

        if hasattr(finder, 'storage'):
            static_dirs.add(finder.storage.location)

    return static_dirs


Instruction:
Write a Python 3 script for
outputting the content of the current command to a temporary file.

Response:
def input(self, **kwargs):
        """
        Specify temporary input file extension.

        Browserify requires explicit file extension (".js" or ".json" by default).
        https://github.com/substack/node-browserify/issues/1469
        """
        if self.infile is None and "{infile}" in self.command:
            if self.filename is None:
                self.infile = NamedTemporaryFile(mode='wb', suffix=self.infile_ext)
                self.infile.write(self.content.encode(self.default_encoding))
                self.infile.flush()
                self.options += (
                    ('infile', self.infile.name),
                )
        return super(BaseCompiler, self).input(**kwargs)


Instruction:
Here you have a function in Python 3, explain what it does
def graph_hash(obj):
    '''this hashes all types to a hash without colissions. python's hashing algorithms are not cross type compatable but hashing tuples with the type as the first element seems to do the trick'''
    obj_type = type(obj)
    try:
        # this works for hashables
        return hash((obj_type, obj))
    except:
        # this works for object containers since graphdb
        # wants to identify different containers
        # instead of the sum of their current internals
        return hash((obj_type, id(obj)))

Response: this hashes all types to a hash without colissions


Instruction:
Can you generate a brief explanation for the following Python 3 code
def store_item(self, item):
        ''' use this function to store a python object in the database '''
        assert not isinstance(item, RamGraphDBNode)
        item_hash = graph_hash(item)
        if item_hash not in self.nodes:
            self.nodes[item_hash] = RamGraphDBNode(item)
        return self.nodes[item_hash]

Response: store a python object in the database


Instruction:
How would you explain what the following Python 3 function does
def store_relation(self, src, name, dst):
        ''' use this to store a relation between two objects '''
        self.__require_string__(name)
        #print('storing relation', src, name, dst)
        # make sure both items are stored
        self.store_item(src).link(name, self.store_item(dst))

Response: use this to store a relation between two objects


Instruction:
Implement a function in Python 3 to
delete a relation from a source or a target

Response:
def delete_relation(self, src, relation, target):
        ''' can be both used as (src, relation, dest) for a single relation or
            (src, relation) to delete all relations of that type from the src '''
        self.__require_string__(relation)
        if src in self and target in self:
            self._get_item_node(src).unlink(relation, self._get_item_node(target))


Instruction:
Given the following Python 3 function, write the documentation
def delete_item(self, item):
        ''' removes an item from the db '''
        for relation, dst in self.relations_of(item, True):
            self.delete_relation(item, relation, dst)
            #print(item, relation, dst)
        for src, relation in self.relations_to(item, True):
            self.delete_relation(src, relation, item)
            #print(src, relation, item)
        h = self._item_hash(item)
        if item in self:
            #print('deleting item:', item)
            self.nodes[h].clear()
            del self.nodes[h]

Response: removes an item from the db


Instruction:
Create a Python 3 function for
listing all relations the originate from target

Response:
def relations_of(self, target, include_object=False):
        ''' list all relations the originate from target '''
        relations = (target if isinstance(target, RamGraphDBNode) else self._get_item_node(target)).outgoing
        if include_object:
            for k in relations:
                for v in relations[k]:
                    if hasattr(v, 'obj'): # filter dead links
                        yield k, v.obj
        else:
            yield from relations


Instruction:
Here you have a function in Python 3, explain what it does
def relations_to(self, target, include_object=False):
        ''' list all relations pointing at an object '''
        relations = self._get_item_node(target).incoming
        if include_object:
            for k in relations:
                for v in relations[k]:
                    if hasattr(v, 'obj'): # filter dead links
                        yield v.obj, k
        else:
            yield from relations

Response: list all relations pointing at an object


Instruction:
Can you generate a brief explanation for the following Python 3 code
def show_objects(self):
        ''' display the entire of objects with their (id, value, node) '''
        for key in self.nodes:
            node = self.nodes[key]
            value = node.obj
            print(key, '-', repr(value), '-', node)

Response: display the entire of objects with their id value node


Instruction:
Can you tell what is the following Python 3 function doing
def list_relations(self):
        ''' list every relation in the database as (src, relation, dst) '''
        for node in self.iter_nodes():
            for relation, target in self.relations_of(node.obj, True):
                yield node.obj, relation, target

Response: list every relation in the database as ( src relation dst )


Instruction:
Create a Python 3 function for
displaying every relation in the database as ( src relation dst

Response:
def show_relations(self):
        ''' display every relation in the database as (src, relation, dst) '''
        for src_node in self.iter_nodes():
            for relation in src_node.outgoing:
                for dst_node in src_node.outgoing[relation]:
                    print(repr(src_node.obj), '-', relation, '-', repr(dst_node.obj))


Instruction:
Write a Python 3 script for
using this to filter VLists simply provide a filter function and what relation to apply it to

Response:
def where(self, relation, filter_fn):
        ''' use this to filter VLists, simply provide a filter function and what relation to apply it to '''
        assert type(relation).__name__ in {'str','unicode'}, 'where needs the first arg to be a string'
        assert callable(filter_fn), 'filter_fn needs to be callable'
        return VList(i for i in self if relation in i._relations() and any(filter_fn(_()) for _ in i[relation]))


Instruction:
Given the following Python 3 function, write the documentation
def _where(self, filter_fn):
        ''' use this to filter VLists, simply provide a filter function to filter the current found objects '''
        assert callable(filter_fn), 'filter_fn needs to be callable'
        return VList(i for i in self if filter_fn(i()))

Response: use this to filter VLists simply provide a filter function that returns True


Instruction:
Can you tell what is the following Python 3 function doing
def _where(self, **kwargs):
        '''use this to filter VLists with kv pairs'''
        out = self
        for k,v in kwargs.items():
            out = out.where(k, lambda i:i==v)
        return out

Response: use this to filter VLists with kv pairs


Instruction:
Can you create a Python 3 function that
creates a file at the given path and sets the permissions to read only read or write

Response:
def _create_file(path=''):
        ''' creates a file at the given path and sets the permissions to user only read/write '''
        from os.path import isfile
        if not isfile(path): # only do the following if the file doesn't exist yet
            from os import chmod
            from stat import S_IRUSR, S_IWUSR

            open(path, "a").close()  # create the file
            attempt(lambda: chmod(path, (S_IRUSR | S_IWUSR)))


Instruction:
Can you generate a brief explanation for the following Python 3 code
def store_item(self, item):
        ''' use this function to store a python object in the database '''
        #print('storing item', item)
        item_id = self._id_of(item)
        #print('item_id', item_id)
        if item_id is None:
            #print('storing item', item)
            blob = self.serialize(item)
            with self._write_lock:
                self._execute(
                    'INSERT into objects (code) values (?);',
                    (blob,)
                )
                self.autocommit()

Response: store a python object in the database


Instruction:
Given the following Python 3 function, write the documentation
def delete_item(self, item):
        ''' removes an item from the db '''
        for relation in self.relations_of(item):
            self.delete_relation(item, relation)
        for origin, relation in self.relations_to(item, True):
            self.delete_relation(origin, relation, item)
        with self._write_lock:
            self._execute('''
                DELETE from objects where code=?
            ''', (self.serialize(item),))
            self.autocommit()

Response: Removes an item from the database.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def store_relation(self, src, name, dst):
        ''' use this to store a relation between two objects '''
        self.__require_string__(name)
        #print('storing relation', src, name, dst)
        # make sure both items are stored
        self.store_item(src)
        self.store_item(dst)
        with self._write_lock:
            #print(locals())
            # run the insertion
            self._execute(
                'insert into relations select ob1.id, ?, ob2.id from objects as ob1, objects as ob2 where ob1.code=? and ob2.code=?;',
                (name, self.serialize(src), self.serialize(dst))
            )
            self.autocommit()

Response: store a relation between two objects


Instruction:
Explain what the following Python 3 code does
def _delete_single_relation(self, src, relation, dst):
        ''' deletes a single relation between objects '''
        self.__require_string__(relation)
        src_id = self._id_of(src)
        dst_id = self._id_of(dst)
        with self._write_lock:
            self._execute('''
                DELETE from relations where src=? and name=? and dst=?
            ''', (src_id, relation, dst_id))
            self.autocommit()

Response: Deletes a single relation between objects src and dst.


Instruction:
Make a summary of the following Python 3 code
def delete_relation(self, src, relation, *targets):
        ''' can be both used as (src, relation, dest) for a single relation or
            (src, relation) to delete all relations of that type from the src '''
        self.__require_string__(relation)
        if len(targets):
            for i in targets:
                self._delete_single_relation(src, relation, i)
        else:
            # delete all connections of that relation from src
            for i in list(self.find(src, relation)):
                self._delete_single_relation(src, relation, i)

Response: delete a single relation from a source


Instruction:
Create a Python 3 function to
return back all elements the target has a relation to

Response:
def find(self, target, relation):
        ''' returns back all elements the target has a relation to '''
        query = 'select ob1.code from objects as ob1, objects as ob2, relations where relations.dst=ob1.id and relations.name=? and relations.src=ob2.id and ob2.code=?' # src is id not source :/
        for i in self._execute(query, (relation, self.serialize(target))):
            yield self.deserialize(i[0])


Instruction:
Write a Python 3 function for
listing all relations the originate from target

Response:
def relations_of(self, target, include_object=False):
        ''' list all relations the originate from target '''
        if include_object:
            _ = self._execute('''
                select relations.name, ob2.code from relations, objects as ob1, objects as ob2 where relations.src=ob1.id and ob2.id=relations.dst and ob1.code=?
            ''', (self.serialize(target),))
            for i in _:
                yield i[0], self.deserialize(i[1])
        else:

            _ = self._execute('''
                select distinct relations.name from relations, objects where relations.src=objects.id and objects.code=?
            ''', (self.serialize(target),))
            for i in _:
                yield i[0]


Instruction:
Explain what the following Python 3 code does
def relations_to(self, target, include_object=False):
        ''' list all relations pointing at an object '''
        if include_object:
            _ = self._execute('''
                select name, (select code from objects where id=src) from relations where dst=?
            ''', (self._id_of(target),))
            for i in _:
                yield self.deserialize(i[1]), i[0]
        else:
            _ = self._execute('''
                select distinct name from relations where dst=?
            ''', (self._id_of(target),))
            for i in _:
                yield i[0]

Response: list all relations pointing at an object


Instruction:
Can you implement a function in Python 3 that
generates tuples containing relation object_that_applies

Response:
def connections_of(self, target):
        ''' generate tuples containing (relation, object_that_applies) '''
        return gen.chain( ((r,i) for i in self.find(target,r)) for r in self.relations_of(target) )


Instruction:
Write a Python 3 function that can
list the entire of objects with their id serialized_form actual_value

Response:
def list_objects(self):
        ''' list the entire of objects with their (id, serialized_form, actual_value) '''
        for i in self._execute('select * from objects'):
            _id, code = i
            yield _id, code, self.deserialize(code)


Instruction:
Can you implement a function in Python 3 that
lists every relation in the database as ( src name dst )

Response:
def list_relations(self):
        ''' list every relation in the database as (src, relation, dst) '''
        _ = self._execute('select * from relations').fetchall()
        for i in _:
            #print(i)
            src, name, dst = i
            src = self.deserialize(
                next(self._execute('select code from objects where id=?',(src,)))[0]
            )
            dst = self.deserialize(
                next(self._execute('select code from objects where id=?',(dst,)))[0]
            )
            yield src, name, dst


Instruction:
Write a Python 3 script for
calculating changes between tables and foreign keys.

Response:
def calc_changes(db, ignore_tables=None):
  migrator = None # expose eventually?
  if migrator is None:
    migrator = auto_detect_migrator(db)

  existing_tables = [unicode(t) for t in db.get_tables()]
  existing_indexes = {table:get_indexes_by_table(db, table) for table in existing_tables}
  existing_columns_by_table = get_columns_by_table(db)
  foreign_keys_by_table = get_foreign_keys_by_table(db)

  table_names_to_models = {_table_name(cls): cls for cls in all_models.keys()}

  to_run = []

  table_adds, add_fks, table_deletes, table_renames = calc_table_changes(existing_tables, ignore_tables=ignore_tables)
  table_renamed_from = {v: k for k, v in table_renames.items()}
  for tbl in table_adds:
    to_run += create_table(table_names_to_models[tbl])
  for field in add_fks:
    if hasattr(field, '__pwdbev__not_deferred') and field.__pwdbev__not_deferred:
      field.deferred = False
    to_run += create_foreign_key(field)
  for k, v in table_renames.items():
    to_run += rename_table(migrator, k, v)

  rename_cols_by_table = {}
  deleted_cols_by_table = {}
  for etn, ecols in existing_columns_by_table.items():
    if etn in table_deletes: continue
    ntn = table_renames.get(etn, etn)
    model = table_names_to_models.get(ntn)
    if not model: continue
    defined_fields = model._meta.sorted_fields
    defined_column_name_to_field = {unicode(_column_name(f)):f for f in defined_fields}
    existing_fks_by_column = {fk.column:fk for fk in foreign_keys_by_table[etn]}
    adds, deletes, renames, alter_statements = calc_column_changes(db, migrator, etn, ntn, ecols, defined_fields, existing_fks_by_column)
    for column_name in adds:
      field = defined_column_name_to_field[column_name]
      to_run += alter_add_column(db, migrator, ntn, column_name, field)
      if not field.null:
        # alter_add_column strips null constraints
        # add them back after setting any defaults
        if field.default is not None:
          to_run += set_default(db, migrator, ntn, column_name, field)
        else:
          to_run.append(('-- adding a not null column without a default will fail if the table is not empty',[]))
        to_run += add_not_null(db, migrator, ntn, column_name, field)

    for column_name in deletes:
      fk = existing_fks_by_column.get(column_name)
      if fk:
        to_run += drop_foreign_key(db, migrator, ntn, fk.name)
      to_run += drop_column(db, migrator, ntn, column_name)
    for ocn, ncn in renames.items():
      field = defined_column_name_to_field[ncn]
      to_run += rename_column(db, migrator, ntn, ocn, ncn, field)
    to_run += alter_statements
    rename_cols_by_table[ntn] = renames
    deleted_cols_by_table[ntn] = deletes

  for ntn, model in table_names_to_models.items():
    etn = table_renamed_from.get(ntn, ntn)
    deletes = deleted_cols_by_table.get(ntn,set())
    existing_indexes_for_table = [i for i in existing_indexes.get(etn, []) if not any([(c in deletes) for c in i.columns])]
    to_run += calc_index_changes(db, migrator, existing_indexes_for_table, model, rename_cols_by_table.get(ntn, {}))

  '''
  to_run += calc_perms_changes($schema_tables, noop) unless $check_perms_for.empty?
  '''
  for tbl in table_deletes:
    to_run += drop_table(migrator, tbl)
  return to_run


Instruction:
Explain what the following Python 3 code does
def set_keep_alive(self, sock, after_idle_sec=5, interval_sec=60,
                       max_fails=5):
        """
        This function instructs the TCP socket to send a heart beat every n
        seconds to detect dead connections. It's the TCP equivalent of the
        IRC ping-pong protocol and allows for better cleanup / detection
        of dead TCP connections.

        It activates after 1 second (after_idle_sec) of idleness, then sends
        a keepalive ping once every 3 seconds(interval_sec), and closes the
        connection after 5 failed ping (max_fails), or 15 seconds
        """

        # OSX
        if platform.system() == "Darwin":
            # scraped from /usr/include, not exported by python's socket module
            TCP_KEEPALIVE = 0x10
            sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
            sock.setsockopt(socket.IPPROTO_TCP, TCP_KEEPALIVE, interval_sec)

        if platform.system() == "Windows":
            sock.ioctl(socket.SIO_KEEPALIVE_VALS, (1, 10000, 3000))

        if platform.system() == "Linux":
            sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE,
                            after_idle_sec)
            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL,
                            interval_sec)
            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, max_fails)

Response: Sets the given socket to keep alive.


Instruction:
Write a Python 3 script to
parse the buffer and return a list of the reply entries.

Response:
def parse_buf(self, encoding="unicode"):
        """
        Since TCP is a stream-orientated protocol, responses aren't guaranteed
        to be complete when they arrive. The buffer stores all the data and
        this function splits the data into replies based on the new line
        delimiter.
        """
        buf_len = len(self.buf)
        replies = []
        reply = b""
        chop = 0
        skip = 0
        i = 0
        buf_len = len(self.buf)
        for i in range(0, buf_len):
            ch = self.buf[i:i + 1]
            if skip:
                skip -= 1
                i += 1
                continue

            nxt = i + 1
            if nxt < buf_len:
                if ch == b"\r" and self.buf[nxt:nxt + 1] == b"\n":

                    # Append new reply.
                    if reply != b"":
                        if encoding == "unicode":
                            replies.append(encode_str(reply, encoding))
                        else:
                            replies.append(reply)
                        reply = b""

                    # Truncate the whole buf if chop is out of bounds.
                    chop = nxt + 1
                    skip = 1
                    i += 1
                    continue

            reply += ch
            i += 1

        # Truncate buf.
        if chop:
            self.buf = self.buf[chop:]

        return replies


Instruction:
How would you explain what the following Python 3 function does
def validate_node(self, node_ip, node_port=None, same_nodes=1):
        self.debug_print("Validating: " + node_ip)

        # Is this a valid IP?
        if not is_ip_valid(node_ip) or node_ip == "0.0.0.0":
            self.debug_print("Invalid node ip in validate node")
            return 0

        # Is this a valid port?
        if node_port != 0 and node_port is not None:
            if not is_valid_port(node_port):
                self.debug_print("Invalid node port in validate port")
                return 0

        """
        Don't accept connections from self to passive server
        or connections to already connected nodes.
        """
        if not self.enable_duplicate_ip_cons:
            # Don't connect to ourself.
            if (node_ip == "127.0.0.1" or
                    node_ip == get_lan_ip(self.interface) or
                    node_ip == self.wan_ip):
                self.debug_print("Cannot connect to ourself.")
                return 0

            # No, really: don't connect to ourself.
            if node_ip == self.passive_bind and node_port == self.passive_port:
                self.debug_print("Error connecting to same listen server.")
                return 0

            # Don't connect to same nodes.
            if same_nodes:
                for node in self.outbound + self.inbound:
                    try:
                        addr, port = node["con"].s.getpeername()
                        if node_ip == addr:
                            self.debug_print("Already connected to this node.")
                            return 0
                    except Exception as e:
                        print(e)
                        return 0

        return 1

Response:
Don't accept connections from self to passive server
        or connections to already connected nodes.


Instruction:
Make a summary of the following Python 3 code
def bootstrap(self):
        # Disable bootstrap.
        if not self.enable_bootstrap:
            return None

        # Avoid raping the rendezvous server.
        t = time.time()
        if self.last_bootstrap is not None:
            if t - self.last_bootstrap <= rendezvous_interval:
                self.debug_print("Bootstrapped recently")
                return None
        self.last_bootstrap = t
        self.debug_print("Searching for nodes to connect to.")

        try:
            connection_slots = self.max_outbound - (len(self.outbound))
            if connection_slots > 0:
                # Connect to rendezvous server.
                rendezvous_con = self.rendezvous.server_connect()

                # Retrieve random nodes to bootstrap with.
                rendezvous_con.send_line("BOOTSTRAP " +
                                         str(self.max_outbound * 2))
                choices = rendezvous_con.recv_line(timeout=2)
                if choices == "NODES EMPTY":
                    rendezvous_con.close()
                    self.debug_print("Node list is empty.")
                    return self
                else:
                    self.debug_print("Found node list.")

                # Parse node list.
                choices = re.findall("(?:(p|s)[:]([0-9]+[.][0-9]+[.][0-9]+[.][0-9]+)[:]([0-9]+))+\s?", choices)
                rendezvous_con.s.close()

                # Attempt to make active simultaneous connections.
                passive_nodes = []
                for node in choices:
                    # Out of connection slots.
                    if not connection_slots:
                        break

                    # Add to list of passive nodes.
                    node_type, node_ip, node_port = node
                    self.debug_print(str(node))
                    if node_type == "p":
                        passive_nodes.append(node)

                # Use passive to make up the remaining cons.
                i = 0
                while i < len(passive_nodes) and connection_slots > 0:
                    node_type, node_ip, node_port = passive_nodes[i]
                    con = self.add_node(node_ip, node_port, "passive")
                    if con is not None:
                        connection_slots -= 1
                        self.debug_print("Con successful.")
                    else:
                        self.debug_print("Con failed.")

                    i += 1

        except Exception as e:
            self.debug_print("Unknown error in bootstrap()")
            error = parse_exception(e)
            log_exception(self.error_log_path, error)

        return self

Response: Returns a new instance of the most recent bootstrapped version of the nodes.


Instruction:
Create a Python 3 function for
determining the type of node based on the node type and the node s information.

Response:
def determine_node(self):
        """
        Determines the type of node based on a combination of forwarding
        reachability and NAT type.
        """

        # Manually set node_type as simultaneous.
        if self.node_type == "simultaneous":
            if self.nat_type != "unknown":
                return "simultaneous"

        # Get IP of binding interface.
        unspecific_bind = ["0.0.0.0", "127.0.0.1", "localhost"]
        if self.passive_bind in unspecific_bind:
            lan_ip = get_lan_ip(self.interface)
        else:
            lan_ip = self.passive_bind

        # Passive node checks.
        if lan_ip is not None \
                and self.passive_port is not None and self.enable_forwarding:
            self.debug_print("Checking if port is forwarded.")

            # Check port isn't already forwarded.
            if is_port_forwarded(lan_ip, self.passive_port, "TCP",
                                 self.forwarding_servers):
                msg = "Port already forwarded. Skipping NAT traversal."
                self.debug_print(msg)

                self.forwarding_type = "forwarded"
                return "passive"
            else:
                self.debug_print("Port is not already forwarded.")

            # Most routers.
            try:
                self.debug_print("Trying UPnP")

                UPnP(self.interface).forward_port("TCP", self.passive_port,
                                                  lan_ip)

                if is_port_forwarded(lan_ip, self.passive_port, "TCP",
                                     self.forwarding_servers):
                    self.forwarding_type = "UPnP"
                    self.debug_print("Forwarded port with UPnP.")
                else:
                    self.debug_print("UPnP failed to forward port.")

            except Exception as e:
                # Log exception.
                error = parse_exception(e)
                log_exception(self.error_log_path, error)
                self.debug_print("UPnP failed to forward port.")

                # Apple devices.
                try:
                    self.debug_print("Trying NATPMP.")
                    NatPMP(self.interface).forward_port("TCP",
                                                        self.passive_port,
                                                        lan_ip)
                    if is_port_forwarded(lan_ip, self.passive_port, "TCP",
                                         self.forwarding_servers):
                        self.forwarding_type = "NATPMP"
                        self.debug_print("Port forwarded with NATPMP.")
                    else:
                        self.debug_print("Failed to forward port with NATPMP.")
                        self.debug_print("Falling back on TCP hole punching or"
                                         " proxying.")
                except Exception as e:
                    # Log exception
                    error = parse_exception(e)
                    log_exception(self.error_log_path, error)
                    self.debug_print("Failed to forward port with NATPMP.")

            # Check it worked.
            if self.forwarding_type != "manual":
                return "passive"

        # Fail-safe node types.
        if self.nat_type != "unknown":
            return "simultaneous"
        else:
            return "active"


Instruction:
Here you have a function in Python 3, explain what it does
def start(self):

        self.debug_print("Starting networking.")
        self.debug_print("Make sure to iterate over replies if you need"
                         " connection alive management!")

        # Register a cnt + c handler
        signal.signal(signal.SIGINT, self.stop)

        # Save WAN IP.
        self.debug_print("WAN IP = " + str(self.wan_ip))

        # Check rendezvous server is up.
        try:
            rendezvous_con = self.rendezvous.server_connect()
            rendezvous_con.close()
        except:
            raise Exception("Unable to connect to rendezvous server.")

        # Started no matter what
        # since LAN connections are always possible.
        self.start_passive_server()

        # Determine NAT type.
        if self.nat_type == "unknown":
            self.debug_print("Determining NAT type.")
            nat_type = self.rendezvous.determine_nat()
            if nat_type is not None and nat_type != "unknown":
                self.nat_type = nat_type
                self.rendezvous.nat_type = nat_type
                self.debug_print("NAT type = " + nat_type)
            else:
                self.debug_print("Unable to determine NAT type.")

        # Check NAT type if node is simultaneous
        # is manually specified.
        if self.node_type == "simultaneous":
            if self.nat_type not in self.rendezvous.predictable_nats:
                self.debug_print("Manual setting of simultanous specified but"
                                 " ignored since NAT does not support it.")
                self.node_type = "active"
        else:
            # Determine node type.
            self.debug_print("Determining node type.")

            # No checks for manually specifying passive
            # (there probably should be.)
            if self.node_type == "unknown":
                self.node_type = self.determine_node()

        # Prevent P2P nodes from running as simultaneous.
        if self.net_type == "p2p":
            """
            TCP hole punching is reserved specifically for direct networks
            (a net object reserved for receiving direct connections
            -- p2p is for connecting to the main network. The reason for this
            is you can't do multiple TCP hole punches at the same time so
            reserved for direct network where it's most needed.
            """
            if self.node_type == "simultaneous":
                self.debug_print("Simultaneous is not allowed for P2P")
                self.node_type = "active"
                self.disable_simultaneous()

        self.debug_print("Node type = " + self.node_type)

        # Close stray cons from determine_node() tests.
        self.close_cons()

        # Set net started status.
        self.is_net_started = 1

        # Initialise our UNL details.
        self.unl = UNL(
            net=self,
            dht_node=self.dht_node,
            wan_ip=self.wan_ip
        )

        # Nestled calls.
        return self

Response:
This function determines node and NAT type, saves connectivity details,
        and starts any needed servers to be a part of the network. This is
        usually the first function called after initialising the Net class.


Instruction:
How would you implement a function in Python 3 that
stops the networking process.

Response:
def stop(self, signum=None, frame=None):
        self.debug_print("Stopping networking.")

        if self.passive is not None:
            try:
                self.passive.shutdown(1)
            except:
                pass
            self.passive.close()
            self.passive = None

        if self.last_advertise is not None:
            self.rendezvous.leave_fight()

        """
        Just let the threads timeout by themselves.
        Otherwise mutex deadlocks could occur.
        for unl_thread in self.unl.unl_threads:
            unl_thread.exit()
        """

        for con in self:
            con.close()

        if signum is not None:
            raise Exception("Process was interrupted.")


Instruction:
Given the following Python 3 function, write the documentation
def send_remote_port(self):
        msg = "REMOTE TCP %s" % (str(self.transport.getPeer().port))
        self.send_line(msg)

Response: Sends the remote port mapped for the connection.


Instruction:
Implement a Python 3 function for
removing old TCP hole punching candidates for a certain node.

Response:
def cleanup_candidates(self, node_ip):
        """
        Removes old TCP hole punching candidates for a
        designated node if a certain amount of time has passed
        since they last connected.
        """
        if node_ip in self.factory.candidates:
            old_candidates = []
            for candidate in self.factory.candidates[node_ip]:
                elapsed = int(time.time() - candidate["time"])
                if elapsed > self.challege_timeout:
                    old_candidates.append(candidate)

            for candidate in old_candidates:
                self.factory.candidates[node_ip].remove(candidate)


Instruction:
Implement a function in Python 3 to
use to progate new candidates to passive simultaneous nodes.

Response:
def propogate_candidates(self, node_ip):
        """
        Used to progate new candidates to passive simultaneous
        nodes.
        """

        if node_ip in self.factory.candidates:
            old_candidates = []
            for candidate in self.factory.candidates[node_ip]:
                # Not connected.
                if not candidate["con"].connected:
                    continue

                # Already sent -- updated when they accept this challenge.
                if candidate["propogated"]:
                    continue

                # Notify node of challege from client.
                msg = "CHALLENGE %s %s %s" % (
                    candidate["ip_addr"],
                    " ".join(map(str, candidate["predictions"])),
                    candidate["proto"])

                self.factory.nodes["simultaneous"][node_ip]["con"].\
                    send_line(msg)
                old_candidates.append(candidate)


Instruction:
Implement a Python 3 function for
calling when the connection to the remote node has been lost.

Response:
def connectionLost(self, reason):
        """
        Mostly handles clean-up of node + candidate structures.
        Avoids memory exhaustion for a large number of connections.
        """
        try:
            self.connected = False
            if debug:
                print(self.log_entry("CLOSED =", "none"))

            # Every five minutes: cleanup
            t = time.time()
            if time.time() - self.factory.last_cleanup >= self.cleanup:
                self.factory.last_cleanup = t

                # Delete old passive nodes.
                old_node_ips = []
                for node_ip in list(self.factory.nodes["passive"]):
                    passive_node = self.factory.nodes["passive"][node_ip]
                    # Gives enough time for passive nodes to receive clients.
                    if t - passive_node["time"] >= self.node_lifetime:
                        old_node_ips.append(node_ip)
                for node_ip in old_node_ips:
                    del self.factory.nodes["passive"][node_ip]

                # Delete old simultaneous nodes.
                old_node_ips = []
                for node_ip in list(self.factory.nodes["simultaneous"]):
                    simultaneous_node =\
                        self.factory.nodes["simultaneous"][node_ip]
                    # Gives enough time for passive nodes to receive clients.
                    if t - simultaneous_node["time"] >= self.node_lifetime:
                        old_node_ips.append(node_ip)
                for node_ip in old_node_ips:
                    del self.factory.nodes["simultaneous"][node_ip]

                # Delete old candidates and candidate structs.
                old_node_ips = []
                for node_ip in list(self.factory.candidates):
                    # Record old candidates.
                    old_candidates = []
                    for candidate in self.factory.candidates[node_ip]:
                        # Hole punching is ms time sensitive.
                        # Candidates older than this is safe to assume
                        # they're not needed.
                        if node_ip not in self.factory.nodes["simultaneous"] \
                                and t - candidate["time"] >= self.challenge_timeout * 5:
                            old_candidates.append(candidate)

                    # Remove old candidates.
                    for candidate in old_candidates:
                        self.factory.candidates[node_ip].remove(candidate)

                    # Record old node IPs.
                    if not len(self.factory.candidates[node_ip]) and \
                            node_ip not in self.factory.nodes["simultaneous"]:
                        old_node_ips.append(node_ip)

                # Remove old node IPs.
                for node_ip in old_node_ips:
                    del self.factory.candidates[node_ip]
        except Exception as e:
            error = parse_exception(e)
            log_exception(error_log_path, error)
            print(self.log_entry("ERROR =", error))


Instruction:
How would you explain what the following Python 3 function does
def fetch(self, server):
        t = None
        socket_default_timeout = socket.getdefaulttimeout()
        opener = urllib.build_opener()
        opener.addheaders = [('User-agent',
                              "Mozilla/5.0 (X11; Linux x86_64; rv:24.0)"
                              " Gecko/20100101 Firefox/24.0")]

        try:
            # Close url resource if fetching not finished within timeout.
            t = Timer(self.timeout, self.handle_timeout, [self.url])
            t.start()

            # Open URL.
            if version_info[0:2] == (2, 5):
                # Support for Python 2.5.* using socket hack
                # (Changes global socket timeout.)
                socket.setdefaulttimeout(self.timeout)
                self.url = opener.open(server)
            else:
                self.url = opener.open(server, timeout=self.timeout)

            # Read response.
            content = self.url.read()

            # Didn't want to import chardet. Prefered to stick to stdlib
            if PY3K:
                try:
                    content = content.decode('UTF-8')
                except UnicodeDecodeError:
                    content = content.decode('ISO-8859-1')

            p = '(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.('
            p += '25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|['
            p += '01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)'
            m = re.search(
                p,
                content)
            myip = m.group(0)
            if len(myip) > 0:
                return myip
            else:
                return ''
        except Exception as e:
            print(e)
            return ''
        finally:
            if self.url is not None:
                self.url.close()
                self.url = None
            if t is not None:
                t.cancel()

            # Reset default socket timeout.
            if socket.getdefaulttimeout() != socket_default_timeout:
                socket.setdefaulttimeout(socket_default_timeout)

Response: This function gets your IP from a specific server and returns the IP and the HTTP status code.


Instruction:
Here you have a function in Python 3, explain what it does
def connect_handler(self, their_unl, events, force_master, hairpin, nonce):
        # Figure out who should make the connection.
        our_unl = self.value.encode("ascii")
        their_unl = their_unl.encode("ascii")
        master = self.is_master(their_unl)

        """
        Master defines who connects if either side can. It's used to
        eliminate having multiple connections with the same host.
        """
        if force_master:
            master = 1

        # Deconstruct binary UNLs into dicts.
        our_unl = self.deconstruct(our_unl)
        their_unl = self.deconstruct(their_unl)

        if our_unl is None:
            raise Exception("Unable to deconstruct our UNL.")

        if their_unl is None:
            raise Exception("Unable to deconstruct their UNL.")

        # This means the nodes are behind the same router.
        if our_unl["wan_ip"] == their_unl["wan_ip"]:
            # Connect to LAN IP.
            our_unl["wan_ip"] = our_unl["lan_ip"]
            their_unl["wan_ip"] = their_unl["lan_ip"]

            # Already behind NAT so no forwarding needed.
            if hairpin:
                our_unl["node_type"] = "passive"
                their_unl["node_type"] = "passive"

        # Generate con ID.
        if nonce != "0" * 64:
            # Convert nonce to bytes.
            if sys.version_info >= (3, 0, 0):
                if type(nonce) == str:
                    nonce.encode("ascii")
            else:
                if type(nonce) == unicode:
                    nonce = str(nonce)

            # Check nonce length.
            assert(len(nonce) == 64)

            # Create con ID.
            con_id = self.net.generate_con_id(
                nonce,
                our_unl["wan_ip"],
                their_unl["wan_ip"]
            )
        else:
            con_id = None

        # Acquire mutex.
        self.mutex.acquire()

        # Wait for other UNLs to finish.
        end_time = time.time()
        end_time += len(self.pending_unls) * 60
        self.debug_print("Waiting for other unls to finish")
        while their_unl in self.pending_unls and time.time() < end_time:
            # This is an undifferentiated duplicate.
            if events is None:
                self.mutex.release()
                return

            time.sleep(1)

        self.debug_print("Other unl finished")

        is_exception = 0
        try:
            # Wait for any other hole punches to finish.
            if (their_unl["node_type"] == "simultaneous" and
                    our_unl["node_type"] != "passive"):
                self.pending_sim_open.append(their_unl["value"])
                end_time = time.time()
                end_time += len(self.pending_unls) * 60
                self.debug_print("wait for other hole punches to finish")
                while len(self.pending_sim_open) and time.time() < end_time:
                    if self.pending_sim_open[0] == their_unl["value"]:
                        break

                    time.sleep(1)

                self.debug_print("other hole punches finished")

            # Set pending UNL.
            self.pending_unls.append(their_unl)

            # Release mutex.
            self.mutex.release()

            # Get connection.
            con = self.get_connection(
                our_unl,
                their_unl,
                master,
                nonce,
                force_master,
                con_id
            )
        except Exception as e:
            is_exception = 1
            print(e)
            print("EXCEPTION IN UNL.GET_CONNECTION")
            log_exception("error.log", parse_exception(e))
        finally:
            # Release mutex.
            if self.mutex.locked() and is_exception:
                self.mutex.release()

            # Undo pending connect state.
            if their_unl in self.pending_unls:
                self.pending_unls.remove(their_unl)

            # Undo pending sim open.
            if len(self.pending_sim_open):
                if self.pending_sim_open[0] == their_unl["value"]:
                    self.pending_sim_open = self.pending_sim_open[1:]

        # Only execute events if this function was called manually.
        if events is not None:
            # Success.
            if con is not None:
                if "success" in events:
                    events["success"](con)

            # Failure.
            if con is None:
                if "failure" in events:
                    events["failure"](con)

Response: Create a new connection to the given node.


Instruction:
Create a Python 3 function to
connect to the master and the events.

Response:
def connect(self, their_unl, events, force_master=1, hairpin=1,
                nonce="0" * 64):
        """
        A new thread is spawned because many of the connection techniques
        rely on sleep to determine connection outcome or to synchronise hole
        punching techniques. If the sleep is in its own thread it won't
        block main execution.
        """
        parms = (their_unl, events, force_master, hairpin, nonce)
        t = Thread(target=self.connect_handler, args=parms)
        t.start()
        self.unl_threads.append(t)


Instruction:
How would you explain what the following Python 3 function does
def calculate_clock_skew(self):
        n = self.statx_n(self.data_points)

        """
        Required to be able to compute the standard
        deviation.
        """
        if n < 1:
            return Decimal("0")

        avg = self.statx_avg(self.data_points)
        sdev = self.statx_sdev(self.data_points)

        """
        Incrementally remove aberration points.
        """
        for k in range(0, self.clean_steps):
            """
            Remove aberration points: keep only
            the sigma range around the average.
            """
            min_val = avg - sdev
            max_val = avg + sdev

            cleaned_data_points = []
            for i in range(0, n):
                v = self.data_points[i]
                if v < min_val or v > max_val:
                    continue
                cleaned_data_points.append(v)

            self.data_points = cleaned_data_points[:]

            """
            Recompute the new average using the
            "sound" points we kept.
            """
            n = self.statx_n(self.data_points)

            """
            Not enough data to compute standard
            deviation.
            """
            if n < 2:
                break

            avg = self.statx_avg(self.data_points)
            sdev = self.statx_sdev(self.data_points)

            if sdev <= self.max_sdev or n < self.min_data:
                break

        """
        If standard deviation is too large still, we
        cannot update our clock. Collect more points.

        If we don't have a minimum amount of data,
        don't attempt the update yet, continue collecting.
        """
        if sdev > self.max_sdev or n < self.min_data:
            return Decimal("0")

        return avg

Response: Calculates the average and standard deviation of the current data points.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def attend_fight(self, mappings, node_ip, predictions, ntp):

        # Bind listen server socket.
        mappings = self.add_listen_sock(mappings)
        log.debug(mappings)

        # Walk to fight.
        self.simultaneous_cons = []
        predictions = predictions.split(" ")
        self.simultaneous_fight(mappings, node_ip, predictions, ntp)

        # Return hole made in opponent.
        if len(self.simultaneous_cons):
            """
            There may be a problem here. I noticed that when these lines
            were removed during testing that connections tended to
            succeed more. There may be a lack of synchronization between
            the timing for connections to succeed so that a close on
            one side of the fight ends up ruining valid connections on
            this side. Will need to test more.

            Notes: the UNL synchronization code could actually fix
            this (potential) problem as a cool unintended side-effect.
            """

            # Close unneeded holes.
            """
            for i in range(1, len(self.simultaneous_cons)):
                try:
                    print("Closing unneeded hole")
                    #self.simultaneous_cons[i].s.close()
                except:
                    pass
            """

            try:
                # Return open hole.
                return self.simultaneous_cons[0]
            except:
                # Try accept a connection.
                log.debug("No holes found")
                for mapping in mappings:
                    # Check if there's a new con.
                    s = mapping["listen"]
                    r, w, e = select.select(
                        [s],
                        [],
                        [],
                        0
                    )

                    # Find socket.
                    for found_sock in r:
                        # Not us.
                        if found_sock != s:
                            continue

                        # Accept a new con from the listen queue.
                        log.debug("Accept logic works!")
                        client, address = s.accept()
                        con = Sock(blocking=0)
                        con.set_sock(client)
                        return con

        return None

Response: This function is used to make a new fight connection. It creates a listen socket and walks to the fight and returns the new connection.


Instruction:
Here you have a function in Python 3, explain what it does
def sequential_connect(self):

        # Connect to rendezvous server.
        try:
            mappings = sequential_bind(self.mapping_no + 1, self.interface)
            con = self.server_connect(mappings[0]["sock"])
        except Exception as e:
            log.debug(e)
            log.debug("this err")
            return None

        # First mapping is used to talk to server.
        mappings.remove(mappings[0])

        # Receive port mapping.
        msg = "SOURCE TCP %s" % (str(mappings[0]["source"]))
        con.send_line(msg)
        reply = con.recv_line(timeout=2)
        remote_port = self.parse_remote_port(reply)
        if not remote_port:
            return None

        # Generate port predictions.
        predictions = ""
        if self.nat_type != "random":
            mappings = self.predict_mappings(mappings)
            for mapping in mappings:
                predictions += str(mapping["remote"]) + " "
            predictions = predictions.rstrip()
        else:
            predictions = "1337"

        return [con, mappings, predictions]

Response: Returns a connection to the Rendezvous Server and returns a tuple of the connection mappings and predictions.


Instruction:
Can you generate the documentation for the following Python 3 function
def simultaneous_listen(self):

        # Close socket.
        if self.server_con is not None:
            self.server_con.s.close()
            self.server_con = None

        # Reset predictions + mappings.
        self.mappings = None
        self.predictions = None

        # Connect to rendezvous server.
        parts = self.sequential_connect()
        if parts is None:
            return 0
        con, mappings, predictions = parts
        con.blocking = 0
        con.timeout = 0
        con.s.settimeout(0)
        self.server_con = con
        self.mappings = mappings
        self.predictions = predictions

        # Register simultaneous node with server.
        msg = "SIMULTANEOUS READY 0 0"
        ret = self.server_con.send_line(msg)
        if not ret:
            return 0
        return 1

Response:
This function is called by passive simultaneous nodes who
        wish to establish themself as such. It sets up a connection to the Rendezvous Server to monitor for new hole punching requests.


Instruction:
Implement a function in Python 3 to
return a list of mappings that are compatible with the current NAT type.

Response:
def predict_mappings(self, mappings):
        """
        This function is used to predict the remote ports that a NAT
        will map a local connection to. It requires the NAT type to
        be determined before use. Current support for preserving and
        delta type mapping behaviour.
        """
        if self.nat_type not in self.predictable_nats:
            msg = "Can't predict mappings for non-predictable NAT type."
            raise Exception(msg)

        for mapping in mappings:
            mapping["bound"] = mapping["sock"].getsockname()[1]

            if self.nat_type == "preserving":
                mapping["remote"] = mapping["source"]

            if self.nat_type == "delta":
                max_port = 65535
                mapping["remote"] = int(mapping["source"]) + self.delta

                # Overflow or underflow = wrap port around.
                if mapping["remote"] > max_port:
                    mapping["remote"] -= max_port
                if mapping["remote"] < 0:
                    mapping["remote"] = max_port - -mapping["remote"]

                # Unknown error.
                if mapping["remote"] < 1 or mapping["remote"] > max_port:
                    mapping["remote"] = 1
                mapping["remote"] = str(mapping["remote"])

        return mappings


Instruction:
Implement a Python 3 function for
attempting to open a hole by TCP hole punching. This function is called by the simultaneous fight function and its the code that handles doing the actual hole punching / connecting.

Response:
def throw_punch(self, args, tries=1):
        """
        Attempt to open a hole by TCP hole punching. This
        function is called by the simultaneous fight function
        and its the code that handles doing the actual hole
        punching / connecting.
        """

        # Parse arguments.
        if len(args) != 3:
            return 0
        sock, node_ip, remote_port = args
        if sock is None or node_ip is None or remote_port is None:
            return 0

        # Generous timeout.
        con = Sock(blocking=1, interface=self.interface)
        con.set_sock(sock)
        local = 0
        if is_ip_private(node_ip):
            """
            When simulating nodes on the same computer a delay needs to be set
            for the loop back interface to simulate the delays that occur over
            a WAN link. This requirement may also be needed for nodes on a LAN.

            sudo tc qdisc replace dev lo root handle 1:0 netem delay 0.5sec

            Speculation: The simulation problem may be to do with CPU cores.
            If the program is run on the same core then the connects will always
            be out of sync. If that's the case -- tries will need to be set to
            ~1000 which was what it was before. Perhaps a delay could be
            simulated by sleeping for random periods if its a local connection?
            That could help punch through at least once and then just set the
            tries to >= 1000.
            """
            tries = 20  # 20
            local = 1

        source_port = sock.getsockname()[1]
        error = 0
        log.debug("Throwing punch")
        for i in range(0, tries):
            # Attempt to connect.
            try:
                con.connect(node_ip, remote_port)
                log.debug("Sim open success!")

                # FATALITY.

                # Atomic operation so mutex not required.
                # Record hole made.
                con.set_blocking(blocking=0, timeout=5)
                self.simultaneous_cons.append(con)
                return 1
            except Exception as e:
                # Punch was blocked, opponent is strong.
                e = str(parse_exception(e))
                log.debug(e)
                error = 1
                continue

        if error:
            sock.close()

        return 0


Instruction:
Make a summary of the following Python 3 code
def parse_remote_port(self, reply):

        remote_port = re.findall("^REMOTE (TCP|UDP) ([0-9]+)$", reply)
        if not len(remote_port):
            remote_port = 0
        else:
            remote_port = int(remote_port[0][1])
            if remote_port < 1 or remote_port > 65535:
                remote_port = 0
        return remote_port

Response: Parses a remote port from a Rendezvous Server s response.


Instruction:
How would you explain what the following Python 3 function does
def determine_nat(self, return_instantly=1):
        # Already set.
        if self.nat_type != "unknown":
            return self.nat_type
        nat_type = "random"

        # Check collision ration.
        if self.port_collisions * 5 > self.nat_tests:
            msg = "Port collision number is too high compared to nat tests."
            msg += " Collisions must be in ratio 1 : 5 to avoid ambiguity"
            msg += " in test results."
            raise Exception(msg)

        # Load mappings for reuse test.
        """
        Notes: This reuse test needs to ideally be performed against
        bootstrapping nodes on at least two different addresses and
        ports to each other because there are NAT types which
        allocate new mappings based on changes to these variables.
        """
        def custom_server_con(port=None, servers=None):
            # Get connection to rendezvous server with random
            # source port specified
            servers = servers or self.rendezvous_servers
            con = None
            while con is None:
                try:
                    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
                    port = port or get_unused_port(None)
                    sock.bind(('', port))
                    source_port = sock.getsockname()[1]
                    index = random.randrange(0, len(servers))
                    log.debug("Trying index: " + str(index))
                    con = self.server_connect(sock, index, servers)
                except:
                    time.sleep(1)
                    sock.close()

            # Record which server we're connected to.
            server = list(con.s.getpeername())[:]
            server = {
                "addr": server[0],
                "port": server[1]
            }

            # Get the port mappings and instruct remote host to disconnect
            # This gives them the timewait state (we also connect to another
            # server anyway so as to avoid using the exact same con tuple.)
            con.send_line("SOURCE TCP " + str(source_port))
            remote_port = con.recv_line(timeout=2)
            remote_port = self.parse_remote_port(remote_port)
            con.send_line("QUIT")

            return source_port, remote_port, server

        log.debug("Starting initial mappings for preserving + reuse tests")
        mappings = []
        for i in range(0, self.nat_tests):
            src, remote, server = custom_server_con()
            mappings.append({
                "source": src,
                "remote": int(remote),
                "server": server
            })
        log.debug(mappings)
        log.debug(len(mappings))
        log.debug(self.nat_tests)
        log.debug("Finished mappings")

        # Preserving test.
        preserving = 0
        for mapping in mappings:
            if mapping["source"] == mapping["remote"]:
                preserving += 1
        if preserving >= (self.nat_tests - self.port_collisions):
            nat_type = "preserving"
            if return_instantly:
                return nat_type

        """
        # Test reuse.
        log.debug("Testing reuse")
        reuse = 0
        for mapping in mappings:
            addr = ("www.example.com", 80)
            servers = self.rendezvous_servers[:]
            servers.remove(mapping["server"])
            log.debug("servers = " + str(servers))
            src, remote, junk = custom_server_con(mapping["source"], servers)
            if remote == mapping["remote"]:
                reuse += 1

        # Check reuse results.
        if reuse >= (self.nat_tests - self.port_collisions):
            nat_type = "reuse"
            if return_instantly:
                return nat_type

            # Load mappings for delta tests.
            mappings = sequential_bind(self.nat_tests, self.interface)
            for i in range(0, self.nat_tests):
                con = self.server_connect(mappings[i]["sock"])
                con.send_line("SOURCE TCP " + str(mappings[i]["source"]))
                remote_port = self.parse_remote_port(con.recv_line(timeout=2))
                mappings[i]["remote"] = int(remote_port)
                con.s.close()
        """

        # Delta test.
        delta_ret = self.delta_test(mappings)
        if delta_ret["nat_type"] != "random":
            # Save delta value.
            self.delta = delta_ret["delta"]
            nat_type = "delta"
            if return_instantly:
                return nat_type

        return nat_type

Response: Returns the next available NAT type and time - to - live mapping for this instance.


Instruction:
Make a summary of the following Python 3 code
def get_unused_port(port=None):
    if port is None or port < 1024 or port > 65535:
        port = random.randint(1024, 65535)
    assert(1024 <= port <= 65535)
    while True:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.bind(('', port))  # Try to open port
        except socket.error as e:
            if e.errno in (98, 10048):  # 98, 10048 means address already bound
                return get_unused_port(None)
            raise e
        s.close()
        return port

Response: Checks if port is already in use.


Instruction:
Make a summary of the following Python 3 code
def get_lan_ip(interface="default"):
    if sys.version_info < (3, 0, 0):
        if type(interface) == str:
            interface = unicode(interface)
    else:
        if type(interface) == bytes:
            interface = interface.decode("utf-8")

    # Get ID of interface that handles WAN stuff.
    default_gateway = get_default_gateway(interface)
    gateways = netifaces.gateways()
    wan_id = None
    if netifaces.AF_INET in gateways:
        gw_list = gateways[netifaces.AF_INET]
        for gw_info in gw_list:
            if gw_info[0] == default_gateway:
                wan_id = gw_info[1]
                break

    # Find LAN IP of interface for WAN stuff.
    interfaces = netifaces.interfaces()
    if wan_id in interfaces:
        families = netifaces.ifaddresses(wan_id)
        if netifaces.AF_INET in families:
            if_info_list = families[netifaces.AF_INET]
            for if_info in if_info_list:
                if "addr" in if_info:
                    return if_info["addr"]

    """
    Execution may reach here if the host is using
    virtual interfaces on Linux and there are no gateways
    which suggests the host is a VPS or server. In this
    case
    """
    if platform.system() == "Linux":
        if ip is not None:
            return ip.routes["8.8.8.8"]["prefsrc"]

    return None

Response: Get the LAN IP of a given interface.


Instruction:
Implement a Python 3 function for
getting the n most recent IP in the n most recent ones.

Response:
def get_wan_ip(n=0):
    """
    That IP module sucks. Occasionally it returns an IP address behind
    cloudflare which probably happens when cloudflare tries to proxy your web
    request because it thinks you're trying to DoS. It's better if we just run
    our own infrastructure.
    """

    if n == 2:
        try:
            ip = myip()
            ip = extract_ip(ip)
            if is_ip_valid(ip):
                return ip
        except Exception as e:
            print(str(e))
            return None

    # Fail-safe: use centralized server for IP lookup.
    from pyp2p.net import forwarding_servers
    for forwarding_server in forwarding_servers:
        url = "http://" + forwarding_server["addr"] + ":"
        url += str(forwarding_server["port"])
        url += forwarding_server["url"]
        url += "?action=get_wan_ip"
        try:
            r = urlopen(url, timeout=5)
            response = r.read().decode("utf-8")
            response = extract_ip(response)
            if is_ip_valid(response):
                return response
        except Exception as e:
            print(str(e))
            continue

    time.sleep(1)
    return get_wan_ip(n + 1)


Instruction:
Can you tell what is the following Python 3 function doing
def get_gateway_addr():
    try:
        import netifaces
        return netifaces.gateways()["default"][netifaces.AF_INET][0]
    except ImportError:
        shell_command = 'netstat -rn'
        if os.name == "posix":
            pattern = \
                re.compile('(?:default|0\.0\.0\.0|::/0)\s+([\w\.:]+)\s+.*UG')
        elif os.name == "nt":
            if platform.version().startswith("6.1"):
                pattern = re.compile(".*?0.0.0.0[ ]+0.0.0.0[ ]+(.*?)[ ]+?.*?\n")
            else:
                pattern = re.compile(".*?Default Gateway:[ ]+(.*?)\n")
        system_out = os.popen(shell_command, 'r').read()
        if not system_out:
            raise NATPMPNetworkError(NATPMP_GATEWAY_CANNOT_FIND,
                                     error_str(NATPMP_GATEWAY_CANNOT_FIND))
        match = pattern.search(system_out)
        if not match:
            raise NATPMPNetworkError(NATPMP_GATEWAY_CANNOT_FIND,
                                     error_str(NATPMP_GATEWAY_CANNOT_FIND))
        addr = match.groups()[0].strip()
        return addr

Response: Try to get the gateway address from the system.


Instruction:
Write a Python 3 function for
taking a gateway address string and returns a non - blocking UDP socket to communicate with its NAT - PMP implementation on its NAT - PMP port.

Response:
def get_gateway_socket(gateway):
    """Takes a gateway address string and returns a non-blocking UDP
       socket to communicate with its NAT-PMP implementation on
       NATPMP_PORT.

       e.g. addr = get_gateway_socket('10.0.1.1')
    """
    if not gateway:
        raise NATPMPNetworkError(NATPMP_GATEWAY_NO_VALID_GATEWAY,
                                 error_str(NATPMP_GATEWAY_NO_VALID_GATEWAY))
    response_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    response_socket.setblocking(0)
    response_socket.connect((gateway, NATPMP_PORT))
    return response_socket


Instruction:
Here you have a function in Python 3, explain what it does
def get_public_address(gateway_ip=None, retry=9):
    if gateway_ip is None:
        gateway_ip = get_gateway_addr()
    addr_request = PublicAddressRequest()
    addr_response = send_request_with_retry(gateway_ip, addr_request,
                                            response_data_class=
                                            PublicAddressResponse,
                                            retry=retry, response_size=12)
    if addr_response.result != 0:
        # sys.stderr.write("NAT-PMP error %d: %s\n" %
        #                  (addr_response.result,
        #                   error_str(addr_response.result)))
        # sys.stderr.flush()
        raise NATPMPResultError(addr_response.result,
                                error_str(addr_response.result), addr_response)
    addr = addr_response.ip
    return addr

Response: A high - level function that returns the public interface IP of the current host by querying the NAT - PMP compatible gateway.


Instruction:
Can you tell what is the following Python 3 function doing
def map_tcp_port(public_port, private_port, lifetime=3600, gateway_ip=None,
                 retry=9, use_exception=True):
    """A high-level wrapper to map_port() that requests a mapping
       for a public TCP port on the NAT to a private TCP port on this host.
       Returns the complete response on success.

            public_port - the public port of the mapping requested
            private_port - the private port of the mapping requested
            lifetime - the duration of the mapping in seconds.
                       Defaults to 3600, per specification.
            gateway_ip - the IP to the NAT-PMP compatible gateway.
                        Defaults to using auto-detection function
                        get_gateway_addr()
            retry - the number of times to retry the request if unsuccessful.
                    Defaults to 9 as per specification.
            use_exception - throw an exception if an error result is
                           received from the gateway.  Defaults to True.
    """
    return map_port(NATPMP_PROTOCOL_TCP, public_port, private_port, lifetime,
                    gateway_ip=gateway_ip, retry=retry,
                    use_exception=use_exception)

Response: A high - level wrapper to create a new TCP port mapping.


Instruction:
Can you tell what is the following Python 3 function doing
def map_udp_port(public_port, private_port, lifetime=3600, gateway_ip=None,
                 retry=9, use_exception=True):
    """A high-level wrapper to map_port() that requests a mapping for
       a public UDP port on the NAT to a private UDP port on this host.
       Returns the complete response on success.

            public_port - the public port of the mapping requested
            private_port - the private port of the mapping requested
            lifetime - the duration of the mapping in seconds.
                       Defaults to 3600, per specification.
            gateway_ip - the IP to the NAT-PMP compatible gateway.
                         Defaults to using auto-detection function
                         get_gateway_addr()
            retry - the number of times to retry the request if unsuccessful.
                    Defaults to 9 as per specification.
            use_exception - throw an exception if an error result is
                            received from the gateway.  Defaults to True.
    """
    return map_port(NATPMP_PROTOCOL_UDP, public_port, private_port, lifetime,
                    gateway_ip=gateway_ip, retry=retry,
                    use_exception=use_exception)

Response: A high - level wrapper to map_port that returns a response for a mapping for a specific public UDP port on the NAT - PMP compatible gateway.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def map_port(protocol, public_port, private_port, lifetime=3600,
             gateway_ip=None, retry=9, use_exception=True):
    """A function to map public_port to private_port of protocol.
       Returns the complete response on success.

            protocol - NATPMP_PROTOCOL_UDP or NATPMP_PROTOCOL_TCP
            public_port - the public port of the mapping requested
            private_port - the private port of the mapping requested
            lifetime - the duration of the mapping in seconds.
                       Defaults to 3600, per specification.
            gateway_ip - the IP to the NAT-PMP compatible gateway.
                         Defaults to using auto-detection function
                         get_gateway_addr()
            retry - the number of times to retry the request if unsuccessful.
                    Defaults to 9 as per specification.
            use_exception - throw an exception if an error result
                            is received from the gateway.  Defaults to True.
    """
    if protocol not in [NATPMP_PROTOCOL_UDP, NATPMP_PROTOCOL_TCP]:
        raise ValueError("Must be either NATPMP_PROTOCOL_UDP or "
                         "NATPMP_PROTOCOL_TCP")
    if gateway_ip is None:
        gateway_ip = get_gateway_addr()
    response = None
    port_mapping_request = PortMapRequest(protocol, private_port,
                                          public_port, lifetime)
    port_mapping_response = \
        send_request_with_retry(gateway_ip, port_mapping_request,
                                response_data_class=PortMapResponse,
                                retry=retry)
    if port_mapping_response.result != 0 and use_exception:
        raise NATPMPResultError(port_mapping_response.result,
                                error_str(port_mapping_response.result),
                                port_mapping_response)
    return port_mapping_response

Response: A function to map a port of a protocol to a private port.


Instruction:
Can you create a Python 3 function that
forwards a port from one gateway to another.

Response:
def forward_port(self, proto, src_port, dest_ip, dest_port=None):
        """
        Creates a new mapping for the default gateway to forward ports.
        Source port is from the perspective of the original client.
        For example, if a client tries to connect to us on port 80,
        the source port is port 80. The destination port isn't
        necessarily 80, however. We might wish to run our web server
        on a different port so we can have the router forward requests
        for port 80 to another port (what I call the destination port.)

        If the destination port isn't specified, it defaults to the
        source port. Proto is either TCP or UDP. Function returns None
        on success, otherwise it raises an exception.
        """

        proto = proto.upper()
        valid_protos = ["TCP", "UDP"]
        if proto not in valid_protos:
            raise Exception("Invalid protocol for forwarding.")

        valid_ports = range(1, 65535)
        if src_port not in valid_ports:
            raise Exception("Invalid port for forwarding.")

        # Source port is forwarded to same destination port number.
        if dest_port is None:
            dest_port = src_port

        # Use UPnP binary for forwarding on Windows.
        if platform.system() == "Windows":
            cmd = "upnpc-static.exe -a %s %s %s %s" % (get_lan_ip(),
                                                       str(src_port),
                                                       str(dest_port),
                                                       proto)
            out, err = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
                                        stderr=subprocess.PIPE).communicate()
            if "is not recognized" in err:
                raise Exception("Missing upnpc-static.exe")

            return

        # Find gateway address.
        gateway_addr = self.find_gateway()
        if gateway_addr is None:
            raise Exception("Unable to find UPnP compatible gateway.")

        # Get control URL.
        rhost = re.findall('([^/]+)', gateway_addr)
        res = urlopen(gateway_addr, timeout=self.timeout).read().decode("utf-8")
        res = res.replace('\r', '')
        res = res.replace('\n', '')
        res = res.replace('\t', '')
        pres = res.split('<serviceId>urn:upnp-org:serviceId:WANIPConn1'
                         '</serviceId>')
        p2res = pres[1].split('</controlURL>')
        p3res = p2res[0].split('<controlURL>')
        ctrl = p3res[1]
        rip = res.split('<presentationURL>')
        rip1 = rip[1].split('</presentationURL>')
        router_ip = rip1[0]

        port_map_desc = "PyP2P"
        msg = \
            '<?xml version="1.0"?><s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><s:Body><u:AddPortMapping xmlns:u="urn:schemas-upnp-org:service:WANIPConnection:1"><NewRemoteHost></NewRemoteHost><NewExternalPort>' \
            + str(src_port) \
            + '</NewExternalPort><NewProtocol>' + str(proto) + '</NewProtocol><NewInternalPort>' \
            + str(dest_port) + '</NewInternalPort><NewInternalClient>' + str(dest_ip) \
            + '</NewInternalClient><NewEnabled>1</NewEnabled><NewPortMappingDescription>' + str(port_map_desc) + '</NewPortMappingDescription><NewLeaseDuration>0</NewLeaseDuration></u:AddPortMapping></s:Body></s:Envelope>'

        # Attempt to add new port map.
        x = 'http://' + rhost[1] + '/' + ctrl
        if sys.version_info >= (3, 0, 0):
            msg = bytes(msg, "utf-8")

        req = Request('http://' + rhost[1] + '/' + ctrl, msg)
        req.add_header('SOAPAction',
                       '"urn:schemas-upnp-org:service:WANIPConnection:1#AddPortMapping"'
                       )
        req.add_header('Content-type', 'application/xml')
        res = urlopen(req, timeout=self.timeout)


Instruction:
Explain what the following Python 3 code does
def next(self, *args):
        self.initialize()
        self.future = asyncio.Future(loop=self.loop)
        self.handle = self.loop.call_at(self.get_next(), self.call_func, *args)
        return self.future

Response: Yield the next available entry in the queue.


Instruction:
Write a Python 3 script for
initializing croniter and related times

Response:
def initialize(self):
        """Initialize croniter and related times"""
        if self.croniter is None:
            self.time = time.time()
            self.datetime = datetime.now(self.tz)
            self.loop_time = self.loop.time()
            self.croniter = croniter(self.spec, start_time=self.datetime)


Instruction:
Can you implement a function in Python 3 that
returns next iteration time related to loop time

Response:
def get_next(self):
        """Return next iteration time related to loop time"""
        return self.loop_time + (self.croniter.get_next(float) - self.time)


Instruction:
Can you generate the documentation for the following Python 3 function
def call_next(self):
        if self.handle is not None:
            self.handle.cancel()
        next_time = self.get_next()
        self.handle = self.loop.call_at(next_time, self.call_next)
        self.call_func()

Response: Set next hop in the loop. Call task


Instruction:
How would you implement a function in Python 3 that
calls the function in the event loop.

Response:
def call_func(self, *args, **kwargs):
        """Called. Take care of exceptions using gather"""
        asyncio.gather(
            self.cron(*args, **kwargs),
            loop=self.loop, return_exceptions=True
            ).add_done_callback(self.set_result)


Instruction:
Given the following Python 3 function, write the documentation
def set_result(self, result):
        result = result.result()[0]
        if self.future is not None:
            if isinstance(result, Exception):
                self.future.set_exception(result)
            else:
                self.future.set_result(result)
            self.future = None
        elif isinstance(result, Exception):
            raise result

Response: Set future s result if needed.


Instruction:
Can you tell what is the following Python 3 function doing
def timeparse(sval):
    match = re.match(r'\s*' + TIMEFORMAT + r'\s*$', sval, re.I)
    if not match or not match.group(0).strip():
        return

    mdict = match.groupdict()
    return sum(
        MULTIPLIERS[k] * cast(v) for (k, v) in mdict.items() if v is not None)

Response: Parse a time expression returning it as a number of seconds.