metaorm 0.1.0__tar.gz

metaorm-0.1.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: metaorm
+Version: 0.1.0
+Summary: Async repository layer over SQLModel
+Author-email: Author Name <author@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/username/metaorm
+Project-URL: Repository, https://github.com/username/metaorm
+Project-URL: Issues, https://github.com/username/metaorm/issues
+Keywords: async,database,orm,repository,sqlmodel
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pydantic-filters>=0.3.5
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: sqlmodel>=0.0.22

metaorm-0.1.0/metaorm/__init__.py

@@ -0,0 +1,26 @@
+from .container import RepositoriesContainer
+from .exceptions import (
+    AlreadyExistsError,
+    DatabaseException,
+    HaveNoSessionError,
+    NotFoundError,
+)
+from .repositories import BaseRepository
+from .settings import DatabaseSettings
+from .tables import BaseTable
+
+__all__ = (
+    # container
+    "RepositoriesContainer",
+    # exceptions
+    "AlreadyExistsError",
+    "DatabaseException",
+    "HaveNoSessionError",
+    "NotFoundError",
+    # repositories
+    "BaseRepository",
+    # settings
+    "DatabaseSettings",
+    # tables
+    "BaseTable",
+)

metaorm-0.1.0/metaorm/container.py

@@ -0,0 +1,60 @@
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from typing import TypeVar
+
+import contextvars
+
+from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from .settings import DatabaseSettings
+
+
+RepositoryType = TypeVar("RepositoryType", bound="BaseRepository")
+
+
+class RepositoriesContainer:
+    def __init__(self, settings: DatabaseSettings):
+        engine_parameters = {
+            "url": settings.dsn,
+            "pool_recycle": settings.pool_recycle,
+        }
+        if not settings.dsn.startswith("sqlite"):
+            engine_parameters["pool_timeout"] = settings.pool_timeout
+            engine_parameters["pool_size"] = settings.pool_size
+
+        self._engine = create_async_engine(**engine_parameters)
+        self._session_context = contextvars.ContextVar(
+            "session_context",
+            default=None,
+        )
+
+    @property
+    def engine(self) -> AsyncEngine:
+        return self._engine
+
+    @property
+    def session(self) -> AsyncSession | None:
+        return self._session_context.get()
+
+    @asynccontextmanager
+    async def transaction(self) -> AsyncGenerator[AsyncSession, None]:
+        existing_session = self._session_context.get()
+        if existing_session is not None:
+            yield existing_session
+            return
+
+        session_parameters = {
+            "bind": self._engine,
+            "expire_on_commit": False,
+        }
+        async with AsyncSession(**session_parameters) as session:
+            token = self._session_context.set(session)
+            try:
+                async with session.begin():
+                    yield session
+            finally:
+                self._session_context.reset(token)
+
+    def get_repository(self, repository_class: type[RepositoryType]) -> RepositoryType:
+        return repository_class(container=self)

metaorm-0.1.0/metaorm/exceptions.py

@@ -0,0 +1,17 @@
+class DatabaseException(Exception):
+    pass
+
+
+class NotFoundError(DatabaseException):
+    def __init__(self, detail: str = "Not found"):
+        super().__init__(detail)
+
+
+class HaveNoSessionError(DatabaseException):
+    def __init__(self):
+        super().__init__("Have no actual session")
+
+
+class AlreadyExistsError(DatabaseException):
+    def __init__(self, detail: str = "Record already exists"):
+        super().__init__(detail)

metaorm-0.1.0/metaorm/repositories.py

