surrealdb-orm 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

surreal_orm/__init__.py

@@ -1,6 +1,12 @@
-from .model_base import BaseSurrealModel
+from .model_base import BaseSurrealModel, SurrealConfigDict
 from .connection_manager import SurrealDBConnectionManager
 from .query_set import QuerySet
 from .enum import OrderBy
 
-__all__ = ["SurrealDBConnectionManager", "BaseSurrealModel", "QuerySet", "OrderBy"]
+__all__ = [
+    "SurrealDBConnectionManager",
+    "BaseSurrealModel",
+    "QuerySet",
+    "OrderBy",
+    "SurrealConfigDict",
+]

surreal_orm/model_base.py

@@ -1,129 +1,132 @@
-from typing import Any, Type, Self
-from pydantic import BaseModel, create_model, ConfigDict
+from typing import Any, Self
+from pydantic import BaseModel, ConfigDict, model_validator
 from .connection_manager import SurrealDBConnectionManager
 from surrealdb import RecordID, SurrealDbError
 
-import warnings
 import logging
 
-warnings.filterwarnings("ignore", message="fields may not start with an underscore", category=RuntimeWarning)
 
 logger = logging.getLogger(__name__)
 
 
+class SurrealConfigDict(ConfigDict):
+    """
+    SurrealConfigDict is a configuration dictionary for SurrealDB models.
+
+    Attributes:
+        primary_key (str | None): The primary key field name for the model.
+    """
+
+    primary_key: str | None
+    " The primary key field name for the model. "
+
+
 class BaseSurrealModel(BaseModel):
     """
     Base class for models interacting with SurrealDB.
     """
 
-    __pydantic_model_cache__: Type[BaseModel] | None = None
-
-    def __init__(self, **data: Any):
-        model_cls = self._init_model()
-        instance = model_cls(**data)
-        object.__setattr__(self, "_data", instance.model_dump())
-        object.__setattr__(self, "_table_name", self.__class__.__name__)
+    @classmethod
+    def get_table_name(cls) -> str:
+        """
+        Get the table name for the model.
+        """
+        return cls.__name__
 
-    def __getattr__(self, item: str) -> Any:
+    @classmethod
+    def get_index_primary_key(cls) -> str | None:
         """
-        If the item is a field in _data, return it,
-        otherwise, let the normal mechanism raise AttributeError.
+        Get the primary key field name for the model.
         """
-        _data = object.__getattribute__(self, "_data")
-        if item in _data:
-            return _data[item]
-        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{item}'.")
+        if hasattr(cls, "model_config"):  # pragma: no cover
+            primary_key = cls.model_config.get("primary_key", None)
+            if isinstance(primary_key, str):
+                return primary_key
 
-    def __str__(self) -> str:
-        return f"{self._data}"
+        return None
 
-    def __setattr__(self, key: str, value: Any) -> None:
+    def get_id(self) -> None | str | RecordID:
         """
-        If we want to allow updates, reinstantiate a Pydantic model
-        with the new value.
+        Get the ID of the model instance.
         """
-        if key in ("_data",):  # and other internal attributes
-            object.__setattr__(self, key, value)
-        else:
-            # Update the dict, validate via Pydantic, etc.
-            current_data = dict(object.__getattribute__(self, "_data"))
-            current_data[key] = value
-            instance = self._init_model()(**current_data)
-            object.__setattr__(self, "_data", instance.model_dump())
+        if hasattr(self, "id"):
+            id_value = getattr(self, "id")
+            return str(id_value) if id_value is not None else None
+
+        if hasattr(self, "model_config"):
+            primary_key = self.model_config.get("primary_key", None)
+            if isinstance(primary_key, str) and hasattr(self, primary_key):
+                primary_key_value = getattr(self, primary_key)
+                return str(primary_key_value) if primary_key_value is not None else None
+
+        return None  # pragma: no cover
 
     @classmethod
-    def from_db(cls, record: dict | list) -> Any:
+    def from_db(cls, record: dict | list) -> Self | list[Self]:
         """
         Create an instance from a SurrealDB record.
         """
         if isinstance(record, list):
-            return [cls.from_db(rs) for rs in record]
-
-        record = cls.__set_data(record)
+            return [cls.from_db(rs) for rs in record]  # type: ignore
 
         return cls(**record)
 
-    def to_db_dict(self) -> dict[str, Any]:
-        """
-        Return a dictionary ready to be inserted into the database.
-        """
-        data_set = {key: value for key, value in self._data.items() if not key.startswith("_") and key != "id"}
-        return data_set
-
-    def show_config(self) -> ConfigDict:
-        # Accès depuis une méthode d'instance
-        return type(self).model_config
-
-    def get_id(self) -> str | RecordID | None:
-        if "id" in self._data:
-            return self._data["id"]
-
-        config = self.show_config()
-        pk_field = config.get("primary_key", "id")
-        return self._data.get(pk_field, None)
-
-    @staticmethod
-    def __set_data(data: Any) -> dict:
+    @model_validator(mode="before")
+    @classmethod
+    def set_data(cls, data: Any) -> Any:
         """
-        Set the model instance data.
+        Set the ID of the model instance.
         """
         if isinstance(data, dict):  # pragma: no cover
