Instruction:
Can you tell what is the following Python 3 function doing
def _on_message(self, delivery_frame, properties, body, consumer):
        _legacy_twisted_log.msg(
            "Message arrived with delivery tag {tag} for {consumer}",
            tag=delivery_frame.delivery_tag,
            consumer=consumer,
            logLevel=logging.DEBUG,
        )
        try:
            message = get_message(delivery_frame.routing_key, properties, body)
            message.queue = consumer.queue
        except ValidationError:
            _legacy_twisted_log.msg(
                "Message id {msgid} did not pass validation; ignoring message",
                msgid=properties.message_id,
                logLevel=logging.WARNING,
            )
            yield consumer.channel.basic_nack(
                delivery_tag=delivery_frame.delivery_tag, requeue=False
            )
            return

        try:
            _legacy_twisted_log.msg(
                "Consuming message from topic {topic!r} (id {msgid})",
                topic=message.topic,
                msgid=properties.message_id,
            )
            yield defer.maybeDeferred(consumer.callback, message)
        except Nack:
            _legacy_twisted_log.msg(
                "Returning message id {msgid} to the queue",
                msgid=properties.message_id,
                logLevel=logging.WARNING,
            )
            yield consumer.channel.basic_nack(
                delivery_tag=delivery_frame.delivery_tag, requeue=True
            )
        except Drop:
            _legacy_twisted_log.msg(
                "Consumer requested message id {msgid} be dropped",
                msgid=properties.message_id,
                logLevel=logging.WARNING,
            )
            yield consumer.channel.basic_nack(
                delivery_tag=delivery_frame.delivery_tag, requeue=False
            )
        except HaltConsumer:
            _legacy_twisted_log.msg(
                "Consumer indicated it wishes consumption to halt, shutting down"
            )
            yield consumer.channel.basic_ack(delivery_tag=delivery_frame.delivery_tag)
            yield self.cancel(consumer.queue)
        except Exception:
            _legacy_twisted_log.msg(
                "Received unexpected exception from consumer {c}",
                c=consumer,
                logLevel=logging.ERROR,
            )
            yield consumer.channel.basic_nack(
                delivery_tag=0, multiple=True, requeue=True
            )
            yield self.cancel(consumer.queue)
        else:
            yield consumer.channel.basic_ack(delivery_tag=delivery_frame.delivery_tag)

Response: A message arrived from the server.


Instruction:
How would you implement a function in Python 3 that
registers a message consumer that executes the provided callback when a message is received.

Response:
def consume(self, callback, queue):
        """
        Register a message consumer that executes the provided callback when
        messages are received.

        The queue must exist prior to calling this method.  If a consumer
        already exists for the given queue, the callback is simply updated and
        any new messages for that consumer use the new callback.

        If :meth:`resumeProducing` has not been called when this method is called,
        it will be called for you.

        Args:
            callback (callable): The callback to invoke when a message is received.
            queue (str): The name of the queue to consume from.

        Returns:
            fedora_messaging.twisted.protocol.Consumer: A namedtuple that
            identifies this consumer.

        NoFreeChannels: If there are no available channels on this connection.
            If this occurs, you can either reduce the number of consumers on this
            connection or create an additional connection.
        """
        if queue in self._consumers and self._consumers[queue].channel.is_open:
            consumer = Consumer(
                tag=self._consumers[queue].tag,
                queue=queue,
                callback=callback,
                channel=self._consumers[queue].channel,
            )
            self._consumers[queue] = consumer
            defer.returnValue(consumer)

        channel = yield self._allocate_channel()
        consumer = Consumer(
            tag=str(uuid.uuid4()), queue=queue, callback=callback, channel=channel
        )

        self._consumers[queue] = consumer
        if not self._running:
            yield self.resumeProducing()
            defer.returnValue(consumer)

        queue_object, _ = yield consumer.channel.basic_consume(
            queue=consumer.queue, consumer_tag=consumer.tag
        )
        deferred = self._read(queue_object, consumer)
        deferred.addErrback(
            lambda f: _legacy_twisted_log.msg,
            "_read failed on consumer {c}",
            c=consumer,
            logLevel=logging.ERROR,
        )
        _legacy_twisted_log.msg("Successfully registered AMQP consumer {c}", c=consumer)
        defer.returnValue(consumer)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def cancel(self, queue):
        try:
            consumer = self._consumers[queue]
            yield consumer.channel.basic_cancel(consumer_tag=consumer.tag)
        except pika.exceptions.AMQPChannelError:
            # Consumers are tied to channels, so if this channel is dead the
            # consumer should already be canceled (and we can't get to it anyway)
            pass
        except KeyError:
            defer.returnValue(None)

        try:
            yield consumer.channel.close()
        except pika.exceptions.AMQPChannelError:
            pass

        del self._consumers[queue]

Response: Cancel the consumer for a queue.


Instruction:
Can you write a function in Python 3 where it
starts or resumes the retrieval of messages from the server queue.

Response:
def resumeProducing(self):
        """
        Starts or resumes the retrieval of messages from the server queue.

        This method starts receiving messages from the server, they will be
        passed to the consumer callback.

        .. note:: This is called automatically when :meth:`.consume` is called,
            so users should not need to call this unless :meth:`.pauseProducing`
            has been called.

        Returns:
            defer.Deferred: fired when the production is ready to start
        """
        # Start consuming
        self._running = True
        for consumer in self._consumers.values():
            queue_object, _ = yield consumer.channel.basic_consume(
                queue=consumer.queue, consumer_tag=consumer.tag
            )
            deferred = self._read(queue_object, consumer)
            deferred.addErrback(
                lambda f: _legacy_twisted_log.msg,
                "_read failed on consumer {c}",
                c=consumer,
                logLevel=logging.ERROR,
            )
        _legacy_twisted_log.msg("AMQP connection successfully established")


Instruction:
Create a Python 3 function to
pause the consumer and cancel all consumers that are currently being processed.

Response:
def pauseProducing(self):
        """
        Pause the reception of messages by canceling all existing consumers.
        This does not disconnect from the server.

        Message reception can be resumed with :meth:`resumeProducing`.

        Returns:
            Deferred: fired when the production is paused.
        """
        if not self._running:
            return
        # Exit the read loop and cancel the consumer on the server.
        self._running = False
        for consumer in self._consumers.values():
            yield consumer.channel.basic_cancel(consumer_tag=consumer.tag)
        _legacy_twisted_log.msg("Paused retrieval of messages for the server queue")


Instruction:
Can you create a Python 3 function that
stops producing messages and disconnect from the server.

Response:
def stopProducing(self):
        """
        Stop producing messages and disconnect from the server.
        Returns:
            Deferred: fired when the production is stopped.
        """
        _legacy_twisted_log.msg("Disconnecting from the AMQP broker")
        yield self.pauseProducing()
        yield self.close()
        self._consumers = {}
        self._channel = None


Instruction:
Here you have a function in Python 3, explain what it does
def get_class(schema_name):
    global _registry_loaded
    if not _registry_loaded:
        load_message_classes()

    try:
        return _schema_name_to_class[schema_name]
    except KeyError:
        _log.warning(
            'The schema "%s" is not in the schema registry! Either install '
            "the package with its schema definition or define a schema. "
            "Falling back to the default schema...",
            schema_name,
        )
        return Message

Response: Returns the sub - class of the specified schema name.


Instruction:
Create a Python 3 function to
retrieve the schema name associated with a message class.

Response:
def get_name(cls):
    """
    Retrieve the schema name associated with a message class.

    Returns:
        str: The schema name.

    Raises:
        TypeError: If the message class isn't registered. Check your entry point
            for correctness.
    """
    global _registry_loaded
    if not _registry_loaded:
        load_message_classes()

    try:
        return _class_to_schema_name[cls]
    except KeyError:
        raise TypeError(
            "The class {} is not in the message registry, which indicates it is"
            ' not in the current list of entry points for "fedora_messaging".'
            " Please check that the class has been added to your package's"
            " entry points.".format(repr(cls))
        )


Instruction:
Can you implement a function in Python 3 that
loads the Fedora. messages entry points and register the message classes.

Response:
def load_message_classes():
    """Load the 'fedora.messages' entry points and register the message classes."""
    for message in pkg_resources.iter_entry_points("fedora.messages"):
        cls = message.load()
        _log.info(
            "Registering the '%s' key as the '%r' class in the Message "
            "class registry",
            message.name,
            cls,
        )
        _schema_name_to_class[message.name] = cls
        _class_to_schema_name[cls] = message.name
    global _registry_loaded
    _registry_loaded = True


Instruction:
Can you create a Python 3 function that
constructs a new Message instance from the properties and body.

Response:
def get_message(routing_key, properties, body):
    """
    Construct a Message instance given the routing key, the properties and the
    body received from the AMQP broker.

    Args:
        routing_key (str): The AMQP routing key (will become the message topic)
        properties (pika.BasicProperties): the AMQP properties
        body (bytes): The encoded message body

    Raises:
        ValidationError: If Message validation failed or message body
            docoding/loading is impossible.
    """
    if properties.headers is None:
        _log.error(
            "Message (body=%r) arrived without headers. " "A publisher is misbehaving!",
            body,
        )
        properties.headers = {}

    try:
        MessageClass = get_class(properties.headers["fedora_messaging_schema"])
    except KeyError:
        _log.error(
            "Message (headers=%r, body=%r) arrived without a schema header."
            " A publisher is misbehaving!",
            properties.headers,
            body,
        )
        MessageClass = Message

    try:
        severity = properties.headers["fedora_messaging_severity"]
    except KeyError:
        _log.error(
            "Message (headers=%r, body=%r) arrived without a severity."
            " A publisher is misbehaving! Defaulting to INFO.",
            properties.headers,
            body,
        )
        severity = INFO

    if properties.content_encoding is None:
        _log.error("Message arrived without a content encoding")
        properties.content_encoding = "utf-8"
    try:
        body = body.decode(properties.content_encoding)
    except UnicodeDecodeError as e:
        _log.error(
            "Unable to decode message body %r with %s content encoding",
            body,
            properties.content_encoding,
        )
        raise ValidationError(e)

    try:
        body = json.loads(body)
    except ValueError as e:
        _log.error("Failed to load message body %r, %r", body, e)
        raise ValidationError(e)

    message = MessageClass(
        body=body, topic=routing_key, properties=properties, severity=severity
    )
    try:
        message.validate()
        _log.debug("Successfully validated message %r", message)
    except jsonschema.exceptions.ValidationError as e:
        _log.error("Message validation of %r failed: %r", message, e)
        raise ValidationError(e)
    return message


