nora/MetaORM
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: migrate to keyword-based repository config, add nested transactions and tests

Browse Source
This commit is contained in:
Oleg Yurchik
2026-08-14 19:58:32 +03:00
parent 3d85c2b5dd
commit 7abb513b30
22 changed files with 658 additions and 324 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
metaorm/__init__.py
View File

@@ -1,3 +1,12 @@
from pydantic_filters import (
BaseFilter,
BasePagination,
BaseSort,
OffsetPagination,
PagePagination,
)
from sqlmodel import Field, Relationship
from .container import RepositoriesContainer
from .exceptions import (
AlreadyExistsError,
@@ -6,10 +15,19 @@ from .exceptions import (
NotFoundError,
)
from .repositories import BaseRepository
from .settings import DatabaseSettings
from .settings import RepositorySettings
from .tables import BaseTable
__all__ = (
# pydantic-filters
"BaseFilter",
"BasePagination",
"BaseSort",
"OffsetPagination",
"PagePagination",
# sqlmodel
"Field",
"Relationship",
# container
"RepositoriesContainer",
# exceptions
@@ -20,7 +38,7 @@ __all__ = (
# repositories
"BaseRepository",
# settings
"DatabaseSettings",
"RepositorySettings",
# tables
"BaseTable",
)

26
metaorm/container.py
View File

@@ -6,13 +6,13 @@ from typing import TypeVar
from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
from sqlmodel.ext.asyncio.session import AsyncSession
from .settings import DatabaseSettings
from .settings import RepositorySettings
RepositoryType = TypeVar("RepositoryType", bound="BaseRepository") # noqa: F821
class RepositoriesContainer:
def __init__(self, settings: DatabaseSettings):
def __init__(self, settings: RepositorySettings):
engine_parameters = {
"url": settings.dsn,
"pool_recycle": settings.pool_recycle,
@@ -37,7 +37,7 @@ class RepositoriesContainer:
@asynccontextmanager
async def transaction(self) -> AsyncGenerator[AsyncSession, None]:
existing_session = self._session_context.get()
existing_session = self._session_context.get(None)
if existing_session is not None:
yield existing_session
return
@@ -54,5 +54,25 @@ class RepositoriesContainer:
finally:
self._session_context.reset(token)
@asynccontextmanager
async def nested_transaction(self) -> AsyncGenerator[AsyncSession, None]:
existing_session = self._session_context.get(None)
if existing_session is not None:
async with existing_session.begin_nested():
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_nested():
yield session
finally:
self._session_context.reset(token)
def get_repository(self, repository_class: type[RepositoryType]) -> RepositoryType:
return repository_class(container=self)

146
metaorm/repositories.py
View File

@@ -1,26 +1,46 @@
from collections.abc import AsyncGenerator, Sequence
from contextlib import asynccontextmanager
from typing import Any
from pydantic import BaseModel
from pydantic_filters import BaseFilter, BasePagination, BaseSort
from pydantic_filters.drivers.sqlalchemy import append_to_statement
from pydantic_filters.filter._fields import FilterFieldInfo
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 .settings import DatabaseSettings
from .exceptions import AlreadyExistsError, DatabaseException
from .settings import RepositorySettings
from .tables import BaseTable
class BaseRepository:
def __init_subclass__(
cls,
table: type[BaseTable] | None = None,
filter_: type[BaseFilter] | None = None,
dto: type[BaseModel] | None = None,
**kwargs,
):
super().__init_subclass__(**kwargs)
if (table := table or getattr(cls, "_table_type", None)) is None:
raise TypeError(
f"{cls.__name__} must specify 'table' keyword argument",
)
if (filter_ := filter_ or getattr(cls, "_filter_type", None)) is None:
raise TypeError(
f"{cls.__name__} must specify 'filter_' keyword argument",
)
cls._table_type = table
cls._filter_type = filter_
cls._dto_type = dto or getattr(cls, "_dto_type", None)
def __init__(
self,
settings: DatabaseSettings | None = None,
settings: RepositorySettings | None = None,
container: RepositoriesContainer | None = None,
):
if container is not None:
@@ -30,47 +50,11 @@ class BaseRepository:
else:
raise TypeError("Either 'container' or 'settings' must be provided")
def get_db_table(self) -> type[BaseTable]:
raise NotImplementedError
def get_dto_type(self) -> type[BaseModel] | None:
return None
def get_filter_type(self) -> type[BaseFilter] | None:
return None
@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
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_: BaseFilter | None = None,
) -> int:
if filter_ is not None:
self._ensure_filter_fields(type(filter_))
table = self.get_db_table()
table = self.get_table_type()
statement = select(func.count()).select_from(table)
statement = append_to_statement(
statement=statement,
@@ -90,10 +74,8 @@ class BaseRepository:
pagination: BasePagination | None = None,
sort: BaseSort | None = None,
options: Sequence[Any] | None = None,
) -> AsyncGenerator[BaseModel]:
if filter_ is not None:
self._ensure_filter_fields(type(filter_))
table = self.get_db_table()
) -> AsyncGenerator[Any]:
table = self.get_table_type()
statement = select(table)
statement = append_to_statement(
statement=statement,
@@ -106,13 +88,13 @@ class BaseRepository:
statement = statement.options(*options)
async with self.transaction():
result = await self.session.execute(statement)
result = await self.session.exec(statement)
result = result.yield_per(100)
for db_item in result.scalars():
for db_item in result:
yield self._convert_from_table(db_item)
async def create_item(self, item: BaseModel) -> BaseModel:
table = self.get_db_table()
table = self.get_table_type()
values = self._convert_to_table(item).to_values()
statement = insert(table).values(values).returning(table)
@@ -138,9 +120,7 @@ class BaseRepository:
options: Sequence[Any] | None = None,
**values,
) -> AsyncGenerator[BaseModel]:
if filter_ is not None:
self._ensure_filter_fields(type(filter_))
table = self.get_db_table()
table = self.get_table_type()
statement = update(table)
statement = append_to_statement(
statement=statement,
@@ -161,9 +141,7 @@ class BaseRepository:
self,
filter_: BaseFilter | None = None,
) -> None:
if filter_ is not None:
self._ensure_filter_fields(type(filter_))
table = self.get_db_table()
table = self.get_table_type()
statement = delete(table)
statement = append_to_statement(
statement=statement,
@@ -174,41 +152,45 @@ class BaseRepository:
async with self.transaction():
await self.session.exec(statement)
@property
def session(self) -> AsyncSession | None:
return self._container.session
@property
def transaction(self):
return self._container.transaction
@property
def nested_transaction(self):
return self._container.nested_transaction
async def create_tables(self) -> None:
table = self.get_table_type()
async with self._container.engine.begin() as connection:
await connection.run_sync(
table.metadata.create_all,
tables=[table.__table__],
)
def _convert_to_table(self, item: BaseModel) -> BaseModel:
table = self.get_db_table()
table = self.get_table_type()
if isinstance(item, table):
return item
return table.from_item(item=item)
def _convert_from_table(self, table: BaseTable) -> BaseModel:
dto_type = self.get_dto_type()
if dto_type is None:
if self.get_dto_type() is None:
return table
return table.to_item()
def _ensure_filter_fields(self, filter_class: type[BaseFilter]) -> None:
"""Workaround for pydantic-filters not registering filter_fields with pydantic v2."""
if getattr(filter_class, "filter_fields", None):
return
@classmethod
def get_table_type(cls) -> type[BaseTable] | None:
return cls._table_type
filter_fields: dict[str, FilterFieldInfo] = {}
for field_name, field_info in filter_class.model_fields.items():
if field_info.annotation is None:
continue
annotation = field_info.annotation
# unwrap Optional[X] -> X
origin = getattr(annotation, "__origin__", None)
if origin is type | None:
args = getattr(annotation, "__args__", ())
if args and args[0] is not type(None):
annotation = args[0]
@classmethod
def get_filter_type(cls) -> type[BaseFilter] | None:
return cls._filter_type
is_sequence = hasattr(
annotation, "__origin__"
) and annotation.__origin__ in (list, set)
filter_fields[field_name] = FilterFieldInfo(
target=field_name,
type_="eq",
is_sequence=is_sequence,
)
filter_class.filter_fields = filter_fields
@classmethod
def get_dto_type(cls) -> type[BaseModel] | None:
return cls._dto_type

2
metaorm/settings.py
View File

@@ -1,7 +1,7 @@
from pydantic import BaseModel, Field
class DatabaseSettings(BaseModel):
class RepositorySettings(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