statikk 0.0.12__py3-none-any.whl → 0.1.0__py3-none-any.whl

statikk/conditions.py

@@ -10,6 +10,7 @@ Example usage of this module:
     from statikk.conditions import Equals, BeginsWith
     app.query(range_key=Equals("123"), hash_key=BeginsWith("abc"))
 """
+
 from abc import ABC, abstractmethod
 from boto3.dynamodb.conditions import Key, ComparisonCondition
 from typing import Any
@@ -37,8 +38,8 @@ class BeginsWith(Condition):
         return Key(key).begins_with(self.value)
 
     def enrich(self, model_class, **kwargs):
-        if not self.value.startswith(model_class.model_type()) and model_class.include_type_in_sort_key():
-            self.value = f"{model_class.model_type()}|{self.value}"
+        if not self.value.startswith(model_class.type()):
+            self.value = f"{model_class.type()}|{self.value}"
 
 
 class LessThan(Condition):

statikk/engine.py

@@ -13,17 +13,15 @@ from statikk.expressions import UpdateExpressionBuilder
 from statikk.models import (
     DatabaseModel,
     GSI,
-    Index,
-    IndexPrimaryKeyField,
-    IndexSecondaryKeyField,
     KeySchema,
 )
+from statikk.fields import FIELD_STATIKK_TYPE, FIELD_STATIKK_PARENT_ID
 
-from aws_xray_sdk.core import xray_recorder
 from aws_xray_sdk.core import patch_all
 
 patch_all()
 
+
 class InvalidIndexNameError(Exception):
     pass
 
@@ -32,6 +30,10 @@ class IncorrectSortKeyError(Exception):
     pass
 
 
+class IncorrectHashKeyError(Exception):
+    pass
+
+
 class ItemNotFoundError(Exception):
     pass
 
@@ -56,8 +58,6 @@ class Table:
             for model in self.models:
                 self._set_index_fields(model, idx)
                 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
 
@@ -160,6 +160,9 @@ class Table:
             BillingMode=self.billing_mode,
         )
 
+    def _get_model_type_by_statikk_type(self, statikk_type: str) -> Type[DatabaseModel]:
+        return [model_type for model_type in self.models if model_type.type() == statikk_type][0]
+
     def delete(self):
         """Deletes the DynamoDB table."""
         self._dynamodb_client().delete_table(TableName=self.name)
@@ -185,18 +188,21 @@ class Table:
             raise ItemNotFoundError(f"{model_class} with id '{id}' not found.")
         data = raw_data["Item"]
         for key, value in data.items():
+            if key == FIELD_STATIKK_TYPE:
+                continue
             data[key] = self._deserialize_value(value, model_class.model_fields[key])
         return model_class(**data)
 
-    def delete_item(self, id: str):
+    def delete_item(self, model: DatabaseModel):
         """
         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)
+        with self.batch_write() as batch:
+            for item in model.split_to_simple_objects():
+                batch.delete(item)
 
-    def put_item(self, model: DatabaseModel) -> DatabaseModel:
+    def put_item(self, model: DatabaseModel):
         """
         Puts an item into the database.
 
@@ -207,7 +213,7 @@ class Table:
         always prefixed with the type of the model to avoid collisions between different model types.
 
         Example:
-            class Card(DatabaseModel):
+            class Card(DatabaseModelV2):
                 id: str
                 player_id: IndexPrimaryKeyField
                 type: IndexSecondaryKeyField
@@ -225,11 +231,9 @@ class Table:
 
         Returns the enriched database model instance.
         """
-        data = self._serialize_item(model)
-        self._get_dynamodb_table().put_item(Item=data)
-        for key, value in data.items():
-            data[key] = self._deserialize_value(value, model.model_fields[key])
-        return type(model)(**data)
+        with self.batch_write() as batch:
+            for item in model.split_to_simple_objects():
+                batch.put(item)
 
     def update_item(
         self,
@@ -252,11 +256,11 @@ class Table:
             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)
-                    for idx in idx_field.index_names:
-                        idx_field.value = value
-                        changed_index_values.add(idx)
+                for index_name, index_fields in model.index_definitions().items():
+                    if attribute in index_fields.sk_fields:
+                        setattr(model, attribute, value)
+                        changed_index_values.add(index_name)
+
             return changed_index_values
 
         changed_index_values = _find_changed_indexes()
@@ -279,6 +283,8 @@ class Table:
         response = self._get_dynamodb_table().update_item(**request)
         data = response["Attributes"]
         for key, value in data.items():
+            if key == FIELD_STATIKK_TYPE:
+                continue
             data[key] = self._deserialize_value(value, model.model_fields[key])
         return type(model)(**data)
 
