ic-python-db 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

ic_python_db/__init__.py

@@ -5,6 +5,7 @@ IC Python DB - A lightweight key-value database with entity relationships and au
 from .constants import ACTION_CREATE, ACTION_DELETE, ACTION_MODIFY
 from .db_engine import Database
 from .entity import Entity
+from .errors import TooLargeError
 from .mixins import TimestampedMixin
 from .properties import (
     Boolean,
@@ -14,13 +15,14 @@ from .properties import (
     ManyToOne,
     OneToMany,
     OneToOne,
+    RelationView,
     String,
 )
 from .schema import SchemaIncompatibleError, build_schema, diff_schemas, schema_hash
 from .storage import MemoryStorage, Storage
 from .system_time import SystemTime
 
-__version__ = "0.12.0"
+__version__ = "0.13.0"
 __all__ = [
     "Database",
     "Entity",
@@ -40,6 +42,8 @@ __all__ = [
     "ACTION_MODIFY",
     "ACTION_DELETE",
     "SchemaIncompatibleError",
+    "TooLargeError",
+    "RelationView",
     "build_schema",
     "diff_schemas",
     "schema_hash",

ic_python_db/constants.py

@@ -4,3 +4,8 @@ LEVEL_MAX_DEFAULT = 3
 ACTION_CREATE = "create"
 ACTION_MODIFY = "modify"
 ACTION_DELETE = "delete"
+
+# Largest collection an unpaged operation (iterating a relation, instances())
+# loads in one call; past it they raise TooLargeError. At about 1M
+# instructions per load this stays well inside a query's 5B budget.
+MAX_UNPAGED = 1000

ic_python_db/db_engine.py

@@ -2,18 +2,34 @@
 Core database engine implementation
 """
 
+import hashlib
 import json
+import sys
 import time
 import weakref
 from typing import Any, Dict, List, Optional, Tuple
 
 from ic_python_logging import get_logger
 
-from .storage import MemoryStorage, Storage, supports_range
+from ._cdk import ic
+from .storage import MemoryStorage, Storage, storage_sort_key, supports_range
 
 logger = get_logger(__name__)
 
 _DIGITS = frozenset("0123456789")
+_HEX = frozenset("0123456789abcdef")
+# Posting-list entry suffix widths (see "Posting lists" below)
+_ID_WIDTH = 12
+_HASH_WIDTH = 24
+_SCAN_PAGE = 500
+_BUCKETS = (("n", _ID_WIDTH, ":"), ("h", _HASH_WIDTH, "g"))
+# Purge queue of deleted index sets (see _ix_clear): fixed-width positions
+# keep its entries contiguous in key order
+_PQ = "_pq@"
+_PQ_HEAD = "_pq:head"
+_PQ_TAIL = "_pq:tail"
+# Entries of deleted sets each index write removes on the side
+_PURGE_PER_WRITE = 20
 
 
 def _is_sequential_id(id_str: str) -> bool:
@@ -45,6 +61,17 @@ def _next_sequential_id(id_str: str, digits: int) -> Optional[int]:
     return max(int(candidate), 10 ** (digits - 1))
 
 
+def _message_time() -> Optional[int]:
+    """The IC's time, which is the same throughout one message; None outside
+    a canister, where the identity map's weak references do the job."""
+    if sys.platform != "wasi" or ic is None:
+        return None
+    try:
+        return ic.time()
+    except Exception:
+        return None
+
+
 class Database:
     """Main database class providing high-level operations"""
 
@@ -96,8 +123,15 @@ class Database:
             )
 
         self._entity_types = {}
-        # Entity registry: {(type_name, entity_id): weakref to entity instance}
-        self._entity_registry = {}
+        # Identity map: {(type_name, entity_id): entity}. Weak, so an entity
+        # lives only as long as some caller holds it, and its entry goes with it.
+        self._entity_registry = weakref.WeakValueDictionary()
+        # In a canister weakref is a stub that holds strong references, so the
+        # map is also emptied when a new message starts (see _registry)
+        self._registry_time: Optional[int] = None
+        # Whether deleted index sets may still have entries to purge (None:
+        # not checked yet). Kept in the heap: a query discards it with its writes.
+        self._purge_pending = None
 
     def as_user(self, user_id: str):
         """Context manager for running operations as a specific user.
@@ -136,6 +170,7 @@ class Database:
 
         # Also clear the entity registry
         self.clear_registry()
+        self._purge_pending = None
 
         if not self._db_audit:
             return
@@ -147,24 +182,28 @@ class Database:
         self._db_audit.insert("_min_id", "0")
         self._db_audit.insert("_max_id", "0")
 
+    def _registry(self):
+        """The identity map, emptied when a new message starts.
+
+        ic.time() is constant within one message, so a new value means the
+        previous message is over: its entities are dropped from the map
+        instead of piling up until the next upgrade. An entity some code
+        still holds stays usable, but loading its id gives a new instance.
+        """
+        now = _message_time()
+        if now is not None and now != self._registry_time:
+            self._entity_registry.clear()
+            self._registry_time = now
+        return self._entity_registry
+
     def register_entity(self, entity_instance):
         """Register an entity instance in the identity map."""
         key = (entity_instance._type, entity_instance._id)
-        # Use weak reference to allow garbage collection
-        self._entity_registry[key] = weakref.ref(entity_instance)
+        self._registry()[key] = entity_instance
 
     def get_entity(self, type_name: str, entity_id: str):
         """Get entity from registry if it exists."""
-        key = (type_name, entity_id)
-        if key in self._entity_registry:
-            entity_ref = self._entity_registry[key]
-            entity = entity_ref()  # Get object from weak reference
-            if entity is not None:
-                return entity
-            else:
-                # Clean up dead reference
-                del self._entity_registry[key]
-        return None
+        return self._registry().get((type_name, entity_id))
 
     def clear_registry(self):
         """Clear the entity registry (useful for testing)."""
@@ -172,9 +211,7 @@ class Database:
 
     def unregister_entity(self, type_name: str, entity_id: str):
         """Remove an entity from the registry (used when deleting)."""
-        key = (type_name, entity_id)
-        if key in self._entity_registry:
-            del self._entity_registry[key]
+        self._registry().pop((type_name, entity_id), None)
 
     def _audit(self, op: str, key: str, data: Any) -> None:
         if self._db_audit and self._audit_enabled:
@@ -493,13 +530,231 @@ class Database:
 
         return check_upgrade_compatibility(self, raise_on_error=raise_on_error)
 
+    # ── Posting lists (issue #18) ──────────────────────────────────────────────
+    #
+    # Field indexes and reverse indexes map one base key to a set of entity
+    # ids. Each id is its own storage entry, so adding or removing one costs
+    # O(1) storage operations however many ids share the base, and a page is
+    # one range read:
+    #
+    #   {base}|n{id zero-padded to _ID_WIDTH}  -> id   canonical sequential ids
+    #   {base}|h{sha256(id)[:_HASH_WIDTH]}     -> id   any other id
+    #   {base}|c                               -> number of ids
+    #
+    # Storage orders str keys by length, then bytewise (storage_sort_key), so
+    # fixed-width suffixes keep one base's entries contiguous, and the "n"
+    # entries come back in ascending numeric id order.
+    #
+    # Before 0.13 a base key held the whole set as one JSON array, which hit
+    # the value-size limit at ~10k ids. Such an array is converted to entries
+    # the first time its base is touched (see _ix_count).
+
+    def _scan(self, start: str, end: str, limit: int) -> List[Tuple[str, str]]:
+        if supports_range(self._db_storage):
+            return self._db_storage.range(start, end, limit)
+        lo, hi = storage_sort_key(start), storage_sort_key(end)
+        keys = sorted(
+            (k for k in self._db_storage.keys() if lo <= storage_sort_key(k) < hi),
+            key=storage_sort_key,
+        )
+        return [(k, self._db_storage.get(k)) for k in keys[:limit]]
+
+    @staticmethod
+    def _ix_entry_key(base: str, entity_id: str) -> str:
+        if _is_sequential_id(entity_id) and len(entity_id) <= _ID_WIDTH:
+            return f"{base}|n{entity_id.zfill(_ID_WIDTH)}"
+        digest = hashlib.sha256(entity_id.encode("utf-8")).hexdigest()
+        return f"{base}|h{digest[:_HASH_WIDTH]}"
+
+    def _ix_count(self, base: str) -> int:
+        raw = self._db_storage.get(f"{base}|c")
+        if raw is not None:
+            return int(raw)
+        legacy = self._db_storage.get(base)
+        if legacy is None:
+            return 0
+        try:
+            ids = json.loads(legacy)
+        except ValueError:
+            return 0
+        if not isinstance(ids, list):
+            return 0
+        self._db_storage.remove(base)
+        unique = {str(i) for i in ids}
+        for entity_id in unique:
+            self._db_storage.insert(self._ix_entry_key(base, entity_id), entity_id)
+        if unique:
+            self._db_storage.insert(f"{base}|c", str(len(unique)))
+        return len(unique)
+
+    def _ix_add(self, base: str, entity_id: str) -> None:
+        self._purge_some()
+        count = self._ix_count(base)
+        if count == 0:
+            self._ix_revive(base)
+        key = self._ix_entry_key(base, entity_id)
+        if self._db_storage.get(key) is not None:
+            return
+        self._db_storage.insert(key, entity_id)
+        self._db_storage.insert(f"{base}|c", str(count + 1))
+
+    def _ix_remove(self, base: str, entity_id: str) -> None:
+        self._purge_some()
+        count = self._ix_count(base)
+        if count == 0:
+            return
+        key = self._ix_entry_key(base, entity_id)
+        if self._db_storage.get(key) is None:
+            return
+        self._db_storage.remove(key)
+        if count > 1:
+            self._db_storage.insert(f"{base}|c", str(count - 1))
+        else:
+            self._db_storage.remove(f"{base}|c")
+
+    def _ix_contains(self, base: str, entity_id: str) -> bool:
+        if self._ix_count(base) == 0:
+            return False
+        return self._db_storage.get(self._ix_entry_key(base, entity_id)) is not None
+
+    def _ix_page(self, base: str, from_id: int, count: int) -> List[str]:
+        """Up to ``count`` sequential ids >= ``from_id``, ascending."""
+        if from_id < 1:
+            raise ValueError("from_id must be at least 1")
+        if count < 1:
+            raise ValueError("count must be at least 1")
+        if self._ix_count(base) == 0 or len(str(from_id)) > _ID_WIDTH:
+            return []
+        start = f"{base}|n{str(from_id).zfill(_ID_WIDTH)}"
+        end = f"{base}|n{':' * _ID_WIDTH}"
+        cut = len(base) + 2
+        # A key of another base can fall inside the range only if its suffix
+        # is not all digits (e.g. value "x|n0;..." next to value "x").
+        return [
+            value
+            for key, value in self._scan(start, end, count)
+            if all(c in _DIGITS for c in key[cut:])
+        ]
+
+    def _ix_bucket(
+        self, base: str, tag: str, width: int, top: str, page_size: int = _SCAN_PAGE
+    ):
+        start = f"{base}|{tag}{'0' * width}"
+        end = f"{base}|{tag}{top * width}"
+        cut = len(base) + 2
+        valid = _DIGITS if tag == "n" else _HEX
+        while True:
+            page = self._scan(start, end, page_size)
+            for key, value in page:
+                if all(c in valid for c in key[cut:]):
+                    yield key, value
+            if len(page) < page_size:
+                return
+            # Smallest same-length key after the last one: append the lowest
+            # char and drop the last, i.e. bump by one in the key order.
+            last = page[-1][0]
+            start = last[:-1] + chr(ord(last[-1]) + 1)
+
+    def _ix_all(self, base: str) -> List[str]:
+        """Every id in the set: sequential ids ascending, then the others."""
+        if self._ix_count(base) == 0:
+            return []
+        ids = [v for _, v in self._ix_bucket(base, "n", _ID_WIDTH, ":")]
+        ids.extend(v for _, v in self._ix_bucket(base, "h", _HASH_WIDTH, "g"))
+        return ids
+
+    def _ix_clear(self, base: str) -> None:
+        """Empty a set in O(1); its entries are purged in bounded steps.
+
+        Every reader checks the counter first, so removing it empties the set
+        at once. The entries are queued and removed by later index writes
+        (_PURGE_PER_WRITE each) or by purge_step(). ``{base}|d`` marks the set
+        as dead and holds its queue position, so re-adding to it (a reused
+        custom id) purges the leftovers first instead of reviving them.
+        """
+        if self._ix_count(base) == 0:
+            return
+        storage = self._db_storage
+        tail = int(storage.get(_PQ_TAIL) or 0)
+        storage.insert(self._pq_key(tail), base)
+        storage.insert(_PQ_TAIL, str(tail + 1))
+        storage.insert(f"{base}|d", str(tail))
+        storage.remove(f"{base}|c")
+        self._purge_pending = True
+
+    @staticmethod
+    def _pq_key(position: int) -> str:
+        return f"{_PQ}{str(position).zfill(_ID_WIDTH)}"
+
+    def _ix_drain(self, base: str, limit: int) -> int:
+        """Remove up to ``limit`` entries of ``base``; returns how many."""
+        removed = 0
+        for tag, width, top in _BUCKETS:
+            keys = []
+            page_size = min(limit - removed, _SCAN_PAGE)
+            for key, _ in self._ix_bucket(base, tag, width, top, page_size):
+                if removed + len(keys) >= limit:
+                    break
+                keys.append(key)
+            for key in keys:
+                self._db_storage.remove(key)
+            removed += len(keys)
+            if removed >= limit:
+                break
+        return removed
+
+    def _ix_revive(self, base: str) -> None:
+        """Before reusing a deleted set: purge its leftovers, drop its queue entry."""
+        position = self._db_storage.get(f"{base}|d")
+        if position is None:
+            return
+        while self._ix_drain(base, _SCAN_PAGE) == _SCAN_PAGE:
+            pass
+        self._db_storage.remove(f"{base}|d")
+        queued = self._pq_key(int(position))
+        if self._db_storage.get(queued) is not None:
+            self._db_storage.remove(queued)
+
+    def _purge_some(self) -> None:
+        if self._purge_pending is not False:
+            self.purge_step(_PURGE_PER_WRITE)
+
+    def purge_step(self, limit: int = 500) -> bool:
+        """Remove up to ``limit`` entries of deleted index sets.
+
+        Deleting an entity empties its relation indexes at once; their entries
+        are removed in the background, a few by each later index write. A
+        timer can call this to finish sooner. Returns True when nothing is
+        left to purge.
+        """
+        if limit < 1:
+            raise ValueError("limit must be at least 1")
+        storage = self._db_storage
+        head = int(storage.get(_PQ_HEAD) or 0)
+        tail = int(storage.get(_PQ_TAIL) or 0)
+        start, budget = head, limit
+        while head < tail and budget > 0:
+            queued = self._pq_key(head)
+            base = storage.get(queued)
+            removed = self._ix_drain(base, budget) if base is not None else 0
+            if removed == budget:
+                break  # out of budget, maybe not drained yet
+            budget -= removed
+            if base is not None:
+                storage.remove(f"{base}|d")
+                storage.remove(queued)
+            head += 1
+        if head != start:
+            storage.insert(_PQ_HEAD, str(head))
+        self._purge_pending = head < tail
+        return not self._purge_pending
+
     # ── 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"]
+    # Base key: _ri:{ParentType}:{parent_id}:{relation_name} (posting list)
 
     def _ri_key(self, parent_type: str, parent_id: str, relation_name: str) -> str:
         return f"_ri:{parent_type}:{parent_id}:{relation_name}"
@@ -507,101 +762,98 @@ class Database:
     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.
+        """All child ids of a parent's relation (O(children); prefer
+        ``reverse_index_page`` for relations that can grow large)."""
+        return self._ix_all(self._ri_key(parent_type, parent_id, relation_name))
 
-        Returns:
-            List of child entity IDs, or empty list if no index exists.
+    def reverse_index_page(
+        self,
+        parent_type: str,
+        parent_id: str,
+        relation_name: str,
+        from_id: int,
+        count: int,
+    ) -> List[str]:
+        """Up to ``count`` sequential child ids >= ``from_id``, ascending.
+
+        Children with custom (non-sequential) ids are not paged; use
+        ``reverse_index_get`` for those.
         """
-        key = self._ri_key(parent_type, parent_id, relation_name)
-        raw = self._db_storage.get(key)
-        if raw:
-            return json.loads(raw)
-        return []
+        return self._ix_page(
+            self._ri_key(parent_type, parent_id, relation_name), from_id, count
+        )
+
+    def reverse_index_count(
+        self, parent_type: str, parent_id: str, relation_name: str
+    ) -> int:
+        """Number of child ids in a parent's relation (one read)."""
+        return self._ix_count(self._ri_key(parent_type, parent_id, relation_name))
+
+    def reverse_index_contains(
+        self, parent_type: str, parent_id: str, relation_name: str, child_id: str
+    ) -> bool:
+        return self._ix_contains(
+            self._ri_key(parent_type, parent_id, relation_name), child_id
+        )
 
     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))
