Instruction:
How would you code a function in Python 3 to
generate a grammar function that will match expected_tokens only.

Response:
def match_tokens(expected_tokens):
    """Generate a grammar function that will match 'expected_tokens' only."""
    if isinstance(expected_tokens, Token):
        # Match a single token.
        def _grammar_func(tokens):
            try:
                next_token = next(iter(tokens))
            except StopIteration:
                return

            if next_token == expected_tokens:
                return TokenMatch(None, next_token.value, (next_token,))

    elif isinstance(expected_tokens, tuple):
        # Match multiple tokens.
        match_len = len(expected_tokens)
        def _grammar_func(tokens):
            upcoming = tuple(itertools.islice(tokens, match_len))
            if upcoming == expected_tokens:
                return TokenMatch(None, None, upcoming)
    else:
        raise TypeError(
            "'expected_tokens' must be an instance of Token or a tuple "
            "thereof. Got %r." % expected_tokens)

    return _grammar_func


Instruction:
Given the following Python 3 function, write the documentation
def expression(self, previous_precedence=0):
        lhs = self.atom()

        return self.operator(lhs, previous_precedence)

Response: An expression is an atom or an infix expression.


Instruction:
Here you have a function in Python 3, explain what it does
def atom(self):
        # Parameter replacement with literals.
        if self.tokens.accept(grammar.param):
            return self.param()

        # Let expressions (let(x = 5, y = 10) x + y)
        if self.tokens.accept(grammar.let):
            return self.let()

        # At the top level, we try to see if we are recursing into an SQL query.
        if self.tokens.accept(grammar.select):
            return self.select()

        # A SELECT query can also start with 'ANY'.
        if self.tokens.accept(grammar.select_any):
            return self.select_any()

        # Explicitly reject any keywords from SQL other than SELECT and ANY.
        # If we don't do this they will match as valid symbols (variables)
        # and that might be confusing to the user.
        self.tokens.reject(grammar.sql_keyword)

        # Match if-else before other things that consume symbols.
        if self.tokens.accept(grammar.if_if):
            return self.if_if()

        # Operators must be matched first because the same symbols could also
        # be vars or applications.
        if self.tokens.accept(grammar.prefix):
            operator = self.tokens.matched.operator
            start = self.tokens.matched.start
            expr = self.expression(operator.precedence)
            return operator.handler(expr, start=start, end=expr.end,
                                    source=self.original)

        if self.tokens.accept(grammar.literal):
            return ast.Literal(self.tokens.matched.value, source=self.original,
                               start=self.tokens.matched.start,
                               end=self.tokens.matched.end)

        # Match builtin pseudo-functions before functions and vars to prevent
        # overrides.
        if self.tokens.accept(grammar.builtin):
            return self.builtin(self.tokens.matched.value)

        # Match applications before vars, because obviously.
        if self.tokens.accept(grammar.application):
            return self.application(
                ast.Var(self.tokens.matched.value, source=self.original,
                        start=self.tokens.matched.start,
                        end=self.tokens.matched.first.end))

        if self.tokens.accept(common_grammar.symbol):
            return ast.Var(self.tokens.matched.value, source=self.original,
                           start=self.tokens.matched.start,
                           end=self.tokens.matched.end)

        if self.tokens.accept(common_grammar.lparen):
            # Parens will contain one or more expressions. If there are several
            # expressions, separated by commas, then they are a repeated value.
            #
            # Unlike lists, repeated values must all be of the same type,
            # otherwise evaluation of the query will fail at runtime (or
            # type-check time, for simple cases.)
            start = self.tokens.matched.start
            expressions = [self.expression()]

            while self.tokens.accept(common_grammar.comma):
                expressions.append(self.expression())

            self.tokens.expect(common_grammar.rparen)

            if len(expressions) == 1:
                return expressions[0]
            else:
                return ast.Repeat(*expressions, source=self.original,
                                  start=start, end=self.tokens.matched.end)

        if self.tokens.accept(common_grammar.lbracket):
            return self.list()

        # We've run out of things we know the next atom could be. If there is
        # still input left then it's illegal syntax. If there is nothing then
        # the input cuts off when we still need an atom. Either is an error.
        if self.tokens.peek(0):
            return self.error(
                "Was not expecting %r here." % self.tokens.peek(0).name,
                start_token=self.tokens.peek(0))
        else:
            return self.error("Unexpected end of input.")

Response: Parse an atom and return a new ast. Atom node.


Instruction:
Can you tell what is the following Python 3 function doing
def accept_operator(self, precedence):
        match = grammar.infix(self.tokens)
        if not match:
            return

        if match.operator.precedence < precedence:
            return

        # The next thing is an operator that we want. Now match it for real.
        return self.tokens.accept(grammar.infix)

Response: Accept the next binary operator only if it s of higher precedence.


Instruction:
Can you implement a function in Python 3 that
climbs operator precedence as long as there are operators. This function implements a basic precedence climbing parser to deal with binary operators in a sane fashion. The outer loop will keep spinning as long as the next token is an operator with a precedence of at least 'min_precedence', parsing operands as atoms (which, in turn, recurse into 'expression' which recurses back into 'operator'). This supports both left- and right-associativity. The only part of the code that's not a regular precedence-climber deals with mixfix operators. A mixfix operator in DottySQL consists of an infix part and a suffix (they are still binary, they just have a terminator).

Response:
def operator(self, lhs, min_precedence):
        """Climb operator precedence as long as there are operators.

        This function implements a basic precedence climbing parser to deal
        with binary operators in a sane fashion. The outer loop will keep
        spinning as long as the next token is an operator with a precedence
        of at least 'min_precedence', parsing operands as atoms (which,
        in turn, recurse into 'expression' which recurses back into 'operator').

        This supports both left- and right-associativity. The only part of the
        code that's not a regular precedence-climber deals with mixfix
        operators. A mixfix operator in DottySQL consists of an infix part
        and a suffix (they are still binary, they just have a terminator).
        """

        # Spin as long as the next token is an operator of higher
        # precedence. (This may not do anything, which is fine.)
        while self.accept_operator(precedence=min_precedence):
            operator = self.tokens.matched.operator

            # If we're parsing a mixfix operator we can keep going until
            # the suffix.
            if operator.suffix:
                rhs = self.expression()
                self.tokens.expect(common_grammar.match_tokens(operator.suffix))
                rhs.end = self.tokens.matched.end
            elif operator.name == ".":
                # The dot operator changes the meaning of RHS.
                rhs = self.dot_rhs()
            else:
                # The right hand side is an atom, which might turn out to be
                # an expression. Isn't recursion exciting?
                rhs = self.atom()

            # Keep going as long as the next token is an infix operator of
            # higher precedence.
            next_min_precedence = operator.precedence
            if operator.assoc == "left":
                next_min_precedence += 1

            while self.tokens.match(grammar.infix):
                if (self.tokens.matched.operator.precedence
                        < next_min_precedence):
                    break
                rhs = self.operator(rhs,
                                    self.tokens.matched.operator.precedence)

            lhs = operator.handler(lhs, rhs, start=lhs.start, end=rhs.end,
                                   source=self.original)

        return lhs


Instruction:
Create a Python 3 function to
match the right - hand side of a dot (. ) operator. The RHS must be a symbol token but it is interpreted as a literal string.

Response:
def dot_rhs(self):
        """Match the right-hand side of a dot (.) operator.

        The RHS must be a symbol token, but it is interpreted as a literal
        string (because that's what goes in the AST of Resolve.)
        """
        self.tokens.expect(common_grammar.symbol)
        return ast.Literal(self.tokens.matched.value,
                           start=self.tokens.matched.start,
                           end=self.tokens.matched.end, source=self.original)


Instruction:
Make a summary of the following Python 3 code
def select(self):
        # Try to match the asterisk, any or list of vars.
        if self.tokens.accept(grammar.select_any):
            return self.select_any()

        if self.tokens.accept(grammar.select_all):
            # The FROM after SELECT * is required.
            self.tokens.expect(grammar.select_from)
            return self.select_from()

        return self.select_what()

Response: First part of an SQL query.


Instruction:
Given the following Python 3 function, write the documentation
def _guess_name_of(self, expr):
        if isinstance(expr, ast.Var):
            return expr.value

        if isinstance(expr, ast.Resolve):
            # We know the RHS of resolve is a Literal because that's what
            # Parser.dot_rhs does.
            return expr.rhs.value

        if isinstance(expr, ast.Select) and isinstance(expr.rhs, ast.Literal):
            name = self._guess_name_of(expr.lhs)
            if name is not None:
                return "%s_%s" % (name, expr.rhs.value)

        if isinstance(expr, ast.Apply) and isinstance(expr.func, ast.Var):
            return expr.func.value

Response: Tries to guess what variable name expr ends in.


Instruction:
Explain what the following Python 3 code does
def select_limit(self, source_expression):
        start = self.tokens.matched.start

        # The expression right after LIMIT is the count to take.
        limit_count_expression = self.expression()

        # Optional OFFSET follows.
        if self.tokens.accept(grammar.select_offset):
            offset_start = self.tokens.matched.start
            offset_end = self.tokens.matched.end

            # Next thing is the count to drop.
            offset_count_expression = self.expression()

            # We have a new source expression, which is drop(count, original).
            offset_source_expression = ast.Apply(
                ast.Var("drop", start=offset_start, end=offset_end,
                        source=self.original),
                offset_count_expression,
                source_expression,
                start=offset_start, end=offset_count_expression.end,
                source=self.original)

            # Drop before taking, because obviously.
            source_expression = offset_source_expression

        limit_expression = ast.Apply(
            ast.Var("take", start=start, end=limit_count_expression.end,
                    source=self.original),
            limit_count_expression,
            source_expression,
            start=start, end=self.tokens.matched.end, source=self.original)

        return limit_expression

Response: Match LIMIT take and drop.


