clear-skies 1.19.30__tar.gz → 1.20.0__tar.gz

{clear_skies-1.19.30 → clear_skies-1.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clear-skies
-Version: 1.19.30
+Version: 1.20.0
 Summary: A framework for building backends in the cloud
 Home-page: https://github.com/cmancone/clearskies
 License: MIT

{clear_skies-1.19.30 → clear_skies-1.20.0}/pyproject.toml

@@ -2,7 +2,7 @@
 
 [tool.poetry]
 name = "clear-skies"
-version = "1.19.30"
+version = "1.20.0"
 description = "A framework for building backends in the cloud"
 authors = [
     "Conor Mancone <cmancone@gmail.com>",

{clear_skies-1.19.30 → clear_skies-1.20.0}/src/clearskies/column_types/__init__.py

@@ -15,6 +15,7 @@ from .datetime_micro import DateTimeMicro
 from .email import Email
 from .float import Float
 from .has_many import HasMany
+from .has_one import HasOne
 from .integer import Integer
 from .json import JSON
 from .many_to_many import ManyToMany
@@ -22,6 +23,7 @@ from .many_to_many_with_data import ManyToManyWithData
 from .phone import Phone
 from .select import Select
 from .string import String
+from .timestamp import Timestamp
 from .updated import Updated
 from .updated_micro import UpdatedMicro
 from .uuid import UUID
@@ -95,6 +97,10 @@ def has_many(name, **kwargs):
     return build_column_config(name, HasMany, **kwargs)
 
 
+def has_one(name, **kwargs):
+    return build_column_config(name, HasOne, **kwargs)
+
+
 def integer(name, **kwargs):
     return build_column_config(name, Integer, **kwargs)
 
@@ -123,6 +129,10 @@ def string(name, **kwargs):
     return build_column_config(name, String, **kwargs)
 
 
+def timestamp(name, **kwargs):
+    return build_column_config(name, Timestamp, **kwargs)
+
+
 def updated(name, **kwargs):
     return build_column_config(name, Updated, **kwargs)
 
@@ -168,6 +178,8 @@ __all__ = [
     "Float",
     "has_many",
     "HasMany",
+    "has_one",
+    "HasOne",
     "integer",
     "Integer",
     "json",

clear_skies-1.20.0/src/clearskies/column_types/has_one.py

@@ -0,0 +1,58 @@
+from .has_many import HasMany
+import re
+from collections import OrderedDict
+from ..autodoc.schema import Array as AutoDocArray
+from ..autodoc.schema import Object as AutoDocObject
+from ..autodoc.schema import String as AutoDocString
+
+
+class HasOne(HasMany):
+    """
+    Controls a has-one relationship.
+
+    This is a readonly column.  When used in a model context it will return the related record.
+    When used in an API context, it will convert the child record into an object.
+
+    It assumes that the foreign id in the child table is `[parent_model_class_name]_id` in all lower case.
+    e.g., if the parent model class is named Status, then it assumes an id in the child class called `status_id`.
+    """
+
+    def can_provide(self, column_name):
+        return column_name == self.name
+
+    def provide(self, data, column_name):
+        foreign_column_name = self.config("foreign_column_name")
+        id_column_name = self.config("parent_id_column_name")
+        return self.child_models.find(f"{foreign_column_name}={data[id_column_name]}")
+
+    def to_json(self, model):
+        json = OrderedDict()
+        columns = self.get_child_columns()
+        child = model.__getattr__(self.name)
+        child_id_column_name = child.id_column_name
+        json = {
+            **json,
+            **columns[child_id_column_name].to_json(child),
+        }
+        for column_name in self.config("readable_child_columns"):
+            json = {
+                **json,
+                **columns[column_name].to_json(child),
+            }
+        return {self.name: json}
+
+    def documentation(self, name=None, example=None, value=None):
+        columns = self.get_child_columns()
+        child_id_column_name = self.child_models.get_id_column_name()
+        child_properties = [columns[child_id_column_name].documentation()]
+
+        for column_name in self.config("readable_child_columns"):
+            child_docs = columns[column_name].documentation()
+            if type(child_docs) != list:
+                child_docs = [child_docs]
+            child_properties.extend(child_docs)
+
+        return AutoDocObject(
+            self.camel_to_nice(self.child_models.model_class().__name__),
+            child_properties,
+        )

clear_skies-1.20.0/src/clearskies/column_types/timestamp.py

@@ -0,0 +1,72 @@
+from .datetime import DateTime
+from datetime import datetime, timezone
+import dateparser
+from ..autodoc.schema import DateTime as AutoDocDateTime
+
+
+class Timestamp(DateTime):
+    my_configs = [
+        "date_format",
+        "milliseconds",
+    ]
+
+    def _finalize_configuration(self, configuration):
+        return {
+            **{
+                "date_format": self._date_format,
+                "milliseconds": False,
+            },
+            **super()._finalize_configuration(configuration),
+        }
+
+    def from_backend(self, value):
+        mult = 1000 if self.config("milliseconds") 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.fromtimestamp(int(value) / mult)
+        elif isinstance(value, int):
+            date = datetime.fromtimestamp(value / mult)
+        else:
+            if not isinstance(value, 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, a string, nor a datetime object"
+                )
+            date = value
+        return date.replace(tzinfo=timezone.utc) if date else None
+
+    def to_backend(self, data):
+        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):
+            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"
+            )
+
+        # hopefully this is a Python datetime object in UTC timezone...
+        return {**data, **{self.name: value}}
+
+    def input_error_for_value(self, value, operator=None):
+        if not isinstance(value, int):
+            return f"'{self.name}' must be an integer"
+        return ""
+
+    def values_match(self, value_1, value_2):
+        """
+        Compares two values to see if they are the same
+        """
+        return value_1 == value_2