@@ -289,7 +295,7 @@ class Table:
         """
         return BatchWriteContext(self)
 
-    def query_index(
+    def _prepare_index_query_params(
         self,
         hash_key: Union[Condition | str],
         model_class: Type[DatabaseModel],
@@ -297,17 +303,6 @@ class Table:
         filter_condition: Optional[ComparisonCondition] = None,
         index_name: Optional[str] = None,
     ):
-        """
-        Queries the database using the provided hash key and range key conditions. A filter condition can also be provided
-        using the filter_condition parameter. The method returns a list of items matching the query, deserialized into the
-        provided model_class parameter.
-
-        :param hash_key: The hash key condition to use for the query. See statikk.conditions.Condition for more information.
-        :param range_key: The range key condition to use for the query. See statikk.conditions.Condition for more information.
-        :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.
-        :param index_name: The name of the index to use for the query. If not provided, the first index configured on the table is used.
-        """
         if isinstance(hash_key, str):
             hash_key = Equals(hash_key)
         if not index_name:
@@ -317,28 +312,89 @@ class Table:
             raise InvalidIndexNameError(f"The provided index name '{index_name}' is not configured on the table.")
         index = index_filter[0]
         key_condition = hash_key.evaluate(index.hash_key.name)
-        if range_key is None and model_class.include_type_in_sort_key():
-            range_key = BeginsWith(model_class.model_type())
+        if range_key is None and FIELD_STATIKK_TYPE not in model_class.index_definitions()[index_name].pk_fields:
+            range_key = BeginsWith(model_class.type())
         if range_key:
-            range_key.enrich(model_class=model_class)
+            if not model_class.is_nested():
+                range_key.enrich(model_class=model_class)
             key_condition = key_condition & range_key.evaluate(index.sort_key.name)
 
         query_params = {
             "IndexName": index_name,
             "KeyConditionExpression": key_condition,
         }
+
         if filter_condition:
             query_params["FilterExpression"] = filter_condition
+        return query_params
+
+    def query_index(
+        self,
+        hash_key: Union[Condition | str],
+        model_class: Type[DatabaseModel],
+        range_key: Optional[Condition] = None,
+        filter_condition: Optional[ComparisonCondition] = None,
+        index_name: Optional[str] = None,
+    ):
+        """
+        Queries the database using the provided hash key and range key conditions. A filter condition can also be provided
+        using the filter_condition parameter. The method returns a list of items matching the query, deserialized into the
+        provided model_class parameter.
+
+        :param hash_key: The hash key condition to use for the query. See statikk.conditions.Condition for more information.
+        :param range_key: The range key condition to use for the query. See statikk.conditions.Condition for more information.
+        :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.
+        :param index_name: The name of the index to use for the query. If not provided, the first index configured on the table is used.
+        """
+        query_params = self._prepare_index_query_params(
+            hash_key=hash_key,
+            model_class=model_class,
+            range_key=range_key,
+            filter_condition=filter_condition,
+            index_name=index_name,
+        )
         last_evaluated_key = True
+        while last_evaluated_key:
+            items = self._get_dynamodb_table().query(**query_params)
+            yield from [model_class(**item) for item in items["Items"]]
+            last_evaluated_key = items.get("LastEvaluatedKey", False)
 
+    def query_hierarchy(
+        self,
+        hash_key: Union[Condition | str],
+        model_class: Type[DatabaseModel],
+        range_key: Optional[Condition] = None,
+        filter_condition: Optional[ComparisonCondition] = None,
+        index_name: Optional[str] = None,
+    ) -> Optional[DatabaseModel]:
+        query_params = self._prepare_index_query_params(
+            hash_key=hash_key,
+            model_class=model_class,
+            range_key=range_key,
+            filter_condition=filter_condition,
+            index_name=index_name,
+        )
+        hierarchy_items = []
+        last_evaluated_key = True
         while last_evaluated_key:
             items = self._get_dynamodb_table().query(**query_params)
-            yield from [self._deserialize_item(item, model_class=model_class) for item in items["Items"]]
+            hierarchy_items.extend([item for item in items["Items"]])
             last_evaluated_key = items.get("LastEvaluatedKey", False)
 
+        reconstructed_dict = self.reconstruct_hierarchy(hierarchy_items)
+
+        if not reconstructed_dict:
+            return None
+
+        model_type = reconstructed_dict.get(FIELD_STATIKK_TYPE)
+        model_class = self._get_model_type_by_statikk_type(model_type)
+
+        reconstructed_dict.pop(FIELD_STATIKK_TYPE, None)
+        return model_class(**reconstructed_dict)
+
     def scan(
         self,
-        model_class: Type[DatabaseModel],
         filter_condition: Optional[ComparisonCondition] = None,
         consistent_read: bool = False,
     ):
@@ -358,7 +414,7 @@ class Table:
 
         while last_evaluated_key:
             items = self._get_dynamodb_table().scan(**query_params)
-            yield from [model_class(**item) for item in items["Items"]]
+            yield from [self._get_model_type_by_statikk_type(item["__statikk_type"])(**item) for item in items["Items"]]
             last_evaluated_key = items.get("LastEvaluatedKey", False)
 
     def _convert_dynamodb_to_python(self, item) -> Dict[str, Any]:
@@ -400,9 +456,9 @@ class Table:
     def _prepare_model_data(
         self,
         item: DatabaseModel,
-        indexes: List[Index],
+        indexes: List[GSI],
         force_override_index_fields: bool = False,
-    ) -> Dict[str, Any]:
+    ) -> DatabaseModel:
         for idx in indexes:
             index_fields = self._compose_index_values(item, idx)
             for key, value in index_fields.items():
@@ -411,24 +467,41 @@ class Table:
                 if value is not None:
                     setattr(item, key, value)
         item.model_rebuild(force=True)
-        return item.model_dump()
+        return item
 
     def _serialize_item(self, item: DatabaseModel):
-        data = self._prepare_model_data(item, self.indexes)
+        data = item.model_dump(exclude=item.get_nested_model_fields())
+        serialized_data = {}
         for key, value in data.items():
             data[key] = self._serialize_value(value)
         return data
 
     def _deserialize_item(self, item: Dict[str, Any], model_class: Type[DatabaseModel]):
         for key, value in item.items():
+            if key == FIELD_STATIKK_TYPE:
+                continue
             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) and value is not None:
+        actual_annotation = annotation.annotation if hasattr(annotation, "annotation") else annotation
+
+        if actual_annotation is datetime or "datetime" in str(annotation) and value is not None:
             return datetime.fromtimestamp(int(value))
-        if annotation is float:
+        if actual_annotation is float:
             return float(value)
+        if actual_annotation is list:
+            origin = getattr(actual_annotation, "__origin__", None)
+            args = getattr(actual_annotation, "__args__", None)
+            item_annotation = args[0] if args else Any
+            return [self._deserialize_value(item, item_annotation) for item in value]
+        if actual_annotation is set:
+            origin = getattr(actual_annotation, "__origin__", None)
+            args = getattr(actual_annotation, "__args__", None)
+            item_annotation = args[0] if args else Any
+            return {self._deserialize_value(item, item_annotation) for item in value}
+        if isinstance(value, dict):
+            return {key: self._deserialize_value(item, annotation) for key, item in value.items() if item is not None}
         return value
 
     def _serialize_value(self, value: Any):
@@ -438,36 +511,26 @@ class Table:
             return Decimal(value)
         if isinstance(value, list):
             return [self._serialize_value(item) for item in value]
+        if isinstance(value, set):
+            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):
+    def _set_index_fields(self, model: Type[DatabaseModel], idx: GSI):
         model_fields = model.model_fields
-        if idx.hash_key.name not in model_fields:
+        if idx.hash_key.name not in model_fields.keys():
             model_fields[idx.hash_key.name] = FieldInfo(annotation=idx.hash_key.type, default=None, required=False)
-        if idx.sort_key.name not in model_fields:
+        if idx.sort_key.name not in model_fields.keys():
             model_fields[idx.sort_key.name] = FieldInfo(annotation=idx.sort_key.type, default=None, required=False)
 
     def _get_sort_key_value(self, model: DatabaseModel, idx: GSI) -> str:
-        sort_key_fields_unordered = [
-            (field_name, getattr(model, field_name).order)
-            for field_name, field_info in model.model_fields.items()
-            if field_info.annotation is not None
-            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:
+        sort_key_fields = model.index_definitions().get(idx.name, []).sk_fields
+        if len(sort_key_fields) == 0:
             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])
 
-        sort_key_fields = [field[0] for field in sort_key_fields_unordered]
-
-        if len(sort_key_fields) == 0 and model.include_type_in_sort_key():
-            return model.model_type()
         if idx.sort_key.type is not str:
-            value = getattr(model, sort_key_fields[0]).value
+            value = getattr(model, sort_key_fields[0])
             if type(value) is not idx.sort_key.type:
                 raise IncorrectSortKeyError(
                     f"Incorrect sort key type. Sort key type for sort key '{idx.sort_key.name}' should be: "
@@ -478,32 +541,28 @@ class Table:
             value = value or idx.sort_key.default
             return self._serialize_value(value)
 
-        sort_key_values: List[str] = []
-        if model.include_type_in_sort_key() and model.model_type() not in sort_key_values:
-            sort_key_values.append(model.model_type())
+        sort_key_values = []
+        if model._parent:
+            sort_key_values.append(getattr(model._parent, idx.sort_key.name))
+        if FIELD_STATIKK_TYPE not in model.index_definitions()[idx.name].pk_fields:
+            sort_key_values.append(model.type())
+        for sort_key_field in sort_key_fields:
+            if sort_key_field in model.model_fields.keys():
+                sort_key_values.append(getattr(model, sort_key_field))
 
-        for field in sort_key_fields:
-            value = getattr(model, field).value
-            sort_key_values.append(value)
         return self.delimiter.join(sort_key_values)
 
     def _compose_index_values(self, model: DatabaseModel, idx: GSI) -> Dict[str, Any]:
-        model_fields = model.model_fields
-        hash_key_field = [
-            field_name
-            for field_name, field_info in model_fields.items()
-            if field_info.annotation is not None
-            if field_info.annotation is IndexPrimaryKeyField and idx.name in getattr(model, field_name).index_names
-        ]
-        if len(hash_key_field) == 0 and model.type_is_primary_key():
-            hash_key_field.append(model.model_type())
-        hash_key_field = hash_key_field[0]
+        hash_key_fields = model.index_definitions().get(idx.name, []).pk_fields
+
+        if len(hash_key_fields) == 0 and not model.is_nested():
+            raise IncorrectHashKeyError(f"Model {model.__class__} does not have a hash key defined.")
 
         def _get_hash_key_value():
-            if hash_key_field == model.model_type():
-                return model.model_type()
-            else:
-                return getattr(model, hash_key_field).value
+            if model._parent:
+                return getattr(model._parent, idx.hash_key.name)
+
+            return self.delimiter.join([self._serialize_value(model.get_attribute(field)) for field in hash_key_fields])
 
         return {
             idx.hash_key.name: _get_hash_key_value(),
@@ -519,15 +578,165 @@ class Table:
         if len(put_items) > 0:
             with dynamodb_table.batch_writer() as batch:
                 for item in put_items:
-                    data = self._serialize_item(item)
+                    enriched_item = self._prepare_model_data(item, self.indexes)
+                    if not enriched_item.was_modified:
+                        continue
+                    if not enriched_item.should_write_to_database():
+                        continue
+                    data = self._serialize_item(enriched_item)
                     batch.put_item(Item=data)
 
         if len(delete_items) > 0:
             with dynamodb_table.batch_writer() as batch:
                 for item in delete_items:
-                    data = self._serialize_item(item)
+                    enriched_item = self._prepare_model_data(item, self.indexes)
+                    data = self._serialize_item(enriched_item)
                     batch.delete_item(Key=data)
 
+    def reconstruct_hierarchy(self, items: list[dict]) -> Optional[dict]:
+        """
+        Reconstructs a hierarchical dictionary structure from a flat list of dictionaries
+        using explicit parent-child relationships and model class definitions.
+
+        Args:
+            items: A flat list of dictionaries representing models with FIELD_STATIKK_PARENT_ID
+
+        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:
+            parent_id = item.get(FIELD_STATIKK_PARENT_ID)
+            if parent_id:
+                if parent_id not in children_by_parent_id:
+                    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]
+
+        if not root_items:
+            return None
+
+        if len(root_items) > 1:
+            root_item = root_items[0]
+        else:
+            root_item = root_items[0]
+
+        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:
+        """
+        Recursively reconstruct an item and its children using model class definitions.
+
+        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
+
+        Returns:
+            The reconstructed item with all child references integrated
+        """
+        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)
+
+        children = children_by_parent_id.get(item["id"], [])
+        if not children:
+            return result
+
+        parent_model_class = self._get_model_type_by_statikk_type(item[FIELD_STATIKK_TYPE])
+
+        children_by_type = {}
+        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
+
+                field_type = 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
+
+                            reconstructed_child = self._reconstruct_item_with_children(
+                                child, items_by_id, children_by_parent_id, processed_items
+                            )
+
+                            result[field_name].append(reconstructed_child)
+                            existing_ids.add(child["id"])
+
+                    elif container_type == "set":
+                        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
+                            reconstructed_child = self._reconstruct_item_with_children(
+                                child, items_by_id, children_by_parent_id, processed_items
+                            )
+
+                            result[field_name].append(reconstructed_child)
+                            existing_ids.add(child["id"])
+
+                    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
+
+        return result
+
 
 class BatchWriteContext:
     def __init__(self, app: Table):