-            if "id" in data and isinstance(data["id"], RecordID):  # pragma: no cover
+            if "id" in data and isinstance(data["id"], RecordID):
                 data["id"] = str(data["id"]).split(":")[1]
             return data
 
-        raise TypeError("Data must be a dictionary.")  # pragma: no cover
-
     async def refresh(self) -> None:
         """
         Refresh the model instance from the database.
         """
+        if not self.get_id():
+            raise SurrealDbError("Can't refresh data, not recorded yet.")  # pragma: no cover
+
         client = await SurrealDBConnectionManager.get_client()
-        record = None
+        record = await client.select(f"{self.get_table_name()}:{self.get_id()}")
 
-        id = self.get_id()
-        record = await client.select(f"{self._table_name}:{id}")
+        if record is None:
+            raise SurrealDbError("Can't refresh data, no record found.")  # pragma: no cover
 
-        self._data = self.__set_data(record)
+        self.from_db(record)
+        return None
 
     async def save(self) -> Self:
         """
         Save the model instance to the database.
         """
         client = await SurrealDBConnectionManager.get_client()
-
-        data = self.to_db_dict()
+        data = self.model_dump(exclude={"id"})
         id = self.get_id()
-        if id:
-            thing = f"{self._table_name}:{id}"
+        table = self.get_table_name()
+
+        if id is not None:
+            thing = f"{table}:{id}"
             await client.create(thing, data)
             return self
+
         # Auto-generate the ID
-        record = await client.create(self._table_name, data)  # pragma: no cover
-        if isinstance(record, dict):  # pragma: no cover
-            self._data = self.__set_data(record)
+        record = await client.create(table, data)  # pragma: no cover
 
-        return self
+        if isinstance(record, list):
+            raise SurrealDbError("Can't save data, multiple records returned.")  # pragma: no cover
+
+        if record is None:
+            raise SurrealDbError("Can't save data, no record returned.")  # pragma: no cover
+
+        obj = self.from_db(record)
+        if isinstance(obj, type(self)):
+            self = obj
+            return self
+
+        raise SurrealDbError("Can't save data, no record returned.")  # pragma: no cover
 
     async def update(self) -> Any:
         """
@@ -131,12 +134,12 @@ class BaseSurrealModel(BaseModel):
         """
         client = await SurrealDBConnectionManager.get_client()
 
-        data = self.to_db_dict()
+        data = self.model_dump(exclude={"id"})
         id = self.get_id()
-        if id:
-            thing = f"{self._table_name}:{id}"
-            return await client.update(thing, data)
-
+        if id is not None:
+            thing = f"{self.__class__.__name__}:{id}"
+            test = await client.update(thing, data)
+            return test
         raise SurrealDbError("Can't update data, no id found.")
 
     async def merge(self, **data: Any) -> Any:
@@ -149,7 +152,7 @@ class BaseSurrealModel(BaseModel):
 
         id = self.get_id()
         if id:
-            thing = f"{self._table_name}:{id}"
+            thing = f"{self.get_table_name()}:{id}"
 
             await client.merge(thing, data_set)
             await self.refresh()
@@ -166,7 +169,7 @@ class BaseSurrealModel(BaseModel):
 
         id = self.get_id()
 
-        thing = f"{self._table_name}:{id}"
+        thing = f"{self.get_table_name()}:{id}"
 
         deleted = await client.delete(thing)
 
@@ -174,50 +177,20 @@ class BaseSurrealModel(BaseModel):
             raise SurrealDbError(f"Can't delete Record id -> '{id}' not found!")
 
         logger.info(f"Record deleted -> {deleted}.")
-        self._data = {}
         del self
 
