Instruction:
How would you implement a function in Python 3 that
returns the current session if needed.

Response:
def current_session():
    """
    Returns the :class:`Session` for the current driver and app, instantiating one if needed.

    Returns:
        Session: The :class:`Session` for the current driver and app.
    """

    driver = current_driver or default_driver

    session_key = "{driver}:{session}:{app}".format(
        driver=driver, session=session_name, app=str(id(app)))
    session = _session_pool.get(session_key, None)

    if session is None:
        from capybara.session import Session
        session = Session(driver, app)
        _session_pool[session_key] = session

    return session


Instruction:
Make a summary of the following Python 3 code
def has_all_of_selectors(self, selector, *locators, **kwargs):

        return self.assert_all_of_selectors(selector, *locators, **kwargs)

Response: Tests if all of the provided selectors are present on the current page or descendants of the current node.


Instruction:
Implement a Python 3 function for
testing if none of the provided selectors are present on the current page or descendants of the current page.

Response:
def has_none_of_selectors(self, selector, *locators, **kwargs):
        """
        Checks if none of the provided selectors are present on the given page or descendants of the
        current node. If options are provided, the assertion will check that each locator is present
        with those options as well (other than ``wait``). ::

            page.has_none_of_selectors("custom", "Tom", "Joe", visible="all")
            page.has_none_of_selectors("css", "#my_div", "a.not_clicked")

        It accepts all options that :meth:`find_all` accepts, such as ``text`` and ``visible``.

        The ``wait`` option applies to all of the selectors as a group, so none of the locators must
        be present with ``wait`` (defaults to :data:`capybara.default_max_wait_time`) seconds.

        If the given selector is not a valid selector, the first argument is assumed to be a locator
        and the default selector will be used.

        Args:
            selector (str, optional): The name of the selector to use. Defaults to
                :data:`capybara.default_selector`.
            *locators (str): Variable length list of locators.
            **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.
        """

        return self.assert_none_of_selectors(selector, *locators, **kwargs)


Instruction:
How would you explain what the following Python 3 function does
def assert_selector(self, *args, **kwargs):

        query = SelectorQuery(*args, **kwargs)

        @self.synchronize(wait=query.wait)
        def assert_selector():
            result = query.resolve_for(self)

            if not (result.matches_count and
                    (len(result) > 0 or expects_none(query.options))):
                raise ExpectationNotMet(result.failure_message)

            return True

        return assert_selector()

Response: Assert that a given selector is on the page or a descendant of the current node.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def assert_style(self, styles, **kwargs):

        query = StyleQuery(styles, **kwargs)

        @self.synchronize(wait=query.wait)
        def assert_style():
            if not query.resolves_for(self):
                raise ExpectationNotMet(query.failure_message)

            return True

        return assert_style()

Response: Assert that an element has the specified CSS styles.


Instruction:
Create a Python 3 function to
assert that all of the provided selectors are present on the given page or descendants of the current node. If options are provided, the assertion will check that each locator is present with those options as well (other than ``wait``). :: page.assert_all_of_selectors("custom", "Tom", "Joe", visible="all") page.assert_all_of_selectors("css", "#my_dif", "a.not_clicked") It accepts all options that :meth:`find_all` accepts, such as ``text`` and ``visible``. The ``wait`` option applies to all of the selectors as a group, so all of the locators must be present within ``wait`` (defaults to :data:`capybara.default_max_wait_time`) seconds. If the given selector is not a valid selector, the first argument is assumed to be a locator and the default selector will be used. Args: selector (str, optional): The name of the selector to use. Defaults to :data:`capybara.default_selector`. *locators (str): Variable length list of locators. **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.

Response:
def assert_all_of_selectors(self, selector, *locators, **kwargs):
        """
        Asserts that all of the provided selectors are present on the given page or descendants of
        the current node. If options are provided, the assertion will check that each locator is
        present with those options as well (other than ``wait``). ::

            page.assert_all_of_selectors("custom", "Tom", "Joe", visible="all")
            page.assert_all_of_selectors("css", "#my_dif", "a.not_clicked")

        It accepts all options that :meth:`find_all` accepts, such as ``text`` and ``visible``.

        The ``wait`` option applies to all of the selectors as a group, so all of the locators must
        be present within ``wait`` (defaults to :data:`capybara.default_max_wait_time`) seconds.

        If the given selector is not a valid selector, the first argument is assumed to be a locator
        and the default selector will be used.

        Args:
            selector (str, optional): The name of the selector to use. Defaults to
                :data:`capybara.default_selector`.
            *locators (str): Variable length list of locators.
            **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.
        """

        wait = kwargs['wait'] if 'wait' in kwargs else capybara.default_max_wait_time

        if not isinstance(selector, Hashable) or selector not in selectors:
            locators = (selector,) + locators
            selector = capybara.default_selector

        @self.synchronize(wait=wait)
        def assert_all_of_selectors():
            for locator in locators:
                self.assert_selector(selector, locator, **kwargs)

            return True

        return assert_all_of_selectors()


Instruction:
Write a Python 3 function for
asserting that none of the provided selectors are present on the given page or descendants of the current node. If options are provided, the assertion will check that each locator is present with those options as well (other than ``wait``). :: page.assert_none_of_selectors("custom", "Tom", "Joe", visible="all") page.assert_none_of_selectors("css", "#my_div", "a.not_clicked") It accepts all options that :meth:`find_all` accepts, such as ``text`` and ``visible``. The ``wait`` option applies to all of the selectors as a group, so none of the locators must be present with ``wait`` (defaults to :data:`capybara.default_max_wait_time`) seconds. If the given selector is not a valid selector, the first argument is assumed to be a locator and the default selector will be used. Args: selector (str, optional): The name of the selector to use. Defaults to :data:`capybara.default_selector`. *locators (str): Variable length list of locators. **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.

Response:
def assert_none_of_selectors(self, selector, *locators, **kwargs):
        """
        Asserts that none of the provided selectors are present on the given page or descendants of
        the current node. If options are provided, the assertion will check that each locator is
        present with those options as well (other than ``wait``). ::

            page.assert_none_of_selectors("custom", "Tom", "Joe", visible="all")
            page.assert_none_of_selectors("css", "#my_div", "a.not_clicked")

        It accepts all options that :meth:`find_all` accepts, such as ``text`` and ``visible``.

        The ``wait`` option applies to all of the selectors as a group, so none of the locators must
        be present with ``wait`` (defaults to :data:`capybara.default_max_wait_time`) seconds.

        If the given selector is not a valid selector, the first argument is assumed to be a locator
        and the default selector will be used.

        Args:
            selector (str, optional): The name of the selector to use. Defaults to
                :data:`capybara.default_selector`.
            *locators (str): Variable length list of locators.
            **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.
        """
        wait = kwargs['wait'] if 'wait' in kwargs else capybara.default_max_wait_time

        if not isinstance(selector, Hashable) or selector not in selectors:
            locators = (selector,) + locators
            selector = capybara.default_selector

        @self.synchronize(wait=wait)
        def assert_none_of_selectors():
            for locator in locators:
                self.assert_no_selector(selector, locator, **kwargs)

            return True

        return assert_none_of_selectors()


Instruction:
Write a Python 3 function for
asserting that a given selector is not on the page or a descendant of the current node. Usage is identical to :meth:`assert_selector`. Query options such as ``count``, ``minimum``, and ``between`` are considered to be an integral part of the selector. This will return True, for example, if a page contains 4 anchors but the query expects 5:: page.assert_no_selector("a", minimum=1) # Found, raises ExpectationNotMet page.assert_no_selector("a", count=4) # Found, raises ExpectationNotMet page.assert_no_selector("a", count=5) # Not Found, returns True Args: *args: Variable length argument list for :class:`SelectorQuery`. **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`. Returns: True Raises: ExpectationNotMet: The given selector matched.

Response:
def assert_no_selector(self, *args, **kwargs):
        """
        Asserts that a given selector is not on the page or a descendant of the current node. Usage
        is identical to :meth:`assert_selector`.

        Query options such as ``count``, ``minimum``, and ``between`` are considered to be an
        integral part of the selector. This will return True, for example, if a page contains 4
        anchors but the query expects 5::

            page.assert_no_selector("a", minimum=1)  # Found, raises ExpectationNotMet
            page.assert_no_selector("a", count=4)    # Found, raises ExpectationNotMet
            page.assert_no_selector("a", count=5)    # Not Found, returns True

        Args:
            *args: Variable length argument list for :class:`SelectorQuery`.
            **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.

        Returns:
            True

        Raises:
            ExpectationNotMet: The given selector matched.
        """

        query = SelectorQuery(*args, **kwargs)

        @self.synchronize(wait=query.wait)
        def assert_no_selector():
            result = query.resolve_for(self)

            if result.matches_count and (
                   len(result) > 0 or expects_none(query.options)):
                raise ExpectationNotMet(result.negative_failure_message)

            return True

        return assert_no_selector()


Instruction:
Can you implement a function in Python 3 that
asserts that the current node matches a given selector.

