clear-skies 2.0.5__py3-none-any.whl → 2.0.6__py3-none-any.whl

clearskies/configs/datetime_or_callable.py

@@ -0,0 +1,19 @@
+import datetime
+from typing import Callable
+
+from clearskies.configs import config
+
+
+class DatetimeOrCallable(config.Config):
+    def __set__(self, instance, value: datetime.datetime | Callable[..., datetime.datetime]):
+        if not isinstance(value, datetime.datetime) 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 requries a datetime object or a callable."
+            )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> datetime.datetime | Callable[..., datetime.datetime]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/endpoint.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from clearskies.configs import config
+
+if TYPE_CHECKING:
+    from clearskies.endpoint import Endpoint as EndpointBase
+
+
+class Endpoint(config.Config):
+    def __set__(self, instance, value: EndpointBase):
+        if not hasattr(value, "success"):
+            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 an endpoint."
+            )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> EndpointBase:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/endpoint_list.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from clearskies.configs import config
+
+if TYPE_CHECKING:
+    from clearskies.endpoint import Endpoint as EndpointBase
+
+
+class EndpointList(config.Config):
+    def __set__(self, instance, value: list[EndpointBase]):
+        if not isinstance(value, list):
+            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 list of endpoints."
+            )
+        for index, item in enumerate(value):
+            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."
+                )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> list[EndpointBase]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/float.py

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

clearskies/configs/float_or_callable.py

@@ -0,0 +1,18 @@
+from typing import Callable
+
+from clearskies.configs import config
+
+
+class FloatOrCallable(config.Config):
+    def __set__(self, instance, value: float | Callable[..., float]):
+        if not isinstance(value, float) 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 parameter that requires a float or a callable."
+            )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> float | Callable[..., float]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/integer.py

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

clearskies/configs/integer_or_callable.py

@@ -0,0 +1,18 @@
+from typing import Callable
+
+from clearskies.configs import config
+
+
+class IntegerOrCallable(config.Config):
+    def __set__(self, instance, value: int | Callable[..., int]):
+        if not isinstance(value, int) 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 parameter that requires an integer or a callable."
+            )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> int | Callable[..., int]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/joins.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from clearskies.configs import config
+
+if TYPE_CHECKING:
+    from clearskies import typing
+
+
+class Joins(config.Config):
+    def __set__(self, instance, value: typing.join | list[typing.join]):
+        if not isinstance(value, list):
+            value = [value]
+
+        for index, item in enumerate(value):
+            if callable(item) or isinstance(item, str):
+                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 string or callable is required"  # type: ignore
+            )
+
+        instance._set_config(self, [*value])
+
+    def __get__(self, instance, parent) -> list[typing.join]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/list_any_dict.py

@@ -0,0 +1,30 @@
+from typing import Any
+
+from clearskies.configs import config
+
+
+class ListAnyDict(config.Config):
+    def __set__(self, instance, value: list[dict[str, Any]]):
+        if not isinstance(value, list):
+            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 list."
+            )
+        for index, list_item in enumerate(value):
+            if not isinstance(list_item, dict):
+                error_prefix = self._error_prefix(instance)
+                raise TypeError(
+                    f"{error_prefix} I was expecting a list of dictionaries, but item # {index + 1} has type '{list_item.__class__.__name__}."
+                )
+            for key, val in list_item.items():
+                if not isinstance(key, str):
+                    error_prefix = self._error_prefix(instance)
+                    raise TypeError(
+                        f"{error_prefix} attempt to set a dictionary with a non-string key for item #{index + 1}."
+                    )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> list[dict[str, Any]]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/list_any_dict_or_callable.py

