clear-skies 1.19.22__py3-none-any.whl → 2.0.23__py3-none-any.whl

clearskies/configs/list_any_dict_or_callable.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+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,67 @@
+from __future__ import annotations
+
+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,58 @@
+from __future__ import annotations
+
+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,26 @@
+from __future__ import annotations
+
+from clearskies.configs.string 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,45 @@
+from __future__ import annotations
+
+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,11 @@
+from __future__ import annotations
+
+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,11 @@
+from __future__ import annotations
+
+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,11 @@
+from __future__ import annotations
+
+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,28 @@
+from __future__ import annotations
+
+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,49 @@
+from __future__ import annotations
+
+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)

clearskies/configs/string.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import re
+
+from clearskies.configs import config
+
+
+class String(config.Config):
+    def __init__(self, required=False, default=None, regexp: str = ""):
+        self.required = required
+        self.default = default
+        self.regexp = regexp
+
+    def __set__(self, instance, value: str):
+        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 parameter that requires a string."
+            )
+        if self.regexp:
+            if not re.match(self.regexp, value):
+                error_prefix = self._error_prefix(instance)
+                raise ValueError(
+                    f"{error_prefix} attempt to set a value of '{value}' but this does not match the required regexp: '{self.regexp}'."
+                )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> str:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/string_dict.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from clearskies.configs import config
+
+
+class StringDict(config.Config):
+    """This is for a configuration that should be a dictionary with keys and values that are all strings."""
+
+    def __set__(self, instance, value: dict[str, str]):
+        if value is None:
+            return
+
+        if not isinstance(value, dict):
+            error_prefix = self._error_prefix(instance)
+            raise TypeError(
+                f"{error_prefix} attempt to set a value of type '{value.__class__.__name__}' to a dict parameter"
+            )
+        for key, val in value.items():
+            if not isinstance(key, str):
+                error_prefix = self._error_prefix(instance)
+                raise TypeError(
+                    f"{error_prefix} attempt to set a key of type '{key.__class__.__name__}' when only string keys are allowed."
+                )
+            if not isinstance(val, str):
+                error_prefix = self._error_prefix(instance)
+                raise TypeError(
+                    f"{error_prefix} attempt to set a value of type '{val.__class__.__name__}' for key '{key}'.  A string was expected."
+                )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> dict[str, str]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/string_list.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import re
+
+from clearskies.configs import config
+
+
+class StringList(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 __init__(self, required=False, default=None, regexp: str = ""):
+        self.required = required
+        self.default = default
+        self.regexp = regexp
+
+    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 of strings 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 '{item.__class__.__name__}' for item #{index + 1}. A string was expected."
+                )
+            if self.regexp and not re.match(self.regexp, item):
+                error_prefix = self._error_prefix(instance)
+                raise ValueError(
+                    f"{error_prefix} attempt to set a value of '{item}' for item #{index + 1} but this does not match the required regexp: '{self.regexp}'."
+                )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> list[str]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/string_list_or_callable.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import re
+from typing import Callable
+
+from clearskies.configs import config
+
+
+class StringListOrCallable(config.Config):
+    """
+    This is for a configuration that should be a list of strings or a callable that returns 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 __init__(self, required=False, default=None, regexp: str = ""):
+        self.required = required
+        self.default = default
+        self.regexp = regexp
+
+    def __set__(self, instance, value: list[str] | Callable[..., list[str]]):
+        if value is None:
+            return
+
+        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 should be a list or a callable"
+            )
+        if isinstance(value, list):
+            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 '{item.__class__.__name__}' for item #{index + 1}.  A string was expected."
+                    )
+                if self.regexp and not re.match(self.regexp, item):
+                    error_prefix = self._error_prefix(instance)
+                    raise ValueError(
+                        f"{error_prefix} attempt to set a value of '{item}' for item #{index + 1} but this does not match the required regexp: '{self.regexp}'."
+                    )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> list[str] | Callable[..., list[str]]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

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,20 @@
+from __future__ import annotations
+
+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)