statikk/fields.py

@@ -0,0 +1,2 @@
+FIELD_STATIKK_TYPE = "__statikk_type"
+FIELD_STATIKK_PARENT_ID = "__statikk_parent_id"

statikk/models.py

@@ -1,15 +1,23 @@
 from __future__ import annotations
 
-import uuid
+import typing
+import logging
+from uuid import uuid4
 from typing import Optional, List, Any, Set, Type
 
 from boto3.dynamodb.conditions import ComparisonCondition
-from pydantic import BaseModel, model_serializer, model_validator
-from pydantic.fields import FieldInfo
+from pydantic import BaseModel, model_serializer, model_validator, Field, Extra
+from pydantic.fields import FieldInfo, Field
 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
+
+if typing.TYPE_CHECKING:
+    from statikk.engine import Table
+
+logger = logging.getLogger(__name__)
 
 
 class Key(BaseModel):
@@ -39,37 +47,114 @@ class Index(BaseModel):
         return self.value
 
 
-class IndexPrimaryKeyField(Index):
-    pass
+class IndexFieldConfig(BaseModel):
+    pk_fields: list[str] = []
+    sk_fields: list[str] = []
 
 
-class IndexSecondaryKeyField(Index):
-    order: Optional[int] = None
+class TrackingMixin:
+    _original_hash: int = Field(exclude=True)
 