@@ -0,0 +1,31 @@
+from typing import Any, Callable
+
+from clearskies.configs import config
+
+
+class ListAnyDictOrCallable(config.Config):
+    def __set__(self, instance, value: list[dict[str, Any]] | Callable[..., list[dict[str, Any]]]):
+        if not isinstance(value, list) 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 requries a list or a callable."
+            )
+        if isinstance(value, list):
+            for index, list_item in enumerate(value):
+                if not isinstance(list_item, dict):
+                    error_prefix = self._error_prefix(instance)
+                    raise TypeError(
+                        f"{error_prefix} I was expecting a list of dictionaries, but item # {index + 1} has type '{list_item.__class__.__name__}."
+                    )
+                for key, val in list_item.items():
+                    if not isinstance(key, str):
+                        error_prefix = self._error_prefix(instance)
+                        raise TypeError(
+                            f"{error_prefix} attempt to set a dictionary with a non-string key for item #{index + 1}."
+                        )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> list[dict[str, Any]] | Callable[..., list[dict[str, Any]]]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/model_class.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import inspect
+from typing import TYPE_CHECKING
+
+from clearskies.configs import config
+from clearskies.functional import validations
+
+if TYPE_CHECKING:
+    from clearskies.model import Model, ModelClassReference
+
+
+class ModelClass(config.Config):
+    """A config that accepts a model class."""
+
+    def __set__(self, instance, value: type[Model | ModelClassReference]):
+        try:
+            validations.is_model_class_or_reference(value, raise_error_message=True, strict=False)
+        except TypeError as e:
+            error_prefix = self._error_prefix(instance)
+            raise TypeError(f"{error_prefix} {str(e)}")
+
+        # reference or model class?
+        instance._set_config(self, value)  # type: ignore
+
+    def __get__(self, instance, parent) -> type[Model]:
+        if not instance:
+            return self  # type: ignore
+
+        value = instance._get_config(self)
+        if validations.is_model_class_reference(value):
+            class_reference = value() if inspect.isclass(value) else value
+            instance._set_config(self, class_reference.get_model_class())
+
+        return instance._get_config(self)

clearskies/configs/model_column.py

@@ -0,0 +1,65 @@
+from clearskies.configs import select
+
+
+class ModelColumn(select.Select):
+    def __init__(self, model_column_config_name="", required=False, default=None):
+        self.required = required
+        self.default = default
+        self.model_column_config_name = model_column_config_name
+        self.model_class = None
+
+    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 string parameter"
+            )
+
+        instance._set_config(self, value)
+        # unlike select, we won't validate the value currently because we won't be able to
+        # do that until the finalize_and_validate_configuration phase
+
+    def get_allowed_columns(self, model_class, column_configs):
+        return [name for name in column_configs.keys()]
+
+    def my_description(self):
+        return "column"
+
+    def get_model_class(self, instance):
+        model_class = self.model_class
+        if not model_class and self.model_column_config_name:
+            model_class = getattr(instance, self.model_column_config_name)
+        return model_class
+
+    def set_model_class(self, model_class):
+        self.model_class = model_class
+
+    def finalize_and_validate_configuration(self, instance):
+        super().finalize_and_validate_configuration(instance)
+
+        # to check for a valid column we need to know the name of the model class.
+        # This can be either provided to us directly or we may be given the name of a configuration
+        # from which we fetch the model class
+        model_class = self.get_model_class(instance)
+
+        # if we don't have one though, no worries - some classes have to provide it later and
+        # can trigger validation then.
+        if not model_class:
+            return
+
+        allowed_columns = self.get_allowed_columns(model_class, model_class.get_columns())
+
+        value = instance._get_config(self)
+        if not value:
+            return
+        if value not in allowed_columns:
+            error_prefix = self._error_prefix(instance)
+            my_description = self.my_description()
+            raise ValueError(
+                f"{error_prefix} attempt to set a value of '{value}' but this is not a {my_description} in the specified model class, '{model_class.__name__}'.  Expected values are: '"
+                + "', '".join(allowed_columns)
+                + "'"
+            )

clearskies/configs/model_columns.py

