Minor docstring, typing and encoding fixes

temp

to docs

Author: michalpokusa

adafruit_httpserver/headers.py

@@ -52,7 +52,7 @@ def __init__(self, headers: Dict[str, str] = None) -> None:
 
         self._storage = {key.lower(): [key, value] for key, value in headers.items()}
 
-    def get(self, name: str, default: str = None):
+    def get(self, name: str, default: str = None) -> Union[str, None]:
         """Returns the value for the given header name, or default if not found."""
         return self._storage.get(name.lower(), [None, default])[1]
 
@@ -66,11 +66,11 @@ def items(self):
 
     def keys(self):
         """Returns a list of header names."""
-        return dict(self._storage.values()).keys()
+        return list(dict(self._storage.values()).keys())
 
     def values(self):
         """Returns a list of header values."""
-        return dict(self._storage.values()).values()
+        return list(dict(self._storage.values()).values())
 
     def update(self, headers: Dict[str, str]):
         """Updates the headers with the given dict."""

adafruit_httpserver/request.py

@@ -34,7 +34,7 @@ def _add_field_value(self, field_name: str, value: Union[str, bytes]) -> None:
             self._storage[field_name].append(value)
 
     @staticmethod
-    def _encode_html_entities(value):
+    def _encode_html_entities(value: str) -> str:
         """Encodes unsafe HTML characters."""
         return (
             str(value)
@@ -84,11 +84,11 @@ def __repr__(self) -> str:
 
 class QueryParams(_IFieldStorage):
     """
-    Class for parsing and storing GET quer parameters requests.
+    Class for parsing and storing GET query parameters requests.
 
     Examples::
 
-        query_params = QueryParams(b"foo=bar&baz=qux&baz=quux")
+        query_params = QueryParams("foo=bar&baz=qux&baz=quux")
         # QueryParams({"foo": "bar", "baz": ["qux", "quux"]})
 
         query_params.get("foo") # "bar"
@@ -99,7 +99,7 @@ class QueryParams(_IFieldStorage):
         query_params.fields # ["foo", "baz"]
     """
 
-    _storage: Dict[str, List[Union[str, bytes]]]
+    _storage: Dict[str, List[str]]
 
     def __init__(self, query_string: str) -> None:
         self._storage = {}
@@ -151,7 +151,7 @@ def __init__(self, data: bytes, content_type: str) -> None:
             self._parse_text_plain(data)
 
     def _parse_x_www_form_urlencoded(self, data: bytes) -> None:
-        decoded_data = data.decode()
+        decoded_data = data.decode("utf-8")
 
         for field_name, value in [
             key_value.split("=", 1) for key_value in decoded_data.split("&")
@@ -169,12 +169,12 @@ def _parse_multipart_form_data(self, data: bytes, boundary: str) -> None:
             self._add_field_value(field_name, value)
 
     def _parse_text_plain(self, data: bytes) -> None:
-        lines = data.split(b"\r\n")[:-1]
+        lines = data.decode("utf-8").split("\r\n")[:-1]
 
         for line in lines:
-            field_name, value = line.split(b"=", 1)
+            field_name, value = line.split("=", 1)
 
-            self._add_field_value(field_name.decode(), value.decode())
+            self._add_field_value(field_name, value)
 
 
 class Request:
@@ -231,7 +231,7 @@ class Request:
 
     raw_request: bytes
     """
-    Raw 'bytes' that were received from the client.
+    Raw ``bytes`` that were received from the client.
 
     Should **not** be modified directly.
     """
@@ -340,10 +340,10 @@ def _raw_body_bytes(self) -> bytes:
         return self.raw_request[empty_line_index + 4 :]
 
     @staticmethod
-    def _parse_start_line(header_bytes: bytes) -> Tuple[str, str, Dict[str, str], str]:
+    def _parse_start_line(header_bytes: bytes) -> Tuple[str, str, QueryParams, str]:
         """Parse HTTP Start line to method, path, query_params and http_version."""
 
-        start_line = header_bytes.decode("utf8").splitlines()[0]
+        start_line = header_bytes.decode("utf-8").splitlines()[0]
 
         method, path, http_version = start_line.split()
 
@@ -359,7 +359,7 @@ def _parse_start_line(header_bytes: bytes) -> Tuple[str, str, Dict[str, str], st
     @staticmethod
     def _parse_headers(header_bytes: bytes) -> Headers:
         """Parse HTTP headers from raw request."""
-        header_lines = header_bytes.decode("utf8").splitlines()[1:]
+        header_lines = header_bytes.decode("utf-8").splitlines()[1:]
 
         return Headers(
             {

adafruit_httpserver/response.py

@@ -178,14 +178,14 @@ def __init__(  # pylint: disable=too-many-arguments
         :param str filename: Name of the file to send.
         :param str root_path: Path to the root directory from which to serve files. Defaults to
           server's ``root_path``.
-        :param Status status: Status code and text. Defaults to 200 OK.
+        :param Status status: Status code and text. Defaults to ``200 OK``.
         :param Headers headers: Headers to include in response.
         :param str content_type: Content type of response.
-        :param bool as_attachment: If True, the file will be sent as an attachment.
+        :param bool as_attachment: If ``True``, the file will be sent as an attachment.
         :param str download_filename: Name of the file to send as an attachment.
-        :param int buffer_size: Size of the buffer used to send the file. Defaults to 1024.
-        :param bool head_only: If True, only headers will be sent. Defaults to False.
-        :param bool safe: If True, checks if ``filename`` is valid. Defaults to True.
+        :param int buffer_size: Size of the buffer used to send the file. Defaults to ``1024``.
+        :param bool head_only: If ``True``, only headers will be sent. Defaults to ``False``.
+        :param bool safe: If ``True``, checks if ``filename`` is valid. Defaults to ``True``.
         """
         if safe:
             self._verify_file_path_is_valid(filename)