clear-skies 1.22.10__py3-none-any.whl → 2.0.23__py3-none-any.whl

clearskies/input_outputs/input_output.py

@@ -1,100 +1,64 @@
-from abc import ABC, abstractmethod
-from collections import OrderedDict
-from ..handlers.exceptions import ClientError
+from __future__ import annotations
+
 import json
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
 
+from clearskies import configs, configurable
 
-class InputOutput(ABC):
-    _response_headers = None
-    _body_as_json = None
-    _body_loaded_as_json = False
-    _routing_data = None
-    _authorization_data = None
+from .headers import Headers
 
-    @abstractmethod
-    def respond(self, body, status_code=200):
-        pass
+if TYPE_CHECKING:
+    from clearskies import typing
 
-    def error(self, body):
-        return self.respond(body, 400)
 
-    def success(self, body):
-        return self.respond(body)
+class InputOutput(ABC, configurable.Configurable):
+    """Manage the request and response to the client."""
 
-    def configure(self):
-        pass
-
-    def has_header(self, key):
-        if self._response_headers is None:
-            return False
-        return key.upper() in self._response_headers
+    response_headers = configs.Headers(default=Headers())
+    request_headers = configs.Headers(default=Headers())
+    query_parameters = configs.AnyDict(default={})
+    routing_data = configs.StringDict(default={})
+    authorization_data = configs.AnyDict(default={})
+    request_method = configs.Select(["GET", "POST", "PATCH", "OPTIONS", "DELETE", "SEARCH"], default="GET")
+    supports_request_method = configs.Boolean(default=True)
+    supports_url = configs.Boolean(default=True)
 
-    def set_header(self, key, value):
-        if self._response_headers is None:
-            self._response_headers = OrderedDict()
-        self._response_headers[key.upper()] = value
+    _body_as_json: dict[str, Any] | list[Any] | None = {}
+    _body_loaded_as_json = False
 
-    def clear_header(self, key):
-        if self._response_headers is None:
-            return
-        if self.has_header(key):
-            del self._response_headers[key.upper()]
+    def __init__(self):
+        self.response_headers = Headers()
+        self.finalize_and_validate_configuration()
 
-    def clear_headers(self, key):
-        self._response_headers = None
+    @abstractmethod
+    def respond(self, body: typing.response, status_code: int = 200) -> Any:
+        """
+        Pass along a response to the client.
 
-    def set_headers(self, headers):
-        for key, value in headers.items():
-            self.set_header(key, value)
+        Accepts a string, bytes, dictionary, or list.  If a content type has not been set then it will automatically
+        be set to application/json
+        """
+        pass
 
     @abstractmethod
-    def get_body(self):
+    def get_body(self) -> str:
+        """Return the raw body set by the client."""
         pass
 
     @abstractmethod
-    def has_body(self):
+    def has_body(self) -> bool:
+        """Whether or not the request included a body."""
         pass
 
-    def routing_data(self):
-        return self._routing_data if self._routing_data is not None else {}
-
-    def set_routing_data(self, data):
-        self._routing_data = data
-
-    def add_routing_data(self, key, value=None):
-        if self._routing_data is None:
-            self._routing_data = {}
-        if type(key) == dict:
-            self._routing_data = {**self._routing_data, **key}
-        else:
-            self._routing_data[key] = value
-
-    def request_data(self, required=True):
-        request_data = self.json_body(False)
-        if not request_data:
-            if self.has_body():
-                raise ClientError("Request body was not valid JSON")
-            request_data = {}
-        return request_data
-
-    def json_body(self, required=True):
-        json = self._get_json_body()
-        # if we get None then either the body was not JSON or was empty.
-        # If it is required then we have an exception either way.  If it is not required
-        # then we have an exception if a body was provided but it was not JSON.  We can check for this
-        # if json is None and there is an actual request body.  If json is none, the body is empty,
-        # and it was not required, then we can just return None
-        if json is None:
-            if required or self.has_body():
-                raise ClientError("Request body was not valid JSON")
-        return json
-
-    def _get_json_body(self):
+    @property
+    def request_data(self) -> dict[str, Any] | list[Any] | None:
+        """Return the data from the request body, assuming it is JSON."""
         if not self._body_loaded_as_json:
-            if self.get_body() is None:
+            self._body_loaded_as_json = True
+            if not self.has_body():
                 self._body_as_json = None
             else:
-                self._body_loaded_as_json = True
                 try:
                     self._body_as_json = json.loads(self.get_body())
                 except json.JSONDecodeError:
@@ -102,30 +66,7 @@ class InputOutput(ABC):
         return self._body_as_json
 
     @abstractmethod
