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

clearskies/columns/has_many_self.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from clearskies import decorators
+from clearskies.columns.has_many import HasMany
+
+if TYPE_CHECKING:
+    from clearskies import typing
+
+
+class HasManySelf(HasMany):
+    """
+    This is just like the HasMany column, but is used when the model references itself.
+
+    This exists because a model can't refer to itself inside it's own class definition.  There are
+    workarounds, but having this class is usually quicker for the developer.
+
+    The main difference between this and HasMany is that you don't have to provide the child class.
+    Also, the name of the column that contains the id of the parent becomes `parent_id` by default,
+    rather than basing it on the name of the model.  This is done because, since the model is also
+    the child, using the name of the model in the name of the column id is often ambiguous.
+
+    See also BelongsToSelf.
+    """
+
+    _descriptor_config_map = None
+
+    @decorators.parameters_to_properties
+    def __init__(
+        self,
+        foreign_column_name: str | None = None,
+        readable_child_columns: list[str] = [],
+        where: typing.condition | list[typing.condition] = [],
+        is_readable: bool = True,
+        on_change_pre_save: typing.action | list[typing.action] = [],
+        on_change_post_save: typing.action | list[typing.action] = [],
+        on_change_save_finished: typing.action | list[typing.action] = [],
+    ):
+        pass
+
+    def finalize_configuration(self, model_class, name) -> None:
+        """
+        Finalize and check the configuration.
+
+        This is an external trigger called by the model class when the model class is ready.
+        The reason it exists here instead of in the constructor is because some columns are tightly
+        connected to the model class, and can't validate configuration until they know what the model is.
+        Therefore, we need the model involved, and the only way for a property to know what class it is
+        in is if the parent class checks in (which is what happens here).
+        """
+        self.child_model_class = model_class
+        has_value = False
+        try:
+            has_value = bool(self.foreign_column_name)
+        except KeyError:
+            pass
+
+        if not has_value:
+            self.foreign_column_name = "parent_id"
+
+        super().finalize_configuration(model_class, name)

clearskies/columns/has_one.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from clearskies.columns.has_many import HasMany
+
+
+class HasOne(HasMany):
+    """
+    This operates exactly like the HasMany relationship, except it assumes there is only ever one child.
+
+    The only real difference between this and HasMany is that the HasMany column type will return a list
+    of models, while this returns the first model.
+    """
+
+    _descriptor_config_map = None
+
+    def __get__(self, model, cls):
+        if model is None:
+            self.model_class = cls
+            return self  # type:  ignore
+
+        return super().__get__(model, cls).first()

clearskies/columns/integer.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable, Self, overload
+
+from clearskies import configs, decorators
+from clearskies.autodoc.schema import Integer as AutoDocInteger
+from clearskies.column import Column
+
+if TYPE_CHECKING:
+    from clearskies import Model, typing
+    from clearskies.autodoc.schema import Schema as AutoDocSchema
+    from clearskies.query import Condition
+
+
+class Integer(Column):
+    """
+    A column that stores integer data.
+
+    ```python
+    import clearskies
+
+
+    class MyModel(clearskies.Model):
+        backend = clearskies.backends.MemoryBackend()
+        id_column_name = "id"
+
+        id = clearskies.columns.Uuid()
+        age = clearskies.columns.Integer()
+
+
+    wsgi = clearskies.contexts.WsgiRef(
+        clearskies.endpoints.Create(
+            MyModel,
+            writeable_column_names=["age"],
+            readable_column_names=["id", "age"],
+        ),
+        classes=[MyModel],
+    )
+    wsgi()
+    ```
+
+    And when invoked:
+
+    ```bash
+    $ curl 'http://localhost:8080' -d '{"age":20}' | jq
+    {
+        "status": "success",
+        "error": "",
+        "data": {
+            "id": "6ea74719-a65f-45ae-b6a3-641ce682ed25",
+            "age": 20
+        },
+        "pagination": {},
+        "input_errors": {}
+    }
+
+    $ curl 'http://localhost:8080' -d '{"age":"asdf"}' | jq
+    {
+        "status": "input_errors",
+        "error": "",
+        "data": [],
+        "pagination": {},
+        "input_errors": {
+            "age": "value should be an integer"
+        }
+    }
+    ```
+    """
+
+    default = configs.Integer(default=None)  #  type: ignore
+    setable = configs.IntegerOrCallable(default=None)  #  type: ignore
+    _allowed_search_operators = ["<=>", "!=", "<=", ">=", ">", "<", "=", "in", "is not null", "is null"]
+
+    auto_doc_class: type[AutoDocSchema] = AutoDocInteger
+
+    _descriptor_config_map = None
+
+    @decorators.parameters_to_properties
+    def __init__(
+        self,
+        default: int | None = None,
+        setable: int | Callable[..., int] | None = None,
+        is_readable: bool = True,
+        is_writeable: bool = True,
+        is_searchable: bool = True,
+        is_temporary: bool = False,
+        validators: typing.validator | list[typing.validator] = [],
+        on_change_pre_save: typing.action | list[typing.action] = [],
+        on_change_post_save: typing.action | list[typing.action] = [],
+        on_change_save_finished: typing.action | list[typing.action] = [],
+        created_by_source_type: str = "",
+        created_by_source_key: str = "",
+        created_by_source_strict: bool = True,
+    ):
+        pass
+
+    @overload
+    def __get__(self, instance: None, cls: type[Model]) -> Self:
+        pass
+
+    @overload
+    def __get__(self, instance: Model, cls: type[Model]) -> int:
+        pass
+
+    def __get__(self, instance, cls):
+        if instance is None:
+            self.model_class = cls
+            return self
+
+        value = super().__get__(instance, cls)
+        return None if value is None else int(value)
+
+    def __set__(self, instance, value: int) -> None:
+        # this makes sure we're initialized
+        if "name" not in self._config:  # type: ignore
+            instance.get_columns()
+
+        instance._next_data[self.name] = value
+
+    def from_backend(self, value) -> int | None:
+        return None if value is None else int(value)
+
+    def to_backend(self, data):
+        if self.name not in data or data[self.name] is None:
+            return data
+
+        return {**data, self.name: int(data[self.name])}
+
+    def input_error_for_value(self, value, operator=None):
+        try:
+            int(value)
+        except ValueError:
+            return "value should be an integer"
+        return ""
+
+    def equals(self, value: int) -> Condition:
+        return super().equals(value)
+
+    def spaceship(self, value: int) -> Condition:
+        return super().spaceship(value)
+
+    def not_equals(self, value: int) -> Condition:
+        return super().not_equals(value)
+
+    def less_than_equals(self, value: int) -> Condition:
+        return super().less_than_equals(value)
+
+    def greater_than_equals(self, value: int) -> Condition:
+        return super().greater_than_equals(value)
+
+    def less_than(self, value: int) -> Condition:
+        return super().less_than(value)
+
+    def greater_than(self, value: int) -> Condition:
+        return super().greater_than(value)
+
+    def is_in(self, values: list[int]) -> Condition:
+        return super().is_in(values)

