ic-python-db 0.7.4__tar.gz → 0.7.6__tar.gz

{ic_python_db-0.7.4/ic_python_db.egg-info → ic_python_db-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ic_python_db
-Version: 0.7.4
+Version: 0.7.6
 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.7.4 → ic_python_db-0.7.6}/ic_python_db/__init__.py

@@ -19,7 +19,7 @@ from .properties import (
 from .storage import MemoryStorage, Storage
 from .system_time import SystemTime
 
-__version__ = "0.7.4"
+__version__ = "0.7.6"
 __all__ = [
     "Database",
     "Entity",

{ic_python_db-0.7.4 → ic_python_db-0.7.6}/ic_python_db/entity.py

@@ -180,7 +180,8 @@ class Entity:
                 setattr(self, k, v)
         self._do_not_save = False
 
-        self._save()
+        if not self._loaded:
+            self._save()
 
     @classmethod
     def new(cls, **kwargs):
@@ -263,8 +264,8 @@ class Entity:
                     )
             self._update_timestamps(caller_id)
 
-        # Save to database
-        data = self.serialize()
+        # Save to database (full serialization preserves all relations)
+        data = self._serialize_full()
 
         if not self._do_not_save:
             logger.debug(f"Saving entity {self._type}@{self._id} to database")
@@ -386,6 +387,10 @@ class Entity:
         # Create instance first
         entity = cls(**data, _loaded=True)
 
+        # If migration was applied, persist the migrated data
+        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.).
@@ -506,9 +511,14 @@ class Entity:
 
         while len(ret) < count and from_id <= cls.max_id():
             logger.info(f"Loading entity {from_id}")
-            entity = cls.load(str(from_id))
-            if entity:
-                ret.append(entity)
+            try:
+                entity = cls.load(str(from_id))
+                if entity:
+                    ret.append(entity)
+            except (ValueError, AttributeError) as e:
+                # Skip entities with broken/dangling relation references
+                # (full fix: issue #4 — lazy relation resolution)
+                logger.warning(f"Skipping {cls.__name__}@{from_id}: {e}")
             from_id += 1
 
         return ret
@@ -554,19 +564,15 @@ class Entity:
         # Remove from context
         self.__class__._context.discard(self)
 
-    def serialize(self) -> Dict[str, Any]:
-        """Convert the entity to a serializable dictionary.
-
-        Returns:
-            Dict containing the entity's serializable data
-        """
+    def _serialize_base(self) -> Dict[str, Any]:
+        """Shared serialization logic: core data, properties, and instance attributes."""
         # Get mixin data first if available
         data = super().serialize() if hasattr(super(), "serialize") else {}
 
         # Add core entity data
         data.update(
             {
-                "_type": self._type,  # Use the entity type
+                "_type": self._type,
                 "_id": self._id,
             }
         )
@@ -584,30 +590,74 @@ class Entity:
             if not k.startswith("_"):
                 data[k] = v
 
-        # Add relations as references (prefer alias over _id if available)
-        def get_entity_reference(entity):
-            """Get the best reference for an entity: alias value if available, otherwise _id."""
-            if hasattr(entity.__class__, "__alias__") and entity.__class__.__alias__:
-                alias_field = entity.__class__.__alias__
-                alias_value = getattr(entity, alias_field, None)
-                if alias_value is not None:
-                    return alias_value
-            return entity._id
+        return data
+
+    @staticmethod
+    def _get_entity_reference(entity):
+        """Get the best reference for an entity: alias value if available, otherwise _id."""
+        if hasattr(entity.__class__, "__alias__") and entity.__class__.__alias__:
+            alias_field = entity.__class__.__alias__
+            alias_value = getattr(entity, alias_field, None)
+            if alias_value is not None:
+                return alias_value
+        return entity._id
+
+    def _serialize_full(self) -> Dict[str, Any]:
+        """Full serialization including all relations. Used by _save() for persistence."""
+        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))
+
+                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
+                    ]
+
+        return data
+
+    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.
+
+        Returns:
+            Dict containing the entity's serializable data
+        """
+        data = self._serialize_base()
+
+        from ic_python_db.properties import ManyToMany, OneToMany, OneToOne
 
         for rel_name, rel_entities in self._relations.items():
             if rel_entities:
-                # Check if this is a *ToMany relation that should always be a list
                 rel_prop = getattr(self.__class__, rel_name, None)
-                from ic_python_db.properties import ManyToMany, OneToMany
+
+                # Skip OneToMany — always reconstructed from reverse ManyToOne
+                if isinstance(rel_prop, OneToMany):
+                    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:
-                    # Single relation for OneToOne/ManyToOne - store as single reference
-                    data[rel_name] = get_entity_reference(rel_entities[0])
+                    data[rel_name] = self._get_entity_reference(rel_entities[0])
                 else:
-                    # Multiple relations or *ToMany relations - store as list of references
-                    data[rel_name] = [get_entity_reference(e) for e in rel_entities]
+                    data[rel_name] = [
+                        self._get_entity_reference(e) for e in rel_entities
+                    ]
 
         return data
 

{ic_python_db-0.7.4 → ic_python_db-0.7.6/ic_python_db.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ic_python_db
-Version: 0.7.4
+Version: 0.7.6
 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.7.4 → ic_python_db-0.7.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ic_python_db"
-version = "0.7.4"
+version = "0.7.6"
 description = "A lightweight key-value database written in Python, intended for use on the Internet Computer (IC)"
 readme = "README.md"
 authors = [

{ic_python_db-0.7.4 → ic_python_db-0.7.6}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="ic_python_db",
-    version="0.7.4",
+    version="0.7.6",
     author="Smart Social Contracts",
     author_email="smartsocialcontracts@gmail.com",
     description="A lightweight key-value database with entity relationships and audit logging",