objectdb 0.7.0__tar.gz

objectdb-0.7.0/.gitignore

@@ -0,0 +1,13 @@
+.mypy_cache
+.pytest_cache
+__pycache__
+.coverage
+*.py,cover
+/build/
+/metrics/
+/.devcontainer/.user_env
+dist/
+
+# Secrets
+.env
+.rustc_info.json

objectdb-0.7.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: objectdb
+Version: 0.7.0
+Author: Felix Trautwein <mail@felixtrautwein.de>
+Requires-Dist: bson>=0.5.10
+Requires-Dist: mongomock-motor>=0.0.36
+Requires-Dist: motor>=3.7.1
+Requires-Dist: pytest-asyncio>=1.2.0

objectdb-0.7.0/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "objectdb"
+version = "0.7.0"
+description = ""
+authors = [{name = "Felix Trautwein <mail@felixtrautwein.de>"}]
+
+
+dependencies = [
+    "motor>=3.7.1",
+    "mongomock_motor>=0.0.36",
+    "pytest-asyncio>=1.2.0",
+    "bson>=0.5.10"
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

objectdb-0.7.0/src/objectdb/database.py

@@ -0,0 +1,200 @@
+"""Database abstraction layer."""
+
+from __future__ import annotations
+
+import copy
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Generic, Optional, Type, TypeVar
+
+import pydantic
+from bson import ObjectId
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import core_schema
+
+T = TypeVar("T", bound="DatabaseItem")
+
+
+class ForeignKey(Generic[T]):
+    """A reference to another DatabaseItem."""
+
+    def __init__(self, target_type: type[T], identifier: str):
+        self.target_type = target_type
+        self.identifier = identifier
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, ForeignKey)
+            and self.target_type == other.target_type
+            and self.identifier == other.identifier
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.target_type, self.identifier))
+
+    def __repr__(self) -> str:
+        return f"ForeignKey({self.target_type.__name__}:{self.identifier})"
+
+    #
+    # --- Pydantic integration ---
+    #
+    @classmethod
+    def __class_getitem__(cls, item: type[T]):
+        target_type = item
+
+        class _ForeignKey(cls):  # type: ignore
+            __origin__ = cls
+            __args__ = (item,)
+
+            @classmethod
+            def __get_pydantic_core_schema__(cls, source_type, handler: GetCoreSchemaHandler):
+                def validator(v):
+                    if isinstance(v, ForeignKey):
+                        return v
+                    if isinstance(v, target_type):
+                        return ForeignKey(target_type, v.identifier)
+                    if isinstance(v, str):
+                        return ForeignKey(target_type, v)
+                    raise TypeError(f"Cannot convert {v!r} to ForeignKey[{target_type.__name__}]")
+
+                return core_schema.no_info_after_validator_function(
+                    validator,
+                    core_schema.union_schema(
+                        [
+                            core_schema.is_instance_schema(target_type),
+                            core_schema.str_schema(),
+                            core_schema.is_instance_schema(ForeignKey),
+                        ]
+                    ),
+                )
+
+            @classmethod
+            def __get_pydantic_json_schema__(cls, _core_schema, handler):
+                # Expose as string in OpenAPI
+                return handler(core_schema.str_schema())
+
+        return _ForeignKey
+
+
+class PyObjectId(ObjectId):
+    """Custom ObjectId type for Pydantic."""
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source, _handler) -> core_schema.PlainValidatorFunctionSchema:
+        return core_schema.no_info_plain_validator_function(cls.validate)
+
+    @classmethod
+    def validate(cls, v: Any) -> PyObjectId:
+        """Validate and convert to ObjectId."""
+        if isinstance(v, ObjectId):
+            return cls(v)
+        if not ObjectId.is_valid(v):
+            raise ValueError(f"Invalid ObjectId: {v}")
+        return cls(v)
+
+
+class DatabaseItem(ABC, pydantic.BaseModel):
+    """Base class for database items."""
+
+    model_config = pydantic.ConfigDict(
+        revalidate_instances="always", json_encoders={ObjectId: str}, populate_by_name=True
+    )
+    identifier: PyObjectId = pydantic.Field(default_factory=PyObjectId, alias="_id")
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DatabaseItem):
+            return NotImplemented
+        return self.identifier == other.identifier
+
+    def __hash__(self) -> int:
+        return hash(self.identifier)
+
+
+class DatabaseError(Exception):
+    """Errors related to database operations."""
+
+
+class UnknownEntityError(DatabaseError):
+    """Requested entity does not exist."""
+
+
+class Database(ABC):
+    """Database abstraction."""
+
+    @abstractmethod
+    async def update(self, item: DatabaseItem) -> None:
+        """Update entity."""
+
+    @abstractmethod
+    async def get(self, schema: Type[T], identifier: PyObjectId) -> T:
+        """Return entity, raise UnknownEntityError if entity does not exist."""
+
+    @abstractmethod
+    async def get_all(self, schema: Type[T]) -> Dict[str, T]:
+        """Return all entities of schema."""
+
+    @abstractmethod
+    async def delete(self, schema: Type[T], identifier: PyObjectId, cascade: bool = False) -> None:
+        """Delete entity."""
+
+    @abstractmethod
+    async def find(self, schema: Type[T], **kwargs: str) -> Optional[Dict[PyObjectId, T]]:
+        """Return all entities of schema matching the filter criteria."""
+
+    @abstractmethod
+    async def find_one(self, schema: Type[T], **kwargs: str) -> Optional[T]:
+        """Return one entitiy of schema matching the filter criteria, raise if multiple exist."""
+
+
+class DictDatabase(Database):
+    """Simple Database implementation with dictionary."""
+
+    def __init__(self) -> None:
+        self.data: Dict[Type[DatabaseItem], Dict[PyObjectId, DatabaseItem]] = {}
+
+    async def update(self, item: DatabaseItem) -> None:
+        """Update data."""
+        item_type = type(item)
+        if item_type not in self.data:
+            self.data[item_type] = {}
+        self.data[item_type][item.identifier] = copy.deepcopy(item)
+
+    async def get(self, schema: Type[T], identifier: PyObjectId) -> T:
+        try:
+            return self.data[schema][identifier]  # type: ignore
+        except KeyError as exc:
+            raise UnknownEntityError(f"Unknown identifier: {identifier}") from exc
+
+    async def get_all(self, schema: Type[T]) -> Dict[str, T]:
+        try:
+            return self.data[schema]  # type: ignore
+        except KeyError as exc:
+            raise DatabaseError(f"Unkonwn schema: {schema}") from exc
+
+    async def delete(self, schema: Type[T], identifier: PyObjectId, cascade: bool = False) -> None:
+        try:
+            del self.data[schema][identifier]
+        except KeyError as exc:
+            raise UnknownEntityError(f"Unknown identifier: {identifier}") from exc
+        if cascade:
+            for db in self.data:
+                for identifier, item in self.data[db].items():
+                    for attribute in item.__class__.model_fields:
+                        if isinstance(attribute, ForeignKey) and attribute == item.identifier:
+                            del self.data[db][identifier]
+
+    async def find(self, schema: Type[T], **kwargs: str) -> Optional[Dict[PyObjectId, T]]:
+        try:
+            results = []
+            for item in self.data[schema].values():  # type: ignore
+                if all(getattr(item, k) == v for k, v in kwargs.items()):
+                    results.append(item)  # type: ignore
+            return {item.identifier: item for item in results}  # type: ignore
+        except KeyError as exc:
+            raise DatabaseError(f"Unkonwn schema: {schema}") from exc
+
+    async def find_one(self, schema: Type[T], **kwargs: str) -> Optional[T]:
+        if results := await self.find(schema, **kwargs):
+            if len(results) > 1:
+                raise DatabaseError(f"Multiple entities found for {schema} with {kwargs}")
+            return list(results.values())[0]
+        return None

