Added QueryParams and interface for both storage classes

Author: michalpokusa

adafruit_httpserver/__init__.py

@@ -51,7 +51,7 @@
     CONNECT,
 )
 from .mime_types import MIMETypes
-from .request import FormData, Request
+from .request import QueryParams, FormData, Request
 from .response import (
     Response,
     FileResponse,

adafruit_httpserver/request.py

@@ -22,7 +22,77 @@
 from .headers import Headers
 
 
-class FormData:
+class _IFieldStorage:
+    """Interface with shared methods for QueryParams and FormData."""
+
+    _storage: Dict[str, List[Union[str, bytes]]]
+
+    def _add_field_value(self, field_name: str, value: Union[str, bytes]) -> None:
+        if field_name not in self._storage:
+            self._storage[field_name] = [value]
+        else:
+            self._storage[field_name].append(value)
+
+    def get(self, field_name: str, default: Any = None) -> Union[str, bytes, None]:
+        """Get the value of a field."""
+        return self._storage.get(field_name, [default])[0]
+
+    def get_list(self, field_name: str) -> List[Union[str, bytes]]:
+        """Get the list of values of a field."""
+        return self._storage.get(field_name, [])
+
+    @property
+    def fields(self):
+        """Returns a list of field names."""
+        return list(self._storage.keys())
+
+    def __getitem__(self, field_name: str):
+        return self.get(field_name)
+
+    def __iter__(self):
+        return iter(self._storage)
+
+    def __len__(self):
+        return len(self._storage)
+
+    def __contains__(self, key: str):
+        return key in self._storage
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({repr(self._storage)})"
+
+
+class QueryParams(_IFieldStorage):
+    """
+    Class for parsing and storing GET quer parameters requests.
+
+    Examples::
+
+        query_params = QueryParams(b"foo=bar&baz=qux&baz=quux")
+        # QueryParams({"foo": "bar", "baz": ["qux", "quux"]})
+
+        query_params.get("foo") # "bar"
+        query_params["foo"] # "bar"
+        query_params.get("non-existent-key") # None
+        query_params.get_list("baz") # ["qux", "quux"]
+        "unknown-key" in query_params # False
+        query_params.fields # ["foo", "baz"]
+    """
+
+    _storage: Dict[str, List[Union[str, bytes]]]
+
+    def __init__(self, query_string: str) -> None:
+        self._storage = {}
+
+        for query_param in query_string.split("&"):
+            if "=" in query_param:
+                key, value = query_param.split("=", 1)
+                self._add_field_value(key, value)
+            elif query_param:
+                self._add_field_value(query_param, "")
+
+
+class FormData(_IFieldStorage):
     """
     Class for parsing and storing form data from POST requests.
 
@@ -31,18 +101,15 @@ class FormData:
 
     Examples::
 
-        form_data = FormData(b"foo=bar&baz=qux", "application/x-www-form-urlencoded")
-
+        form_data = FormData(b"foo=bar&baz=qux&baz=quuz", "application/x-www-form-urlencoded")
         # or
-
-        form_data = FormData(b"foo=bar\\r\\nbaz=qux", "text/plain")
-
+        form_data = FormData(b"foo=bar\\r\\nbaz=qux\\r\\nbaz=quux", "text/plain")
         # FormData({"foo": "bar", "baz": "qux"})
 
         form_data.get("foo") # "bar"
         form_data["foo"] # "bar"
         form_data.get("non-existent-key") # None
-        form_data.get_list("baz") # ["qux"]
+        form_data.get_list("baz") # ["qux", "quux"]
         "unknown-key" in form_data # False
         form_data.fields # ["foo", "baz"]
     """
@@ -63,12 +130,6 @@ def __init__(self, data: bytes, content_type: str) -> None:
         elif content_type.startswith("text/plain"):
             self._parse_text_plain(data)
 
-    def _add_field_value(self, field_name: str, value: Union[str, bytes]) -> None:
-        if field_name not in self._storage:
-            self._storage[field_name] = [value]
-        else:
-            self._storage[field_name].append(value)
-
     def _parse_x_www_form_urlencoded(self, data: bytes) -> None:
         decoded_data = data.decode()
 
@@ -95,34 +156,6 @@ def _parse_text_plain(self, data: bytes) -> None:
 
             self._add_field_value(field_name.decode(), value.decode())
 
-    def get(self, field_name: str, default: Any = None) -> Union[str, bytes, None]:
-        """Get the value of a field."""
-        return self._storage.get(field_name, [default])[0]
-
-    def get_list(self, field_name: str) -> List[Union[str, bytes]]:
-        """Get the list of values of a field."""
-        return self._storage.get(field_name, [])
-
-    @property
-    def fields(self):
-        """Returns a list of field names."""
-        return list(self._storage.keys())
-
-    def __getitem__(self, field_name: str):
-        return self.get(field_name)
-
-    def __iter__(self):
-        return iter(self._storage)
-
-    def __len__(self):
-        return len(self._storage)
-
-    def __contains__(self, key: str):
-        return key in self._storage
-
-    def __repr__(self) -> str:
-        return f"FormData({repr(self._storage)})"
-
 
 class Request:
     """
@@ -156,15 +189,15 @@ class Request:
     path: str
     """Path of the request, e.g. ``"/foo/bar"``."""
 
-    query_params: Dict[str, str]
+    query_params: QueryParams
     """
     Query/GET parameters in the request.
 
     Example::
 
             request  = Request(raw_request=b"GET /?foo=bar HTTP/1.1...")
             request.query_params
-            # {"foo": "bar"}
+            # QueryParams({"foo": "bar"})
     """
 
     http_version: str
@@ -258,13 +291,7 @@ def _parse_start_line(header_bytes: bytes) -> Tuple[str, str, Dict[str, str], st
 
         path, query_string = path.split("?", 1)
 
-        query_params = {}
-        for query_param in query_string.split("&"):
-            if "=" in query_param:
-                key, value = query_param.split("=", 1)
-                query_params[key] = value
-            elif query_param:
-                query_params[query_param] = ""
+        query_params = QueryParams(query_string)
 
         return method, path, query_params, http_version