alpha-python 0.1.0__py3-none-any.whl

alpha/infra/models/json_patch.py

@@ -0,0 +1,21 @@
+import datetime
+from contextlib import suppress
+
+import jsonpatch
+
+
+class JsonPatch(jsonpatch.JsonPatch):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.update_dates()
+
+    def update_dates(self) -> None:
+        """Post init to ensure that if a date can be formated to isoformat this
+        is done.
+        """
+        for update in self:
+            if isinstance(update['value'], str):
+                with suppress(ValueError):
+                    update['value'] = datetime.datetime.fromisoformat(
+                        update['value']
+                    )

alpha/infra/models/order_by.py

@@ -0,0 +1,69 @@
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import Any
+
+from sqlalchemy import BinaryExpression
+from sqlalchemy.orm import Query
+from sqlalchemy.orm.attributes import InstrumentedAttribute
+
+from alpha.infra.models.query_clause import QueryClause
+
+
+class Order(Enum):
+    ASC = auto()
+    DESC = auto()
+
+
+@dataclass
+class OrderBy(QueryClause):
+    field: str | InstrumentedAttribute[Any] = ""
+    order: Order = Order.ASC
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.__class__ = self._get_filter_class()
+
+    def _get_filter_class(self):
+        match self.order:
+            case Order.ASC:
+                return AscendingOrder
+            case Order.DESC:
+                return DescendingOrder
+
+
+class AscendingOrder(OrderBy):
+    @property
+    def filter_statement(self) -> BinaryExpression[Any]:
+        """Returns a lesser then filter statement
+
+        Returns
+        -------
+            Filter statement
+        """
+        if self._instrumented_attr:
+            return self._instrumented_attr.asc()
+        self._raise_instrumented_attr_exception()
+
+    def query_clause(self, query: Query[Any]):
+        if self._instrumented_attr:
+            return query.order_by(self._instrumented_attr.asc())
+        self._raise_instrumented_attr_exception()
+
+
+class DescendingOrder(OrderBy):
+    @property
+    def filter_statement(self) -> BinaryExpression[Any]:
+        """Returns a lesser then filter statement
+
+        Returns
+        -------
+            Filter statement
+        """
+        if self._instrumented_attr:
+            return self._instrumented_attr.desc()
+        self._raise_instrumented_attr_exception()
+
+    def query_clause(self, query: Query[Any]):
+        if self._instrumented_attr:
+            return query.order_by(self._instrumented_attr.desc())
+        self._raise_instrumented_attr_exception()

alpha/infra/models/query_clause.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+from typing import Any
+
+from sqlalchemy.orm.attributes import InstrumentedAttribute
+from sqlalchemy.orm.query import Query
+
+from alpha import exceptions
+from alpha.domain.models.base_model import BaseDomainModel
+
+
+@dataclass
+class QueryClause:
+    field: str | InstrumentedAttribute[str]
+    _domain_model: BaseDomainModel | None = None
+    _instrumented_attr: InstrumentedAttribute[Any] | None = None
+
+    def __post_init__(self) -> None:
+        # Get key name if field is an instrumented attribute
+        if isinstance(self.field, InstrumentedAttribute):
+            self._instrumented_attr = self.field
+            self.field = self.field.key
+
+        # Try to get the instrumented attribute if only a field name is given
+        self.set_domain_model()
+
+    def query_clause(self, query: Query[Any]) -> Query[Any]:
+        raise NotImplementedError
+
+    def set_domain_model(self, model: BaseDomainModel | None = None):
+        self._domain_model = model
+
+        if not self._instrumented_attr:
+            if self._domain_model:
+                self._instrumented_attr = getattr(
+                    self._domain_model, self.field  # type: ignore
+                )
+
+    def _raise_instrumented_attr_exception(self):
+        raise exceptions.InstrumentedAttributeMissing(
+            """
+            The 'field' attribute needs to be of an \
+sqlalchemy.orm.InstrumentedAttribute type, or specify the mapped domain model \
+by adding the _domain_model attribute
+            """
+        )