Response:
def assert_matches_selector(self, *args, **kwargs):
        """
        Asserts that the current node matches a given selector. ::

            node.assert_matches_selector("p#foo")
            node.assert_matches_selector("xpath", "//p[@id='foo']")

        It also accepts all options that :meth:`find_all` accepts, such as ``text`` and
        ``visible``. ::

            node.assert_matches_selector("li", text="Horse", visible=True)

        Args:
            *args: Variable length argument list for :class:`SelectorQuery`.
            **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.

        Returns:
            True

        Raises:
            ExpectationNotMet: If the selector does not match.
        """

        query = SelectorQuery(*args, **kwargs)

        @self.synchronize(wait=query.wait)
        def assert_matches_selector():
            result = query.resolve_for(self.find_first("xpath", "./parent::*", minimum=0) or self.query_scope)

            if self not in result:
                raise ExpectationNotMet("Item does not match the provided selector")

            return True

        return assert_matches_selector()


Instruction:
Can you write a function in Python 3 where it
checks if the page or current node has a radio button or checkbox with the given label name or id or id that is currently checked.

Response:
def has_checked_field(self, locator, **kwargs):
        """
        Checks if the page or current node has a radio button or checkbox with the given label,
        value, or id, that is currently checked.

        Args:
            locator (str): The label, name, or id of a checked field.
            **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.

        Returns:
            bool: Whether it exists.
        """

        kwargs["checked"] = True
        return self.has_selector("field", locator, **kwargs)


Instruction:
Make a summary of the following Python 3 code
def has_no_checked_field(self, locator, **kwargs):

        kwargs["checked"] = True
        return self.has_no_selector("field", locator, **kwargs)

Response: Checks if the page or current node has no radio button or checkbox with the given label name or id or id that is currently checked.


Instruction:
Here you have a function in Python 3, explain what it does
def has_unchecked_field(self, locator, **kwargs):

        kwargs["checked"] = False
        return self.has_selector("field", locator, **kwargs)

Response: Checks if the page or current node has a radio button or checkbox with the given label name or id or id that is currently unchecked.


Instruction:
How would you explain what the following Python 3 function does
def has_no_unchecked_field(self, locator, **kwargs):

        kwargs["checked"] = False
        return self.has_no_selector("field", locator, **kwargs)

Response: Checks if the page or current node has no radio button or checkbox with the given label name or id or id.


Instruction:
Given the following Python 3 function, write the documentation
def assert_text(self, *args, **kwargs):

        query = TextQuery(*args, **kwargs)

        @self.synchronize(wait=query.wait)
        def assert_text():
            count = query.resolve_for(self)

            if not (matches_count(count, query.options) and
                    (count > 0 or expects_none(query.options))):
                raise ExpectationNotMet(query.failure_message)

            return True

        return assert_text()

Response: Assert that the page or current node has the given text content ignoring any HTML tags.


Instruction:
Can you implement a function in Python 3 that
asserts that the page or current node doesn t have the given text content.

Response:
def assert_no_text(self, *args, **kwargs):
        """
        Asserts that the page or current node doesn't have the given text content, ignoring any
        HTML tags.

        Args:
            *args: Variable length argument list for :class:`TextQuery`.
            **kwargs: Arbitrary keyword arguments for :class:`TextQuery`.

        Returns:
            True

        Raises:
            ExpectationNotMet: If the assertion hasn't succeeded during the wait time.
        """

        query = TextQuery(*args, **kwargs)

        @self.synchronize(wait=query.wait)
        def assert_no_text():
            count = query.resolve_for(self)

            if matches_count(count, query.options) and (
                   count > 0 or expects_none(query.options)):
                raise ExpectationNotMet(query.negative_failure_message)

            return True

        return assert_no_text()


Instruction:
How would you implement a function in Python 3 that
asserts that the page has the given title.

Response:
def assert_title(self, title, **kwargs):
        """
        Asserts that the page has the given title.

        Args:
            title (str | RegexObject): The string or regex that the title should match.
            **kwargs: Arbitrary keyword arguments for :class:`TitleQuery`.

        Returns:
            True

        Raises:
            ExpectationNotMet: If the assertion hasn't succeeded during the wait time.
        """

        query = TitleQuery(title, **kwargs)

        @self.synchronize(wait=query.wait)
        def assert_title():
            if not query.resolves_for(self):
                raise ExpectationNotMet(query.failure_message)

            return True

        return assert_title()


Instruction:
Create a Python 3 function for
asserting that the page doesn t have the given title.

Response:
def assert_no_title(self, title, **kwargs):
        """
        Asserts that the page doesn't have the given title.

        Args:
            title (str | RegexObject): The string that the title should include.
            **kwargs: Arbitrary keyword arguments for :class:`TitleQuery`.

        Returns:
            True

        Raises:
            ExpectationNotMet: If the assertion hasn't succeeded during the wait time.
        """

        query = TitleQuery(title, **kwargs)

        @self.synchronize(wait=query.wait)
        def assert_no_title():
            if query.resolves_for(self):
                raise ExpectationNotMet(query.negative_failure_message)

            return True

        return assert_no_title()


Instruction:
How would you code a function in Python 3 to
check if the page has the given title.

Response:
def has_title(self, title, **kwargs):
        """
        Checks if the page has the given title.

        Args:
            title (str | RegexObject): The string or regex that the title should match.
            **kwargs: Arbitrary keyword arguments for :class:`TitleQuery`.

        Returns:
            bool: Whether it matches.
        """

        try:
            self.assert_title(title, **kwargs)
            return True
        except ExpectationNotMet:
            return False


Instruction:
Make a summary of the following Python 3 code
def has_no_title(self, title, **kwargs):

        try:
            self.assert_no_title(title, **kwargs)
            return True
        except ExpectationNotMet:
            return False

Response: Checks if the page doesn t have the given title.


Instruction:
Write a Python 3 script for
finding all elements on the page matching the given selector and options.

Response:
def find_all(self, *args, **kwargs):
        """
        Find all elements on the page matching the given selector and options.

        Both XPath and CSS expressions are supported, but Capybara does not try to automatically
        distinguish between them. The following statements are equivalent::

            page.find_all("css", "a#person_123")
            page.find_all("xpath", "//a[@id='person_123']")

        If the type of selector is left out, Capybara uses :data:`capybara.default_selector`. It's
        set to ``"css"`` by default. ::

            page.find_all("a#person_123")

            capybara.default_selector = "xpath"
            page.find_all("//a[@id='person_123']")

        The set of found elements can further be restricted by specifying options. It's possible to
        select elements by their text or visibility::

            page.find_all("a", text="Home")
            page.find_all("#menu li", visible=True)

        By default if no elements are found, an empty list is returned; however, expectations can be
        set on the number of elements to be found which will trigger Capybara's waiting behavior for
        the expectations to match. The expectations can be set using::

            page.assert_selector("p#foo", count=4)
            page.assert_selector("p#foo", maximum=10)
            page.assert_selector("p#foo", minimum=1)
            page.assert_selector("p#foo", between=range(1, 11))

        See :func:`capybara.result.Result.matches_count` for additional information about count
        matching.

        Args:
            *args: Variable length argument list for :class:`SelectorQuery`.
            **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.

        Returns:
            Result: A collection of found elements.

        Raises:
            ExpectationNotMet: The matched results did not meet the expected criteria.
        """

        query = SelectorQuery(*args, **kwargs)

        @self.synchronize(wait=query.wait)
        def find_all():
            result = query.resolve_for(self)

            if not result.matches_count:
                raise ExpectationNotMet(result.failure_message)

            return result

        return find_all()


Instruction:
How would you implement a function in Python 3 that
finds the first element on the page matching the given selector and options.

Response:
def find_first(self, *args, **kwargs):
        """
        Find the first element on the page matching the given selector and options, or None if no
        element matches.

        By default, no waiting behavior occurs. However, if ``capybara.wait_on_first_by_default``
        is set to true, it will trigger Capybara's waiting behavior for a minimum of 1 matching
        element to be found.

        Args:
            *args: Variable length argument list for :class:`SelectorQuery`.
            **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.

        Returns:
            Element: The found element or None.
        """

        if capybara.wait_on_first_by_default:
            kwargs.setdefault("minimum", 1)

        try:
            result = self.find_all(*args, **kwargs)
            return result[0] if len(result) > 0 else None
        except ExpectationNotMet:
            return None


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

        self.node = node
        self.actual_text = normalize_text(
            node.visible_text if self.query_type == "visible" else node.all_text)
        self.count = len(re.findall(self.search_regexp, self.actual_text))

        return self.count

Response: Resolves this query relative to the given node.


Instruction:
Implement a function in Python 3 to
return the inner content of a given XML node including tags.

Response:
def inner_content(node):
    """
    Returns the inner content of a given XML node, including tags.

    Args:
        node (lxml.etree.Element): The node whose inner content is desired.

    Returns:
        str: The inner content of the node.
    """

    from lxml import etree

    # Include text content at the start of the node.
    parts = [node.text]

    for child in node.getchildren():
        # Include the child serialized to raw XML.
        parts.append(etree.tostring(child, encoding="utf-8"))

        # Include any text following the child.
        parts.append(child.tail)

    # Discard any non-existent text parts and return.
    return "".join(filter(None, parts))


Instruction:
Can you implement a function in Python 3 that
returns the inner text of a given XML node excluding tags.