clearskies/columns/json.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, Callable, Self, overload
+
+from clearskies import configs, decorators
+from clearskies.column import Column
+
+if TYPE_CHECKING:
+    from clearskies import Model, typing
+
+
+class Json(Column):
+    """
+    A column to store generic data.
+
+    ```python
+    import clearskies
+
+
+    class MyModel(clearskies.Model):
+        backend = clearskies.backends.MemoryBackend()
+        id_column_name = "id"
+
+        id = clearskies.columns.Uuid()
+        my_data = clearskies.columns.Json()
+
+
+    wsgi = clearskies.contexts.WsgiRef(
+        clearskies.endpoints.Create(
+            MyModel,
+            writeable_column_names=["my_data"],
+            readable_column_names=["id", "my_data"],
+        ),
+        classes=[MyModel],
+    )
+    wsgi()
+    ```
+
+    And when invoked:
+
+    ```bash
+    $ curl 'http://localhost:8080' -d '{"my_data":{"count":[1,2,3,4,{"thing":true}]}}' | jq
+    {
+        "status": "success",
+        "error": "",
+        "data": {
+            "id": "63cbd5e7-a198-4424-bd35-3890075a2a5e",
+            "my_data": {
+                "count": [
+                    1,
+                    2,
+                    3,
+                    4,
+                    {
+                        "thing": true
+                    }
+                ]
+            }
+        },
+        "pagination": {},
+        "input_errors": {}
+    }
+    ```
+
+    Note that there is no attempt to check the shape of the input passed into a JSON column.
+
+    """
+
+    setable = configs.Any(default=None)  # type: ignore
+    default = configs.Any(default=None)  # type: ignore
+    is_searchable = configs.Boolean(default=False)
+    _descriptor_config_map = None
+
+    @decorators.parameters_to_properties
+    def __init__(
+        self,
+        default: dict[str, Any] | list[Any] | None = None,
+        setable: dict[str, Any] | list[Any] | Callable[..., dict[str, Any]] | None = None,
+        is_readable: bool = True,
+        is_writeable: bool = True,
+        is_temporary: bool = False,
+        validators: typing.validator | list[typing.validator] = [],
+        on_change_pre_save: typing.action | list[typing.action] = [],
+        on_change_post_save: typing.action | list[typing.action] = [],
+        on_change_save_finished: typing.action | list[typing.action] = [],
+        created_by_source_type: str = "",
+        created_by_source_key: str = "",
+        created_by_source_strict: bool = True,
+    ):
+        pass
+
+    @overload
+    def __get__(self, instance: None, cls: type[Model]) -> Self:
+        pass
+
+    @overload
+    def __get__(self, instance: Model, cls: type[Model]) -> dict[str, Any]:
+        pass
+
+    def __get__(self, instance, cls):
+        return super().__get__(instance, cls)
+
+    def __set__(self, instance, value: dict[str, Any]) -> None:
+        # this makes sure we're initialized
+        if "name" not in self._config:  # type: ignore
+            instance.get_columns()
+
+        instance._next_data[self.name] = value
+
+    def from_backend(self, value) -> dict[str, Any] | list[Any] | None:
+        if isinstance(value, (list, dict)):
+            return value
+        if not value:
+            return None
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError:
+            return None
+
+    def to_backend(self, data):
+        if self.name not in data or data[self.name] is None:
+            return data
+
+        value = data[self.name]
+        return {**data, self.name: value if isinstance(value, str) else json.dumps(value)}