clear-skies 0.0.3a0__py3-none-any.whl

clearskies/configs/string_or_callable.py

@@ -0,0 +1,18 @@
+from typing import Callable
+
+from clearskies.configs import config
+
+
+class StringOrCallable(config.Config):
+    def __set__(self, instance, value: str | Callable[..., str]):
+        if not isinstance(value, str) and not callable(value):
+            error_prefix = self._error_prefix(instance)
+            raise TypeError(
+                f"{error_prefix} attempt to set a value of type '{value.__class__.__name__}' to a parameter that requires a string or a callable."
+            )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> str | Callable[..., str]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/timedelta.py

@@ -0,0 +1,18 @@
+import datetime
+
+from clearskies.configs import config
+
+
+class Timedelta(config.Config):
+    def __set__(self, instance, value: datetime.timedelta):
+        if not isinstance(value, datetime.timedelta):
+            error_prefix = self._error_prefix(instance)
+            raise TypeError(
+                f"{error_prefix} attempt to set a value of type '{value.__class__.__name__}' to a parameter that requries a datetime.timedelta object."
+            )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> datetime.timedelta:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/timezone.py

@@ -0,0 +1,18 @@
+import datetime
+
+from clearskies.configs import config
+
+
+class Timezone(config.Config):
+    def __set__(self, instance, value: datetime.timezone | None):
+        if value and not isinstance(value, datetime.timezone):
+            error_prefix = self._error_prefix(instance)
+            raise TypeError(
+                f"{error_prefix} attempt to set a value of type '{value.__class__.__name__}' to a parameter that requries a timezone (datetime.timezone)."
+            )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> datetime.timezone:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/url.py

@@ -0,0 +1,23 @@
+from clearskies.configs import string
+from clearskies.functional import routing
+
+
+class Url(string.String):
+    def __set__(self, instance, value: str):
+        if value is None:
+            return
+
+        if not isinstance(value, str):
+            error_prefix = self._error_prefix(instance)
+            raise TypeError(
+                f"{error_prefix} attempt to set a value of type '{value.__class__.__name__}' to a url parameter"
+            )
+        value = value.strip("/")
+
+        if value:
+            try:
+                routing.extract_url_parameter_name_map(value)
+            except ValueError as e:
+                error_prefix = self._error_prefix(instance)
+                raise ValueError(f"{error_prefix} {e}")
+        instance._set_config(self, value)

clearskies/configs/validators.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from clearskies.configs import config
+
+if TYPE_CHECKING:
+    from clearskies import typing
+
+
+class Validators(config.Config):
+    """
+    Validator config.
+
+    A config that accepts various things that are accepted as validators in model columns:
+
+     1. An instance of clearskies.validators.Validator
+     2. A list of clearskies.validators.Validator
+
+    Incoming values are normalized to a list so that a list always comes out even if a non-list is provided.
+    """
+
+    def __set__(
+        self,
+        instance,
+        value: typing.validator | list[typing.validator],
+    ):
+        if not isinstance(value, list):
+            value = [value]
+
+        for index, item in enumerate(value):
+            if hasattr(item, "additional_write_columns") and hasattr(item, "check"):
+                continue
+
+            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 a Validator is required"
+            )
+
+        instance._set_config(self, [*value])
+
+    def __get__(self, instance, parent) -> list[typing.validator]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/writeable_model_column.py

@@ -0,0 +1,9 @@
+from clearskies.configs import model_column
+
+
+class WriteableModelColumn(model_column.ModelColumn):
+    def get_allowed_columns(self, model_class, column_configs):
+        return [name for (name, column) in column_configs.items() if column.is_writeable]
+
+    def my_description(self):
+        return "writeable column"

clearskies/configs/writeable_model_columns.py

@@ -0,0 +1,9 @@
+from clearskies.configs import model_columns
+
+
+class WriteableModelColumns(model_columns.ModelColumns):
+    def get_allowed_columns(self, model_class, column_configs):
+        return [name for (name, column) in column_configs.items() if column.is_writeable]
+
+    def my_description(self):
+        return "writeable column"

clearskies/configurable.py