objectdb-0.7.0/src/objectdb/database_mongodb.py

@@ -0,0 +1,52 @@
+"""Redis Database implementation."""
+
+from typing import Any, Dict, Mapping, Optional, Type
+
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorDatabase
+from objectdb.database import Database, DatabaseItem, PyObjectId, T, UnknownEntityError
+
+
+class MongoDBDatabase(Database):
+    """MongoDB database implementation."""
+
+    def __init__(self, mongodb_client: AsyncIOMotorClient, name: str) -> None:
+        self.connection: AsyncIOMotorClient[Mapping[str, dict[str, Any]]] = mongodb_client
+        self.database: AsyncIOMotorDatabase[Mapping[str, dict[str, Any]]] = self.connection[name]
+
+    async def update(self, item: DatabaseItem):
+        """Update data."""
+        item_type = type(item)
+        item.model_validate(item)
+        await self.database[item_type.__name__].update_one(
+            filter={"_id": item.identifier},
+            update={"$set": item.model_dump(by_alias=True, exclude={"_id"})},
+            upsert=True,
+        )
+
+    async def get(self, schema: Type[T], identifier: PyObjectId) -> T:
+        collection = self.database[schema.__name__]
+        if res := await collection.find_one(filter={"_id": identifier}):
+            return schema.model_validate(res)
+        raise UnknownEntityError(f"Unknown identifier: {identifier}")
+
+    async def get_all(self, schema: Type[T]) -> Dict[str, T]:
+        raise NotImplementedError
+
+    async def delete(self, schema: Type[T], identifier: PyObjectId, cascade: bool = False) -> None:
+        collection = self.database[schema.__name__]
+        result = await collection.delete_one(filter={"_id": identifier})
+        if result.deleted_count != 1:
+            raise UnknownEntityError(f"Unknown identifier: {identifier}")
+
+    async def find(self, schema: Type[T], **kwargs: Any) -> Optional[Dict[PyObjectId, T]]:
+        collection = self.database[schema.__name__]
+        if results := collection.find(filter=kwargs):
+            return {res["_id"]: schema.model_validate(res) async for res in results}
+        return None
+
+    async def find_one(self, schema: Type[T], **kwargs: Any) -> Optional[T]:
+        """Find one item matching the criteria."""
+        collection = self.database[schema.__name__]
+        if result := await collection.find_one(filter=kwargs):
+            return schema.model_validate(result)
+        return None