+    def __init__(self):
+        self._original_hash = self._recursive_hash()
 
-class DatabaseModel(BaseModel):
-    id: str
+    def _recursive_hash(self) -> int:
+        """
+        Compute a hash value for the model, ignoring nested DatabaseModel instances.
 
-    @classmethod
-    def model_type(cls):
-        return cls.__name__
+        This ensures that changes to child models don't affect the parent's hash.
+
+        Returns:
+            A hash value representing the model's non-model fields.
+        """
+        values = []
+        for field_name in self.model_fields:
+            if not hasattr(self, field_name):
+                continue
+
+            if field_name.startswith("_"):
+                continue
+
+            value = getattr(self, field_name)
+
+            if hasattr(value, "__class__") and issubclass(value.__class__, DatabaseModel):
+                continue
+
+            if isinstance(value, list) or isinstance(value, set):
+                contains_model = False
+                for item in value:
+                    if hasattr(item, "__class__") and issubclass(item.__class__, DatabaseModel):
+                        contains_model = True
+                        break
+                if contains_model:
+                    continue
+
+            if isinstance(value, dict):
+                contains_model = False
+                if not contains_model:
+                    for val in value.values():
+                        if hasattr(val, "__class__") and issubclass(val.__class__, DatabaseModel):
+                            contains_model = True
+                            break
+                if contains_model:
+                    continue
+
+            values.append(self._make_hashable(value))
+
+        return hash(tuple(values))
+
+    def _make_hashable(self, value: Any) -> Any:
+        if isinstance(value, (str, int, float, bool, type(None))):
+            return value
+        elif isinstance(value, list) or isinstance(value, set):
+            return tuple(self._make_hashable(item) for item in value)
+        elif isinstance(value, dict):
+            return tuple((self._make_hashable(k), self._make_hashable(v)) for k, v in sorted(value.items()))
+        elif isinstance(value, BaseModel):
+            return value._recursive_hash() if hasattr(value, "_recursive_hash") else hash(value)
+        else:
+            try:
+                return hash(value)
+            except Exception:
+                logger.warning(
+                    f"{type(value)} is unhashable, tracking will not work. Consider implementing the TrackingMixin for this type."
+                )
+        return value
+
+    @property
+    def was_modified(self) -> bool:
+        return self._recursive_hash() != self._original_hash
+
+
+class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
+    id: str = Field(default_factory=lambda: str(uuid4()))
+    _parent: Optional[DatabaseModel] = None
+    _model_types_in_hierarchy: dict[str, Type[DatabaseModel]] = {}
 
     @classmethod