-    def get_request_method(self):
-        pass
-
-    @abstractmethod
-    def get_script_name(self):
-        pass
-
-    @abstractmethod
-    def get_path_info(self):
-        pass
-
-    def get_full_path(self):
-        path_info = self.get_path_info()
-        script_name = self.get_script_name()
-        if not path_info or path_info[0] != "/":
-            path_info = f"/{path_info}"
-        return f"{path_info}{script_name}".replace("//", "/")
-
-    @abstractmethod
-    def get_query_string(self):
-        pass
-
-    @abstractmethod
-    def get_content_type(self):
+    def get_client_ip(self):
         pass
 
     @abstractmethod
@@ -133,30 +74,43 @@ class InputOutput(ABC):
         pass
 
     @abstractmethod
-    def has_request_header(self, header_name):
-        pass
-
-    @abstractmethod
-    def get_request_header(self, header_name, silent=True):
-        pass
-
-    @abstractmethod
-    def get_query_parameter(self, key):
+    def get_full_path(self) -> str:
         pass
 
-    @abstractmethod
-    def get_query_parameters(self):
-        pass
-
-    @abstractmethod
-    def get_client_ip(self):
-        pass
-
-    def set_authorization_data(self, data):
-        self._authorization_data = data
-
-    def get_authorization_data(self):
-        return self._authorization_data if self._authorization_data else {}
-
     def context_specifics(self):
         return {}
+
+    def get_context_for_callables(self) -> dict[str, Any]:
+        """
+        Return a dictionary with various important parts of the request that are passed along to user-defined functions.
+
+        It's common to make various aspects of an incoming request available to user-defined functions that are
+        attached to clearskies hooks everywhere.  This function centralizes the definition of what aspects of
+        the reequest shouuld be passed along to callables in this case.  When this is in use it typically
+        looks like this:
+
+        di.call_function(some_function, **input_output.get_context_for_callables())
+
+        And this function returns a dictionary with the following values:
+
+        | Key                | Type                             | Ref                                | Value                                                                           |
+        |--------------------|----------------------------------|------------------------------------|---------------------------------------------------------------------------------|
+        | routing_data       | dict[str, str]                   | input_output.routing_data          | A dictionary of data extracted from URL path parameters.                        |
+        | authorization_data | dict[str, Any]                   | input_output.authorization_data    | A dictionary containing the authorization data set by the authentication method |
+        | request_data       | dict[str, Any] | None            | input_output.request_data          | The data sent along with the request (assuming a JSON request body)             |
+        | query_parameters   | dict[str, Any]                   | input_output.query_parameters      | The query parameters                                                            |
+        | request_headers    | clearskies.input_outputs.Headers | input_output.request_headers       | The request headers sent by the client                                          |
+        | **routing_data     | string                           | **input_output.routing_data        | The routing data is unpacked so keys can be fetched directly                    |
+        | **[varies]         | varies                           | **input_output.context_specifics() | Any additional properties added on by the context (see your context docs)       |
+        """
+        return {
+            **self.routing_data,
+            **self.context_specifics(),
+            **{
+                "routing_data": self.routing_data,
+                "authorization_data": self.authorization_data,
+                "request_data": self.request_data,
+                "request_headers": self.request_headers,
+                "query_parameters": self.query_parameters,
+            },
+        }

clearskies/input_outputs/programmatic.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import Any
+
+from clearskies.input_outputs.headers import Headers
+from clearskies.input_outputs.input_output import InputOutput
+
+
+class Programmatic(InputOutput):
+    _body: str | dict[str, Any] | list[Any] = ""
+    url: str = ""
+    ip_address: str = "127.0.0.1"
+    protocol: str = "https"
+
+    def __init__(
+        self,
+        url: str = "",
+        request_method: str = "GET",
+        body: str | dict[str, Any] | list[Any] = "",
+        query_parameters: dict[str, Any] = {},
+        request_headers: dict[str, str] = {},
+        ip_address: str = "127.0.0.1",
+        protocol: str = "https",
+    ):
+        self.url = url
+        self.request_headers = Headers(request_headers)
+        self.query_parameters = query_parameters
+        self.ip_address = ip_address
+        self.protocol = protocol
+        self._body_loaded_as_json = True
+        self._body_as_json = None
+        self.request_method = request_method
+        if body:
+            self._body = body
+            if isinstance(body, dict) or isinstance(body, list):
+                self._body_as_json = body
+
+        super().__init__()
+
+    def respond(self, response, status_code=200):
+        return (status_code, response, self.response_headers)
+
+    def get_full_path(self):
+        return self.url
+
+    def has_body(self):
+        return bool(self._body)
+
+    def get_body(self):
+        if not self.has_body():
+            return ""
+
+        return self._body
+
+    def context_specifics(self):
+        return {}
+
+    def get_client_ip(self):
+        return self.ip_address
+
+    def get_protocol(self):
+        return self.protocol

