SARepo 0.1.3__tar.gz → 0.1.5__tar.gz

{sarepo-0.1.3 → sarepo-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SARepo
-Version: 0.1.3
+Version: 0.1.5
 Summary: Minimal, explicit Repository & Unit-of-Work layer over SQLAlchemy 2.x
 Author: nurbergenovv
 License: MIT

sarepo-0.1.5/SARepo/repo.py

@@ -0,0 +1,50 @@
+
+from typing import Generic, List, TypeVar, Type, Optional, Any, Protocol
+
+from SARepo.sa_repo import Spec
+from .base import Page, PageRequest
+
+T = TypeVar("T")
+
+class CrudRepository(Protocol, Generic[T]):
+    model: Type[T]
+    def getAll(self, limit: Optional[int] = None, *, include_deleted: bool = False) -> List[T]: ...
+    def get(self, id_: Any, *, include_deleted: bool = False) -> T: ...
+    def try_get(self, id_: Any, *, include_deleted: bool = False) -> Optional[T]: ...
+    def add(self, entity: T) -> T: ...
+    def update(self, entity: T) -> T: ...
+    def remove(self, entity: T) -> None: ...
+    def delete_by_id(self, id_: Any) -> bool: ...
+    def page(self, page: PageRequest, spec: Optional[Spec] = None, order_by=None, *, include_deleted: bool = False) -> Page[T]: ...
+    def get_all_by_column(
+    self,
+    column_name: str,
+    value: Any,
+    *,
+    limit: Optional[int] = None,
+    order_by=None,
+    include_deleted: bool = False,
+    **extra_filters
+) -> list[T]: ...
+    def find_all_by_column(
+    self,
+    column_name: str,
+    value: Any,
+    *,
+    limit: Optional[int] = None,
+    order_by=None,
+    include_deleted: bool = False,
+    **extra_filters
+) -> list[T]: ...
+    def get_or_create(
+        self,
+        defaults: Optional[dict] = None,
+        **unique_filters
+    ) -> tuple[T, bool]: ...
+    def raw_query(self, sql: str, params: Optional[dict] = None) -> list[dict]: ...
+    def aggregate_avg(self, column_name: str, **filters) -> Optional[float]: ...
+    def aggregate_min(self, column_name: str, **filters): ...
+    def aggregate_max(self, column_name: str, **filters): ...
+    def aggregate_sum(self, column_name: str, **filters): ... 
+    def count(self, **filters) -> int: ...
+    def restore(self, id_: Any) -> bool: ...

sarepo-0.1.5/SARepo/sa_repo.py

@@ -0,0 +1,423 @@
+
+from typing import List, Type, Generic, TypeVar, Optional, Sequence, Any, Callable
+from sqlalchemy.orm import Session
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import inspect, select, func, text
+from .base import PageRequest, Page, NotFoundError
+
+T = TypeVar("T")
+Spec = Callable
+
+class SARepository(Generic[T]):
+    """Synchronous repository implementation for SQLAlchemy 2.x."""
+    def __init__(self, model: Type[T], session: Session):
+        self.model = model
+        self.session = session
+
+    def _resolve_column(self, column_name: str):
+        try:
+            return getattr(self.model, column_name)
+        except AttributeError as e:
+            raise ValueError(f"Model {self.model.__name__} has no column '{column_name}'") from e
+
+    def _apply_filters(self, stmt, **filters):
+        if filters:
+            stmt = stmt.filter_by(**filters)
+        return stmt
+
+    def _select(self):
+        return select(self.model)
+
+    def _has_soft_delete(self) -> bool:
+        return hasattr(self.model, "is_deleted")
+
+    def _apply_alive_filter(self, stmt, include_deleted: bool) :
+        if self._has_soft_delete() and not include_deleted:
+            stmt = stmt.where(self.model.is_deleted == False)  # noqa: E712
+        return stmt
+    
+    def getAll(self, limit: Optional[int] = None, *, include_deleted: bool = False) -> List[T]:
+        stmt = select(self.model)
+        stmt = self._apply_alive_filter(stmt, include_deleted)
+        if limit is not None:
+            stmt = stmt.limit(limit)
+        result = self.session.execute(stmt)
+        return result.scalars().all()    
+    
+    def get(self, id_: Any, *, include_deleted: bool = False) -> T:
+        obj = self.session.get(self.model, id_)
+        if not obj:
+            raise NotFoundError(f"{self.model.__name__}({id_}) not found")
+        if self._has_soft_delete() and not include_deleted and getattr(obj, "is_deleted", False):
+            raise NotFoundError(f"{self.model.__name__}({id_}) not found")  # скрываем как «нет»
+        return obj
+
+    def try_get(self, id_: Any, *, include_deleted: bool = False) -> Optional[T]:
+        obj = self.session.get(self.model, id_)
+        if not obj:
+            return None
+        if self._has_soft_delete() and not include_deleted and getattr(obj, "is_deleted", False):
+            return None
+        return obj
+    
+    def add(self, entity: T) -> T:
+        self.session.add(entity)
+        self.session.flush()
+        self.session.refresh(entity)
+        return entity
+
+    def update(self, entity: T) -> T:
+        self.session.flush()
+        self.session.refresh(entity)
+        return entity
+
+    def remove(self, entity: T) -> None:
+        insp = inspect(entity, raiseerr=False)
+        if not (insp and (insp.persistent or insp.pending)):
+            pk = getattr(entity, "id", None)
+            if pk is None:
+                raise ValueError("remove() needs a persistent entity or an entity with a primary key set")
+            entity = self.session.get(self.model, pk)
+            if entity is None:
+                return
+        if hasattr(entity, "is_deleted"):
+            setattr(entity, "is_deleted", True)
+        else:
+            self.session.delete(entity)
+
+    def delete_by_id(self, id_: Any) -> bool:
+        obj = self.session.get(self.model, id_)
+        if not obj:
+            return False
+        self.remove(obj)
+        return True
+
+    def page(self, page: PageRequest, spec: Optional[Spec] = None, order_by=None, *, include_deleted: bool = False) -> Page[T]:
+        base = self._select()
+        if spec:
+            base = spec(base)
+        base = self._apply_alive_filter(base, include_deleted)
+        if order_by is not None:
+            base = base.order_by(order_by)
+
+        total = self.session.execute(
+            select(func.count()).select_from(base.subquery())
+        ).scalar_one()
+
+        items = self.session.execute(
+            base.offset(page.page * page.size).limit(page.size)
+        ).scalars().all()
+        return Page(items, total, page.page, page.size)
+    
+    def get_all_by_column(
+        self,
+        column_name: str,
+        value: Any,
+        *,
+        limit: Optional[int] = None,
+        order_by=None,
+        include_deleted: bool = False,
+        **extra_filters
+    ) -> list[T]:
+        col = self._resolve_column(column_name)
+        stmt = select(self.model).where(col == value)
+        stmt = self._apply_alive_filter(stmt, include_deleted)
+        stmt = self._apply_filters(stmt, **extra_filters)
+        if order_by is not None:
+            stmt = stmt.order_by(order_by)
+        if limit is not None:
+            stmt = stmt.limit(limit)
+        res = self.session.execute(stmt)
+        return res.scalars().all()
+        
+    # Alias 
+    def find_all_by_column(self, *args, **kwargs):
+        return self.get_all_by_column(*args, **kwargs)
+    
+    def get_or_create(
+        self,
+        defaults: Optional[dict] = None,
+        **unique_filters
+    ) -> tuple[T, bool]:
+        """
+        Возвращает (obj, created). unique_filters определяют уникальность.
+        defaults дополняют поля при создании.
+        """
+        stmt = select(self.model).filter_by(**unique_filters)
+        if hasattr(self.model, "is_deleted"):
+            stmt = stmt.where(self.model.is_deleted == False)  # noqa: E712
+        obj = self.session.execute(stmt).scalar_one_or_none()
+        if obj:
+            return obj, False
+        payload = {**unique_filters, **(defaults or {})}
+        obj = self.model(**payload)  # type: ignore[call-arg]
+        self.session.add(obj)
+        self.session.flush()
+        self.session.refresh(obj)
+        return obj, True
+
+    def raw_query(self, sql: str, params: Optional[dict] = None) -> list[dict]:
+        """
+        Безопасно выполняет сырой SQL (используй плейсхолдеры :name).
+        Возвращает список dict (строки).
+        """
+        res = self.session.execute(text(sql), params or {})
+        # mapping() -> RowMapping (dict-like)
+        return [dict(row) for row in res.mappings().all()]
+
+    def aggregate_avg(self, column_name: str, **filters) -> Optional[float]:
+        col = self._resolve_column(column_name)
+        stmt = select(func.avg(col))
+        if hasattr(self.model, "is_deleted"):
+            stmt = stmt.where(self.model.is_deleted == False)  # noqa: E712
+        stmt = self._apply_filters(stmt, **filters)
+        return self.session.execute(stmt).scalar()
+
+    def aggregate_min(self, column_name: str, **filters):
+        col = self._resolve_column(column_name)
+        stmt = select(func.min(col))
+        if hasattr(self.model, "is_deleted"):
+            stmt = stmt.where(self.model.is_deleted == False)
+        stmt = self._apply_filters(stmt, **filters)
+        return self.session.execute(stmt).scalar()
+
+    def aggregate_max(self, column_name: str, **filters):
+        col = self._resolve_column(column_name)
+        stmt = select(func.max(col))
+        if hasattr(self.model, "is_deleted"):
+            stmt = stmt.where(self.model.is_deleted == False)
+        stmt = self._apply_filters(stmt, **filters)
+        return self.session.execute(stmt).scalar()
+
+    def aggregate_sum(self, column_name: str, **filters):
+        col = self._resolve_column(column_name)
+        stmt = select(func.sum(col))
+        if hasattr(self.model, "is_deleted"):
+            stmt = stmt.where(self.model.is_deleted == False)
+        stmt = self._apply_filters(stmt, **filters)
+        return self.session.execute(stmt).scalar()
+
+    def count(self, **filters) -> int:
+        stmt = select(func.count()).select_from(self.model)
+        if hasattr(self.model, "is_deleted") and not filters.pop("include_deleted", False):
+            stmt = stmt.where(self.model.is_deleted == False)  # noqa: E712
+        if filters:
+            stmt = stmt.filter_by(**filters)
+        return int(self.session.execute(stmt).scalar_one())
+
+    def restore(self, id_: Any) -> bool:
+        """
+        Для soft-delete: is_deleted=False. Возвращает True, если восстановили.
+        """
+        if not hasattr(self.model, "is_deleted"):
+            raise RuntimeError(f"{self.model.__name__} has no 'is_deleted' field")
+        obj = self.session.get(self.model, id_)
+        if not obj:
+            return False
+        if getattr(obj, "is_deleted", False):
+            setattr(obj, "is_deleted", False)
+            self.session.flush()
+            return True
+        return False
+
+class SAAsyncRepository(Generic[T]):
+    """Async repository implementation for SQLAlchemy 2.x."""
+    def __init__(self, model: Type[T], session: AsyncSession):
+        self.model = model
+        self.session = session
+    
+    def _resolve_column(self, column_name: str):
+        try:
+            return getattr(self.model, column_name)
+        except AttributeError as e:
+            raise ValueError(f"Model {self.model.__name__} has no column '{column_name}'") from e
+
+    def _apply_filters(self, stmt, **filters):
+        if filters:
+            stmt = stmt.filter_by(**filters)
+        return stmt
+    
+    def _select(self):
+        return select(self.model)
+    
+    def _has_soft_delete(self) -> bool:
+        return hasattr(self.model, "is_deleted")
+
+    def _apply_alive_filter(self, stmt, include_deleted: bool) :
+        if self._has_soft_delete() and not include_deleted:
+            stmt = stmt.where(self.model.is_deleted == False)  # noqa: E712
+        return stmt
+
+    async def getAll(self, limit: Optional[int] = None, *, include_deleted: bool = False) -> List[T]:
+        stmt = select(self.model)
+        stmt = self._apply_alive_filter(stmt, include_deleted)
+        if limit is not None:
+            stmt = stmt.limit(limit)
+        result = await self.session.execute(stmt)
+        return result.scalars().all()
+
+    async def get(self, id_: Any, *, include_deleted: bool = False) -> T:
+        obj = await self.session.get(self.model, id_)
+        if not obj:
+            raise NotFoundError(f"{self.model.__name__}({id_}) not found")
+        if self._has_soft_delete() and not include_deleted and getattr(obj, "is_deleted", False):
+            raise NotFoundError(f"{self.model.__name__}({id_}) not found")
+        return obj
+
+    async def try_get(self, id_: Any, *, include_deleted: bool = False) -> Optional[T]:
+        obj = await self.session.get(self.model, id_)
+        if not obj:
+            return None
+        if self._has_soft_delete() and not include_deleted and getattr(obj, "is_deleted", False):
+            return None
+        return obj
+
+    async def add(self, entity: T) -> T:
+        self.session.add(entity)
+        await self.session.flush()
+        await self.session.refresh(entity)
+        return entity
+
+    async def update(self, entity: T) -> T:
+        await self.session.flush()
+        await self.session.refresh(entity)
+        return entity
+
+    async def remove(self, entity: T) -> None:
+        insp = inspect(entity, raiseerr=False)
+        if not (insp and (insp.persistent or insp.pending)):
+            pk = getattr(entity, "id", None)
+            if pk is None:
+                raise ValueError("remove() needs a persistent entity or an entity with a primary key set")
+            entity = await self.session.get(self.model, pk)
+            if entity is None:
+                return
+        if hasattr(entity, "is_deleted"):
+            setattr(entity, "is_deleted", True)
+        else:
+            await self.session.delete(entity)
+
+    async def delete_by_id(self, id_: Any) -> bool:
+        obj = await self.session.get(self.model, id_)
+        if not obj:
+            return False
+        await self.remove(obj)
+        return True
+
+    async def page(self, page: PageRequest, spec: Optional[Spec] = None, order_by=None, *, include_deleted: bool = False) -> Page[T]: # type: ignore
+        base = self._select()
+        if spec:
+            base = spec(base)
+        base = self._apply_alive_filter(base, include_deleted)
+        if order_by is not None:
+            base = base.order_by(order_by)
+
+        total = (await self.session.execute(
+            select(func.count()).select_from(base.subquery())
+        )).scalar_one()
+
+        res = await self.session.execute(
+            base.offset(page.page * page.size).limit(page.size)
+        )
+        items = res.scalars().all()
+        return Page(items, total, page.page, page.size)
+
+    async def get_all_by_column(
+        self,
+        column_name: str,
+        value: Any,
+        *,
+        limit: Optional[int] = None,
+        order_by=None,
+        include_deleted: bool = False,
+        **extra_filters
+    ) -> list[T]:
+        col = self._resolve_column(column_name)
+        stmt = select(self.model).where(col == value)
+        stmt = self._apply_alive_filter(stmt, include_deleted)
+        stmt = self._apply_filters(stmt, **extra_filters)
+        if order_by is not None:
+            stmt = stmt.order_by(order_by)
+        if limit is not None:
+            stmt = stmt.limit(limit)
+        res = await self.session.execute(stmt)
+        return res.scalars().all()
+
+    # Alias
+    async def find_all_by_column(self, *args, **kwargs):
+        return await self.get_all_by_column(*args, **kwargs)
+    
+    async def get_or_create(
+        self,
+        defaults: Optional[dict] = None,
+        **unique_filters
+    ) -> tuple[T, bool]:
+        stmt = select(self.model).filter_by(**unique_filters)
+        if hasattr(self.model, "is_deleted"):
+            stmt = stmt.where(self.model.is_deleted == False)  # noqa: E712
+        obj = (await self.session.execute(stmt)).scalar_one_or_none()
+        if obj:
+            return obj, False
+        payload = {**unique_filters, **(defaults or {})}
+        obj = self.model(**payload)  # type: ignore[call-arg]
+        self.session.add(obj)
+        await self.session.flush()
+        await self.session.refresh(obj)
+        return obj, True
+
+    async def raw_query(self, sql: str, params: Optional[dict] = None) -> list[dict]:
+        res = await self.session.execute(text(sql), params or {})
+        return [dict(row) for row in res.mappings().all()]
+
+    async def aggregate_avg(self, column_name: str, **filters) -> Optional[float]:
+        col = self._resolve_column(column_name)
+        stmt = select(func.avg(col))
+        if hasattr(self.model, "is_deleted"):
+            stmt = stmt.where(self.model.is_deleted == False)  # noqa: E712
+        stmt = self._apply_filters(stmt, **filters)
+        return (await self.session.execute(stmt)).scalar()
+
+    async def aggregate_min(self, column_name: str, **filters):
+        col = self._resolve_column(column_name)
+        stmt = select(func.min(col))
+        if hasattr(self.model, "is_deleted"):
+            stmt = stmt.where(self.model.is_deleted == False)
+        stmt = self._apply_filters(stmt, **filters)
+        return (await self.session.execute(stmt)).scalar()
+
+    async def aggregate_max(self, column_name: str, **filters):
+        col = self._resolve_column(column_name)
+        stmt = select(func.max(col))
+        if hasattr(self.model, "is_deleted"):
+            stmt = stmt.where(self.model.is_deleted == False)
+        stmt = self._apply_filters(stmt, **filters)
+        return (await self.session.execute(stmt)).scalar()
+
+    async def aggregate_sum(self, column_name: str, **filters):
+        col = self._resolve_column(column_name)
+        stmt = select(func.sum(col))
+        if hasattr(self.model, "is_deleted"):
+            stmt = stmt.where(self.model.is_deleted == False)
+        stmt = self._apply_filters(stmt, **filters)
+        return (await self.session.execute(stmt)).scalar()
+
+    async def count(self, **filters) -> int:
+        include_deleted = bool(filters.pop("include_deleted", False))
+        stmt = select(func.count()).select_from(self.model)
+        if hasattr(self.model, "is_deleted") and not include_deleted:
+            stmt = stmt.where(self.model.is_deleted == False)  # noqa: E712
+        if filters:
+            stmt = stmt.filter_by(**filters)
+        return int((await self.session.execute(stmt)).scalar_one())
+
+    async def restore(self, id_: Any) -> bool:
+        if not hasattr(self.model, "is_deleted"):
+            raise RuntimeError(f"{self.model.__name__} has no 'is_deleted' field")
+        obj = await self.session.get(self.model, id_)
+        if not obj:
+            return False
+        if getattr(obj, "is_deleted", False):
+            setattr(obj, "is_deleted", False)
+            await self.session.flush()
+            return True
+        return False

{sarepo-0.1.3 → sarepo-0.1.5}/SARepo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SARepo
-Version: 0.1.3
+Version: 0.1.5
 Summary: Minimal, explicit Repository & Unit-of-Work layer over SQLAlchemy 2.x
 Author: nurbergenovv
 License: MIT

{sarepo-0.1.3 → sarepo-0.1.5}/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "SARepo"
-version = "0.1.3"
+version = "0.1.5"
 description = "Minimal, explicit Repository & Unit-of-Work layer over SQLAlchemy 2.x"
 readme = "README.md"
 requires-python = ">=3.11"

sarepo-0.1.5/tests/test_sync_basic.py

@@ -0,0 +1,145 @@
+import pytest
+from typing import Optional
+from sqlalchemy import create_engine, String, Integer, Boolean, Text
+from sqlalchemy.orm import sessionmaker, DeclarativeBase, Mapped, mapped_column
+
+from SARepo.sa_repo import SARepository
+from SARepo.base import NotFoundError
+
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class Item(Base):
+    __tablename__ = "items"
+
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    title: Mapped[str] = mapped_column(String(100), nullable=False, index=True)
+    city: Mapped[Optional[str]] = mapped_column(String(50), nullable=True)
+    amount: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
+    age: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
+    is_deleted: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False, index=True)
+    note: Mapped[Optional[str]] = mapped_column(Text)
+
+
+
+@pytest.fixture()
+def session():
+    engine = create_engine("sqlite+pysqlite:///:memory:", echo=False)
+    Base.metadata.create_all(engine)
+    SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
+    with SessionLocal() as s:
+        yield s
+
+
+@pytest.fixture()
+def repo(session):
+    return SARepository(Item, session)
+
+
+def seed(session, repo):
+    """Наполняем базу различными записями для агрегатов/фильтров."""
+    data = [
+        Item(title="alpha",  city="Almaty",   amount=10, age=20, note="A"),
+        Item(title="beta",   city="Astana",   amount=20, age=30, note="B"),
+        Item(title="gamma",  city="Almaty",   amount=30, age=40, note="G"),
+        Item(title="delta",  city="Shymkent", amount=40, age=50, note="D"),
+        Item(title="omega",  city=None,       amount=50, age=60, note="O"),
+    ]
+    for obj in data:
+        repo.add(obj)
+    session.commit()
+
+
+
+def test_find_all_by_column_basic(session, repo):
+    seed(session, repo)
+
+    items = repo.find_all_by_column("city", "Almaty")
+    titles = {x.title for x in items}
+    assert titles == {"alpha", "gamma"}
+
+    limited = repo.find_all_by_column("city", "Almaty", limit=1, order_by=Item.amount.desc())
+    assert len(limited) == 1 and limited[0].title == "gamma"
+
+    with pytest.raises(ValueError):
+        repo.find_all_by_column("no_such_column", "x")
+
+
+def test_get_or_create(session, repo):
+    seed(session, repo)
+
+    obj, created = repo.get_or_create(title="alpha", defaults={"city": "Kokshetau"})
+    assert created is False
+    assert obj.city == "Almaty"
+
+    obj2, created2 = repo.get_or_create(title="sigma", defaults={"city": "Aktau", "amount": 77})
+    assert created2 is True
+    assert (obj2.title, obj2.city, obj2.amount) == ("sigma", "Aktau", 77)
+
+
+def test_raw_query(session, repo):
+    seed(session, repo)
+
+    rows = repo.raw_query(
+        "SELECT id, title, city FROM items WHERE lower(title) LIKE :p",
+        {"p": "%a%"}
+    )
+    assert isinstance(rows, list) and all(isinstance(r, dict) for r in rows)
+    titles = {r["title"] for r in rows}
+    assert {"alpha", "gamma", "delta"}.issubset(titles)
+
+
+def test_aggregates_avg_min_max_sum_ignore_soft_deleted_by_default(session, repo):
+    seed(session, repo)
+
+    omega = repo.find_all_by_column("title", "omega")[0]
+    omega.is_deleted = True
+    session.commit()
+
+    avg_amount = repo.aggregate_avg("amount")
+    min_amount = repo.aggregate_min("amount")
+    max_amount = repo.aggregate_max("amount")
+    sum_amount = repo.aggregate_sum("amount")
+
+    assert avg_amount == pytest.approx((10 + 20 + 30 + 40) / 4)
+    assert min_amount == 10
+    assert max_amount == 40
+    assert sum_amount == 10 + 20 + 30 + 40
+
+    avg_age_almaty = repo.aggregate_avg("age", city="Almaty")
+    assert avg_age_almaty == pytest.approx((20 + 40) / 2)
+
+
+def test_count_with_and_without_deleted(session, repo):
+    seed(session, repo)
+
+    for t in ("alpha", "beta"):
+        x = repo.find_all_by_column("title", t)[0]
+        x.is_deleted = True
+    session.commit()
+
+    assert repo.count() == 3
+
+    assert repo.count(include_deleted=True) == 5
+
+    assert repo.count(city="Almaty") == 1 
+
+
+def test_restore(session, repo):
+    seed(session, repo)
+
+    beta = repo.find_all_by_column("title", "beta")[0]
+    beta.is_deleted = True
+    session.commit()
+
+    ok = repo.restore(beta.id)
+    assert ok is True
+    session.commit()
+
+    ok2 = repo.restore(beta.id)
+    assert ok2 is False
+
+    assert repo.count() == 5