-    def include_type_in_sort_key(cls):
-        return True
+    def type(cls) -> str:
+        return cls.__name__
 
     @classmethod
-    def type_is_primary_key(cls):
-        return False
+    def index_definitions(cls) -> dict[str, IndexFieldConfig]:
+        return {"main_index": IndexFieldConfig(pk_fields=[], sk_fields=[])}
 
     @classmethod
-    def set_table_ref(cls, table):
+    def set_table_ref(cls, table: "Table"):
         cls._table = table
 
     @classmethod
     def batch_write(cls):
         return cls._table.batch_write()
 
+    @classmethod
+    def is_nested(cls) -> bool:
+        return False
+
+    @property
+    def is_simple_object(self) -> bool:
+        return len(self._model_types_in_hierarchy) == 1
+
     @classmethod
     def query(
         cls,
@@ -86,11 +171,27 @@ class DatabaseModel(BaseModel):
             index_name=index_name,
         )
 
+    @classmethod
+    def query_hierarchy(
+        cls,
+        hash_key: Union[Condition | str],
+        range_key: Optional[Condition] = None,
+        filter_condition: Optional[ComparisonCondition] = None,
+        index_name: Optional[str] = None,
+    ) -> DatabaseModel:
+        return cls._table.query_hierarchy(
+            hash_key=hash_key,
+            model_class=cls,
+            range_key=range_key,
+            filter_condition=filter_condition,
+            index_name=index_name,
+        )
+
     def save(self):
         return self._table.put_item(self)
 
     def delete(self):
