clear-skies 2.0.10__tar.gz → 2.0.12__tar.gz

{clear_skies-2.0.10 → clear_skies-2.0.12}/CHANGELOG.md

@@ -5,9 +5,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.12] - 2025-10-09
+
+### Changed
+- Use dict for Header class by @cmancone in [#23](https://github.com/clearskies-py/clearskies/pull/23)
+- Make headers a dict
+
+## [2.0.11] - 2025-10-09
+
+### Changed
+- Bump version to v2.0.11 by @github-actions[bot]
+- Typos by @cmancone in [#24](https://github.com/clearskies-py/clearskies/pull/24)
+- Input Output reorg by @cmancone
+
 ## [2.0.10] - 2025-10-06
 
 ### Changed
+- Bump version to v2.0.10 by @github-actions[bot]
 - Include injectable props for base secret class, and detection of… by @cmancone in [#22](https://github.com/clearskies-py/clearskies/pull/22)
 - Black by @cmancone
 - Include injectable props for base secret class, and detection of missing class by @cmancone
@@ -799,6 +813,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * @ made their first contribution
 * @tnijboer made their first contribution
 * @conormancone-cimpress made their first contribution
+[2.0.12]: https://github.com/clearskies-py/clearskies/compare/v2.0.11..v2.0.12
+[2.0.11]: https://github.com/clearskies-py/clearskies/compare/v2.0.10..v2.0.11
 [2.0.10]: https://github.com/clearskies-py/clearskies/compare/v2.0.9..v2.0.10
 [2.0.9]: https://github.com/clearskies-py/clearskies/compare/v2.0.8..v2.0.9
 [2.0.8]: https://github.com/clearskies-py/clearskies/compare/v2.0.7..v2.0.8

clear_skies-2.0.12/LATEST_CHANGELOG.md

@@ -0,0 +1,6 @@
+## [2.0.12] - 2025-10-09
+
+### Changed
+- Use dict for Header class by @cmancone in [#23](https://github.com/clearskies-py/clearskies/pull/23)
+- Make headers a dict
+

{clear_skies-2.0.10 → clear_skies-2.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clear-skies
-Version: 2.0.10
+Version: 2.0.12
 Summary: A framework for building backends in the cloud
 Project-URL: Documentation, https://clearskies.io/
 Project-URL: Repository, https://github.com/clearskies-py/clearskies

{clear_skies-2.0.10 → clear_skies-2.0.12}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "clear-skies"
 description = "A framework for building backends in the cloud"
-version = "2.0.10"
+version = "2.0.12"
 license = "MIT"
 readme = "./README.md"
 authors = [{name = "Conor Mancone", email = "cmancone@gmail.com"}]

{clear_skies-2.0.10 → clear_skies-2.0.12}/src/clearskies/columns/audit.py

@@ -155,7 +155,7 @@ class Audit(HasMany):
             },
         )
 
-    def post_delete(self, model):
+    def post_delete(self, model: Model) -> None:
         super().post_delete(model)
         exclude_columns = self.exclude_columns
         model_columns = self.get_model_columns()
@@ -167,7 +167,7 @@ class Audit(HasMany):
                 continue
             final_data = {
                 **final_data,
-                **(model_columns[key].to_json(model) if key in model_columns else {key: model.data.get(key)}),
+                **(model_columns[key].to_json(model) if key in model_columns else {key: model.get_raw_data().get(key)}),
             }
 
         for key in mask_columns:
@@ -178,7 +178,7 @@ class Audit(HasMany):
         self.child_model.create(
             {
                 "class": self.model_class.__name__,
-                "resource_id": model.get(self.model_class.id_column_name),
+                "resource_id": getattr(model, self.model_class.id_column_name),
                 "action": "delete",
                 "data": final_data,
             }

{clear_skies-2.0.10 → clear_skies-2.0.12}/src/clearskies/configs/__init__.py

@@ -87,6 +87,7 @@ from .endpoint import Endpoint
 from .endpoint_list import EndpointList
 from .float import Float
 from .float_or_callable import FloatOrCallable
+from .headers import Headers
 from .integer import Integer
 from .integer_or_callable import IntegerOrCallable
 from .joins import Joins
@@ -139,6 +140,7 @@ __all__ = [
     "EndpointList",
     "Float",
     "FloatOrCallable",
+    "Headers",
     "Joins",
     "Integer",
     "IntegerOrCallable",

{clear_skies-2.0.10 → clear_skies-2.0.12}/src/clearskies/configs/endpoint_list.py

@@ -19,7 +19,7 @@ class EndpointList(config.Config):
             if not hasattr(item, "top_level_authentication_and_authorization"):
                 error_prefix = self._error_prefix(instance)
                 raise TypeError(
-                    f"{error_prefix} attempt to set a value of type '{item.__class__.__name__}' for item #{index+1} when all items in the list should be instances of clearskies.End."
+                    f"{error_prefix} attempt to set a value of type '{item.__class__.__name__}' for item #{index + 1} when all items in the list should be instances of clearskies.End."
                 )
         instance._set_config(self, value)
 

clear_skies-2.0.12/src/clearskies/configs/headers.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from clearskies.configs import config
+
+if TYPE_CHECKING:
+    from clearskies.input_outputs import headers
+
+
+class Headers(config.Config):
+    """
+    This is for a configuration that should be an instance of type clearskies.input_outputs.Headers.
+    """
+
+    def __set__(self, instance, value: headers.Headers):
+        if value is None:
+            return
+
+        if not hasattr(value, "_duck_cheat") or value._duck_cheat != "headers":
+            error_prefix = self._error_prefix(instance)
+            raise TypeError(
+                f"{error_prefix} attempt to set a value of type '{value.__class__.__name__}' to a property that expets an instance of clearskies.input_outputs.Headers"
+            )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> headers.Headers:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

{clear_skies-2.0.10 → clear_skies-2.0.12}/src/clearskies/contexts/cli.py

@@ -119,6 +119,11 @@ class Cli(Context):
     Although note that the first two are going to be preferred over the third, simply because with the
     third there's simply no way to specify the type of a variable.  As a result, you may run into issues
     with strict type checking on endpoints.
+
+    ### Context Callables
+
+    When using the Cli context, an additional named argument is made available to any callables invoked by clearskies:
+    `sys_argv`.  This contains `sys.argv`.
     """
 
     def __call__(self):  # type: ignore

{clear_skies-2.0.10 → clear_skies-2.0.12}/src/clearskies/contexts/context.py

@@ -7,12 +7,12 @@ from typing import TYPE_CHECKING, Any, Callable
 from clearskies import exceptions
 from clearskies.di import Di
 from clearskies.di.additional_config import AdditionalConfig
+from clearskies.input_outputs import InputOutput
 from clearskies.input_outputs import Programmatic
 
 if TYPE_CHECKING:
     from clearskies.endpoint import Endpoint
     from clearskies.endpoint_group import EndpointGroup
-    from clearskies.input_outputs import InputOutput
 
 
 class Context:
@@ -54,6 +54,9 @@ class Context:
         self.application = application
 
     def execute_application(self, input_output: InputOutput):
+        self.di.add_binding("input_output", input_output)
+        self.di.add_class_override(InputOutput, input_output)
+
         if hasattr(self.application, "injectable_properties"):
             self.application.injectable_properties(self.di)
             return self.application(input_output)

{clear_skies-2.0.10 → clear_skies-2.0.12}/src/clearskies/contexts/wsgi.py

@@ -72,6 +72,11 @@ class Wsgi(Context):
     by and large it's normal and expected that you'll persist the cache between requests by creating the context outside
     of any handler functions.
 
+    ### Context for Callables
+
+    When using this context, one additional named property becomes available to any callables invoked by clearskies:
+    `wsgi_environment`.  This contains the environment object passed in by the WSGI server to clearskies.
+
     """
 
     def __call__(self, env, start_response):  # type: ignore

{clear_skies-2.0.10 → clear_skies-2.0.12}/src/clearskies/di/di.py

@@ -520,7 +520,7 @@ class Di:
         """
         if not inspect.isclass(class_to_override):
             raise ValueError(
-                "Invalid value passed to add_class_override for 'class_or_name' parameter: it was neither a name nor a class"
+                "Invalid value passed to add_class_override for 'class_to_override' parameter: it was not a class."
             )
 
         self._class_overrides_by_class[class_to_override] = replacement
@@ -723,12 +723,18 @@ class Di:
             return None
         if not callable(class_to_build):
             return None
-        if inspect.isabstract(class_to_build):
-            return None
 
-        # then first things first: check our class overrides
+        # check our class overrides
         if class_to_build in self._class_overrides_by_class:
-            return self.build_class(self._class_overrides_by_class[class_to_build], context=context, cache=cache)
+            replacement = self._class_overrides_by_class[class_to_build]
+            if not inspect.isclass(replacement):
+                return replacement
+            return self.build_class(replacement, context=context, cache=cache)
+
+        # generally we can't build abstract classes, so if the class is abstract then we should pass.
+        # However, this is not the case if it has an override - then the developer has given us specific guidance
+        if inspect.isabstract(class_to_build):
+            return None
 
         # next check our additional config classes
         built_value = None

{clear_skies-2.0.10 → clear_skies-2.0.12}/src/clearskies/end.py

@@ -88,8 +88,6 @@ class End(
         if response:
             return response
 
-        self.di.add_binding("input_output", input_output)
-
         # catch everything when we do an AuthN/AuthZ check because we allow custom-defined classes,
         # and this gives more flexibility (or possibly forgiveness) for how they raise exceptions.
         try:

{clear_skies-2.0.10 → clear_skies-2.0.12}/src/clearskies/endpoint.py

@@ -969,7 +969,7 @@ class Endpoint(
         """Whether or not we can handle an incoming request based on URL and request method."""
         # soo..... this excessively duplicates the logic in __call__, but I'm being lazy right now
         # and not fixing it.
-        request_method = input_output.get_request_method().upper()
+        request_method = input_output.request_method.upper()
         if request_method == "OPTIONS":
             return True
         if request_method not in self.request_methods:
@@ -986,7 +986,7 @@ class Endpoint(
         # matches_request is only checked by the endpoint group, not by the context.  As a result, we need to check our
         # route.  However we always have to check our route anyway because the full routing data can only be figured
         # out at the endpoint level, so calling out to routing.mattch_route is unavoidable.
-        request_method = input_output.get_request_method().upper()
+        request_method = input_output.request_method.upper()
         if request_method == "OPTIONS":
             return self.cors(input_output)
         if request_method not in self.request_methods:

{clear_skies-2.0.10 → clear_skies-2.0.12}/src/clearskies/input_outputs/cli.py

@@ -5,19 +5,16 @@ import sys
 from os import isatty
 from sys import stdin
 
+from clearskies.input_outputs.headers import Headers
 from clearskies.input_outputs.input_output import InputOutput
 
 
 class Cli(InputOutput):
-    _args: list[str] = []
+    path: str
     _has_body: bool = False
     _body: str = ""
-    _request_method: str = ""
-    _request_headers: dict[str, str] = {}
 
     def __init__(self):
-        self._request_headers = {}
-        self._args = []
         self._parse_args(sys.argv)
         super().__init__()
 
@@ -30,16 +27,13 @@ class Cli(InputOutput):
             sys.exit(final)
         print(final)
 
-    def get_arguments(self):
-        return sys.argv
-
     def _parse_args(self, argv):
         tty_data = None
         if not isatty(stdin.fileno()):
             tty_data = sys.stdin.read().strip()
 
         request_headers = {}
-        self._args = []
+        args = []
         kwargs = {}
         index = 0
         # In general we will use positional arguments for routing, and kwargs for request data.
@@ -49,10 +43,10 @@ class Cli(InputOutput):
         while index < len(argv) - 1:
             index += 1
 
-            # if we don't start with a dash then we are a positional argument
+            # if we don't start with a dash then we are a positional argument which are used for building the URL-equivalent
             arg = argv[index]
             if arg[0] != "-":
-                self._args.append(arg)
+                args.append(arg)
                 continue
 
             # otherwise a kwarg
@@ -83,8 +77,8 @@ class Cli(InputOutput):
 
             kwargs[key] = value
 
-        self._request_headers = request_headers
-        self._request_method = "GET"
+        self.request_headers = Headers(request_headers)
+        self.request_method = "GET"
         request_method_source = ""
         for key in ["x", "X", "request_method"]:
             if key not in kwargs:
@@ -94,7 +88,7 @@ class Cli(InputOutput):
                 raise ValueError(
                     f"Invalid clearskies cli calling sequence: the request method was specified via both the -{key} parameter and the -{request_method_source} parameter. To avoid ambiguity, it should only be set once."
                 )
-            self._request_method = kwargs[key]
+            self.request_method = kwargs[key].upper()
             del kwargs[key]
             request_method_source = key
 
@@ -127,6 +121,8 @@ class Cli(InputOutput):
             final_data = kwargs
             data_source = "kwargs"
 
+        self.path = "/".join(args)
+
         # Most of the above inputs result in a string for our final data, in which case we'll leave it as the "raw body"
         # so that it can optionally be interpreted as JSON.  If we received a bunch of kwargs though, we'll allow those to
         # only be "read" as JSON.
@@ -139,17 +135,8 @@ class Cli(InputOutput):
             self._has_body = True
             self._body = final_data
 
-    def get_script_name(self):
-        return sys.argv[0]
-
-    def get_path_info(self):
-        return "/".join(self._args)
-
     def get_full_path(self):
-        return self.get_path_info()
-
-    def get_request_method(self):
-        return self._request_method
+        return self.path
 
     def has_body(self):
         return self._has_body
@@ -160,14 +147,11 @@ class Cli(InputOutput):
 
         return self._body
 
+    def get_protocol(self):
+        return "cli"
+
     def context_specifics(self):
-        return {}
+        return {"sys_argv": sys.argv}
 
     def get_client_ip(self):
         return "127.0.0.1"
-
-    def get_query_string(self):
-        return ""
-
-    def get_request_headers(self):
-        return self._request_headers

clear_skies-2.0.12/src/clearskies/input_outputs/headers.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import re
+from typing import TypeVar
+
+_T = TypeVar("_T")
+
+
+class Headers(dict[str, str]):
+    _duck_cheat = "headers"
+
+    def __init__(self, headers: dict[str, str] = {}) -> None:
+        normalized_headers = (
+            {key.upper().replace("_", "-"): value for (key, value) in headers.items()} if headers else {}
+        )
+        super().__init__(normalized_headers)
+
+    def __contains__(self, key: object) -> bool:
+        if not isinstance(key, str):
+            return False
+        return super().__contains__(key.upper().replace("_", "-"))
+
+    def __getitem__(self, key: str) -> str:
+        return super().__getitem__(key.upper().replace("_", "-"))
+
+    def __setitem__(self, key: str, value: str) -> None:
+        if not isinstance(key, str):
+            raise TypeError(
+                f"Header keys must be strings, but an object of type '{key.__class__.__name__}' was provided."
+            )
+        if not isinstance(value, str):
+            raise TypeError(
+                f"Header values must be strings, but an object of type '{value.__class__.__name__}' was provided."
+            )
+        normalized_key = re.sub("\\s+", " ", key.upper().replace("_", "-"))
+        normalized_value = re.sub("\\s+", " ", value.strip())
+        super().__setitem__(normalized_key, normalized_value)
+
+    def __getattr__(self, key: str) -> str | None:
+        return self.get(key.upper().replace("_", "-"), None)
+
+    def __setattr__(self, key: str, value: str) -> None:
+        if key.startswith("_") or key == "_duck_cheat":
+            # Allow setting private attributes and special attributes normally
+            super().__setattr__(key, value)
+        else:
+            self.__setitem__(key, value)
+
+    def get(self, key: str, default: _T = None) -> str | _T:  # type: ignore[assignment]
+        return super().get(key.upper().replace("_", "-"), default)
+
+    def add(self, key: str, value: str) -> None:
+        """Add a header.  This expects a string with a colon separating the key and value."""
+        setattr(self, key, value)

{clear_skies-2.0.10 → clear_skies-2.0.12}/src/clearskies/input_outputs/input_output.py

@@ -5,7 +5,9 @@ from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any
 from urllib.parse import parse_qs
 
-from clearskies import configs, configurable, input_outputs
+from clearskies import configs, configurable
+
+from .headers import Headers
 
 if TYPE_CHECKING:
     from clearskies import typing
@@ -14,21 +16,18 @@ if TYPE_CHECKING:
 class InputOutput(ABC, configurable.Configurable):
     """Manage the request and response to the client."""
 
-    response_headers: input_outputs.Headers = None  # type: ignore
-    request_headers: input_outputs.Headers = None  # type: ignore
+    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")
 
     _body_as_json: dict[str, Any] | list[Any] | None = {}
     _body_loaded_as_json = False
 
     def __init__(self):
-        self.response_headers = input_outputs.Headers()
-        self.request_headers = input_outputs.Headers(self.get_request_headers())
-        self.query_parameters = {key: val[0] for (key, val) in parse_qs(self.get_query_string()).items()}
-        self.authorization_data = {}
-        self.routing_data = {}
+        self.response_headers = Headers()
         self.finalize_and_validate_configuration()
 
     @abstractmethod
@@ -65,41 +64,17 @@ class InputOutput(ABC, configurable.Configurable):
                     self._body_as_json = None
         return self._body_as_json
 
-    @abstractmethod
-    def get_request_method(self) -> str:
-        """Return the request method set by the client."""
-        pass
-
-    @abstractmethod
-    def get_script_name(self) -> str:
-        """Return the script name, e.g. the path requested."""
-        pass
-
-    @abstractmethod
-    def get_path_info(self) -> str:
-        """Return the path info for the request."""
-        pass
-
-    @abstractmethod
-    def get_query_string(self) -> str:
-        """Return the full query string for the request (everything after the first question mark in the document URL)."""
-        pass
-
     @abstractmethod
     def get_client_ip(self):
         pass
 
     @abstractmethod
-    def get_request_headers(self) -> dict[str, str]:
+    def get_protocol(self):
         pass
 
+    @abstractmethod
     def get_full_path(self) -> str:
-        """Return the full path requested by the client."""
-        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("//", "/")
+        pass
 
     def context_specifics(self):
         return {}
@@ -117,17 +92,19 @@ class InputOutput(ABC, configurable.Configurable):
 
         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                    |
+        | 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,

{clear_skies-2.0.10 → clear_skies-2.0.12}/src/clearskies/input_outputs/programmatic.py

@@ -2,14 +2,15 @@ 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] = ""
-    _request_method: str = ""
-    _request_headers: dict[str, Any] = {}
     url: str = ""
+    ip_address: str = "127.0.0.1"
+    protocol: str = "https"
 
     def __init__(
         self,
@@ -18,35 +19,30 @@ class Programmatic(InputOutput):
         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 = {**request_headers}
+        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
+        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__()
-        self.query_parameters = {**query_parameters}
 
     def respond(self, response, status_code=200):
         return (status_code, response, self.response_headers)
 
-    def get_script_name(self):
-        return self.url
-
-    def get_path_info(self):
-        return self.url
-
     def get_full_path(self):
         return self.url
 
-    def get_request_method(self):
-        return self._request_method
-
     def has_body(self):
         return bool(self._body)
 
@@ -60,10 +56,7 @@ class Programmatic(InputOutput):
         return {}
 
     def get_client_ip(self):
-        return "127.0.0.1"
-
-    def get_query_string(self):
-        return ""
+        return self.ip_address
 
-    def get_request_headers(self):
-        return self._request_headers
+    def get_protocol(self):
+        return self.protocol