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

clearskies/columns/phone.py

@@ -1,159 +0,0 @@
-import re
-from typing import Any, Callable
-
-import clearskies.decorators
-import clearskies.typing
-from clearskies import configs
-from clearskies.columns.string import String
-
-
-class Phone(String):
-    """
-    A string column that stores a phone number.
-
-    The main difference between this and a plain string column is that this will validate that the string contains
-    a phone number (containing only digits, dashes, spaces, plus sign, and parenthesis) of the appropriate length.
-    When persisting the value to the backend, this column removes all non-digit characters.
-
-    If you also set the usa_only flag to true then it will also validate that it is a valid US number containing
-    9 digits and, optionally, a leading `1`.  Example:
-
-    ```python
-    import clearskies
-
-
-    class User(clearskies.Model):
-        id_column_name = "id"
-        backend = clearskies.backends.MemoryBackend()
-
-        id = clearskies.columns.Uuid()
-        name = clearskies.columns.String()
-        phone = clearskies.columns.Phone(usa_only=True)
-
-
-    wsgi = clearskies.contexts.WsgiRef(
-        clearskies.endpoints.Create(
-            User,
-            writeable_column_names=["name", "phone"],
-            readable_column_names=["id", "name", "phone"],
-        ),
-    )
-    wsgi()
-    ```
-
-    Which you can invoke:
-
-    ```bash
-    $ curl http://localhost:8080 -d '{"name":"John Doe", "phone": "+1 (555) 451-1234"}' | jq
-    {
-        "status": "success",
-        "error": "",
-        "data": {
-            "id": "e2b4bdad-b70f-4d44-a94c-0e265868b4d2",
-            "name": "John Doe",
-            "phone": "15554511234"
-        },
-        "pagination": {},
-        "input_errors": {}
-    }
-
-    $ curl http://localhost:8080 -d '{"name":"John Doe", "phone": "555 451-1234"}' | jq
-    {
-        "status": "success",
-        "error": "",
-        "data": {
-            "id": "aea34022-4b75-4eed-ac92-65fa4f4511ae",
-            "name": "John Doe",
-            "phone": "5554511234"
-        },
-        "pagination": {},
-        "input_errors": {}
-    }
-
-
-    $ curl http://localhost:8080 -d '{"name":"John Doe", "phone": "555 451-12341"}' | jq
-    {
-        "status": "input_errors",
-        "error": "",
-        "data": [],
-        "pagination": {},
-        "input_errors": {
-            "phone": "Invalid phone number"
-        }
-    }
-
-    $ curl http://localhost:8080 -d '{"name":"John Doe", "phone": "1-2-3-4 asdf"}' | jq
-    {
-        "status": "input_errors",
-        "error": "",
-        "data": [],
-        "pagination": {},
-        "input_errors": {
-            "phone": "Invalid phone number"
-        }
-    }
-    ```
-    """
-
-    """ Whether or not to allow non-USA numbers. """
-    usa_only = configs.Boolean(default=True)
-    _descriptor_config_map = None
-
-    @clearskies.decorators.parameters_to_properties
-    def __init__(
-        self,
-        usa_only: bool = True,
-        default: str | None = None,
-        setable: str | Callable[..., str] | None = None,
-        is_readable: bool = True,
-        is_writeable: bool = True,
-        is_searchable: bool = True,
-        is_temporary: bool = False,
-        validators: clearskies.typing.validator | list[clearskies.typing.validator] = [],
-        on_change_pre_save: clearskies.typing.action | list[clearskies.typing.action] = [],
-        on_change_post_save: clearskies.typing.action | list[clearskies.typing.action] = [],
-        on_change_save_finished: clearskies.typing.action | list[clearskies.typing.action] = [],
-        created_by_source_type: str = "",
-        created_by_source_key: str = "",
-        created_by_source_strict: bool = True,
-    ):
-        pass
-
-    def to_backend(self, data: dict[str, Any]) -> dict[str, Any]:
-        if not data.get(self.name):
-            return data
-
-        # phone numbers are stored as only digits.
-        return {**data, **{self.name: re.sub(r"\D", "", data[self.name])}}
-
-    def input_error_for_value(self, value: str, operator: str | None = None) -> str:
-        if type(value) != str:
-            return f"Value must be a string for {self.name}"
-
-        # we'll allow spaces, dashes, parenthesis, dashes, and plus signs.
-        # if there is anything else then it's not a valid phone number.
-        # However, we don't do more detailed validation, because I'm too lazy to
-        # figure out what is and is not a valid phone number, especially when
-        # you get to the world of international numbers.
-        if re.search(r"[^\d \-()+]", value):
-            return "Invalid phone number"
-
-        # for some final validation (especially US numbers) work only with the digits.
-        value = re.sub(r"\D", "", value)
-
-        if len(value) > 15:
-            return "Invalid phone number"
-
-        # we can't be too short unless we're doing a fuzzy search
-        if len(value) < 10 and operator and operator.lower() != "like":
-            return "Invalid phone number"
-
-        if self.usa_only:
-            if len(value) > 11:
-                return "Invalid phone number"
-            if value[0] == "1" and len(value) != 11:
-                return "Invalid phone number"
-            if value[0] != "1" and len(value) != 10:
-                return "Invalid phone number"
-
-        return ""