Instruction:
Can you generate the documentation for the following Python 3 function
def builtin(self, keyword):
        # The match includes the lparen token, so the keyword is just the first
        # token in the match, not the whole thing.
        keyword_start = self.tokens.matched.first.start
        keyword_end = self.tokens.matched.first.end
        self.tokens.expect(common_grammar.lparen)

        if self.tokens.matched.start != keyword_end:
            return self.error(
                "No whitespace allowed between function and lparen.",
                start_token=self.tokens.matched.first)

        expr_type = grammar.BUILTINS[keyword.lower()]
        arguments = [self.expression()]
        while self.tokens.accept(common_grammar.comma):
            arguments.append(self.expression())

        self.tokens.expect(common_grammar.rparen)

        if expr_type.arity and expr_type.arity != len(arguments):
            return self.error(
                "%s expects %d arguments, but was passed %d." % (
                    keyword, expr_type.arity, len(arguments)),
                start_token=self.tokens.matched.first)

        return expr_type(*arguments, start=keyword_start,
                         end=self.tokens.matched.end, source=self.original)

Response: Parse the pseudo - function application subgrammar.


Instruction:
How would you explain what the following Python 3 function does
def application(self, func):
        start = self.tokens.matched.start
        if self.tokens.accept(common_grammar.rparen):
            # That was easy.
            return ast.Apply(func, start=start, end=self.tokens.matched.end,
                             source=self.original)

        arguments = [self.expression()]
        while self.tokens.accept(common_grammar.comma):
            arguments.append(self.expression())

        self.tokens.expect(common_grammar.rparen)
        return ast.Apply(func, *arguments, start=start,
                         end=self.tokens.matched.end, source=self.original)

Response: Parse the function application subgrammar.


Instruction:
Given the following Python 3 function, write the documentation
def list(self):
        start = self.tokens.matched.start

        if self.tokens.accept(common_grammar.rbracket):
            return ast.Tuple(start=start, end=self.tokens.matched.end,
                             source=self.original)

        elements = [self.expression()]

        while self.tokens.accept(common_grammar.comma):
            elements.append(self.expression())

        self.tokens.expect(common_grammar.rbracket)
        return ast.Tuple(*elements, start=start, end=self.tokens.matched.end,
                         source=self.original)