Instruction:
Implement a Python 3 function for
serializing a list of messages to a JSON formatted str.

Response:
def dumps(messages):
    """
    Serialize messages to a JSON formatted str

    Args:
        messages (list): The list of messages to serialize. Each message in
            the messages is subclass of Messge.

    Returns:
        str: Serialized messages.

    Raises:
        TypeError: If at least one message is not instance of Message class or subclass.
    """
    serialized_messages = []
    try:
        for message in messages:
            message_dict = message._dump()
            serialized_messages.append(message_dict)
    except AttributeError:
        _log.error("Improper object for messages serialization.")
        raise TypeError("Message have to be instance of Message class or subclass.")

    return json.dumps(serialized_messages, sort_keys=True)


Instruction:
Explain what the following Python 3 code does
def _filter_headers(self):
        headers = {}
        for user in self.usernames:
            headers["fedora_messaging_user_{}".format(user)] = True
        for package in self.packages:
            headers["fedora_messaging_rpm_{}".format(package)] = True
        for container in self.containers:
            headers["fedora_messaging_container_{}".format(container)] = True
        for module in self.modules:
            headers["fedora_messaging_module_{}".format(module)] = True
        for flatpak in self.flatpaks:
            headers["fedora_messaging_flatpak_{}".format(flatpak)] = True
        return headers

Response: Add headers designed for filtering messages based on objects.


Instruction:
How would you implement a function in Python 3 that
validates the message headers and body with the user - provided schema.

Response:
def validate(self):
        """
        Validate the headers and body with the message schema, if any.

        In addition to the user-provided schema, all messages are checked against
        the base schema which requires certain message headers and the that body
        be a JSON object.

        .. warning:: This method should not be overridden by sub-classes.

        Raises:
            jsonschema.ValidationError: If either the message headers or the message body
                are invalid.
            jsonschema.SchemaError: If either the message header schema or the message body
                schema are invalid.
        """
        for schema in (self.headers_schema, Message.headers_schema):
            _log.debug(
                'Validating message headers "%r" with schema "%r"',
                self._headers,
                schema,
            )
            jsonschema.validate(self._headers, schema)
        for schema in (self.body_schema, Message.body_schema):
            _log.debug(
                'Validating message body "%r" with schema "%r"', self.body, schema
            )
            jsonschema.validate(self.body, schema)


Instruction:
Implement a Python 3 function for
dumping message attributes. Returns: dict: A dictionary of message attributes.

Response:
def _dump(self):
        """
        Dump message attributes.

        Returns:
            dict: A dictionary of message attributes.
        """
        return {
            "topic": self.topic,
            "headers": self._headers,
            "id": self.id,
            "body": self.body,
            "queue": self.queue,
        }


Instruction:
Can you tell what is the following Python 3 function doing
def _check_callback(callback):
    # If the callback is a class, create an instance of it first
    if inspect.isclass(callback):
        callback_object = callback()
        if not callable(callback_object):
            raise ValueError(
                "Callback must be a class that implements __call__ or a function."
            )
    elif callable(callback):
        callback_object = callback
    else:
        raise ValueError(
            "Callback must be a class that implements __call__ or a function."
        )

    return callback_object

Response: Checks if a callback is potentially a class and creates an instance of it.


Instruction:
Can you tell what is the following Python 3 function doing
def twisted_consume(callback, bindings=None, queues=None):
    if isinstance(bindings, dict):
        bindings = [bindings]
    callback = _check_callback(callback)

    global _twisted_service
    if _twisted_service is None:
        _twisted_service = service.FedoraMessagingServiceV2(config.conf["amqp_url"])
        reactor.callWhenRunning(_twisted_service.startService)
        # Twisted is killing the underlying connection before stopService gets
        # called, so we need to add it as a pre-shutdown event to gracefully
        # finish up messages in progress.
        reactor.addSystemEventTrigger(
            "before", "shutdown", _twisted_service.stopService
        )

    return _twisted_service._service.factory.consume(callback, bindings, queues)

Response: Start a consumer using the provided callback and run it using the Twisted - managed thread pool.


Instruction:
Write a Python 3 script for
starting a message consumer that executes the provided callback when messages are received from the operating system.

Response:
def consume(callback, bindings=None, queues=None):
    """
    Start a message consumer that executes the provided callback when messages are
    received.

    This API is blocking and will not return until the process receives a signal
    from the operating system.

    .. warning:: This API is runs the callback in the IO loop thread. This means
        if your callback could run for a length of time near the heartbeat interval,
        which is likely on the order of 60 seconds, the broker will kill the TCP
        connection and the message will be re-delivered on start-up.

        For now, use the :func:`twisted_consume` API which runs the
        callback in a thread and continues to handle AMQP events while the
        callback runs if you have a long-running callback.

    The callback receives a single positional argument, the message:

    >>> from fedora_messaging import api
    >>> def my_callback(message):
    ...     print(message)
    >>> bindings = [{'exchange': 'amq.topic', 'queue': 'demo', 'routing_keys': ['#']}]
    >>> queues = {
    ...     "demo": {"durable": False, "auto_delete": True, "exclusive": True, "arguments": {}}
    ... }
    >>> api.consume(my_callback, bindings=bindings, queues=queues)

    If the bindings and queue arguments are not provided, they will be loaded from
    the configuration.

    For complete documentation on writing consumers, see the :ref:`consumers`
    documentation.

    Args:
        callback (callable): A callable object that accepts one positional argument,
            a :class:`Message` or a class object that implements the ``__call__``
            method. The class will be instantiated before use.
        bindings (dict or list of dict): Bindings to declare before consuming. This
            should be the same format as the :ref:`conf-bindings` configuration.
        queues (dict): The queue or queues to declare and consume from. This should be
            in the same format as the :ref:`conf-queues` configuration dictionary where
            each key is a queue name and each value is a dictionary of settings for that
            queue.

    Raises:
        fedora_messaging.exceptions.HaltConsumer: If the consumer requests that
            it be stopped.
        ValueError: If the consumer provide callback that is not a class that
            implements __call__ and is not a function, if the bindings argument
            is not a dict or list of dicts with the proper keys, or if the queues
            argument isn't a dict with the proper keys.
    """
    if isinstance(bindings, dict):
        bindings = [bindings]

    if bindings is None:
        bindings = config.conf["bindings"]
    else:
        try:
            config.validate_bindings(bindings)
        except exceptions.ConfigurationException as e:
            raise ValueError(e.message)

    if queues is None:
        queues = config.conf["queues"]
    else:
        try:
            config.validate_queues(queues)
        except exceptions.ConfigurationException as e:
            raise ValueError(e.message)

    session = _session.ConsumerSession()
    session.consume(callback, bindings=bindings, queues=queues)


Instruction:
Can you generate the documentation for the following Python 3 function
def publish(message, exchange=None):
    pre_publish_signal.send(publish, message=message)

    if exchange is None:
        exchange = config.conf["publish_exchange"]

    global _session_cache
    if not hasattr(_session_cache, "session"):
        _session_cache.session = _session.PublisherSession()

    try:
        _session_cache.session.publish(message, exchange=exchange)
        publish_signal.send(publish, message=message)
    except exceptions.PublishException as e:
        publish_failed_signal.send(publish, message=message, reason=e)
        raise

Response: Publish a message to an exchange.


Instruction:
Write a Python 3 script to
create the Protocol instance.

Response:
def buildProtocol(self, addr):
        """Create the Protocol instance.

        See the documentation of
        `twisted.internet.protocol.ReconnectingClientFactory` for details.
        """
        self.resetDelay()
        self.client = self.protocol(self._parameters)
        self.client.factory = self
        self.client.ready.addCallback(lambda _: self._on_client_ready())
        return self.client


Instruction:
Can you tell what is the following Python 3 function doing
def _on_client_ready(self):
        _legacy_twisted_log.msg("Successfully connected to the AMQP broker.")
        yield self.client.resumeProducing()

        yield self.client.declare_exchanges(self.exchanges)
        yield self.client.declare_queues(self.queues)
        yield self.client.bind_queues(self.bindings)
        for queue, callback in self.consumers.items():
            yield self.client.consume(callback, queue)

        _legacy_twisted_log.msg("Successfully declared all AMQP objects.")
        self._client_ready.callback(None)

Response: Called when the client is ready to send and receive messages.


Instruction:
Can you generate the documentation for the following Python 3 function
def clientConnectionLost(self, connector, reason):
        if not isinstance(reason.value, error.ConnectionDone):
            _legacy_twisted_log.msg(
                "Lost connection to the AMQP broker ({reason})",
                reason=reason.value,
                logLevel=logging.WARNING,
            )
        if self._client_ready.called:
            # Renew the ready deferred, it will callback when the
            # next connection is ready.
            self._client_ready = defer.Deferred()
        protocol.ReconnectingClientFactory.clientConnectionLost(self, connector, reason)

Response: Called when the connection to the broker has been lost.


Instruction:
Here you have a function in Python 3, explain what it does
def clientConnectionFailed(self, connector, reason):
        _legacy_twisted_log.msg(
            "Connection to the AMQP broker failed ({reason})",
            reason=reason.value,
            logLevel=logging.WARNING,
        )
        protocol.ReconnectingClientFactory.clientConnectionFailed(
            self, connector, reason
        )

Response: Called when the client has failed to connect to the broker.


Instruction:
Can you tell what is the following Python 3 function doing
def stopTrying(self):
        protocol.ReconnectingClientFactory.stopTrying(self)
        if not self._client_ready.called:
            self._client_ready.errback(
                pika.exceptions.AMQPConnectionError(
                    u"Could not connect, reconnection cancelled."
                )
            )

