statikk 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

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
 
@@ -246,6 +246,8 @@ class Table:
                 else:
                     batch.put(item)
 
+        model._session.reset()
+
     def update_item(
         self,
         hash_key: str,
@@ -294,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
 
@@ -425,7 +430,9 @@ 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)
+        model._is_persisted = True
+        return model
 
     def scan(
         self,
@@ -624,6 +631,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)
 
@@ -638,9 +646,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:
@@ -650,128 +655,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
+        processed_root = self._process_item(root_item, items_by_id, children_by_parent_id)
+        return processed_root
 
-        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:
+    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/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/models.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from datetime import datetime
 import typing
 import logging
 from uuid import uuid4
@@ -13,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
@@ -53,6 +54,43 @@ class IndexFieldConfig(BaseModel):
     sk_fields: list[str] = []
 
 
+class TreeStructureChange(BaseModel):
+    new_parent: Optional[Any]
+    new_parent_field_name: Optional[str]
+    subtree: Any
+    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)
 
@@ -158,12 +196,22 @@ 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
 
     def is_parent_changed(self):
         """
@@ -182,6 +230,17 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
     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=[])}
@@ -202,12 +261,19 @@ 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:
+        if self._parent is not None:
+            return self._parent.is_persisted
+
+        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
@@ -293,8 +359,25 @@ 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)
+        field_type = inner_type if is_optional else parent.model_fields[field_name].annotation
+        field = getattr(self, 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))
+
+        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))
+
+        elif issubclass(field_type, DatabaseModel):
+            setattr(parent, field_name, None)
 
     def add_child_node(self, field_name: str, child_node: DatabaseModel):
         if not child_node.is_nested():
@@ -303,26 +386,33 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
         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)
+
         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
-
+        reparented = None
         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)
-            return 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)
-            return 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:
+            if self.should_track_session:
+                self._session.add_change(self, field_name, reparented)
             return reparented
 
         raise ValueError(f"Unsupported field type: {field_type}")
@@ -341,6 +431,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")
@@ -371,9 +462,7 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
             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
 
@@ -383,7 +472,6 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
                     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):
@@ -391,23 +479,6 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
                             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):
@@ -424,25 +495,25 @@ 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]]:
         return self._model_types_in_hierarchy.get(name)
 
     def _set_parent_to_field(
-        self, field: DatabaseModel, parent: DatabaseModel, root: DatabaseModel, force_override: bool = False
+        self,
+        field: DatabaseModel,
+        field_name: str,
+        parent: DatabaseModel,
+        root: DatabaseModel,
+        force_override: bool = False,
     ):
         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)
         field.set_parent_references(root, force_override)
         field.init_tracking()
@@ -452,7 +523,7 @@ class DatabaseModel(BaseModel, TrackingMixin, extra=Extra.allow):
         Sets parent references for all DatabaseModel objects in the hierarchy.
         """
         for parent, field_name, model in self.traverse_hierarchy():
-            self._set_parent_to_field(model, parent, root, force_override)
+            self._set_parent_to_field(model, field_name, parent, root, force_override)
 
     def traverse_hierarchy(self):
         """
@@ -461,14 +532,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):
         """
@@ -484,11 +551,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.13.dist-info → statikk-0.1.15.dist-info}/METADATA

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

statikk-0.1.15.dist-info/RECORD

@@ -0,0 +1,12 @@
+statikk/__init__.py,sha256=pH5i4Fj1tbXLqLtTVIdoojiplZssQn0nnud8-HXodRE,577
+statikk/conditions.py,sha256=63FYMR-UUaE-ZJEb_8CU721CQTwhajq39-BbokmKeMA,2166
+statikk/engine.py,sha256=ccQ57Xsg1brgbDZMHewPzTuCEvz0vRkEVHCRhvX2m5Q,30502
+statikk/expressions.py,sha256=boAeGxZj2cDsXxoiX3IIEzfX9voSMQngi4-rE_jYeuE,12233
+statikk/fields.py,sha256=uLGD3xEnz2nqQY6EwG8Dd7pnRMMVP4PU2Z2I-uGNaTA,150
+statikk/models.py,sha256=3vDyq_ox6zCGsSw72PcIbOEf4pgs3oJskLhvf--EtMQ,19740
+statikk/typing.py,sha256=laOlOpWOm9_sOj4hhdZnGTUZRiq8760_B9I9B3wBhz8,750
+statikk-0.1.15.dist-info/licenses/LICENSE.txt,sha256=uSH_2Hpb2Bigy5_HhBliN2fZbBU64G3ERM5zzhKPUEE,1078
+statikk-0.1.15.dist-info/METADATA,sha256=sL1Y0GF7pUk3leDfgyTlhV69F5wnOiCPm5jO3WPLkcg,3183
+statikk-0.1.15.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+statikk-0.1.15.dist-info/top_level.txt,sha256=etKmBbjzIlLpSefXoiOfhWGEgvqUEALaFwCjFDBD9YI,8
+statikk-0.1.15.dist-info/RECORD,,

statikk-0.1.13.dist-info/RECORD

@@ -1,12 +0,0 @@
-statikk/__init__.py,sha256=pH5i4Fj1tbXLqLtTVIdoojiplZssQn0nnud8-HXodRE,577
-statikk/conditions.py,sha256=63FYMR-UUaE-ZJEb_8CU721CQTwhajq39-BbokmKeMA,2166
-statikk/engine.py,sha256=xH8vbUcup3FmZ3h3RL6-j1hxVDSQwrRASp8ILhoKXn8,32604
-statikk/expressions.py,sha256=boAeGxZj2cDsXxoiX3IIEzfX9voSMQngi4-rE_jYeuE,12233
-statikk/fields.py,sha256=LkMP5NnX7WS0HSLxI3Q-dMOrfaJ0SD7SayZxJU5Acgg,86
-statikk/models.py,sha256=fU5SwxKP1Afsy91RhYiJSD58CCF92s4YxX-fwH6p7ZI,17705
-statikk/typing.py,sha256=laOlOpWOm9_sOj4hhdZnGTUZRiq8760_B9I9B3wBhz8,750
-statikk-0.1.13.dist-info/licenses/LICENSE.txt,sha256=uSH_2Hpb2Bigy5_HhBliN2fZbBU64G3ERM5zzhKPUEE,1078
-statikk-0.1.13.dist-info/METADATA,sha256=pv7MrB9Svi22O1z--jDhW8DkEvdxNP4nErQLt7HqQpg,3183
-statikk-0.1.13.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-statikk-0.1.13.dist-info/top_level.txt,sha256=etKmBbjzIlLpSefXoiOfhWGEgvqUEALaFwCjFDBD9YI,8
-statikk-0.1.13.dist-info/RECORD,,