@@ -0,0 +1,150 @@
+from collections.abc import AsyncGenerator, Sequence
+from contextlib import asynccontextmanager
+from typing import Any, Generic, TypeVar
+
+from pydantic_filters import BasePagination, BaseSort
+from pydantic_filters.drivers.sqlalchemy import append_to_statement
+from sqlalchemy import func
+from sqlalchemy.exc import IntegrityError
+from sqlmodel import delete, insert, select, update
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from .container import RepositoriesContainer
+from .exceptions import AlreadyExistsError, DatabaseException, HaveNoSessionError
+from .tables import BaseTable
+
+
+DTOType = TypeVar("DTOType")
+FilterType = TypeVar("FilterType")
+
+
+class BaseRepository(Generic[DTOType, FilterType]):
+    def __init__(self, container: RepositoriesContainer):
+        self._container = container
+
+    @property
+    def session(self) -> AsyncSession:
+        session = self._container.session
+        if session is None:
+            raise HaveNoSessionError()
+        return session
+
+    @asynccontextmanager
+    async def transaction(self) -> AsyncGenerator[None, None]:
+        existing_session = self._container.session
+        if existing_session is not None:
+            yield
+            return
+
+        async with self._container.transaction():
+            yield
+
+    def get_db_table(self) -> type[BaseTable]:
+        raise NotImplementedError
+
+    async def create_tables(self) -> None:
+        table = self.get_db_table()
+        async with self._container.engine.begin() as connection:
+            await connection.run_sync(
+                table.metadata.create_all,
+                tables=[table.__table__],
+            )
+
+    async def get_items_count(
+        self,
+        filter_: FilterType | None = None,
+    ) -> int:
+        table = self.get_db_table()
+        statement = select(func.count()).select_from(table)
+        statement = append_to_statement(
+            statement=statement,
+            model=table,
+            filter_=filter_,
+        )
+
+        async with self.transaction():
+            result = await self.session.exec(statement)
+            items_count = result.first()
+
+        return items_count
+
+    async def get_items(
+        self,
+        filter_: FilterType | None = None,
+        pagination: BasePagination | None = None,
+        sort: BaseSort | None = None,
+        options: Sequence[Any] | None = None,
+    ) -> AsyncGenerator[DTOType]:
+        table = self.get_db_table()
+        statement = select(table)
+        statement = append_to_statement(
+            statement=statement,
+            model=table,
+            filter_=filter_,
+            pagination=pagination,
+            sort=sort,
+        )
+        if options:
+            statement = statement.options(*options)
+
+        async with self.transaction():
+            result = await self.session.execute(statement)
+            result = result.yield_per(100)
+            for db_item in result.scalars():
+                yield db_item.to_item()
+
+    async def create_item(self, item: DTOType) -> DTOType:
+        table = self.get_db_table()
+        values = table.from_item(item=item).to_values()
+        statement = insert(table).values(values).returning(table)
+
+        async with self.transaction():
+            try:
+                result = await self.session.exec(statement)
+            except IntegrityError as error:
+                error_message = str(error.orig).lower()
+                if "unique" in error_message or "duplicate" in error_message:
+                    raise AlreadyExistsError(
+                        f"Record for model '{table.__name__}' already exists",
+                    ) from error
+                raise DatabaseException(
+                    f"Integrity error for model '{table.__name__}'",
+                ) from error
+            db_item = result.scalar_one()
+
+        return db_item.to_item()
+
+    async def update_items(
+        self,
+        filter_: FilterType | None = None,
+        **values,
+    ) -> AsyncGenerator[DTOType]:
+        table = self.get_db_table()
+        statement = update(table)
+        statement = append_to_statement(
+            statement=statement,
+            model=table,
+            filter_=filter_,
+        )
+        statement = statement.values(**values).returning(table)
+
+        async with self.transaction():
+            result = await self.session.exec(statement)
+            result = result.yield_per(100)
+            for db_item in result.scalars():
+                yield db_item.to_item()
+
+    async def delete_items(
+        self,
+        filter_: FilterType | None = None,
+    ) -> None:
+        table = self.get_db_table()
+        statement = delete(table)
+        statement = append_to_statement(
+            statement=statement,
+            model=table,
+            filter_=filter_,
+        )
+
+        async with self.transaction():
+            await self.session.exec(statement)

metaorm-0.1.0/metaorm/settings.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel, Field
+
+
+class DatabaseSettings(BaseModel):
+    dsn: str = Field(default="sqlite+aiosqlite:///db.sqlite3", pattern=r"^.+://")
+    pool_size: int = Field(default=5, ge=1)
+    pool_recycle: int = Field(default=60, ge=1)  # in seconds: 1 minute
+    pool_timeout: int = Field(default=60, ge=1)  # in seconds: 1 minute

metaorm-0.1.0/metaorm/tables.py

@@ -0,0 +1,21 @@
+from typing import Any, Generic, Self, TypeVar
+
+from pydantic import BaseModel
+from sqlmodel import SQLModel
+
+
+ItemType = TypeVar("ItemType", bound=BaseModel)
+
+
+class BaseTable(SQLModel, Generic[ItemType]):
+    @classmethod
+    def from_item(cls, item: ItemType) -> Self:
+        raise NotImplementedError
+
+    def to_item(self) -> ItemType:
+        raise NotImplementedError
+
+    def to_values(self) -> dict[str, Any]:
+        return {
+            column.name: getattr(self, column.name) for column in self.__table__.columns
+        }