+        self._ix_add(self._ri_key(parent_type, parent_id, relation_name), child_id)
 
     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)
+        self._ix_remove(self._ri_key(parent_type, parent_id, relation_name), child_id)
 
     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)
+        """Delete a whole reverse index (used when the parent is deleted).
+
+        Costs one removal per child id.
+        """
+        self._ix_clear(self._ri_key(parent_type, parent_id, relation_name))
 
     # ── Field Index API (issue #11) ────────────────────────────────────────────
     #
     # Secondary indexes for scalar properties declared with indexed=True.
     # Allow equality lookups (Entity.find_by) without scanning all entities.
     #
-    # Key format: _fi:{Type}:{field}:{value}
-    # Value: JSON array of entity IDs, e.g. ["1", "2", "3"]
+    # Base key: _fi:{Type}:{field}:{value} (posting list)
 
     def _fi_key(self, type_name: str, field_name: str, value: str) -> str:
         return f"_fi:{type_name}:{field_name}:{value}"
 
     def field_index_get(self, type_name: str, field_name: str, value: str) -> List[str]:
-        """Read the ID list for entities whose ``field_name`` equals ``value``.
+        """All ids of entities whose ``field_name`` equals ``value``
+        (O(matches); prefer ``field_index_page``)."""
+        return self._ix_all(self._fi_key(type_name, field_name, value))
 
-        Returns:
-            List of entity IDs, or empty list if no index entry exists.
-        """
-        key = self._fi_key(type_name, field_name, value)
-        raw = self._db_storage.get(key)
-        if raw:
-            return json.loads(raw)
-        return []
+    def field_index_page(
+        self, type_name: str, field_name: str, value: str, from_id: int, count: int
+    ) -> List[str]:
+        """Up to ``count`` sequential ids >= ``from_id`` whose ``field_name``
+        equals ``value``, ascending. One range read."""
+        return self._ix_page(self._fi_key(type_name, field_name, value), from_id, count)
+
+    def field_index_count(self, type_name: str, field_name: str, value: str) -> int:
+        """Number of entities whose ``field_name`` equals ``value`` (one read)."""
+        return self._ix_count(self._fi_key(type_name, field_name, value))
 
     def field_index_add(
         self, type_name: str, field_name: str, value: str, entity_id: str
     ) -> None:
         """Add an entity ID to the index entry for ``value``."""