@@ -0,0 +1,76 @@
+from typing import Any
+
+from clearskies.configs import config
+
+
+class Configurable:
+    _config: dict[str, Any] | None = None
+    _descriptor_config_map: dict[int, str] | None = None
+
+    def _set_config(self, descriptor, value):
+        if not self._config:
+            self._config = {}
+
+        self._config[self._descriptor_to_name(descriptor)] = value
+
+    def _get_config(self, descriptor):
+        if not self._config:
+            self._config = {}
+
+        name = self._descriptor_to_name(descriptor)
+        if name not in self._config:
+            raise KeyError(f"Attempt to fetch a config value named '{name}' but no value has been set for this config")
+        return self._config[name]
+
+    @classmethod
+    def _get_config_object(cls, attribute_name):
+        return getattr(cls, attribute_name)
+
+    @classmethod
+    def get_descriptor_config_map(cls):
+        if cls._descriptor_config_map:
+            return cls._descriptor_config_map
+
+        descriptor_config_map = {}
+        for attribute_name in dir(cls):
+            descriptor = getattr(cls, attribute_name)
+            if not isinstance(descriptor, config.Config):
+                continue
+
+            descriptor_config_map[id(descriptor)] = attribute_name
+
+        cls._descriptor_config_map = descriptor_config_map
+        return cls._descriptor_config_map
+
+    def _descriptor_to_name(self, descriptor):
+        descriptor_config_map = self.get_descriptor_config_map()
+        if id(descriptor) not in descriptor_config_map:
+            raise ValueError(
+                f"The reason behind this error is kinda long and complicated, but doens't really matter.  To make it go away, just add `_descriptor_config_map = None` to the definition of {self.__class__.__name__}"
+            )
+        return descriptor_config_map[id(descriptor)]
+
+    def finalize_and_validate_configuration(self):
+        my_class = self.__class__
+        if not self._config:
+            self._config = {}
+
+        # now it's time to check for required values and provide defaults
+        attribute_names = self.get_descriptor_config_map().values()
+        for attribute_name in attribute_names:
+            config = getattr(my_class, attribute_name)
+            if attribute_name not in self._config:
+                self._config[attribute_name] = config.default
+
+            if config.required and self._config.get(attribute_name) is None:
+                raise ValueError(
+                    f"Missing required configuration property '{attribute_name}' for class '{my_class.__name__}'"
+                )
+
+        # loop through a second time to have the configs check their values
+        # we do this as a separate step because we want to make sure required and default
+        # values are specified before we have the configs do their validation.
+        for attribute_name in attribute_names:
+            getattr(my_class, attribute_name).finalize_and_validate_configuration(self)
+            if attribute_name not in self._config:
+                self._config[attribute_name] = None

clearskies/contexts/__init__.py

@@ -0,0 +1,11 @@
+from clearskies.contexts.cli import Cli
+from clearskies.contexts.context import Context
+from clearskies.contexts.wsgi import Wsgi
+from clearskies.contexts.wsgi_ref import WsgiRef
+
+__all__ = [
+    "Cli",
+    "Context",
+    "Wsgi",
+    "WsgiRef",
+]

clearskies/contexts/cli.py

@@ -0,0 +1,7 @@
+from clearskies.contexts.context import Context
+from clearskies.input_outputs import Cli as CliInputOutput
+
+
+class Cli(Context):
+    def __call__(self):  # type: ignore
+        return self.execute_application(CliInputOutput())

clearskies/contexts/context.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import datetime
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, Callable
+
+import clearskies.endpoint
+import clearskies.endpoint_group
+from clearskies.di import Di
+from clearskies.di.additional_config import AdditionalConfig
+from clearskies.input_outputs import Programmatic
+
+if TYPE_CHECKING:
+    from clearskies.input_outputs import InputOutput
+
+
+class Context:
+    di: Di = None  # type: ignore
+
+    def __init__(
+        self,
+        application: Callable | clearskies.endpoint.Endpoint | clearskies.endpoint_group.EndpointGroup,
+        classes: type | list[type] = [],
+        modules: ModuleType | list[ModuleType] = [],
+        bindings: dict[str, Any] = {},
+        additional_configs: AdditionalConfig | list[AdditionalConfig] = [],
+        class_overrides: dict[type, Any] = {},
+        overrides: dict[str, type] = {},
+        now: datetime.datetime | None = None,
+        utcnow: datetime.datetime | None = None,
+    ):
+        self.di = Di(
+            classes=classes,
+            modules=modules,
+            bindings=bindings,
+            additional_configs=additional_configs,
+            class_overrides=class_overrides,
+            now=now,
+            utcnow=utcnow,
+        )
+        self.application = application
+
+    def execute_application(self, input_output: InputOutput):
+        if hasattr(self.application, "injectable_properties"):
+            self.application.injectable_properties(self.di)
+            return self.application(input_output)
+        elif callable(self.application):
+            try:
+                return input_output.respond(
+                    self.di.call_function(self.application, **input_output.get_context_for_callables())
+                )
+            except clearskies.exceptions.ClientError as e:
+                return input_output.respond(str(e), 400)
+            except clearskies.exceptions.Authentication as e:
+                return input_output.respond(str(e), 401)
+            except clearskies.exceptions.Authorization as e:
+                return input_output.respond(str(e), 403)
+            except clearskies.exceptions.NotFound as e:
+                return input_output.respond(str(e), 404)
+            except clearskies.exceptions.MovedPermanently as e:
+                return input_output.respond(str(e), 302)
+            except clearskies.exceptions.MovedTemporarily as e:
+                return input_output.respond(str(e), 307)
+
+    def __call__(
+        self,
+        url: str = "",
+        request_method: str = "GET",
+        body: str | dict[str, Any] | list[Any] = "",
+        query_parameters: dict[str, str] = {},
+        request_headers: dict[str, str] = {},
+    ):
+        return self.execute_application(
+            Programmatic(
+                url=url,
+                request_method=request_method,
+                body=body,
+                query_parameters=query_parameters,
+                request_headers=request_headers,
+            )
+        )
+
+    def build(self, thing: Any, cache: bool = False) -> Any:
+        return self.di.build(thing, cache=cache)