Response:
def inner_text(node):
    """
    Returns the inner text of a given XML node, excluding tags.

    Args:
        node: (lxml.etree.Element): The node whose inner text is desired.

    Returns:
        str: The inner text of the node.
    """

    from lxml import etree

    # Include text content at the start of the node.
    parts = [node.text]

    for child in node.getchildren():
        # Include the raw text content of the child.
        parts.append(etree.tostring(child, encoding="utf-8", method="text"))

        # Include any text following the child.
        parts.append(child.tail)

    # Discard any non-existent text parts and return.
    return "".join(map(decode_bytes, filter(None, parts)))


Instruction:
Create a Python 3 function for
normalizing the given URL with all query keys properly escaped.

Response:
def normalize_url(url):
    """
    Returns the given URL with all query keys properly escaped.

    Args:
        url (str): The URL to normalize.

    Returns:
        str: The normalized URL.
    """

    uri = urlparse(url)
    query = uri.query or ""

    pairs = parse_qsl(query)
    decoded_pairs = [(unquote(key), value) for key, value in pairs]
    encoded_pairs = [(quote(key), value) for key, value in decoded_pairs]
    normalized_query = urlencode(encoded_pairs)

    return ParseResult(
        scheme=uri.scheme,
        netloc=uri.netloc,
        path=uri.path,
        params=uri.params,
        query=normalized_query,
        fragment=uri.fragment).geturl()


Instruction:
How would you implement a function in Python 3 that
defines a write - only property that provides a setter function that provides the given setter function. This is a decorator that provides a setter function that can be used to set the value of the object s _handler property.

Response:
def setter_decorator(fset):
    """
    Define a write-only property that, in addition to the given setter function, also
    provides a setter decorator defined as the property's getter function.

    This allows one to set the property either through traditional assignment, as a
    method argument, or through decoration::

        class Widget(object):
            @setter_decorator
            def handler(self, value):
                self._handler = value

        widget = Widget()

        # Method 1: Traditional assignment
        widget.handler = lambda input: process(input)

        # Method 2: Assignment via method argument
        widget.handler(lambda input: process(input))

        # Method 3: Assignment via decoration
        @widget.handler
        def handler(input):
            return process(input)

        # Method 3b: Assignment via decoration with extraneous parens
        @widget.handler()
        def handler(input):
            return process(input)
    """

    def fget(self):
        def inner(value):
            fset(self, value)

        def outer(value=None):
            if value:
                # We are being called with the desired value, either directly or
                # as a decorator.
                inner(value)
            else:
                # Assume we are being called as a decorator with extraneous parens,
                # so return the setter as the actual decorator.
                return inner

        return outer

    fdoc = fset.__doc__

    return property(fget, fset, None, fdoc)


Instruction:
Implement a function in Python 3 to
return True if the given value is valid.

Response:
def _valid_value(self, value):
        """ bool: Whether the given value is valid. """

        if not self.valid_values:
            return True

        valid_values = (self.valid_values if isinstance(self.valid_values, list)
                        else list(self.valid_values))
        return value in valid_values


Instruction:
Can you implement a function in Python 3 that
finds a file field on the page and attach a file given its path.

Response:
def attach_file(self, locator_or_path, path=None, **kwargs):
        """
        Find a file field on the page and attach a file given its path. The file field can be found
        via its name, id, or label text. ::

            page.attach_file(locator, "/path/to/file.png")

        Args:
            locator_or_path (str): Which field to attach the file to, or the path of the file that
                will be attached.
            path (str, optional): The path of the file that will be attached. Defaults to
                ``locator_or_path``.
            **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.

        Raises:
            FileNotFound: No file exists at the given path.
        """

        if path is None:
            locator, path = None, locator_or_path
        else:
            locator = locator_or_path

        if not os.path.isfile(path):
            raise FileNotFound("cannot attach file, {0} does not exist".format(path))

        self.find("file_field", locator, **kwargs).set(path)


Instruction:
How would you code a function in Python 3 to
check the contents of the specified check box.

Response:
def check(self, locator=None, allow_label_click=None, **kwargs):
        """
        Find a check box and mark it as checked. The check box can be found via name, id, or label
        text. ::

            page.check("German")

        Args:
            locator (str, optional): Which check box to check.
            allow_label_click (bool, optional): Attempt to click the label to toggle state if
                element is non-visible. Defaults to :data:`capybara.automatic_label_click`.
            **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.
        """

        self._check_with_label(
            "checkbox", True, locator=locator, allow_label_click=allow_label_click, **kwargs)


Instruction:
Write a Python 3 script to
find a radio button and mark it as checked. The radio button can be found via name, id, or label text. :: page.choose("Male") Args: locator (str, optional): Which radio button to choose. allow_label_click (bool, optional): Attempt to click the label to toggle state if element is non-visible. Defaults to :data:`capybara.automatic_label_click`. **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.

Response:
def choose(self, locator=None, allow_label_click=None, **kwargs):
        """
        Find a radio button and mark it as checked. The radio button can be found via name, id, or
        label text. ::

            page.choose("Male")

        Args:
            locator (str, optional): Which radio button to choose.
            allow_label_click (bool, optional): Attempt to click the label to toggle state if
                element is non-visible. Defaults to :data:`capybara.automatic_label_click`.
            **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.
        """

        self._check_with_label(
            "radio_button", True, locator=locator, allow_label_click=allow_label_click, **kwargs)


Instruction:
How would you explain what the following Python 3 function does
def fill_in(self, locator=None, current_value=None, value=None, fill_options=None, **kwargs):

        if current_value is not None:
            kwargs["value"] = current_value

        fill_options = fill_options or {}

        self.find("fillable_field", locator, **kwargs).set(value, **fill_options)

Response: Fills in the given value in the given field.


Instruction:
Make a summary of the following Python 3 code
def select(self, value=None, field=None, **kwargs):

        if field:
            self.find("select", field, **kwargs).find("option", value, **kwargs).select_option()
        else:
            self.find("option", value, **kwargs).select_option()

Response: Select the option from the current scope.


Instruction:
Implement a Python 3 function for
finding a check box and uncheck it. The check box can be found via name, id, or label text. :: page.uncheck("German") Args: locator (str, optional): Which check box to uncheck. allow_label_click (bool, optional): Attempt to click the label to toggle state if element is non-visible. Defaults to :data:`capybara.automatic_label_click`. **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.

Response:
def uncheck(self, locator=None, allow_label_click=None, **kwargs):
        """
        Find a check box and uncheck it. The check box can be found via name, id, or label text. ::

            page.uncheck("German")

        Args:
            locator (str, optional): Which check box to uncheck.
            allow_label_click (bool, optional): Attempt to click the label to toggle state if
                element is non-visible. Defaults to :data:`capybara.automatic_label_click`.
            **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.
        """

        self._check_with_label(
            "checkbox", False, locator=locator, allow_label_click=allow_label_click, **kwargs)


Instruction:
Can you implement a function in Python 3 that
finds a select box on the page and unselect a particular option from it. If the select box is a multiple select, ``unselect`` can be called multiple times to unselect more than one option. The select box can be found via its name, id, or label text. :: page.unselect("March", field="Month") Args: value (str, optional): Which option to unselect. field (str, optional): The id, name, or label of the select box. **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.

Response:
def unselect(self, value=None, field=None, **kwargs):
        """
        Find a select box on the page and unselect a particular option from it. If the select box is
        a multiple select, ``unselect`` can be called multiple times to unselect more than one
        option. The select box can be found via its name, id, or label text. ::

            page.unselect("March", field="Month")

        Args:
            value (str, optional): Which option to unselect.
            field (str, optional): The id, name, or label of the select box.
            **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.
        """

        if field:
            self.find("select", field, **kwargs).find("option", value, **kwargs).unselect_option()
        else:
            self.find("option", value, **kwargs).unselect_option()


Instruction:
Given the following Python 3 function, write the documentation
def _check_with_label(self, selector, checked, locator=None, allow_label_click=None, visible=None, wait=None,
                          **kwargs):
        """
        Args:
            selector (str): The selector for the type of element that should be checked/unchecked.
            checked (bool): Whether the element should be checked.
            locator (str, optional): Which element to check.
            allow_label_click (bool, optional): Attempt to click the label to toggle state if
                element is non-visible. Defaults to :data:`capybara.automatic_label_click`.
            visible (bool | str, optional): The desired element visibility. Defaults to
                :data:`capybara.ignore_hidden_elements`.
            wait (int | float, optional): The number of seconds to wait to check the element.
                Defaults to :data:`capybara.default_max_wait_time`.
            **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.
        """

        if allow_label_click is None:
            allow_label_click = capybara.automatic_label_click

        @self.synchronize(wait=BaseQuery.normalize_wait(wait))
        def check_with_label():
            element = None
            try:
                element = self.find(selector, locator, visible=visible, **kwargs)
                element.set(checked)
            except Exception as e:
                if not allow_label_click or not self._should_catch_error(e):
                    raise
                try:
                    if not element:
                        element = self.find(selector, locator, visible="all", **kwargs)
                    label = self.find("label", field=element, visible=True)
                    if element.checked != checked:
                        label.click()
                except Exception:
                    raise e

        check_with_label()

Response: Check the element with the specified label.


