ic-python-db 0.8.2__py3-none-any.whl → 0.9.0__py3-none-any.whl

ic_python_db/__init__.py

@@ -20,7 +20,7 @@ from .schema import SchemaIncompatibleError, build_schema, diff_schemas, schema_
 from .storage import MemoryStorage, Storage
 from .system_time import SystemTime
 
-__version__ = "0.8.2"
+__version__ = "0.9.0"
 __all__ = [
     "Database",
     "Entity",

ic_python_db/db_engine.py

@@ -366,6 +366,66 @@ class Database:
 
         return check_upgrade_compatibility(self, raise_on_error=raise_on_error)
 
+    # ── Reverse Index API ──────────────────────────────────────────────────────
+    #
+    # Reverse indexes allow OneToMany / ManyToMany / inverse-OneToOne relations
+    # to be resolved without scanning all child entities.
+    #
+    # Key format: _ri:{ParentType}:{parent_id}:{relation_name}
+    # Value: JSON array of child entity IDs, e.g. ["1", "2", "3"]
+
+    def _ri_key(self, parent_type: str, parent_id: str, relation_name: str) -> str:
+        return f"_ri:{parent_type}:{parent_id}:{relation_name}"
+
+    def reverse_index_get(
+        self, parent_type: str, parent_id: str, relation_name: str
+    ) -> List[str]:
+        """Read the reverse index for a parent entity's relation.
+
+        Returns:
+            List of child entity IDs, or empty list if no index exists.
+        """
+        key = self._ri_key(parent_type, parent_id, relation_name)
+        raw = self._db_storage.get(key)
+        if raw:
+            return json.loads(raw)
+        return []
+
+    def reverse_index_add(
+        self, parent_type: str, parent_id: str, relation_name: str, child_id: str
+    ) -> None:
+        """Add a child ID to a parent's reverse index."""
+        key = self._ri_key(parent_type, parent_id, relation_name)
+        raw = self._db_storage.get(key)
+        ids = json.loads(raw) if raw else []
+        if child_id not in ids:
+            ids.append(child_id)
+            self._db_storage.insert(key, json.dumps(ids))
+
+    def reverse_index_remove(
+        self, parent_type: str, parent_id: str, relation_name: str, child_id: str
+    ) -> None:
+        """Remove a child ID from a parent's reverse index."""
+        key = self._ri_key(parent_type, parent_id, relation_name)
+        raw = self._db_storage.get(key)
+        if not raw:
+            return
+        ids = json.loads(raw)
+        if child_id in ids:
+            ids.remove(child_id)
+            if ids:
+                self._db_storage.insert(key, json.dumps(ids))
+            else:
+                self._db_storage.remove(key)
+
+    def reverse_index_delete(
+        self, parent_type: str, parent_id: str, relation_name: str
+    ) -> None:
+        """Delete an entire reverse index entry (used when parent is deleted)."""
+        key = self._ri_key(parent_type, parent_id, relation_name)
+        if self._db_storage.get(key) is not None:
+            self._db_storage.remove(key)
+
     def get_audit(
         self, id_from: Optional[int] = None, id_to: Optional[int] = None
     ) -> Dict[str, str]:

ic_python_db/entity.py

@@ -71,7 +71,6 @@ class Entity:
         _id (str): Unique sequential identifier ("1", "2", "3", ...)
         _loaded (bool): True if loaded from DB, False if newly created
         _counted (bool): True if entity has been counted (prevents double-counting)
-        _relations (dict): Dictionary mapping relation names to related entities
         _do_not_save (bool): Temporary flag to prevent saving during initialization
 
     Class-level attributes:
@@ -161,8 +160,6 @@ class Entity:
         self._loaded = False if kwargs.get("_loaded") is None else kwargs["_loaded"]
         self._counted = False  # Track if this entity has been counted
 
-        self._relations = {}
-
         # Add to context
         self.__class__._context.add(self)
 
@@ -439,62 +436,62 @@ class Entity:
         if stored_version != current_version:
             entity._save()
 
-        # Restore legacy "relations" block if present in serialized data.
-        # Otherwise keep the _relations that __init__ already populated
-        # via relationship descriptors (OneToMany, ManyToOne, etc.).
-        if "relations" in data:
-            relations_data = data.pop("relations")
-            relations = {}
-            for rel_name, rel_refs in relations_data.items():
-                relations[rel_name] = []
-                for ref in rel_refs:
-                    related = (
-                        Entity.db()
-                        ._entity_types[ref["_type"]]
-                        .load(ref["_id"], level=level - 1)
-                    )
-                    if related:
-                        relations[rel_name].append(related)
-            entity._relations = relations
-
         return entity
 
     @classmethod
     def find(cls: Type[T], d) -> List[T]:
-        D = d
-        L = [_.serialize() for _ in cls.instances()]
+        """Find entities matching a dictionary filter.
+
+        Uses load_some over the full ID range. Prefer indexed lookups where possible.
+        """
+        max_id = cls.max_id()
+        if max_id == 0:
+            return []
+        all_entities = cls.load_some(1, max_id)
         return [
-            cls.load(d["_id"]) for d in L if all(d.get(k) == v for k, v in D.items())
+            e
+            for e in all_entities
+            if all(getattr(e, k, None) == v for k, v in d.items())
         ]
 
     @classmethod
     def instances(cls: Type[T]) -> List[T]:
         """Get all instances of this entity type, including subclass instances.
 
-        Uses load_some() for O(max_id) performance instead of scanning all keys.
+        .. deprecated::
+            This method loads ALL entities and is O(max_id). Prefer load_some()
+            with pagination or use relationship accessors.
 
         Returns:
             List of entities
         """
+        try:
+            import warnings
+
+            warnings.warn(
+                "Entity.instances() is deprecated and will be removed. "
+                "Use load_some() with pagination instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        except (ImportError, AttributeError):
+            pass
         db = Database.get_instance()
         full_type_name = cls.get_full_type_name()
         db.register_entity_type(cls, full_type_name)
 
-        # Use load_some for O(max_id) instead of O(total_keys)
         max_id = cls.max_id()
         if max_id == 0:
             instances = []
         else:
             instances = cls.load_some(1, max_id)
 
-        # Also check for subclass instances
-        # Track processed classes to avoid duplicates when types are registered under multiple names
         processed_classes = {cls}
         for type_name, type_cls in db._entity_types.items():
             if type_cls in processed_classes:
-                continue  # Skip already processed classes
+                continue
             if type_name == full_type_name or type_name == cls.__name__:
-                continue  # Skip self
+                continue
             if db.is_subclass(type_name, cls):
                 processed_classes.add(type_cls)
                 subclass_max_id = type_cls.max_id()
@@ -572,10 +569,11 @@ class Entity:
         return ret
 
     def delete(self) -> None:
+        """Delete this entity from the database, cleaning up all reverse indexes."""
         logger.debug(f"Deleting entity {self._type}@{self._id}")
-        """Delete this entity from the database."""
         from .constants import ACTION_DELETE
         from .hooks import call_entity_hook
+        from .properties import ManyToMany, ManyToOne, OneToMany, OneToOne
 
         # Call hook before deletion
         allow, _ = call_entity_hook(self, None, self, None, ACTION_DELETE)
@@ -583,17 +581,74 @@ class Entity:
         if not allow:
             raise PermissionError("Hook rejected entity deletion")
 
-        self.db().delete(self._type, self._id)
+        db = self.db()
+
+        # Clean up reverse indexes for all relation properties
+        for cls in reversed(self.__class__.__mro__):
+            for attr_name, attr_value in cls.__dict__.items():
+                if attr_name.startswith("_"):
+                    continue
+                if isinstance(attr_value, ManyToOne):
+                    # Remove self from parent's reverse index
+                    parent_ref = self.__dict__.get(f"_rel_{attr_name}")
+                    if parent_ref is not None:
+                        for type_name in attr_value._get_allowed_types():
+                            entity_class = db._entity_types.get(type_name)
+                            if entity_class and db.load(type_name, parent_ref):
+                                db.reverse_index_remove(
+                                    type_name,
+                                    parent_ref,
+                                    attr_value.reverse_name,
+                                    self._id,
+                                )
+                                break
+                elif isinstance(attr_value, OneToOne):
+                    # Remove self from target's reverse index
+                    target_ref = self.__dict__.get(f"_rel_{attr_name}")
+                    if target_ref is not None:
+                        for type_name in attr_value._get_allowed_types():
+                            entity_class = db._entity_types.get(type_name)
+                            if entity_class and db.load(type_name, target_ref):
+                                db.reverse_index_remove(
+                                    type_name,
+                                    target_ref,
+                                    attr_value.reverse_name,
+                                    self._id,
+                                )
+                                break
+                    # Also delete any reverse index where self is parent (inverse side)
+                    db.reverse_index_delete(self._type, self._id, attr_name)
+                elif isinstance(attr_value, OneToMany):
+                    # Delete the reverse index entry for this parent
+                    db.reverse_index_delete(self._type, self._id, attr_name)
+                elif isinstance(attr_value, ManyToMany):
+                    # Remove self from each related entity's reverse index
+                    related_ids = db.reverse_index_get(self._type, self._id, attr_name)
+                    for related_id in related_ids:
+                        for type_name in attr_value._get_allowed_types():
+                            entity_class = db._entity_types.get(type_name)
+                            if entity_class and db.load(type_name, related_id):
+                                db.reverse_index_remove(
+                                    type_name,
+                                    related_id,
+                                    attr_value.reverse_name,
+                                    self._id,
+                                )
+                                break
+                    # Delete own index
+                    db.reverse_index_delete(self._type, self._id, attr_name)
+
+        db.delete(self._type, self._id)
 
         # Remove from entity registry
-        self.db().unregister_entity(self._type, self._id)
+        db.unregister_entity(self._type, self._id)
 
         # Decrement the count when an entity is deleted
         type_name = self.__class__.get_full_type_name()
         count_key = f"{type_name}_count"
-        current_count = int(self.db().load("_system", count_key) or 0)
+        current_count = int(db.load("_system", count_key) or 0)
         if current_count > 0:
-            self.db().save("_system", count_key, str(current_count - 1))
+            db.save("_system", count_key, str(current_count - 1))
         else:
             raise ValueError(
                 f"Entity count for {type_name} is already zero; cannot decrement further."
@@ -605,7 +660,7 @@ class Entity:
             if hasattr(self, alias_field):
                 alias_value = getattr(self, alias_field)
                 if alias_value is not None:
-                    self.db().delete(self._alias_key(), alias_value)
+                    db.delete(self._alias_key(), alias_value)
 
         logger.debug(f"Deleted entity {self._type}@{self._id}")
 
@@ -651,61 +706,73 @@ class Entity:
         return entity._id
 
     def _serialize_full(self) -> Dict[str, Any]:
-        """Full serialization including all relations. Used by _save() for persistence."""
+        """Full serialization including relation FK references. Used by _save()."""
         data = self._serialize_base()
 
-        from ic_python_db.properties import ManyToMany, OneToMany
-
-        for rel_name, rel_entities in self._relations.items():
-            if rel_entities:
-                rel_prop = getattr(self.__class__, rel_name, None)
-                is_to_many = isinstance(rel_prop, (OneToMany, ManyToMany))
+        from ic_python_db.properties import ManyToOne, OneToOne
 
-                if len(rel_entities) == 1 and not is_to_many:
-                    data[rel_name] = self._get_entity_reference(rel_entities[0])
-                else:
-                    data[rel_name] = [
-                        self._get_entity_reference(e) for e in rel_entities
-                    ]
+        for cls in reversed(self.__class__.__mro__):
+            for attr_name, attr_value in cls.__dict__.items():
+                if attr_name.startswith("_"):
+                    continue
+                if isinstance(attr_value, (ManyToOne, OneToOne)):
+                    ref = self.__dict__.get(f"_rel_{attr_name}")
+                    if ref is not None:
+                        data[attr_name] = ref
 
         return data
 
+    def _resolve_ref_with_alias(self, entity_id: str, allowed_types: list) -> str:
+        """Resolve an entity ID to its best reference (alias value or ID)."""
+        db = self.db()
+        for type_name in allowed_types:
+            entity_class = db._entity_types.get(type_name)
+            if entity_class:
+                entity = entity_class.load(entity_id)
+                if entity:
+                    return self._get_entity_reference(entity)
+        return entity_id
+
     def serialize(self) -> Dict[str, Any]:
         """Convert the entity to a portable serializable dictionary.
 
-        OneToMany relations are skipped (reconstructed from reverse ManyToOne).
-        For bilateral OneToOne relations, only the alphabetically-earlier entity
-        type serializes the reference, avoiding circular dependencies.
+        Includes: ManyToOne FK, owning-side OneToOne FK, ManyToMany entries.
+        Excludes: OneToMany (reconstructed from ManyToOne during import).
 
         Returns:
             Dict containing the entity's serializable data
         """
         data = self._serialize_base()
 
-        from ic_python_db.properties import ManyToMany, OneToMany, OneToOne
+        from ic_python_db.properties import ManyToMany, ManyToOne, OneToOne
 
-        for rel_name, rel_entities in self._relations.items():
-            if rel_entities:
-                rel_prop = getattr(self.__class__, rel_name, None)
+        db = self.db()
 
-                # Skip OneToMany — always reconstructed from reverse ManyToOne
-                if isinstance(rel_prop, OneToMany):
+        for cls in reversed(self.__class__.__mro__):
+            for attr_name, attr_value in cls.__dict__.items():
+                if attr_name.startswith("_"):
                     continue
-                # For OneToOne bilateral, only serialize on one deterministic side:
-                # the entity whose type name is alphabetically <= the target type.
-                if isinstance(rel_prop, OneToOne):
-                    target_type = rel_entities[0]._type if rel_entities else None
-                    if target_type and self._type > target_type:
-                        continue
-
-                is_to_many = isinstance(rel_prop, (OneToMany, ManyToMany))
-
-                if len(rel_entities) == 1 and not is_to_many:
-                    data[rel_name] = self._get_entity_reference(rel_entities[0])
-                else:
-                    data[rel_name] = [
-                        self._get_entity_reference(e) for e in rel_entities
-                    ]
+                if isinstance(attr_value, ManyToOne):
+                    ref = self.__dict__.get(f"_rel_{attr_name}")
+                    if ref is not None:
+                        data[attr_name] = self._resolve_ref_with_alias(
+                            ref, attr_value._get_allowed_types()
+                        )
+                elif isinstance(attr_value, OneToOne):
+                    ref = self.__dict__.get(f"_rel_{attr_name}")
+                    if ref is not None:
+                        data[attr_name] = self._resolve_ref_with_alias(
+                            ref, attr_value._get_allowed_types()
+                        )
+                elif isinstance(attr_value, ManyToMany):
+                    related_ids = db.reverse_index_get(self._type, self._id, attr_name)
+                    if related_ids:
+                        data[attr_name] = [
+                            self._resolve_ref_with_alias(
+                                rid, attr_value._get_allowed_types()
+                            )
+                            for rid in related_ids
+                        ]
 
         return data
 
@@ -970,70 +1037,3 @@ class Entity:
             Hash value
         """
         return hash((self._type, self._id))
-
-    def add_relation(self, from_rel: str, to_rel: str, other: "Entity") -> None:
-        """Add a bidirectional relationship with another entity.
-
-        Args:
-            from_rel: Name of relation from this entity to other
-            to_rel: Name of relation from other entity to this
-            other: Entity to create relationship with
-        """
-        # Add forward relation
-        if from_rel not in self._relations:
-            self._relations[from_rel] = []
-        if other not in self._relations[from_rel]:
-            self._relations[from_rel].append(other)
-
-        # Add reverse relation
-        if to_rel not in other._relations:
-            other._relations[to_rel] = []
-        if self not in other._relations[to_rel]:
-            other._relations[to_rel].append(self)
-
-        # Save both entities
-        self._save()
-        other._save()
-
-    def get_relations(
-        self, relation_name: str, entity_type: str = None
-    ) -> List["Entity"]:
-        """Get all related entities for a relation, optionally filtered by type.
-
-        Args:
-            relation_name: Name of the relation to follow
-            entity_type: Optional type name to filter entities by
-
-        Returns:
-            List of related entities
-        """
-        if relation_name not in self._relations:
-            return []
-
-        entities = self._relations[relation_name]
-        if entity_type:
-            entities = [e for e in entities if e._type == entity_type]
-
-        return entities
-
-    def remove_relation(self, from_rel: str, to_rel: str, other: "Entity") -> None:
-        """Remove a bidirectional relationship with another entity.
-
-        Args:
-            from_rel: Name of relation from this entity to other
-            to_rel: Name of relation from other entity to this
-            other: Entity to remove relationship with
-        """
-        # Remove forward relation
-        if from_rel in self._relations:
-            if other in self._relations[from_rel]:
-                self._relations[from_rel].remove(other)
-
-        # Remove reverse relation
-        if to_rel in other._relations:
-            if self in other._relations[to_rel]:
-                other._relations[to_rel].remove(self)
-
-        # Save both entities
-        self._save()
-        other._save()

ic_python_db/properties.py

@@ -1,28 +1,28 @@
-"""Property definitions for Entity classes."""
+"""Property definitions for Entity classes.
+
+Relation properties (ManyToOne, OneToMany, OneToOne, ManyToMany) use persisted
+reverse indexes in stable storage so that relationships can be resolved without
+scanning all entities.
+"""
 
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
     Generic,
-    Iterator,
     List,
     Optional,
     Type,
     TypeVar,
     Union,
-    overload,
 )
 
 if TYPE_CHECKING:
     from .entity import Entity
 
-# TypeVar for property value types
 T = TypeVar("T")
-# TypeVar for entity types in relations
 E = TypeVar("E", bound="Entity")
 
-# Prefix used for storing property values in entity __dict__
 PROPERTY_STORAGE_PREFIX = "prop"
 
 
@@ -30,13 +30,6 @@ class Property(Generic[T]):
     """Definition of an entity property.
 
     A generic descriptor class that provides type-safe property access.
-    The type parameter T indicates the type of value this property holds.
-
-    Attributes:
-        name: Name of the property
-        type: Type of the property (e.g. str, int)
-        default: Default value if not set
-        validator: Optional function to validate values
     """
 
     name: str
@@ -57,29 +50,19 @@ class Property(Generic[T]):
         self.validator = validator
 
     def __set_name__(self, owner: type, name: str) -> None:
-        """Set the property name when class is created."""
         self.name = name
 
-    @overload
-    def __get__(self, obj: None, objtype: Optional[type]) -> "Property[T]": ...
-
-    @overload
-    def __get__(self, obj: object, objtype: Optional[type]) -> Optional[T]: ...
-
     def __get__(
         self, obj: object, objtype: Optional[type] = None
     ) -> Union["Property[T]", Optional[T]]:
-        """Get the property value."""
         if obj is None:
-            return self
+            return self  # type: ignore[return-value]
         return obj.__dict__.get(f"_{PROPERTY_STORAGE_PREFIX}_{self.name}", self.default)
 
     def __set__(self, obj, value):
-        """Set the property value with type checking and validation."""
         from .constants import ACTION_CREATE, ACTION_MODIFY
         from .hooks import call_entity_hook
 
-        # Get old value and determine action
         old_value = obj.__dict__.get(
             f"_{PROPERTY_STORAGE_PREFIX}_{self.name}", self.default
         )
@@ -89,7 +72,6 @@ class Property(Generic[T]):
             else ACTION_MODIFY
         )
 
-        # Call hook before setting
         allow, modified_value = call_entity_hook(
             obj, self.name, old_value, value, action
         )
@@ -185,113 +167,47 @@ class Boolean(Property[bool]):
         super().__init__(name="", type=bool, default=default)
 
 
-class Relation(Generic[E]):
-    """Base property for defining and accessing relations.
+# ── Relation Properties ───────────────────────────────────────────────────────
 
-    This is the base class for all relation properties. It provides common functionality
-    for managing relationships between entities.
 
-    For one-to-one relationships (default), this property returns a single entity and
-    enforces single cardinality. For one-to-many or many-to-many relationships, it
-    returns a list of entities.
+class Relation(Generic[E]):
+    """Base class for relation properties.
 
-    The type parameter E indicates the type of related entity.
+    Provides shared utilities for resolving and validating related entities.
+    Subclasses implement specific relationship semantics using persisted
+    reverse indexes.
     """
 
     name: Optional[str]
     entity_types: Union[str, List[str]]
     reverse_name: Optional[str]
-    many: bool
 
     def __init__(
         self,
         entity_types: Union[str, List[str]],
         reverse_name: Optional[str] = None,
-        many: bool = False,
     ):
-        """Initialize relation property.
-
-        Args:
-            entity_types: Type names of related entities
-            reverse_name: Optional name for reverse relation
-            many: Whether this property can hold multiple entities (default: False)
-        """
         self.entity_types = entity_types
         self.name = None
         self.reverse_name = reverse_name
-        self.many = many
 
     def __set_name__(self, owner: type, name: str) -> None:
-        """Set the property name when class is created."""
         self.name = name
         if self.reverse_name is None:
             self.reverse_name = name
 
-    @overload
-    def __get__(self, obj: None, objtype: Optional[type]) -> "Relation[E]": ...
-
-    @overload
-    def __get__(
-        self, obj: object, objtype: Optional[type]
-    ) -> Union[Optional[E], List[E]]: ...
-
-    def __get__(
-        self, obj: object, objtype: Optional[type] = None
-    ) -> Union["Relation[E]", Optional[E], List[E]]:
-        """Get related entities."""
-        if obj is None:
-            return self
-        relations = obj.get_relations(self.name)
-        if not self.many:
-            # For single relationships, return the first entity or None
-            return relations[0] if relations else None
-        return relations
+    @property
+    def many(self) -> bool:
+        """Whether this relation holds multiple entities."""
+        return isinstance(self, (OneToMany, ManyToMany))
 
-    def __set__(self, obj, value):
-        """Set related entities.
-
-        Args:
-            value: For many=False: a single Entity instance
-                  For many=True: a list/tuple of Entity instances
-        """
-        if self.many:
-            if not isinstance(value, (list, tuple)):
-                raise TypeError(f"{self.name} requires a list or tuple of entities")
-            values_list = value
-        else:
-            values_list = [value]
-
-        # Get existing and new relations as sets
-        existing = set(obj.get_relations(self.name))
-        new = set(values_list)
-
-        # For one-to-many, check if entities have existing relations
-        if isinstance(self, OneToMany):
-            for entity in new:
-                existing_relations = entity.get_relations(self.reverse_name)
-                if existing_relations:
-                    old_relation = existing_relations[0]
-                    if old_relation != obj:
-                        # Remove the entity from the old relation's list
-                        old_relation._relations[self.name].remove(entity)
-                        # Remove the old relation from the entity's list
-                        entity._relations[self.reverse_name].remove(old_relation)
-
-        # Remove relations that are not in new set
-        to_remove = existing - new
-        for entity in to_remove:
-            obj.remove_relation(self.name, self.reverse_name, entity)
-
-        # Add relations that are not in existing set
-        to_add = new - existing
-        for entity in to_add:
-            obj.add_relation(self.name, self.reverse_name, entity)
+    def _get_allowed_types(self) -> List[str]:
+        if isinstance(self.entity_types, str):
+            return [self.entity_types]
+        return list(self.entity_types)
 
     def validate_entity(self, entity: Any) -> bool:
-        """Validate that an entity is of the correct type.
-
-        Handles both namespaced (e.g., "app::User") and non-namespaced (e.g., "User") types.
-        """
+        """Validate that an entity is of the correct type."""
         from .entity import Entity
 
         if entity is None:
@@ -299,17 +215,8 @@ class Relation(Generic[E]):
         if not isinstance(entity, Entity):
             raise TypeError(f"{self.name} must be set to Entity instances")
 
-        # Convert entity_types to list for uniform handling
-        allowed_types = (
-            [self.entity_types]
-            if isinstance(self.entity_types, str)
-            else self.entity_types
-        )
-
-        # Check if entity type matches any allowed type
-        # This handles both exact matches and namespace variations
+        allowed_types = self._get_allowed_types()
         if entity._type not in allowed_types:
-            # Also check if the class name matches (for backward compatibility)
             entity_class_name = (
                 entity._type.split("::")[-1] if "::" in entity._type else entity._type
             )
@@ -319,22 +226,13 @@ class Relation(Generic[E]):
             )
             if not type_matches:
                 raise TypeError(
-                    f"{self.name} must be set an Entity instance of any of the following types: {self.entity_types}, "
-                    f"but got type '{entity._type}'"
+                    f"{self.name} must be an Entity of type {self.entity_types}, "
+                    f"but got '{entity._type}'"
                 )
-
         return True
 
     def resolve_entity(self, obj: Any, value: Any) -> Optional[E]:
-        """Resolve a value to an Entity instance.
-
-        Args:
-            obj: The entity object that owns this relation
-            value: Can be an Entity instance, string ID, or string name/alias
-
-        Returns:
-            Entity instance or None
-        """
+        """Resolve a value (Entity, ID string, or alias) to an Entity instance."""
         from .entity import Entity
 
         if value is None:
@@ -344,23 +242,14 @@ class Relation(Generic[E]):
             return value  # type: ignore[return-value]
 
         if isinstance(value, (str, int)):
-            # Try to find entity by ID or name (alias) using each allowed entity type
-            entity_types = (
-                [self.entity_types]
-                if isinstance(self.entity_types, str)
-                else self.entity_types
-            )
-            for entity_type_name in entity_types:
-                # Get the entity class from the database registry
+            for entity_type_name in self._get_allowed_types():
                 entity_class = obj.db()._entity_types.get(entity_type_name)
-
                 if entity_class:
                     found_entity = entity_class[value]
                     if found_entity:
                         return found_entity
-
             raise ValueError(
-                f"No entity of types {self.entity_types} found with ID or name '{value}'"
+                f"No entity of type {self.entity_types} found with ID or name '{value}'"
             )
 
         raise TypeError(
@@ -368,114 +257,94 @@ class Relation(Generic[E]):
         )
 
 
-class RelationList(Generic[E]):
-    """Helper class for managing lists of related entities."""
-
-    def __init__(self, obj: Any, prop: "Relation[E]"):
-        self.obj = obj
-        self.prop = prop
-
-    def add(self, entity: Union[E, str, int]) -> None:
-        """Add a new relation."""
-        # Resolve entity (supports string ID/name)
-        resolved = self.prop.resolve_entity(self.obj, entity)
-
-        # Validate entity type using the base validate_entity method
-        self.prop.validate_entity(resolved)
-
-        # For one-to-many, check if entity already has a relation
-        if isinstance(self.prop, OneToMany):
-            existing_relations = resolved.get_relations(self.prop.reverse_name)
-            if existing_relations:
-                # Remove existing relation since it's one-to-many
-                old_relation = existing_relations[0]
-                # Remove the entity from the old relation's list
-                if old_relation != self.obj:
-                    old_relation._relations[self.prop.name].remove(resolved)
-                    # Remove the old relation from the entity's list
-                    resolved._relations[self.prop.reverse_name].remove(old_relation)
-
-        self.obj.add_relation(self.prop.name, self.prop.reverse_name, resolved)
-
-    def remove(self, entity: Union[E, str, int]) -> None:
-        """Remove a relation."""
-        self.obj.remove_relation(self.prop.name, self.prop.reverse_name, entity)
-
-    def __iter__(self) -> "Iterator[E]":
-        return iter(self.obj.get_relations(self.prop.name))
-
-    def __len__(self) -> int:
-        return len(self.obj.get_relations(self.prop.name))
-
-
-class OneToOne(Relation[E]):
-    """Property for defining one-to-one relationships.
+class ManyToOne(Relation[E]):
+    """Many-to-one relationship (child stores FK to parent).
 
-    This property type represents a one-to-one relationship where each entity
-    can be related to exactly one entity on the other side.
+    This is the "owning" side. Setting this property:
+    - Stores the parent's ID on the child entity
+    - Updates the parent's reverse index so it can find this child
 
     Example:
-        class Person(Entity):
-            profile = OneToOne('Profile', 'person')
+        class Employee(Entity):
+            department = ManyToOne('Department', 'employees')
 
-        class Profile(Entity):
-            person = OneToOne('Person', 'profile')
+        class Department(Entity):
+            employees = OneToMany('Employee', 'department')
     """
 
     def __init__(
-        self,
-        entity_types: Union[str, List[str]],
-        reverse_name: Optional[str] = None,
+        self, entity_types: Union[str, List[str]], reverse_name: Optional[str] = None
     ):
-        super().__init__(entity_types, reverse_name, many=False)
+        super().__init__(entity_types, reverse_name)
+
+    def __get__(
+        self, obj: object, objtype: Optional[type] = None
+    ) -> Union["ManyToOne[E]", Optional[E]]:
+        if obj is None:
+            return self  # type: ignore[return-value]
+        parent_ref = obj.__dict__.get(f"_rel_{self.name}")
+        if parent_ref is None:
+            return None
+        for type_name in self._get_allowed_types():
+            entity_class = obj.db()._entity_types.get(type_name)
+            if entity_class:
+                entity = entity_class.load(parent_ref)
+                if entity:
+                    return entity  # type: ignore[return-value]
+        return None
 
     def __set__(self, obj, value):
-        """Set the related entity with one-to-one constraints."""
+        from .db_engine import Database
+        from .entity import Entity
+
+        # Fast path: loading from DB — just store the raw reference, indexes are intact
+        if getattr(obj, "_do_not_save", False) and getattr(obj, "_loaded", False):
+            if value is None:
+                obj.__dict__[f"_rel_{self.name}"] = None
+            elif isinstance(value, Entity):
+                obj.__dict__[f"_rel_{self.name}"] = value._id
+            else:
+                obj.__dict__[f"_rel_{self.name}"] = str(value)
+            return
+
         if value is not None:
-            # Check if trying to set multiple values
             if isinstance(value, (list, tuple)):
                 raise ValueError(
-                    f"{self.name} cannot be set to multiple values (one-to-one relationship)"
+                    f"{self.name} cannot be set to multiple values (many-to-one)"
                 )
-
-            # Validate entity type
             value = self.resolve_entity(obj, value)
+            self.validate_entity(value)
 
-            # Check that the reverse property is OneToOne
-            reverse_prop = value.__class__.__dict__.get(self.reverse_name)
-            if not isinstance(reverse_prop, OneToOne):
-                raise ValueError(
-                    f"Reverse property '{self.reverse_name}' must be OneToOne"
-                )
+        db = Database.get_instance()
+        old_ref = obj.__dict__.get(f"_rel_{self.name}")
 
-            # Get current value if any
-            current = self.__get__(obj)
-            if current is value:
-                return
-            if current is not None:
-                # Remove existing relation
-                obj.remove_relation(self.name, self.reverse_name, current)
+        # Remove from old parent's reverse index
+        if old_ref is not None and obj._id is not None:
+            for type_name in self._get_allowed_types():
+                entity_class = db._entity_types.get(type_name)
+                if entity_class and db.load(type_name, old_ref):
+                    db.reverse_index_remove(
+                        type_name, old_ref, self.reverse_name, obj._id
+                    )
+                    break
 
-            # Check if value is already related to another entity and remove that relation
-            existing = value.get_relations(self.reverse_name)
-            if existing:
-                existing_entity = existing[0]
-                if existing_entity is obj:
-                    return
-                # Remove the existing relation from both sides
-                existing_entity.remove_relation(self.name, self.reverse_name, value)
-                value.remove_relation(self.reverse_name, self.name, existing_entity)
+        # Set new reference
+        if value is not None:
+            obj.__dict__[f"_rel_{self.name}"] = value._id
+            if obj._id is not None:
+                db.reverse_index_add(value._type, value._id, self.reverse_name, obj._id)
+        else:
+            obj.__dict__[f"_rel_{self.name}"] = None
 
-        # Set the new relation
-        super().__set__(obj, value)
+        if not obj._do_not_save:
+            obj._save()
 
 
 class OneToMany(Relation[E]):
-    """Property for defining one-to-many relationships.
+    """One-to-many relationship (parent side, resolved via reverse index).
 
-    This property type represents a one-to-many relationship where the 'one' side
-    owns multiple instances of the 'many' side, but each 'many' instance belongs to
-    only one owner.
+    Accessing this property reads the persisted reverse index to find child
+    IDs, then loads each child. No scanning required.
 
     Example:
         class Department(Entity):
@@ -486,102 +355,181 @@ class OneToMany(Relation[E]):
     """
 
     def __init__(self, entity_types: Union[str, List[str]], reverse_name: str):
-        super().__init__(entity_types, reverse_name, many=True)
+        super().__init__(entity_types, reverse_name)
 
-    def __set__(self, obj, values):
-        """Set related entities with one-to-many constraints."""
-        if not isinstance(values, (list, tuple)):
-            raise TypeError(f"{self.name} must be set to a list of entities")
-
-        resolved_values = []
-        for value in values:
-            # Resolve value to Entity instance
-            resolved_value = self.resolve_entity(obj, value)
-
-            # Validate entity type using the base validate_entity method
-            self.validate_entity(resolved_value)
-            resolved_values.append(resolved_value)
-
-            # Check that the reverse property is ManyToOne
-            reverse_prop = resolved_value.__class__.__dict__.get(self.reverse_name)
-            if not isinstance(reverse_prop, ManyToOne):
-                raise ValueError(
-                    f"Reverse property '{self.reverse_name}' must be ManyToOne"
-                )
+    def __get__(
+        self, obj: object, objtype: Optional[type] = None
+    ) -> Union["OneToMany[E]", List[E]]:
+        if obj is None:
+            return self  # type: ignore[return-value]
 
-        # Replace original values with resolved entities
-        super().__set__(obj, resolved_values)
+        from .db_engine import Database
 
-    @overload
-    def __get__(self, obj: None, objtype: Optional[type]) -> "OneToMany[E]": ...
+        db = Database.get_instance()
+        child_ids = db.reverse_index_get(obj._type, obj._id, self.name)
 
-    @overload
-    def __get__(self, obj: object, objtype: Optional[type]) -> "RelationList[E]": ...
+        children = []
+        for child_id in child_ids:
+            for type_name in self._get_allowed_types():
+                entity_class = db._entity_types.get(type_name)
+                if entity_class:
+                    child = entity_class.load(child_id)
+                    if child:
+                        children.append(child)
+                        break
+        return children  # type: ignore[return-value]
 
-    def __get__(
-        self, obj: object, objtype: Optional[type] = None
-    ) -> Union["OneToMany[E]", "RelationList[E]"]:
-        """Get related entities as a RelationList."""
-        if obj is None:
-            return self
-        return RelationList(obj, self)
+    def __set__(self, obj, values):
+        raise AttributeError(
+            f"Cannot set OneToMany '{self.name}' directly. "
+            f"Set the ManyToOne '{self.reverse_name}' on each child instead."
+        )
 
 
-class ManyToOne(Relation[E]):
-    """Property for defining many-to-one relationships.
+class OneToOne(Relation[E]):
+    """One-to-one relationship.
 
-    This property type represents a many-to-one relationship where multiple entities
-    can belong to a single owner entity.
+    The "owning" side stores the FK and updates the reverse index.
+    The "inverse" side resolves via the reverse index.
 
     Example:
-        class Employee(Entity):
-            department = ManyToOne('Department', 'employees')
+        class Person(Entity):
+            profile = OneToOne('Profile', 'person')
 
-        class Department(Entity):
-            employees = OneToMany('Employee', 'department')
+        class Profile(Entity):
+            person = OneToOne('Person', 'profile')
     """
 
     def __init__(
-        self, entity_types: Union[str, List[str]], reverse_name: Optional[str] = None
+        self,
+        entity_types: Union[str, List[str]],
+        reverse_name: Optional[str] = None,
     ):
-        super().__init__(entity_types, reverse_name, many=False)
+        super().__init__(entity_types, reverse_name)
+
+    def __get__(
+        self, obj: object, objtype: Optional[type] = None
+    ) -> Union["OneToOne[E]", Optional[E]]:
+        if obj is None:
+            return self  # type: ignore[return-value]
+
+        from .db_engine import Database
+
+        # Check if this side stores the FK (owning side)
+        local_ref = obj.__dict__.get(f"_rel_{self.name}")
+        if local_ref is not None:
+            for type_name in self._get_allowed_types():
+                entity_class = obj.db()._entity_types.get(type_name)
+                if entity_class:
+                    entity = entity_class.load(local_ref)
+                    if entity:
+                        return entity  # type: ignore[return-value]
+            return None
+
+        # Inverse side: check reverse index
+        db = Database.get_instance()
+        child_ids = db.reverse_index_get(obj._type, obj._id, self.name)
+        if child_ids:
+            for type_name in self._get_allowed_types():
+                entity_class = db._entity_types.get(type_name)
+                if entity_class:
+                    entity = entity_class.load(child_ids[0])
+                    if entity:
+                        return entity  # type: ignore[return-value]
+        return None
 
     def __set__(self, obj, value):
-        """Set the related entity with many-to-one constraints."""
+        from .db_engine import Database
+        from .entity import Entity
+
+        # Fast path: loading from DB — just store the raw reference, indexes are intact
+        if getattr(obj, "_do_not_save", False) and getattr(obj, "_loaded", False):
+            if value is None:
+                obj.__dict__[f"_rel_{self.name}"] = None
+            elif isinstance(value, Entity):
+                obj.__dict__[f"_rel_{self.name}"] = value._id
+            else:
+                obj.__dict__[f"_rel_{self.name}"] = str(value)
+            return
+
         if value is not None:
-            # Check if trying to set multiple values
             if isinstance(value, (list, tuple)):
                 raise ValueError(
-                    f"{self.name} cannot be set to multiple values (many-to-one relationship)"
+                    f"{self.name} cannot be set to multiple values (one-to-one)"
                 )
-
-            # Resolve value to Entity instance
             value = self.resolve_entity(obj, value)
-
-            # Validate entity type using the base validate_entity method
             self.validate_entity(value)
 
-            # Check that the reverse property is OneToMany
-            # Use getattr to walk MRO so inherited relations are found
-            reverse_prop = getattr(value.__class__, self.reverse_name, None)
-            if not reverse_prop:
-                raise ValueError(
-                    f"Reverse property '{self.reverse_name}' not found in {value.__class__.__name__} entity"
-                )
+        db = Database.get_instance()
+        old_ref = obj.__dict__.get(f"_rel_{self.name}")
 
-            if not isinstance(reverse_prop, OneToMany):
-                raise ValueError(
-                    f"Reverse property '{self.reverse_name}' must be OneToMany and it is '{reverse_prop.__class__.__name__}'"
+        # Remove from old target's reverse index
+        if old_ref is not None and obj._id is not None:
+            for type_name in self._get_allowed_types():
+                entity_class = db._entity_types.get(type_name)
+                if entity_class and db.load(type_name, old_ref):
+                    db.reverse_index_remove(
+                        type_name, old_ref, self.reverse_name, obj._id
+                    )
+                    break
+
+        # Enforce OneToOne exclusivity: if the target entity already has a direct
+        # FK on the reverse relation pointing to a different entity, clear it.
+        if value is not None:
+            existing_on_target = value.__dict__.get(f"_rel_{self.reverse_name}")
+            if existing_on_target is not None and existing_on_target != obj._id:
+                # The target already links to someone else via reverse relation.
+                # Clear that link and its reverse index entry.
+                db.reverse_index_remove(
+                    obj._type, existing_on_target, self.name, value._id
                 )
+                value.__dict__[f"_rel_{self.reverse_name}"] = None
+                value._save()
+
+            # Also check if obj was previously linked via reverse index (inverse side)
+            # e.g., if someone else set "other.rel = obj" previously
+            existing_in_ri = db.reverse_index_get(obj._type, obj._id, self.name)
+            for old_other_id in existing_in_ri:
+                if old_other_id != value._id:
+                    db.reverse_index_remove(obj._type, obj._id, self.name, old_other_id)
+                    # Clear the other entity's direct FK
+                    for tn in self._get_allowed_types():
+                        ec = db._entity_types.get(tn)
+                        if ec:
+                            other_entity = ec.load(old_other_id)
+                            if (
+                                other_entity
+                                and other_entity.__dict__.get(
+                                    f"_rel_{self.reverse_name}"
+                                )
+                                == obj._id
+                            ):
+                                other_entity.__dict__[f"_rel_{self.reverse_name}"] = (
+                                    None
+                                )
+                                other_entity._save()
+                                break
+
+        # Set new reference
+        if value is not None:
+            obj.__dict__[f"_rel_{self.name}"] = value._id
+            if obj._id is not None:
+                db.reverse_index_add(value._type, value._id, self.reverse_name, obj._id)
+        else:
+            obj.__dict__[f"_rel_{self.name}"] = None
+            # Also clear any reverse index entries pointing at obj for this relation
+            existing_in_ri = db.reverse_index_get(obj._type, obj._id, self.name)
+            for old_other_id in existing_in_ri:
+                db.reverse_index_remove(obj._type, obj._id, self.name, old_other_id)
 
-        super().__set__(obj, value)
+        if not obj._do_not_save:
+            obj._save()
 
 
 class ManyToMany(Relation[E]):
-    """Property for defining many-to-many relationships.
+    """Many-to-many relationship with bidirectional reverse indexes.
 
-    This property type represents a many-to-many relationship where entities
-    on both sides can be related to multiple entities on the other side.
+    Both sides maintain a reverse index. Setting on either side updates both.
 
     Example:
         class Student(Entity):
@@ -592,53 +540,67 @@ class ManyToMany(Relation[E]):
     """
 
     def __init__(self, entity_types: Union[str, List[str]], reverse_name: str):
-        super().__init__(entity_types, reverse_name, many=True)
+        super().__init__(entity_types, reverse_name)
+
+    def __get__(
+        self, obj: object, objtype: Optional[type] = None
+    ) -> Union["ManyToMany[E]", List[E]]:
+        if obj is None:
+            return self  # type: ignore[return-value]
+
+        from .db_engine import Database
+
+        db = Database.get_instance()
+        related_ids = db.reverse_index_get(obj._type, obj._id, self.name)
+
+        entities = []
+        for related_id in related_ids:
+            for type_name in self._get_allowed_types():
+                entity_class = db._entity_types.get(type_name)
+                if entity_class:
+                    entity = entity_class.load(related_id)
+                    if entity:
+                        entities.append(entity)
+                        break
+        return entities  # type: ignore[return-value]
 
     def __set__(self, obj, values):
-        """Set related entities with many-to-many constraints."""
+        from .db_engine import Database
         from .entity import Entity
 
-        # Convert single entity to list for convenience
+        if values is None:
+            values = []
         if isinstance(values, Entity):
             values = [values]
         elif isinstance(values, (str, int)):
-            # Handle single string ID/name
             values = [values]
-        elif values is not None and not isinstance(values, (list, tuple)):
+        elif not isinstance(values, (list, tuple)):
             raise TypeError(f"{self.name} must be set to an entity or list of entities")
 
-        if values is not None:
-            resolved_values = []
-            for value in values:
-                # Resolve value to Entity instance
-                resolved_value = self.resolve_entity(obj, value)
-
-                # Validate entity type using the base validate_entity method
-                self.validate_entity(resolved_value)
-                resolved_values.append(resolved_value)
-
-                # Check that the reverse property is ManyToMany
-                reverse_prop = resolved_value.__class__.__dict__.get(self.reverse_name)
-                if not isinstance(reverse_prop, ManyToMany):
-                    raise ValueError(
-                        f"Reverse property '{self.reverse_name}' must be ManyToMany"
+        resolved = []
+        for v in values:
+            entity = self.resolve_entity(obj, v)
+            self.validate_entity(entity)
+            resolved.append(entity)
+
+        db = Database.get_instance()
+
+        # Remove old relations from both sides' indexes
+        old_ids = db.reverse_index_get(obj._type, obj._id, self.name)
+        for old_id in old_ids:
+            db.reverse_index_remove(obj._type, obj._id, self.name, old_id)
+            for type_name in self._get_allowed_types():
+                entity_class = db._entity_types.get(type_name)
+                if entity_class and db.load(type_name, old_id):
+                    db.reverse_index_remove(
+                        type_name, old_id, self.reverse_name, obj._id
                     )
+                    break
 
-            # Replace original values with resolved entities
-            values = resolved_values
-
-        super().__set__(obj, values)
-
-    @overload
-    def __get__(self, obj: None, objtype: Optional[type]) -> "ManyToMany[E]": ...
-
-    @overload
-    def __get__(self, obj: object, objtype: Optional[type]) -> "RelationList[E]": ...
+        # Add new relations to both sides' indexes
+        for entity in resolved:
+            db.reverse_index_add(obj._type, obj._id, self.name, entity._id)
+            db.reverse_index_add(entity._type, entity._id, self.reverse_name, obj._id)
 
-    def __get__(
-        self, obj: object, objtype: Optional[type] = None
-    ) -> Union["ManyToMany[E]", "RelationList[E]"]:
-        """Get related entities as a RelationList."""
-        if obj is None:
-            return self
-        return RelationList(obj, self)
+        if not obj._do_not_save:
+            obj._save()

{ic_python_db-0.8.2.dist-info → ic_python_db-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ic-python-db
-Version: 0.8.2
+Version: 0.9.0
 Summary: A lightweight key-value database written in Python, intended for use on the Internet Computer (IC)
 Home-page: https://github.com/smart-social-contracts/ic-python-db
 Author: Smart Social Contracts

{ic_python_db-0.8.2.dist-info → ic_python_db-0.9.0.dist-info}/RECORD

@@ -1,18 +1,18 @@
-ic_python_db/__init__.py,sha256=ImQQTAjHTT7UEqYwhySPAijIU0jJHEjn53QH7W54Ddk,989
+ic_python_db/__init__.py,sha256=qHr8h3FfgYJ1S5P7R7ZQBbEG94J3IDsrGPJj7Z-2-lg,989
 ic_python_db/_cdk.py,sha256=zTj8HzXUcPz8R73nh5bo6JMkCorp-KSW1hDutzi5LZs,387
 ic_python_db/constants.py,sha256=oLvKJev-65gXFd284DdYutWBX95sTF5Xkikc6IC4mhM,118
 ic_python_db/context.py,sha256=97F4_EAJm3adOnUfh0SaDisX3nc7F2vFIZwZUsUAy58,1080
-ic_python_db/db_engine.py,sha256=YeekQT7gSVSKlXkVS7cnwEpFibPMuzgIOGLxk2la734,13560
-ic_python_db/entity.py,sha256=LSlFYDvQoLnn1DQWpsgzlJ6MK5cPLGCEHiV5UsRge-4,40054
+ic_python_db/db_engine.py,sha256=jPJsqBPKT5omk43fODzXsR58ZY9BVTuZKo-4qW-tbdk,16022
+ic_python_db/entity.py,sha256=jzQczj0jMqOYwDkPx5sd4Z85vdd9i8GS9UnT6_HfYxc,40997
 ic_python_db/hooks.py,sha256=B1wV18dAMH-PootSripmMpG9Cr9M3W3lcNEF7QvPrL4,1620
 ic_python_db/mixins.py,sha256=qZmb3ssXYf2NSjHJtgmdsOlkIJdouDjPHdQ9tZmrZi8,1937
-ic_python_db/properties.py,sha256=f2_ugxToz5QIXRL6EukneQmXZBu-wbIrio0zlVqdme0,22632
+ic_python_db/properties.py,sha256=U_NpybwIIi_tJf9n1Aayl7dXfyKqPCMn1j2ujj_RcK8,21497
 ic_python_db/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ic_python_db/schema.py,sha256=zCfrlYQlSvfhBuUfDLup9uPW_OyqJKZs5qMg1RzaINM,16142
 ic_python_db/storage.py,sha256=2F6m_01g2jwoF40s4BrdO2SffJNSO3gPf0QU3Co7T5Y,1873
 ic_python_db/system_time.py,sha256=xrx8NfjLXCGsac3hUpuvsNwCH91tQ9jfH4N-XFo8iJk,2614
-ic_python_db-0.8.2.dist-info/licenses/LICENSE,sha256=6q6XYNOGnJcVSus2bAezFn7bU_2Y5T6W4aGQHBb8X-c,1079
-ic_python_db-0.8.2.dist-info/METADATA,sha256=mos6F5JJwuVBnHHGINkP-ru95mRZWIknQjKMsI0Zzd0,15130
-ic_python_db-0.8.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-ic_python_db-0.8.2.dist-info/top_level.txt,sha256=ZaOTqhWKtJQEuXmqR920AqbDBAqv1mvsKj3TClWimDk,13
-ic_python_db-0.8.2.dist-info/RECORD,,
+ic_python_db-0.9.0.dist-info/licenses/LICENSE,sha256=6q6XYNOGnJcVSus2bAezFn7bU_2Y5T6W4aGQHBb8X-c,1079
+ic_python_db-0.9.0.dist-info/METADATA,sha256=xzdjbQH3GiCH2BzIDDYFPXG5R1nZCAV48OVlnqlpv-M,15130
+ic_python_db-0.9.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ic_python_db-0.9.0.dist-info/top_level.txt,sha256=ZaOTqhWKtJQEuXmqR920AqbDBAqv1mvsKj3TClWimDk,13
+ic_python_db-0.9.0.dist-info/RECORD,,