clearskies/contexts/wsgi.py

@@ -0,0 +1,16 @@
+import datetime
+from types import ModuleType
+from typing import Any, Callable
+from wsgiref.simple_server import make_server
+from wsgiref.util import setup_testing_defaults
+
+import clearskies.endpoint
+import clearskies.endpoint_group
+from clearskies.contexts.context import Context
+from clearskies.di import AdditionalConfig
+from clearskies.input_outputs import Wsgi as WsgiInputOutput
+
+
+class Wsgi(Context):
+    def __call__(self, env, start_response):  # type: ignore
+        return self.execute_application(WsgiInputOutput(env, start_response))

clearskies/contexts/wsgi_ref.py

@@ -0,0 +1,49 @@
+import datetime
+from types import ModuleType
+from typing import Any, Callable
+from wsgiref.simple_server import make_server
+from wsgiref.util import setup_testing_defaults
+
+import clearskies.endpoint
+import clearskies.endpoint_group
+from clearskies.contexts.context import Context
+from clearskies.di import AdditionalConfig
+from clearskies.input_outputs import Wsgi as WsgiInputOutput
+
+
+class WsgiRef(Context):
+    port: int = 8080
+
+    def __init__(
+        self,
+        application: Callable | clearskies.endpoint.Endpoint | clearskies.endpoint_group.EndpointGroup,
+        port: int = 8080,
+        classes: type | list[type] = [],
+        modules: ModuleType | list[ModuleType] = [],
+        bindings: dict[str, Any] = {},
+        additional_configs: AdditionalConfig | list[AdditionalConfig] = [],
+        class_overrides: dict[type, type] = {},
+        overrides: dict[str, type] = {},
+        now: datetime.datetime | None = None,
+        utcnow: datetime.datetime | None = None,
+    ):
+        super().__init__(
+            application,
+            classes=classes,
+            modules=modules,
+            bindings=bindings,
+            additional_configs=additional_configs,
+            class_overrides=class_overrides,
+            overrides=overrides,
+            now=now,
+            utcnow=utcnow,
+        )
+        self.port = port
+
+    def __call__(self):  # type: ignore
+        with make_server("", self.port, self.handler) as httpd:
+            print(f"Starting WSGI server on port {self.port}.  This is NOT intended for production usage.")
+            httpd.serve_forever()
+
+    def handler(self, environment, start_response):
+        return self.execute_application(WsgiInputOutput(environment, start_response))

clearskies/di/__init__.py

@@ -0,0 +1,14 @@
+import clearskies.di.inject as inject
+from clearskies.di.additional_config import AdditionalConfig
+from clearskies.di.additional_config_auto_import import AdditionalConfigAutoImport
+from clearskies.di.di import Di
+from clearskies.di.injectable import Injectable
+from clearskies.di.injectable_properties import InjectableProperties
+
+__all__ = [
+    "AdditionalConfig",
+    "AdditionalConfigAutoImport",
+    "Di",
+    "InjectableProperties",
+    "injectInjectable",
+]

clearskies/di/additional_config.py