-        key = self._fi_key(type_name, field_name, value)
-        raw = self._db_storage.get(key)
-        ids = json.loads(raw) if raw else []
-        if entity_id not in ids:
-            ids.append(entity_id)
-            self._db_storage.insert(key, json.dumps(ids))
+        self._ix_add(self._fi_key(type_name, field_name, value), entity_id)
 
     def field_index_remove(
         self, type_name: str, field_name: str, value: str, entity_id: str
     ) -> None:
         """Remove an entity ID from the index entry for ``value``."""
-        key = self._fi_key(type_name, field_name, value)
-        raw = self._db_storage.get(key)
-        if not raw:
-            return
-        ids = json.loads(raw)
-        if entity_id in ids:
-            ids.remove(entity_id)
-            if ids:
-                self._db_storage.insert(key, json.dumps(ids))
-            else:
-                self._db_storage.remove(key)
+        self._ix_remove(self._fi_key(type_name, field_name, value), entity_id)
 
     # Reverse counters (unidirectional relations)
     # Key format: "_rc:{parent_type}:{parent_id}:{relation_name}"
@@ -620,41 +872,32 @@ class Database:
     ) -> int:
         """Read the reverse counter for a parent entity's relation.
 
-        Falls back to the length of a legacy reverse-index array (from when
-        the relation was bidirectional) if no counter exists yet.
+        Falls back to the size of a legacy reverse index (from when the
+        relation was bidirectional) if no counter exists yet.
         """
         key = self._rc_key(parent_type, parent_id, relation_name)
         raw = self._db_storage.get(key)
         if raw is not None:
             return int(raw)