sarepo-0.1.3/SARepo/repo.py

@@ -1,16 +0,0 @@
-
-from typing import Generic, List, TypeVar, Type, Optional, Any, Protocol
-from .base import Page, PageRequest
-
-T = TypeVar("T")
-
-class CrudRepository(Protocol, Generic[T]):
-    model: Type[T]
-    def getAll(self, limit: Optional[int]) -> List[T]: ...
-    def get(self, id_: Any) -> T: ...
-    def try_get(self, id_: Any) -> Optional[T]: ...
-    def add(self, entity: T) -> T: ...
-    def update(self, entity: T) -> T: ...
-    def remove(self, entity: T) -> None: ...
-    def delete_by_id(self, id_: Any) -> bool: ...
-    def page(self, page: PageRequest, spec=None, order_by=None) -> Page[T]: ...

sarepo-0.1.3/SARepo/sa_repo.py

@@ -1,152 +0,0 @@
-
-from typing import List, Type, Generic, TypeVar, Optional, Sequence, Any, Callable
-from sqlalchemy.orm import Session
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import inspect, select, func
-from .base import PageRequest, Page, NotFoundError
-
-T = TypeVar("T")
-Spec = Callable  # aliased to match specs.Spec
-
-class SARepository(Generic[T]):
-    """Synchronous repository implementation for SQLAlchemy 2.x."""
-    def __init__(self, model: Type[T], session: Session):
-        self.model = model
-        self.session = session
-
-    def _select(self):
-        return select(self.model)
-
-    def getAll(self, limit: Optional[int] = None) -> List[T]:
-        stmt = select(self.model)
-        if limit is not None:
-            stmt = stmt.limit(limit)
-        result = self.session.execute(stmt)
-        return result.scalars().all()
-    
-    def get(self, id_: Any) -> T:
-        obj = self.session.get(self.model, id_)
-        if not obj:
-            raise NotFoundError(f"{self.model.__name__}({id_}) not found")
-        return obj
-
-    def try_get(self, id_: Any) -> Optional[T]:
-        return self.session.get(self.model, id_)
-
-    def add(self, entity: T) -> T:
-        self.session.add(entity)
-        self.session.flush()
-        self.session.refresh(entity)
-        return entity
-
-    def update(self, entity: T) -> T:
-        self.session.flush()
-        self.session.refresh(entity)
-        return entity
-
-    def remove(self, entity: T) -> None:
-        insp = inspect(entity, raiseerr=False)
-        if not (insp and (insp.persistent or insp.pending)):
-            pk = getattr(entity, "id", None)
-            if pk is None:
-                raise ValueError("remove() needs a persistent entity or an entity with a primary key set")
-            entity = self.session.get(self.model, pk)
-            if entity is None:
-                return
-        if hasattr(entity, "is_deleted"):
-            setattr(entity, "is_deleted", True)
-        else:
-            self.session.delete(entity)
-
-    def delete_by_id(self, id_: Any) -> bool:
-        obj = self.session.get(self.model, id_)
-        if not obj:
-            return False
-        self.remove(obj)
-        return True
-
-    def page(self, page: PageRequest, spec: Optional[Spec] = None, order_by=None) -> Page[T]:
-        stmt = self._select()
-        if spec:
-            stmt = spec(stmt)
-        if order_by is not None:
-            stmt = stmt.order_by(order_by)
-        total = self.session.execute(
-            select(func.count()).select_from(stmt.subquery())
-        ).scalar_one()
-        items = self.session.execute(
-            stmt.offset(page.page * page.size).limit(page.size)
-        ).scalars().all()
-        return Page(items, total, page.page, page.size)
-
-class SAAsyncRepository(Generic[T]):
-    """Async repository implementation for SQLAlchemy 2.x."""
-    def __init__(self, model: Type[T], session: AsyncSession):
-        self.model = model
-        self.session = session
-        
-    async def getAll(self, limit: Optional[int] = None) -> List[T]:
-        stmt = select(self.model)
-        if limit is not None:
-            stmt = stmt.limit(limit)
-        result = await self.session.execute(stmt)
-        return result.scalars().all()
-
-    def _select(self):
-        return select(self.model)
-
-    async def get(self, id_: Any) -> T:
-        obj = await self.session.get(self.model, id_)
-        if not obj:
-            raise NotFoundError(f"{self.model.__name__}({id_}) not found")
-        return obj
-
-    async def try_get(self, id_: Any) -> Optional[T]:
-        return await self.session.get(self.model, id_)
-
-    async def add(self, entity: T) -> T:
-        self.session.add(entity)
-        await self.session.flush()
-        await self.session.refresh(entity)
-        return entity
-
-    async def update(self, entity: T) -> T:
-        await self.session.flush()
-        await self.session.refresh(entity)
-        return entity
-
-    async def remove(self, entity: T) -> None:
-        insp = inspect(entity, raiseerr=False)
-        if not (insp and (insp.persistent or insp.pending)):
-            pk = getattr(entity, "id", None)
-            if pk is None:
-                raise ValueError("remove() needs a persistent entity or an entity with a primary key set")
-            entity = await self.session.get(self.model, pk)
-            if entity is None:
-                return
-        if hasattr(entity, "is_deleted"):
-            setattr(entity, "is_deleted", True)
-        else:
-            await self.session.delete(entity)
-
-    async def delete_by_id(self, id_: Any) -> bool:
-        obj = await self.session.get(self.model, id_)
-        if not obj:
-            return False
-        await self.remove(obj)
-        return True
-
-    async def page(self, page: PageRequest, spec: Optional[Spec] = None, order_by=None) -> Page[T]:
-        stmt = self._select()
-        if spec:
-            stmt = spec(stmt)
-        if order_by is not None:
-            stmt = stmt.order_by(order_by)
-        total = (await self.session.execute(
-            select(func.count()).select_from(stmt.subquery())
-        )).scalar_one()
-        res = await self.session.execute(
-            stmt.offset(page.page * page.size).limit(page.size)
-        )
-        items = res.scalars().all()
-        return Page(items, total, page.page, page.size)