@@ -0,0 +1,56 @@
+from clearskies.configs import select_list
+
+
+class ModelColumns(select_list.SelectList):
+    def __init__(self, model_column_config_name="", allow_relationship_references=False, required=False, default=None):
+        self.required = required
+        self.default = default
+        self.model_column_config_name = model_column_config_name
+        self.allow_relationship_references = allow_relationship_references
+
+    def __set__(self, instance, value: list[str]):
+        if value is None:
+            return
+
+        if not isinstance(value, list):
+            error_prefix = self._error_prefix(instance)
+            raise TypeError(
+                f"{error_prefix} attempt to set a value of type '{value.__class__.__name__}' to a list parameter"
+            )
+
+        instance._set_config(self, value)
+        # unlike select_list, we won't validate the value currently because we won't be able to
+        # do that until the finalize_and_validate_configuration phase
+
+    def get_allowed_columns(self, model_class, column_configs):
+        return [name for name in column_configs.keys()]
+
+    def my_description(self):
+        return "column"
+
+    def finalize_and_validate_configuration(self, instance):
+        super().finalize_and_validate_configuration(instance)
+
+        # when we were created we were told the name of the config that stores
+        # the model class we're getting readable columns from.  Let's use that
+        # and fetch the model class.  Note that this is an optional feature though
+        if not self.model_column_config_name:
+            return
+
+        model_class = getattr(instance, self.model_column_config_name)
+        values = instance._get_config(self)
+        if not values or not model_class:
+            return
+
+        allowed_columns = self.get_allowed_columns(model_class, model_class.get_columns())
+        for value in values:
+            if self.allow_relationship_references and "." in value:
+                value = value.split(".")[0]
+            if value not in allowed_columns:
+                error_prefix = self._error_prefix(instance)
+                my_description = self.my_description()
+                raise ValueError(
+                    f"{error_prefix} attempt to set a value of '{value}' but this is not a {my_description} in the specified model class, '{model_class.__name__}.  Expected values are: '"
+                    + "', '".join(allowed_columns)
+                    + "'"
+                )

clearskies/configs/model_destination_name.py

@@ -0,0 +1,25 @@
+from clearskies.configs.string import String
+from clearskies.functional import string
+
+
+class ModelDestinationName(String):
+    def __init__(self, model_column_config_name, required=False, default=None):
+        self.required = required
+        self.default = default
+        self.model_column_config_name = model_column_config_name
+
+    def get_model_class(self, instance):
+        if self.model_column_config_name:
+            return getattr(instance, self.model_column_config_name)
+        return None
+
+    def finalize_and_validate_configuration(self, instance):
+        # we use the model class itself to decide on our value.  However,
+        # if we don't have it yet, don't worry.  Someone will eventually tell us
+        # what we need to know
+        model_class = self.get_model_class(instance)
+        if not model_class:
+            return
+
+        instance._set_config(self, model_class.destination_name())
+        super().finalize_and_validate_configuration(instance)

clearskies/configs/model_to_id_column.py

@@ -0,0 +1,43 @@
+from clearskies.configs import model_column
+from clearskies.functional import string
+
+
+class ModelToIdColumn(model_column.ModelColumn):
+    def __init__(
+        self,
+        model_column_config_name="",
+        source_model_class=None,
+        source_model_class_config_name="",
+        required=False,
+        default=None,
+    ):
+        self.required = required
+        self.default = default
+        self.model_column_config_name = model_column_config_name
+        self.source_model_class_config_name = source_model_class_config_name
+        self.model_class = None
+        self.source_model_class = source_model_class
+
+    def finalize_and_validate_configuration(self, instance):
+        # we use the model class itself to decide on our value.  However,
+        # if we don't have it yet, don't worry.  Someone will eventually tell us
+        # what we need to know
+        model_class = self.get_model_class(instance)
+        if not model_class:
+            return
+        if self.source_model_class:
+            model_class = self.source_model_class
+        elif self.source_model_class_config_name:
+            model_class = getattr(instance, self.source_model_class_config_name)
+
+        has_config = False
+        try:
+            if instance._get_config(self):
+                has_config = True
+        except KeyError:
+            pass
+
+        if not has_config:
+            instance._set_config(self, string.camel_case_to_snake_case(model_class.__name__) + "_id")
+
+        super().finalize_and_validate_configuration(instance)