-        return self._table.delete_item(self.id)
+        return self._table.delete_item(self)
 
     def update(self, sort_key: Optional[str] = None) -> DatabaseModelUpdateExpressionBuilder:
         return DatabaseModelUpdateExpressionBuilder(self, sort_key)
@@ -118,73 +219,141 @@ class DatabaseModel(BaseModel):
     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)
 
+    def should_write_to_database(self) -> bool:
+        if self.is_nested():
+            return self._parent.should_write_to_database()
+        return True
+
     @classmethod
     def scan(
         cls,
         filter_condition: Optional[ComparisonCondition] = None,
         consistent_read: bool = False,
     ):
-        return cls._table.scan(model_class=cls, filter_condition=filter_condition)
+        return cls._table.scan(filter_condition=filter_condition)
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        data = handler(self)
+        data[FIELD_STATIKK_TYPE] = self.type()
+        if self._parent:
+            data[FIELD_STATIKK_PARENT_ID] = self._parent.id
+        return data
 
-    @staticmethod
-    def _index_types() -> Set[Type[Index]]:
-        return {Index, IndexPrimaryKeyField, IndexSecondaryKeyField}
+    @model_validator(mode="after")
+    def initialize_tracking(self):
+        self._original_hash = self._recursive_hash()
+        self._model_types_in_hierarchy[self.type()] = type(self)
+        if not self.is_nested():
+            self._set_parent_references(self)
 
-    @staticmethod
-    def _is_index_field(field: FieldInfo) -> bool:
-        index_types = {Index, IndexPrimaryKeyField, IndexSecondaryKeyField}
-        return field.annotation in index_types
+        return self
 
-    @classmethod
-    def _create_index_field_from_shorthand(cls, field: FieldInfo, value: str) -> FieldInfo:
-        annotation = field.annotation
-        extra_fields = dict()
-        if field.default is not PydanticUndefined:
-            extra_fields["index_names"] = field.default.index_names
-            if field.annotation is IndexSecondaryKeyField:
-                extra_fields["order"] = field.default.order
-        return annotation(value=value, **extra_fields)
-
-    @model_validator(mode="before")
-    @classmethod
-    def check_boxed_indexes(cls, data: Any) -> Any:
+    def split_to_simple_objects(self, items: Optional[list[DatabaseModel]] = None) -> list[DatabaseModel]:
         """
-        This method allows for a cleaner interface when working with model indexes.
-        Instead of having to manually box the index value, this method will do it for you.
-        For example:
-          my_model = MyModel(id="123", my_index="abc")
-        Is equivalent to:
-          my_model = MyModel(id="123", my_index=IndexPrimaryKeyField(value="abc"))
-        """
-        if isinstance(data, dict):
-            if "id" not in data:
-                data["id"] = str(uuid.uuid4())
-
-            for key, value in data.items():
-                field = cls.model_fields[key]
-                if cls._is_index_field(field) and not isinstance(value, dict):
-                    if isinstance(value, tuple(cls._index_types())):
-                        continue
-                    else:
-                        data[key] = cls._create_index_field_from_shorthand(field, value)
-        return data
+        Split a complex nested DatabaseModel into a list of individual DatabaseModel instances.
 