Response: Parse a list ( tuple which can contain any combination of types.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_singleton(self):
        only_value = None
        for value in six.itervalues(self.ordered_dict):
            # This loop will raise if it runs more than once.
            if only_value is not None:
                raise ValueError("%r is not a singleton." % self)

            only_value = value

        if only_value is self.__UnsetSentinel or only_value is None:
            raise ValueError("%r is empty." % self)

        return only_value

Response: Returns the singleton value of the entry in the row.


Instruction:
Write a Python 3 script to
return True if the object obj implements the specified protocol.

Response:
def implements(obj, protocol):
    """Does the object 'obj' implement the 'prococol'?"""
    if isinstance(obj, type):
        raise TypeError("First argument to implements must be an instance. "
                        "Got %r." % obj)
    return isinstance(obj, protocol) or issubclass(AnyType, protocol)


Instruction:
Can you generate the documentation for the following Python 3 function
def isa(cls, protocol):
    if not isinstance(cls, type):
        raise TypeError("First argument to isa must be a type. Got %s." %
                        repr(cls))

    if not isinstance(protocol, type):
        raise TypeError(("Second argument to isa must be a type or a Protocol. "
                         "Got an instance of %r.") % type(protocol))
    return issubclass(cls, protocol) or issubclass(AnyType, protocol)

Response: Checks if the given class participates in the given protocol.


Instruction:
How would you explain what the following Python 3 function does
def implemented(cls, for_type):

        for function in cls.required():
            if not function.implemented_for_type(for_type):
                raise TypeError(
                    "%r doesn't implement %r so it cannot participate in "
                    "the protocol %r." %
                    (for_type, function.func.__name__, cls))

        cls.register(for_type)

Response: Assert that protocol cls is implemented for type for_type.


Instruction:
Here you have a function in Python 3, explain what it does
def __get_type_args(for_type=None, for_types=None):
        if for_type:
            if for_types:
                raise ValueError("Cannot pass both for_type and for_types.")
            for_types = (for_type,)
        elif for_types:
            if not isinstance(for_types, tuple):
                raise TypeError("for_types must be passed as a tuple of "
                                "types (classes).")
        else:
            raise ValueError("Must pass either for_type or for_types.")

        return for_types

Response: Parse the arguments and return a tuple of types to implement for.


Instruction:
Implement a function in Python 3 to
build a function that calls the method func_name on objects and returns the result of calling the method with the same name as the contents of the obj parameter and the arguments from the args.

Response:
def _build_late_dispatcher(func_name):
        """Return a function that calls method 'func_name' on objects.

        This is useful for building late-bound dynamic dispatch.

        Arguments:
            func_name: The name of the instance method that should be called.

        Returns:
            A function that takes an 'obj' parameter, followed by *args and
            returns the result of calling the instance method with the same
            name as the contents of 'func_name' on the 'obj' object with the
            arguments from *args.
        """
        def _late_dynamic_dispatcher(obj, *args):
            method = getattr(obj, func_name, None)
            if not callable(method):
                raise NotImplementedError(
                    "Instance method %r is not implemented by %r." % (
                        func_name, obj))

            return method(*args)

        return _late_dynamic_dispatcher


Instruction:
Create a Python 3 function to
provide protocol implementation for a type.

Response:
def implement(cls, implementations, for_type=None, for_types=None):
        """Provide protocol implementation for a type.

        Register all implementations of multimethod functions in this
        protocol and add the type into the abstract base class of the
        protocol.

        Arguments:
            implementations: A dict of (function, implementation), where each
                function is multimethod and each implementation is a callable.
            for_type: The concrete type implementations apply to.
            for_types: Same as for_type, but takes a tuple of types.

            You may not supply both for_type and for_types for obvious reasons.

        Raises:
            ValueError for arguments.
            TypeError if not all implementations are provided or if there
                are issues related to polymorphism (e.g. attempting to
                implement a non-multimethod function.
        """
        for type_ in cls.__get_type_args(for_type, for_types):
            cls._implement_for_type(for_type=type_,
                                    implementations=implementations)


Instruction:
How would you implement a function in Python 3 that
parses one of the rules as either objectfilter or dottysql.

Response:
def _parse_query(self, source):
        """Parse one of the rules as either objectfilter or dottysql.

        Example:
            _parse_query("5 + 5")
            # Returns Sum(Literal(5), Literal(5))

        Arguments:
            source: A rule in either objectfilter or dottysql syntax.

        Returns:
            The AST to represent the rule.
        """
        if self.OBJECTFILTER_WORDS.search(source):
            syntax_ = "objectfilter"
        else:
            syntax_ = None  # Default it is.

        return query.Query(source, syntax=syntax_)


Instruction:
Can you generate the documentation for the following Python 3 function
def _parse_tagfile(self):
        rules = None
        tag = None
        for line in self.original:
            match = self.TAG_DECL_LINE.match(line)
            if match:
                if tag and rules:
                    yield tag, rules
                rules = []
                tag = match.group(1)
                continue

            match = self.TAG_RULE_LINE.match(line)
            if match:
                source = match.group(1)
                rules.append(self._parse_query(source))

Response: Parse the tagfile and yield tuples of tag_name list of rule ASTs.


Instruction:
How would you code a function in Python 3 to
normalize both sides but don t eliminate the expression.

Response:
def normalize(expr):
    """Normalize both sides, but don't eliminate the expression."""
    lhs = normalize(expr.lhs)
    rhs = normalize(expr.rhs)
    return type(expr)(lhs, rhs, start=lhs.start, end=rhs.end)


Instruction:
Here you have a function in Python 3, explain what it does
def normalize(expr):
    args = [normalize(arg) for arg in expr.args]

    return type(expr)(expr.func, *args, start=expr.start, end=expr.end)

Response: No elimination but normalize arguments.


Instruction:
Create a Python 3 function for
normalizing n - ary expressions and eliminate empty branches.

Response:
def normalize(expr):
    """Pass through n-ary expressions, and eliminate empty branches.

    Variadic and binary expressions recursively visit all their children.

    If all children are eliminated then the parent expression is also
    eliminated:

    (& [removed] [removed]) => [removed]

    If only one child is left, it is promoted to replace the parent node:

    (& True) => True
    """
    children = []
    for child in expr.children:
        branch = normalize(child)
        if branch is None:
            continue

        if type(branch) is type(expr):
            children.extend(branch.children)
        else:
            children.append(branch)

    if len(children) == 0:
        return None

    if len(children) == 1:
        return children[0]

    return type(expr)(*children, start=children[0].start,
                      end=children[-1].end)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def dedupe(items):
    seen = set()
    for item in items:
        if item not in seen:
            yield item
            seen.add(item)

Response:
Remove duplicates from a sequence of hashable items while maintaining
    order.


Instruction:
Write a Python 3 script for
returning a generator that yields datetime. datetime objects from the given date range.

Response:
def _date_range(self, granularity, since, to=None):
        """Returns a generator that yields ``datetime.datetime`` objects from
        the ``since`` date until ``to`` (default: *now*).

        * ``granularity`` -- The granularity at which the generated datetime
          objects should be created: seconds, minutes, hourly, daily, weekly,
          monthly, or yearly
        * ``since`` -- a ``datetime.datetime`` object, from which we start
          generating periods of time. This can also be ``None``, and will
          default to the past 7 days if that's the case.
        * ``to`` -- a ``datetime.datetime`` object, from which we start
          generating periods of time. This can also be ``None``, and will
          default to now if that's the case.

        If ``granularity`` is one of daily, weekly, monthly, or yearly, this
        function gives objects at the daily level.

        If ``granularity`` is one of the following, the number of datetime
        objects returned is capped, otherwise this code is really slow and
        probably generates more data than we want:

            * hourly: returns at most 720 values (~30 days)
            * minutes: returns at most 480 values (8 hours)
            * second: returns at most 300 values (5 minutes)

        For example, if granularity is "seconds", we'll receive datetime
        objects that differ by 1 second each.

        """
        if since is None:
            since = datetime.utcnow() - timedelta(days=7)  # Default to 7 days

        if to is None:
            to = datetime.utcnow()
        elapsed = (to - since)

        # Figure out how many units to generate for the elapsed time.
        # I'm going to use `granularity` as a keyword parameter to timedelta,
        # so I need to change the wording for hours and anything > days.
        if granularity == "seconds":
            units = elapsed.total_seconds()
            units = 300 if units > 300 else units
        elif granularity == "minutes":
            units = elapsed.total_seconds() / 60
            units = 480 if units > 480 else units
        elif granularity == "hourly":
            granularity = "hours"
            units = elapsed.total_seconds() / 3600
            units = 720 if units > 720 else units
        else:
            granularity = "days"
            units = elapsed.days + 1

        return (to - timedelta(**{granularity: u}) for u in range(int(units)))


Instruction:
Can you write a function in Python 3 where it
returns a set of the metric slugs for the given category

Response:
def _category_slugs(self, category):
        """Returns a set of the metric slugs for the given category"""
        key = self._category_key(category)
        slugs = self.r.smembers(key)
        return slugs


Instruction:
Can you tell what is the following Python 3 function doing
def _categorize(self, slug, category):
        key = self._category_key(category)
        self.r.sadd(key, slug)

        # Store all category names in a Redis set, for easy retrieval
        self.r.sadd(self._categories_key, category)

Response: Add the slug to the category.


Instruction:
Write a Python 3 script for
returning a generator of all possible granularities based on the MIN_GRANULARITY and MAX_GRANULARITY settings.

Response:
def _granularities(self):
        """Returns a generator of all possible granularities based on the
        MIN_GRANULARITY and MAX_GRANULARITY settings.
        """
        keep = False
        for g in GRANULARITIES:
            if g == app_settings.MIN_GRANULARITY and not keep:
                keep = True
            elif g == app_settings.MAX_GRANULARITY and keep:
                keep = False
                yield g
            if keep:
                yield g


Instruction:
Can you write a function in Python 3 where it
builds an OrderedDict of metric keys and patterns for the given slug and date.

Response:
def _build_key_patterns(self, slug, date):
        """Builds an OrderedDict of metric keys and patterns for the given slug
        and date."""
        # we want to keep the order, from smallest to largest granularity
        patts = OrderedDict()
        metric_key_patterns = self._metric_key_patterns()
        for g in self._granularities():
            date_string = date.strftime(metric_key_patterns[g]["date_format"])
            patts[g] = metric_key_patterns[g]["key"].format(slug, date_string)
        return patts


Instruction:
Can you create a Python 3 function that
builds the redis keys used to store metrics.

Response:
def _build_keys(self, slug, date=None, granularity='all'):
        """Builds redis keys used to store metrics.

        * ``slug`` -- a slug used for a metric, e.g. "user-signups"
        * ``date`` -- (optional) A ``datetime.datetime`` object used to
          generate the time period for the metric. If omitted, the current date
          and time (in UTC) will be used.
        * ``granularity`` -- Must be one of: "all" (default), "yearly",
        "monthly", "weekly", "daily", "hourly", "minutes", or "seconds".

        Returns a list of strings.

        """
        slug = slugify(slug)  # Ensure slugs have a consistent format
        if date is None:
            date = datetime.utcnow()
        patts = self._build_key_patterns(slug, date)
        if granularity == "all":
            return list(patts.values())
        return [patts[granularity]]


Instruction:
Write a Python 3 function that can
return a dictionary of metrics data indexed by category.

Response:
def metric_slugs_by_category(self):
        """Return a dictionary of metrics data indexed by category:

            {<category_name>: set(<slug1>, <slug2>, ...)}

        """
        result = OrderedDict()
        categories = sorted(self.r.smembers(self._categories_key))
        for category in categories:
            result[category] = self._category_slugs(category)

        # We also need to see the uncategorized metric slugs, so need some way
        # to check which slugs are not already stored.
        categorized_metrics = set([  # Flatten the list of metrics
            slug for sublist in result.values() for slug in sublist
        ])
        f = lambda slug: slug not in categorized_metrics
        uncategorized = list(set(filter(f, self.metric_slugs())))
        if len(uncategorized) > 0:
            result['Uncategorized'] = uncategorized
        return result


Instruction:
Can you implement a function in Python 3 that
removes all keys for the given slug from the set of available metrics.

Response:
def delete_metric(self, slug):
        """Removes all keys for the given ``slug``."""

        # To remove all keys for a slug, I need to retrieve them all from
        # the set of metric keys, This uses the redis "keys" command, which is
        # inefficient, but this shouldn't be used all that often.
        prefix = "m:{0}:*".format(slug)
        keys = self.r.keys(prefix)
        self.r.delete(*keys)  # Remove the metric data

        # Finally, remove the slug from the set
        self.r.srem(self._metric_slugs_key, slug)


Instruction:
Given the following Python 3 function, write the documentation
def set_metric(self, slug, value, category=None, expire=None, date=None):
        keys = self._build_keys(slug, date=date)

        # Add the slug to the set of metric slugs
        self.r.sadd(self._metric_slugs_key, slug)

        # Construct a dictionary of key/values for use with mset
        data = {}
        for k in keys:
            data[k] = value
        self.r.mset(data)

        # Add the category if applicable.
        if category:
            self._categorize(slug, category)

        # Expire the Metric in ``expire`` seconds if applicable.
        if expire:
            for k in keys:
                self.r.expire(k, expire)

Response: Assigns a specific value to the current metric.


Instruction:
Here you have a function in Python 3, explain what it does
def metric(self, slug, num=1, category=None, expire=None, date=None):
        # Add the slug to the set of metric slugs
        self.r.sadd(self._metric_slugs_key, slug)

        if category:
            self._categorize(slug, category)

        # Increment keys. NOTE: current redis-py (2.7.2) doesn't include an
        # incrby method; .incr accepts a second ``amount`` parameter.
        keys = self._build_keys(slug, date=date)

        # Use a pipeline to speed up incrementing multiple keys
        pipe = self.r.pipeline()
        for key in keys:
            pipe.incr(key, num)
            if expire:
                pipe.expire(key, expire)
        pipe.execute()

Response: Records a metric in Redis.


Instruction:
Write a Python 3 function that can
get the current values for a metric.

Response:
def get_metric(self, slug):
        """Get the current values for a metric.

        Returns a dictionary with metric values accumulated for the seconds,
        minutes, hours, day, week, month, and year.

        """
        results = OrderedDict()
        granularities = self._granularities()
        keys = self._build_keys(slug)
        for granularity, key in zip(granularities, keys):
            results[granularity] = self.r.get(key)
        return results


Instruction:
Explain what the following Python 3 code does
def get_metrics(self, slug_list):
        # meh. I should have been consistent here, but I'm lazy, so support these
        # value names instead of granularity names, but respect the min/max
        # granularity settings.
        keys = ['seconds', 'minutes', 'hours', 'day', 'week', 'month', 'year']
        key_mapping = {gran: key for gran, key in zip(GRANULARITIES, keys)}
        keys = [key_mapping[gran] for gran in self._granularities()]

        results = []
        for slug in slug_list:
            metrics = self.r.mget(*self._build_keys(slug))
            if any(metrics):  # Only if we have data.
                results.append((slug, dict(zip(keys, metrics))))
        return results

Response: Get the metrics for multiple slugs.


Instruction:
Here you have a function in Python 3, explain what it does
def get_category_metrics(self, category):
        slug_list = self._category_slugs(category)
        return self.get_metrics(slug_list)

Response: Get the metrics belonging to the given category


Instruction:
Implement a Python 3 function for
removing the category from Redis. This doesn t touch the metrics ; they simply become uncategorized.

Response:
def delete_category(self, category):
        """Removes the category from Redis. This doesn't touch the metrics;
        they simply become uncategorized."""
        # Remove mapping of metrics-to-category
        category_key = self._category_key(category)
        self.r.delete(category_key)

        # Remove category from Set
        self.r.srem(self._categories_key, category)


Instruction:
Explain what the following Python 3 code does
def reset_category(self, category, metric_slugs):
        key = self._category_key(category)
        if len(metric_slugs) == 0:
            # If there are no metrics, just remove the category
            self.delete_category(category)
        else:
            # Save all the slugs in the category, and save the category name
            self.r.sadd(key, *metric_slugs)
            self.r.sadd(self._categories_key, category)

Response: Resets or creates a category containing a list of metrics.


Instruction:
How would you code a function in Python 3 to
get the history for one or more metrics.

Response:
def get_metric_history(self, slugs, since=None, to=None, granularity='daily'):
        """Get history for one or more metrics.

        * ``slugs`` -- a slug OR a list of slugs
        * ``since`` -- the date from which we start pulling metrics
        * ``to`` -- the date until which we start pulling metrics
        * ``granularity`` -- seconds, minutes, hourly,
                             daily, weekly, monthly, yearly

        Returns a list of tuples containing the Redis key and the associated
        metric::

            r = R()
            r.get_metric_history('test', granularity='weekly')
            [
                ('m:test:w:2012-52', '15'),
            ]

        To get history for multiple metrics, just provide a list of slugs::

            metrics = ['test', 'other']
            r.get_metric_history(metrics, granularity='weekly')
            [
                ('m:test:w:2012-52', '15'),
                ('m:other:w:2012-52', '42'),
            ]

        """
        if not type(slugs) == list:
            slugs = [slugs]

        # Build the set of Redis keys that we need to get.
        keys = []
        for slug in slugs:
            for date in self._date_range(granularity, since, to):
                keys += self._build_keys(slug, date, granularity)
        keys = list(dedupe(keys))

        # Fetch our data, replacing any None-values with zeros
        results = [0 if v is None else v for v in self.r.mget(keys)]
        results = zip(keys, results)
        return sorted(results, key=lambda t: t[0])


Instruction:
Write a Python 3 function that can
return a list of lists of all the keys in the system that are in the same format as the ones in the system.

Response:
def get_metric_history_as_columns(self, slugs, since=None,
                                      granularity='daily'):
        """Provides the same data as ``get_metric_history``, but in a columnar
        format. If you had the following yearly history, for example::

            [
                ('m:bar:y:2012', '1'),
                ('m:bar:y:2013', '2'),
                ('m:foo:y:2012', '3'),
                ('m:foo:y:2013', '4')
            ]

        this method would provide you with the following data structure::

            [
                ['Period',  'bar',  'foo']
                ['y:2012',  '1',    '3'],
                ['y:2013',  '2',    '4'],
            ]

        Note that this also includes a header column. Data in this format may
        be useful for certain graphing libraries (I'm looking at you Google
        Charts LineChart).

        """
        history = self.get_metric_history(slugs, since, granularity=granularity)
        _history = []  # new, columnar history
        periods = ['Period']  # A separate, single column for the time period
        for s in slugs:
            column = [s]  # story all the data for a single slug
            for key, value in history:
                # ``metric_slug`` extracts the slug from the Redis Key
                if template_tags.metric_slug(key) == s:
                    column.append(value)

                # Get time period value as first column; This value is
                # duplicated in the Redis key for each value, so this is a bit
                # inefficient, but... oh well.
                period = template_tags.strip_metric_prefix(key)
                if period not in periods:
                    periods.append(period)

            _history.append(column)  # Remember that slug's column of data

        # Finally, stick the time periods in the first column.
        _history.insert(0, periods)
        return list(zip(*_history))


Instruction:
Implement a Python 3 function for
returning a dict that can be used to plot the metrics for a specific set of slugs.

Response:
def get_metric_history_chart_data(self, slugs, since=None, granularity='daily'):
        """Provides the same data as ``get_metric_history``, but with metrics
        data arranged in a format that's easy to plot with Chart.js. If you had
        the following yearly history, for example::

            [
                ('m:bar:y:2012', '1'),
                ('m:bar:y:2013', '2'),
                ('m:bar:y:2014', '3'),
                ('m:foo:y:2012', '4'),
                ('m:foo:y:2013', '5')
                ('m:foo:y:2014', '6')
            ]

        this method would provide you with the following data structure::

            'periods': ['y:2012', 'y:2013', 'y:2014']
            'data': [
              {
                'slug': 'bar',
                'values': [1, 2, 3]
              },
              {
                'slug': 'foo',
                'values': [4, 5, 6]
              },
            ]

        """
        slugs = sorted(slugs)
        history = self.get_metric_history(slugs, since, granularity=granularity)

        # Convert the history into an intermediate data structure organized
        # by periods. Since the history is sorted by key (which includes both
        # the slug and the date, the values should be ordered correctly.
        periods = []
        data = OrderedDict()
        for k, v in history:
            period = template_tags.strip_metric_prefix(k)
            if period not in periods:
                periods.append(period)

            slug = template_tags.metric_slug(k)
            if slug not in data:
                data[slug] = []
            data[slug].append(v)

        # Now, reorganize data for our end result.
        metrics = {'periods': periods, 'data': []}
        for slug, values in data.items():
            metrics['data'].append({
                'slug': slug,
                'values': values
            })

        return metrics


Instruction:
Can you tell what is the following Python 3 function doing
def gauge(self, slug, current_value):
        k = self._gauge_key(slug)
        self.r.sadd(self._gauge_slugs_key, slug)  # keep track of all Gauges
        self.r.set(k, current_value)

Response: Set the value for a Gauge.


Instruction:
Write a Python 3 script for
removing all gauges with the given slug.

Response:
def delete_gauge(self, slug):
        """Removes all gauges with the given ``slug``."""
        key = self._gauge_key(slug)
        self.r.delete(key)  # Remove the Gauge
        self.r.srem(self._gauge_slugs_key, slug)


Instruction:
Create a Python 3 function for
rendering a template with a menu to view a metric or metrics for a given number of years.

Response:
def metrics_since(slugs, years, link_type="detail", granularity=None):
    """Renders a template with a menu to view a metric (or metrics) for a
    given number of years.

    * ``slugs`` -- A Slug or a set/list of slugs
    * ``years`` -- Number of years to show past metrics
    * ``link_type`` -- What type of chart do we want ("history" or "aggregate")
        * history  -- use when displaying a single metric's history
        * aggregate -- use when displaying aggregate metric history
    * ``granularity`` -- For "history" only; show the metric's granularity;
      default is "daily"

    """
    now = datetime.utcnow()

    # Determine if we're looking at one slug or multiple slugs
    if type(slugs) in [list, set]:
        slugs = "+".join(s.lower().strip() for s in slugs)

    # Set the default granularity if it's omitted
    granularity = granularity.lower().strip() if granularity else "daily"

    # Each item is: (slug, since, text, granularity)
    # Always include values for Today, 1 week, 30 days, 60 days, 90 days...
    slug_values = [
        (slugs, now - timedelta(days=1), "Today", granularity),
        (slugs, now - timedelta(days=7), "1 Week", granularity),
        (slugs, now - timedelta(days=30), "30 Days", granularity),
        (slugs, now - timedelta(days=60), "60 Days", granularity),
        (slugs, now - timedelta(days=90), "90 Days", granularity),
    ]

    # Then an additional number of years
    for y in range(1, years + 1):
        t = now - timedelta(days=365 * y)
        text = "{0} Years".format(y)
        slug_values.append((slugs, t, text, granularity))
    return {'slug_values': slug_values, 'link_type': link_type.lower().strip()}


Instruction:
How would you code a function in Python 3 to
include a Donut Chart for the specified Gauge.

Response:
def gauge(slug, maximum=9000, size=200, coerce='float'):
    """Include a Donut Chart for the specified Gauge.

    * ``slug`` -- the unique slug for the Gauge.
    * ``maximum`` -- The maximum value for the gauge (default is 9000)
    * ``size`` -- The size (in pixels) of the gauge (default is 200)
    * ``coerce`` -- type to which gauge values should be coerced. The default
      is float. Use ``{% gauge some_slug coerce='int' %}`` to coerce to integer

    """
    coerce_options = {'float': float, 'int': int, 'str': str}
    coerce = coerce_options.get(coerce, float)

    redis = get_r()
    value = coerce(redis.get_gauge(slug))
    if value < maximum and coerce == float:
        diff = round(maximum - value, 2)
    elif value < maximum:
        diff = maximum - value
    else:
        diff = 0

    return {
        'slug': slug,
        'current_value': value,
        'max_value': maximum,
        'size': size,
        'diff': diff,
    }


Instruction:
Create a Python 3 function to
template Tag to display a metric s current detail.

Response:
def metric_detail(slug, with_data_table=False):
    """Template Tag to display a metric's *current* detail.

    * ``slug`` -- the metric's unique slug
    * ``with_data_table`` -- if True, prints the raw data in a table.

    """
    r = get_r()
    granularities = list(r._granularities())
    metrics = r.get_metric(slug)
    metrics_data = []
    for g in granularities:
        metrics_data.append((g, metrics[g]))

    return {
        'granularities': [g.title() for g in granularities],
        'slug': slug,
        'metrics': metrics_data,
        'with_data_table': with_data_table,
    }


Instruction:
Given the following Python 3 function, write the documentation
def metric_history(slug, granularity="daily", since=None, to=None,
                   with_data_table=False):
    """Template Tag to display a metric's history.

    * ``slug`` -- the metric's unique slug
    * ``granularity`` -- the granularity: daily, hourly, weekly, monthly, yearly
    * ``since`` -- a datetime object or a string string matching one of the
      following patterns: "YYYY-mm-dd" for a date or "YYYY-mm-dd HH:MM:SS" for
      a date & time.
    * ``to`` -- the date until which we start pulling metrics
    * ``with_data_table`` -- if True, prints the raw data in a table.

    """
    r = get_r()
    try:
        if since and len(since) == 10:  # yyyy-mm-dd
            since = datetime.strptime(since, "%Y-%m-%d")
        elif since and len(since) == 19:  # yyyy-mm-dd HH:MM:ss
            since = datetime.strptime(since, "%Y-%m-%d %H:%M:%S")

        if to and len(to) == 10:  # yyyy-mm-dd
            to = datetime.strptime(since, "%Y-%m-%d")
        elif to and len(to) == 19:  # yyyy-mm-dd HH:MM:ss
            to = datetime.strptime(to, "%Y-%m-%d %H:%M:%S")

    except (TypeError, ValueError):
        # assume we got a datetime object or leave since = None
        pass

    metric_history = r.get_metric_history(
        slugs=slug,
        since=since,
        to=to,
        granularity=granularity
    )

    return {
        'since': since,
        'to': to,
        'slug': slug,
        'granularity': granularity,
        'metric_history': metric_history,
        'with_data_table': with_data_table,
    }

Response: Return a template tag that displays a metric s history.


Instruction:
Can you implement a function in Python 3 that
returns a dict that can be used to display multiple metrics in a single page.

Response:
def aggregate_detail(slug_list, with_data_table=False):
    """Template Tag to display multiple metrics.

    * ``slug_list`` -- A list of slugs to display
    * ``with_data_table`` -- if True, prints the raw data in a table.

    """
    r = get_r()
    metrics_data = []
    granularities = r._granularities()

    # XXX converting granularties into their key-name for metrics.
    keys = ['seconds', 'minutes', 'hours', 'day', 'week', 'month', 'year']
    key_mapping = {gran: key for gran, key in zip(GRANULARITIES, keys)}
    keys = [key_mapping[gran] for gran in granularities]

    # Our metrics data is of the form:
    #
    #   (slug, {time_period: value, ... }).
    #
    # Let's convert this to (slug, list_of_values) so that the list of
    # values is in the same order as the granularties
    for slug, data in r.get_metrics(slug_list):
        values = [data[t] for t in keys]
        metrics_data.append((slug, values))

    return {
        'chart_id': "metric-aggregate-{0}".format("-".join(slug_list)),
        'slugs': slug_list,
        'metrics': metrics_data,
        'with_data_table': with_data_table,
        'granularities': [g.title() for g in keys],
    }


Instruction:
Can you implement a function in Python 3 that
returns a dictionary of data for the given list of metric slugs.

Response:
def aggregate_history(slugs, granularity="daily", since=None, with_data_table=False):
    """Template Tag to display history for multiple metrics.

    * ``slug_list`` -- A list of slugs to display
    * ``granularity`` -- the granularity: seconds, minutes, hourly,
                         daily, weekly, monthly, yearly
    * ``since`` -- a datetime object or a string string matching one of the
      following patterns: "YYYY-mm-dd" for a date or "YYYY-mm-dd HH:MM:SS" for
      a date & time.
    * ``with_data_table`` -- if True, prints the raw data in a table.

    """
    r = get_r()
    slugs = list(slugs)

    try:
        if since and len(since) == 10:  # yyyy-mm-dd
            since = datetime.strptime(since, "%Y-%m-%d")
        elif since and len(since) == 19:  # yyyy-mm-dd HH:MM:ss
            since = datetime.strptime(since, "%Y-%m-%d %H:%M:%S")
    except (TypeError, ValueError):
        # assume we got a datetime object or leave since = None
        pass

    history = r.get_metric_history_chart_data(
        slugs=slugs,
        since=since,
        granularity=granularity
    )

    return {
        'chart_id': "metric-aggregate-history-{0}".format("-".join(slugs)),
        'slugs': slugs,
        'since': since,
        'granularity': granularity,
        'metric_history': history,
        'with_data_table': with_data_table,
    }


Instruction:
Can you tell what is the following Python 3 function doing
def user_func(func, arg_types=None, return_type=None):
    class UserFunction(std_core.TypedFunction):
        name = func.__name__

        def __call__(self, *args, **kwargs):
            return func(*args, **kwargs)

        @classmethod
        def reflect_static_args(cls):
            return arg_types

        @classmethod
        def reflect_static_return(cls):
            return return_type

    return UserFunction()

Response: Create an EFILTER - callable version of function func.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def infer(query, replacements=None, root_type=None,
          libs=("stdcore", "stdmath")):
    """Determine the type of the query's output without actually running it.

    Arguments:
        query: A query object or string with the query.
        replacements: Built-time parameters to the query, either as dict or as
            an array (for positional interpolation).
        root_type: The types of variables to be supplied to the query inference.
        libs: What standard libraries should be taken into account for the
            inference.

    Returns:
        The type of the query's output, if it can be determined. If undecidable,
        returns efilter.protocol.AnyType.

        NOTE: The inference returns the type of a row in the results, not of the
        actual Python object returned by 'apply'. For example, if a query
        returns multiple rows, each one of which is an integer, the type of the
        output is considered to be int, not a collection of rows.

    Examples:
        infer("5 + 5") # -> INumber

        infer("SELECT * FROM people WHERE age > 10") # -> AnyType

        # If root_type implements the IStructured reflection API:
        infer("SELECT * FROM people WHERE age > 10", root_type=...) # -> dict
    """
    # Always make the scope stack start with stdcore.
    if root_type:
        type_scope = scope.ScopeStack(std_core.MODULE, root_type)
    else:
        type_scope = scope.ScopeStack(std_core.MODULE)

    stdcore_included = False
    for lib in libs:
        if lib == "stdcore":
            stdcore_included = True
            continue

        module = std_core.LibraryModule.ALL_MODULES.get(lib)
        if not module:
            raise TypeError("No standard library module %r." % lib)

        type_scope = scope.ScopeStack(module, type_scope)

    if not stdcore_included:
        raise TypeError("'stdcore' must always be included.")

    query = q.Query(query, params=replacements)
    return infer_type.infer_type(query, type_scope)

Response: Infer the type of the query s output without actually running it.


Instruction:
Create a Python 3 function for
yielding objects from data that match the query.

Response:
def search(query, data, replacements=None):
    """Yield objects from 'data' that match the 'query'."""
    query = q.Query(query, params=replacements)
    for entry in data:
        if solve.solve(query, entry).value:
            yield entry


Instruction:
Can you generate a brief explanation for the following Python 3 code
def peek(self, steps=1):
        try:
            tokens = iter(self)
            for _ in six.moves.range(steps):
                next(tokens)

            return next(tokens)
        except StopIteration:
            return None

Response: Look ahead and return the next token.


Instruction:
Implement a Python 3 function for
skipping ahead by steps tokens.

Response:
def skip(self, steps=1):
        """Skip ahead by 'steps' tokens."""
        for _ in six.moves.range(steps):
            self.next_token()


Instruction:
Explain what the following Python 3 code does
def next_token(self):
        if self.lookahead:
            self.current_token = self.lookahead.popleft()
            return self.current_token

        self.current_token = self._parse_next_token()
        return self.current_token

Response: Returns the next logical token advancing the tokenizer.


Instruction:
Here you have a function in Python 3, explain what it does
def _next_pattern(self):
        current_state = self.state_stack[-1]
        position = self._position
        for pattern in self.patterns:
            if current_state not in pattern.states:
                continue

            m = pattern.regex.match(self.source, position)
            if not m:
                continue

            position = m.end()
            token = None

            if pattern.next_state:
                self.state_stack.append(pattern.next_state)

            if pattern.action:
                callback = getattr(self, pattern.action, None)
                if callback is None:
                    raise RuntimeError(
                        "No method defined for pattern action %s!" %
                        pattern.action)

                if "token" in m.groups():
                    value = m.group("token")
                else:
                    value = m.group(0)
                token = callback(string=value, match=m,
                                 pattern=pattern)

            self._position = position

            return token

        self._error("Don't know how to match next. Did you forget quotes?",
                    start=self._position, end=self._position + 1)

Response: Parses the next pattern by matching each in turn.


Instruction:
Explain what the following Python 3 code does
def _error(self, message, start, end=None):
        raise errors.EfilterParseError(
            source=self.source, start=start, end=end, message=message)

Response: Raise a nice error with the token highlighted.


Instruction:
Can you generate the documentation for the following Python 3 function
def emit(self, string, match, pattern, **_):
        return grammar.Token(name=pattern.name, value=string,
                             start=match.start(), end=match.end())

Response: Emits a token using the current pattern match and pattern label.


Instruction:
Write a Python 3 function for
getting version string by parsing PKG - INFO file.

Response:
def get_pkg_version():
    """Get version string by parsing PKG-INFO."""
    try:
        with open("PKG-INFO", "r") as fp:
            rgx = re.compile(r"Version: (\d+)")
            for line in fp.readlines():
                match = rgx.match(line)
                if match:
                    return match.group(1)
    except IOError:
        return None


Instruction:
Write a Python 3 function for
generating a version string from git commits.

Response:
def get_version(dev_version=False):
    """Generates a version string.

    Arguments:
        dev_version: Generate a verbose development version from git commits.

    Examples:
        1.1
        1.1.dev43 # If 'dev_version' was passed.
    """
    if dev_version:
        version = git_dev_version()
        if not version:
            raise RuntimeError("Could not generate dev version from git.")

        return version

    return "1!%d.%d" % (MAJOR, MINOR)


Instruction:
Given the following Python 3 function, write the documentation
def _heartbeat(self):

        try:

            self._prof.prof('heartbeat thread started', uid=self._uid)

            mq_connection = pika.BlockingConnection(pika.ConnectionParameters(host=self._mq_hostname, port=self._port))
            mq_channel = mq_connection.channel()

            response = True
            while (response and (not self._hb_terminate.is_set())):
                response = False
                corr_id = str(uuid.uuid4())

                # Heartbeat request signal sent to task manager via rpc-queue
                mq_channel.basic_publish(exchange='',
                                         routing_key=self._hb_request_q,
                                         properties=pika.BasicProperties(
                                             reply_to=self._hb_response_q,
                                             correlation_id=corr_id),
                                         body='request')
                self._logger.info('Sent heartbeat request')

                # mq_connection.close()

                # Sleep for hb_interval and then check if tmgr responded
                mq_connection.sleep(self._hb_interval)

                # mq_connection = pika.BlockingConnection(
                #     pika.ConnectionParameters(host=self._mq_hostname, port=self._port))
                # mq_channel = mq_connection.channel()

                method_frame, props, body = mq_channel.basic_get(queue=self._hb_response_q)

                if body:
                    if corr_id == props.correlation_id:
                        self._logger.info('Received heartbeat response')
                        response = True

                        mq_channel.basic_ack(delivery_tag=method_frame.delivery_tag)

                # Appease pika cos it thinks the connection is dead
                # mq_connection.close()

        except KeyboardInterrupt:
            self._logger.exception('Execution interrupted by user (you probably hit Ctrl+C), ' +
                               'trying to cancel tmgr process gracefully...')
            raise KeyboardInterrupt

        except Exception as ex:
            self._logger.exception('Heartbeat failed with error: %s' % ex)
            raise

        finally:

            try:
                mq_connection.close()
            except:
                self._logger.warning('mq_connection not created')

            self._prof.prof('terminating heartbeat thread', uid=self._uid)

Response: This method is executed in the heartbeat thread. It sends a request to the heartbeat - req queue and receives a response from the heartbeat - res queue.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def start_heartbeat(self):

        if not self._hb_thread:

            try:

                self._logger.info('Starting heartbeat thread')
                self._prof.prof('creating heartbeat thread', uid=self._uid)
                self._hb_terminate = threading.Event()
                self._hb_thread = threading.Thread(target=self._heartbeat, name='heartbeat')

                self._prof.prof('starting heartbeat thread', uid=self._uid)
                self._hb_thread.start()

                return True

            except Exception, ex:

                self._logger.exception('Heartbeat not started, error: %s' % ex)
                self.terminate_heartbeat()
                raise

        else:
            self._logger.warn('Heartbeat thread already running, but attempted to restart!')

Response: Start the heartbeat thread.


Instruction:
Given the following Python 3 function, write the documentation
def terminate_heartbeat(self):

        try:

            if self._hb_thread:

                self._hb_terminate.set()

                if self.check_heartbeat():
                    self._hb_thread.join()

                self._hb_thread = None

                self._logger.info('Hearbeat thread terminated')

                self._prof.prof('heartbeat thread terminated', uid=self._uid)

                # We close in the heartbeat because it ends after the tmgr process
                self._prof.close()

        except Exception, ex:
            self._logger.exception('Could not terminate heartbeat thread')
            raise

        finally:

            if not (self.check_heartbeat() or self.check_manager()):

                mq_connection = pika.BlockingConnection(pika.ConnectionParameters(host=self._mq_hostname, port=self._port))
                mq_channel = mq_connection.channel()

                # To respond to heartbeat - get request from rpc_queue
                mq_channel.queue_delete(queue=self._hb_response_q)
                mq_channel.queue_delete(queue=self._hb_request_q)

                mq_connection.close()

Response: This method terminate the heartbeat thread.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def terminate_manager(self):

        try:

            if self._tmgr_process:

                if not self._tmgr_terminate.is_set():
                    self._tmgr_terminate.set()

                if self.check_manager():
                    self._tmgr_process.join()

                self._tmgr_process = None
                self._logger.info('Task manager process closed')

                self._prof.prof('tmgr process terminated', uid=self._uid)

        except Exception, ex:
            self._logger.exception('Could not terminate task manager process')
            raise

Response: Terminate the tmgr process.


Instruction:
Given the following Python 3 function, write the documentation
def getvalues(self):
        idx = 0
        generator = self._generator_func()
        first_value = next(generator)
        self._value_type = type(first_value)
        yield first_value

        for idx, value in enumerate(generator):
            if not isinstance(value, self._value_type):
                raise TypeError(
                    "All values of a repeated var must be of the same type."
                    " First argument was of type %r, but argument %r is of"
                    " type %r." %
                    (self._value_type, value, repeated.value_type(value)))

            self._watermark = max(self._watermark, idx + 1)
            yield value

        # Iteration stopped - check if we're at the previous watermark and raise
        # if not.
        if idx + 1 < self._watermark:
            raise ValueError(
                "LazyRepetition %r was previously able to iterate its"
                " generator up to idx %d, but this time iteration stopped after"
                " idx %d! Generator function %r is not stable." %
                (self, self._watermark, idx + 1, self._generator_func))

        # Watermark is higher than previous count! Generator function returned
        # more values this time than last time.
        if self._count is not None and self._watermark >= self._count:
            raise ValueError(
                "LazyRepetition %r previously iterated only up to idx %d but"
                " was now able to reach idx %d! Generator function %r is not"
                " stable." %
                (self, self._count - 1, idx + 1, self._generator_func))

        # We've finished iteration - cache count. After this the count will be
        # watermark + 1 forever.
        self._count = self._watermark + 1

Response: Yields all the values from the generator_func and type - checks.


Instruction:
Explain what the following Python 3 code does
def value_eq(self, other):
        self_sorted = ordered.ordered(self.getvalues())
        other_sorted = ordered.ordered(repeated.getvalues(other))
        return self_sorted == other_sorted

Response: Sorted comparison of values.


Instruction:
Can you write a function in Python 3 where it
prints a detailed audit of all calls to this function.

Response:
def call_audit(func):
    """Print a detailed audit of all calls to this function."""
    def audited_func(*args, **kwargs):
        import traceback
        stack = traceback.extract_stack()
        r = func(*args, **kwargs)
        func_name = func.__name__

        print("@depth %d, trace %s -> %s(*%r, **%r) => %r" % (
            len(stack),
            " -> ".join("%s:%d:%s" % x[0:3] for x in stack[-5:-2]),
            func_name,
            args,
            kwargs,
            r))
        return r

    return audited_func


Instruction:
Can you tell what is the following Python 3 function doing
def prefer_type(self, prefer, over):
        self._write_lock.acquire()
        try:
            if self._preferred(preferred=over, over=prefer):
                raise ValueError(
                    "Type %r is already preferred over %r." % (over, prefer))
            prefs = self._prefer_table.setdefault(prefer, set())
            prefs.add(over)
        finally:
            self._write_lock.release()

Response: Prefer one type over another type.


Instruction:
Implement a function in Python 3 to
find the best implementation of this function given a type.

Response:
def _find_and_cache_best_function(self, dispatch_type):
        """Finds the best implementation of this function given a type.

        This function caches the result, and uses locking for thread safety.

        Returns:
            Implementing function, in below order of preference:
            1. Explicitly registered implementations (through
               multimethod.implement) for types that 'dispatch_type' either is
               or inherits from directly.
            2. Explicitly registered implementations accepting an abstract type
               (interface) in which dispatch_type participates (through
               abstract_type.register() or the convenience methods).
            3. Default behavior of the multimethod function. This will usually
               raise a NotImplementedError, by convention.

        Raises:
            TypeError: If two implementing functions are registered for
                different abstract types, and 'dispatch_type' participates in
                both, and no order of preference was specified using
                prefer_type.
        """
        result = self._dispatch_table.get(dispatch_type)
        if result:
            return result

        # The outer try ensures the lock is always released.
        with self._write_lock:
            try:
                dispatch_mro = dispatch_type.mro()
            except TypeError:
                # Not every type has an MRO.
                dispatch_mro = ()

            best_match = None
            result_type = None

            for candidate_type, candidate_func in self.implementations:
                if not issubclass(dispatch_type, candidate_type):
                    # Skip implementations that are obviously unrelated.
                    continue

                try:
                    # The candidate implementation may be for a type that's
                    # actually in the MRO, or it may be for an abstract type.
                    match = dispatch_mro.index(candidate_type)
                except ValueError:
                    # This means we have an implementation for an abstract
                    # type, which ranks below all concrete types.
                    match = None

                if best_match is None:
                    if result and match is None:
                        # Already have a result, and no order of preference.
                        # This is probably because the type is a member of two
                        # abstract types and we have separate implementations
                        # for those two abstract types.

                        if self._preferred(candidate_type, over=result_type):
                            result = candidate_func
                            result_type = candidate_type
                        elif self._preferred(result_type, over=candidate_type):
                            # No need to update anything.
                            pass
                        else:
                            raise TypeError(
                                "Two candidate implementations found for "
                                "multimethod function %s (dispatch type %s) "
                                "and neither is preferred." %
                                (self.func_name, dispatch_type))
                    else:
                        result = candidate_func
                        result_type = candidate_type
                        best_match = match

                if (match or 0) < (best_match or 0):
                    result = candidate_func
                    result_type = candidate_type
                    best_match = match

            self._dispatch_table[dispatch_type] = result
            return result


Instruction:
Create a Python 3 function for
parsing the arguments and return a tuple of types to implement for.

Response:
def __get_types(for_type=None, for_types=None):
        """Parse the arguments and return a tuple of types to implement for.

        Raises:
            ValueError or TypeError as appropriate.
        """
        if for_type:
            if for_types:
                raise ValueError("Cannot pass both for_type and for_types.")
            for_types = (for_type,)
        elif for_types:
            if not isinstance(for_types, tuple):
                raise TypeError("for_types must be passed as a tuple of "
                                "types (classes).")
        else:
            raise ValueError("Must pass either for_type or for_types.")

        return for_types


Instruction:
How would you explain what the following Python 3 function does
def implementation(self, for_type=None, for_types=None):
        for_types = self.__get_types(for_type, for_types)

        def _decorator(implementation):
            self.implement(implementation, for_types=for_types)
            return self

        return _decorator

Response: Returns a decorator that will register the implementation.


Instruction:
Can you write a function in Python 3 where it
registers an implementation function for for_type.

Response:
def implement(self, implementation, for_type=None, for_types=None):
        """Registers an implementing function for for_type.

        Arguments:
            implementation: Callable implementation for this type.
            for_type: The type this implementation applies to.
            for_types: Same as for_type, but takes a tuple of types.

            for_type and for_types cannot both be passed (for obvious reasons.)

        Raises:
            ValueError
        """
        unbound_implementation = self.__get_unbound_function(implementation)
        for_types = self.__get_types(for_type, for_types)

        for t in for_types:
            self._write_lock.acquire()
            try:
                self.implementations.append((t, unbound_implementation))
            finally:
                self._write_lock.release()


Instruction:
Given the following Python 3 function, write the documentation
def to_int_list(values):
    results = []
    for v in values:
        try:
            results.append(int(v))
        except (TypeError, ValueError):
            results.append(0)
    return results

Response: Converts the given list of vlues into a list of integers.


Instruction:
How would you code a function in Python 3 to
validate the resource description.

Response:
def _validate_resource_desc(self):
        """
        **Purpose**: Validate the resource description provided to the ResourceManager
        """

        self._prof.prof('validating rdesc', uid=self._uid)
        self._logger.debug('Validating resource description')

        expected_keys = ['resource',
                         'walltime',
                         'cpus']

        for key in expected_keys:
            if key not in self._resource_desc:
                raise MissingError(obj='resource description', missing_attribute=key)

        if not isinstance(self._resource_desc['resource'], str):
            raise TypeError(expected_type=str, actual_type=type(self._resource_desc['resource']))

        if not isinstance(self._resource_desc['walltime'], int):
            raise TypeError(expected_type=int, actual_type=type(self._resource_desc['walltime']))

        if not isinstance(self._resource_desc['cpus'], int):
            raise TypeError(expected_type=int, actual_type=type(self._resource_desc['cpus']))

        if 'gpus' in self._resource_desc:
            if (not isinstance(self._resource_desc['gpus'], int)):
                raise TypeError(expected_type=int, actual_type=type(self._resource_desc['project']))

        if 'project' in self._resource_desc:
            if (not isinstance(self._resource_desc['project'], str)) and (not self._resource_desc['project']):
                raise TypeError(expected_type=str, actual_type=type(self._resource_desc['project']))

        if 'access_schema' in self._resource_desc:
            if not isinstance(self._resource_desc['access_schema'], str):
                raise TypeError(expected_type=str, actual_type=type(self._resource_desc['access_schema']))

        if 'queue' in self._resource_desc:
            if not isinstance(self._resource_desc['queue'], str):
                raise TypeError(expected_type=str, actual_type=type(self._resource_desc['queue']))

        if not isinstance(self._rts_config, dict):
            raise TypeError(expected_type=dict, actual_type=type(self._rts_config))

        self._validated = True

        self._logger.info('Resource description validated')
        self._prof.prof('rdesc validated', uid=self._uid)

        return self._validated


Instruction:
Write a Python 3 script to
populate the object with the validated resource description.

Response:
def _populate(self):
        """
        **Purpose**:    Populate the ResourceManager class with the validated
                        resource description
        """

        if self._validated:

            self._prof.prof('populating rmgr', uid=self._uid)
            self._logger.debug('Populating resource manager object')

            self._resource = self._resource_desc['resource']
            self._walltime = self._resource_desc['walltime']
            self._cpus = self._resource_desc['cpus']
            self._gpus = self._resource_desc.get('gpus', 0)
            self._project = self._resource_desc.get('project', None)
            self._access_schema = self._resource_desc.get('access_schema', None)
            self._queue = self._resource_desc.get('queue', None)

            self._logger.debug('Resource manager population successful')
            self._prof.prof('rmgr populated', uid=self._uid)

        else:
            raise EnTKError('Resource description not validated')


Instruction:
Write a Python 3 script for
including the Gauge slugs and data in the context.

Response:
def get_context_data(self, **kwargs):
        """Includes the Gauge slugs and data in the context."""
        data = super(GaugesView, self).get_context_data(**kwargs)
        data.update({'gauges': get_r().gauge_slugs()})
        return data


Instruction:
Can you generate the documentation for the following Python 3 function
def get_context_data(self, **kwargs):
        data = super(MetricsListView, self).get_context_data(**kwargs)

        # Metrics organized by category, like so:
        # { <category_name>: [ <slug1>, <slug2>, ... ]}
        data.update({'metrics': get_r().metric_slugs_by_category()})
        return data

Response: Includes the metrics slugs in the context.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_context_data(self, **kwargs):
        data = super(MetricDetailView, self).get_context_data(**kwargs)
        data['slug'] = kwargs['slug']
        data['granularities'] = list(get_r()._granularities())
        return data

Response: Includes the metrics slugs in the context.


Instruction:
How would you code a function in Python 3 to
include the metrics slugs in the context.

Response:
def get_context_data(self, **kwargs):
        """Includes the metrics slugs in the context."""
        data = super(MetricHistoryView, self).get_context_data(**kwargs)

        # Accept GET query params for ``since``
        since = self.request.GET.get('since', None)
        if since and len(since) == 10:  # yyyy-mm-dd
            since = datetime.strptime(since, "%Y-%m-%d")
        elif since and len(since) == 19:  # yyyy-mm-dd HH:MM:ss
            since = datetime.strptime(since, "%Y-%m-%d %H:%M:%S")

        data.update({
            'since': since,
            'slug': kwargs['slug'],
            'granularity': kwargs['granularity'],
            'granularities': list(get_r()._granularities()),
        })
        return data


Instruction:
How would you implement a function in Python 3 that
reverses the redis_metric_aggregate_detail URL using self. metric_slugs as an argument.

Response:
def get_success_url(self):
        """Reverses the ``redis_metric_aggregate_detail`` URL using
        ``self.metric_slugs`` as an argument."""
        slugs = '+'.join(self.metric_slugs)
        url = reverse('redis_metric_aggregate_detail', args=[slugs])
        # Django 1.6 quotes reversed URLs, which changes + into %2B. We want
        # want to keep the + in the url (it's ok according to RFC 1738)
        # https://docs.djangoproject.com/en/1.6/releases/1.6/#quoting-in-reverse
        return url.replace("%2B", "+")


Instruction:
Explain what the following Python 3 code does
def form_valid(self, form):
        self.metric_slugs = [k.strip() for k in form.cleaned_data['metrics']]
        return super(AggregateFormView, self).form_valid(form)

Response:
Pull the metrics from the submitted form and store them as a
        list.


Instruction:
Implement a function in Python 3 to
include the metrics slugs in the context.

Response:
def get_context_data(self, **kwargs):
        """Includes the metrics slugs in the context."""
        r = get_r()
        category = kwargs.pop('category', None)
        data = super(AggregateDetailView, self).get_context_data(**kwargs)

        if category:
            slug_set =   r._category_slugs(category)
        else:
            slug_set = set(kwargs['slugs'].split('+'))

        data['granularities'] = list(r._granularities())
        data['slugs'] = slug_set
        data['category'] = category
        return data


Instruction:
Can you implement a function in Python 3 that
includes the metrics slugs in the context.

Response:
def get_context_data(self, **kwargs):
        """Includes the metrics slugs in the context."""
        r = get_r()
        data = super(AggregateHistoryView, self).get_context_data(**kwargs)
        slug_set = set(kwargs['slugs'].split('+'))
        granularity = kwargs.get('granularity', 'daily')

        # Accept GET query params for ``since``
        since = self.request.GET.get('since', None)
        if since and len(since) == 10:  # yyyy-mm-dd
            since = datetime.strptime(since, "%Y-%m-%d")
        elif since and len(since) == 19:  # yyyy-mm-dd HH:MM:ss
            since = datetime.strptime(since, "%Y-%m-%d %H:%M:%S")

        data.update({
            'slugs': slug_set,
            'granularity': granularity,
            'since': since,
            'granularities': list(r._granularities())
        })
        return data


Instruction:
Create a Python 3 function for
seeing if this view was called with a specified category.

Response:
def get(self, *args, **kwargs):
        """See if this view was called with a specified category."""
        self.initial = {"category_name":  kwargs.get('category_name', None)}
        return super(CategoryFormView, self).get(*args, **kwargs)


Instruction:
Given the following Python 3 function, write the documentation
def form_valid(self, form):
        form.categorize_metrics()
        return super(CategoryFormView, self).form_valid(form)

Response:
Update the the
        category so contains the given metrics.


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

        """
        Rerun sets the state of the Pipeline to scheduling so that the Pipeline
        can be checked for new stages
        """

        self._state = states.SCHEDULING
        self._completed_flag = threading.Event()
        print 'Pipeline %s in %s state'%(self._uid, self._state)

Response:
Rerun sets the state of the Pipeline to scheduling so that the Pipeline
        can be checked for new stages


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

        pipeline_desc_as_dict = {

            'uid': self._uid,
            'name': self._name,
            'state': self._state,
            'state_history': self._state_history,
            'completed': self._completed_flag.is_set()
        }

        return pipeline_desc_as_dict

Response: Convert the current Pipeline into a dictionary.


Instruction:
Can you tell what is the following Python 3 function doing
def from_dict(self, d):

        if 'uid' in d:
            if d['uid']:
                self._uid = d['uid']

        if 'name' in d:
            if d['name']:
                self._name = d['name']

        if 'state' in d:
            if isinstance(d['state'], str) or isinstance(d['state'], unicode):
                if d['state'] in states._pipeline_state_values.keys():
                    self._state = d['state']
                else:
                    raise ValueError(obj=self._uid,
                                     attribute='state',
                                     expected_value=states._pipeline_state_values.keys(),
                                     actual_value=d['state'])
            else:
                raise TypeError(entity='state', expected_type=str,
                                actual_type=type(d['state']))

        else:
            self._state = states.INITIAL

        if 'state_history' in d:
            if isinstance(d['state_history'], list):
                self._state_history = d['state_history']
            else:
                raise TypeError(entity='state_history', expected_type=list, actual_type=type(
                    d['state_history']))

        if 'completed' in d:
            if isinstance(d['completed'], bool):
                if d['completed']:
                    self._completed_flag.set()
            else:
                raise TypeError(entity='completed', expected_type=bool,
                                actual_type=type(d['completed']))

Response: Create a new object from a dictionary.


Instruction:
Make a summary of the following Python 3 code
def _increment_stage(self):

        try:

            if self._cur_stage < self._stage_count:
                self._cur_stage += 1
            else:
                self._completed_flag.set()

        except Exception, ex:
            raise EnTKError(text=ex)

Response: Increment the stage pointer.


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

        try:

            if self._cur_stage > 0:
                self._cur_stage -= 1
                self._completed_flag = threading.Event()  # reset

        except Exception, ex:
            raise EnTKError(text=ex)

Response: Decrement the stage pointer.


Instruction:
How would you code a function in Python 3 to
check whether the argument stages is of list of Stage objects.

Response:
def _validate_entities(self, stages):
        """
        Purpose: Validate whether the argument 'stages' is of list of Stage objects

        :argument: list of Stage objects
        """
        if not stages:
            raise TypeError(expected_type=Stage, actual_type=type(stages))

        if not isinstance(stages, list):
            stages = [stages]

        for value in stages:
            if not isinstance(value, Stage):
                raise TypeError(expected_type=Stage, actual_type=type(value))

        return stages


Instruction:
How would you explain what the following Python 3 function does
def _assign_uid(self, sid):
        self._uid = ru.generate_id(
            'pipeline.%(item_counter)04d', ru.ID_CUSTOM, namespace=sid)
        for stage in self._stages:
            stage._assign_uid(sid)

        self._pass_uid()

Response:
Assign a uid to the current object based on the sid passed. Pass the current uid to children of
            current object


Instruction:
How would you explain what the following Python 3 function does
def _pass_uid(self):

        for stage in self._stages:
            stage.parent_pipeline['uid'] = self._uid
            stage.parent_pipeline['name'] = self._name
            stage._pass_uid()

Response: Passes the current Pipeline s uid to all Stages.


Instruction:
How would you implement a function in Python 3 that
extracts YANG model from an IETF RFC or draft text file. This is the main (external) API entry for the module. :param add_line_refs: :param source_id: identifier (file name or URL) of a draft or RFC file containing one or more YANG models :param srcdir: If source_id points to a file, the optional parameter identifies the directory where the file is located :param dstdir: Directory where to put the extracted YANG models :param strict: Strict syntax enforcement :param strict_examples: Only output valid examples when in strict mode :param debug_level: Determines how much debug output is printed to the console :param force_revision_regexp: Whether it should create a <filename>@<revision>.yang even on error using regexp :param force_revision_pyang: Whether it should create a <filename>@<revision>.yang even on error using pyang :return: None

Response:
def xym(source_id, srcdir, dstdir, strict=False, strict_examples=False, debug_level=0, add_line_refs=False,
        force_revision_pyang=False, force_revision_regexp=False):
    """
    Extracts YANG model from an IETF RFC or draft text file.
    This is the main (external) API entry for the module.

    :param add_line_refs:
    :param source_id: identifier (file name or URL) of a draft or RFC file containing
           one or more YANG models
    :param srcdir: If source_id points to a file, the optional parameter identifies
           the directory where the file is located
    :param dstdir: Directory where to put the extracted YANG models
    :param strict: Strict syntax enforcement
    :param strict_examples: Only output valid examples when in strict mode
    :param debug_level: Determines how much debug output is printed to the console
    :param force_revision_regexp: Whether it should create a <filename>@<revision>.yang even on error using regexp
    :param force_revision_pyang: Whether it should create a <filename>@<revision>.yang even on error using pyang
    :return: None
    """

    if force_revision_regexp and force_revision_pyang:
        print('Can not use both methods for parsing name and revision - using regular expression method only')
        force_revision_pyang = False

    url = re.compile(r'^(?:http|ftp)s?://'  # http:// or https://
                     r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|'  # domain
                     r'localhost|'  # localhost...
                     r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'  # ...or ip
                     r'(?::\d+)?'  # optional port
                     r'(?:/?|[/?]\S+)$', re.IGNORECASE)
    rqst_hdrs = {'Accept': 'text/plain', 'Accept-Charset': 'utf-8'}

    ye = YangModuleExtractor(source_id, dstdir, strict, strict_examples, add_line_refs, debug_level)
    is_url = url.match(source_id)
    if is_url:
        r = requests.get(source_id, headers=rqst_hdrs)
        if r.status_code == 200:
            content = r.text.encode('utf8').splitlines(True)
            ye.extract_yang_model(content)
        else:
            print("Failed to fetch file from URL '%s', error '%d'" % (source_id, r.status_code), file=sys.stderr)
    else:
        try:
            with open(os.path.join(srcdir, source_id)) as sf:
                ye.extract_yang_model(sf.readlines())
        except IOError as ioe:
            print(ioe)
    return ye.get_extracted_models(force_revision_pyang, force_revision_regexp)


Instruction:
Explain what the following Python 3 code does
def warning(self, s):
        print("   WARNING: '%s', %s" % (self.src_id, s), file=sys.stderr)

Response: Print a warning message to stderr.


Instruction:
Can you generate the documentation for the following Python 3 function
def error(self, s):
        print("   ERROR: '%s', %s" % (self.src_id, s), file=sys.stderr)

Response: Prints out an error message to stderr.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def remove_leading_spaces(self, input_model):
        leading_spaces = 1024
        output_model = []
        for mline in input_model:
            line = mline[0]
            if line.rstrip(' \r\n') != '':
                leading_spaces = min(leading_spaces, len(line) - len(line.lstrip(' ')))
                output_model.append([line[leading_spaces:], mline[1]])

                line_len = len(line[leading_spaces:])
                if line_len > self.max_line_len:
                    self.max_line_len = line_len
            else:
                output_model.append(['\n', mline[1]])
        return output_model

Response: This function removes leading spaces from YANG model lines.


Instruction:
Make a summary of the following Python 3 code
def add_line_references(self, input_model):
        output_model = []
        for ln in input_model:
            line_len = len(ln[0])
            line_ref = ('// %4d' % ln[1]).rjust((self.max_line_len - line_len + 7), ' ')
            new_line = '%s %s\n' % (ln[0].rstrip(' \r\n\t\f'), line_ref)
            output_model.append([new_line, ln[1]])
        return output_model

Response:
This function adds line numbers to the line number in
                 in the YANG model.


Instruction:
Can you create a Python 3 function that
removes extra empty lines from a YANG model that was extracted by extract_new_line_from_draft or extract_new_line_from_RFC text.

Response:
def remove_extra_empty_lines(self, input_model):
        """
        Removes superfluous newlines from a YANG model that was extracted
        from a draft or RFC text. Newlines are removed whenever 2 or more
        consecutive empty lines are found in the model. This function is a
        part of the model post-processing pipeline.
        :param input_model: The YANG model to be processed
        :return: YANG model with superfluous newlines removed
        """
        ncnt = 0
        output_model = []
        for ln in input_model:
            if ln[0].strip(' \n\r') is '':
                if ncnt is 0:
                    output_model.append(ln)
                elif self.debug_level > 1:
                        self.debug_print_strip_msg(ln[1] - 1, ln[0])
                ncnt += 1
            else:
                output_model.append(ln)
                ncnt = 0
        if self.debug_level > 0:
            print('   Removed %d empty lines' % (len(input_model) - len(output_model)))
        return output_model


Instruction:
Can you generate the documentation for the following Python 3 function
def post_process_model(self, input_model, add_line_refs):
        intermediate_model = self.remove_leading_spaces(input_model)
        intermediate_model = self.remove_extra_empty_lines(intermediate_model)
        if add_line_refs:
            intermediate_model = self.add_line_references(intermediate_model)
        return finalize_model(intermediate_model)

Response: This function is called by the YANG model post - processing pipeline. It is called after the YANG model is processed and the YANG model is written to the module file.


Instruction:
Can you write a function in Python 3 where it
writes YANG model that was extracted from a source identifier to a. YANG destination file.

Response:
def write_model_to_file(self, mdl, fn):
        """
        Write a YANG model that was extracted from a source identifier
        (URL or source .txt file) to a .yang destination file
        :param mdl: YANG model, as a list of lines
        :param fn: Name of the YANG model file
        :return:
        """
        # Write the model to file
        output = ''.join(self.post_process_model(mdl, self.add_line_refs))
        if fn:
            fqfn = self.dst_dir + '/' + fn
            if os.path.isfile(fqfn):
                self.error("File '%s' exists" % fqfn)
                return
            with open(fqfn, 'w') as of:
                of.write(output)
                of.close()
                self.extracted_models.append(fn)
        else:
            self.error("Output file name can not be determined; YANG file not created")


Instruction:
Implement a function in Python 3 to
debug print of the currently parsed line

Response:
def debug_print_line(self, i, level, line):
        """
        Debug print of the currently parsed line
        :param i: The line number of the line that is being currently parsed
        :param level: Parser level
        :param line: the line that is currently being parsed
        :return: None
        """
        if self.debug_level == 2:
            print("Line %d (%d): '%s'" % (i + 1, level, line.rstrip(' \r\n\t\f')))
        if self.debug_level > 2:
            print("Line %d (%d):" % (i + 1, level))
            hexdump(line)


Instruction:
Can you write a function in Python 3 where it
debugs print indicating that an empty line is being skipped

Response:
def debug_print_strip_msg(self, i, line):
        """
        Debug print indicating that an empty line is being skipped
        :param i: The line number of the line that is being currently parsed
        :param line: the parsed line
        :return: None
        """
        if self.debug_level == 2:
            print("     Stripping Line %d: '%s'" % (i + 1, line.rstrip(' \r\n\t\f')))
        elif self.debug_level > 2:
            print("     Stripping Line %d:" % (i + 1))
            hexdump(line)


Instruction:
Implement a function in Python 3 to
skip over empty lines in the parsed text i until the next empty line.

Response:
def strip_empty_lines_forward(self, content, i):
        """
        Skip over empty lines
        :param content: parsed text
        :param i: current parsed line
        :return: number of skipped lined
        """
        while i < len(content):
            line = content[i].strip(' \r\n\t\f')
            if line != '':
                break
            self.debug_print_strip_msg(i, content[i])
            i += 1  # Strip an empty line
        return i


Instruction:
Create a Python 3 function to
strip empty lines preceding the line that is currently being parsed.

Response:
def strip_empty_lines_backward(self, model, max_lines_to_strip):
        """
        Strips empty lines preceding the line that is currently being parsed. This
        fucntion is called when the parser encounters a Footer.
        :param model: lines that were added to the model up to this point
        :param line_num: the number of teh line being parsed
        :param max_lines_to_strip: max number of lines to strip from the model
        :return: None
        """
        for l in range(0, max_lines_to_strip):
            if model[-1][0].strip(' \r\n\t\f') != '':
                return
            self.debug_print_strip_msg(model[-1][1] - 1, model[-1][0])
            model.pop()