clear-skies 2.0.27__py3-none-any.whl

clearskies/configs/any_dict.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Any
+
+from clearskies.configs import config
+
+
+class AnyDict(config.Config):
+    def __set__(self, instance, value: dict[str, Any]):
+        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 parameter that requries a dictionary."
+            )
+        for key in value.keys():
+            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.")
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> dict[str, Any]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/any_dict_or_callable.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from clearskies.configs import config
+
+
+class AnyDictOrCallable(config.Config):
+    def __set__(self, instance, value: dict[str, Any] | Callable[..., dict[str, Any]]):
+        if not isinstance(value, dict) 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 dictionary or a callable."
+            )
+        if isinstance(value, dict):
+            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 dictionary with a non-string key.")
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> dict[str, Any] | Callable[..., dict[str, Any]]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/authentication.py

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

clearskies/configs/authorization.py

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

clearskies/configs/boolean.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from clearskies.configs import config
+
+
+class Boolean(config.Config):
+    def __set__(self, instance, value: bool):
+        if not isinstance(value, bool):
+            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 boolean."
+            )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> bool:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/boolean_or_callable.py

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

clearskies/configs/callable_config.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Callable as CallableType
+
+from clearskies.configs import config
+
+
+class Callable(config.Config):
+    def __set__(self, instance, value: CallableType):
+        if value is not None 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 Callable."
+            )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> CallableType | None:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/columns.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from clearskies.configs import config
+
+if TYPE_CHECKING:
+    from clearskies.column import Column
+
+
+class Columns(config.Config):
+    """This is for a configuration that should be a dictionary of columns with the key being the column name."""
+
+    def __set__(self, instance, value: dict[str, Column]):
+        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 dictionary with columns"
+            )
+        for index, item in enumerate(value.values()):
+            if not hasattr(item, "on_change_pre_save"):
+                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 column was expected."
+                )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> dict[str, Column]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/conditions.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 Conditions(config.Config):
+    def __set__(self, instance, value: typing.condition | list[typing.condition]):
+        if not isinstance(value, list):
+            value = [value]
+
+        for index, item in enumerate(value):
+            if callable(item) or isinstance(item, str) or hasattr(item, "_raw_condition"):
+                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, condition, callable is required"  # type: ignore
+            )
+
+        instance._set_config(self, [*value])
+
+    def __get__(self, instance, parent) -> list[typing.condition]:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/config.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class Config:
+    def __init__(self, required: bool = False, default: Any = None):
+        self.required = required
+        self.default = default
+
+    def _error_prefix(self, instance) -> str:
+        name = instance._descriptor_to_name(self)
+        class_name = instance.__class__.__name__
+        return f"Error with '{class_name}.{name}':"
+
+    def finalize_and_validate_configuration(self, instance):
+        if self.default:
+            try:
+                instance._get_config(self)
+            except KeyError:
+                instance._set_config(self.default)
+
+        if self.required and instance._get_config(self) is None:
+            name = instance._descriptor_to_name(self)
+            prefix = self._error_prefix(instance)
+            raise ValueError("{prefix} {name} is a required configuration setting, but no value was set")

clearskies/configs/datetime.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import datetime
+
+from clearskies.configs import config
+
+
+class Datetime(config.Config):
+    def __set__(self, instance, value: datetime.datetime):
+        if not isinstance(value, datetime.datetime):
+            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."
+            )
+        instance._set_config(self, value)
+
+    def __get__(self, instance, parent) -> datetime.datetime:
+        if not instance:
+            return self  # type: ignore
+        return instance._get_config(self)

clearskies/configs/datetime_or_callable.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+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/email.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from clearskies.configs import string
+
+
+class Email(string.String):
+    def __init__(
+        self, required=False, default=None, regexp: str = r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)"
+    ):
+        super().__init__(required=required, default=default, regexp=regexp)

clearskies/configs/email_list.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from clearskies.configs import string_list
+
+
+class EmailList(string_list.StringList):
+    """
+    This is for a configuration that should be a list of strings in email format.
+
+    This is different than StringList, which also accepts a list of strings, but
+    validates that all of those values match the required format.
+    """
+
+    def __init__(
+        self, required=False, default=None, regexp: str = r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)"
+    ):
+        super().__init__(required=required, default=default, regexp=regexp)

clearskies/configs/email_list_or_callable.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from clearskies.configs import string_list_or_callable
+
+
+class EmailListOrCallable(string_list_or_callable.StringListOrCallable):
+    """
+    This is for a configuration that should be a list of emails or a callable that returns a list of emails.
+
+    This is different than StringList, which also accepts a list of strings, but
+    validates that all of those values match the email format.
+    """
+
+    def __init__(
+        self, required=False, default=None, regexp: str = r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)"
+    ):
+        super().__init__(required=required, default=default, regexp=regexp)

clearskies/configs/email_or_email_list_or_callable.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import Callable
+
+from clearskies.configs import config
+
+
+class EmailOrEmailListOrCallable(config.Config):
+    """
+    This is for a configuration that should be an email or a list of emails or a callable that returns a list of emails.
+
+    This is a combination of Email and EmailListOrCallable.
+    """
+
+    def __init__(
+        self, required=False, default=None, regexp: str = r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)"
+    ):
+        self.required = required
+        self.default = default
+        self.regexp = regexp
+
+    def __set__(self, instance, value: str | list[str] | Callable[..., list[str]]):
+        if value is None:
+            return
+        if self.regexp:
+            import re
+        if isinstance(value, str):
+            if self.regexp and 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}'."
+                )
+            value = [value]
+        elif 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):
+            if self.regexp:
+                import re
+
+            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 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/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,18 @@
+from __future__ import annotations
+
+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,20 @@
+from __future__ import annotations
+
+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/headers.py

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

clearskies/configs/integer.py

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