-    @model_validator(mode="after")
-    def validate_index_fields(self):
-        sort_key_field_orders = [
-            getattr(self, field_name).order
-            for field_name, field_info in self.model_fields.items()
-            if field_info.annotation is not None
-            if field_info.annotation is IndexSecondaryKeyField
-        ]
-        have_orders_defined = any([order for order in sort_key_field_orders])
-        all_orders_defined = all([order for order in sort_key_field_orders])
-        use_default_ordering = all([order is None for order in sort_key_field_orders])
-        if have_orders_defined and not all_orders_defined and not use_default_ordering:
-            raise ValueError(
-                f"`order` is not defined on at least one of the Index keys on model {type(self)}. Please set the order for all sort key fields."
-            )
-        if all_orders_defined and len(set(sort_key_field_orders)) != len(sort_key_field_orders):
-            raise ValueError(
-                f"Duplicate `order` values found on model {type(self)}. Please ensure that all `order` values are unique."
-            )
+        This method recursively traverses the model and all its nested DatabaseModel instances,
+        collecting them into a flat list for simpler processing or storage.
+
+        Args:
+            items: An optional existing list to add items to. If None, a new list is created.
+
+        Returns:
+            A list containing this model and all nested DatabaseModel instances.
+        """
+        if items is None:
+            items = [self]
+        else:
+            if self not in items:
+                items.append(self)
+
+        # Iterate through all fields of the model
+        for field_name, field_value in self:
+            # Skip fields that start with underscore (private fields)
+            if field_name.startswith("_"):
+                continue
+
+            # Handle direct DatabaseModel instances
+            if hasattr(field_value, "__class__") and issubclass(field_value.__class__, DatabaseModel):
+                if field_value not in items:
+                    items.append(field_value)
+                field_value.split_to_simple_objects(items)
+
+            # Handle lists containing DatabaseModel instances
+            elif isinstance(field_value, list):
+                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)
+
+            # Handle sets containing DatabaseModel instances
+            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)
+
+            # Handle dictionaries that may contain DatabaseModel instances
+            elif isinstance(field_value, dict):
+                # Check dictionary values
+                for value in field_value.values():
+                    if hasattr(value, "__class__") and issubclass(value.__class__, DatabaseModel):
+                        if value not in items:
+                            items.append(value)
+                        value.split_to_simple_objects(items)
+
+        return items
+
+    def get_attribute(self, attribute_name: str):
+        if attribute_name == FIELD_STATIKK_TYPE:
+            return self.type()
+        return getattr(self, attribute_name)
+
+    def get_nested_model_fields(self) -> set[DatabaseModel]:
+        nested_models = []
+        for field_name, field_value in self:
+            if issubclass(field_value.__class__, DatabaseModel) and field_value.is_nested():
+                nested_models.append(field_name)
+            elif isinstance(field_value, list):
+                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]]:
+        return self._model_types_in_hierarchy.get(name)
+
+    def _set_parent_to_field(self, field: DatabaseModel, parent: DatabaseModel, root: DatabaseModel):
+        if field._parent:
+            return  # Already set
+        field._parent = parent
+        root._model_types_in_hierarchy[field.type()] = type(field)
+        field._set_parent_references(root)
+
+    def _set_parent_references(self, root: DatabaseModel):
+        for field_name, field_value in self:
+            if isinstance(field_value, DatabaseModel):
+                self._set_parent_to_field(field_value, self, root)
+            elif isinstance(field_value, list):
+                for item in field_value:
+                    if isinstance(item, DatabaseModel):
+                        self._set_parent_to_field(item, self, root)
+            elif isinstance(field_value, set):
+                for item in field_value:
+                    if isinstance(item, DatabaseModel):
+                        self._set_parent_to_field(item, self, root)
+            elif isinstance(field_value, dict):
+                for key, value in field_value.items():
+                    if isinstance(value, DatabaseModel):
+                        self._set_parent_to_field(value, self, root)

{statikk-0.0.12.dist-info → statikk-0.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: statikk
-Version: 0.0.12
+Version: 0.1.0
 Summary: statikk is a single table application (STA) library for DynamoDb.
 Home-page: https://github.com/terinia/statikk
 Author: Balint Biro
@@ -13,25 +13,23 @@ Classifier: Programming Language :: Python
 Requires-Python: >=3.8
 Description-Content-Type: text/x-rst; charset=UTF-8
 License-File: LICENSE.txt
-Requires-Dist: pydantic ==2.7.4
-Requires-Dist: boto3 ==1.28.43
-Requires-Dist: aws-xray-sdk ==2.14.0
-Requires-Dist: importlib-metadata ; python_version < "3.8"
+Requires-Dist: importlib-metadata; python_version < "3.8"
+Requires-Dist: pydantic<3.0,>=2.7.4
+Requires-Dist: boto3<2.0,>=1.28.43
+Requires-Dist: aws-xray-sdk<3.0,>=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] ==4.2.14 ; extra == 'testing'
+Requires-Dist: setuptools; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: moto[dynamodb]==4.2.14; extra == "testing"
 
 .. image:: ./assets/logo.png
     :alt: Statikk
     :align: center
 
-We built this library because we got fed up with all the boilerplate we needed to write to use DynamoDB in a Single Table Application architecture.
-We were originally using `PynamoDB <https://github.com/pynamodb/PynamoDB>`_ , but we found it to be too verbose for our liking.
+An ORM-like Single Table Application (STA) architecture library for Python and DynamoDb. Makes it really eason to set up and work with STAs.
 
-This library is very much in alpha phase and is not yet recommended for production use. We are actively working on it and using it as a core library
-for our upcoming game, Conquests of Ethoas. Drastic API changes can still happen.
+The library is in alpha. Constant work is being done on it as I'm developing my game.
 
 =================
 Requirements
@@ -55,15 +53,19 @@ Basic Usage
 
 .. code-block:: python
 
-    from statikk.models import DatabaseModel, Table, GlobalSecondaryIndex, KeySchema, IndexPrimaryKeyField, IndexSecondaryKeyField
+    from statikk.models import DatabaseModel, Table, GlobalSecondaryIndex, KeySchema
 
     class MyAwesomeModel(DatabaseModel):
-      player_id: IndexPrimaryKeyField
-      tier: IndexSecondaryKeyField
+      player_id: str
+      tier: str
       name: str = "Foo"
       values: set = {1, 2, 3, 4}
       cost: int = 4
 
+      @classmethod
+      def index_definitions(cls) -> dict[str, IndexFieldConfig]:
+        return {"main-index": IndexFieldConfig(pk_fields=["player_id"], sk_fields=["tier"])}
+
     table = Table(
       name="my-dynamodb-table",
       key_schema=KeySchema(hash_key="id"),

statikk-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+statikk/__init__.py,sha256=pH5i4Fj1tbXLqLtTVIdoojiplZssQn0nnud8-HXodRE,577
+statikk/conditions.py,sha256=63FYMR-UUaE-ZJEb_8CU721CQTwhajq39-BbokmKeMA,2166
+statikk/engine.py,sha256=GCcqowgJa041Oo22sarSqDUQRWS4GbwHSNz_WGmcpNM,30855
+statikk/expressions.py,sha256=mF6Hmj3Kmj6KKXTymeTHSepVA7rhiSINpFgSAPeBTRY,12210
+statikk/fields.py,sha256=LkMP5NnX7WS0HSLxI3Q-dMOrfaJ0SD7SayZxJU5Acgg,86
+statikk/models.py,sha256=S5KdjNH0ufGn7iW4ZTVMXv1e177U95C28mbUlwDax_k,12831
+statikk-0.1.0.dist-info/LICENSE.txt,sha256=uSH_2Hpb2Bigy5_HhBliN2fZbBU64G3ERM5zzhKPUEE,1078
+statikk-0.1.0.dist-info/METADATA,sha256=Aqf0Od-2YmGbkQRqX36IhwPPzx-r5Wjr2ipe5dBcj7o,3160
+statikk-0.1.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+statikk-0.1.0.dist-info/top_level.txt,sha256=etKmBbjzIlLpSefXoiOfhWGEgvqUEALaFwCjFDBD9YI,8
+statikk-0.1.0.dist-info/RECORD,,

{statikk-0.0.12.dist-info → statikk-0.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.2.0)
+Generator: setuptools (75.8.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

statikk-0.0.12.dist-info/RECORD

@@ -1,10 +0,0 @@
-statikk/__init__.py,sha256=pH5i4Fj1tbXLqLtTVIdoojiplZssQn0nnud8-HXodRE,577
-statikk/conditions.py,sha256=66kJ-2YWqlV-dzEkiAe6c985dMQ-lpaoZ8aaoWhSs_M,2220
-statikk/engine.py,sha256=aYIVTwUxlSLnoB8DOUpX4udf0PcIoiTzgSfJ3YCtPaU,22193
-statikk/expressions.py,sha256=mF6Hmj3Kmj6KKXTymeTHSepVA7rhiSINpFgSAPeBTRY,12210
-statikk/models.py,sha256=q-wY2bQRgaH0NTnR4NGnQ22eO3rUshK-aAykt7NVFO4,6172
-statikk-0.0.12.dist-info/LICENSE.txt,sha256=uSH_2Hpb2Bigy5_HhBliN2fZbBU64G3ERM5zzhKPUEE,1078
-statikk-0.0.12.dist-info/METADATA,sha256=KEEKDEMhWuuw_uSGW16PptvjXQIyMxi96Hh9Zg8Z4yI,3339
-statikk-0.0.12.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-statikk-0.0.12.dist-info/top_level.txt,sha256=etKmBbjzIlLpSefXoiOfhWGEgvqUEALaFwCjFDBD9YI,8
-statikk-0.0.12.dist-info/RECORD,,