Instruction:
Explain what the following Python 3 code does
def synchronize(self, func=None, wait=None, errors=()):

        def decorator(func):
            @wraps(func)
            def outer(*args, **kwargs):
                seconds = wait if wait is not None else capybara.default_max_wait_time

                def inner():
                    return func(*args, **kwargs)

                if self.session.synchronized:
                    return inner()
                else:
                    timer = Timer(seconds)
                    self.session.synchronized = True
                    try:
                        while True:
                            try:
                                return inner()
                            except Exception as e:
                                self.session.raise_server_error()

                                if not self._should_catch_error(e, errors):
                                    raise
                                if timer.expired:
                                    raise

                                sleep(0.05)

                                if timer.stalled:
                                    raise FrozenInTime(
                                        "time appears to be frozen, Capybara does not work with "
                                        "libraries which freeze time, consider using time "
                                        "traveling instead")
                                if capybara.automatic_reload:
                                    self.reload()
                    finally:
                        self.session.synchronized = False

            return outer

        if func:
            return decorator(func)
        else:
            return decorator

Response: This method is used to synchronize a function with Capybara s primary defense against asynchronicity problems.


Instruction:
How would you implement a function in Python 3 that
returns whether the given error should be caught.

Response:
def _should_catch_error(self, error, errors=()):
        """
        Returns whether to catch the given error.

        Args:
            error (Exception): The error to consider.
            errors (Tuple[Type[Exception], ...], optional): The exception types that should be
                caught. Defaults to :class:`ElementNotFound` plus any driver-specific invalid
                element errors.

        Returns:
            bool: Whether to catch the given error.
        """

        caught_errors = (
            errors or
            self.session.driver.invalid_element_errors + (ElementNotFound,))

        return isinstance(error, caught_errors)


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

        if self.query.options["count"] is not None:
            count_opt = int(self.query.options["count"])
            self._cache_at_least(count_opt + 1)
            return cmp(len(self._result_cache), count_opt)

        if self.query.options["minimum"] is not None:
            min_opt = int(self.query.options["minimum"])
            if not self._cache_at_least(min_opt):
                return -1

        if self.query.options["maximum"] is not None:
            max_opt = int(self.query.options["maximum"])
            if self._cache_at_least(max_opt + 1):
                return 1

        if self.query.options["between"] is not None:
            between = self.query.options["between"]
            min_opt, max_opt = between[0], between[-1]
            if not self._cache_at_least(min_opt):
                return -1
            if self._cache_at_least(max_opt + 1):
                return 1
            return 0

        return 0

Response: Returns how the result count compares to the query options.


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

        message = failure_message(self.query.description, self.query.options)

        if len(self) > 0:
            message += ", found {count} {matches}: {results}".format(
                count=len(self),
                matches=declension("match", "matches", len(self)),
                results=", ".join([desc(node.text) for node in self]))
        else:
            message += " but there were no matches"

        if self._rest:
            elements = ", ".join([desc(element.text) for element in self._rest])
            message += (". Also found {}, which matched the selector"
                        " but not all filters.".format(elements))

        return message

Response: str - A message describing the query failure.


Instruction:
Write a Python 3 script for
attempting to fill the result cache with at least the given size. Returns True if the result cache contains at least the given size.

Response:
def _cache_at_least(self, size):
        """
        Attempts to fill the result cache with at least the given number of results.

        Returns:
            bool: Whether the cache contains at least the given size.
        """

        try:
            while len(self._result_cache) < size:
                self._result_cache.append(next(self._result_iter))
            return True
        except StopIteration:
            return False


Instruction:
Can you tell what is the following Python 3 function doing
def desc(value):

    def normalize_strings(value):
        if isinstance(value, list):
            value = [normalize_strings(e) for e in value]

        if isinstance(value, dict):
            value = {normalize_strings(k): normalize_strings(v) for k, v in iter(value.items())}

        if isregex(value):
            value = value.pattern

        if isbytes(value):
            value = decode_bytes(value)

        if PY2:
            if isstring(value):
                # In Python 2, strings (``unicode`` objects) represent as ``u'...'``, so ensure
                # the string is encoded (as a ``str`` object) for cleaner representation.
                value = encode_string(value)

        return value

    value = normalize_strings(value)

    return repr(value)

Response: str - A normalized representation for a user - provided value.


Instruction:
Make a summary of the following Python 3 code
def expects_none(options):

    if any(options.get(key) is not None for key in ["count", "maximum", "minimum", "between"]):
        return matches_count(0, options)
    else:
        return False

Response: Returns whether the given query options expect a possible count of zero.


Instruction:
Can you generate the documentation for the following Python 3 function
def failure_message(description, options):

    message = "expected to find {}".format(description)

    if options["count"] is not None:
        message += " {count} {times}".format(
            count=options["count"],
            times=declension("time", "times", options["count"]))
    elif options["between"] is not None:
        between = options["between"]
        if between:
            first, last = between[0], between[-1]
        else:
            first, last = None, None

        message += " between {first} and {last} times".format(
            first=first,
            last=last)
    elif options["maximum"] is not None:
        message += " at most {maximum} {times}".format(
            maximum=options["maximum"],
            times=declension("time", "times", options["maximum"]))
    elif options["minimum"] is not None:
        message += " at least {minimum} {times}".format(
            minimum=options["minimum"],
            times=declension("time", "times", options["minimum"]))

    return message

Response: Returns a expectation failure message for the given query description.


Instruction:
Here you have a function in Python 3, explain what it does
def matches_count(count, options):

    if options.get("count") is not None:
        return count == int(options["count"])
    if options.get("maximum") is not None and int(options["maximum"]) < count:
        return False
    if options.get("minimum") is not None and int(options["minimum"]) > count:
        return False
    if options.get("between") is not None and count not in options["between"]:
        return False
    return True

Response: Returns whether the given count matches the given query options.


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

    if value is None:
        return ""

    text = decode_bytes(value) if isbytes(value) else str_(value)

    return normalize_whitespace(text)

Response: Normalizes the given value to a string of text with extra whitespace removed.


Instruction:
How would you implement a function in Python 3 that
normalizes the given text with outer whitespace removed inner whitespace collapsed.

Response:
def normalize_whitespace(text):
    """
    Returns the given text with outer whitespace removed and inner whitespace collapsed.

    Args:
        text (str): The text to normalize.

    Returns:
        str: The normalized text.
    """

    return re.sub(r"\s+", " ", text, flags=re.UNICODE).strip()


Instruction:
Can you write a function in Python 3 where it
returns a compiled regular expression for the given text.

Response:
def toregex(text, exact=False):
    """
    Returns a compiled regular expression for the given text.

    Args:
        text (str | RegexObject): The text to match.
        exact (bool, optional): Whether the generated regular expression should match exact
            strings. Defaults to False.

    Returns:
        RegexObject: A compiled regular expression that will match the text.
    """

    if isregex(text):
        return text

    escaped = re.escape(normalize_text(text))
    if exact:
        escaped = r"\A{}\Z".format(escaped)

    return re.compile(escaped)


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

        if self.url:
            self.actual_path = session.current_url
        else:
            result = urlparse(session.current_url)

            if self.only_path:
                self.actual_path = result.path
            else:
                request_uri = result.path
                if result.query:
                    request_uri += "?{0}".format(result.query)

                self.actual_path = request_uri

        if isregex(self.expected_path):
            return self.expected_path.search(self.actual_path)
        else:
            return normalize_url(self.actual_path) == normalize_url(self.expected_path)

Response: Returns whether this query resolves for the given session.


Instruction:
Can you create a Python 3 function that
boots a server for the app.

Response:
def boot(self):
        """
        Boots a server for the app, if it isn't already booted.

        Returns:
            Server: This server.
        """

        if not self.responsive:
            # Remember the port so we can reuse it if we try to serve this same app again.
            type(self)._ports[self.port_key] = self.port

            init_func = capybara.servers[capybara.server_name]
            init_args = (self.middleware, self.port, self.host)

            self.server_thread = Thread(target=init_func, args=init_args)

            # Inform Python that it shouldn't wait for this thread to terminate before
            # exiting. (It will still be appropriately terminated when the process exits.)
            self.server_thread.daemon = True

            self.server_thread.start()

            # Make sure the server actually starts and becomes responsive.
            timer = Timer(60)
            while not self.responsive:
                if timer.expired:
                    raise RuntimeError("WSGI application timed out during boot")
                self.server_thread.join(0.1)

        return self


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

        if self.server_thread and self.server_thread.join(0):
            return False

        try:
            # Try to fetch the endpoint added by the middleware.
            identify_url = "http://{0}:{1}/__identify__".format(self.host, self.port)

            with closing(urlopen(identify_url)) as response:
                body, status_code = response.read(), response.getcode()

                if str(status_code)[0] == "2" or str(status_code)[0] == "3":
                    return decode_bytes(body) == str(id(self.app))
        except URLError:
            pass

        return False

Response: Returns True if the server is up and responsive.


Instruction:
How would you explain what the following Python 3 function does
def cgetter(self, fcget: typing.Optional[typing.Callable[[typing.Any], typing.Any]]) -> "AdvancedProperty":
        self.__fcget = fcget
        return self

Response: Descriptor to change the class - wide getter on a property.


Instruction:
Write a Python 3 function for
setting the descriptor to change the instance method.

Response:
def instance_method(self, imeth: typing.Optional[typing.Callable[..., typing.Any]]) -> "SeparateClassMethod":
        """Descriptor to change instance method.

        :param imeth: New instance method.
        :type imeth: typing.Optional[typing.Callable]
        :return: SeparateClassMethod
        :rtype: SeparateClassMethod
        """
        self.__instance_method = imeth
        return self


