surrealdb-orm 0.1.2__tar.gz → 0.1.4__tar.gz

{surrealdb_orm-0.1.2 → surrealdb_orm-0.1.4}/.gitignore

@@ -32,7 +32,6 @@ junit.xml
 
 # Jupyter Notebook
 .ipynb_checkpoints
-*.ipynb
 
 # Environment directories
 .env

{surrealdb_orm-0.1.2 → surrealdb_orm-0.1.4}/Makefile

@@ -1,5 +1,5 @@
 .DEFAULT_GOAL := all
-sources = src tests
+sources = src
 
 .PHONY: .uv  # Check that uv is installed
 .uv:
@@ -20,6 +20,10 @@ lint:
 	uv run ruff format --check
 	uv run ruff check
 
+.PHONY: mypy
+mypy:
+	uv run python -m mypy $(sources)
+
 .PHONY: typecheck
 typecheck:
 	uv run pyright
@@ -41,4 +45,4 @@ html: test-all-python
 	uv run coverage html -d htmlcov
 
 .PHONY: all
-all: format lint typecheck test-all-python
+all: format mypy lint typecheck test-all-python

{surrealdb_orm-0.1.2 → surrealdb_orm-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: surrealdb-orm
-Version: 0.1.2
+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.2
+Alpha 0.1.4
 
 ---
 

{surrealdb_orm-0.1.2 → surrealdb_orm-0.1.4}/README.md

@@ -25,7 +25,7 @@
 
 ## ✅ Version
 
-Alpha 0.1.2
+Alpha 0.1.4
 
 ---
 

{surrealdb_orm-0.1.2 → surrealdb_orm-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "surrealdb-orm"
-version = "0.1.2"
+version = "0.1.4"
 description = "SurrealDB ORM as 'DJango style' for Python with async support. Works with pydantic validation."  
 readme = "README.md"
 requires-python = ">=3.11"
@@ -32,7 +32,7 @@ Repository = "https://github.com/EulogySnowfall/SurrealDB-ORM.git"
 Issues = "https://github.com/EulogySnowfall/SurrealDB-ORM/issues"
 
 [tool.setuptools]
-packages = ["src.surrealdb_orm"]
+packages = ["src/surreal_orm"]
 
 
 [build-system]
@@ -42,6 +42,7 @@ build-backend = "hatchling.build"
 [tool.ruff]
 line-length = 128
 target-version = "py311"
+exclude = ["examples"]
 
 [tool.mypy]
 python_version = "3.11"
@@ -87,7 +88,7 @@ lint = [
 
 
 [tool.hatch.build.targets.wheel]
-packages = ["src.surreal_orm"]
+packages = ["src/surreal_orm"]
 
 [tool.hatch.build.targets.sdist]
-include = ["/README.md", "/Makefile", "/src", "/tests"]
+include = ["README.md", "Makefile", "/src"]

surrealdb_orm-0.1.4/src/surreal_orm/__init__.py

@@ -0,0 +1,12 @@
+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",
+    "SurrealConfigDict",
+]

surrealdb_orm-0.1.4/src/surreal_orm/model_base.py

@@ -0,0 +1,202 @@
+from typing import Any, Self
+from pydantic import BaseModel, ConfigDict, model_validator
+from .connection_manager import SurrealDBConnectionManager
+from surrealdb import RecordID, SurrealDbError
+
+import logging
+
+
+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.
+    """
+
+    @classmethod
+    def get_table_name(cls) -> str:
+        """
+        Get the table name for the model.
+        """
+        return cls.__name__
+
+    @classmethod
+    def get_index_primary_key(cls) -> str | None:
+        """
+        Get the primary key field name for the model.
+        """
+        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
+
+        return None
+
+    def get_id(self) -> None | str | RecordID:
+        """
+        Get the ID of the model instance.
+        """
+        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) -> Self | list[Self]:
+        """
+        Create an instance from a SurrealDB record.
+        """
+        if isinstance(record, list):
+            return [cls.from_db(rs) for rs in record]  # type: ignore
+
+        return cls(**record)
+
+    @model_validator(mode="before")
+    @classmethod
+    def set_data(cls, data: Any) -> Any:
+        """
+        Set the ID of the model instance.
+        """
+        if isinstance(data, dict):  # pragma: no cover
+            if "id" in data and isinstance(data["id"], RecordID):
+                data["id"] = str(data["id"]).split(":")[1]
+            return data
+
+    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 = await client.select(f"{self.get_table_name()}:{self.get_id()}")
+
+        if record is None:
+            raise SurrealDbError("Can't refresh data, no record found.")  # pragma: no cover
+
+        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.model_dump(exclude={"id"})
+        id = self.get_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(table, data)  # pragma: no cover
+
+        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:
+        """
+        Update the model instance to the database.
+        """
+        client = await SurrealDBConnectionManager.get_client()
+
+        data = self.model_dump(exclude={"id"})
+        id = self.get_id()
+        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:
+        """
+        Update the model instance to the database.
+        """
+
+        client = await SurrealDBConnectionManager.get_client()
+        data_set = {key: value for key, value in data.items()}
+
+        id = self.get_id()
+        if id:
+            thing = f"{self.get_table_name()}:{id}"
+
+            await client.merge(thing, data_set)
+            await self.refresh()
+            return
+
+        raise SurrealDbError(f"No Id for the data to merge: {data}")
+
+    async def delete(self) -> None:
+        """
+        Delete the model instance from the database.
+        """
+
+        client = await SurrealDBConnectionManager.get_client()
+
+        id = self.get_id()
+
+        thing = f"{self.get_table_name()}:{id}"
+
+        deleted = await client.delete(thing)
+
+        if not deleted:
+            raise SurrealDbError(f"Can't delete Record id -> '{id}' not found!")
+
+        logger.info(f"Record deleted -> {deleted}.")
+        del self
+
+    @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'."
+            )
+
+        return self
+
+    @classmethod
+    def objects(cls) -> Any:
+        """
+        Return a QuerySet for the model class.
+        """
+        from .query_set import QuerySet
+
+        return QuerySet(cls)

{surrealdb_orm-0.1.2 → surrealdb_orm-0.1.4}/src/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.2/src/surreal_orm/__init__.py

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

surrealdb_orm-0.1.2/src/surreal_orm/model_base.py

@@ -1,229 +0,0 @@
-from typing import Any, Type, Self
-from pydantic import BaseModel, create_model, ConfigDict
-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 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__)
-
-    def __getattr__(self, item: str) -> Any:
-        """
-        If the item is a field in _data, return it,
-        otherwise, let the normal mechanism raise AttributeError.
-        """
-        _data = object.__getattribute__(self, "_data")
-        if item in _data:
-            return _data[item]
-        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{item}'.")
-
-    def __str__(self) -> str:
-        return f"{self._data}"
-
-    def __setattr__(self, key: str, value: Any) -> None:
-        """
-        If we want to allow updates, reinstantiate a Pydantic model
-        with the new value.
-        """
-        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())
-
-    @classmethod
-    def from_db(cls, record: dict | list) -> Any:
-        """
-        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(**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:
-        """
-        Set the model instance data.
-        """
-        if isinstance(data, dict):  # pragma: no cover
-            if "id" in data and isinstance(data["id"], RecordID):  # pragma: no cover
-                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.
-        """
-        client = await SurrealDBConnectionManager.get_client()
-        record = None
-
-        id = self.get_id()
-        record = await client.select(f"{self._table_name}:{id}")
-
-        self._data = self.__set_data(record)
-
-    async def save(self) -> Self:
-        """
-        Save the model instance to the database.
-        """
-        client = await SurrealDBConnectionManager.get_client()
-
-        data = self.to_db_dict()
-        id = self.get_id()
-        if id:
-            thing = f"{self._table_name}:{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)
-
-        return self
-
-    async def update(self) -> Any:
-        """
-        Update the model instance to the database.
-        """
-        client = await SurrealDBConnectionManager.get_client()
-
-        data = self.to_db_dict()
-        id = self.get_id()
-        if id:
-            thing = f"{self._table_name}:{id}"
-            return await client.update(thing, data)
-
-        raise SurrealDbError("Can't update data, no id found.")
-
-    async def merge(self, **data: Any) -> Any:
-        """
-        Update the model instance to the database.
-        """
-
-        client = await SurrealDBConnectionManager.get_client()
-        data_set = {key: value for key, value in data.items()}
-
-        id = self.get_id()
-        if id:
-            thing = f"{self._table_name}:{id}"
-
-            await client.merge(thing, data_set)
-            await self.refresh()
-            return
-
-        raise SurrealDbError(f"No Id for the data to merge: {data}")
-
-    async def delete(self) -> None:
-        """
-        Delete the model instance from the database.
-        """
-
-        client = await SurrealDBConnectionManager.get_client()
-
-        id = self.get_id()
-
-        thing = f"{self._table_name}:{id}"
-
-        deleted = await client.delete(thing)
-
-        if not deleted:
-            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,
-            )
-
-        cls.__pydantic_model_cache__ = pyd_model
-        return pyd_model
-
-    @classmethod
-    def objects(cls) -> Any:
-        """
-        Return a QuerySet for the model class.
-        """
-        from .query_set import QuerySet
-
-        return QuerySet(cls)

surrealdb_orm-0.1.2/tests/test_e2e.py

@@ -1,250 +0,0 @@
-import pytest
-from pydantic import ConfigDict, Field
-from src import surreal_orm
-from surrealdb import RecordID
-from surrealdb.errors import SurrealDbError
-
-
-SURREALDB_URL = "http://localhost:8000"
-SURREALDB_USER = "root"
-SURREALDB_PASS = "root"
-SURREALDB_NAMESPACE = "ns"
-SURREALDB_DATABASE = "db"
-
-
-class ModelTest(surreal_orm.BaseSurrealModel):
-    model_config = ConfigDict(extra="allow")
-    id: str | RecordID | None = Field(default=None)
-    name: str = Field(..., max_length=100)
-    age: int = Field(..., ge=0, le=125)
-
-
-class ModelTestEmpty(surreal_orm.BaseSurrealModel):
-    model_config = ConfigDict(extra="allow")
-    id: str | RecordID | None = Field(default=None)
-    name: str = Field(..., max_length=100)
-    age: int = Field(..., ge=0, le=125)
-
-
-@pytest.fixture(scope="module", autouse=True)
-def setup_surrealdb() -> None:
-    # Initialiser SurrealDB
-    surreal_orm.SurrealDBConnectionManager.set_connection(
-        SURREALDB_URL,
-        SURREALDB_USER,
-        SURREALDB_PASS,
-        SURREALDB_NAMESPACE,
-        SURREALDB_DATABASE,
-    )
-
-
-@pytest.mark.filterwarnings("ignore:fields may not")
-async def test_save_model() -> None:
-    model = ModelTest(id="1", name="Test", age=32)
-    await model.save()
-
-    # Vérification de l'insertion
-    client = await surreal_orm.SurrealDBConnectionManager.get_client()
-    result = await client.select("ModelTest")
-    test_id = RecordID(table_name="ModelTest", identifier=1)
-    assert len(result) == 1
-
-    assert result[0] == {"id": test_id, "name": "Test", "age": 32}
-
-
-async def test_merge_model() -> None:
-    item = await ModelTest.objects().get(1)
-    assert item.name == "Test"
-    assert item.age == 32
-    await item.merge(age=23)  # Also test whole refresh() method
-    item.age = 23
-    item.name = "Test"
-    item.id = "1"
-
-    item2 = await ModelTest.objects().filter(name="Test").get()
-    assert item2.age == 23
-    assert item2.name == "Test"
-    assert item2.id == "1"
-
-
-async def test_update_model() -> None:
-    item = await ModelTest.objects().get(1)
-    assert item.name == "Test"
-    assert item.age == 23
-    item.age = 25
-    await item.update()
-    item2 = await ModelTest.objects().get(1)
-    assert item2.age == 25
-
-    item2 = await ModelTest.objects().filter(name="Test").get()
-    assert item2.age == 25
-    assert item2.name == "Test"
-    assert item2.id == "1"
-
-    item3 = ModelTest(id=None, name="TestNone", age=17)
-
-    with pytest.raises(SurrealDbError) as exc1:
-        await item3.update()
-
-    assert str(exc1.value) == "Can't update data, no id found."
-
-    with pytest.raises(SurrealDbError) as exc2:
-        await item3.merge(age=19)
-
-    assert str(exc2.value) == "No Id for the data to merge: {'age': 19}"
-
-
-async def test_first_model() -> None:
-    model = await ModelTest.objects().filter(name="Test").first()
-    if isinstance(model, ModelTest):
-        assert model.name == "Test"
-        assert model.age == 25
-        assert model.id == "1"
-    else:
-        assert False
-
-    with pytest.raises(SurrealDbError) as exc1:
-        await ModelTest.objects().filter(name="NotExist").first()
-
-    assert str(exc1.value) == "No result found."
-
-
-async def test_filter_model() -> None:
-    item3 = ModelTest(id=None, name="Test2", age=17)
-    await item3.save()
-
-    models = await ModelTest.objects().filter(age__lt=30).exec()  # Test from_db isinstance(record["id"], RecordID)
-    assert len(models) == 2
-    for model in models:
-        assert model.age < 30
-
-
-async def test_delete_model() -> None:
-    model = ModelTest(id="2", name="Test2", age=34)
-    await model.save()
-    client = await surreal_orm.SurrealDBConnectionManager.get_client()
-    result = await client.select("ModelTest")
-    assert len(result) == 3
-
-    await model.delete()
-    result = await client.select("ModelTest")
-    assert len(result) == 2
-
-    model2 = ModelTest(id="345", name="Test2", age=34)
-
-    with pytest.raises(SurrealDbError) as exc1:
-        await model2.delete()  # Test delete() without saved()
-
-    assert str(exc1.value) == "Can't delete Record id -> '345' not found!"
-
-
-async def test_query_model() -> None:
-    # Utiliser test_model pour exécuter la requête
-    results = await ModelTest.objects().filter(name="Test").exec()
-    assert len(results) == 1
-    assert results[0].name == "Test"
-
-
-async def test_multi_select() -> None:
-    await ModelTest(id=None, name="Ian", age=23).save()
-    await ModelTest(id=None, name="Yan", age=32).save()
-    await ModelTest(id=None, name="Isa", age=32).save()
-
-    result = await ModelTest.objects().all()
-
-    assert len(result) == 5
-
-    result2 = await ModelTest.objects().filter(name__in=["Ian", "Yan"]).exec()
-
-    assert len(result2) == 2
-    for item in result2:
-        assert item.name in ["Yan", "Ian"]
-
-
-async def test_order_by() -> None:
-    result1 = await ModelTest.objects().order_by("name").exec()
-    assert len(result1) == 5
-    assert result1[0].name == "Ian"
-
-    result2 = await ModelTest.objects().order_by("name", surreal_orm.OrderBy.DESC).exec()
-    assert len(result2) == 5
-    assert result2[0].name == "Yan"
-
-
-async def test_offset() -> None:
-    result = await ModelTest.objects().offset(2).exec()
-    assert len(result) == 3
-
-
-async def test_limit() -> None:
-    result = await ModelTest.objects().limit(2).exec()
-    assert len(result) == 2
-
-
-async def test_select_field() -> None:
-    result = await ModelTest.objects().select("name", "age").exec()
-    assert len(result) == 5
-    assert isinstance(result[0], dict)
-
-
-async def test_select_with_variable() -> None:
-    result = await ModelTest.objects().filter(age__lte="$max_age").variables(max_age=25).exec()
-    assert len(result) == 3
-    for res in result:
-        assert res.age <= 25
-
-
-async def test_query() -> None:
-    result = await ModelTest.objects().query("SELECT * FROM ModelTest WHERE age > 25")
-    assert len(result) == 2
-    for res in result:
-        assert res.age > 25
-
-    result2 = await ModelTest.objects().query("SELECT * FROM ModelTest WHERE age > $age", {"age": 19})
-    assert len(result2) == 4
-
-    with pytest.raises(SurrealDbError) as exc:
-        await ModelTest.objects().query("SELECT * FROM NoTable WHERE age > 34")
-
-    assert str(exc.value) == "The query must include 'FROM ModelTest' to reference the correct table."
-
-
-async def test_error_on_get_multi() -> None:
-    with pytest.raises(SurrealDbError) as exc1:
-        await ModelTest.objects().get()
-
-    assert str(exc1.value) == "More than one result found."
-
-    with pytest.raises(SurrealDbError) as exc2:
-        await ModelTestEmpty.objects().get()
-
-    assert str(exc2.value) == "No result found."
-
-
-@pytest.mark.filterwarnings("ignore:fields may not")
-async def test_with_primary_key() -> None:
-    class ModelTest2(surreal_orm.BaseSurrealModel):
-        model_config = ConfigDict(extra="allow", primary_key="email")  # type: ignore
-        name: str = Field(..., max_length=100)
-        age: int = Field(..., ge=0, le=125)
-        email: str = Field(..., max_length=100)
-
-    model = ModelTest2(name="Test", age=32, email="test@test.com")
-    await model.save()
-
-    fletch = await ModelTest2.objects().get("test@test.com")
-    if isinstance(fletch, ModelTest2):
-        assert fletch.name == "Test"
-        assert fletch.age == 32
-        assert fletch.email == "test@test.com"
-    else:
-        assert False
-
-    deleted = await ModelTest2.objects().delete_table()
-    assert deleted is True
-
-
-async def test_delete_table() -> None:
-    # Suppression de la table via test_model
-    result = await ModelTest.objects().delete_table()
-    assert result is True

surrealdb_orm-0.1.2/tests/test_manager.py

@@ -1,162 +0,0 @@
-import pytest
-from typing import AsyncGenerator, Any
-from src.surreal_orm import SurrealDBConnectionManager
-from surrealdb.errors import SurrealDbConnectionError
-
-SURREALDB_URL = "http://localhost:8000"
-SURREALDB_USER = "root"
-SURREALDB_PASS = "root"
-SURREALDB_NAMESPACE = "ns"
-SURREALDB_DATABASE = "db"
-
-
-@pytest.fixture
-async def setup_connection_manager() -> AsyncGenerator[Any, Any]:
-    SurrealDBConnectionManager.set_connection(
-        SURREALDB_URL,
-        SURREALDB_USER,
-        SURREALDB_PASS,
-        SURREALDB_NAMESPACE,
-        SURREALDB_DATABASE,
-    )
-    yield
-    await SurrealDBConnectionManager.close_connection()
-
-
-def test_set_connection() -> None:
-    assert SurrealDBConnectionManager.is_connection_set() is True
-
-
-async def test_get_client() -> None:
-    client = await SurrealDBConnectionManager.get_client()
-    assert client is not None
-    assert SurrealDBConnectionManager.is_connected() is True
-    await SurrealDBConnectionManager.close_connection()
-    assert SurrealDBConnectionManager.is_connected() is False
-    await SurrealDBConnectionManager.set_user("wrong_user")
-
-    with pytest.raises(SurrealDbConnectionError) as exc1:
-        await SurrealDBConnectionManager.get_client()
-
-    await SurrealDBConnectionManager.unset_connection()
-    with pytest.raises(ValueError) as exc2:
-        await SurrealDBConnectionManager.get_client()
-
-    assert str(exc1.value) == "Can't connect to the database."
-    assert str(exc2.value) == "Connection not been set."
-
-
-async def test_close_connection() -> None:
-    await SurrealDBConnectionManager.close_connection()
-    assert SurrealDBConnectionManager.is_connected() is False
-
-
-async def test_get_connection_string(setup_connection_manager: AsyncGenerator[Any, Any]) -> None:
-    connection_string = SurrealDBConnectionManager.get_connection_string()
-    assert connection_string == SURREALDB_URL
-
-
-def test_get_connection_kwargs(setup_connection_manager: AsyncGenerator[Any, Any]) -> None:
-    kwargs = SurrealDBConnectionManager.get_connection_kwargs()
-    assert kwargs == {
-        "url": SURREALDB_URL,
-        "user": SURREALDB_USER,
-        "namespace": SURREALDB_NAMESPACE,
-        "database": SURREALDB_DATABASE,
-    }
-
-
-def test_is_connection_set(setup_connection_manager: AsyncGenerator[Any, Any]) -> None:
-    kwargs = SurrealDBConnectionManager.is_connection_set()
-    assert kwargs is True
-
-
-async def test_set_url(setup_connection_manager: AsyncGenerator[Any, Any]) -> None:
-    new_url = "http://localhost:8001"
-    assert await SurrealDBConnectionManager.set_url(new_url) is True
-    assert SurrealDBConnectionManager.get_url() == new_url
-    assert await SurrealDBConnectionManager.set_url(new_url, True) is False  # Cover validate_connection to False
-
-    await SurrealDBConnectionManager.unset_connection()
-    with pytest.raises(ValueError) as exc:
-        await SurrealDBConnectionManager.set_url(new_url)
-
-    assert str(exc.value) == "You can't change the URL when the others setting are not already set."
-
-
-async def test_set_user(setup_connection_manager: AsyncGenerator[Any, Any]) -> None:
-    new_user = "admin"
-    assert await SurrealDBConnectionManager.set_user(new_user) is True
-    assert SurrealDBConnectionManager.get_user() == new_user
-    assert await SurrealDBConnectionManager.set_user(new_user, True) is False  # Cover validate_connection to False
-    assert SurrealDBConnectionManager.get_user() is None
-    await SurrealDBConnectionManager.unset_connection()
-    with pytest.raises(ValueError) as exc:
-        await SurrealDBConnectionManager.set_user(new_user)
-
-    assert str(exc.value) == "You can't change the User when the others setting are not already set."
-
-
-async def test_set_password(setup_connection_manager: AsyncGenerator[Any, Any]) -> None:
-    new_password = "new_pass"
-    assert await SurrealDBConnectionManager.set_password(new_password) is True
-    assert SurrealDBConnectionManager.is_password_set()
-    assert await SurrealDBConnectionManager.set_password(new_password, True) is False  # Cover validate_connection to False
-    assert SurrealDBConnectionManager.is_password_set() is False
-    assert SurrealDBConnectionManager.is_connection_set() is False
-
-    await SurrealDBConnectionManager.unset_connection()
-    with pytest.raises(ValueError) as exc:
-        await SurrealDBConnectionManager.set_password(new_password)
-
-    assert str(exc.value) == "You can't change the password when the others setting are not already set."
-
-
-async def test_set_namespace(setup_connection_manager: AsyncGenerator[Any, Any]) -> None:
-    new_namespace = "new_ns"
-    assert await SurrealDBConnectionManager.set_namespace(new_namespace) is True
-    assert SurrealDBConnectionManager.get_namespace() == new_namespace
-    assert await SurrealDBConnectionManager.set_namespace(new_namespace, True) is True
-    await SurrealDBConnectionManager.set_password("wrong_pass")
-    assert await SurrealDBConnectionManager.set_namespace(new_namespace, True) is False  # Cover validate_connection to False
-
-    await SurrealDBConnectionManager.unset_connection()
-    with pytest.raises(ValueError) as exc:
-        await SurrealDBConnectionManager.set_namespace(new_namespace)
-
-    assert str(exc.value) == "You can't change the namespace when the others setting are not already set."
-
-
-async def test_set_database(setup_connection_manager: AsyncGenerator[Any, Any]) -> None:
-    new_database = "new_db"
-    assert await SurrealDBConnectionManager.set_database(new_database) is True
-    assert SurrealDBConnectionManager.get_database() == new_database
-    assert await SurrealDBConnectionManager.set_database(new_database, True) is True
-    await SurrealDBConnectionManager.set_password("wrong_pass")
-    assert await SurrealDBConnectionManager.set_database(new_database, True) is False  # Cover validate_connection to False
-
-    await SurrealDBConnectionManager.unset_connection()
-    with pytest.raises(ValueError) as exc:
-        await SurrealDBConnectionManager.set_database(new_database)
-
-    assert str(exc.value) == "You can't change the database when the others setting are not already set."
-
-
-async def test_unset() -> None:
-    await SurrealDBConnectionManager.unset_connection()
-    assert SurrealDBConnectionManager.is_connected() is False
-    assert SurrealDBConnectionManager.is_connection_set() is False
-
-
-async def test_reconnect(setup_connection_manager: AsyncGenerator[Any, Any]) -> None:
-    await SurrealDBConnectionManager.close_connection()
-    assert SurrealDBConnectionManager.is_connected() is False
-    await SurrealDBConnectionManager.reconnect()
-    assert SurrealDBConnectionManager.is_connected() is True
-
-
-async def test_context_manager(setup_connection_manager: AsyncGenerator[Any, Any]) -> None:
-    async with SurrealDBConnectionManager():
-        assert SurrealDBConnectionManager.is_connected() is True
-
-    assert SurrealDBConnectionManager.is_connected() is False

surrealdb_orm-0.1.2/tests/test_unit.py

@@ -1,104 +0,0 @@
-import pytest
-from pydantic import ConfigDict, Field
-from src import surreal_orm
-
-
-@pytest.fixture(scope="module", autouse=True)
-def setup_model() -> surreal_orm.BaseSurrealModel:
-    class TestModel(surreal_orm.BaseSurrealModel):
-        model_config = ConfigDict(extra="allow")
-        id: str = Field(...)
-        name: str = Field(..., max_length=100)
-        age: int = Field(..., ge=0)
-
-    return TestModel(id="1", name="Test", age=45)
-
-
-@pytest.mark.filterwarnings("ignore:fields may not")
-def test_model_get_query_set(setup_model: surreal_orm.BaseSurrealModel) -> None:
-    query = setup_model.objects()
-    assert isinstance(query, surreal_orm.QuerySet)
-
-
-def test_model_get_id(setup_model: surreal_orm.BaseSurrealModel) -> None:
-    assert setup_model.get_id() == "1"  # cover _data.get("id") is True
-
-
-def test_model_to_db_dict(setup_model: surreal_orm.BaseSurrealModel) -> None:
-    assert setup_model.to_db_dict() == {"name": "Test", "age": 45}
-
-
-def test_queryset_select() -> None:
-    qs = surreal_orm.BaseSurrealModel.objects().select("id", "name")
-    assert qs.select_item == ["id", "name"]
-
-
-def test_queryset_filter() -> None:
-    qs = surreal_orm.BaseSurrealModel.objects().filter(name="Test", age__gt=18)
-    assert qs._filters == [("name", "exact", "Test"), ("age", "gt", 18)]
-    qs = surreal_orm.BaseSurrealModel.objects().filter(name__in=["Test", "Test2"], age__gte=18)
-    qs = surreal_orm.BaseSurrealModel.objects().filter(age__lte=45)
-    assert qs._filters == [("age", "lte", 45)]
-    qs = surreal_orm.BaseSurrealModel.objects().filter(age__lt=45)
-    assert qs._filters == [("age", "lt", 45)]
-
-
-def test_queryset_variables(setup_model: surreal_orm.BaseSurrealModel) -> None:
-    qs = setup_model.objects().variables(name="Test")
-    assert qs._variables == {"name": "Test"}
-
-
-def test_queryset_limit(setup_model: surreal_orm.BaseSurrealModel) -> None:
-    qs = setup_model.objects().limit(100)
-    assert qs._limit == 100
-
-
-def test_queryset_offset(setup_model: surreal_orm.BaseSurrealModel) -> None:
-    qs = setup_model.objects().offset(100)
-    assert qs._offset == 100
-
-
-def test_queryset_order_by(setup_model: surreal_orm.BaseSurrealModel) -> None:
-    qs = setup_model.objects().order_by("name")
-    assert qs._order_by == "name ASC"
-
-
-def test_getattr(setup_model: surreal_orm.BaseSurrealModel) -> None:
-    assert setup_model.name == "Test"
-    assert setup_model.age == 45
-    assert setup_model.id == "1"
-
-    with pytest.raises(AttributeError) as exc:
-        setup_model.no_attribut
-
-    assert str(exc.value) == "'TestModel' object has no attribute 'no_attribut'."
-
-
-def test_str_dunnder(setup_model: surreal_orm.BaseSurrealModel) -> None:
-    assert str(setup_model) == "{'id': '1', 'name': 'Test', 'age': 45}"
-
-
-@pytest.mark.filterwarnings("ignore:fields may not")
-def test_class_without_config(setup_model: surreal_orm.BaseSurrealModel) -> None:
-    class TestModel2(surreal_orm.BaseSurrealModel):
-        id: str = Field(...)
-        name: str = Field(..., max_length=100)
-        age: int = Field(..., ge=0)
-
-    assert TestModel2(id="1", name="Test", age=45).to_db_dict() == {
-        "name": "Test",
-        "age": 45,
-    }
-
-
-@pytest.mark.filterwarnings("ignore:fields may not")
-def test_class_with_key_specify(setup_model: surreal_orm.BaseSurrealModel) -> None:
-    class TestModel3(surreal_orm.BaseSurrealModel):
-        model_config = ConfigDict(extra="allow", primary_key="email")  # type: ignore
-        name: str = Field(..., max_length=100)
-        age: int = Field(..., ge=0)
-        email: str = Field(..., max_length=100, alias="id")
-
-    model = TestModel3(name="Test", age=45, email="test@test.com")  # type: ignore
-
-    assert model.get_id() == "test@test.com"  # type: ignore