objectdb-0.7.0/tests/conftest.py

@@ -0,0 +1,15 @@
+from typing import AsyncGenerator
+
+import pytest
+from mongomock_motor import AsyncMongoMockClient
+from motor.motor_asyncio import AsyncIOMotorClient
+from objectdb.database_mongodb import MongoDBDatabase  # your class
+
+
+@pytest.fixture
+async def mongo_db() -> AsyncGenerator[MongoDBDatabase, None]:
+    """Return a MongoDBDatabase instance backed by mongomock_motor."""
+    client: AsyncIOMotorClient = AsyncMongoMockClient()
+    db = MongoDBDatabase(mongodb_client=client, name="test_db")
+    yield db
+    await client.drop_database("test_db")

objectdb-0.7.0/tests/test_database.py

@@ -0,0 +1,66 @@
+"""Tests for database module."""
+
+import pytest
+from objectdb.database import DatabaseItem, DictDatabase, ForeignKey, UnknownEntityError
+
+
+class Customer(DatabaseItem):
+    """Sample item for testing."""
+
+    name: str
+    city: str
+
+
+class Product(DatabaseItem):
+    """Sample item for testing."""
+
+    name: str
+    customer: ForeignKey[Customer]
+
+
+@pytest.mark.asyncio
+async def test_add_item() -> None:
+    """Test adding item to database."""
+    test_item = Customer(name="name", city="city")
+    db = DictDatabase()
+    await db.update(test_item)
+    assert db.get(Customer, test_item.identifier)
+
+
+@pytest.mark.asyncio
+async def test_update_item() -> None:
+    """Test updating item in database."""
+    test_item = Customer(name="name", city="city")
+    db = DictDatabase()
+    await db.update(test_item)
+    item_to_change = await db.get(Customer, test_item.identifier)
+    item_to_change.city = "changed_city"
+    await db.update(item_to_change)
+    updated_item = await db.get(Customer, test_item.identifier)
+    assert updated_item.city == "changed_city"
+
+
+@pytest.mark.asyncio
+async def test_delete_item() -> None:
+    """Test deleting items."""
+    test_item = Customer(name="name", city="city")
+    db = DictDatabase()
+    await db.update(test_item)
+    assert db.get(type(test_item), test_item.identifier)
+    await db.delete(type(test_item), test_item.identifier)
+    with pytest.raises(UnknownEntityError):
+        await db.get(type(test_item), test_item.identifier)
+
+
+@pytest.mark.skip(reason="Not implemented yet")
+@pytest.mark.asyncio
+async def test_cascading_delete() -> None:
+    """Test cascading delete of items with foreign keys."""
+    customer = Customer(name="name", city="city")
+    db = DictDatabase()
+    await db.update(customer)
+    product = Product(name="product", customer=customer)  # type: ignore
+    await db.update(product)
+    await db.delete(type(customer), customer.identifier)
+    with pytest.raises(UnknownEntityError):
+        await db.get(type(product), product.identifier)

