Cleanup pylint and run through black

Author: paul-1

adafruit_httpserver.py

@@ -76,7 +76,7 @@ def __init__(
                 raise ValueError("Unparseable raw_request: ", raw_request) from exc
 
         # If ? is found in path, strip form data for matching route
-        self.form = self.path.split('?')[0]
+        self.form = self.path.split("?")[0]
 
     def __hash__(self) -> int:
         return hash(self.method) ^ hash(self.form)
@@ -86,7 +86,7 @@ def __eq__(self, other: "_HTTPRequest") -> bool:
         return self.method == other.method and self.form == other.form
 
     def __repr__(self) -> str:
-        return f"_HTTPRequest(path={repr(self.path)}, method={repr(self.method)}, form={repr(self.form)})"
+        return f"_HTTPRequest(path={repr(self.path)}, method={repr(self.method)})"
 
 
 class MIMEType:
@@ -218,9 +218,9 @@ def __init__(
           The data to return in the response body, if ``filename`` is not ``None``.
         :param str filename: If not ``None``,
           return the contents of the specified file, and ignore ``body``.
-        :param int value of Cache-Control: max-age=<value> header.
-          604800 (7 days) is is default for files served not using route decorator.
-          0 if not specified in the route decorator HTTPResponse.
+        :param int cache: sets Cache-Control: max-age=<value> header.
+          604800 (7 days) is is default for files served. If using the route decorator,
+          then the default is 0 unless specified HTTPResponse.
         :param str root: root directory for filename, without a trailing slash
         """
         self.status = status
@@ -236,17 +236,15 @@ def send(self, conn: Any) -> None:
         if self.filename:
             try:
                 file_length = os.stat(self.root + self.filename)[6]
-                self._send_file_response(conn, self.filename, self.root, file_length, self.cache)
+                self._send_file_response(conn, file_length)
             except OSError:
-                self._send_response(
-                    conn,
-                    HTTPStatus.NOT_FOUND,
-                    MIMEType.TEXT_PLAIN,
-                    f"{HTTPStatus.NOT_FOUND} {self.filename}\r\n",
-                    0
-                )
+                self.status = HTTPStatus.NOT_FOUND
+                self.content_type = MIMEType.TEXT_PLAIN
+                self.body = f"{HTTPStatus.NOT_FOUND} {self.filename}\r\n".encode()
+                self.cache = 0
+                self._send_response(conn)
         else:
-            self._send_response(conn, self.status, self.content_type, self.body, self.cache)
+            self._send_response(conn)
 
     def send_chunk_headers(self, conn: Any):
         """Send Headers for a chunked response over the given socket."""
@@ -260,24 +258,27 @@ def send_body_chunk(self, conn: Any, chunk: str):
         :param Any conn: Current connection.
         :param str chunk: String data to be sent.
         """
-        size="%X\r\n".encode() % len(chunk)
+        size = "%X\r\n".encode() % len(chunk)
         self._send_bytes(conn, size)
-        self._send_bytes(conn, chunk.encode() + b'\r\n')
+        self._send_bytes(conn, chunk.encode() + b"\r\n")
 
-    def _send_response(self, conn, status, content_type, body, cache):
+    def _send_response(self, conn):
         self._send_bytes(
-            conn, self._HEADERS_FORMAT.format(status, content_type, len(body), cache)
+            conn,
+            self._HEADERS_FORMAT.format(
+                self.status, self.content_type, len(self.body), self.cache
+            ),
         )
-        self._send_bytes(conn, body)
+        self._send_bytes(conn, self.body)
 
-    def _send_file_response(self, conn, filename, root, file_length, cache):
+    def _send_file_response(self, conn, file_length):
         self._send_bytes(
             conn,
             self._HEADERS_FORMAT.format(
-                self.status, MIMEType.mime_type(filename), file_length, cache
+                self.status, MIMEType.mime_type(self.filename), file_length, self.cache
             ),
         )
-        with open(root + filename, "rb") as file:
+        with open(self.root + self.filename, "rb") as file:
             while bytes_read := file.read(2048):
                 self._send_bytes(conn, bytes_read)
 
@@ -325,7 +326,7 @@ def route_func(request):
                 raw_text = request.raw_request.decode("utf8")
                 print("Received a request of length", len(raw_text), "bytes")
                 return HTTPResponse(body="hello world")
-                
+
             @server.route(path, method)
             def route_func(request, conn):
                 raw_text = request.raw_request.decode("utf8")
@@ -382,7 +383,7 @@ def poll(self, timeout=-1):
         Call this method inside your main event loop to get the server to
         check for new incoming client requests. When a request comes in,
         the application callable will be invoked.
-        
+
         :param int timeout: Optional timeout value in seconds.
         """
         try:
@@ -408,7 +409,9 @@ def poll(self, timeout=-1):
                     if response is None:
                         return
                 elif request.method == "GET":
-                    response = HTTPResponse(filename=request.path, cache=604800, root=self.root_path)
+                    response = HTTPResponse(
+                        filename=request.path, cache=604800, root=self.root_path
+                    )
                 else:
                     response = HTTPResponse(status=HTTPStatus.INTERNAL_SERVER_ERROR)
 
@@ -418,10 +421,10 @@ def poll(self, timeout=-1):
             if ex.errno == EAGAIN:
                 # there is no data available right now, try again later.
                 return
-            elif ex.errno == ECONNRESET:
+            if ex.errno == ECONNRESET:
                 # connection reset by peer, try again later.
                 return
-            elif ex.errno == ETIMEDOUT:
+            if ex.errno == ETIMEDOUT:
                 # connection timed out
                 return
             raise