@@ -0,0 +1,130 @@
+from typing import Any
+
+
+class AdditionalConfig:
+    """
+    This class allows you to add additional names to the Di container.
+
+    The idea here is that you extend the AdditonalConfig class and attach as many
+    `provide_*` methods to the class as you want.  This allows the developer to declare a number of
+    dependencies and easily attach them to the Di container in one go - helpful for modules that
+    come with a variety of things that they want to make available to developers.
+
+    When an AdditionalConfig instance is attached to the Di container, the container (in essence) finds all the
+    `provide_*` methods in the class and registers the corresponding name in the Di container - e.g. if you have
+    a method called `provide_widget` then when a class or function requests an argument named `widget`
+    from the Di container, the container will call the `provide_widget` method on your instance and pass along
+    the return value to the thing that requested a `widget`. The `provide_*` methods can declare their own
+    dependencies, including ones declared in the same `AdditionalConfig` class (they just can't be circular, of course).
+
+    As always, keep in mind the priority of dependency injection names (see the `clearskies.di.Di` class for full
+    details).  If two `AdditionalConfig` objects declare a `provide_*` method with the same name, then the Di
+    system will call the method for the `AdditionalConfig` object that was added last.
+
+    By default the Di system caches all values.  If you have a dependency that shouldn't be cached, you can
+    extend the `can_cache` method and have it return True/False depending on the name and context.
+
+    Example:
+    ```python
+    from clearskies.di import Di, AdditionalConfig
+
+
+    class MyAdditionalConfig(AdditionalConfig):
+        def provide_inner_dependency(self):
+            return 5
+
+        def provide_important_thing(self, inner_dependency):
+            return inner_dependency * 10
+
+
+    class AnotherAdditionalConfig(AdditionalConfig):
+        def provide_inner_dependency(self):
+            return 10
+
+
+    di = Di(additional_configs=[MyAdditionalConfig(), AnotherAdditionalConfig()])
+    # Equivalent:
+    # di = Di()
+    # di.add_addtional_configs([MyAdditionalConfig(), AnotherAdditionalConfig()])
+
+
+    def my_function(important_thing):
+        print(important_thing)  # prints 100
+    ```
+    """
+
+    def can_cache(self, name: str, di, context: str) -> bool:
+        """
+        Cache control.
+
+        The Di container caches values by default, but this method allows you to override that.
+        After fetching an object from the AdditionalConfig class, the Di container will call this method to
+        determine whether or not to cache  it.  `name` will be the name of the Di value that was built, and
+        context will be the name of the class that the value was built for.  You then return True/False.
+
+        Note that this controls whether or not to cache the returned value, not whether or not to check the
+        cache for a value.  The importance is that, once there is a value in the cache, that will be reused
+        for all future requests for that name.  Example:
+
+        ```python
+        from clearskies.di import Di, AdditionalConfig
+        import secrets
+
+
+        class MyAdditionalConfig(AdditionalConfig):
+            def provide_random_number_not_cached(self):
+                return secrets.randbelow(100)
+
+            def provide_random_number_cached(self):
+                return secrets.randbelow(100)
+
+            def can_cache(self, name, context=None):
+                return name == "random_number_not_cached"
+
+
+        di = Di(additional_configs=MyAdditionalConfig())
+
+
+        def my_function(random_number_cached, random_number_not_cached):
+            print(random_number_cached)
+            print(random_number_not_cached)
+
+
+        di.call_function(my_function)
+        di.call_function(my_function)
+        di.call_function(my_function)
+        di.call_function(my_function)
+
+        # This prints something like:
+        # 58
+        # 12
+        # 58
+        # 14
+        # 58
+        # 41
+        ```
+        """
+        return True
+
+    def can_build(self, name):
+        return hasattr(self, f"provide_{name}")
+
+    def build(self, name, di, context=None):
+        if not hasattr(self, f"provide_{name}"):
+            raise KeyError(
+                f"AdditionalConfig class '{self.__class__.__name__}' cannot build requested dependency, '{name}'"
+            )
+
+        return di.call_function(getattr(self, f"provide_{name}"))
+
+    def can_build_class(self, class_to_check: type) -> bool:
+        """Return True/False to denote if this AdditionalConfig class can provide a given class."""
+        return False
+
+    def build_class(self, class_to_provide: type, argument_name: str, di, context: str = "") -> Any:
+        """Return the desired instance of a given class."""
+        pass
+
+    def can_cache_class(self, class_to_build: type, di, context: str) -> bool:
+        """Control whether or not the Di container caches the instance after building a class."""
+        return False

clearskies/di/additional_config_auto_import.py

@@ -0,0 +1,17 @@
+from .additional_config import AdditionalConfig
+
+
+class AdditionalConfigAutoImport(AdditionalConfig):
+    """
+    AdditionalConfig, but now with auto import.
+
+    This works exactly like the AdditionalConfig class, but will be automatically imported into the Di
+    container if found in a module being imported into the Di container.  This just provides a way for
+    modules to easily inject names into the Di system.  In order to be found, an imported module
+    just needs to make sure that it imports the class that extends the AdditionalConfigAutoImport class.
+
+    Note that automatically-imported AdditionalConfig classes automatically have lower priority than
+    any AdditionalConfig classes added explicitly to the Di container.
+    """
+
+    pass