statikk 0.1.17__tar.gz → 0.1.19__tar.gz

{statikk-0.1.17 → statikk-0.1.19}/PKG-INFO

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

{statikk-0.1.17 → statikk-0.1.19}/src/statikk/engine.py

@@ -240,13 +240,24 @@ class Table:
         """
 
         with self.batch_write() as batch:
-            for item in model.split_to_simple_objects():
+            items = model.split_to_simple_objects()
+            new_keys = self._create_snapshot_representation(model)
+            keys_to_delete = model._db_snapshot_keys - new_keys
+
+            for key in keys_to_delete:
+                hash_key, sort_key = key.split("#", 1)
+                delete_params = {self.key_schema.hash_key: hash_key}
+                if sort_key:
+                    delete_params[self.key_schema.sort_key] = sort_key
+                batch.delete_by_key(delete_params)
+
+            for item in items:
                 if item.should_delete:
                     batch.delete(item)
                 else:
                     batch.put(item)
 
-        model._session.reset()
+        model._db_snapshot_keys = new_keys
 
     def update_item(
         self,
@@ -302,20 +313,17 @@ class Table:
         return type(model)(**data)
 
     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
+        subtree_root._parent = new_parent
+        subtree_root._parent_field_name = field_name
+        subtree_root.set_parent_references(subtree_root, force_override=True)
         parent = None
-        for node in subtree_copy.dfs_traverse_hierarchy():
+        for node in subtree_root.dfs_traverse_hierarchy():
             self.build_model_indexes(node)
             if parent:
                 setattr(node, FIELD_STATIKK_PARENT_ID, parent.id)
             parent = node
 
-        return subtree_copy
+        return subtree_root
 
     def build_model_indexes(self, model: T) -> T:
         for idx in self.indexes:
@@ -432,8 +440,7 @@ class Table:
 
         reconstructed_dict.pop(FIELD_STATIKK_TYPE, None)
         model = model_class.model_validate(reconstructed_dict)
-        for node in model.dfs_traverse_hierarchy():
-            node._is_persisted = True
+        model._db_snapshot_keys = self._create_snapshot_representation(model)
         return model
 
     def scan(
@@ -502,7 +509,7 @@ class Table:
         for idx in indexes:
             index_fields = self._compose_index_values(item, idx)
             for key, value in index_fields.items():
-                if hasattr(item, key) and (getattr(item, key) is not None and not item._parent_changed):
+                if hasattr(item, key) and (getattr(item, key) is not None):
                     continue
                 if value is not None:
                     setattr(item, key, value)
@@ -612,7 +619,9 @@ class Table:
             idx.sort_key.name: self._get_sort_key_value(model, idx),
         }
 
-    def _perform_batch_write(self, put_items: List[DatabaseModel], delete_items: List[DatabaseModel]):
+    def _perform_batch_write(
+        self, put_items: List[DatabaseModel], delete_items: List[DatabaseModel], delete_keys: list[dict[str, Any]]
+    ):
         if len(put_items) == 0 and len(delete_items) == 0:
             return
 
@@ -625,6 +634,11 @@ class Table:
                     data = self._serialize_item(enriched_item)
                     batch.delete_item(Key=data)
 
+        if len(delete_keys) > 0:
+            with dynamodb_table.batch_writer() as batch:
+                for key in delete_keys:
+                    batch.delete_item(Key=key)
+
         if len(put_items) > 0:
             with dynamodb_table.batch_writer() as batch:
                 for item in put_items:
@@ -633,10 +647,19 @@ 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)
 
+    def _create_snapshot_representation(self, model: DatabaseModel) -> set:
+        db_snasphot = set()
+        for node in model.dfs_traverse_hierarchy():
+            model_key = {self.key_schema.hash_key: getattr(node, self.key_schema.hash_key)}
+            if self.key_schema.sort_key:
+                model_key[self.key_schema.sort_key] = getattr(node, self.key_schema.sort_key)
+            key_string = f"{model_key.get(self.key_schema.hash_key)}#{model_key.get(self.key_schema.sort_key, '')}"
+            db_snasphot.add(key_string)
+        return db_snasphot
+
     def reconstruct_hierarchy(self, items: list[dict]) -> Optional[dict]:
         """
         Reconstructs a hierarchical dictionary structure from a flat list of dictionaries