Response: Stop trying to reconnect to the broker.


Instruction:
Explain what the following Python 3 code does
def stopFactory(self):
        if self.client:
            yield self.client.stopProducing()
        protocol.ReconnectingClientFactory.stopFactory(self)

Response:
Stop the factory.

        See the documentation of
        `twisted.internet.protocol.ReconnectingClientFactory` for details.


Instruction:
Can you tell what is the following Python 3 function doing
def consume(self, callback, queue):
        self.consumers[queue] = callback
        if self._client_ready.called:
            return self.client.consume(callback, queue)

Response: Register a new consumer.


Instruction:
How would you implement a function in Python 3 that
cancels the consumer for a queue.

Response:
def cancel(self, queue):
        """
        Cancel the consumer for a queue.

        This removes the consumer from the list of consumers to be configured for
        every connection.

        Args:
            queue (str): The name of the queue the consumer is subscribed to.
        Returns:
            defer.Deferred or None: Either a Deferred that fires when the consumer
                is canceled, or None if the consumer was already canceled. Wrap
                the call in :func:`defer.maybeDeferred` to always receive a Deferred.
        """
        try:
            del self.consumers[queue]
        except KeyError:
            pass
        if self.client:
            return self.client.cancel(queue)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def publish(self, message, exchange=None):
        exchange = exchange or config.conf["publish_exchange"]
        while True:
            client = yield self.whenConnected()
            try:
                yield client.publish(message, exchange)
                break
            except ConnectionException:
                continue

Response: Publish a message to an AMQP exchange.


Instruction:
Can you implement a function in Python 3 that
creates the Protocol instance.

Response:
def buildProtocol(self, addr):
        """Create the Protocol instance.

        See the documentation of
        `twisted.internet.protocol.ReconnectingClientFactory` for details.
        """
        self._client = self.protocol(self._parameters, confirms=self.confirms)
        self._client.factory = self

        @defer.inlineCallbacks
        def on_ready(unused_param=None):
            """Reset the connection delay when the AMQP handshake is complete."""
            _std_log.debug("AMQP handshake completed; connection ready for use")
            self.resetDelay()
            self._client_deferred.callback(self._client)
            self._client_deferred = defer.Deferred()

            # Restart any consumer from previous connections that wasn't canceled
            # including queues and bindings, as the queue might not have been durable
            for consumer, queue, bindings in self._consumers.values():
                _std_log.info("Re-registering the %r consumer", consumer)
                yield self._client.declare_queues([queue])
                yield self._client.bind_queues(bindings)
                yield self._client.consume(consumer.callback, consumer.queue, consumer)

        def on_ready_errback(failure):
            """If opening the connection fails or is lost, this errback is called."""
            if failure.check(pika.exceptions.AMQPConnectionError, error.ConnectionDone):
                # In this case the connection failed to open. This will be called
                # if the TLS handshake goes wrong (likely) and it may be called if
                # the AMQP handshake fails. It's *probably* a problem with the
                # credentials.
                msg = (
                    "The TCP connection appears to have started, but the TLS or AMQP handshake "
                    "with the broker failed; check your connection and authentication "
                    "parameters and ensure your user has permission to access the vhost"
                )
                wrapped_failure = Failure(
                    exc_value=ConnectionException(reason=msg, original=failure),
                    exc_type=ConnectionException,
                )
                self._client_deferred.errback(wrapped_failure)
            else:
                # Some unexpected exception happened
                _std_log.exception(
                    "The connection failed with an unexpected exception; please report this bug."
                )

        self._client.ready.addCallback(on_ready)
        self._client.ready.addErrback(on_ready_errback)
        return self._client


Instruction:
Can you tell what is the following Python 3 function doing
def stopFactory(self):
        if self._client:
            yield self._client.halt()
        protocol.ReconnectingClientFactory.stopFactory(self)

Response:
Stop the factory.

        See the documentation of
        `twisted.internet.protocol.ReconnectingClientFactory` for details.


Instruction:
Given the following Python 3 function, write the documentation
def when_connected(self):
        if self._client and not self._client.is_closed:
            return defer.succeed(self._client)
        else:
            return self._client_deferred

Response: Returns a Deferred that fires with a connectedFedoraMessagingProtocolV2 instance.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def consume(self, callback, bindings, queues):
        expanded_bindings = collections.defaultdict(list)
        for binding in bindings:
            for key in binding["routing_keys"]:
                b = binding.copy()
                del b["routing_keys"]
                b["routing_key"] = key
                expanded_bindings[b["queue"]].append(b)

        expanded_queues = []
        for name, settings in queues.items():
            q = {"queue": name}
            q.update(settings)
            expanded_queues.append(q)

        protocol = yield self.when_connected()

        consumers = []
        for queue in expanded_queues:
            yield protocol.declare_queues([queue])
            b = expanded_bindings.get(queue["queue"], [])
            yield protocol.bind_queues(b)
            consumer = yield protocol.consume(callback, queue["queue"])
            self._consumers[queue["queue"]] = (consumer, queue, b)
            consumers.append(consumer)

        defer.returnValue(consumers)

Response: Start a consumer that will consume messages from a queue.


Instruction:
Can you implement a function in Python 3 that
cancels a consumer that was previously started with consume.

Response:
def cancel(self, consumers):
        """
        Cancel a consumer that was previously started with consume.

        Args:
            consumer (list of fedora_messaging.api.Consumer): The consumers to cancel.
        """
        for consumer in consumers:
            del self._consumers[consumer.queue]
            protocol = yield self.when_connected()
            yield protocol.cancel(consumer)


Instruction:
How would you explain what the following Python 3 function does
def cancel(self):
        # Remove it from protocol and factory so it doesn't restart later.
        try:
            del self._protocol._consumers[self.queue]
        except (KeyError, AttributeError):
            pass
        try:
            del self._protocol.factory._consumers[self.queue]
        except (KeyError, AttributeError):
            pass
        # Signal to the _read loop it's time to stop and wait for it to finish
        # with whatever message it might be working on, then wait for the deferred
        # to fire which indicates it is done.
        self._running = False
        yield self._read_loop
        try:
            yield self._channel.basic_cancel(consumer_tag=self._tag)
        except pika.exceptions.AMQPChannelError:
            # Consumers are tied to channels, so if this channel is dead the
            # consumer should already be canceled (and we can't get to it anyway)
            pass
        try:
            yield self._channel.close()
        except pika.exceptions.AMQPChannelError:
            pass
        if not self.result.called:
            self.result.callback(self)

Response: Cancel the consumer and clean up resources associated with it.


Instruction:
Create a Python 3 function to
validate the bindings configuration.

Response:
def validate_bindings(bindings):
    """
    Validate the bindings configuration.

    Raises:
        exceptions.ConfigurationException: If the configuration provided is of an
            invalid format.
    """
    if not isinstance(bindings, (list, tuple)):
        raise exceptions.ConfigurationException(
            "bindings must be a list or tuple of dictionaries, but was a {}".format(
                type(bindings)
            )
        )

    for binding in bindings:
        missing_keys = []
        for key in ("queue", "exchange", "routing_keys"):
            if key not in binding:
                missing_keys.append(key)
        if missing_keys:
            raise exceptions.ConfigurationException(
                "a binding is missing the following keys from its settings "
                "value: {}".format(missing_keys)
            )

        if not isinstance(binding["routing_keys"], (list, tuple)):
            raise exceptions.ConfigurationException(
                "routing_keys must be a list or tuple, but was a {}".format(
                    type(binding["routing_keys"])
                )
            )


Instruction:
Implement a function in Python 3 to
validate the queues configuration.

Response:
def validate_queues(queues):
    """
    Validate the queues configuration.

    Raises:
        exceptions.ConfigurationException: If the configuration provided is of an
            invalid format.
    """
    if not isinstance(queues, dict):
        raise exceptions.ConfigurationException(
            "'queues' must be a dictionary mapping queue names to settings."
        )

    for queue, settings in queues.items():
        if not isinstance(settings, dict):
            raise exceptions.ConfigurationException(
                "the {} queue in the 'queues' setting has a value of type {}, but it "
                "should be a dictionary of settings.".format(queue, type(settings))
            )
        missing_keys = []
        for key in ("durable", "auto_delete", "exclusive", "arguments"):
            if key not in settings:
                missing_keys.append(key)
        if missing_keys:
            raise exceptions.ConfigurationException(
                "the {} queue is missing the following keys from its settings "
                "value: {}".format(queue, missing_keys)
            )


Instruction:
How would you explain what the following Python 3 function does
def validate_client_properties(props):
    for key in ("version", "information", "product"):
        # Nested dictionaries are not merged so key can be missing
        if key not in props:
            props[key] = DEFAULTS["client_properties"][key]
        # Don't let users override these as they identify this library in AMQP
        if props[key] != DEFAULTS["client_properties"][key]:
            raise exceptions.ConfigurationException(
                '"{}" is a reserved keyword in client_properties'.format(key)
            )

Response: Validate the client properties setting.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def _validate(self):
        for key in self:
            if key not in DEFAULTS:
                raise exceptions.ConfigurationException(
                    'Unknown configuration key "{}"! Valid configuration keys are'
                    " {}".format(key, list(DEFAULTS.keys()))
                )

        validate_queues(self["queues"])
        validate_bindings(self["bindings"])
        validate_client_properties(self["client_properties"])

Response: Perform checks on the configuration to assert its validity.


Instruction:
Create a Python 3 function to
load application configuration from a file and merge it with the default configuration.

Response:
def load_config(self, config_path=None):
        """
        Load application configuration from a file and merge it with the default
        configuration.

        If the ``FEDORA_MESSAGING_CONF`` environment variable is set to a
        filesystem path, the configuration will be loaded from that location.
        Otherwise, the path defaults to ``/etc/fedora-messaging/config.toml``.
        """
        self.loaded = True
        config = copy.deepcopy(DEFAULTS)

        if config_path is None:
            if "FEDORA_MESSAGING_CONF" in os.environ:
                config_path = os.environ["FEDORA_MESSAGING_CONF"]
            else:
                config_path = "/etc/fedora-messaging/config.toml"

        if os.path.exists(config_path):
            _log.info("Loading configuration from {}".format(config_path))
            with open(config_path) as fd:
                try:
                    file_config = toml.load(fd)
                    for key in file_config:
                        config[key.lower()] = file_config[key]
                except toml.TomlDecodeError as e:
                    msg = "Failed to parse {}: error at line {}, column {}: {}".format(
                        config_path, e.lineno, e.colno, e.msg
                    )
                    raise exceptions.ConfigurationException(msg)
        else:
            _log.info("The configuration file, {}, does not exist.".format(config_path))

        self.update(config)
        self._validate()
        return self


