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

clearskies/configs/datetime_or_callable.py

@@ -1,19 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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):
-            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

@@ -1,16 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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)