@@ -657,8 +680,11 @@ class Table:
                     children_by_parent_id[parent_id] = []
                 children_by_parent_id[parent_id].append(item)
 
-        root_item = [item for item in items if FIELD_STATIKK_PARENT_ID not in item][0]
+        root_items = [item for item in items if FIELD_STATIKK_PARENT_ID not in item]
+        if not root_items:
+            return None
 
+        root_item = root_items[0]
         processed_root = self._process_item(root_item, items_by_id, children_by_parent_id)
         return processed_root
 
@@ -732,6 +758,7 @@ class BatchWriteContext:
         self._table = app
         self._put_items: List[DatabaseModel] = []
         self._delete_items: List[DatabaseModel] = []
+        self._delete_keys: List[dict[str, Any]] = []
 
     def put(self, item: DatabaseModel):
         self._put_items.append(item)
@@ -739,8 +766,11 @@ class BatchWriteContext:
     def delete(self, item: DatabaseModel):
         self._delete_items.append(item)
 
+    def delete_by_key(self, key: dict[str, Any]):
+        self._delete_keys.append(key)
+
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self._table._perform_batch_write(self._put_items, self._delete_items)
+        self._table._perform_batch_write(self._put_items, self._delete_items, self._delete_keys)

{statikk-0.1.17 → statikk-0.1.19}/src/statikk/models.py

@@ -61,36 +61,6 @@ class TreeStructureChange(BaseModel):
     timestamp: datetime = Field(default_factory=datetime.now)
 
 
-class Session(BaseModel):
-    _changes: list[TreeStructureChange] = []
-
-    def add_change(self, new_parent: Optional[T], new_parent_field_name: Optional[str], subtree: T):
-        self._changes.append(
-            TreeStructureChange(new_parent=new_parent, new_parent_field_name=new_parent_field_name, subtree=subtree)
-        )
-
-    def get_subtree_changes_by_parent_id(
-        self, parent_id: str, subtree_id: str, field_name: str
-    ) -> Optional[TreeStructureChange]:
-        sorted_changes = sorted(self._changes, key=lambda change: change.timestamp, reverse=True)
-        return next(
-            filter(
-                lambda change: change.new_parent.id == parent_id
-                and change.subtree.id == subtree_id
-                and change.new_parent_field_name == field_name,
-                sorted_changes,
-            ),
-            None,
-        )
-
-    def get_last_change_for(self, subtree_id):
-        sorted_changes = sorted(self._changes, key=lambda change: change.timestamp, reverse=True)
-        return next(filter(lambda change: change.subtree.id == subtree_id, sorted_changes), None)
-
-    def reset(self):
-        self._changes = []
-
-
 class TrackingMixin:
     _original_hash: int = Field(exclude=True)
 
@@ -202,9 +172,7 @@ class DatabaseModel(BaseModel, TrackingMixin):
     _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()
+    _db_snapshot_keys = set()
 
     class Config:
         extra = Extra.allow
@@ -215,34 +183,10 @@ class DatabaseModel(BaseModel, TrackingMixin):
             return False
         return self.id == other.id
 
-    def is_parent_changed(self):
-        """
-        Recursively check if this node or any of its ancestors has been marked as having changed parents.
-        Returns True if the node or any ancestor has _parent_changed=True, otherwise False.
-        """
-        if self._parent_changed:
-            return True
-
-        if self._parent is not None:
-            return self._parent.is_parent_changed()
-
-        return False
-
     @classmethod
     def type(cls) -> str:
         return cls.__name__
 
