statikk 0.1.14__tar.gz → 0.1.16__tar.gz

{statikk-0.1.14 → statikk-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statikk
-Version: 0.1.14
+Version: 0.1.16
 Summary: statikk is a single table application (STA) library for DynamoDb.
 Home-page: https://github.com/terinia/statikk
 Author: Balint Biro

{statikk-0.1.14 → statikk-0.1.16}/src/statikk/engine.py

@@ -16,7 +16,7 @@ from statikk.models import (
     GSI,
     KeySchema,
 )
-from statikk.fields import FIELD_STATIKK_TYPE, FIELD_STATIKK_PARENT_ID
+from statikk.fields import FIELD_STATIKK_TYPE, FIELD_STATIKK_PARENT_ID, FIELD_STATIKK_PARENT_FIELD_NAME
 from copy import deepcopy
 from aws_xray_sdk.core import patch_all
 
@@ -296,20 +296,23 @@ class Table:
         response = self._get_dynamodb_table().update_item(**request)
         data = response["Attributes"]
         for key, value in data.items():
-            if key in [FIELD_STATIKK_TYPE, FIELD_STATIKK_PARENT_ID]:
+            if key in [FIELD_STATIKK_TYPE, FIELD_STATIKK_PARENT_ID, FIELD_STATIKK_PARENT_FIELD_NAME]:
                 continue
             data[key] = self._deserialize_value(value, model.model_fields[key])
         return type(model)(**data)
 
-    def reparent_subtree(self, subtree_root: T, new_parent: T) -> T:
+    def reparent_subtree(self, subtree_root: T, new_parent: T, field_name: str) -> T:
         subtree_copy = deepcopy(subtree_root)
         subtree_root._parent_changed = True
 
         subtree_copy.set_parent_references(subtree_copy, force_override=True)
         subtree_copy._parent = new_parent
+        subtree_copy._parent_field_name = field_name
+        parent = subtree_copy._parent
         for node in subtree_copy.dfs_traverse_hierarchy():
             self.build_model_indexes(node)
-            setattr(node, FIELD_STATIKK_PARENT_ID, new_parent.id)
+            setattr(node, FIELD_STATIKK_PARENT_ID, parent.id)
+            parent = node
 
         return subtree_copy
 
@@ -427,7 +430,10 @@ class Table:
         model_class = self._get_model_type_by_statikk_type(model_type)
 
         reconstructed_dict.pop(FIELD_STATIKK_TYPE, None)
-        return model_class(**reconstructed_dict)
+        model = model_class.model_validate(reconstructed_dict)
+        for node in model.dfs_traverse_hierarchy():
+            node._is_persisted = True
+        return model
 
     def scan(
         self,
@@ -626,6 +632,7 @@ class Table:
                         continue
                     if not enriched_item.should_write_to_database():
                         continue
+                    enriched_item._is_persisted = True
                     data = self._serialize_item(enriched_item)
                     batch.put_item(Item=data)
 
@@ -640,9 +647,6 @@ class Table:
         Returns:
             The top-level dictionary with its hierarchy fully reconstructed, or None if the list is empty
         """
-        if not items:
-            return None
-
         items_by_id = {item["id"]: item for item in items}
         children_by_parent_id = {}
         for item in items:
@@ -652,128 +656,74 @@ class Table:
                     children_by_parent_id[parent_id] = []
                 children_by_parent_id[parent_id].append(item)
 
-        # Find the root item (the one with no parent ID)
-        root_items = [item for item in items if FIELD_STATIKK_PARENT_ID not in item]
+        root_item = [item for item in items if FIELD_STATIKK_PARENT_ID not in item][0]
 
-        if not root_items:
-            return None
-
-        if len(root_items) > 1:
-            root_item = root_items[0]
-        else:
-            root_item = root_items[0]
+        processed_root = self._process_item(root_item, items_by_id, children_by_parent_id)
+        return processed_root
 
-        processed_items = set()
-        return self._reconstruct_item_with_children(root_item, items_by_id, children_by_parent_id, processed_items)
-
-    def _reconstruct_item_with_children(
-        self, item: dict, items_by_id: dict, children_by_parent_id: dict, processed_items: set
-    ) -> dict:
+    def _process_item(self, item: dict, items_by_id: dict, children_by_parent_id: dict) -> dict:
         """
-        Recursively reconstruct an item and its children using model class definitions.
+        Recursively processes an item and all its children to rebuild the hierarchical structure.
 
         Args:
-            item: The item to reconstruct
-            items_by_id: Map of all item IDs to items
-            children_by_parent_id: Map of parent IDs to lists of child items
-            processed_items: Set of already processed item IDs to avoid duplicates
+            item: The current item to process
+            items_by_id: Dictionary mapping item IDs to items
+            children_by_parent_id: Dictionary mapping parent IDs to lists of child items
 
         Returns:
-            The reconstructed item with all child references integrated
+            The processed item with all its child relationships resolved
         """
-        if item["id"] in processed_items:
-            return item
-        processed_items.add(item["id"])
-        result = item.copy()
-
-        if FIELD_STATIKK_PARENT_ID in result:
-            result.pop(FIELD_STATIKK_PARENT_ID)
+        processed_item = deepcopy(item)
 
-        children = children_by_parent_id.get(item["id"], [])
-        if not children:
-            return result
+        if FIELD_STATIKK_TYPE in processed_item:
+            model_class = self._get_model_type_by_statikk_type(processed_item[FIELD_STATIKK_TYPE])
+            model_fields = model_class.model_fields
+        else:
+            return processed_item
 
-        parent_model_class = self._get_model_type_by_statikk_type(item[FIELD_STATIKK_TYPE])
+        # Get children of this item
+        children = children_by_parent_id.get(processed_item["id"], [])
 
-        children_by_type = {}
+        # Group children by parent field name
+        children_by_field = {}
         for child in children:
-            child_type = child[FIELD_STATIKK_TYPE]
-            if child_type not in children_by_type:
-                children_by_type[child_type] = []
-            children_by_type[child_type].append(child)
-
-        for child_type, child_items in children_by_type.items():
-            child_model_class = self._get_model_type_by_statikk_type(child_type)
-            matching_fields = []
-
-            for field_name, field_info in parent_model_class.model_fields.items():
-                if field_name.startswith("_"):
-                    continue
-
-                is_optional, inner_type = inspect_optional_field(parent_model_class, field_name)
-
-                field_type = inner_type if is_optional else field_info.annotation
-
-                if field_type == child_model_class:
-                    matching_fields.append((field_name, "single"))
-
-                elif hasattr(field_type, "__origin__") and field_type.__origin__ == list:
-                    args = getattr(field_type, "__args__", [])
-                    if args and args[0] == child_model_class:
-                        matching_fields.append((field_name, "list"))
-
-                elif hasattr(field_type, "__origin__") and field_type.__origin__ == set:
-                    args = getattr(field_type, "__args__", [])
-                    if args and args[0] == child_model_class:
-                        matching_fields.append((field_name, "set"))
-
-            if matching_fields:
-                for field_name, container_type in matching_fields:
-                    if container_type == "list":
-                        if field_name not in result:
-                            result[field_name] = []
-
-                        existing_ids = {
-                            item.get("id") for item in result[field_name] if isinstance(item, dict) and "id" in item
-                        }
-
-                        for child in child_items:
-                            if child["id"] in existing_ids:
-                                continue
+            field_name = child.get(FIELD_STATIKK_PARENT_FIELD_NAME)
+            if field_name:
+                if field_name not in children_by_field:
+                    children_by_field[field_name] = []
+                children_by_field[field_name].append(child)
+
+        for field_name, field_info in model_fields.items():
+            if field_name not in children_by_field:
+                continue
 
-                            reconstructed_child = self._reconstruct_item_with_children(
-                                child, items_by_id, children_by_parent_id, processed_items
-                            )
+            field_children = children_by_field[field_name]
 
-                            result[field_name].append(reconstructed_child)
-                            existing_ids.add(child["id"])
+            field_type = field_info.annotation
+            is_optional = False
+            inner_type = field_type
 
-                    elif container_type == "set":
-                        if field_name not in result:
-                            result[field_name] = []
+            if hasattr(field_type, "__origin__") and field_type.__origin__ is Union:
+                args = field_type.__args__
+                if type(None) in args:
+                    is_optional = True
+                    # Get the non-None type
+                    inner_type = next(arg for arg in args if arg is not type(None))
 
-                        existing_ids = {
-                            item.get("id") for item in result[field_name] if isinstance(item, dict) and "id" in item
-                        }
+            if hasattr(inner_type, "__origin__") and inner_type.__origin__ == list:
+                child_list = []
 
-                        for child in child_items:
-                            if child["id"] in existing_ids:
-                                continue
-                            reconstructed_child = self._reconstruct_item_with_children(
-                                child, items_by_id, children_by_parent_id, processed_items
-                            )
+                for child in field_children:
+                    processed_child = self._process_item(child, items_by_id, children_by_parent_id)
+                    child_list.append(processed_child)
 
-                            result[field_name].append(reconstructed_child)
-                            existing_ids.add(child["id"])
+                processed_item[field_name] = child_list
 
-                    elif container_type == "single":
-                        if child_items:
-                            reconstructed_child = self._reconstruct_item_with_children(
-                                child_items[0], items_by_id, children_by_parent_id, processed_items
-                            )
-                            result[field_name] = reconstructed_child
+            elif len(field_children) == 1:
+                processed_child = self._process_item(field_children[0], items_by_id, children_by_parent_id)
+                processed_item[field_name] = processed_child
 
-        return result
+        return processed_item
 
 
 class BatchWriteContext:

{statikk-0.1.14 → statikk-0.1.16}/src/statikk/fields.py

@@ -1,2 +1,3 @@
 FIELD_STATIKK_TYPE = "__statikk_type"
 FIELD_STATIKK_PARENT_ID = "__statikk_parent_id"
+FIELD_STATIKK_PARENT_FIELD_NAME = "__statikk_parent_field_name"

{statikk-0.1.14 → statikk-0.1.16}/src/statikk/models.py

@@ -14,7 +14,7 @@ from pydantic_core._pydantic_core import PydanticUndefined
 
 from statikk.conditions import Condition
 from statikk.expressions import DatabaseModelUpdateExpressionBuilder
-from statikk.fields import FIELD_STATIKK_TYPE, FIELD_STATIKK_PARENT_ID
+from statikk.fields import FIELD_STATIKK_TYPE, FIELD_STATIKK_PARENT_ID, FIELD_STATIKK_PARENT_FIELD_NAME
 
 if typing.TYPE_CHECKING:
     from statikk.engine import Table
@@ -196,14 +196,20 @@ class TrackingMixin:
         return {}
 
 
-class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
+class DatabaseModel(BaseModel, TrackingMixin):
     id: str = Field(default_factory=lambda: str(uuid4()))
     _parent: Optional[DatabaseModel] = None
+    _parent_field_name: Optional[str] = None
     _model_types_in_hierarchy: dict[str, Type[DatabaseModel]] = {}
     _should_delete: bool = False
     _parent_changed: bool = False
+    _is_persisted: bool = False
     _session = Session()
 
+    class Config:
+        extra = Extra.allow
+        arbitrary_types_allowed = True
+
     def __eq__(self, other):
         return self.id == other.id
 
@@ -255,12 +261,16 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
     def is_simple_object(self) -> bool:
         return len(self._model_types_in_hierarchy) == 1
 
+    @property
+    def is_persisted(self) -> bool:
+        return self._is_persisted
+
     @property
     def should_delete(self) -> bool:
         if self._is_any_parent_marked_for_deletion():
             return True
 
-        return self._should_delete or self.is_parent_changed()
+        return self.is_persisted and (self._should_delete or self.is_parent_changed())
 
     def _is_any_parent_marked_for_deletion(self) -> bool:
         current = self._parent
@@ -346,8 +356,8 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
     def mark_for_delete(self):
         self._should_delete = True
 
-    def change_parent_to(self, new_parent: DatabaseModel) -> T:
-        return self._table.reparent_subtree(self, new_parent)
+    def _change_parent_to(self, new_parent: DatabaseModel, field_name: str) -> T:
+        return self._table.reparent_subtree(self, new_parent, field_name)
 
     def _remove_from_parent(self, parent, field_name, subtree):
         is_optional, inner_type = inspect_optional_field(parent.__class__, field_name)
@@ -384,17 +394,17 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
         if hasattr(field_type, "__origin__") and field_type.__origin__ == list:
             if not isinstance(getattr(self, field_name), list):
                 setattr(self, field_name, [])
-            reparented = child_node.change_parent_to(self)
+            reparented = child_node._change_parent_to(self, field_name)
             getattr(self, field_name).append(reparented)
 
         elif hasattr(field_type, "__origin__") and field_type.__origin__ == set:
             if not isinstance(getattr(self, field_name), set):
                 setattr(self, field_name, set())
-            reparented = child_node.change_parent_to(self)
+            reparented = child_node._change_parent_to(self, field_name)
             getattr(self, field_name).add(reparented)
 
         elif issubclass(field_type, DatabaseModel):
-            reparented = child_node.change_parent_to(self)
+            reparented = child_node._change_parent_to(self, field_name)
             setattr(self, field_name, reparented)
 
         if reparented:
@@ -418,6 +428,7 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
         data[FIELD_STATIKK_TYPE] = self.type()
         if self._parent:
             data[FIELD_STATIKK_PARENT_ID] = self._parent.id
+            data[FIELD_STATIKK_PARENT_FIELD_NAME] = self._parent_field_name
         return data
 
     @model_validator(mode="after")
@@ -465,13 +476,6 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
                             items.append(item)
                         item.split_to_simple_objects(items)
 
-            elif isinstance(field_value, set):
-                for item in field_value:
-                    if hasattr(item, "__class__") and issubclass(item.__class__, DatabaseModel):
-                        if item not in items:
-                            items.append(item)
-                        item.split_to_simple_objects(items)
-
         return items
 
     def get_attribute(self, attribute_name: str):
@@ -488,14 +492,6 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
                 for item in field_value:
                     if issubclass(item.__class__, DatabaseModel) and item.is_nested():
                         nested_models.append(field_name)
-            elif isinstance(field_value, set):
-                for item in field_value:
-                    if issubclass(item.__class__, DatabaseModel) and item.is_nested():
-                        nested_models.append(field_name)
-            elif isinstance(field_value, dict):
-                for key, value in field_value.items():
-                    if issubclass(value.__class__, DatabaseModel) and value.is_nested():
-                        nested_models.append(field_name)
         return set(nested_models)
 
     def get_type_from_hierarchy_by_name(self, name: str) -> Optional[Type[DatabaseModel]]:
@@ -512,6 +508,7 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
         if field._parent and not force_override:
             return  # Already set
         field._parent = parent
+        field._parent_field_name = field_name
         if field.should_track_session:
             field._session.add_change(parent, field_name, field)
         root._model_types_in_hierarchy[field.type()] = type(field)
@@ -532,14 +529,10 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
         for field_name, field_value in self:
             if isinstance(field_value, DatabaseModel):
                 yield self, field_name, field_value
-            elif isinstance(field_value, (list, set)):
+            elif isinstance(field_value, list):
                 for item in field_value:
                     if isinstance(item, DatabaseModel):
                         yield self, field_name, item
-            elif isinstance(field_value, dict):
-                for key, value in field_value.items():
-                    if isinstance(value, DatabaseModel):
-                        yield self, key, value
 
     def dfs_traverse_hierarchy(self):
         """
@@ -555,11 +548,7 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
         for field_name, field_value in fields:
             if isinstance(field_value, DatabaseModel):
                 yield from field_value.dfs_traverse_hierarchy()
-            elif isinstance(field_value, (list, set)):
+            elif isinstance(field_value, list):
                 for item in field_value:
                     if isinstance(item, DatabaseModel):
                         yield from item.dfs_traverse_hierarchy()
-            elif isinstance(field_value, dict):
-                for key, value in field_value.items():
-                    if isinstance(value, DatabaseModel):
-                        yield from value.dfs_traverse_hierarchy()

{statikk-0.1.14 → statikk-0.1.16}/src/statikk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statikk
-Version: 0.1.14
+Version: 0.1.16
 Summary: statikk is a single table application (STA) library for DynamoDb.
 Home-page: https://github.com/terinia/statikk
 Author: Balint Biro

{statikk-0.1.14 → statikk-0.1.16}/tests/test_engine.py

@@ -897,79 +897,6 @@ def test_nested_hierarchies():
     assert list(table.scan()) == []
 
 
-def test_update_parent():
-    class DoublyNestedModel(DatabaseModel):
-        bar: str
-
-        @classmethod
-        def index_definitions(cls) -> dict[str, IndexFieldConfig]:
-            return {"main-index": IndexFieldConfig(sk_fields=["bar"])}
-
-        @classmethod
-        def is_nested(cls) -> bool:
-            return True
-
-    class NestedModel(DatabaseModel):
-        nested_id: str
-        name: str
-        doubly_nested: list[DoublyNestedModel] = []
-
-        @classmethod
-        def is_nested(cls) -> bool:
-            return True
-
-        @classmethod
-        def index_definitions(cls) -> dict[str, IndexFieldConfig]:
-            return {"main-index": IndexFieldConfig(sk_fields=["nested_id"])}
-
-    class Model(DatabaseModel):
-        model_id: str
-        name: str
-        nested: list[NestedModel] = []
-
-        @classmethod
-        def index_definitions(cls) -> dict[str, IndexFieldConfig]:
-            return {"main-index": IndexFieldConfig(pk_fields=["model_id"], sk_fields=["name"])}
-
-    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=[DoublyNestedModel, NestedModel, Model],
-    )
-    _create_dynamodb_table(table)
-    doubly_nested_model = DoublyNestedModel(bar="bar")
-    nested_model = NestedModel(nested_id="nested-model-1", name="nested-model-1", doubly_nested=[doubly_nested_model])
-    model = Model(model_id="model-1", name="model-1", nested=[nested_model])
-    model.save()
-    hierarchy = Model.query_hierarchy(hash_key=Equals("model-1"))
-    model_2 = Model(model_id="model-2", name="model-2", nested=[])
-    model_2.save()
-    nested = hierarchy.nested[0]
-    updated_hierarchy = nested.change_parent_to(model_2)
-    model_2.nested.append(updated_hierarchy)
-    model_2.save()
-    assert hierarchy.nested[0].is_parent_changed()
-    assert not model_2.nested[0].is_parent_changed()
-    assert model_2.nested[0].id == nested_model.id
-    model_2 = Model.query_hierarchy(hash_key=Equals("model-2"))
-    assert model_2.nested[0].id == nested_model.id
-    assert model_2.nested[0].gsi_pk == "model-2"
-    assert model_2.nested[0].gsi_sk == "Model|model-2|NestedModel|nested-model-1"
-
-    # when reparenting to a root node, the old subtree is deleted from the database after saving the old root
-    hierarchy.save()
-    hierarchy = Model.query_hierarchy(hash_key=Equals("model-1"))
-    assert len(hierarchy.nested) == 0
-
-
 def test_rebuild_model_indexes():
     class MyDatabaseModel(DatabaseModel):
         foo: str = "foo"
@@ -1017,7 +944,7 @@ def test_add_child_node():
         bar: str
         other_nested: Optional[MyOtherNestedDatabaseModel] = None
         list_nested: list[MyOtherNestedDatabaseModel] = []
-        set_nested: set[MyOtherNestedDatabaseModel] = {}
+        other_list_nested: list[MyOtherNestedDatabaseModel] = []
 
         @classmethod
         def is_nested(cls) -> bool:
@@ -1044,22 +971,23 @@ def test_add_child_node():
     my_database_model.build_model_indexes()
     my_database_model.nested.add_child_node("other_nested", MyOtherNestedDatabaseModel(baz="baz"))
     my_database_model.nested.add_child_node("list_nested", MyOtherNestedDatabaseModel(baz="bazz"))
-    my_database_model.nested.add_child_node("set_nested", MyOtherNestedDatabaseModel(baz="bazzz"))
+    my_database_model.nested.add_child_node("other_list_nested", MyOtherNestedDatabaseModel(baz="bazzz"))
     assert my_database_model.nested.other_nested.baz == "baz"
     assert my_database_model.nested.list_nested[0].baz == "bazz"
-    set_nested_item = my_database_model.nested.set_nested.pop()
-    assert set_nested_item.baz == "bazzz"
-    assert set_nested_item._parent == my_database_model.nested
-    assert set_nested_item.gsi_pk == set_nested_item._parent.gsi_pk
-    assert set_nested_item.gsi_sk == "MyDatabaseModel|MyNestedDatabaseModel|bar|MyOtherNestedDatabaseModel|bazzz"
+    other_list_nested = my_database_model.nested.other_list_nested[0]
+    assert other_list_nested.baz == "bazzz"
+    assert other_list_nested._parent == my_database_model.nested
+    assert other_list_nested.gsi_pk == other_list_nested._parent.gsi_pk
+    assert other_list_nested.gsi_sk == "MyDatabaseModel|MyNestedDatabaseModel|bar|MyOtherNestedDatabaseModel|bazzz"
     assert my_database_model.nested.other_nested._parent == my_database_model.nested
     assert my_database_model.nested.list_nested[0]._parent == my_database_model.nested
-    my_database_model.nested.add_child_node("set_nested", my_database_model.nested.list_nested[0])
+    my_database_model.nested.add_child_node("other_list_nested", my_database_model.nested.list_nested[0])
     assert my_database_model.nested.list_nested[0]._parent_changed is True
-    set_nested_new = my_database_model.nested.set_nested.pop()
-    assert set_nested_new._parent_changed is False
-    assert set_nested_new.gsi_sk == "MyDatabaseModel|MyNestedDatabaseModel|bar|MyOtherNestedDatabaseModel|bazz"
-    my_database_model.nested.add_child_node("list_nested", set_nested_new)
+    other_list_nested_new = my_database_model.nested.other_list_nested[1]
+    assert len(my_database_model.nested.other_list_nested) == 2
+    assert other_list_nested_new._parent_changed is False
+    assert other_list_nested_new.gsi_sk == "MyDatabaseModel|MyNestedDatabaseModel|bar|MyOtherNestedDatabaseModel|bazz"
+    my_database_model.nested.add_child_node("list_nested", other_list_nested_new)
     assert my_database_model.nested.list_nested[0]._parent_changed is False
     assert my_database_model.nested.list_nested[0]._parent == my_database_model.nested
     assert my_database_model.nested.list_nested[0].gsi_pk == "foo"
@@ -1067,4 +995,14 @@ def test_add_child_node():
         my_database_model.nested.list_nested[0].gsi_sk
         == "MyDatabaseModel|MyNestedDatabaseModel|bar|MyOtherNestedDatabaseModel|bazz"
     )
-    assert set_nested_new._parent_changed is True
+    assert other_list_nested_new._parent_changed is True
+    my_database_model.save()
+    my_database_model = MyDatabaseModel.query_hierarchy(hash_key=Equals("foo"))
+    assert len(my_database_model.nested.list_nested) == 1
+    assert len(my_database_model.nested.other_list_nested) == 1
+    hierarchy = MyDatabaseModel.query_hierarchy(hash_key=Equals("foo"))
+    assert hierarchy.is_persisted is True
+    assert hierarchy.nested.is_persisted is True
+    assert hierarchy.nested.list_nested[0].is_persisted is True
+    assert hierarchy.nested.other_list_nested[0].is_persisted is True
+    assert hierarchy.nested.other_nested.is_persisted is True