clearskies/columns/select.py

@@ -1,92 +0,0 @@
-from typing import Callable
-
-import clearskies.decorators
-import clearskies.typing
-from clearskies import configs
-from clearskies.columns.string import String
-
-
-class Select(String):
-    """
-    A string column but, when writeable via an endpoint, only specific values are allowed.
-
-    Note: the allowed values are case sensitive.
-
-    ```python
-    import clearskies
-
-
-    class Order(clearskies.Model):
-        id_column_name = "id"
-        backend = clearskies.backends.MemoryBackend()
-
-        id = clearskies.columns.Uuid()
-        total = clearskies.columns.Float()
-        status = clearskies.columns.Select(["Open", "Processing", "Shipped", "Complete"])
-
-
-    wsgi = clearskies.contexts.WsgiRef(
-        clearskies.endpoints.Create(
-            Order,
-            writeable_column_names=["total", "status"],
-            readable_column_names=["id", "total", "status"],
-        ),
-    )
-    wsgi()
-    ```
-
-    And when invoked:
-
-    ```bash
-    $ curl http://localhost:8080 -d '{"total": 125, "status": "Open"}' | jq
-    {
-        "status": "success",
-        "error": "",
-        "data": {
-            "id": "22f2c950-6519-4d8e-9084-013455449b07",
-            "total": 125.0,
-            "status": "Open"
-        },
-        "pagination": {},
-        "input_errors": {}
-    }
-
-    $ curl http://localhost:8080 -d '{"total": 125, "status": "huh"}' | jq
-    {
-        "status": "input_errors",
-        "error": "",
-        "data": [],
-        "pagination": {},
-        "input_errors": {
-            "status": "Invalid value for status"
-        }
-    }
-    ```
-    """
-
-    """ The allowed values. """
-    allowed_values = configs.StringList(required=True)
-    _descriptor_config_map = None
-
-    @clearskies.decorators.parameters_to_properties
-    def __init__(
-        self,
-        allowed_values: list[str],
-        default: str | None = None,
-        setable: str | Callable[..., str] | None = None,
-        is_readable: bool = True,
-        is_writeable: bool = True,
-        is_searchable: bool = True,
-        is_temporary: bool = False,
-        validators: clearskies.typing.validator | list[clearskies.typing.validator] = [],
-        on_change_pre_save: clearskies.typing.action | list[clearskies.typing.action] = [],
-        on_change_post_save: clearskies.typing.action | list[clearskies.typing.action] = [],
-        on_change_save_finished: clearskies.typing.action | list[clearskies.typing.action] = [],
-        created_by_source_type: str = "",
-        created_by_source_key: str = "",
-        created_by_source_strict: bool = True,
-    ):
-        pass
-
-    def input_error_for_value(self, value: str, operator: str | None = None) -> str:
-        return f"Invalid value for {self.name}" if value not in self.allowed_values else ""

