clear-skies 2.0.27__py3-none-any.whl

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

@@ -0,0 +1,80 @@
+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: 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
+        request_headers = {}
+        for key, value in self._environment.items():
+            if key.upper()[0:5] == "HTTP_":
+                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 "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()])  # type: ignore
+        if type(body) == bytes:
+            final_body = body
+        elif type(body) == str:
+            final_body = body.encode("utf-8")
+        else:
+            final_body = json.dumps(body).encode("utf-8")
+        return [final_body]
+
+    def has_body(self):
+        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(int(self._from_environment("CONTENT_LENGTH"))).decode("utf-8")
+                if self._from_environment("CONTENT_LENGTH")
+                else ""
+            )
+        return self._cached_body
+
+    def get_script_name(self):
+        return self._from_environment("SCRIPT_NAME")
+
+    def get_path_info(self):
+        return self._from_environment("PATH_INFO")
+
+    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 context_specifics(self):
+        return {"wsgi_environment": self._environment}
+
+    def get_client_ip(self):
+        return self._environment.get("REMOTE_ADDR")

clearskies/loggable.py

@@ -0,0 +1,19 @@
+import logging
+
+
+class Loggable:
+    """
+    Make a class loggable.
+
+    A Mixin that uses the __init_subclass__ hook to automatically inject
+    a named logger into any subclass based on its module and class name.
+    """
+
+    logger: logging.Logger
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        # Automatically create a logger named 'module.ClassName'
+        # This runs once when the class is defined (imported), not instantiated.
+        logger_name = f"{cls.__module__}.{cls.__name__}"
+        cls.logger = logging.getLogger(logger_name)