metaorm-0.1.0/metaorm.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: metaorm
+Version: 0.1.0
+Summary: Async repository layer over SQLModel
+Author-email: Author Name <author@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/username/metaorm
+Project-URL: Repository, https://github.com/username/metaorm
+Project-URL: Issues, https://github.com/username/metaorm/issues
+Keywords: async,database,orm,repository,sqlmodel
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pydantic-filters>=0.3.5
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: sqlmodel>=0.0.22

metaorm-0.1.0/metaorm.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+metaorm/__init__.py
+metaorm/container.py
+metaorm/exceptions.py
+metaorm/repositories.py
+metaorm/settings.py
+metaorm/tables.py
+metaorm.egg-info/PKG-INFO
+metaorm.egg-info/SOURCES.txt
+metaorm.egg-info/dependency_links.txt
+metaorm.egg-info/requires.txt
+metaorm.egg-info/top_level.txt
+tests/test_container.py
+tests/test_exceptions.py
+tests/test_repositories.py
+tests/test_settings.py
+tests/test_tables.py

metaorm-0.1.0/metaorm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

metaorm-0.1.0/metaorm.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pydantic>=2.0
+pydantic-filters>=0.3.5
+sqlalchemy>=2.0
+sqlmodel>=0.0.22

metaorm-0.1.0/metaorm.egg-info/top_level.txt

@@ -0,0 +1 @@
+metaorm