objectdb-0.7.0/tests/test_database_mongodb.py

@@ -0,0 +1,109 @@
+"""Tests for the MongoDB database implementation."""
+
+import pytest
+from objectdb.database import DatabaseItem
+from objectdb.database_mongodb import MongoDBDatabase, UnknownEntityError
+
+
+class User(DatabaseItem):
+    """Test user entity."""
+
+    name: str
+    email: str
+
+
+@pytest.mark.asyncio
+async def test_insert_and_get(mongo_db: MongoDBDatabase) -> None:
+    """Test inserting and retrieving an item."""
+    # GIVEN a user
+    user = User(name="Alice", email="alice@example.com")
+    # WHEN inserting it into the database
+    await mongo_db.update(user)
+    # THEN it can be retrieved by its identifier
+    fetched = await mongo_db.get(User, identifier=user.identifier)
+    assert fetched.name == "Alice"
+    assert fetched.identifier == user.identifier
+
+
+@pytest.mark.asyncio
+async def test_update_existing(mongo_db: MongoDBDatabase) -> None:
+    """Test updating an existing item."""
+    # GIVEN a user in the database
+    user = User(name="Bob", email="box@example.com")
+    await mongo_db.update(user)
+    # WHEN updating the user's email
+    user.email = "bob@example.com"
+    await mongo_db.update(user)
+    # THEN the change is reflected in the database
+    fetched = await mongo_db.get(User, identifier=user.identifier)
+    assert fetched.email == "bob@example.com"
+
+
+@pytest.mark.asyncio
+async def test_delete_existing(mongo_db: MongoDBDatabase) -> None:
+    """Test deleting an item."""
+    # GIVEN a user in the database
+    user = User(name="Charlie", email="charlie@example.com")
+    await mongo_db.update(user)
+    # WHEN deleting the user
+    await mongo_db.delete(type(user), user.identifier)
+    # THEN the user can no longer be retrieved
+    with pytest.raises(UnknownEntityError):
+        await mongo_db.get(User, identifier=user.identifier)
+
+
+@pytest.mark.asyncio
+async def test_get_unknown(mongo_db: MongoDBDatabase) -> None:
+    """Test retrieving an unknown item raises an error."""
+    # GIVEN a user that does not exist in the database
+    user = User(name="Dave", email="dave@example.com")
+    # WHEN trying to get a user with a random identifier
+    with pytest.raises(UnknownEntityError):
+        await mongo_db.get(User, identifier=user.identifier)
+
+
+@pytest.mark.asyncio
+async def test_find_users(mongo_db: MongoDBDatabase) -> None:
+    """Test finding users by attribute."""
+    # GIVEN multiple users in the database
+    user1 = User(name="Eve", email="eve@example.com")
+    user2 = User(name="Frank", email="frank@example.com")
+    await mongo_db.update(user1)
+    await mongo_db.update(user2)
+    # WHEN finding users by name
+    results = await mongo_db.find(User, name="Eve")
+    # THEN only the matching user is returned
+    assert results == {user1.identifier: user1}
+
+
+@pytest.mark.asyncio
+async def test_find_one_user(mongo_db: MongoDBDatabase) -> None:
+    """Test finding a single user by attribute."""
+    # GIVEN two users in the database
+    user = User(name="Grace", email="grace@example.com")
+    User(name="Heidi", email="heidi@example.com")
+    await mongo_db.update(user)
+    # WHEN finding the user by name
+    result = await mongo_db.find_one(User, name="Grace")
+    # THEN the correct user is returned
+    assert result == user
+
+
+@pytest.mark.asyncio
+async def test_find_one_user_not_found(mongo_db: MongoDBDatabase) -> None:
+    """Test finding a single user that does not exist."""
+    # GIVEN no users in the database
+    # WHEN finding a user by name that does not exist
+    # THEN None is returned
+    assert await mongo_db.find_one(User, name="NonExistentUser") is None
+
+
+@pytest.mark.asyncio
+async def test_delete_unknown(mongo_db: MongoDBDatabase) -> None:
+    """Test deleting an unknown item raises an error."""
+    # GIVEN a user that does not exist in the database
+    user = User(name="Ivan", email="ivan@example.com")
+    # WHEN trying to delete the user
+    # THEN an UnknownEntityError is raised
+    with pytest.raises(UnknownEntityError):
+        await mongo_db.delete(User, user.identifier)