-    @property
-    def should_track_session(self) -> bool:
-        """
-        If set to True, subtree movements across the database model will be tracked in a session.
-        Use this if you need to move a subtree across multiple parent-child relationships within a single session.
-        Session is reset after each save.
-        """
-        if self._parent is not None:
-            return self._parent.should_track_session
-        return False
-
     @classmethod
     def index_definitions(cls) -> dict[str, IndexFieldConfig]:
         return {"main_index": IndexFieldConfig(pk_fields=[], sk_fields=[])}
@@ -263,16 +207,11 @@ class DatabaseModel(BaseModel, TrackingMixin):
     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.is_persisted and (self._should_delete or self.is_parent_changed())
+        return self._should_delete
 
     def _is_any_parent_marked_for_deletion(self) -> bool:
         current = self._parent
@@ -361,22 +300,24 @@ class DatabaseModel(BaseModel, TrackingMixin):
     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):
+    def _remove_from_parent(self, parent: DatabaseModel, field_name: str):
         is_optional, inner_type = inspect_optional_field(parent.__class__, field_name)
         field_type = inner_type if is_optional else parent.model_fields[field_name].annotation
-        field = getattr(self, field_name)
+        field = getattr(parent, field_name)
         if hasattr(field_type, "__origin__") and field_type.__origin__ == list:
             if not isinstance(field, list):
-                setattr(self, field_name, [])
-            field.remove(next(filter(lambda item: item.id == subtree.id, getattr(parent, field_name)), None))
+                setattr(parent, field_name, [])
+            field.remove(next(filter(lambda item: item.id == self.id, getattr(parent, field_name)), None))
 
         elif hasattr(field_type, "__origin__") and field_type.__origin__ == set:
             if not isinstance(field, set):
-                setattr(self, field_name, set())
-            field.remove(next(filter(lambda item: item.id == subtree.id, getattr(parent, field_name)), None))
+                setattr(parent, field_name, set())
+            field.remove(next(filter(lambda item: item.id == self.id, getattr(parent, field_name)), None))
 
         elif issubclass(field_type, DatabaseModel):
-            setattr(parent, field_name, None)
+            current_value = getattr(parent, field_name)
+            if current_value and current_value.id == self.id:
+                setattr(parent, field_name, None)
 
     def add_child_node(self, field_name: str, child_node: DatabaseModel):
         if not child_node.is_nested():
@@ -385,10 +326,8 @@ class DatabaseModel(BaseModel, TrackingMixin):
         if not hasattr(self, field_name):
             raise ValueError(f"Field {field_name} does not exist on {self.__class__.__name__}")
 
-        if self.should_track_session:
-            previous_change = self._session.get_subtree_changes_by_parent_id(self.id, child_node.id, field_name)
-            if previous_change:
-                self._remove_from_parent(previous_change.new_parent, previous_change.new_parent_field_name, child_node)
+        if child_node._parent:
+            child_node._remove_from_parent(child_node._parent, child_node._parent_field_name)
 
         is_optional, inner_type = inspect_optional_field(self.__class__, field_name)
         field_type = inner_type if is_optional else self.model_fields[field_name].annotation
@@ -410,8 +349,6 @@ class DatabaseModel(BaseModel, TrackingMixin):
             setattr(self, field_name, reparented)
 
         if reparented:
-            if self.should_track_session:
-                self._session.add_change(self, field_name, reparented)
             return reparented
 
         raise ValueError(f"Unsupported field type: {field_type}")
@@ -511,8 +448,6 @@ class DatabaseModel(BaseModel, TrackingMixin):
             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)
         field.set_parent_references(root, force_override)
         field.init_tracking()

{statikk-0.1.17 → statikk-0.1.19}/src/statikk.egg-info/PKG-INFO

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

{statikk-0.1.17 → statikk-0.1.19}/tests/test_engine.py

@@ -982,27 +982,18 @@ def test_add_child_node():
     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("other_list_nested", my_database_model.nested.list_nested[0])
-    assert my_database_model.nested.list_nested[0]._parent_changed is True
     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"
     assert (
         my_database_model.nested.list_nested[0].gsi_sk
         == "MyDatabaseModel|MyNestedDatabaseModel|bar|MyOtherNestedDatabaseModel|bazz"
     )
-    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