tcllib.requests.runner

Complexity

Total Complexity

11

Size/Duplication

Total Lines	60
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	RequestRunner.get_server()	0	3	1
A	RequestRunner.get_http()	0	7	3
A	RequestRunner.__init__()	0	5	2
B	RequestRunner.run()	0	24	5

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""Generic request executors."""

from . import http, serverselector
from .tclrequest import TclRequest


class UnknownMethodException(Exception):
    """Ignore unknown methods."""
    pass


class RequestRunner:

The variable __class__ seems to be unused.

    """Generic request executor."""

    def __init__(self, server_selector: serverselector.ServerSelector, https=True):
        """Populate variables."""
        self.server_selector = server_selector
        self.protocol = "https://" if https else "http://"
        self.max_tries = 5

    def get_http(self, method="GET") -> http.HttpRequest:

This method could be written as a function/class method.

        """Return the http class according to desired method."""
        if method == "GET":
            return http.HttpRequest
        elif method == "POST":
            return http.HttpPostRequest
        raise UnknownMethodException("Unknown http method: {}".format(method))

    def get_server(self) -> str:
        """Return a master server."""
        return self.server_selector.get_master_server()

    def run(self, query: TclRequest, timeout: int=10) -> bool:

Exactly one space required around keyword argument assignment

        """Run the actual query."""
        for _ in range(0, self.max_tries):
            url = "{}{}{}".format(self.protocol, self.get_server(), query.uri)
            http_handler = self.get_http(query.method)(url, timeout)
            http_handler.headers = query.get_headers()
            http_handler.params = query.get_params()
            http_handler.reset_session()
            self.server_selector.hook_prerequest()
            try:
                req = http_handler.run()
                if query.rawmode:
                    done = query.is_done(req.status_code, req.content)
                else:
                    req.encoding = "utf-8"
                    done = query.is_done(req.status_code, req.text)
                self.server_selector.hook_postrequest(done)
                if done:
                    return done
            except http.TimeoutException:
                self.server_selector.hook_postrequest(False)
                query.error = "Timeout."
        query.error = "Max tries ({}) reached.".format(self.max_tries)
        return False