metaorm-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "metaorm"
+version = "0.1.0"
+description = "Async repository layer over SQLModel"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.12"
+authors = [
+    {name = "Author Name", email = "author@example.com"},
+]
+keywords = [
+    "async",
+    "database",
+    "orm",
+    "repository",
+    "sqlmodel",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "pydantic>=2.0",
+    "pydantic-filters>=0.3.5",
+    "sqlalchemy>=2.0",
+    "sqlmodel>=0.0.22",
+]
+
+[project.urls]
+Homepage = "https://github.com/username/metaorm"
+Repository = "https://github.com/username/metaorm"
+Issues = "https://github.com/username/metaorm/issues"
+
+[dependency-groups]
+dev = [
+    "aiosqlite>=0.22.0",
+    "pytest>=9.1.1",
+    "pytest-asyncio>=1.4.0",
+    "pytest-cov>=7.1.0",
+    "ruff>=0.16.2",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["metaorm*"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

metaorm-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

metaorm-0.1.0/tests/test_container.py

@@ -0,0 +1,47 @@
+import pytest
+from sqlalchemy.ext.asyncio import AsyncEngine
+
+from metaorm import HaveNoSessionError, RepositoriesContainer
+from tests.models import UserRepository
+
+
+class TestRepositoriesContainer:
+    async def test_engine_property_returns_async_engine(
+        self,
+        repositories_container: RepositoriesContainer,
+    ) -> None:
+        assert isinstance(repositories_container.engine, AsyncEngine)
+
+    async def test_session_is_none_without_transaction(
+        self,
+        repositories_container: RepositoriesContainer,
+    ) -> None:
+        assert repositories_container.session is None
+
+    async def test_transaction_creates_session(
+        self,
+        repositories_container: RepositoriesContainer,
+    ) -> None:
+        assert repositories_container.session is None
+
+        async with repositories_container.transaction() as session:
+            assert session is not None
+            assert repositories_container.session is session
+
+        assert repositories_container.session is None
+
+    async def test_nested_transaction_yields_same_session(
+        self,
+        repositories_container: RepositoriesContainer,
+    ) -> None:
+        async with repositories_container.transaction() as outer_session:
+            async with repositories_container.transaction() as inner_session:
+                assert inner_session is outer_session
+
+    async def test_get_repository_returns_repository_instance(
+        self,
+        repositories_container: RepositoriesContainer,
+    ) -> None:
+        repository = repositories_container.get_repository(UserRepository)
+
+        assert isinstance(repository, UserRepository)

metaorm-0.1.0/tests/test_exceptions.py

@@ -0,0 +1,56 @@
+import pytest
+
+from metaorm import (
+    AlreadyExistsError,
+    DatabaseException,
+    HaveNoSessionError,
+    NotFoundError,
+)
+
+
+class TestExceptions:
+    def test_database_exception_is_base_class(self) -> None:
+        assert issubclass(NotFoundError, DatabaseException)
+        assert issubclass(HaveNoSessionError, DatabaseException)
+        assert issubclass(AlreadyExistsError, DatabaseException)
+
+    def test_not_found_error_default_message(self) -> None:
+        error = NotFoundError()
+
+        assert str(error) == "Not found"
+
+    def test_not_found_error_custom_message(self) -> None:
+        error = NotFoundError(detail="User not found")
+
+        assert str(error) == "User not found"
+
+    def test_have_no_session_error_message(self) -> None:
+        error = HaveNoSessionError()
+
+        assert str(error) == "Have no actual session"
+
+    def test_already_exists_error_default_message(self) -> None:
+        error = AlreadyExistsError()
+
+        assert str(error) == "Record already exists"
+
+    def test_already_exists_error_custom_message(self) -> None:
+        error = AlreadyExistsError(detail="User already exists")
+
+        assert str(error) == "User already exists"
+
+    @pytest.mark.parametrize(
+        "exception_class",
+        [
+            DatabaseException,
+            NotFoundError,
+            HaveNoSessionError,
+            AlreadyExistsError,
+        ],
+    )
+    def test_all_exceptions_are_catchable_as_database_exception(
+        self,
+        exception_class: type[Exception],
+    ) -> None:
+        with pytest.raises(DatabaseException):
+            raise exception_class()

metaorm-0.1.0/tests/test_repositories.py

@@ -0,0 +1,129 @@
+import pytest
+from pydantic_filters import BaseSort, OffsetPagination
+
+from metaorm import AlreadyExistsError, HaveNoSessionError
+from tests.models import User, UserRepository
+
+
+class TestBaseRepository:
+    async def test_session_raises_error_without_transaction(
+        self,
+        user_repository: UserRepository,
+    ) -> None:
+        with pytest.raises(HaveNoSessionError):
+            _ = user_repository.session
+
+    async def test_create_item(self, user_repository: UserRepository) -> None:
+        user = User(name="Alice", email="alice@example.com")
+
+        created = await user_repository.create_item(user)
+
+        assert created.id is not None
+        assert created.name == "Alice"
+        assert created.email == "alice@example.com"
+
+    async def test_get_items(self, user_repository: UserRepository) -> None:
+        user1 = User(name="Alice", email="alice@example.com")
+        user2 = User(name="Bob", email="bob@example.com")
+        await user_repository.create_item(user1)
+        await user_repository.create_item(user2)
+
+        items = [item async for item in user_repository.get_items()]
+
+        assert len(items) == 2
+        assert {item.name for item in items} == {"Alice", "Bob"}
+
+    async def test_get_items_count(self, user_repository: UserRepository) -> None:
+        await user_repository.create_item(
+            User(name="Alice", email="alice@example.com"),
+        )
+        await user_repository.create_item(
+            User(name="Bob", email="bob@example.com"),
+        )
+
+        count = await user_repository.get_items_count()
+
+        assert count == 2
+
+    async def test_update_items(self, user_repository: UserRepository) -> None:
+        await user_repository.create_item(
+            User(name="Alice", email="alice@example.com"),
+        )
+        await user_repository.create_item(
+            User(name="Bob", email="bob@example.com"),
+        )
+
+        updated = [
+            item
+            async for item in user_repository.update_items(name="Updated")
+        ]
+
+        assert len(updated) == 2
+        assert all(item.name == "Updated" for item in updated)
+
+    async def test_delete_items(self, user_repository: UserRepository) -> None:
+        await user_repository.create_item(
+            User(name="Alice", email="alice@example.com"),
+        )
+        await user_repository.create_item(
+            User(name="Bob", email="bob@example.com"),
+        )
+
+        await user_repository.delete_items()
+
+        count = await user_repository.get_items_count()
+
+        assert count == 0
+
+    async def test_create_item_raises_already_exists_on_duplicate(
+        self,
+        user_repository: UserRepository,
+    ) -> None:
+        user = User(name="Alice", email="alice@example.com")
+        await user_repository.create_item(user)
+
+        with pytest.raises(AlreadyExistsError):
+            await user_repository.create_item(user)
+
+    async def test_transaction_reuses_existing_session(
+        self,
+        user_repository: UserRepository,
+    ) -> None:
+        async with user_repository.transaction():
+            _ = user_repository.session
+
+    async def test_get_items_with_pagination(
+        self,
+        user_repository: UserRepository,
+    ) -> None:
+        for index in range(5):
+            await user_repository.create_item(
+                User(name=f"User{index}", email=f"user{index}@example.com"),
+            )
+
+        pagination = OffsetPagination(offset=1, limit=2)
+        items = [
+            item
+            async for item in user_repository.get_items(pagination=pagination)
+        ]
+
+        assert len(items) == 2
+
+    async def test_get_items_with_sort(
+        self,
+        user_repository: UserRepository,
+    ) -> None:
+        await user_repository.create_item(
+            User(name="Charlie", email="c@example.com"),
+        )
+        await user_repository.create_item(
+            User(name="Alice", email="a@example.com"),
+        )
+        await user_repository.create_item(
+            User(name="Bob", email="b@example.com"),
+        )
+
+        sort = BaseSort(sort_by="name", sort_by_order="asc")
+        items = [item async for item in user_repository.get_items(sort=sort)]
+
+        assert [item.name for item in items] == ["Alice", "Bob", "Charlie"]

metaorm-0.1.0/tests/test_settings.py

@@ -0,0 +1,47 @@
+import pytest
+from pydantic import ValidationError
+
+from metaorm import DatabaseSettings
+
+
+class TestDatabaseSettings:
+    def test_default_values(self) -> None:
+        settings = DatabaseSettings()
+
+        assert settings.dsn == "sqlite+aiosqlite:///db.sqlite3"
+        assert settings.pool_size == 5
+        assert settings.pool_recycle == 60
+        assert settings.pool_timeout == 60
+
+    def test_custom_values(self) -> None:
+        settings = DatabaseSettings(
+            dsn="postgresql+asyncpg://user:pass@localhost/db",
+            pool_size=10,
+            pool_recycle=120,
+            pool_timeout=30,
+        )
+
+        assert settings.dsn == "postgresql+asyncpg://user:pass@localhost/db"
+        assert settings.pool_size == 10
+        assert settings.pool_recycle == 120
+        assert settings.pool_timeout == 30
+
+    def test_dsn_must_match_pattern(self) -> None:
+        with pytest.raises(ValidationError):
+            DatabaseSettings(dsn="invalid_dsn")
+
+    @pytest.mark.parametrize(
+        "field_name,invalid_value",
+        [
+            ("pool_size", 0),
+            ("pool_recycle", 0),
+            ("pool_timeout", 0),
+        ],
+    )
+    def test_integer_fields_must_be_greater_or_equal_one(
+        self,
+        field_name: str,
+        invalid_value: int,
+    ) -> None:
+        with pytest.raises(ValidationError):
+            DatabaseSettings(**{field_name: invalid_value})

metaorm-0.1.0/tests/test_tables.py

@@ -0,0 +1,42 @@
+from typing import Optional
+
+import pytest
+from sqlmodel import Field, SQLModel
+
+from metaorm import BaseTable
+from tests.models import User
+
+
+class TestBaseTable:
+    def test_to_values_returns_column_data(self) -> None:
+        from tests.models import UserTable
+
+        user_table = UserTable(id=1, name="Alice", email="alice@example.com")
+
+        values = user_table.to_values()
+
+        assert values == {
+            "id": 1,
+            "name": "Alice",
+            "email": "alice@example.com",
+        }
+
+    def test_from_item_not_implemented_in_base_class(self) -> None:
+        class DummyFromItemTable(BaseTable[User], table=True):
+            __tablename__ = "dummy_from_item"
+            id: Optional[int] = Field(default=None, primary_key=True)
+
+        with pytest.raises(NotImplementedError):
+            DummyFromItemTable.from_item(
+                User(name="Alice", email="alice@example.com"),
+            )
+
+    def test_to_item_not_implemented_in_base_class(self) -> None:
+        class DummyToItemTable(BaseTable[User], table=True):
+            __tablename__ = "dummy_to_item"
+            id: Optional[int] = Field(default=None, primary_key=True)
+
+        dummy = DummyToItemTable(id=1, name="Alice", email="alice@example.com")
+
+        with pytest.raises(NotImplementedError):
+            dummy.to_item()