Instruction:
Can you implement a function in Python 3 that
generates a Twisted SSL context object from a pika connection parameter object.

Response:
def _ssl_context_factory(parameters):
    """
    Produce a Twisted SSL context object from a pika connection parameter object.
    This is necessary as Twisted manages the connection, not Pika.

    Args:
        parameters (pika.ConnectionParameters): The connection parameters built
            from the fedora_messaging configuration.
    """
    client_cert = None
    ca_cert = None
    key = config.conf["tls"]["keyfile"]
    cert = config.conf["tls"]["certfile"]
    ca_file = config.conf["tls"]["ca_cert"]
    if ca_file:
        with open(ca_file, "rb") as fd:
            # Open it in binary mode since otherwise Twisted will immediately
            # re-encode it as ASCII, which won't work if the cert bundle has
            # comments that can't be encoded with ASCII.
            ca_cert = ssl.Certificate.loadPEM(fd.read())
    if key and cert:
        # Note that _configure_tls_parameters sets the auth mode to EXTERNAL
        # if both key and cert are defined, so we don't need to do that here.
        with open(key) as fd:
            client_keypair = fd.read()
        with open(cert) as fd:
            client_keypair += fd.read()
        client_cert = ssl.PrivateCertificate.loadPEM(client_keypair)

    hostname = parameters.host
    if not isinstance(hostname, six.text_type):
        # Twisted requires the hostname as decoded text, which it isn't in Python 2
        # Decode with the system encoding since this came from the config file. Die,
        # Python 2, die.
        hostname = hostname.decode(locale.getdefaultlocale()[1])
    try:
        context_factory = ssl.optionsForClientTLS(
            hostname,
            trustRoot=ca_cert or ssl.platformTrust(),
            clientCertificate=client_cert,
            extraCertificateOptions={"raiseMinimumTo": ssl.TLSVersion.TLSv1_2},
        )
    except AttributeError:
        # Twisted 12.2 path for EL7 :(
        context_factory = ssl.CertificateOptions(
            certificate=client_cert.original,
            privateKey=client_cert.privateKey.original,
            caCerts=[ca_cert.original] or ssl.platformTrust(),
            verify=True,
            requireCertificate=True,
            verifyOnce=False,
            enableSessions=False,
        )

    return context_factory


Instruction:
Make a summary of the following Python 3 code
def stopService(self):
        self._service.factory.stopTrying()
        yield self._service.factory.stopFactory()
        yield service.MultiService.stopService(self)

Response: Gracefully stop the service.


Instruction:
Can you create a Python 3 function that
configures the TLS connection parameters for the current object.

Response:
def _configure_tls_parameters(parameters):
    """
    Configure the pika connection parameters for TLS based on the configuration.

    This modifies the object provided to it. This accounts for whether or not
    the new API based on the standard library's SSLContext is available for
    pika.

    Args:
        parameters (pika.ConnectionParameters): The connection parameters to apply
            TLS connection settings to.
    """
    cert = config.conf["tls"]["certfile"]
    key = config.conf["tls"]["keyfile"]
    if cert and key:
        _log.info(
            "Authenticating with server using x509 (certfile: %s, keyfile: %s)",
            cert,
            key,
        )
        parameters.credentials = pika.credentials.ExternalCredentials()
    else:
        cert, key = None, None

    if SSLOptions is None:
        parameters.ssl = True
        parameters.ssl_options = {
            "keyfile": key,
            "certfile": cert,
            "ca_certs": config.conf["tls"]["ca_cert"],
            "cert_reqs": ssl.CERT_REQUIRED,
            "ssl_version": ssl.PROTOCOL_TLSv1_2,
        }
    else:
        ssl_context = ssl.create_default_context()
        if config.conf["tls"]["ca_cert"]:
            try:
                ssl_context.load_verify_locations(cafile=config.conf["tls"]["ca_cert"])
            except ssl.SSLError as e:
                raise ConfigurationException(
                    'The "ca_cert" setting in the "tls" section is invalid ({})'.format(
                        e
                    )
                )
        ssl_context.options |= ssl.OP_NO_SSLv2
        ssl_context.options |= ssl.OP_NO_SSLv3
        ssl_context.options |= ssl.OP_NO_TLSv1
        ssl_context.options |= ssl.OP_NO_TLSv1_1
        ssl_context.verify_mode = ssl.CERT_REQUIRED
        ssl_context.check_hostname = True
        if cert and key:
            try:
                ssl_context.load_cert_chain(cert, key)
            except ssl.SSLError as e:
                raise ConfigurationException(
                    'The "keyfile" setting in the "tls" section is invalid ({})'.format(
                        e
                    )
                )
        parameters.ssl_options = SSLOptions(
            ssl_context, server_hostname=parameters.host
        )


Instruction:
Given the following Python 3 function, write the documentation
def publish(self, message, exchange=None):
        message.validate()
        try:
            self._connect_and_publish(exchange, message)
        except (pika_errs.NackError, pika_errs.UnroutableError) as e:
            _log.warning("Message was rejected by the broker (%s)", str(e))
            raise PublishReturned(reason=e)
        except (pika_errs.ConnectionClosed, pika_errs.AMQPChannelError):
            # Because this is a blocking connection (and thus can't heartbeat)
            # we might need to restart the connection.
            _log.info("Resetting connection to %s", self._parameters.host)
            self._connection = self._channel = None
            try:
                self._connect_and_publish(exchange, message)
            except (pika_errs.NackError, pika_errs.UnroutableError) as e:
                _log.warning("Message was rejected by the broker (%s)", str(e))
                raise PublishReturned(reason=e)
            except pika_errs.AMQPError as e:
                _log.error(str(e))
                if self._connection and self._connection.is_open:
                    self._connection.close()
                raise ConnectionException(reason=e)
        except pika_errs.AMQPError as e:
            if self._connection and self._connection.is_open:
                self._connection.close()
            raise ConnectionException(reason=e)

Response: Publish a message to an AMQP exchange.


Instruction:
Make a summary of the following Python 3 code
def _shutdown(self):
        if self._channel:
            _log.info("Halting %r consumer sessions", self._channel.consumer_tags)
        self._running = False
        if self._connection and self._connection.is_open:
            self._connection.close()
        # Reset the signal handler
        for signum in (signal.SIGTERM, signal.SIGINT):
            signal.signal(signum, signal.SIG_DFL)

Response: Gracefully shut down the consumer and exit.


Instruction:
How would you explain what the following Python 3 function does
def _on_cancelok(self, cancel_frame):
        _log.info("Consumer canceled; returning all unprocessed messages to the queue")
        self._channel.basic_nack(delivery_tag=0, multiple=True, requeue=True)

Response: Called when the server acknowledges a cancel request.


Instruction:
Here you have a function in Python 3, explain what it does
def _on_qosok(self, qosok_frame):
        for name, args in self._exchanges.items():
            self._channel.exchange_declare(
                exchange=name,
                exchange_type=args["type"],
                durable=args["durable"],
                auto_delete=args["auto_delete"],
                arguments=args["arguments"],
                passive=config.conf["passive_declares"],
                callback=self._on_exchange_declareok,
            )
        for name, args in self._queues.items():
            self._channel.queue_declare(
                queue=name,
                durable=args["durable"],
                auto_delete=args["auto_delete"],
                exclusive=args["exclusive"],
                arguments=args["arguments"],
                passive=config.conf["passive_declares"],
                callback=self._on_queue_declareok,
            )

Response: Called when the server acknowledges the QoS settings.


Instruction:
Can you generate the documentation for the following Python 3 function
def _on_channel_close(self, channel, reply_code_or_reason, reply_text=None):
        if isinstance(reply_code_or_reason, pika_errs.ChannelClosed):
            reply_code = reply_code_or_reason.reply_code
            reply_text = reply_code_or_reason.reply_text
        elif isinstance(reply_code_or_reason, int):
            reply_code = reply_code_or_reason
        else:
            reply_code = 0
            reply_text = str(reply_code_or_reason)

        _log.info("Channel %r closed (%d): %s", channel, reply_code, reply_text)
        self._channel = None

Response: Callback invoked when the channel is closed.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def _on_connection_open(self, connection):
        _log.info("Successfully opened connection to %s", connection.params.host)
        self._channel = connection.channel(on_open_callback=self._on_channel_open)

Response: Callback invoked when the connection is successfully established.


Instruction:
Create a Python 3 function to
invoke when a queue is successfully declared.

Response:
def _on_queue_declareok(self, frame):
        """
        Callback invoked when a queue is successfully declared.

        Args:
            frame (pika.frame.Method): The message sent from the server.
        """
        _log.info("Successfully declared the %s queue", frame.method.queue)
        for binding in self._bindings:
            if binding["queue"] == frame.method.queue:
                for key in binding["routing_keys"]:
                    _log.info(
                        "Asserting %s is bound to %s with the %s key",
                        binding["queue"],
                        binding["exchange"],
                        key,
                    )
                    self._channel.queue_bind(
                        callback=None,
                        queue=binding["queue"],
                        exchange=binding["exchange"],
                        routing_key=key,
                    )
                bc_args = dict(queue=frame.method.queue)
                if _pika_version < pkg_resources.parse_version("1.0.0b1"):
                    bc_args["consumer_callback"] = self._on_message
                else:
                    bc_args["on_message_callback"] = self._on_message
                tag = self._channel.basic_consume(**bc_args)
                self._consumers[tag] = binding["queue"]


Instruction:
Can you generate a brief explanation for the following Python 3 code
def call_later(self, delay, callback):
        if hasattr(self._connection.ioloop, "call_later"):
            self._connection.ioloop.call_later(delay, callback)
        else:
            self._connection.ioloop.add_timeout(delay, callback)

