statikk 0.0.9__tar.gz → 0.0.12__tar.gz

{statikk-0.0.9 → statikk-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: statikk
-Version: 0.0.9
+Version: 0.0.12
 Summary: statikk is a single table application (STA) library for DynamoDb.
 Home-page: https://github.com/terinia/statikk
 Author: Balint Biro
@@ -14,13 +14,14 @@ Requires-Python: >=3.8
 Description-Content-Type: text/x-rst; charset=UTF-8
 License-File: LICENSE.txt
 Requires-Dist: importlib-metadata; python_version < "3.8"
-Requires-Dist: pydantic==2.3.0
+Requires-Dist: pydantic==2.7.4
 Requires-Dist: boto3==1.28.43
+Requires-Dist: aws-xray-sdk==2.14.0
 Provides-Extra: testing
 Requires-Dist: setuptools; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
-Requires-Dist: moto[dynamodb]; extra == "testing"
+Requires-Dist: moto[dynamodb]==4.2.14; extra == "testing"
 
 .. image:: ./assets/logo.png
     :alt: Statikk

{statikk-0.0.9 → statikk-0.0.12}/setup.cfg

@@ -24,8 +24,9 @@ package_dir =
 python_requires = >=3.8
 install_requires = 
 	importlib-metadata; python_version<"3.8"
-	pydantic==2.3.0
+	pydantic==2.7.4
 	boto3==1.28.43
+	aws-xray-sdk==2.14.0
 
 [options.packages.find]
 where = src
@@ -37,7 +38,7 @@ testing =
 	setuptools
 	pytest
 	pytest-cov
-	moto[dynamodb]
+	moto[dynamodb]==4.2.14
 
 [options.entry_points]
 

{statikk-0.0.9 → statikk-0.0.12}/src/statikk/engine.py

@@ -6,7 +6,7 @@ import boto3
 from botocore.config import Config
 from pydantic.fields import FieldInfo
 from boto3.dynamodb.conditions import ComparisonCondition, Key
-from boto3.dynamodb.types import TypeDeserializer
+from boto3.dynamodb.types import TypeDeserializer, Decimal
 
 from statikk.conditions import Condition, Equals, BeginsWith
 from statikk.expressions import UpdateExpressionBuilder
@@ -19,6 +19,10 @@ from statikk.models import (
     KeySchema,
 )
 
+from aws_xray_sdk.core import xray_recorder
+from aws_xray_sdk.core import patch_all
+
+patch_all()
 
 class InvalidIndexNameError(Exception):
     pass
@@ -54,19 +58,30 @@ class Table:
                 model.set_table_ref(self)
                 if "type" not in model.model_fields:
                     model.model_fields["type"] = FieldInfo(annotation=str, default=model.model_type(), required=False)
+        self._client = None
+        self._dynamodb_table = None
 
     def _dynamodb_client(self):
-        return boto3.client(
+        if self._client:
+            return self._client
+
+        self._client = boto3.client(
             "dynamodb",
             config=Config(region_name=os.environ.get("AWS_DEFAULT_REGION", "eu-west-1")),
         )
 
+        return self._client
+
     def _get_dynamodb_table(self):
+        if self._dynamodb_table:
+            return self._dynamodb_table
+
         dynamodb = boto3.resource(
             "dynamodb",
             config=Config(region_name=os.environ.get("AWS_DEFAULT_REGION", "eu-west-1")),
         )
-        return dynamodb.Table(self.name)
+        self._dynamodb_table = dynamodb.Table(self.name)
+        return self._dynamodb_table
 
     def _to_dynamodb_type(self, type: Any):
         if type is str:
@@ -149,15 +164,13 @@ class Table:
         """Deletes the DynamoDB table."""
         self._dynamodb_client().delete_table(TableName=self.name)
 
-    def delete_item(self, id: str):
-        """
-        Deletes an item from the database by id, using the partition key of the table.
-        :param id: The id of the item to delete.
-        """
-        key = {self.key_schema.hash_key: id}
-        self._get_dynamodb_table().delete_item(Key=key)
-
-    def get_item(self, id: str, model_class: Type[DatabaseModel], sort_key: Optional[Any] = None):
+    def get_item(
+        self,
+        id: str,
+        model_class: Type[DatabaseModel],
+        sort_key: Optional[Any] = None,
+        consistent_read: bool = False,
+    ):
         """
         Returns an item from the database by id, using the partition key of the table.
         :param id: The id of the item to retrieve.
@@ -167,15 +180,22 @@ class Table:
         key = {self.key_schema.hash_key: id}
         if sort_key:
             key[self.key_schema.sort_key] = self._serialize_value(sort_key)
-        raw_data = self._get_dynamodb_table().get_item(Key=key)
+        raw_data = self._get_dynamodb_table().get_item(Key=key, ConsistentRead=consistent_read)
         if "Item" not in raw_data:
             raise ItemNotFoundError(f"{model_class} with id '{id}' not found.")
         data = raw_data["Item"]
-        del data["type"]
         for key, value in data.items():
             data[key] = self._deserialize_value(value, model_class.model_fields[key])
         return model_class(**data)
 
+    def delete_item(self, id: str):
+        """
+        Deletes an item from the database by id, using the partition key of the table.
+        :param id: The id of the item to delete.
+        """
+        key = {self.key_schema.hash_key: id}
+        self._get_dynamodb_table().delete_item(Key=key)
+
     def put_item(self, model: DatabaseModel) -> DatabaseModel:
         """
         Puts an item into the database.
@@ -207,7 +227,6 @@ class Table:
         """
         data = self._serialize_item(model)
         self._get_dynamodb_table().put_item(Item=data)
-        del data["type"]
         for key, value in data.items():
             data[key] = self._deserialize_value(value, model.model_fields[key])
         return type(model)(**data)
@@ -231,6 +250,7 @@ class Table:
         def _find_changed_indexes():
             changed_index_values = set()
             for prefixed_attribute, value in expression_attribute_values.items():
+                expression_attribute_values[prefixed_attribute] = self._serialize_value(value)
                 attribute = prefixed_attribute.replace(":", "")
                 if model.model_fields[attribute].annotation is IndexSecondaryKeyField:
                     idx_field = getattr(model, attribute)
@@ -313,13 +333,14 @@ class Table:
 
         while last_evaluated_key:
             items = self._get_dynamodb_table().query(**query_params)
-            yield from [model_class(**item) for item in items["Items"]]
+            yield from [self._deserialize_item(item, model_class=model_class) for item in items["Items"]]
             last_evaluated_key = items.get("LastEvaluatedKey", False)
 
     def scan(
         self,
         model_class: Type[DatabaseModel],
         filter_condition: Optional[ComparisonCondition] = None,
+        consistent_read: bool = False,
     ):
         """
         Scans the database for items matching the provided filter condition. The method returns a list of items matching
@@ -328,7 +349,9 @@ class Table:
         :param model_class: The model class to use to deserialize the items.
         :param filter_condition: An optional filter condition to use for the query. See boto3.dynamodb.conditions.ComparisonCondition for more information.
         """
-        query_params = {}
+        query_params = {
+            "ConsistentRead": consistent_read,
+        }
         if filter_condition:
             query_params["FilterExpression"] = filter_condition
         last_evaluated_key = True
@@ -366,7 +389,7 @@ class Table:
                 else:
                     results.extend(
                         [
-                            model_class(**self._convert_dynamodb_to_python(item))
+                            self._deserialize_item(self._convert_dynamodb_to_python(item), model_class)
                             for item in response["Responses"][self.name]
                         ]
                     )
@@ -394,17 +417,29 @@ class Table:
         data = self._prepare_model_data(item, self.indexes)
         for key, value in data.items():
             data[key] = self._serialize_value(value)
-        data["type"] = item.model_type()
         return data
 
+    def _deserialize_item(self, item: Dict[str, Any], model_class: Type[DatabaseModel]):
+        for key, value in item.items():
+            item[key] = self._deserialize_value(value, model_class.model_fields[key])
+        return model_class(**item)
+
     def _deserialize_value(self, value: Any, annotation: Any):
-        if annotation is datetime or "datetime" in str(annotation):
+        if annotation is datetime or "datetime" in str(annotation) and value is not None:
             return datetime.fromtimestamp(int(value))
+        if annotation is float:
+            return float(value)
         return value
 
     def _serialize_value(self, value: Any):
         if isinstance(value, datetime):
             return int(value.timestamp())
+        if isinstance(value, float):
+            return Decimal(value)
+        if isinstance(value, list):
+            return [self._serialize_value(item) for item in value]
+        if isinstance(value, dict):
+            return {key: self._serialize_value(item) for key, item in value.items() if item is not None}
         return value
 
     def _set_index_fields(self, model: DatabaseModel | Type[DatabaseModel], idx: GSI):
@@ -422,6 +457,8 @@ class Table:
             if field_info.annotation is IndexSecondaryKeyField and idx.name in getattr(model, field_name).index_names
         ]
 
+        if len(sort_key_fields_unordered) == idx.sort_key is not None:
+            raise IncorrectSortKeyError(f"Model {model.__class__} does not have a sort key defined.")
         if sort_key_fields_unordered[0][1] is not None:
             sort_key_fields_unordered.sort(key=lambda x: x[1])
 

{statikk-0.0.9 → statikk-0.0.12}/src/statikk/models.py

@@ -111,15 +111,19 @@ class DatabaseModel(BaseModel):
         )
 
     @classmethod
-    def get(cls, id: str, sort_key: Optional[str] = None):
-        return cls._table.get_item(id=id, model_class=cls, sort_key=sort_key)
+    def get(cls, id: str, sort_key: Optional[str] = None, consistent_read: bool = False):
+        return cls._table.get_item(id=id, model_class=cls, sort_key=sort_key, consistent_read=consistent_read)
 
     @classmethod
     def batch_get(cls, ids: List[str], batch_size: int = 100):
         return cls._table.batch_get_items(ids=ids, model_class=cls, batch_size=batch_size)
 
     @classmethod
-    def scan(cls, filter_condition: Optional[ComparisonCondition] = None):
+    def scan(
+        cls,
+        filter_condition: Optional[ComparisonCondition] = None,
+        consistent_read: bool = False,
+    ):
         return cls._table.scan(model_class=cls, filter_condition=filter_condition)
 
     @staticmethod

{statikk-0.0.9 → statikk-0.0.12}/src/statikk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: statikk
-Version: 0.0.9
+Version: 0.0.12
 Summary: statikk is a single table application (STA) library for DynamoDb.
 Home-page: https://github.com/terinia/statikk
 Author: Balint Biro
@@ -14,13 +14,14 @@ Requires-Python: >=3.8
 Description-Content-Type: text/x-rst; charset=UTF-8
 License-File: LICENSE.txt
 Requires-Dist: importlib-metadata; python_version < "3.8"
-Requires-Dist: pydantic==2.3.0
+Requires-Dist: pydantic==2.7.4
 Requires-Dist: boto3==1.28.43
+Requires-Dist: aws-xray-sdk==2.14.0
 Provides-Extra: testing
 Requires-Dist: setuptools; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
-Requires-Dist: moto[dynamodb]; extra == "testing"
+Requires-Dist: moto[dynamodb]==4.2.14; extra == "testing"
 
 .. image:: ./assets/logo.png
     :alt: Statikk

{statikk-0.0.9 → statikk-0.0.12}/src/statikk.egg-info/requires.txt

@@ -1,5 +1,6 @@
-pydantic==2.3.0
+pydantic==2.7.4
 boto3==1.28.43
+aws-xray-sdk==2.14.0
 
 [:python_version < "3.8"]
 importlib-metadata
@@ -8,4 +9,4 @@ importlib-metadata
 setuptools
 pytest
 pytest-cov
-moto[dynamodb]
+moto[dynamodb]==4.2.14

{statikk-0.0.9 → statikk-0.0.12}/tests/test_engine.py

@@ -1,6 +1,7 @@
+from _decimal import Decimal
 from datetime import datetime, timezone
-from typing import List
-
+from typing import List, Optional
+from pydantic import BaseModel
 import pytest
 from boto3.dynamodb.conditions import Attr
 from moto import mock_dynamodb
@@ -28,7 +29,8 @@ class MyAwesomeModel(DatabaseModel):
     name: str = "Foo"
     values: set = {1, 2, 3, 4}
     cost: int = 4
-
+    probability: float = 0.5
+    created_at: Optional[datetime] = None
 
 class SimpleModel(DatabaseModel):
     player_id: IndexPrimaryKeyField
@@ -89,6 +91,8 @@ def test_create_my_awesome_model():
         "values": {1, 2, 3, 4},
         "cost": 4,
         "type": "MyAwesomeModel",
+        "probability": 0.5,
+        "created_at": None
     }
     model_2 = MyAwesomeModel(id="foo-2", player_id="123", tier="EPIC", name="FooFoo")
     table.put_item(model_2)
@@ -102,6 +106,8 @@ def test_create_my_awesome_model():
         "values": {1, 2, 3, 4},
         "cost": 4,
         "type": "MyAwesomeModel",
+        "probability": 0.5,
+        "created_at": None
     }
     mock_dynamodb().stop()
 
@@ -340,7 +346,7 @@ def test_batch_get_items():
         models=[MyAwesomeModel],
     )
     _create_dynamodb_table(table)
-    model = MyAwesomeModel(id="foo", player_id="123", tier="LEGENDARY")
+    model = MyAwesomeModel(id="foo", player_id="123", tier="LEGENDARY", created_at=datetime(2024, 7, 9))
     model_2 = MyAwesomeModel(id="foo-2", player_id="123", tier="LEGENDARY")
     table.put_item(model)
     table.put_item(model_2)
@@ -349,9 +355,11 @@ def test_batch_get_items():
     assert models[0].id == model.id
     assert models[0].model_type == model.model_type
     assert models[0].tier == model.tier
+    assert models[0].created_at == datetime(2024, 7, 9)
     assert models[1].id == model_2.id
     assert models[1].model_type == model_2.model_type
     assert models[1].tier == model_2.tier
+    assert models[1].created_at is None
     mock_dynamodb().stop()
 
 
@@ -744,3 +752,71 @@ def test_index_field_order_is_respected():
     model.save()
     item = table.get_item("123", ModelWithIndexOrdersDefined)
     assert item.gsi_sk == "ModelWithIndexOrdersDefined|EPIC|Mage"
+
+
+def test_nested_models():
+    class InnerInnerModel(BaseModel):
+        baz: str
+
+    class InnerModel(BaseModel):
+        foo: str
+        values: List[datetime] = [
+            datetime(2023, 9, 9, 12, 0, 0),
+            datetime(2023, 9, 9, 13, 0, 0),
+        ]
+        cost: int = 5
+        inner_inner: InnerInnerModel
+
+    class NestedModel(DatabaseModel):
+        player_id: IndexPrimaryKeyField
+        unit_class: IndexSecondaryKeyField = IndexSecondaryKeyField(order=2)
+        tier: IndexSecondaryKeyField = IndexSecondaryKeyField(order=1)
+        name: str = "Foo"
+        values: set = {1, 2, 3, 4}
+        cost: int = 4
+        inner_model: InnerModel
+
+    mock_dynamodb().start()
+    table = Table(
+        name="my-dynamodb-table",
+        key_schema=KeySchema(hash_key="id"),
+        indexes=[
+            GSI(
+                name="main-index",
+                hash_key=Key(name="gsi_pk"),
+                sort_key=Key(name="gsi_sk"),
+            )
+        ],
+        models=[NestedModel],
+    )
+    _create_dynamodb_table(table)
+    model = NestedModel(
+        id="123",
+        player_id="456",
+        unit_class="Mage",
+        tier="EPIC",
+        inner_model=InnerModel(foo="bar", inner_inner=InnerInnerModel(baz="baz")),
+    )
+    model.save()
+    item = table.get_item("123", NestedModel)
+    assert item.model_dump() == {
+        "id": "123",
+        "player_id": "456",
+        "unit_class": "Mage",
+        "tier": "EPIC",
+        "name": "Foo",
+        "values": {Decimal("1"), Decimal("2"), Decimal("3"), Decimal("4")},
+        "cost": 4,
+        "inner_model": {
+            "foo": "bar",
+            "values": [
+                datetime(2023, 9, 9, 10, 0, tzinfo=timezone.utc),
+                datetime(2023, 9, 9, 11, 0, tzinfo=timezone.utc),
+            ],
+            "cost": 5,
+            "inner_inner": {"baz": "baz"},
+        },
+        "gsi_pk": "456",
+        "gsi_sk": "NestedModel|EPIC|Mage",
+        "type": "NestedModel",
+    }