Merge pull request #29 from michalpokusa/httpheaders-and-some-fixes

Case insensitive HTTPHeaders, HTTPResponse context manager and some fixes

Author: dhalbert

README.rst

@@ -21,12 +21,14 @@ Introduction
     :target: https://github.com/psf/black
     :alt: Code Style: Black
 
-Simple HTTP Server for CircuitPython.
+HTTP Server for CircuitPython.
 
 - Supports `socketpool` or `socket` as a source of sockets; can be used in CPython.
 - HTTP 1.1.
 - Serves files from a designated root.
-- Simple routing available to serve computed results.
+- Routing for serving computed responses from handler.
+- Gives access to request headers, query parameters, body and client's address, the one from which the request came.
+- Supports chunked transfer encoding.
 
 
 Dependencies

adafruit_httpserver/headers.py

@@ -0,0 +1,105 @@
+# SPDX-FileCopyrightText: Copyright (c) 2022 Dan Halbert for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+"""
+`adafruit_httpserver.headers.HTTPHeaders`
+====================================================
+* Author(s): Michał Pokusa
+"""
+
+try:
+    from typing import Dict, Tuple
+except ImportError:
+    pass
+
+
+class HTTPHeaders:
+    """
+    A dict-like class for storing HTTP headers.
+
+    Allows access to headers using **case insensitive** names.
+
+    Does **not** implement all dict methods.
+
+    Examples::
+
+        headers = HTTPHeaders({"Content-Type": "text/html", "Content-Length": "1024"})
+
+        len(headers)
+        # 2
+
+        headers.setdefault("Access-Control-Allow-Origin", "*")
+        headers["Access-Control-Allow-Origin"]
+        # '*'
+
+        headers["Content-Length"]
+        # '1024'
+
+        headers["content-type"]
+        # 'text/html'
+
+        headers["User-Agent"]
+        # KeyError: User-Agent
+
+        "CONTENT-TYPE" in headers
+        # True
+    """
+
+    _storage: Dict[str, Tuple[str, str]]
+
+    def __init__(self, headers: Dict[str, str] = None) -> None:
+
+        headers = headers or {}
+
+        self._storage = {key.lower(): [key, value] for key, value in headers.items()}
+
+    def get(self, name: str, default: str = None):
+        """Returns the value for the given header name, or default if not found."""
+        return self._storage.get(name.lower(), [None, default])[1]
+
+    def setdefault(self, name: str, default: str = None):
+        """Sets the value for the given header name if it does not exist."""
+        return self._storage.setdefault(name.lower(), [name, default])[1]
+
+    def items(self):
+        """Returns a list of (name, value) tuples."""
+        return dict(self._storage.values()).items()
+
+    def keys(self):
+        """Returns a list of header names."""
+        return dict(self._storage.values()).keys()
+
+    def values(self):
+        """Returns a list of header values."""
+        return dict(self._storage.values()).values()
+
+    def update(self, headers: Dict[str, str]):
+        """Updates the headers with the given dict."""
+        return self._storage.update(
+            {key.lower(): [key, value] for key, value in headers.items()}
+        )
+
+    def copy(self):
+        """Returns a copy of the headers."""
+        return HTTPHeaders(dict(self._storage.values()))
+
+    def __getitem__(self, name: str):
+        return self._storage[name.lower()][1]
+
+    def __setitem__(self, name: str, value: str):
+        self._storage[name.lower()] = [name, value]
+
+    def __delitem__(self, name: str):
+        del self._storage[name.lower()]
+
+    def __iter__(self):
+        return iter(dict(self._storage.values()))
+
+    def __len__(self):
+        return len(self._storage)
+
+    def __contains__(self, key: str):
+        return key.lower() in self._storage.keys()
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({dict(self._storage.values())})"

adafruit_httpserver/request.py

@@ -8,17 +8,36 @@
 """
 
 try:
-    from typing import Dict, Tuple
+    from typing import Dict, Tuple, Union
+    from socket import socket
+    from socketpool import SocketPool
 except ImportError:
     pass
 
+from .headers import HTTPHeaders
+
 
 class HTTPRequest:
     """
     Incoming request, constructed from raw incoming bytes.
     It is passed as first argument to route handlers.
     """
 
+    connection: Union["SocketPool.Socket", "socket.socket"]
+    """
+    Socket object usable to send and receive data on the connection.
+    """
+
+    client_address: Tuple[str, int]
+    """
+    Address and port bound to the socket on the other end of the connection.
+
+    Example::
+
+            request.client_address
+            # ('192.168.137.1', 40684)
+    """
+
     method: str
     """Request method e.g. "GET" or "POST"."""
 
@@ -39,26 +58,26 @@ class HTTPRequest:
     http_version: str
     """HTTP version, e.g. "HTTP/1.1"."""
 
-    headers: Dict[str, str]
+    headers: HTTPHeaders
     """
-    Headers from the request as `dict`.
-
-    Values should be accessed using **lower case header names**.
-
-    Example::
-
-            request.headers
-            # {'connection': 'keep-alive', 'content-length': '64' ...}
-            request.headers["content-length"]
-            # '64'
-            request.headers["Content-Length"]
-            # KeyError: 'Content-Length'
+    Headers from the request.
     """
 
     raw_request: bytes
-    """Raw bytes passed to the constructor."""
+    """
+    Raw 'bytes' passed to the constructor and body 'bytes' received later.
+
+    Should **not** be modified directly.
+    """
 
-    def __init__(self, raw_request: bytes = None) -> None:
+    def __init__(
+        self,
+        connection: Union["SocketPool.Socket", "socket.socket"],
+        client_address: Tuple[str, int],
+        raw_request: bytes = None,
+    ) -> None:
+        self.connection = connection
+        self.client_address = client_address
         self.raw_request = raw_request
 
         if raw_request is None:
@@ -120,12 +139,14 @@ def _parse_start_line(header_bytes: bytes) -> Tuple[str, str, Dict[str, str], st
         return method, path, query_params, http_version
 
     @staticmethod
-    def _parse_headers(header_bytes: bytes) -> Dict[str, str]:
+    def _parse_headers(header_bytes: bytes) -> HTTPHeaders:
         """Parse HTTP headers from raw request."""
         header_lines = header_bytes.decode("utf8").splitlines()[1:]
 
-        return {
-            name.lower(): value
-            for header_line in header_lines
-            for name, value in [header_line.split(": ", 1)]
-        }
+        return HTTPHeaders(
+            {
+                name: value
+                for header_line in header_lines
+                for name, value in [header_line.split(": ", 1)]
+            }
+        )