Instruction:
Write a Python 3 function that can
set the class method to be used for this class.

Response:
def class_method(self, cmeth: typing.Optional[typing.Callable[..., typing.Any]]) -> "SeparateClassMethod":
        """Descriptor to change class method.

        :param cmeth: New class method.
        :type cmeth: typing.Optional[typing.Callable]
        :return: SeparateClassMethod
        :rtype: SeparateClassMethod
        """
        self.__class_method = cmeth
        return self


Instruction:
How would you code a function in Python 3 to
get outer traceback text for logging.

Response:
def __traceback(self) -> str:
        """Get outer traceback text for logging."""
        if not self.log_traceback:
            return ""
        exc_info = sys.exc_info()
        stack = traceback.extract_stack()
        exc_tb = traceback.extract_tb(exc_info[2])
        full_tb = stack[:1] + exc_tb  # cut decorator and build full traceback
        exc_line: typing.List[str] = traceback.format_exception_only(*exc_info[:2])
        # Make standard traceback string
        tb_text = "\nTraceback (most recent call last):\n" + "".join(traceback.format_list(full_tb)) + "".join(exc_line)
        return tb_text


Instruction:
Can you generate the documentation for the following Python 3 function
def __get_obj_source(self, instance: typing.Any, owner: typing.Optional[type] = None) -> str:
        if self.log_object_repr:
            return f"{instance!r}"
        return f"<{owner.__name__ if owner is not None else instance.__class__.__name__}() at 0x{id(instance):X}>"

Response: Get object repr block.


Instruction:
Make a summary of the following Python 3 code
def _get_logger_for_instance(self, instance: typing.Any) -> logging.Logger:
        if self.logger is not None:  # pylint: disable=no-else-return
            return self.logger
        elif hasattr(instance, "logger") and isinstance(instance.logger, logging.Logger):
            return instance.logger
        elif hasattr(instance, "log") and isinstance(instance.log, logging.Logger):
            return instance.log
        return _LOGGER

Response: Get the logger for the given instance.


Instruction:
Explain what the following Python 3 code does
def logger(self, logger: typing.Union[logging.Logger, str, None]) -> None:
        if logger is None or isinstance(logger, logging.Logger):
            self.__logger = logger
        else:
            self.__logger = logging.getLogger(logger)

Response: Set the logger instance to use as override.


Instruction:
Given the following Python 3 function, write the documentation
def get_simple_vars_from_src(src):
    ast_data = (ast.Str, ast.Num, ast.List, ast.Set, ast.Dict, ast.Tuple, ast.Bytes, ast.NameConstant)

    tree = ast.parse(src)

    result = collections.OrderedDict()

    for node in ast.iter_child_nodes(tree):
        if not isinstance(node, ast.Assign):  # We parse assigns only
            continue
        try:
            if isinstance(node.value, ast_data):
                value = ast.literal_eval(node.value)
            else:
                continue
        except ValueError:
            continue
        for tgt in node.targets:
            if isinstance(tgt, ast.Name) and isinstance(tgt.ctx, ast.Store):
                result[tgt.id] = value
    return result

Response: Get simple variable names and values from source code.


Instruction:
Can you generate the documentation for the following Python 3 function
def run(self):
        try:
            build_ext.build_ext.run(self)

            # Copy __init__.py back to repair package.
            build_dir = os.path.abspath(self.build_lib)
            root_dir = os.path.abspath(os.path.join(__file__, ".."))
            target_dir = build_dir if not self.inplace else root_dir

            src_file = os.path.join("advanced_descriptors", "__init__.py")

            src = os.path.join(root_dir, src_file)
            dst = os.path.join(target_dir, src_file)

            if src != dst:
                shutil.copyfile(src, dst)
        except (
            distutils.errors.DistutilsPlatformError,
            FileNotFoundError,
        ):
            raise BuildFailed()

Response: Runs the extension build.


Instruction:
Can you generate the documentation for the following Python 3 function
def _call_api(self, method, params=None):
        url = self.url.format(method=method)
        if not params:
            params = {'token': self.token}
        else:
            params['token'] = self.token
        logger.debug('Send request to %s', url)
        response = requests.get(url, params=params).json()
        if self.verify:
            if not response['ok']:
                msg = 'For {url} API returned this bad response {response}'
                raise Exception(msg.format(url=url, response=response))
        return response

Response: Call the Slack API.


Instruction:
Can you create a Python 3 function that
returns a list of all channels in this slack team

Response:
def channels(self):
        """
        List of channels of this slack team
        """
        if not self._channels:
            self._channels = self._call_api('channels.list')['channels']
        return self._channels


Instruction:
Can you generate the documentation for the following Python 3 function
def users(self):
        if not self._users:
            self._users = self._call_api('users.list')['members']
        return self._users

Response: Returns a list of users of this slack team


Instruction:
Implement a Python 3 function for
returning the channel dict given by human - readable name

Response:
def channel_from_name(self, name):
        """
        Return the channel dict given by human-readable {name}
        """
        try:
            channel = [channel for channel in self.channels
                       if channel['name'] == name][0]
        except IndexError:
            raise ValueError('Unknown channel for name: "{}"'.format(name))
        return channel


Instruction:
How would you explain what the following Python 3 function does
def make_message(self, text, channel):
        try:
            channel_id = self.slack.channel_from_name(channel)['id']
        except ValueError:
            channel_id = channel
        return pack({
            'text': text,
            'type': 'message',
            'channel': channel_id,
            'id': self.message_id,
        })

Response: High - level function for creating messages. Return packed bytes.


Instruction:
Write a Python 3 script to
translate machine identifiers into human - readable ones.

Response:
def translate(self, message):
        """
        Translate machine identifiers into human-readable
        """
        # translate user
        try:
            user_id = message.pop('user')
            user = self.slack.user_from_id(user_id)
            message[u'user'] = user['name']
        except (KeyError, IndexError, ValueError):
            pass
        # translate channel
        try:
            if type(message['channel']) == str:
                channel_id = message.pop('channel')
            else:
                channel_id = message.pop('channel')['id']
                self.slack.reload_channels()
            channel = self.slack.channel_from_id(channel_id)
            message[u'channel'] = channel['name']
        except (KeyError, IndexError, ValueError):
            pass
        return message