Response: Schedule a one - shot timeout given delay seconds.


Instruction:
Explain what the following Python 3 code does
def consume(self, callback, bindings=None, queues=None, exchanges=None):
        self._bindings = bindings or config.conf["bindings"]
        self._queues = queues or config.conf["queues"]
        self._exchanges = exchanges or config.conf["exchanges"]

        # If the callback is a class, create an instance of it first
        if inspect.isclass(callback):
            cb_obj = callback()
            if not callable(cb_obj):
                raise ValueError(
                    "Callback must be a class that implements __call__"
                    " or a function."
                )
            self._consumer_callback = cb_obj
        elif callable(callback):
            self._consumer_callback = callback
        else:
            raise ValueError(
                "Callback must be a class that implements __call__" " or a function."
            )
        self._running = True
        self.connect()
        self._connection.ioloop.start()

Response: This method is used to consume messages from a message queue.


Instruction:
Can you implement a function in Python 3 that
gets the avatar URL from the email s From header.

Response:
def get_avatar(from_header, size=64, default="retro"):
    """Get the avatar URL from the email's From header.

    Args:
        from_header (str): The email's From header. May contain the sender's full name.

    Returns:
        str: The URL to that sender's avatar.
    """
    params = OrderedDict([("s", size), ("d", default)])
    query = parse.urlencode(params)
    address = email.utils.parseaddr(from_header)[1]
    value_hash = sha256(address.encode("utf-8")).hexdigest()
    return "https://seccdn.libravatar.org/avatar/{}?{}".format(value_hash, query)


Instruction:
Explain what the following Python 3 code does
def url(self):
        base_url = "https://lists.fedoraproject.org/archives"
        archived_at = self._get_archived_at()
        if archived_at and archived_at.startswith("<"):
            archived_at = archived_at[1:]
        if archived_at and archived_at.endswith(">"):
            archived_at = archived_at[:-1]
        if archived_at and archived_at.startswith("http"):
            return archived_at
        elif archived_at:
            return base_url + archived_at
        else:
            return None

Response: An URL to the email in HyperKitty.


Instruction:
Can you tell what is the following Python 3 function doing
def get_requirements(requirements_file="requirements.txt"):
    with open(requirements_file) as fd:
        lines = fd.readlines()
    dependencies = []
    for line in lines:
        maybe_dep = line.strip()
        if maybe_dep.startswith("#"):
            # Skip pure comment lines
            continue
        if maybe_dep.startswith("git+"):
            # VCS reference for dev purposes, expect a trailing comment
            # with the normal requirement
            __, __, maybe_dep = maybe_dep.rpartition("#")
        else:
            # Ignore any trailing comment
            maybe_dep, __, __ = maybe_dep.partition("#")
        # Remove any whitespace and assume non-empty results are dependencies
        maybe_dep = maybe_dep.strip()
        if maybe_dep:
            dependencies.append(maybe_dep)
    return dependencies

Response: Get the contents of a file listing the requirements. txt.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def user_avatar_url(username, size=64, default="retro"):
    openid = "http://{}.id.fedoraproject.org/".format(username)
    return libravatar_url(openid=openid, size=size, default=default)

Response: Get the avatar URL of the given Fedora username.


Instruction:
Can you implement a function in Python 3 that
gets the URL to an avatar from Libravatar.

Response:
def libravatar_url(email=None, openid=None, size=64, default="retro"):
    """Get the URL to an avatar from libravatar.

    Either the user's email or openid must be provided.

    If you want to use Libravatar federation (through DNS), you should install
    and use the ``libravatar`` library instead. Check out the
    ``libravatar.libravatar_url()`` function.

    Args:
        email (str): The user's email
        openid (str): The user's OpenID
        size (int): Size of the avatar in pixels (it's a square).
        default (str): Default avatar to return if not found.
    Returns:
        str: The URL to the avatar image.
    Raises:
        ValueError: If neither email nor openid are provided.
    """
    # We use an OrderedDict here to make testing easier (URL strings become
    # predictable).
    params = collections.OrderedDict([("s", size), ("d", default)])
    query = parse.urlencode(params)
    if email:
        value = email
    elif openid:
        value = openid
    else:
        raise ValueError("You must provide either the email or the openid.")
    idhash = sha256(value.encode("utf-8")).hexdigest()
    return "https://seccdn.libravatar.org/avatar/%s?%s" % (idhash, query)


Instruction:
Can you write a function in Python 3 where it
gets parameters for a resource.

Response:
def get_parameters(parser, token):
    """
    {% get_parameters except_field %}
    """
    args = token.split_contents()
    if len(args) < 2:
        raise template.TemplateSyntaxError(
            "get_parameters tag takes at least 1 argument"
        )
    return GetParametersNode(args[1].strip())


Instruction:
Create a Python 3 function for
returning a list of all field names on the instance.

Response:
def get_all_fields(obj):
    """Returns a list of all field names on the instance."""
    fields = []
    for f in obj._meta.fields:
        fname = f.name

        get_choice = "get_" + fname + "_display"
        if hasattr(obj, get_choice):
            value = getattr(obj, get_choice)()
        else:
            try:
                value = getattr(obj, fname)
            except Exception:
                value = None

        if isinstance(value, list):
            value = ",".join(str(v) for v in value)

        if f.editable and value and f.name:
            fields.append(
                {"label": f.verbose_name, "name": f.name, "value": value}
            )

    return fields


Instruction:
Can you generate the documentation for the following Python 3 function
def query_string(context, **kwargs):
    params = context["request"].GET.copy()

    for key, value in list(kwargs.items()):
        params[key] = value

    return "?" + params.urlencode()

Response: Add param to the given query string


Instruction:
Explain what the following Python 3 code does
def query_string_ordering(context, value, **kwargs):
    params = context["request"].GET.copy()

    # if the given value is '-id', it's core value would be 'id'
    core_value = value
    default_order = "asc"

    if core_value[0] == "-":
        core_value = value[1:]
        default_order = "desc"

    current_value = ""

    # by preference get the current ordering value from the filter
    # so that even if no explicit ordering is in the URL, we still
    # get the implicit ordering, the page's default
    # See generics.filters.FilterSet
    if "filter" in context:
        current_value = context["filter"].ordered_value()
    elif "ordering" in params:
        current_value = params["ordering"]

    # The first two clauses check if the current ordering is on the
    # same field as the desired one, in which case we reverse the direction.
    # If it's on another field, we use the default direction.
    if current_value == core_value:
        order_prefix = "-"
    elif current_value == "-" + core_value:
        order_prefix = ""
    elif default_order == "desc":
        order_prefix = "-"
    else:
        order_prefix = ""

    params["ordering"] = order_prefix + core_value
    return "?" + params.urlencode()

Response: This function returns a query string that can be used to order the pages in the given language.


Instruction:
Can you tell what is the following Python 3 function doing
def arctic_url(context, link, *args, **kwargs):

    def reverse_mutable_url_args(url_args):
        mutated_url_args = []
        for arg in url_args:

            # listview item, and argument is a string
            if "item" in context and type(arg) == str:
                # try to get attribute of this object
                try:
                    arg = getattr(context["v"], arg.split(".")[-1])
                # if not found fallback to row pk, which is always first column
                except Exception:
                    arg = context["item"][0]
            mutated_url_args.append(arg)
        return reverse(link, args=mutated_url_args, kwargs=None)

    url_args = args

    # set arguments defined in urls if provided
    if type(link) in (tuple, list):
        context["urls"][link[0]] = list(link[1:])
        link = link[0]
    if link in context["urls"]:

        # for where the params directly given. e.g. ('article-detail',
        # (self.object.pk,))
        url_args = context["urls"][link]

        # list given, which means it's mutable!
        if isinstance(url_args, list):
            return reverse_mutable_url_args(url_args)

    return reverse(link, args=url_args, kwargs=None)

Response: Resolves links into urls with optional url arguments set in self. urls.


Instruction:
Write a Python 3 function that can
return the role model that is active in this project.

Response:
def get_role_model():
    """
    Returns the Role model that is active in this project.
    """
    app_model = getattr(settings, "ARCTIC_ROLE_MODEL", "arctic.Role")

    try:
        return django_apps.get_model(app_model)
    except ValueError:
        raise ImproperlyConfigured(
            "ARCTIC_ROLE_MODEL must be of the " "form 'app_label.model_name'"
        )
    except LookupError:
        raise ImproperlyConfigured(
            "ARCTIC_ROLE_MODEL refers to model '%s' that has not been "
            "installed" % settings.ARCTIC_ROLE_MODEL
        )


Instruction:
Can you tell what is the following Python 3 function doing
def get_user_role_model():
    app_model = getattr(settings, "ARCTIC_USER_ROLE_MODEL", "arctic.UserRole")

    try:
        return django_apps.get_model(app_model)
    except ValueError:
        raise ImproperlyConfigured(
            "ARCTIC_USER_ROLE_MODEL must be of the "
            "form 'app_label.model_name'"
        )
    except LookupError:
        raise ImproperlyConfigured(
            "ARCTIC_USER_ROLE_MODEL refers to model '%s' that has not been "
            "installed" % settings.ARCTIC_USER_ROLE_MODEL
        )

Response: Returns the UserRole model that is active in this project.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def dispatch(self, request, *args, **kwargs):
        if self.requires_login:
            if settings.LOGIN_URL is None or settings.LOGOUT_URL is None:
                raise ImproperlyConfigured(
                    "LOGIN_URL and LOGOUT_URL "
                    "has to be defined if requires_login is True"
                )

            if not request.user.is_authenticated:
                return redirect(
                    "%s?next=%s"
                    % (
                        resolve_url(settings.LOGIN_URL),
                        quote(request.get_full_path()),
                    )
                )

        return super(View, self).dispatch(request, *args, **kwargs)

Response: This method is used to redirect to the login page if the user is not authenticated.


Instruction:
Create a Python 3 function to
return a list of all the breadcrumbs that can be used for this object.