-        legacy = self._db_storage.get(
-            self._ri_key(parent_type, parent_id, relation_name)
-        )
-        if legacy:
-            return len(json.loads(legacy))
-        return 0
+        return self.reverse_index_count(parent_type, parent_id, relation_name)
 
     def reverse_count_add(
         self, parent_type: str, parent_id: str, relation_name: str, delta: int
     ) -> None:
         """Adjust the reverse counter by delta (never below zero).
 
-        On first write, seeds the counter from a legacy reverse-index array
-        (if present) and drops the array — lazy, exactly-once migration of
-        relations converted from bidirectional to unidirectional.
+        On first write, seeds the counter from a legacy reverse index (if
+        present) and drops it — lazy, exactly-once migration of relations
+        converted from bidirectional to unidirectional.
         """
         key = self._rc_key(parent_type, parent_id, relation_name)
         raw = self._db_storage.get(key)
         if raw is not None:
             current = int(raw)
         else:
-            legacy_key = self._ri_key(parent_type, parent_id, relation_name)
-            legacy = self._db_storage.get(legacy_key)
-            if legacy:
-                current = len(json.loads(legacy))
-                self._db_storage.remove(legacy_key)
-            else:
-                current = 0
+            current = self.reverse_index_count(parent_type, parent_id, relation_name)
+            if current:
+                self.reverse_index_delete(parent_type, parent_id, relation_name)
         self._db_storage.insert(key, str(max(0, current + delta)))
 
     def reverse_count_delete(

ic_python_db/entity.py

@@ -80,7 +80,7 @@ class Entity:
                            Entities with namespaces are stored as "namespace::ClassName"
                            Allows multiple entities with same class name in different namespaces
         _entity_type (str): Optional entity type for subclasses
-        _context (Set[Entity]): Set of all entities in current context
+        _context (Set[Entity]): Unused, kept empty for compatibility (issue #23)
 
     Property Storage:
         User-defined properties (String, Integer, etc.) are stored as _prop_{name}
@@ -89,7 +89,10 @@ class Entity:
     """
 
     _entity_type = None  # To be defined in subclasses
-    _context: Set["Entity"] = set()  # Set of entities in current context
+    # Used to hold every entity ever constructed, which kept them all in the
+    # heap until the next upgrade (issue #23). Kept, empty, for code that
+    # clears it.
+    _context: Set["Entity"] = set()
     _deferred_types: List[Type["Entity"]] = []  # Types defined before DB exists
     _do_not_save = False
     __version__ = 1  # Default schema version
@@ -160,9 +163,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
 
-        # Add to context
-        self.__class__._context.add(self)
-
         # Register this type with the database (using full type name)
         self.db().register_entity_type(self.__class__, self._type)
 
@@ -457,12 +457,42 @@ class Entity:
 
         return entity
 
+    @classmethod
+    def _require_unpaged(cls, method: str) -> None:
+        """Raise TooLargeError before ``method`` loads more than MAX_UNPAGED entities."""
+        from . import constants
+        from .errors import TooLargeError
+
+        total = cls.count()
+        if total > constants.MAX_UNPAGED:
+            raise TooLargeError(
+                f"{cls.__name__}.{method}() would load all {total} entities, more "
+                f"than {constants.MAX_UNPAGED} in one call; use {cls.__name__}.count(), "
+                f"{cls.__name__}.find_by() on an indexed field, or "
+                f"{cls.__name__}.page(from_id, count) instead"
+            )
+
     @classmethod
     def find(cls: Type[T], d) -> List[T]:
         """Find entities matching a dictionary filter.
 
-        Uses load_some over the full ID range. Prefer indexed lookups where possible.
+        .. deprecated::
+            Loads every entity of the type to filter them, and raises
+            TooLargeError past constants.MAX_UNPAGED. Use find_by() on an
+            indexed field, or page() (issue #22).
         """
+        try:
+            import warnings
+
+            warnings.warn(
+                "Entity.find() is deprecated and will be removed. "
+                "Use find_by() on an indexed field, or page().",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        except (ImportError, AttributeError):
+            pass
+        cls._require_unpaged("find")
         max_id = cls.max_id()
         if max_id == 0:
             return []
@@ -505,9 +535,11 @@ class Entity:
     ) -> Tuple[List[T], Optional[int]]:
         """Equality lookup on an indexed field with cursor pagination (issue #11).
 
-        IDs come from the persistent field index, so cost is proportional to
-        the number of matches, not to max_id. Results are ordered by ascending
-        entity ID, compatible with load_some-style cursors.
+        IDs come from the persistent field index with one range read per
+        page, so cost is proportional to ``count``, not to the number of
+        matches or to max_id. Results are ordered by ascending entity ID,
+        compatible with load_some-style cursors. Entities with custom
+        (non-sequential) ids are not returned.
 
         Args:
             field: Name of a property declared with indexed=True
@@ -528,34 +560,32 @@ class Entity:
         if count < 1:
             raise ValueError("count must be at least 1")
 
-        ids = cls.db().field_index_get(cls.get_full_type_name(), field, str(value))
-        matching = sorted((int(i) for i in ids if i.isdigit() and int(i) >= from_id))
-
+        db = cls.db()
+        type_name = cls.get_full_type_name()
         entities: List[T] = []
-        last_id = None
-        for entity_id in matching:
-            if len(entities) >= count:
-                break
-            entity = cls.load(str(entity_id))
-            if entity is not None:
-                entities.append(entity)
-            last_id = entity_id
-
-        has_more = last_id is not None and any(i > last_id for i in matching)
-        next_from_id = (last_id + 1) if has_more else None
-        return entities, next_from_id
+        cursor = from_id
+        while len(entities) < count:
+            need = count - len(entities)
+            # One extra id tells whether another page exists
+            ids = db.field_index_page(type_name, field, str(value), cursor, need + 1)
+            for entity_id in ids[:need]:
+                entity = cls.load(entity_id)
+                if entity is not None:
+                    entities.append(entity)
+            if len(ids) <= need:
+                return entities, None
+            cursor = int(ids[need])
+        return entities, cursor
 
     @classmethod
     def count_by(cls: Type[T], field: str, value: Any) -> int:
-        """Number of entities whose indexed ``field`` equals ``value``.
+        """Number of entities whose indexed ``field`` equals ``value`` (one read).
 
         Raises:
             ValueError: If the field is not declared with indexed=True
         """
         cls._require_indexed_field(field)
-        return len(
-            cls.db().field_index_get(cls.get_full_type_name(), field, str(value))
-        )
+        return cls.db().field_index_count(cls.get_full_type_name(), field, str(value))
 
     @classmethod
     def rebuild_field_index(
@@ -612,8 +642,9 @@ class Entity:
         """Get all instances of this entity type, including subclass instances.
 
         .. deprecated::
-            This method loads ALL entities and is O(max_id). Prefer load_some()
-            with pagination or use relationship accessors.
+            Loads every entity, and raises TooLargeError past
+            constants.MAX_UNPAGED. Use count(), find_by() on an indexed field,
+            or page() (issue #22).
 
         Returns:
             List of entities
@@ -623,7 +654,7 @@ class Entity:
 
             warnings.warn(
                 "Entity.instances() is deprecated and will be removed. "
-                "Use load_some() with pagination instead.",
+                "Use count(), find_by() or page() instead.",
                 DeprecationWarning,
                 stacklevel=2,
             )
@@ -632,6 +663,7 @@ class Entity:
         db = Database.get_instance()
         full_type_name = cls.get_full_type_name()
         db.register_entity_type(cls, full_type_name)
+        cls._require_unpaged("instances")
 
         max_id = cls.max_id()
         if max_id == 0:
@@ -653,6 +685,44 @@ class Entity:
 
         return instances
 
+    @classmethod
+    def page(
+        cls: Type[T], from_id: int = 1, count: int = 50
+    ) -> Tuple[List[T], Optional[int]]:
+        """One page of this type's entities, in ascending id order (issue #22).
+
+        Returns (entities, next_from_id); next_from_id is None on the last page.
+        Costs one range read plus ``count`` loads, however many entities
+        exist, so it replaces instances() for large types::
+
+            cursor = 1
+            while cursor is not None:
+                users, cursor = User.page(cursor, 50)
+
+        Only this type's own entities (not subclasses'), with canonical
+        sequential ids, as with load_some(). Entities that fail to load are
+        skipped, so a page may hold fewer than ``count``.
+        """
+        if from_id < 1:
+            raise ValueError("from_id must be at least 1")
+        if count < 1:
+            raise ValueError("count must be at least 1")
+        db = cls.db()
+        type_name = cls.get_full_type_name()
+        # One extra row tells whether another page exists
+        rows = db.load_page(type_name, from_id, count + 1)
+        entities: List[T] = []
+        for entity_id, data in rows[:count]:
+            try:
+                entity = db.get_entity(type_name, entity_id)
+                if entity is None:
+                    entity = cls._hydrate(entity_id, data)
+                entities.append(entity)
+            except (ValueError, AttributeError) as e:
+                logger.warning(f"Skipping {cls.__name__}@{entity_id}: {e}")
+        next_from_id = int(rows[count][0]) if len(rows) > count else None
+        return entities, next_from_id
+
     @classmethod
     def count(cls: Type[T]) -> int:
         """Get the total count of entities of this type.
@@ -749,7 +819,13 @@ class Entity:
         logger.debug(f"Deleting entity {self._type}@{self._id}")
         from .constants import ACTION_DELETE
         from .hooks import call_entity_hook
-        from .properties import ManyToMany, ManyToOne, OneToMany, OneToOne
+        from .properties import (
+            ManyToMany,
+            ManyToOne,
+            OneToMany,
+            OneToOne,
+            _require_unpaged,
+        )
 
         # Call hook before deletion
         allow, _ = call_entity_hook(self, None, self, None, ACTION_DELETE)
@@ -759,6 +835,18 @@ class Entity:
 
         db = self.db()
 
+        # Refuse before changing anything: each ManyToMany member is updated
+        for cls in reversed(self.__class__.__mro__):
+            for attr_name, attr_value in cls.__dict__.items():
+                if not attr_name.startswith("_") and isinstance(attr_value, ManyToMany):
+                    _require_unpaged(
+                        db,
+                        self,
+                        attr_name,
+                        "delete it",
+                        f"first .discard() its {attr_name} page by page",
+                    )
+
         # Clean up reverse indexes for all relation properties
         for cls in reversed(self.__class__.__mro__):
             for attr_name, attr_value in cls.__dict__.items():
@@ -883,9 +971,6 @@ class Entity:
 
         logger.debug(f"Deleted entity {self._type}@{self._id}")
 
-        # Remove from context
-        self.__class__._context.discard(self)
-
     def _serialize_base(self) -> Dict[str, Any]:
         """Shared serialization logic: core data, properties, and instance attributes."""
         # Get mixin data first if available
@@ -963,7 +1048,12 @@ class Entity:
         """
         data = self._serialize_base()
 
-        from ic_python_db.properties import ManyToMany, ManyToOne, OneToOne
+        from ic_python_db.properties import (
+            ManyToMany,
+            ManyToOne,
+            OneToOne,
+            _require_unpaged,
+        )
 
         db = self.db()
 
@@ -984,6 +1074,13 @@ class Entity:
                             ref, attr_value._get_allowed_types()
                         )
                 elif isinstance(attr_value, ManyToMany):
+                    _require_unpaged(
+                        db,
+                        self,
+                        attr_name,
+                        "serialize it",
+                        f"serialize its {attr_name} with .page()",
+                    )
                     related_ids = db.reverse_index_get(self._type, self._id, attr_name)
                     if related_ids:
                         data[attr_name] = [

ic_python_db/errors.py

@@ -0,0 +1,10 @@
+"""Errors raised by ic_python_db."""
+
+
+class TooLargeError(ValueError):
+    """An operation would touch more than ``constants.MAX_UNPAGED`` items in one call.
+
+    On the IC each call has a fixed instruction budget, and running past it
+    traps with no hint of the cause. This error is raised first instead, and
+    its message names the paged alternative.
+    """

ic_python_db/properties.py

@@ -373,8 +373,8 @@ class ManyToOne(Relation[E]):
 class OneToMany(Relation[E]):
     """One-to-many relationship (parent side, resolved via reverse index).
 
-    Accessing this property reads the persisted reverse index to find child
-    IDs, then loads each child. No scanning required.
+    Accessing this property returns a RelationView: counting, membership and
+    pages read the persisted reverse index without loading every child.
 
     Example:
         class Department(Entity):
@@ -389,25 +389,10 @@ class OneToMany(Relation[E]):
 
     def __get__(
         self, obj: object, objtype: Optional[type] = None
-    ) -> Union["OneToMany[E]", List[E]]:
+    ) -> Union["OneToMany[E]", "RelationView"]:
         if obj is None:
             return self  # type: ignore[return-value]
-
-        from .db_engine import Database
-
-        db = Database.get_instance()
-        child_ids = db.reverse_index_get(obj._type, obj._id, self.name)
-
-        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]
+        return RelationView(obj, self)  # type: ignore[return-value]
 
     def __set__(self, obj, values):
         raise AttributeError(
@@ -556,19 +541,154 @@ class OneToOne(Relation[E]):
             obj._save()
 
 
-class ManyToManyList(list):
-    """List subclass returned by ManyToMany.__get__ that supports .add() and .remove()."""
+def _require_unpaged(db, obj, relation_name, action, instead):
+    """Raise TooLargeError before ``action`` loads more members than MAX_UNPAGED."""
+    from . import constants
+    from .errors import TooLargeError
+
+    total = db.reverse_index_count(obj._type, obj._id, relation_name)
+    if total > constants.MAX_UNPAGED:
+        owner_type = obj._type.split("::")[-1]
+        raise TooLargeError(
+            f"{owner_type}.{relation_name} has {total} members, more than "
+            f"{constants.MAX_UNPAGED} can be handled in one call; to {action}, {instead}"
+        )
+
+
+class RelationView:
+    """The members of a OneToMany or ManyToMany relation, loaded only on demand.
+
+    Returned by the relation's getter instead of a list (issue #21), so that
+    questions about a large relation stay cheap:
+
+        if section.stands: ...              # one read
+        len(section.stands)                 # one read
+        stand in section.stands             # two reads
+        page, cursor = section.stands.page(1, 50)   # one range read + 50 loads
+        group.members.add(user)             # index writes only, no loads
 
-    def __init__(self, items, owner, prop):
-        super().__init__(items)
+    Iterating, indexing and comparing load every member and raise
+    TooLargeError past constants.MAX_UNPAGED; use page() for large relations.
+    ``list(view)`` gives a plain list.
+
+    len() and ``in`` count stored references. A unidirectional target deleted
+    elsewhere stays referenced until discarded (no reverse list exists to find
+    its owners); loading skips it.
+    """
+
+    def __init__(self, owner, prop):
         self._owner = owner
         self._prop = prop
 
+    def _db(self):
+        from .db_engine import Database
+
+        return Database.get_instance()
+
+    def _key(self):
+        return (self._owner._type, self._owner._id, self._prop.name)
+
+    def _load(self, entity_id):
+        db = self._db()
+        for type_name in self._prop._get_allowed_types():
+            entity_class = db._entity_types.get(type_name)
+            if entity_class:
+                entity = entity_class.load(entity_id)
+                if entity:
+                    return entity
+        return None
+
+    def __len__(self):
+        return self._db().reverse_index_count(*self._key())
+
+    def __bool__(self):
+        return len(self) > 0
+
+    def __contains__(self, entity):
+        from .entity import Entity
+
+        if isinstance(entity, Entity):
+            try:
+                self._prop.validate_entity(entity)
+            except TypeError:
+                return False
+            entity_id = entity._id
+        else:
+            entity_id = str(entity)
+        return self._db().reverse_index_contains(*self._key(), entity_id)
+
+    def page(self, from_id: int = 1, count: int = 50):
+        """Up to ``count`` members with id >= ``from_id``, in ascending id order.
+
+        Returns (members, next_from_id); next_from_id is None on the last page.
+        Costs one range read and ``count`` loads, however large the relation.
+        Members with custom (non-sequential) ids are not paged.
+        """
+        if count < 1:
+            raise ValueError("count must be at least 1")
+        db = self._db()
+        members = []
+        cursor = from_id
+        while len(members) < count:
+            need = count - len(members)
+            # One extra id tells whether another page exists
+            ids = db.reverse_index_page(*self._key(), cursor, need + 1)
+            for entity_id in ids[:need]:
+                entity = self._load(entity_id)
+                if entity is not None:
+                    members.append(entity)
+            if len(ids) <= need:
+                return members, None
+            cursor = int(ids[need])
+        return members, cursor
+
+    def _all(self):
+        from . import constants
+        from .errors import TooLargeError
+
+        total = len(self)
+        if total > constants.MAX_UNPAGED:
+            owner_type = self._owner._type.split("::")[-1]
+            raise TooLargeError(
+                f"{owner_type}.{self._prop.name} has {total} members, more than "
+                f"{constants.MAX_UNPAGED} can be loaded in one call; use "
+                f".page(from_id, count), len() or 'in' instead"
+            )
+        members = []
+        for entity_id in self._db().reverse_index_get(*self._key()):
+            entity = self._load(entity_id)
+            if entity is not None:
+                members.append(entity)
+        return members
+
+    def __iter__(self):
+        return iter(self._all())
+
+    def __getitem__(self, index):
+        return self._all()[index]
+
+    def __eq__(self, other):
+        if isinstance(other, RelationView):
+            other = other._all()
+        if isinstance(other, (list, tuple)):
+            return self._all() == list(other)
+        return NotImplemented
+
+    def __repr__(self):
+        return f"<RelationView {self._owner._type}@{self._owner._id}.{self._prop.name}>"
+
+    def _require_many_to_many(self, action):
+        if not isinstance(self._prop, ManyToMany):
+            raise TypeError(
+                f"Cannot {action} on OneToMany '{self._prop.name}'. "
+                f"Set the ManyToOne '{self._prop.reverse_name}' on the child instead."
+            )
+
     def add(self, entity):
         """Add an entity to this many-to-many relationship."""
-        from .db_engine import Database
         from .entity import Entity
 
+        self._require_many_to_many("add")
         if isinstance(entity, (str, int)):
             resolved = self._prop.resolve_entity(self._owner, entity)
         elif isinstance(entity, Entity):
@@ -577,15 +697,10 @@ class ManyToManyList(list):
             raise TypeError(f"Cannot add {type(entity)} to ManyToMany relation")
 
         self._prop.validate_entity(resolved)
-        db = Database.get_instance()
+        db = self._db()
 
-        existing = db.reverse_index_get(
-            self._owner._type, self._owner._id, self._prop.name
-        )
-        if resolved._id not in existing:
-            db.reverse_index_add(
-                self._owner._type, self._owner._id, self._prop.name, resolved._id
-            )
+        if not db.reverse_index_contains(*self._key(), resolved._id):
+            db.reverse_index_add(*self._key(), resolved._id)
             if self._prop.unidirectional:
                 db.reverse_count_add(
                     resolved._type, resolved._id, self._prop.reverse_name, 1
@@ -599,13 +714,12 @@ class ManyToManyList(list):
                 )
             if not self._owner._do_not_save:
                 self._owner._save()
-        self.append(resolved)
 
     def discard(self, entity):
         """Remove an entity from this many-to-many relationship (no error if absent)."""
-        from .db_engine import Database
         from .entity import Entity
 
+        self._require_many_to_many("discard")
         if isinstance(entity, Entity):
             entity_id = entity._id
             entity_type = entity._type
@@ -613,13 +727,9 @@ class ManyToManyList(list):
             entity_id = str(entity)
             entity_type = None
 
-        db = Database.get_instance()
-        was_present = entity_id in db.reverse_index_get(
-            self._owner._type, self._owner._id, self._prop.name
-        )
-        db.reverse_index_remove(
-            self._owner._type, self._owner._id, self._prop.name, entity_id
-        )
+        db = self._db()
+        was_present = db.reverse_index_contains(*self._key(), entity_id)
+        db.reverse_index_remove(*self._key(), entity_id)
         if self._prop.unidirectional:
             if was_present:
                 if entity_type is None:
@@ -641,7 +751,6 @@ class ManyToManyList(list):
                     type_name, entity_id, self._prop.reverse_name, self._owner._id
                 )
 
-        self[:] = [e for e in self if getattr(e, "_id", None) != entity_id]
         if not self._owner._do_not_save:
             self._owner._save()
 
@@ -650,6 +759,10 @@ class ManyToManyList(list):
         self.discard(entity)
 
 
+# Name of the view before 0.13, when it was a list subclass
+ManyToManyList = RelationView
+
+
 class ManyToMany(Relation[E]):
     """Many-to-many relationship with bidirectional reverse indexes.
 
@@ -690,25 +803,10 @@ class ManyToMany(Relation[E]):
 
     def __get__(
         self, obj: object, objtype: Optional[type] = None
-    ) -> Union["ManyToMany[E]", List[E]]:
+    ) -> Union["ManyToMany[E]", "RelationView"]:
         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 ManyToManyList(entities, obj, self)  # type: ignore[return-value]
+        return RelationView(obj, self)  # type: ignore[return-value]
 
     def __set__(self, obj, values):
         from .db_engine import Database
@@ -730,6 +828,7 @@ class ManyToMany(Relation[E]):
             resolved.append(entity)
 
         db = Database.get_instance()
+        _require_unpaged(db, obj, self.name, "set it", "use .add() and .discard()")
 
         # Remove old relations from both sides' indexes
         old_ids = db.reverse_index_get(obj._type, obj._id, self.name)

{ic_python_db-0.12.0.dist-info → ic_python_db-0.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ic-python-db
-Version: 0.12.0
+Version: 0.13.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
@@ -60,7 +60,7 @@ A lightweight key-value database with entity relationships and audit logging cap
 ## Features
 
 - **Persistent Storage**: Works with StableBTreeMap stable structure for persistent storage on your canister's stable memory so your data persists automatically across canister upgrades.
-- **Range-based paging**: `load_some`, `find`, `instances` and `rebuild_field_index` read a page of entities with a single ordered `range` call on the stable map (Basilisk `StableBTreeMap.range`), so cost tracks the rows returned rather than the highest id ever issued, and deleted ids are free. Backends without `range` (older CDK builds, plain dict test doubles) transparently fall back to one read per id.
+- **Range-based paging**: `page`, `load_some` and `rebuild_field_index` read a page of entities with a single ordered `range` call on the stable map (Basilisk `StableBTreeMap.range`), so cost tracks the rows returned rather than the highest id ever issued, and deleted ids are free. Backends without `range` (older CDK builds, plain dict test doubles) transparently fall back to one read per id. `instances()` and `find()` load a whole type: they are deprecated and raise `TooLargeError` past 1,000 entities (use `count()`, `find_by()` or `page()`).
 - **Entity-Relational Database**: Create, read and write entities with OneToOne, OneToMany, ManyToOne, and ManyToMany relationships.
 - **Schema Versioning & Upgrade Safety**: Automatic schema introspection, compatibility checking, and auto-migration for safe changes. Breaking changes without a `migrate()` method are rejected, preventing data corruption on canister upgrades.
 - **Entity Hooks**: Intercept and control entity lifecycle events (create, modify, delete) with `on_event` hooks.
@@ -163,11 +163,12 @@ Then use the defined entities to store objects:
 
     assert Person.count() == 3
     assert Person.max_id() == 4
-    assert Person.instances() == [john, alice, eva]
 
-    # Cursor-based pagination
-    assert Person.load_some(0, 2) == [john, alice]
-    assert Person.load_some(2, 2) == [eva]
+    # Cursor-based pagination: (page, next_from_id), None on the last page
+    page, cursor = Person.page(1, 2)
+    assert page == [john, alice]
+    page, cursor = Person.page(cursor, 2)
+    assert page == [eva] and cursor is None
 
     # Retrieve database contents in JSON format
     print(Database.get_instance().dump_json(pretty=True))
@@ -229,7 +230,29 @@ while cursor is not None:
 
 The rebuild is idempotent. The `indexed` flag is not part of the schema descriptor, so toggling it never triggers upgrade-compatibility errors.
 
-Note: each distinct value's ID list is stored in a single storage entry, so extremely hot values are bounded by the backing store's `max_value_size` — the same constraint as relationship reverse indexes.
+Each matching id is its own storage entry, so a value can match any number of entities without reaching the backing store's `max_value_size`.
+
+## Large Relations
+
+`OneToMany` and `ManyToMany` getters return a `RelationView`, not a list. Questions about the relation and single pages never load every member, so they stay cheap however large it grows:
+
+```python
+if section.stands: ...                       # one read
+len(section.stands)                          # one read
+stand in section.stands                      # two reads
+stands, cursor = section.stands.page(1, 50)  # one range read + 50 loads
+group.members.add(user)                      # index writes only
+```
+
+Iterating, indexing and comparing still work, but they load every member, so past `constants.MAX_UNPAGED` (1,000) they raise `TooLargeError` instead of running into the IC instruction limit. Walk a large relation with `page()`, across calls if needed:
+
+```python
+cursor = 1
+while cursor is not None:
+    stands, cursor = section.stands.page(cursor, 50)
+```
+
+`list(view)` gives a plain list. Deleting a parent is O(1): its index entries are purged in bounded steps by later writes, or by `Database.get_instance().purge_step()` from a timer.
 
 ## Namespaces
 

ic_python_db-0.13.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+ic_python_db/__init__.py,sha256=amMTKKg0eRKGSc6Hz8O-ZqhZfwOZFwRbfxxB5UQfX5o,1083
+ic_python_db/_cdk.py,sha256=zTj8HzXUcPz8R73nh5bo6JMkCorp-KSW1hDutzi5LZs,387
+ic_python_db/constants.py,sha256=gs6klyqUxUjE0LFJxXpaya8QEgYeKx4ovP9Mu04rtHk,351
+ic_python_db/context.py,sha256=97F4_EAJm3adOnUfh0SaDisX3nc7F2vFIZwZUsUAy58,1080
+ic_python_db/db_engine.py,sha256=KniUAn9Gzn8G8bhj-8Kz0-Q1xX6dIvtcN3t3Ng-STSc,36792
+ic_python_db/entity.py,sha256=fRUN0gBBN-KtEXOZOh5rxXlskFltfG8kDlwq1fK6Ck0,54408
+ic_python_db/errors.py,sha256=q_2oAu2mX4B3eGySS-8xOU_CIoKoPlxKwECkbxaHQ1E,366
+ic_python_db/hooks.py,sha256=B1wV18dAMH-PootSripmMpG9Cr9M3W3lcNEF7QvPrL4,1620
+ic_python_db/mixins.py,sha256=qZmb3ssXYf2NSjHJtgmdsOlkIJdouDjPHdQ9tZmrZi8,1937
+ic_python_db/properties.py,sha256=yo2mPH2OjzYvGM3KKSAaiIGTep_qv2496ZT9-_T34FU,31253
+ic_python_db/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ic_python_db/schema.py,sha256=h1RAbapExo8pMD5IQvK8ZTVkgyonbPV9qSqliSP0Y14,16249
+ic_python_db/storage.py,sha256=899qyuA3alpAFIPM23A_07vqquUB5ZG5GjjpzlHW1Os,3828
+ic_python_db/system_time.py,sha256=xrx8NfjLXCGsac3hUpuvsNwCH91tQ9jfH4N-XFo8iJk,2614
+ic_python_db-0.13.0.dist-info/licenses/LICENSE,sha256=6q6XYNOGnJcVSus2bAezFn7bU_2Y5T6W4aGQHBb8X-c,1079
+ic_python_db-0.13.0.dist-info/METADATA,sha256=lwTLW2L4sj_aLQ--SxXjAFZ0WBRb7of1UXi7YqCa83I,18319
+ic_python_db-0.13.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+ic_python_db-0.13.0.dist-info/top_level.txt,sha256=ZaOTqhWKtJQEuXmqR920AqbDBAqv1mvsKj3TClWimDk,13
+ic_python_db-0.13.0.dist-info/RECORD,,

{ic_python_db-0.12.0.dist-info → ic_python_db-0.13.0.dist-info}/WHEEL

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

ic_python_db-0.12.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-ic_python_db/__init__.py,sha256=8F0p76Ez1Hhcb9iHKzJjrCWp4aZGgvAGdP9-b9Ka-CU,990
-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=wK6mJshJMjrmVa7LPjA5ZVz1LXSxTtRjht6MU2mDM6k,26133
-ic_python_db/entity.py,sha256=zU_7zoYUs125DToM4Htywc9fhz5NxZhbdvYGMei5RJs,50437
-ic_python_db/hooks.py,sha256=B1wV18dAMH-PootSripmMpG9Cr9M3W3lcNEF7QvPrL4,1620
-ic_python_db/mixins.py,sha256=qZmb3ssXYf2NSjHJtgmdsOlkIJdouDjPHdQ9tZmrZi8,1937
-ic_python_db/properties.py,sha256=l7q3Iv8R-57XMlYwz2gcJV9mObYV_LfR6mw2jZgGwns,27556
-ic_python_db/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ic_python_db/schema.py,sha256=h1RAbapExo8pMD5IQvK8ZTVkgyonbPV9qSqliSP0Y14,16249
-ic_python_db/storage.py,sha256=899qyuA3alpAFIPM23A_07vqquUB5ZG5GjjpzlHW1Os,3828
-ic_python_db/system_time.py,sha256=xrx8NfjLXCGsac3hUpuvsNwCH91tQ9jfH4N-XFo8iJk,2614
-ic_python_db-0.12.0.dist-info/licenses/LICENSE,sha256=6q6XYNOGnJcVSus2bAezFn7bU_2Y5T6W4aGQHBb8X-c,1079
-ic_python_db-0.12.0.dist-info/METADATA,sha256=9AjuP2o844gKy9w2Ee-vSZNrqBrEglF6GvsE3v-JHcI,17115
-ic_python_db-0.12.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-ic_python_db-0.12.0.dist-info/top_level.txt,sha256=ZaOTqhWKtJQEuXmqR920AqbDBAqv1mvsKj3TClWimDk,13
-ic_python_db-0.12.0.dist-info/RECORD,,