Instruction:
Can you write a function in Python 3 where it
sends the payload onto the {slack.[payload['type]'} channel. The message is transalated from IDs to human-readable identifiers. Note: The slack API only sends JSON, isBinary will always be false.

Response:
def onMessage(self, payload, isBinary):
        """
        Send the payload onto the {slack.[payload['type]'} channel.
        The message is transalated from IDs to human-readable identifiers.

        Note: The slack API only sends JSON, isBinary will always be false.
        """
        msg = self.translate(unpack(payload))
        if 'type' in msg:
            channel_name = 'slack.{}'.format(msg['type'])
            print('Sending on {}'.format(channel_name))
            channels.Channel(channel_name).send({'text': pack(msg)})


Instruction:
Create a Python 3 function for
sending a Slack message to Slack

Response:
def sendSlack(self, message):
        """
        Send message to Slack
        """
        channel = message.get('channel', 'general')
        self.sendMessage(self.make_message(message['text'], channel))


Instruction:
Write a Python 3 function for
reading the available messages and send them through the protocol.

Response:
def read_channel(self):
        """
        Get available messages and send through to the protocol
        """
        channel, message = self.protocol.channel_layer.receive_many([u'slack.send'], block=False)
        delay = 0.1
        if channel:
            self.protocols[0].sendSlack(message)
        reactor.callLater(delay, self.read_channel)


Instruction:
Can you implement a function in Python 3 that
runs the Slack API.

Response:
def run(self, args):
        """
        Pass in raw arguments, instantiate Slack API and begin client.
        """
        args = self.parser.parse_args(args)
        if not args.token:
            raise ValueError('Supply the slack token through --token or setting DJANGOBOT_TOKEN')

        # Import the channel layer
        sys.path.insert(0, ".")
        module_path, object_path = args.channel_layer.split(':', 1)
        channel_layer = importlib.import_module(module_path)
        for part in object_path.split('.'):
            channel_layer = getattr(channel_layer, part)

        # Boot up the client
        Client(
            channel_layer=channel_layer,
            token=args.token,
        ).run()


Instruction:
Explain what the following Python 3 code does
def _set_affiliation(self, v, load=False):
        if hasattr(v, "_utype"):
            v = v._utype(v)
        try:
            t = YANGDynClass(
                v,
                base=RestrictedClassType(
                    base_type=unicode,
                    restriction_type="dict_key",
                    restriction_arg={
                        u"napalm-star-wars:EMPIRE": {
                            "@namespace": u"https://napalm-yang.readthedocs.io/napalm-star-wars",
                            "@module": u"napalm-star-wars",
                        },
                        u"EMPIRE": {
                            "@namespace": u"https://napalm-yang.readthedocs.io/napalm-star-wars",
                            "@module": u"napalm-star-wars",
                        },
                        u"napalm-star-wars:REBEL_ALLIANCE": {
                            "@namespace": u"https://napalm-yang.readthedocs.io/napalm-star-wars",
                            "@module": u"napalm-star-wars",
                        },
                        u"REBEL_ALLIANCE": {
                            "@namespace": u"https://napalm-yang.readthedocs.io/napalm-star-wars",
                            "@module": u"napalm-star-wars",
                        },
                    },
                ),
                is_leaf=True,
                yang_name="affiliation",
                parent=self,
                path_helper=self._path_helper,
                extmethods=self._extmethods,
                register_paths=True,
                namespace="https://napalm-yang.readthedocs.io/napalm-star-wars",
                defining_module="napalm-star-wars",
                yang_type="identityref",
                is_config=True,
            )
        except (TypeError, ValueError):
            raise ValueError(
                {
                    "error-string": """affiliation must be of a type compatible with identityref""",
                    "defined-type": "napalm-star-wars:identityref",
                    "generated-type": """YANGDynClass(base=RestrictedClassType(base_type=unicode, restriction_type="dict_key", restriction_arg={u'napalm-star-wars:EMPIRE': {'@namespace': u'https://napalm-yang.readthedocs.io/napalm-star-wars', '@module': u'napalm-star-wars'}, u'EMPIRE': {'@namespace': u'https://napalm-yang.readthedocs.io/napalm-star-wars', '@module': u'napalm-star-wars'}, u'napalm-star-wars:REBEL_ALLIANCE': {'@namespace': u'https://napalm-yang.readthedocs.io/napalm-star-wars', '@module': u'napalm-star-wars'}, u'REBEL_ALLIANCE': {'@namespace': u'https://napalm-yang.readthedocs.io/napalm-star-wars', '@module': u'napalm-star-wars'}},), is_leaf=True, yang_name="affiliation", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='https://napalm-yang.readthedocs.io/napalm-star-wars', defining_module='napalm-star-wars', yang_type='identityref', is_config=True)""",
                }
            )

        self.__affiliation = t
        if hasattr(self, "_set"):
            self._set()

Response: Sets the affiliation of the current object.


Instruction:
Can you generate the documentation for the following Python 3 function
def dict_diff(prv, nxt):
    keys = set(prv.keys() + nxt.keys())
    result = {}
    for k in keys:
        if prv.get(k) != nxt.get(k):
            result[k] = (prv.get(k), nxt.get(k))
    return result

Response: Return a dict of keys that differ with another config object.


Instruction:
Create a Python 3 function to
give a string add necessary codes to format the string.

Response:
def colorize(msg, color):
    """Given a string add necessary codes to format the string."""
    if DONT_COLORIZE:
        return msg
    else:
        return "{}{}{}".format(COLORS[color], msg, COLORS["endc"])


Instruction:
Given the following Python 3 function, write the documentation
def v2_playbook_on_task_start(self, task, **kwargs):
        self.last_task_name = task.get_name()
        self.printed_last_task = False

Response: Run when a task starts.


Instruction:
Can you tell what is the following Python 3 function doing
def v2_runner_on_ok(self, result, **kwargs):
        failed = "failed" in result._result
        unreachable = "unreachable" in result._result

        if (
            "print_action" in result._task.tags
            or failed
            or unreachable
            or self._display.verbosity > 1
        ):
            self._print_task()
            self.last_skipped = False
            msg = unicode(result._result.get("msg", "")) or unicode(
                result._result.get("reason", "")
            ) or unicode(
                result._result.get("message", "")
            )

            stderr = [
                result._result.get("exception", None),
                result._result.get("module_stderr", None),
            ]
            stderr = "\n".join([e for e in stderr if e]).strip()

            self._print_host_or_item(
                result._host,
                result._result.get("changed", False),
                msg,
                result._result.get("diff", None),
                is_host=True,
                error=failed or unreachable,
                stdout=result._result.get("module_stdout", None),
                stderr=stderr.strip(),
            )

            if "results" in result._result:
                for r in result._result["results"]:
                    failed = "failed" in r

                    stderr = [r.get("exception", None), r.get("module_stderr", None)]
                    stderr = "\n".join([e for e in stderr if e]).strip()

                    self._print_host_or_item(
                        r["item"],
                        r.get("changed", False),
                        unicode(r.get("msg", "")),
                        r.get("diff", None),
                        is_host=False,
                        error=failed,
                        stdout=r.get("module_stdout", None),
                        stderr=stderr.strip(),
                    )
        else:
            self.last_skipped = True
            print(".", end="")

Response: Run when a task finishes correctly.


Instruction:
Can you write a function in Python 3 where it
displays info about playbook statistics.

Response:
def v2_playbook_on_stats(self, stats):
        """Display info about playbook statistics."""
        print()
        self.printed_last_task = False
        self._print_task("STATS")

        hosts = sorted(stats.processed.keys())
        for host in hosts:
            s = stats.summarize(host)

            if s["failures"] or s["unreachable"]:
                color = "failed"
            elif s["changed"]:
                color = "changed"
            else:
                color = "ok"

            msg = "{}    : ok={}\tchanged={}\tfailed={}\tunreachable={}".format(
                host, s["ok"], s["changed"], s["failures"], s["unreachable"]
            )
            print(colorize(msg, color))


Instruction:
Write a Python 3 function for
running when a task is skipped.

Response:
def v2_runner_on_skipped(self, result, **kwargs):
        """Run when a task is skipped."""
        if self._display.verbosity > 1:
            self._print_task()
            self.last_skipped = False

            line_length = 120
            spaces = " " * (31 - len(result._host.name) - 4)

            line = "  * {}{}- {}".format(
                colorize(result._host.name, "not_so_bold"),
                spaces,
                colorize("skipped", "skipped"),
            )

            reason = result._result.get("skipped_reason", "") or result._result.get(
                "skip_reason", ""
            )
            if len(reason) < 50:
                line += " -- {}".format(reason)
                print("{} {}---------".format(line, "-" * (line_length - len(line))))
            else:
                print("{} {}".format(line, "-" * (line_length - len(line))))
                print(self._indent_text(reason, 8))
                print(reason)


Instruction:
Given the following Python 3 function, write the documentation
def prefix_to_addrmask(value, sep=" "):
    prefix = netaddr.IPNetwork(value)
    return "{}{}{}".format(prefix.ip, sep, prefix.netmask)

Response: Converts a CIDR formatted prefix into an address netmask representation.


Instruction:
Implement a Python 3 function for
setting the keepalive interval of the current node.

Response:
def _set_keepalive_interval(self, v, load=False):
        """
    Setter method for keepalive_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/timers/state/keepalive_interval (decimal64)
    If this variable is read-only (config: false) in the
    source YANG file, then _set_keepalive_interval is considered as a private
    method. Backends looking to populate this variable should
    do so via calling thisObj._set_keepalive_interval() directly.

    YANG Description: Time interval in seconds between transmission of keepalive
messages to the neighbor.  Typically set to 1/3 the
hold-time.
    """
        if hasattr(v, "_utype"):
            v = v._utype(v)
        try:
            t = YANGDynClass(
                v,
                base=RestrictedPrecisionDecimalType(precision=2),
                default=Decimal(30),
                is_leaf=True,
                yang_name="keepalive-interval",
                parent=self,
                path_helper=self._path_helper,
                extmethods=self._extmethods,
                register_paths=True,
                namespace="http://openconfig.net/yang/network-instance",
                defining_module="openconfig-network-instance",
                yang_type="decimal64",
                is_config=False,
            )
        except (TypeError, ValueError):
            raise ValueError(
                {
                    "error-string": """keepalive_interval must be of a type compatible with decimal64""",
                    "defined-type": "decimal64",
                    "generated-type": """YANGDynClass(base=RestrictedPrecisionDecimalType(precision=2), default=Decimal(30), is_leaf=True, yang_name="keepalive-interval", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='decimal64', is_config=False)""",
                }
            )

        self.__keepalive_interval = t
        if hasattr(self, "_set"):
            self._set()


Instruction:
Write a Python 3 function for
adding a model to the class.

Response:
def add_model(self, model, force=False):
        """
        Add a model.

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

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

        Examples:

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

        try:
            model = model()
        except Exception:
            pass

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

        for k, v in model:
            self._elements[k] = v
            setattr(self, k, v)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get(self, filter=False):
        result = {}

        for k, v in self.elements().items():
            intermediate = v.get(filter=filter)
            if intermediate:
                result[k] = intermediate

        return result

Response: Returns a dictionary with the values of the YANG classes.


Instruction:
How would you implement a function in Python 3 that
loads a dictionary into the model.

Response:
def load_dict(self, data, overwrite=False, auto_load_model=True):
        """
        Load a dictionary into the model.

        Args:
            data(dict): Dictionary to load
            overwrite(bool): Whether the data present in the model should be overwritten by the
                data in the dict or not.
            auto_load_model(bool): If set to true models will be loaded as they are needed

        Examples:

            >>> vlans_dict = {
            >>>     "vlans": { "vlan": { 100: {
            >>>                             "config": {
            >>>                                 "vlan_id": 100, "name": "production"}},
            >>>                          200: {
            >>>                             "config": {
            >>>                                 "vlan_id": 200, "name": "dev"}}}}}
            >>> config.load_dict(vlans_dict)
            >>> print(config.vlans.vlan.keys())
            ... [200, 100]
            >>> print(100, config.vlans.vlan[100].config.name)
            ... (100, u'production')
            >>> print(200, config.vlans.vlan[200].config.name)
            ... (200, u'dev')
        """
        for k, v in data.items():
            if k not in self._elements.keys() and not auto_load_model:
                raise AttributeError("Model {} is not loaded".format(k))

            elif k not in self._elements.keys() and auto_load_model:
                self._load_model(k)

            attr = getattr(self, k)
            _load_dict(attr, v)


Instruction:
Implement a function in Python 3 to
return a dictionary with the values of the model.

Response:
def to_dict(self, filter=True):
        """
        Returns a dictionary with the values of the model. Note that the values
        of the leafs are evaluated to python types.

        Args:
            filter (bool): If set to ``True``, show only values that have been set.

        Returns:
            dict: A dictionary with the values of the model.

        Example:

            >>> pretty_print(config.to_dict(filter=True))
            >>> {
            >>>     "interfaces": {
            >>>         "interface": {
            >>>             "et1": {
            >>>                 "config": {
            >>>                     "description": "My description",
            >>>                     "mtu": 1500
            >>>                 },
            >>>                 "name": "et1"
            >>>             },
            >>>             "et2": {
            >>>                 "config": {
            >>>                     "description": "Another description",
            >>>                     "mtu": 9000
            >>>                 },
            >>>                 "name": "et2"
            >>>             }
            >>>         }
            >>>     }
            >>> }

        """
        result = {}
        for k, v in self:
            r = _to_dict(v, filter)
            if r:
                result[k] = r
        return result


Instruction:
Can you generate a brief explanation for the following Python 3 code
def parse_config(self, device=None, profile=None, native=None, attrs=None):
        if attrs is None:
            attrs = self.elements().values()

        for v in attrs:
            parser = Parser(
                v, device=device, profile=profile, native=native, is_config=True
            )
            parser.parse()

Response: Parse the configuration file into the corresponding models.


Instruction:
How would you explain what the following Python 3 function does
def parse_state(self, device=None, profile=None, native=None, attrs=None):
        if attrs is None:
            attrs = self.elements().values()

        for v in attrs:
            parser = Parser(
                v, device=device, profile=profile, native=native, is_config=False
            )
            parser.parse()

Response: Parse the state of the junos system into the corresponding models.


Instruction:
Can you tell what is the following Python 3 function doing
def translate_config(self, profile, merge=None, replace=None):
        result = []
        for k, v in self:
            other_merge = getattr(merge, k) if merge else None
            other_replace = getattr(replace, k) if replace else None
            translator = Translator(
                v, profile, merge=other_merge, replace=other_replace
            )
            result.append(translator.translate())

        return "\n".join(result)

Response: Translate the object to native configuration.


Instruction:
Given the following Python 3 function, write the documentation
def load_filters():
    all_filters = {}
    for m in JINJA_FILTERS:
        if hasattr(m, "filters"):
            all_filters.update(m.filters())
    return all_filters

Response: Loads and returns all filters.


Instruction:
Given the following Python 3 function, write the documentation
def _parse_list_nested_recursive(
        cls, data, path, iterators, list_vars, cur_vars=None
    ):
        """
        This helps parsing shit like:

            <protocols>
                <bgp>
                    <group>
                        <name>my_peers</name>
                        <neighbor>
                            <name>192.168.100.2</name>
                            <description>adsasd</description>
                            <peer-as>65100</peer-as>
                        </neighbor>
                        <neighbor>
                            <name>192.168.100.3</name>
                            <peer-as>65100</peer-as>
                        </neighbor>
                    </group>
                    <group>
                        <name>my_other_peers</name>
                        <neighbor>
                            <name>172.20.0.1</name>
                            <peer-as>65200</peer-as>
                        </neighbor>
                    </group>
                </bgp>
            </protocols>

        """
        cur_vars = dict(cur_vars) if cur_vars else {}
        if path:
            p = path[0]
            path = path[1:]
        else:
            for _ in data:
                list_vars.append(cur_vars)
            iterators.append(data)
            return data

        if p.startswith("?"):
            for x in data:
                key, var_path = p.split(".")
                cur_vars.update({key.lstrip("?"): x.xpath(var_path)[0].text})
                cls._parse_list_nested_recursive(
                    x, path, iterators, list_vars, cur_vars
                )
        else:
            x = data.xpath(p)
            cls._parse_list_nested_recursive(x, path, iterators, list_vars, cur_vars)

Response: Recursively parse the xml data for a nested list of objects.


Instruction:
Make a summary of the following Python 3 code
def _set_trunk_vlans(self, v, load=False):
        if hasattr(v, "_utype"):
            v = v._utype(v)
        try:
            t = YANGDynClass(
                v,
                base=TypedListType(
                    allowed_type=[
                        RestrictedClassType(
                            base_type=RestrictedClassType(
                                base_type=int,
                                restriction_dict={"range": ["0..65535"]},
                                int_size=16,
                            ),
                            restriction_dict={"range": ["1..4094"]},
                        ),
                        RestrictedClassType(
                            base_type=six.text_type,
                            restriction_dict={
                                "pattern": "(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])\\.\\.(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])"
                            },
                        ),
                        RestrictedClassType(
                            base_type=six.text_type,
                            restriction_dict={
                                "pattern": "(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])\\.((409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])|\\*)"
                            },
                        ),
                        RestrictedClassType(
                            base_type=six.text_type,
                            restriction_dict={
                                "pattern": "(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])\\.\\.(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])\\.((409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])|\\*)"
                            },
                        ),
                        RestrictedClassType(
                            base_type=six.text_type,
                            restriction_dict={
                                "pattern": "(\\*|(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9]))\\.(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])\\.\\.(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])"
                            },
                        ),
                    ]
                ),
                is_leaf=False,
                yang_name="trunk-vlans",
                parent=self,
                path_helper=self._path_helper,
                extmethods=self._extmethods,
                register_paths=True,
                namespace="http://openconfig.net/yang/vlan",
                defining_module="openconfig-vlan",
                yang_type="union",
                is_config=False,
            )
        except (TypeError, ValueError):
            raise ValueError(
                {
                    "error-string": """trunk_vlans must be of a type compatible with union""",
                    "defined-type": "openconfig-vlan:union",
                    "generated-type": """YANGDynClass(base=TypedListType(allowed_type=[RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])\\.\\.(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])\\.((409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])|\\*)'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])\\.\\.(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])\\.((409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])|\\*)'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(\\*|(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9]))\\.(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])\\.\\.(409[0-4]|40[0-8][0-9]|[1-3][0-9]{3}|[1-9][0-9]{1,2}|[1-9])'}),]), is_leaf=False, yang_name="trunk-vlans", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/vlan', defining_module='openconfig-vlan', yang_type='union', is_config=False)""",
                }
            )

        self.__trunk_vlans = t
        if hasattr(self, "_set"):
            self._set()

Response: Sets the value of the trunk_vlans property of the base node.


Instruction:
How would you code a function in Python 3 to
find the necessary file for the given profile and filename.

Response:
def find_yang_file(profile, filename, path):
    """
    Find the necessary file for the given test case.

    Args:
        device(napalm device connection): for which device
        filename(str): file to find
        path(str): where to find it relative to where the module is installed
    """
    # Find base_dir of submodule
    module_dir = os.path.dirname(__file__)
    full_path = os.path.join(module_dir, "mappings", profile, path, filename)

    if os.path.exists(full_path):
        return full_path
    else:
        msg = "Couldn't find parsing file: {}".format(full_path)
        logger.error(msg)
        raise IOError(msg)


Instruction:
Given the following Python 3 function, write the documentation
def model_to_dict(model, mode="", show_defaults=False):

    def is_mode(obj, mode):
        if mode == "":
            return True
        elif mode == "config":
            return obj._yang_name == "config" or obj._is_config
        elif mode == "state":
            return obj._yang_name == "state" or not obj._is_config
        else:
            raise ValueError(
                "mode can only be config, state or ''. Passed: {}".format(mode)
            )

    def get_key(key, model, parent_defining_module, show_defaults):
        if not show_defaults:
            # No need to display rw/ro when showing the defaults.
            key = "{} {}".format(key, "[rw]" if model._is_config else "[ro]")
        if parent_defining_module != model._defining_module:
            key = "{}:{}".format(model._defining_module, key)
        return key

    if model._yang_type in ("container", "list"):
        cls = model if model._yang_type in ("container",) else model._contained_class()
        result = {}
        for k, v in cls:
            r = model_to_dict(v, mode=mode, show_defaults=show_defaults)
            if r:
                result[get_key(k, v, model._defining_module, show_defaults)] = r
        return result
    else:
        if show_defaults:
            if model._default is False:
                if model._yang_type != "boolean":
                    # Unless the datatype is bool, when the _default attribute
                    # is False, it means there is not default value defined in
                    # the YANG model.
                    return None
            return model._default
        return model._yang_type if is_mode(model, mode) else None

Response: Given a model return a dictionary representation of the model.


Instruction:
How would you implement a function in Python 3 that
returns the difference between two models.

Response:
def diff(f, s):
    """
    Given two models, return the difference between them.

    Args:

        f (Pybindbase): First element.
        s (Pybindbase): Second element.

    Returns:

        dict: A dictionary highlighting the differences.

    Examples:

        >>> diff = napalm_yang.utils.diff(candidate, running)
        >>> pretty_print(diff)
        >>> {
        >>>     "interfaces": {
        >>>         "interface": {
        >>>             "both": {
        >>>                 "Port-Channel1": {
        >>>                     "config": {
        >>>                         "mtu": {
        >>>                             "first": "0",
        >>>                             "second": "9000"
        >>>                         }
        >>>                     }
        >>>                 }
        >>>             },
        >>>             "first_only": [
        >>>                 "Loopback0"
        >>>             ],
        >>>             "second_only": [
        >>>                 "Loopback1"
        >>>             ]
        >>>         }
        >>>     }
        >>> }
    """
    if isinstance(f, base.Root) or f._yang_type in ("container", None):
        result = _diff_root(f, s)
    elif f._yang_type in ("list",):
        result = _diff_list(f, s)
    else:
        result = {}
        first = "{}".format(f)
        second = "{}".format(s)
        if first != second:
            result = {"first": first, "second": second}

    return result


Instruction:
Write a Python 3 function that can
post to URL and get result as a response object.

Response:
def http_post(self, url, data=None):
        """POST to URL and get result as a response object.

        :param url: URL to POST.
        :type url: str
        :param data: Data to send in the form body.
        :type data: str
        :rtype: requests.Response
        """
        if not url.startswith('https://'):
            raise ValueError('Protocol must be HTTPS, invalid URL: %s' % url)
        return requests.post(url, data, verify=True)


Instruction:
Can you generate the documentation for the following Python 3 function
def get_authorization_code_uri(self, **params):
        if 'response_type' not in params:
            params['response_type'] = self.default_response_type
        params.update({'client_id': self.client_id,
                       'redirect_uri': self.redirect_uri})
        return utils.build_url(self.authorization_uri, params)

Response: Construct a full URL that can be used to obtain an authorization code from the provider authorization_uri.


Instruction:
Can you write a function in Python 3 where it
gets an access token from the provider token URI.

Response:
def get_token(self, code, **params):
        """Get an access token from the provider token URI.

        :param code: Authorization code.
        :type code: str
        :return: Dict containing access token, refresh token, etc.
        :rtype: dict
        """
        params['code'] = code
        if 'grant_type' not in params:
            params['grant_type'] = self.default_grant_type
        params.update({'client_id': self.client_id,
                       'client_secret': self.client_secret,
                       'redirect_uri': self.redirect_uri})
        response = self.http_post(self.token_uri, params)
        try:
            return response.json()
        except TypeError:
            return response.json


Instruction:
Implement a Python 3 function for
returning the query parameters as a dict from the specified URL.

Response:
def url_query_params(url):
    """Return query parameters as a dict from the specified URL.

    :param url: URL.
    :type url: str
    :rtype: dict
    """
    return dict(urlparse.parse_qsl(urlparse.urlparse(url).query, True))


Instruction:
How would you explain what the following Python 3 function does
def url_dequery(url):
    url = urlparse.urlparse(url)
    return urlparse.urlunparse((url.scheme,
                                url.netloc,
                                url.path,
                                url.params,
                                '',
                                url.fragment))

Response: Return a URL with the query component removed.


Instruction:
Create a Python 3 function for
constructing a URL based off of base containing all parameters in the query portion of base plus any additional parameters.

Response:
def build_url(base, additional_params=None):
    """Construct a URL based off of base containing all parameters in
    the query portion of base plus any additional parameters.

    :param base: Base URL
    :type base: str
    ::param additional_params: Additional query parameters to include.
    :type additional_params: dict
    :rtype: str
    """
    url = urlparse.urlparse(base)
    query_params = {}
    query_params.update(urlparse.parse_qsl(url.query, True))
    if additional_params is not None:
        query_params.update(additional_params)
        for k, v in additional_params.iteritems():
            if v is None:
                query_params.pop(k)

    return urlparse.urlunparse((url.scheme,
                                url.netloc,
                                url.path,
                                url.params,
                                urllib.urlencode(query_params),
                                url.fragment))


Instruction:
Implement a Python 3 function for
handling an internal exception that was caught and suppressed.

Response:
def _handle_exception(self, exc):
        """Handle an internal exception that was caught and suppressed.

        :param exc: Exception to process.
        :type exc: Exception
        """
        logger = logging.getLogger(__name__)
        logger.exception(exc)


Instruction:
Can you write a function in Python 3 where it
returns a Response object from the given parameters.

Response:
def _make_response(self, body='', headers=None, status_code=200):
        """Return a response object from the given parameters.

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