clearskies/columns/string.py

@@ -1,102 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Self, overload
-
-from clearskies.column import Column
-
-if TYPE_CHECKING:
-    from clearskies import Model
-
-
-class String(Column):
-    """
-    A simple string column.
-
-    ```python
-    import clearskies
-
-
-    class Pet(clearskies.Model):
-        id_column_name = "id"
-        backend = clearskies.backends.MemoryBackend()
-
-        id = clearskies.columns.Uuid()
-        name = clearskies.columns.String()
-
-
-    wsgi = clearskies.contexts.WsgiRef(
-        clearskies.endpoints.Create(
-            Pet,
-            writeable_column_names=["name"],
-            readable_column_names=["id", "name"],
-        ),
-    )
-    wsgi()
-    ```
-
-    And when invoked:
-
-    ```bash
-    $ curl http://localhost:8080 -d '{"name": "Spot"}' | jq
-    {
-        "status": "success",
-        "error": "",
-        "data": {
-            "id": "e5b8417f-91bc-4fe5-9b64-04f571a7b10a",
-            "name": "Spot"
-        },
-        "pagination": {},
-        "input_errors": {}
-    }
-
-    $ curl http://localhost:8080 -d '{"name": 10}' | jq
-    {
-        "status": "input_errors",
-        "error": "",
-        "data": [],
-        "pagination": {},
-        "input_errors": {
-            "name": "value should be a string"
-        }
-    }
-
-    ```
-    """
-
-    _allowed_search_operators = ["<=>", "!=", "<=", ">=", ">", "<", "=", "in", "is not null", "is null", "like"]
-    _descriptor_config_map = None
-
-    @overload
-    def __get__(self, instance: None, cls: type[Model]) -> Self:
-        pass
-
-    @overload
-    def __get__(self, instance: Model, cls: type[Model]) -> str:
-        pass
-
-    def __get__(self, instance, cls):
-        if instance is None:
-            self.model_class = cls
-            return self
-
-        # this makes sure we're initialized
-        if "name" not in self._config:  # type: ignore
-            instance.get_columns()
-
-        if self.name not in instance._data:
-            return None  # type: ignore
-
-        if self.name not in instance._transformed_data:
-            instance._transformed_data[self.name] = self.from_backend(instance._data[self.name])
-
-        return instance._transformed_data[self.name]
-
-    def __set__(self, instance: Model, value: str) -> 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 input_error_for_value(self, value: str, operator: str | None = None) -> str:
-        return "value should be a string" if type(value) != str else ""

clearskies/columns/timestamp.py