Response:
def get_breadcrumbs(self):
        """
        Breadcrumb format: (('name', 'url'), ...) or None if not used.
        """
        if not self.breadcrumbs:
            return None
        else:
            allowed_breadcrumbs = []
            for breadcrumb in self.breadcrumbs:

                # check permission based on named_url
                if breadcrumb[1] is not None and not view_from_url(
                    breadcrumb[1]
                ).has_permission(self.request.user):
                    continue

                obj = self if not hasattr(self, "object") else self.object
                url = (
                    None
                    if not breadcrumb[1]
                    else reverse_url(breadcrumb[1], obj)
                )
                allowed_breadcrumbs.append({"name": breadcrumb[0], "url": url})
            return allowed_breadcrumbs


Instruction:
Can you tell what is the following Python 3 function doing
def get_tabs(self):
        if not self.tabs:
            return None
        else:
            allowed_tabs = []
            for tab in self.tabs:

                # check permission based on named_url
                if not view_from_url(tab[1]).has_permission(self.request.user):
                    continue

                obj = self if not hasattr(self, "object") else self.object
                url = reverse_url(tab[1], obj)
                allowed_tabs.append(
                    {
                        "name": tab[0],
                        "active": self.request.path == url,
                        "url": self.in_modal(url),
                    }
                )
            return allowed_tabs

Response: Return a list of tabs that can be used in the current page.


Instruction:
Implement a function in Python 3 to
return all media required to render this view including forms.

Response:
def media(self):
        """
        Return all media required to render this view, including forms.
        """
        media = self._get_common_media()
        media += self._get_view_media()
        media += self.get_media_assets()
        return media


Instruction:
Implement a Python 3 function for
gathering view - level media assets and css

Response:
def _get_view_media(self):
        """
        Gather view-level media assets
        """
        try:
            css = self.Media.css
        except AttributeError:
            css = {}
        try:
            js = self.Media.js
        except AttributeError:
            js = []
        return Media(css=css, js=js)


Instruction:
Can you tell what is the following Python 3 function doing
def get_list_header(self):
        model = self.object_list.model
        result = []
        if not self.get_fields():
            result.append(
                {"name": "", "verbose": str(model._meta.verbose_name)}
            )
        else:
            prefix = self.get_prefix()
            ordering_fields = self.get_ordering_fields()
            for field_name in self.get_fields():
                item = {}
                if isinstance(field_name, tuple):
                    # custom property that is not a field of the model
                    name = field_name[0]
                    item["label"] = field_name[1]
                else:
                    name = field_name
                    try:
                        field_meta = find_field_meta(model, field_name)
                        if field_meta._verbose_name:  # noqa
                            # explicitly set on the model, so don't change
                            item["label"] = field_meta._verbose_name  # noqa
                        else:
                            # title-case the field name (issue #80)
                            item["label"] = field_meta.verbose_name.title()
                    except FieldDoesNotExist:
                        item["label"] = field_name
                    except AttributeError:
                        item["label"] = field_name
                item["name"] = prefix + name
                if name in ordering_fields:
                    item["order_url"], item[
                        "order_direction"
                    ] = self.ordering_url(name)
                result.append(item)

        return result

Response: Returns a list of dictionaries with the field names labels links field css classes order_url and order_direction


Instruction:
Make a summary of the following Python 3 code
def get_ordering(self):
        if self.sorting_field:
            return [self.sorting_field]
        prefix = self.get_prefix()
        fields = self.get_ordering_with_prefix()
        if self.prefix:
            fields = [f.replace(prefix, "", 1) for f in fields]
        return [
            f
            for f in fields
            if f.lstrip("-") in self.get_ordering_fields_lookups()
        ]

Response: Ordering used for queryset filtering.


Instruction:
Here you have a function in Python 3, explain what it does
def get_list_header(self):
        result = []
        for field_name in self.get_fields():
            item = {}
            if isinstance(field_name, tuple):
                # custom property that is not a field of the model
                item["name"] = field_name[0]
                item["label"] = field_name[1]
            else:
                item["name"] = field_name
                item["label"] = field_name.title()
            if item["name"] in self.get_ordering_fields():
                item["order_url"], item["order_direction"] = self.ordering_url(
                    item["name"]
                )
            result.append(item)

        return result

Response: Returns a list of dictionaries with the field names labels links field css classes order_url and order_direction


Instruction:
Given the following Python 3 function, write the documentation
def get_paginator(
        self,
        dataset,
        per_page,
        orphans=0,
        allow_empty_first_page=True,
        **kwargs
    ):
        """Return an instance of the paginator for this view."""
        return IndefinitePaginator(
            dataset,
            per_page,
            orphans=orphans,
            allow_empty_first_page=allow_empty_first_page,
            **kwargs
        )

Response: Return an instance of the paginator for this view.


Instruction:
Here you have a function in Python 3, explain what it does
def get(self, request, *args, **kwargs):
        self.object = self.get_object()
        can_delete = True
        protected_objects = []
        collector_message = None
        collector = Collector(using="default")
        try:
            collector.collect([self.object])
        except ProtectedError as e:
            collector_message = (
                "Cannot delete %s because it has relations "
                "that depends on it." % self.object
            )
            protected_objects = e.protected_objects
            can_delete = False

        if can_delete and self.redirect:
            messages.success(request, self.get_success_message(self.object))
            return self.delete(request, *args, **kwargs)

        context = self.get_context_data(
            object=self.object,
            can_delete=can_delete,
            collector_message=collector_message,
            protected_objects=protected_objects,
        )
        return self.render_to_response(context)

Response: Catch protected relations and show to user.


Instruction:
Can you generate the documentation for the following Python 3 function
def get_modal_link(self, url, obj={}):
        if not (url in self.modal_links.keys()):
            return None

        try:
            if type(obj) != dict:
                obj.obj = str(obj)
                obj = vars(obj)
            link = self.modal_links[url]
            if link["type"] == "confirm":
                link["message"] = link["message"].format(**obj)
                link["title"] = link["title"].format(**obj)
                link["ok"]  # triggers a KeyError exception if not existent
                link["cancel"]
            elif link["type"] == "iframe":
                try:
                    link["size"]
                except KeyError:
                    link["size"] = "medium"
            else:
                raise ImproperlyConfigured(
                    "modal_links type: " + link["type"] + " is unsupported"
                )
            return link
        except KeyError as e:
            raise ImproperlyConfigured(
                "modal_links misses the following attribute: " + str(e)
            )
        except AttributeError:
            return None

Response: Returns the metadata for a modal link that needs to be confirmed if it exists.


Instruction:
Can you generate the documentation for the following Python 3 function
def get_success_url(self):
        if not self.success_url:
            if self.request.GET.get("inmodal"):
                return reverse("arctic:redirect_to_parent")
            raise ImproperlyConfigured(
                "No URL to redirect to. Provide a success_url."
            )
        return self.in_modal(str(self.success_url))

Response: Return the URL to redirect to after processing a valid form.


Instruction:
Make a summary of the following Python 3 code
def _set_has_no_columns(self, has_no_column, col_avg, col_last, fields):
        for index, field in has_no_column.items():
            if index == len(has_no_column):
                field_name = "{field}|{col_last}".format(
                    field=field, col_last=col_last
                )
                has_no_column[index] = self._return_field(field_name, fields)
            else:
                field_name = "{field}|{col_avg}".format(
                    field=field, col_avg=col_avg
                )
                has_no_column[index] = self._return_field(field_name, fields)
        return has_no_column

Response: Regenerate has_no_column by adding the amount of columns at the end of the has_no_column.


Instruction:
How would you code a function in Python 3 to
calculate the average of all columns and return a rounded down number.

Response:
def _calc_avg_and_last_val(self, has_no_column, sum_existing_columns):
        """
        Calculate the average of all columns and return a rounded down number.
        Store the remainder and add it to the last row. Could be implemented
        better. If the enduser wants more control, he can also just add the
        amount of columns. Will work fine with small number (<4) of items in a
        row.

        :param has_no_column:
        :param sum_existing_columns:
        :return: average, columns_for_last_element
        """
        sum_no_columns = len(has_no_column)
        columns_left = self.ALLOWED_COLUMNS - sum_existing_columns

        if sum_no_columns == 0:
            columns_avg = columns_left
        else:
            columns_avg = int(columns_left / sum_no_columns)

        remainder = columns_left - (columns_avg * sum_no_columns)
        columns_for_last_element = columns_avg + remainder
        return columns_avg, columns_for_last_element


Instruction:
Here you have a function in Python 3, explain what it does
def _split_str(self, field):
        field_items = field.split("|")
        if len(field_items) == 2:
            return field_items[0], field_items[1]
        elif len(field_items) == 1:
            return field_items[0], None