Instruction:
Can you generate a brief explanation for the following Python 3 code
def _make_redirect_error_response(self, redirect_uri, err):
        params = {
            'error': err,
            'response_type': None,
            'client_id': None,
            'redirect_uri': None
        }
        redirect = utils.build_url(redirect_uri, params)
        return self._make_response(headers={'Location': redirect},
                                   status_code=302)

Response: Create a HTTP 302 redirect response object containing the error.


Instruction:
Here you have a function in Python 3, explain what it does
def _make_json_response(self, data, headers=None, status_code=200):
        response_headers = {}
        if headers is not None:
            response_headers.update(headers)
        response_headers['Content-Type'] = 'application/json;charset=UTF-8'
        response_headers['Cache-Control'] = 'no-store'
        response_headers['Pragma'] = 'no-cache'
        return self._make_response(json.dumps(data),
                                   response_headers,
                                   status_code)

Response: Return a response object from the given JSON data.


Instruction:
Implement a Python 3 function for
generating and return an authorization code HTTP response.

Response:
def get_authorization_code(self,
                               response_type,
                               client_id,
                               redirect_uri,
                               **params):
        """Generate authorization code HTTP response.

        :param response_type: Desired response type. Must be exactly "code".
        :type response_type: str
        :param client_id: Client ID.
        :type client_id: str
        :param redirect_uri: Client redirect URI.
        :type redirect_uri: str
        :rtype: requests.Response
        """

        # Ensure proper response_type
        if response_type != 'code':
            err = 'unsupported_response_type'
            return self._make_redirect_error_response(redirect_uri, err)

        # Check redirect URI
        is_valid_redirect_uri = self.validate_redirect_uri(client_id,
                                                           redirect_uri)
        if not is_valid_redirect_uri:
            return self._invalid_redirect_uri_response()

        # Check conditions
        is_valid_client_id = self.validate_client_id(client_id)
        is_valid_access = self.validate_access()
        scope = params.get('scope', '')
        is_valid_scope = self.validate_scope(client_id, scope)

        # Return proper error responses on invalid conditions
        if not is_valid_client_id:
            err = 'unauthorized_client'
            return self._make_redirect_error_response(redirect_uri, err)

        if not is_valid_access:
            err = 'access_denied'
            return self._make_redirect_error_response(redirect_uri, err)

        if not is_valid_scope:
            err = 'invalid_scope'
            return self._make_redirect_error_response(redirect_uri, err)

        # Generate authorization code
        code = self.generate_authorization_code()

        # Save information to be used to validate later requests
        self.persist_authorization_code(client_id=client_id,
                                        code=code,
                                        scope=scope)

        # Return redirection response
        params.update({
            'code': code,
            'response_type': None,
            'client_id': None,
            'redirect_uri': None
        })
        redirect = utils.build_url(redirect_uri, params)
        return self._make_response(headers={'Location': redirect},
                                   status_code=302)