-    @classmethod
-    def _init_model(cls) -> Any:
-        """
-        Generate a real Pydantic model only once (per subclass)
-        from the fields annotated in the class inheriting from BaseSurrealModel.
-        """
-        if cls.__pydantic_model_cache__ is not None:
-            return cls.__pydantic_model_cache__
-
-        # Retrieve the annotations declared in the class (e.g., ModelTest)
-        hints: dict[str, Any] = {}
-        config_dict = None
-        for base in reversed(cls.__mro__):  # To capture all annotations
-            hints.update(getattr(base, "__annotations__", {}))
-            # Optionally, check if the class has 'model_config' to inject it
-            if hasattr(base, "model_config"):
-                config_dict = getattr(base, "model_config")
-
-        # Create the Pydantic model (dynamically)
-        fields = {}
-        for field_name, field_type in hints.items():
-            # Read the object already defined in the class (if Field(...))
-            default_val = getattr(cls, field_name, ...)
-            fields[field_name] = (field_type, default_val)
-
-        # Create model
-        if config_dict:
-            pyd_model = create_model(  # type: ignore
-                f"{cls.__name__}PydModel",
-                __config__=config_dict,
-                **fields,
-            )
-        else:
-            pyd_model = create_model(  # type: ignore
-                f"{cls.__name__}PydModel",
-                __base__=BaseModel,
-                **fields,
+    @model_validator(mode="after")
+    def check_config(self) -> Self:
+        """
+        Check the model configuration.
+        """
+
+        if not self.get_index_primary_key() and not hasattr(self, "id"):
+            raise SurrealDbError(  # pragma: no cover
+                "Can't create model, the model need either 'id' field or primirary_key in 'model_config'."
             )
 
-        cls.__pydantic_model_cache__ = pyd_model
-        return pyd_model
+        return self
 
     @classmethod
     def objects(cls) -> Any:

surreal_orm/query_set.py

@@ -301,7 +301,6 @@ class QuerySet:
         results = await self._execute_query(query)
         try:
             data = cast(dict, results[0])
-
             return self.model.from_db(data["result"])
         except ValidationError as e:
             logger.info(f"Pydantic invalid format for the class, returning dict value: {e}")

{surrealdb_orm-0.1.3.dist-info → surrealdb_orm-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: surrealdb-orm
-Version: 0.1.3
+Version: 0.1.4
 Summary: SurrealDB ORM as 'DJango style' for Python with async support. Works with pydantic validation.
 Project-URL: Homepage, https://github.com/EulogySnowfall/SurrealDB-ORM
 Project-URL: Documentation, https://github.com/EulogySnowfall/SurrealDB-ORM
@@ -70,7 +70,7 @@ Description-Content-Type: text/markdown
 
 ## ✅ Version
 
-Alpha 0.1.3
+Alpha 0.1.4
 
 ---
 

surrealdb_orm-0.1.4.dist-info/RECORD

@@ -0,0 +1,12 @@
+surreal_orm/__init__.py,sha256=p2dnNi1Ar0FNrLlC7oHtYiUrrdYwQKt--72_-omCElk,306
+surreal_orm/connection_manager.py,sha256=kRAK6qhkKRVbhTjWZV6LaOGiH_jClwQ3zzmjca1A5Ro,8561
+surreal_orm/constants.py,sha256=CLavEca1M6cLJLqVl4l4KoE-cBrgVQNsuGxW9zGJBmg,429
+surreal_orm/enum.py,sha256=kR-vzkHqnqy9YaYOvWTwAHdl2-WCzPcSEch-YTyJv1Y,158
+surreal_orm/model_base.py,sha256=zz6y8TQavk0XvLhunzQflJpPG85FizeCR-mAy-LHlK8,6082
+surreal_orm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+surreal_orm/query_set.py,sha256=VD8F2vKv5_uIXRCV_0HCx6lnarF-Qx3x8MYJq2LH78U,18155
+surreal_orm/utils.py,sha256=mni_dTtb4VGTdge8eWSZpBw5xoWci2m-XThKFHYPKTo,171
+surrealdb_orm-0.1.4.dist-info/METADATA,sha256=AFDw-vOKASG0mGa73Zo9CcaQKe-E-ocia3tOUJdcELY,5980
+surrealdb_orm-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+surrealdb_orm-0.1.4.dist-info/licenses/LICENSE,sha256=TO3Ub0nPPx5NxwjsDuBAu3RBdBLmdDybqC5dem4oGts,1074
+surrealdb_orm-0.1.4.dist-info/RECORD,,

surrealdb_orm-0.1.3.dist-info/RECORD

@@ -1,11 +0,0 @@
-surreal_orm/__init__.py,sha256=RNoDt0Gt7_jTjzxzXGPXKUqe7EnCdt31b35tnA-JcOM,243
-surreal_orm/connection_manager.py,sha256=kRAK6qhkKRVbhTjWZV6LaOGiH_jClwQ3zzmjca1A5Ro,8561
-surreal_orm/constants.py,sha256=CLavEca1M6cLJLqVl4l4KoE-cBrgVQNsuGxW9zGJBmg,429
-surreal_orm/enum.py,sha256=kR-vzkHqnqy9YaYOvWTwAHdl2-WCzPcSEch-YTyJv1Y,158
-surreal_orm/model_base.py,sha256=U9ZJeOS75uJXMvhKTNy8I2QDXMxoF5eVUkQe-vesggk,7358
-surreal_orm/query_set.py,sha256=ng-jTFWiUpxPJH-KC7SNxZ2PwmciCnkOifOWa7A2KEs,18156
-surreal_orm/utils.py,sha256=mni_dTtb4VGTdge8eWSZpBw5xoWci2m-XThKFHYPKTo,171
-surrealdb_orm-0.1.3.dist-info/METADATA,sha256=T9tXMFp3th-r4FMnFQt2s8z4Pz5zCs0_KoE33k64-gU,5980
-surrealdb_orm-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-surrealdb_orm-0.1.3.dist-info/licenses/LICENSE,sha256=TO3Ub0nPPx5NxwjsDuBAu3RBdBLmdDybqC5dem4oGts,1074
-surrealdb_orm-0.1.3.dist-info/RECORD,,