@@ -1,164 +0,0 @@
-from __future__ import annotations
-
-import datetime
-from typing import TYPE_CHECKING, Any, Callable, Self, Type, overload
-
-import clearskies.decorators
-import clearskies.typing
-from clearskies import configs
-from clearskies.columns.datetime import Datetime
-
-if TYPE_CHECKING:
-    from clearskies import Model
-
-
-class Timestamp(Datetime):
-    """
-    A timestamp column.
-
-    The difference between this and the datetime column is that this stores the datetime
-    as a standard unix timestamp - the number of seconds since the unix epoch.
-
-    Also, this **always** assumes the timezone for the timestamp is UTC
-
-    ```python
-    import datetime
-    import clearskies
-
-
-    class Pet(clearskies.Model):
-        id_column_name = "id"
-        backend = clearskies.backends.MemoryBackend()
-
-        id = clearskies.columns.Uuid()
-        name = clearskies.columns.String()
-        last_fed = clearskies.columns.Timestamp()
-
-
-    def demo_timestamp(utcnow: datetime.datetime, pets: Pet) -> dict[str, str | int]:
-        pet = pets.create({
-            "name": "Spot",
-            "last_fed": utcnow,
-        })
-        return {
-            "last_fed": pet.last_fed.isoformat(),
-            "raw_data": pet.get_raw_data()["last_fed"],
-        }
-
-
-    cli = clearskies.contexts.Cli(
-        clearskies.endpoints.Callable(
-            demo_timestamp,
-        ),
-        classes=[Pet],
-    )
-    cli()
-    ```
-
-    And when invoked it returns:
-
-    ```json
-    {
-        "status": "success",
-        "error": "",
-        "data": {"last_fed": "2025-05-18T19:14:56+00:00", "raw_data": 1747595696},
-        "pagination": {},
-        "input_errors": {},
-    }
-    ```
-
-    Note that if you pull the column from the model in the usual way (e.g. `pet.last_fed` you get a timestamp,
-    but if you check the raw data straight out of the backend (e.g. `pet.get_raw_data()["last_fed"]`) it's an
-    integer.
-    """
-
-    # whether or not to include the microseconds in the timestamp
-    include_microseconds = configs.Boolean(default=False)
-    _descriptor_config_map = None
-
-    @clearskies.decorators.parameters_to_properties
-    def __init__(
-        self,
-        include_microseconds: bool = False,
-        default: datetime.datetime | None = None,
-        setable: datetime.datetime | Callable[..., datetime.datetime] | None = None,
-        is_readable: bool = True,
-        is_writeable: bool = True,
-        is_searchable: bool = True,
-        is_temporary: bool = False,
-        validators: clearskies.typing.validator | list[clearskies.typing.validator] = [],
-        on_change_pre_save: clearskies.typing.action | list[clearskies.typing.action] = [],
-        on_change_post_save: clearskies.typing.action | list[clearskies.typing.action] = [],
-        on_change_save_finished: clearskies.typing.action | list[clearskies.typing.action] = [],
-        created_by_source_type: str = "",
-        created_by_source_key: str = "",
-        created_by_source_strict: bool = True,
-    ):
-        pass
-
-    def from_backend(self, value) -> datetime.datetime | None:
-        mult = 1000 if self.include_microseconds else 1
-        if not value:
-            date = None
-        elif isinstance(value, str):
-            if not value.isdigit():
-                raise ValueError(
-                    f"Invalid data was found in the backend for model {self.model_class.__name__} and column {self.name}: a string value was found that is not a timestamp.  It was '{value}'"
-                )
-            date = datetime.datetime.fromtimestamp(int(value) / mult, datetime.timezone.utc)
-        elif isinstance(value, int) or isinstance(value, float):
-            date = datetime.datetime.fromtimestamp(value / mult, datetime.timezone.utc)
-        else:
-            if not isinstance(value, datetime.datetime):
-                raise ValueError(
-                    f"Invalid data was found in the backend for model {self.model_class.__name__} and column {self.name}: the value was neither an integer, float, string, or datetime object"
-                )
-            date = value
-        return date.replace(tzinfo=datetime.timezone.utc) if date else None
-
-    def to_backend(self, data: dict[str, Any]) -> dict[str, Any]:
-        if not self.name in data or isinstance(data[self.name], int) or data[self.name] == None:
-            return data
-
-        value = data[self.name]
-        if isinstance(value, str):
-            if not value.isdigit():
-                raise ValueError(
-                    f"Invalid data was sent to the backend for model {self.model_class.__name__} and column {self.name}: a string value was found that is not a timestamp. It was '{value}'"
-                )
-            value = int(value)
-        elif isinstance(value, datetime.datetime):
-            value = value.timestamp()
-        else:
-            raise ValueError(
-                f"Invalid data was sent to the backend for model {self.model_class.__name__} and column {self.name}: the value was neither an integer, a string, nor a datetime object"
-            )
-
-        return {**data, self.name: int(value)}
-
-    @overload
-    def __get__(self, instance: None, cls: type) -> Self:
-        pass
-
-    @overload
-    def __get__(self, instance: Model, cls: type) -> datetime.datetime:
-        pass
-
-    def __get__(self, instance, cls):
-        return super().__get__(instance, cls)
-
-    def __set__(self, instance, value: datetime.datetime) -> 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 input_error_for_value(self, value: str, operator: str | None = None) -> str:
-        if not isinstance(value, int):
-            return f"'{self.name}' must be an integer"
-        return ""
-
-    def values_match(self, value_1, value_2):
-        """Compare two values to see if they are the same."""
-        return value_1 == value_2