sarepo-0.1.3/tests/test_sync_basic.py

@@ -1,73 +0,0 @@
-import pytest
-from sqlalchemy import create_engine, String
-from sqlalchemy.orm import sessionmaker, DeclarativeBase, Mapped, mapped_column
-from SARepo.sa_repo import SARepository
-from SARepo.base import PageRequest, NotFoundError
-
-class Base(DeclarativeBase): pass
-
-class Item(Base):
-    __tablename__ = "items"
-    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
-    title: Mapped[str] = mapped_column(String(100), nullable=False)
-
-def test_crud_and_pagination():
-    engine = create_engine("sqlite+pysqlite:///:memory:", echo=False)
-    Base.metadata.create_all(engine)
-    SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
-
-    with SessionLocal() as session:
-        repo = SARepository(Item, session)
-        for i in range(25):
-            repo.add(Item(title=f"t{i}"))
-        session.commit()
-
-        page = repo.page(PageRequest(1, 10))
-        assert page.total == 25
-        assert len(page.items) == 10
-        assert page.page == 1
-        assert page.pages == 3
-        # проверим, что конкретные объекты есть
-        got = {it.title for it in page.items}
-        assert got.issubset({f"t{i}" for i in range(25)})
-
-def test_get_all():
-    engine = create_engine("sqlite+pysqlite:///:memory:", echo=False)
-    Base.metadata.create_all(engine)
-    SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
-
-    with SessionLocal() as session:
-        repo = SARepository(Item, session)
-        for i in range(10):
-            repo.add(Item(title=f"get-all-{i}"))
-        session.commit()
-
-        items = repo.getAll()
-        assert isinstance(items, list)
-        assert len(items) == 10
-        titles = {i.title for i in items}
-        assert titles == {f"get-all-{i}" for i in range(10)}
-        
-        items2 = repo.getAll(5)
-        assert isinstance(items2, list)
-        assert len(items2) == 5
-        titles = {i.title for i in items2}
-        assert titles == {f"get-all-{i}" for i in range(5)}
-
-def test_get_and_try_get():
-    engine = create_engine("sqlite+pysqlite:///:memory:", echo=False)
-    Base.metadata.create_all(engine)
-    SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
-
-    with SessionLocal() as session:
-        repo = SARepository(Item, session)
-        obj = repo.add(Item(title="one"))
-        session.commit()
-
-        same = repo.get(obj.id)
-        assert same.id == obj.id and same.title == "one"
-
-        assert repo.try_get(9999) is None
-
-        with pytest.raises(NotFoundError):
-            repo.get(9999)