clearskies/input_outputs/wsgi.py

@@ -1,31 +1,42 @@
-from .input_output import InputOutput
-import urllib, urllib.parse
+from __future__ import annotations
+
 import json
+from typing import Callable
+from urllib.parse import parse_qs
+
+from clearskies.input_outputs.headers import Headers
+from clearskies.input_outputs.input_output import InputOutput
 
 
-class WSGI(InputOutput):
-    _environment = None
-    _start_response = None
-    _request_headers = None
-    _cached_body = None
-    _query_parameters = None
+class Wsgi(InputOutput):
+    _environment: dict[str, str] = {}
+    _start_response: Callable
+    _cached_body: str | None = None
 
     def __init__(self, environment, start_response):
         self._environment = environment
         self._start_response = start_response
-        self._request_headers = {}
+        request_headers = {}
         for key, value in self._environment.items():
             if key.upper()[0:5] == "HTTP_":
-                self._request_headers[key[5:].lower()] = value
+                request_headers[key[5:].lower()] = value
+
+        self.request_headers = Headers(request_headers)
+        self.query_parameters = {
+            key: val[0] for (key, val) in parse_qs(self._environment.get("QUERY_STRING", "")).items()
+        }
+        self.request_method = self._environment.get("REQUEST_METHOD").upper()
+
+        super().__init__()
 
     def _from_environment(self, key):
         return self._environment[key] if key in self._environment else ""
 
     def respond(self, body, status_code=200):
-        if not self.has_header("content-type"):
-            self.set_header("content-type", "application/json; charset=UTF-8")
+        if "content-type" not in self.response_headers:
+            self.response_headers.content_type = "application/json; charset=UTF-8"
 
-        self._start_response(f"{status_code} Ok", [header for header in self._response_headers.items()])
+        self._start_response(f"{status_code} Ok", [header for header in self.response_headers.items()])  # type: ignore
         if type(body) == bytes:
             final_body = body
         elif type(body) == str:
@@ -35,56 +46,33 @@ class WSGI(InputOutput):
         return [final_body]
 
     def has_body(self):
-        return bool(self.get_body())
+        return bool(self._from_environment("CONTENT_LENGTH"))
 
     def get_body(self):
         if self._cached_body is None:
-            self._cached_body = self._from_environment("wsgi.input").read().decode("utf-8")
+            self._cached_body = (
+                self._from_environment("wsgi.input").read(int(self._from_environment("CONTENT_LENGTH"))).decode("utf-8")
+                if self._from_environment("CONTENT_LENGTH")
+                else ""
+            )
         return self._cached_body
 
-    def get_request_method(self):
-        return self._from_environment("REQUEST_METHOD").upper()
-
     def get_script_name(self):
         return self._from_environment("SCRIPT_NAME")
 
     def get_path_info(self):
         return self._from_environment("PATH_INFO")
 
-    def get_query_string(self):
-        return self._from_environment("QUERY_STRING")
-
-    def get_content_type(self):
-        return self._from_environment("CONTENT_TYPE")
+    def get_full_path(self):
+        path_info = self.get_path_info()
+        script_name = self.get_script_name()
+        if not path_info or path_info[0] != "/":
+            path_info = f"/{path_info}"
+        return f"{path_info}{script_name}".replace("//", "/")
 
     def get_protocol(self):
         return self._from_environment("wsgi.url_scheme").lower()
 
-    def has_request_header(self, header_name):
-        return header_name.lower() in self._request_headers
-
-    def get_request_header(self, header_name, silent=False):
-        if not header_name.lower() in self._request_headers:
-            if not silent:
-                raise KeyError(f"HTTP header '{header_name}' was not found in request")
-            return ""
-        return self._request_headers[header_name.lower()]
-
-    def _parse_query_parameters(self):
-        if self._query_parameters is None:
-            self._query_parameters = {
-                key: val[0] if len(val) == 1 else val
-                for (key, val) in urllib.parse.parse_qs(self.get_query_string()).items()
-            }
-
-    def get_query_parameter(self, key):
-        self._parse_query_parameters()
-        return self._query_parameters[key] if key in self._query_parameters else []
-
-    def get_query_parameters(self):
-        self._parse_query_parameters()
-        return self._query_parameters
-
     def context_specifics(self):
         return {"wsgi_environment": self._environment}