clearskies/configs/readable_model_column.py

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

clearskies/configs/readable_model_columns.py

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

clearskies/configs/schema.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from clearskies.configs import config
+
+if TYPE_CHECKING:
+    from clearskies.schema import Schema as SchemaType
+
+
+class Schema(config.Config):
+    def __set__(self, instance, value: type[SchemaType]) -> None:
+        if not hasattr(value, "get_columns"):
+            error_prefix = self._error_prefix(instance)
+            raise TypeError(
+                f"{error_prefix} attempt to set a value of type '{value.__class__.__name__}' to parameter that requires a Schema."
+            )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> type[SchemaType]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/searchable_model_columns.py

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

clearskies/configs/security_headers.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from clearskies.configs import config
+
+if TYPE_CHECKING:
+    from clearskies import SecurityHeader
+
+
+class SecurityHeaders(config.Config):
+    """
+    This is for a configuration that should be a list of strings.
+
+    This is different than SelectList, which also accepts a list of strings, but
+    valdiates that all of those values match against an allow list.
+    """
+
+    def __set__(self, instance, value: list[SecurityHeader]):
+        if value is None:
+            return
+
+        if not isinstance(value, list):
+            error_prefix = self._error_prefix(instance)
+            raise TypeError(
+                f"{error_prefix} attempt to set a value of type '{value.__class__.__name__}' to a list parameter"
+            )
+        for index, item in enumerate(value):
+            if not hasattr(item, "set_headers_for_input_output"):
+                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}.  A clearskies.SecurityHeader was expected."
+                )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> list[SecurityHeader]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/select.py

@@ -0,0 +1,26 @@
+from clearskies.configs import string
+
+
+class Select(string.String):
+    def __init__(self, allowed_values: list[str], required=False, default=None):
+        self.allowed_values = allowed_values
+        self.required = required
+        self.default = default
+
+    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 string parameter"
+            )
+        if value not in self.allowed_values:
+            error_prefix = self._error_prefix(instance)
+            raise ValueError(
+                f"{error_prefix} attempt to set a value of type '{value}' which is not in the list of allowed values.  It must be one of '"  # type: ignore
+                + "', '".join(self.allowed_values)
+                + "'"
+            )
+        instance._set_config(self, value)

clearskies/configs/select_list.py

@@ -0,0 +1,47 @@
+from clearskies.configs import config
+
+
+class SelectList(config.Config):
+    """
+    This is for a configuration that should be a list of strings matching some list of allowed values.
+
+    The allowed values are set when you create the config, and when values are set for the config
+    they must match.
+
+    This is different than StringList, which also accepts a list of any strings.
+    """
+
+    def __init__(self, allowed_values: list[str], required=False, default=None):
+        self.allowed_values = allowed_values
+        self.required = required
+        self.default = default
+
+    def __set__(self, instance, value: list[str]):
+        if value is None:
+            return
+
+        if not isinstance(value, list):
+            error_prefix = self._error_prefix(instance)
+            raise TypeError(
+                f"{error_prefix} attempt to set a value of type '{value.__class__.__name__}' to a list parameter"
+            )
+        for index, item in enumerate(value):
+            if not isinstance(item, str):
+                error_prefix = self._error_prefix(instance)
+                raise TypeError(
+                    f"{error_prefix} attempt to set a value of type '{value.__class__.__name__}' for item #{index + 1}.  A string was expected."
+                )
+
+            if item not in self.allowed_values:
+                error_prefix = self._error_prefix(instance)
+                raise ValueError(
+                    f"{error_prefix} attempt to set a value of '{item}' for item #{index + 1}.  This is not in the list of allowed values.  It must be one of '"
+                    + "', '".join(self.allowed_values)
+                    + "'"
+                )
+        instance._set_config(self, [*value])
+
+    def __get__(self, instance, parent) -> list[str]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)