clearskies/columns/updated.py

@@ -1,110 +0,0 @@
-from __future__ import annotations
-
-import datetime
-from typing import TYPE_CHECKING, Any
-
-import clearskies.decorators
-import clearskies.di
-import clearskies.typing
-from clearskies import configs
-from clearskies.columns.datetime import Datetime
-
-if TYPE_CHECKING:
-    from clearskies import Model
-
-
-class Updated(Datetime):
-    """
-    The updated column records the time that a record is created or updated.
-
-    Note that this will always populate the column anytime the model is created or updated.
-    You don't have to provide the timestamp yourself and you should never expose it as
-    a writeable column through an endpoint (in fact, you can't).
-
-    ```python
-    import clearskies
-    import time
-
-
-    class MyModel(clearskies.Model):
-        backend = clearskies.backends.MemoryBackend()
-        id_column_name = "id"
-
-        id = clearskies.columns.Uuid()
-        name = clearskies.columns.String()
-        created = clearskies.columns.Created()
-        updated = clearskies.columns.Updated()
-
-
-    def test_updated(my_models: MyModel) -> MyModel:
-        my_model = my_models.create({"name": "Jane"})
-        updated_column_after_create = my_model.updated
-
-        time.sleep(2)
-
-        my_model.save({"name": "Susan"})
-
-        return {
-            "updated_column_after_create": updated_column_after_create.isoformat(),
-            "updated_column_at_end": my_model.updated.isoformat(),
-            "difference_in_seconds": (my_model.updated - updated_column_after_create).total_seconds(),
-        }
-
-
-    cli = clearskies.contexts.Cli(clearskies.endpoints.Callable(test_updated), classes=[MyModel])
-    cli()
-    ```
-
-    And when invoked:
-
-    ```bash
-    $ ./test.py | jq
-    {
-        "status": "success",
-        "error": "",
-        "data": {
-            "updated_column_after_create": "2025-05-18T19:28:46+00:00",
-            "updated_column_at_end": "2025-05-18T19:28:48+00:00",
-            "difference_in_seconds": 2.0
-        },
-        "pagination": {},
-        "input_errors": {}
-    }
-    ```
-
-    Note that the `updated` column was set both when the record was first created and when it was updated,
-    so there is a two second difference between them (since we slept for two seconds).
-
-    """
-
-    """
-    Created fields are never writeable because they always set the created time automatically.
-    """
-    is_writeable = configs.Boolean(default=False)
-    _descriptor_config_map = None
-
-    now = clearskies.di.inject.Now()
-
-    @clearskies.decorators.parameters_to_properties
-    def __init__(
-        self,
-        in_utc: bool = True,
-        date_format: str = "%Y-%m-%d %H:%M:%S",
-        backend_default: str = "0000-00-00 00:00:00",
-        is_readable: bool = True,
-        is_searchable: bool = True,
-        is_temporary: bool = False,
-        on_change_pre_save: clearskies.typing.action | list[clearskies.typing.action] = [],
-        on_change_post_save: clearskies.typing.action | list[clearskies.typing.action] = [],
-        on_change_save_finished: clearskies.typing.action | list[clearskies.typing.action] = [],
-    ):
-        pass
-
-    def pre_save(self, data: dict[str, Any], model: Model) -> dict[str, Any]:
-        now = self.now
-        if self.timezone_aware:
-            now = now.astimezone(self.timezone)
-        data = {**data, self.name: now}
-        if self.on_change_pre_save:
-            data = self.execute_actions_with_data(self.on_change_pre_save, model, data)
-        return data