Instruction:
How would you explain what the following Python 3 function does
def refresh_token(self,
                      grant_type,
                      client_id,
                      client_secret,
                      refresh_token,
                      **params):
        """Generate access token HTTP response from a refresh token.

        :param grant_type: Desired grant type. Must be "refresh_token".
        :type grant_type: str
        :param client_id: Client ID.
        :type client_id: str
        :param client_secret: Client secret.
        :type client_secret: str
        :param refresh_token: Refresh token.
        :type refresh_token: str
        :rtype: requests.Response
        """

        # Ensure proper grant_type
        if grant_type != 'refresh_token':
            return self._make_json_error_response('unsupported_grant_type')

        # Check conditions
        is_valid_client_id = self.validate_client_id(client_id)
        is_valid_client_secret = self.validate_client_secret(client_id,
                                                             client_secret)
        scope = params.get('scope', '')
        is_valid_scope = self.validate_scope(client_id, scope)
        data = self.from_refresh_token(client_id, refresh_token, scope)
        is_valid_refresh_token = data is not None

        # Return proper error responses on invalid conditions
        if not (is_valid_client_id and is_valid_client_secret):
            return self._make_json_error_response('invalid_client')

        if not is_valid_scope:
            return self._make_json_error_response('invalid_scope')

        if not is_valid_refresh_token:
            return self._make_json_error_response('invalid_grant')

        # Discard original refresh token
        self.discard_refresh_token(client_id, refresh_token)

        # Generate access tokens once all conditions have been met
        access_token = self.generate_access_token()
        token_type = self.token_type
        expires_in = self.token_expires_in
        refresh_token = self.generate_refresh_token()

        # Save information to be used to validate later requests
        self.persist_token_information(client_id=client_id,
                                       scope=scope,
                                       access_token=access_token,
                                       token_type=token_type,
                                       expires_in=expires_in,
                                       refresh_token=refresh_token,
                                       data=data)

        # Return json response
        return self._make_json_response({
            'access_token': access_token,
            'token_type': token_type,
            'expires_in': expires_in,
            'refresh_token': refresh_token
        })

Response: Generate an access token HTTP response from a refresh token.