Response: Split the string into title|7 into ( title 7


Instruction:
Can you implement a function in Python 3 that
creates a url link for sorting the given field.

Response:
def ordering_url(self, field_name):
        """
        Creates a url link for sorting the given field.

        The direction of sorting will be either ascending, if the field is not
        yet sorted, or the opposite of the current sorting if sorted.
        """
        path = self.request.path
        direction = ""
        query_params = self.request.GET.copy()
        ordering = self.request.GET.get("order", "").split(",")
        field = self._get_ordering_field_lookup(field_name)
        if not ordering:
            ordering = self.get_default_ordering()
        merged_ordering = list(ordering)  # copy the list

        for ordering_field in self.get_ordering_fields_lookups():
            if (ordering_field.lstrip("-") not in ordering) and (
                ("-" + ordering_field.lstrip("-")) not in ordering
            ):
                merged_ordering.append(ordering_field)

        new_ordering = []
        for item in merged_ordering:
            if item.lstrip("-") == field.lstrip("-"):
                if (item[0] == "-") or not (item in ordering):
                    if item in ordering:
                        direction = "desc"
                    new_ordering.insert(0, item.lstrip("-"))
                else:
                    direction = "asc"
                    new_ordering.insert(0, "-" + item)

        query_params["order"] = ",".join(new_ordering)

        return (path + "?" + query_params.urlencode(safe=","), direction)


Instruction:
How would you code a function in Python 3 to
hook to dynamically change the fields that will be displayed

Response:
def get_fields(self, strip_labels=False):
        """
        Hook to dynamically change the fields that will be displayed
        """
        if strip_labels:
            return [
                f[0] if type(f) in (tuple, list) else f for f in self.fields
            ]
        return self.fields


Instruction:
Can you tell what is the following Python 3 function doing
def get_ordering_fields_lookups(self):
        ordering_field = []
        for field_name in self.get_ordering_fields():
            ordering_field.append(self._get_ordering_field_lookup(field_name))
        return ordering_field

Response: Gets the real model fields to order by by


Instruction:
Here you have a function in Python 3, explain what it does
def _get_ordering_field_lookup(self, field_name):
        field = field_name
        get_field = getattr(self, "get_%s_ordering_field" % field_name, None)
        if get_field:
            field = get_field()
        return field

Response: get real model field to order by by


Instruction:
Make a summary of the following Python 3 code
def get_advanced_search_form(self, data):
        if self.get_advanced_search_form_class():
            self._advanced_search_form = self.get_advanced_search_form_class()(
                data=data
            )
            return self._advanced_search_form

Response: Hook to dynamically change the advanced search form


Instruction:
Write a Python 3 script to
synchronize all the roles defined in the settings to the database.

Response:
def sync(cls):
        """
        Save all the roles defined in the settings that are not yet in the db
        this is needed to create a foreign key relation between a user and a
        role. Roles that are no longer specified in settings are set as
        inactive.
        """
        try:
            settings_roles = set(settings.ARCTIC_ROLES.keys())
        except AttributeError:
            settings_roles = set()

        saved_roles = set(Role.objects.values_list("name", flat=True))
        unsaved_roles = settings_roles - saved_roles
        unused_roles = saved_roles - settings_roles - set([cls.ADMIN])

        # ensure that admin is not defined in settings
        if cls.ADMIN in settings_roles:
            raise ImproperlyConfigured(
                '"' + cls.ADMIN + '" role is reserved '
                "and cannot be defined in settings"
            )

        # ensure that admin exists in the database
        if cls.ADMIN not in saved_roles:
            Role(name=cls.ADMIN, is_active=True).save()

        # check if the role defined in settings already exists in the database
        # and if it does ensure it is enabled.
        for role in saved_roles:
            if role in settings_roles:
                saved_role = Role.objects.get(name=role)
                if not saved_role.is_active:
                    saved_role.is_active = True
                    saved_role.save()

        for role in unsaved_roles:
            Role(name=role).save()

        for role in unused_roles:
            unused_role = Role.objects.get(name=role)
            unused_role.is_active = False
            unused_role.save()


Instruction:
Here you have a function in Python 3, explain what it does
def get_permission_required(cls):
        if cls.permission_required is None:
            raise ImproperlyConfigured(
                "{0} is missing the permission_required attribute. "
                "Define {0}.permission_required, or override "
                "{0}.get_permission_required().".format(cls.__name__)
            )
        if isinstance(cls.permission_required, six.string_types):
            if cls.permission_required != "":
                perms = (cls.permission_required,)
            else:
                perms = ()
        else:
            perms = cls.permission_required

        return perms

Response: Get permission required property. Must return an iterable.


Instruction:
Make a summary of the following Python 3 code
def has_permission(cls, user):
        # no login is needed, so its always fine
        if not cls.requires_login:
            return True

        # if user is somehow not logged in
        if not user.is_authenticated:
            return False

        # attribute permission_required is mandatory, returns tuple
        perms = cls.get_permission_required()
        # if perms are defined and empty, we skip checking
        if not perms:
            return True

        # get role of user, skip admin role
        role = user.urole.role.name
        if role == cls.ADMIN:
            return True

        # check if at least one permissions is valid
        for permission in perms:
            if cls.check_permission(role, permission):
                return True

        # permission denied
        return False

Response: Returns True if the user has permission for the given user.


Instruction:
Given the following Python 3 function, write the documentation
def check_permission(cls, role, permission):
        result = permission in settings.ARCTIC_ROLES[role]
        # will try to call a method with the same name as the permission
        # to enable an object level permission check.
        if result:
            try:
                return getattr(cls, permission)(role)
            except AttributeError:
                pass
        return result

Response: Check if role contains permission


Instruction:
Here you have a function in Python 3, explain what it does
def str_to_bool(val):
    if isinstance(val, str):
        val = val.lower()

    return val in ["true", "on", "yes", True]

Response:
Helper function to turn a string representation of true into
    boolean True.


Instruction:
Write a Python 3 function for
returning a Page object with pagination bar.

Response:
def arctic_paginate(parser, token):
    """
    Renders a Page object with pagination bar.
    Example::
        {% arctic_paginate page_obj paginator=page_obj.paginator range=10 %}
    Named Parameters::
        range - The size of the pagination bar (ie, if set to 10 then, at most,
                10 page numbers will display at any given time) Defaults to
                None, which shows all pages.
        show_first_last - Accepts "true" or "false". Determines whether or not
                          to show the first and last page links. Defaults to
                          "false"
    """
    bits = token.split_contents()
    if len(bits) < 2:
        raise TemplateSyntaxError(
            "'%s' takes at least one argument"
            " (Page object reference)" % bits[0]
        )
    page = parser.compile_filter(bits[1])
    kwargs = {}
    bits = bits[2:]

    kwarg_re = re.compile(r"(\w+)=(.+)")

    if len(bits):
        for bit in bits:
            match = kwarg_re.match(bit)
            if not match:
                raise TemplateSyntaxError(
                    "Malformed arguments to bootstrap_pagination paginate tag"
                )
            name, value = match.groups()
            kwargs[name] = parser.compile_filter(value)

    return PaginationNode(page, kwargs)


Instruction:
Write a Python 3 function that can
return a dictionary which is a frendlier format for a menu definition.

Response:
def menu(menu_config=None, **kwargs):
    """
    Tranforms a menu definition into a dictionary which is a frendlier format
    to parse in a template.
    """
    request = kwargs.pop("request", None)
    user = kwargs.pop("user", None)
    url_full_name = ":".join(
        [request.resolver_match.namespace, request.resolver_match.url_name]
    )

    if not menu_config:
        menu_config = settings.ARCTIC_MENU

    menu_dict = OrderedDict()
    for menu_entry in menu_config:
        if type(menu_entry) in (list, tuple):

            # check permission based on named_url
            path = None
            if menu_entry[1]:
                if not view_from_url(menu_entry[1]).has_permission(user):
                    continue

                path = reverse(menu_entry[1])
            # icons and collapse are optional
            icon = None
            if (len(menu_entry) >= 3) and (
                not type(menu_entry[2]) in (list, tuple)
            ):
                icon = menu_entry[2]
            active_weight = len(path) if path else 0
            menu_dict[menu_entry[0]] = {
                "url": menu_entry[1],
                "icon": icon,
                "submenu": None,
                "active": is_active(menu_entry, url_full_name),
                "active_weight": active_weight,
            }

            # check if the last item in a menu entry is a submenu
            submenu = _get_submenu(menu_entry)
            if submenu:
                menu_dict[menu_entry[0]]["submenu"] = menu(
                    submenu, user=user, request=request
                )
    return menu_clean(menu_dict)


Instruction:
How would you explain what the following Python 3 function does
def menu_clean(menu_config):
    max_weight = -1
    for _, value in list(menu_config.items()):
        if value["submenu"]:
            for _, v in list(value["submenu"].items()):
                if v["active"]:
                    # parent inherits the weight of the axctive child
                    value["active"] = True
                    value["active_weight"] = v["active_weight"]

        if value["active"]:
            max_weight = max(value["active_weight"], max_weight)

    if max_weight > 0:
        # one of the items is active: make items with lesser weight inactive
        for _, value in list(menu_config.items()):
            if value["active"] and value["active_weight"] < max_weight:
                value["active"] = False
    return menu_config

Response: Clean the menu items to ensure that only the largest weight is active.


Instruction:
How would you explain what the following Python 3 function does
def view_from_url(named_url):  # noqa
    # code below is `stolen` from django's reverse method.
    resolver = get_resolver(get_urlconf())

    if type(named_url) in (list, tuple):
        named_url = named_url[0]
    parts = named_url.split(":")
    parts.reverse()
    view = parts[0]
    path = parts[1:]
    current_path = None
    resolved_path = []
    ns_pattern = ""
    ns_converters = {}

    # if it's a local url permission already given, so we just return true
    if named_url.startswith("#"):

        class LocalUrlDummyView:
            @staticmethod
            def has_permission(user):
                return True

        return LocalUrlDummyView

    while path:
        ns = path.pop()
        current_ns = current_path.pop() if current_path else None

        # Lookup the name to see if it could be an app identifier
        try:
            app_list = resolver.app_dict[ns]
            # Yes! Path part matches an app in the current Resolver
            if current_ns and current_ns in app_list:
                # If we are reversing for a particular app,
                # use that namespace
                ns = current_ns
            elif ns not in app_list:
                # The name isn't shared by one of the instances
                # (i.e., the default) so just pick the first instance
                # as the default.
                ns = app_list[0]
        except KeyError:
            pass

        if ns != current_ns:
            current_path = None

        try:
            extra, resolver = resolver.namespace_dict[ns]
            resolved_path.append(ns)
            ns_pattern = ns_pattern + extra
            try:
                ns_converters.update(resolver.pattern.converters)
            except Exception:
                pass
        except KeyError as key:
            if resolved_path:
                raise NoReverseMatch(
                    "%s is not a registered namespace inside '%s'"
                    % (key, ":".join(resolved_path))
                )
            else:
                raise NoReverseMatch("%s is not a registered namespace" % key)
    if ns_pattern:
        try:
            resolver = get_ns_resolver(
                ns_pattern, resolver, tuple(ns_converters.items())
            )
        except Exception:
            resolver = get_ns_resolver(ns_pattern, resolver)

    # custom code, get view from reverse_dict
    reverse_dict = resolver.reverse_dict.dict()
    for key, url_obj in reverse_dict.items():
        if url_obj == reverse_dict[view] and key != view:
            module = importlib.import_module(key.__module__)
            return getattr(module, key.__name__)

Response: Finds and returns the view class from a named url.


Instruction:
Here you have a function in Python 3, explain what it does
def find_attribute(obj, value):
    if "__" in value:
        value_list = value.split("__")
        attr = get_attribute(obj, value_list[0])
        return find_attribute(attr, "__".join(value_list[1:]))
    return get_attribute(obj, value)

Response: Find the attribute connected to the last object in a chain of objects.


Instruction:
How would you implement a function in Python 3 that
gets the attribute of the object.

Response:
def get_attribute(obj, value):
    """
    Normally the result of list_items for listviews are a set of model objects.
    But when you want a GROUP_BY query (with 'values' method), than
    the result will be a dict. This method will help you find an item for
    either objects or dictionaries.
    """
    if type(obj) == dict:
        return dict.get(obj, value)
    else:
        return getattr(obj, value)


Instruction:
Write a Python 3 function for
finding the meta object that corresponds to the given value.

Response:
def find_field_meta(obj, value):
    """
    In a model, finds the attribute meta connected to the last object when
    a chain of  connected objects is given in a string separated with double
    underscores.
    """
    if "__" in value:
        value_list = value.split("__")
        child_obj = obj._meta.get_field(value_list[0]).rel.to
        return find_field_meta(child_obj, "__".join(value_list[1:]))
    return obj._meta.get_field(value)


Instruction:
Here you have a function in Python 3, explain what it does
def get_field_class(qs, field_name):
    try:
        return qs.model._meta.get_field(field_name).__class__.__name__
    # while annotating, it's possible that field does not exists.
    except FieldDoesNotExist:
        return None

Response: Given a queryset and a field name it will return the field s class


Instruction:
Implement a Python 3 function for
reversing a named url, in addition to the standard django reverse, it also accepts a list of ('named url', 'field1', 'field2', ...) and will use the value of the supplied fields as arguments. When a fallback field is given it will use it as an argument if none other are given.

Response:
def reverse_url(url, obj, fallback_field=None):
    """
    Reverses a named url, in addition to the standard django reverse, it also
    accepts a list of ('named url', 'field1', 'field2', ...) and will use the
    value of the supplied fields as arguments.
    When a fallback field is given it will use it as an argument if none other
    are given.
    """
    args = []
    if type(url) in (list, tuple):
        named_url = url[0]
        for arg in url[1:]:
            if type(obj) is dict:
                args.append(obj[arg])
            else:
                args.append(find_attribute(obj, arg))
    else:
        if url.startswith("#"):  # local url
            return url
        named_url = url
        if obj and fallback_field:
            if type(obj) is dict:
                args = [obj[fallback_field]]
            else:
                args = [get_attribute(obj, fallback_field)]

    # Instead of giving NoReverseMatch exception it's more desirable,
    # for field_links in listviews to just ignore the link.
    if fallback_field and not args:
        return ""

    return reverse(named_url, args=args)


Instruction:
Implement a Python 3 function for
trying to get a setting from the django settings if not available defaults to the one defined in defaults. py

Response:
def arctic_setting(setting_name, valid_options=None):
    """
    Tries to get a setting from the django settings, if not available defaults
    to the one defined in defaults.py
    """
    try:
        value = getattr(settings, setting_name)
        if valid_options and value not in valid_options:
            error_message = "Invalid value for {}, must be one of: {}".format(
                setting_name, str(valid_options)
            )
            raise ImproperlyConfigured(error_message)
    except AttributeError:
        pass
    return getattr(settings, setting_name, getattr(defaults, setting_name))


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

    def func_wrapper(self, start, stop):
        offset = start
        limit = stop - start
        return func(self, offset, limit)

    return func_wrapper

Response: Decorator that converts python slicing to offset and limit


Instruction:
Write a Python 3 script to
check whether the item is list of list

Response:
def is_list_of_list(item):
    """
    check whether the item is list (tuple)
    and consist of list (tuple) elements
    """
    if (
        type(item) in (list, tuple)
        and len(item)
        and isinstance(item[0], (list, tuple))
    ):
        return True
    return False


Instruction:
Here you have a function in Python 3, explain what it does
def generate_id(*s):
    with translation.override("en"):
        generated_id = slugify("-".join([str(i) for i in s]))
    return generated_id

Response: Generates an id from one or more strings


Instruction:
Implement a function in Python 3 to
render the current item in the browser.

Response:
def render(self, name, value, attrs=None, renderer=None):
        """For django 1.10 compatibility"""
        if django.VERSION >= (1, 11):
            return super(BetterFileInput, self).render(name, value, attrs)

        t = render_to_string(
            template_name=self.template_name,
            context=self.get_context(name, value, attrs),
        )
        return mark_safe(t)


Instruction:
Can you generate the documentation for the following Python 3 function
def get_table(ports):
    table = PrettyTable(["Name", "Port", "Protocol", "Description"])
    table.align["Name"] = "l"
    table.align["Description"] = "l"
    table.padding_width = 1

    for port in ports:
        table.add_row(port)

    return table

Response: This function returns a pretty table used to display the port results.


Instruction:
Implement a function in Python 3 to
search ports and numbers and print them.

Response:
def run(port, like, use_json, server):
    """Search port names and numbers."""
    if not port and not server[0]:
        raise click.UsageError("Please specify a port")

    if server[0]:
        app.run(host=server[0], port=server[1])
        return

    ports = get_ports(port, like)
    if not ports:
        sys.stderr.write("No ports found for '{0}'\n".format(port))
        return

    if use_json:
        print(json.dumps(ports, indent=4))
    else:
        table = get_table(ports)
        print(table)


Instruction:
Make a summary of the following Python 3 code
def get_account(self, address, id=None, endpoint=None):
        return self._call_endpoint(GET_ACCOUNT_STATE, params=[address], id=id, endpoint=endpoint)

Response: This function is used to get the state of an account on the blockchain.


Instruction:
Here you have a function in Python 3, explain what it does
def get_height(self, id=None, endpoint=None):
        return self._call_endpoint(GET_BLOCK_COUNT, id=id, endpoint=endpoint)

Response: Get the current height of the blockchain


Instruction:
Write a Python 3 function that can
get an asset by its hash

Response:
def get_asset(self, asset_hash, id=None, endpoint=None):
        """
        Get an asset by its hash
        Args:
            asset_hash: (str) asset to lookup, example would be 'c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b'
            id: (int, optional) id to use for response tracking
            endpoint: (RPCEndpoint, optional) endpoint to specify to use

        Returns:
            json object of the result or the error encountered in the RPC call
        """
        return self._call_endpoint(GET_ASSET_STATE, params=[asset_hash], id=id, endpoint=endpoint)


Instruction:
Can you tell what is the following Python 3 function doing
def get_balance(self, asset_hash, id=None, endpoint=None):
        return self._call_endpoint(GET_BALANCE, params=[asset_hash], id=id, endpoint=endpoint)

Response: Get the balance of a specific asset hash


Instruction:
Can you implement a function in Python 3 that
gets the hash of the highest block in the cache

Response:
def get_best_blockhash(self, id=None, endpoint=None):
        """
        Get the hash of the highest block
        Args:
            id: (int, optional) id to use for response tracking
            endpoint: (RPCEndpoint, optional) endpoint to specify to use
        Returns:
            json object of the result or the error encountered in the RPC call
        """
        return self._call_endpoint(GET_BEST_BLOCK_HASH, id=id, endpoint=endpoint)


Instruction:
Implement a function in Python 3 to
get a block by its height or hash.

Response:
def get_block(self, height_or_hash, id=None, endpoint=None):
        """
        Look up a block by the height or hash of the block.
        Args:
            height_or_hash: (int or str) either the height of the desired block or its hash in the form '1e67372c158a4cfbb17b9ad3aaae77001a4247a00318e354c62e53b56af4006f'
            id: (int, optional) id to use for response tracking
            endpoint: (RPCEndpoint, optional) endpoint to specify to use

        Returns:
            block: a json object or the ``neorpc.Core.Block.Block`` object
        """
        return self._call_endpoint(GET_BLOCK, params=[height_or_hash, 1], id=id, endpoint=endpoint)


Instruction:
Make a summary of the following Python 3 code
def get_block_hash(self, height, id=None, endpoint=None):
        return self._call_endpoint(GET_BLOCK_HASH, params=[height], id=id, endpoint=endpoint)

Response: Get hash of a block by its height


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_block_header(self, block_hash, id=None, endpoint=None):
        return self._call_endpoint(GET_BLOCK_HEADER, params=[block_hash, 1], id=id, endpoint=endpoint)

Response: Get the block header information according to the specified script hash.


Instruction:
Create a Python 3 function to
get the system fee of a block by height. This is used in calculating gas claims Args: height: (int) height of the block to lookup id: (int, optional) id to use for response tracking endpoint: (RPCEndpoint, optional) endpoint to specify to use Returns: json object of the result or the error encountered in the RPC call

Response:
def get_block_sysfee(self, height, id=None, endpoint=None):
        """
        Get the system fee of a block by height.  This is used in calculating gas claims
        Args:
            height: (int) height of the block to lookup
            id: (int, optional) id to use for response tracking
            endpoint: (RPCEndpoint, optional) endpoint to specify to use

        Returns:
            json object of the result or the error encountered in the RPC call
        """
        return self._call_endpoint(GET_BLOCK_SYS_FEE, params=[height], id=id, endpoint=endpoint)


Instruction:
Create a Python 3 function to
get the number of nodes connected to the endpoint

Response:
def get_connection_count(self, id=None, endpoint=None):
        """
        Gets the number of nodes connected to the endpoint
        Args:
            id: (int, optional) id to use for response tracking
            endpoint: (RPCEndpoint, optional) endpoint to specify to use
        Returns:
            json object of the result or the error encountered in the RPC call
        """
        return self._call_endpoint(GET_CONNECTION_COUNT, id=id, endpoint=endpoint)


Instruction:
Can you tell what is the following Python 3 function doing
def get_contract_state(self, contract_hash, id=None, endpoint=None):
        return self._call_endpoint(GET_CONTRACT_STATE, params=[contract_hash], id=id, endpoint=endpoint)

Response: Get a contract state object by its hash