SARepo 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

SARepo/repo.py

@@ -1,50 +1,109 @@
+from __future__ import annotations
 
-from typing import Generic, List, TypeVar, Type, Optional, Any, Protocol
+from typing import Any, Generic, List, Optional, Protocol, Type, TypeVar, runtime_checkable
 
 from SARepo.sa_repo import Spec
 from .base import Page, PageRequest
 
 T = TypeVar("T")
 
+
+@runtime_checkable
 class CrudRepository(Protocol, Generic[T]):
+    """
+    Контракт CRUD-репозитория для SQLAlchemy-подобной реализации.
+    Реализация должна соответствовать сигнатурам ниже.
+    """
+
     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: Optional[T] = None, id: Optional[Any] = None) -> bool: ...
-    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 getAll(
+        self,
+        limit: Optional[int] = None,
+        *,
+        include_deleted: bool = False,
+        order_by=None,
+        **filters: Any,
+    ) -> List[T]:
+        ...
+
+    def get(self, id_: Any = None, *, include_deleted: bool = False, **filters: Any) -> T:
+        """
+        Должен вернуть объект T или бросить исключение (например, NotFoundError),
+        если объект не найден. Если хочешь Optional — измени сигнатуру.
+        """
+        ...
+
+    def try_get(self, id_: Any = None, *, include_deleted: bool = False, **filters: Any) -> Optional[T]:
+        ...
+
+    def add(self, entity: T) -> T:
+        ...
+
+    def update(self, entity: T) -> T:
+        ...
+
+    def remove(self, entity: Optional[T] = None, id: Optional[Any] = None) -> bool:
+        ...
+
+    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]: ...
+        self,
+        column_name: str,
+        value: Any,
+        *,
+        limit: Optional[int] = None,
+        order_by=None,
+        include_deleted: bool = False,
+        **extra_filters: Any,
+    ) -> 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: ...
+        column_name: str,
+        value: Any,
+        *,
+        limit: Optional[int] = None,
+        order_by=None,
+        include_deleted: bool = False,
+        **extra_filters: Any,
+    ) -> list[T]:
+        ...
+
+    def get_or_create(self, defaults: Optional[dict] = None, **unique_filters: Any) -> tuple[T, bool]:
+        ...
+
+    def raw_query(self, sql: str, params: Optional[dict] = None) -> list[dict]:
+        ...
+
+    def aggregate_avg(self, column_name: str, **filters: Any) -> Optional[float]:
+        ...
+
+    def aggregate_min(self, column_name: str, **filters: Any):
+        ...
+
+    def aggregate_max(self, column_name: str, **filters: Any):
+        ...
+
+    def aggregate_sum(self, column_name: str, **filters: Any):
+        ...
+
+    def count(self, **filters: Any) -> int:
+        ...
+
+    def restore(self, id_: Any) -> bool:
+        ...

SARepo/sa_repo.py

@@ -1,19 +1,22 @@
-
-from typing import List, Type, Generic, TypeVar, Optional, Sequence, Any, Callable
+from typing import List, Type, Generic, TypeVar, Optional, Sequence, Any, Callable, Tuple
 from sqlalchemy.orm import Session
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import inspect, select, func, text
+from sqlalchemy import inspect, select, func, text, insert, update, and_
 from .base import PageRequest, Page, NotFoundError
 
 T = TypeVar("T")
 Spec = Callable
 
+
 class SARepository(Generic[T]):
-    """Synchronous repository implementation for SQLAlchemy 2.x."""
+    """Sync repository implementation for SQLAlchemy 2.x (ORM Session)."""
+
     def __init__(self, model: Type[T], session: Session):
         self.model = model
         self.session = session
 
+    # ---- helpers
+
     def _resolve_column(self, column_name: str):
         try:
             return getattr(self.model, column_name)
@@ -25,59 +28,144 @@ class SARepository(Generic[T]):
             stmt = stmt.filter_by(**filters)
         return stmt
 
+    def _to_dto(self, obj: Any) -> Any:
+        if hasattr(obj, "to_read_model"):
+            return obj.to_read_model()
+        return obj
+
     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) :
+    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]:
+
+    # ---- CRUD/queries
+
+    def getAll(
+        self,
+        limit: Optional[int] = None,
+        *,
+        include_deleted: bool = False,
+        order_by=None,
+        **filters,
+    ) -> List[T]:
+        """
+        Получить все записи с возможностью фильтрации (username='foo', age__gt=20, и т.д.)
+        """
         stmt = select(self.model)
+        stmt = self._apply_filters(stmt, **filters)
         stmt = self._apply_alive_filter(stmt, include_deleted)
+        if order_by is not None:
+            stmt = stmt.order_by(order_by)
         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")
+        return result.scalars().all()
+
+    def get(self, id_: Any = None, *, include_deleted: bool = False, **filters) -> Optional[T]:
+        """
+        Получить один объект по id или по произвольным фильтрам.
+            repo.get(id_=1)
+            repo.get(username='ibrahim')
+            repo.get(username__ilike='%rah%')   # если у тебя реализована интерпретация таких фильтров выше по стеку
+        """
+        if id_ is not None:
+            obj = self.session.get(self.model, id_)
+            if not obj:
+                return None
+        else:
+            stmt = select(self.model)
+            stmt = self._apply_filters(stmt, **filters)
+            stmt = self._apply_alive_filter(stmt, include_deleted)
+            res = self.session.execute(stmt)
+            obj = res.scalars().first()
+            if not obj:
+                return None
+
         if self._has_soft_delete() and not include_deleted and getattr(obj, "is_deleted", False):
-            raise NotFoundError(f"{self.model.__name__}({id_}) not found")  # скрываем как «нет»
+            raise NotFoundError(f"{self.model.__name__}({getattr(obj, 'id', '?')}) deleted")
         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):
+    def try_get(self, id_: Any = None, *, include_deleted: bool = False, **filters) -> Optional[T]:
+        """Как get(), но не выбрасывает исключение при soft-deleted."""
+        try:
+            return self.get(id_=id_, include_deleted=include_deleted, **filters)
+        except NotFoundError:
             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 add(self, data: dict) -> T:
+        """
+        Вставка через Core insert(...).returning(model.id) — как в async-версии.
+        Возвращает dict с добавленным id (повторяю твою семантику).
+        """
+        stmt = insert(self.model).values(**data).returning(self.model.id)
+        res = self.session.execute(stmt)
+        new_id = res.scalar_one()
+        self.session.commit()
+        data["id"] = new_id
+        return data  # так же, как у тебя: возвращаем dict, а не ORM-объект
+
+    def update(
+        self,
+        data: dict,
+        *,
+        include_deleted: bool = False,
+        expect_one: bool = False,
+        **filters,
+    ) -> Optional[T]:
+        """
+        Обновляет запись(и) по произвольным фильтрам.
+        Возвращает DTO одной обновлённой строки (если ровно одна) или None.
+        """
+        if not data:
+            raise ValueError("`data` не может быть пустым.")
+        if not filters:
+            raise ValueError("Нужен хотя бы один фильтр (например, id=1 или username='foo').")
+
+        values = {self._resolve_column(k).key: v for k, v in data.items()}
+        conditions = [self._resolve_column(k) == v for k, v in filters.items()]
+        if self._has_soft_delete() and not include_deleted:
+            conditions.append(self.model.is_deleted == False)  # noqa: E712
+
+        stmt = (
+            update(self.model)
+            .where(and_(*conditions))
+            .values(**values)
+            .returning(self.model)
+        )
+
+        res = self.session.execute(stmt)
+        updated_obj = res.scalar_one_or_none()
+
+        if expect_one:
+            rowcount = res.rowcount
+            if rowcount != 1:
+                self.session.rollback()
+                raise ValueError(f"Ожидалась ровно 1 строка, затронуто: {rowcount}")
+
+        if updated_obj is not None:
+            self.session.commit()
+            return self._to_dto(updated_obj)
+
+        self.session.rollback()
+        return None
 
     def remove(self, entity: Optional[T] = None, id: Optional[Any] = None) -> bool:
+        """
+        Поведение идентично твоему async-коду: soft-delete, иначе физическое удаление.
+        Коммиты намеренно не делаю, чтобы не менять твою транзакционную модель.
+        """
         if entity is None and id is None:
             raise ValueError("remove() requires either entity or id")
-    
+
         if id is not None:
             return self._delete_by_id(id)
-        
+
         insp = inspect(entity, raiseerr=False)
         if not (insp and (insp.persistent or insp.pending)):
             pk = getattr(entity, "id", None)
@@ -86,24 +174,36 @@ class SARepository(Generic[T]):
             entity = self.session.get(self.model, pk)
             if entity is None:
                 return False
+
         if hasattr(entity, "is_deleted"):
             setattr(entity, "is_deleted", True)
+            self.session.flush()
         else:
             self.session.delete(entity)
-            
+
         return True
 
     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
+        return self.remove(obj)
 
-    def page(self, page: PageRequest, spec: Optional[Spec] = None, order_by=None, *, include_deleted: bool = False) -> Page[T]:
+    def page(
+        self,
+        page: PageRequest,
+        spec: Optional[Spec] = None,
+        order_by=None,
+        *,
+        include_deleted: bool = False,
+    ) -> Page[T]:  # type: ignore
+        """
+        Точно повторяю логику подсчёта total через подзапрос.
+        Ожидается, что Page(items, total, page.page, page.size) уже есть в твоём коде.
+        """
         base = self._select()
         if spec:
-            base = spec(base)
+            base = spec(base)  # type: ignore
         base = self._apply_alive_filter(base, include_deleted)
         if order_by is not None:
             base = base.order_by(order_by)
@@ -112,11 +212,12 @@ class SARepository(Generic[T]):
             select(func.count()).select_from(base.subquery())
         ).scalar_one()
 
-        items = self.session.execute(
+        res = self.session.execute(
             base.offset(page.page * page.size).limit(page.size)
-        ).scalars().all()
-        return Page(items, total, page.page, page.size)
-    
+        )
+        items = res.scalars().all()
+        return Page(items, total, page.page, page.size)  # type: ignore
+
     def get_all_by_column(
         self,
         column_name: str,
@@ -125,8 +226,8 @@ class SARepository(Generic[T]):
         limit: Optional[int] = None,
         order_by=None,
         include_deleted: bool = False,
-        **extra_filters
-    ) -> list[T]:
+        **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)
@@ -137,26 +238,23 @@ class SARepository(Generic[T]):
             stmt = stmt.limit(limit)
         res = self.session.execute(stmt)
         return res.scalars().all()
-        
-    # Alias 
+
+    # 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 дополняют поля при создании.
-        """
+        **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 = 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)
@@ -165,12 +263,8 @@ class SARepository(Generic[T]):
         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)
+        # В SQLA 2.x для маппингов:
         return [dict(row) for row in res.mappings().all()]
 
     def aggregate_avg(self, column_name: str, **filters) -> Optional[float]:
@@ -206,17 +300,15 @@ class SARepository(Generic[T]):
         return self.session.execute(stmt).scalar()
 
     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 filters.pop("include_deleted", False):
+        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(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_)
@@ -228,12 +320,14 @@ class SARepository(Generic[T]):
             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)
@@ -244,60 +338,147 @@ class SAAsyncRepository(Generic[T]):
         if filters:
             stmt = stmt.filter_by(**filters)
         return stmt
-    
+
+    def _to_dto(self, obj: Any) -> Any:
+        if hasattr(obj, "to_read_model"):
+            return obj.to_read_model()
+        return obj
+
     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) :
+    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]:
+    async def getAll(
+            self,
+            limit: Optional[int] = None,
+            *,
+            include_deleted: bool = False,
+            order_by=None,
+            **filters
+    ) -> List[T]:
+        """
+        Получить все записи с возможностью фильтрации (username='foo', age__gt=20, и т.д.)
+        """
         stmt = select(self.model)
+        stmt = self._apply_filters(stmt, **filters)
         stmt = self._apply_alive_filter(stmt, include_deleted)
+        if order_by is not None:
+            stmt = stmt.order_by(order_by)
         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")
+    async def get(self, id_: Any = None, *, include_deleted: bool = False, **filters) -> Optional[T]:
+        """
+        Получить один объект по id или по произвольным фильтрам.
+        Пример:
+            await repo.get(id_=1)
+            await repo.get(username='ibrahim')
+            await repo.get(username__ilike='%rah%')
+        """
+        if id_ is not None:
+            obj = await self.session.get(self.model, id_)
+            if not obj:
+                return None
+        else:
+            stmt = select(self.model)
+            stmt = self._apply_filters(stmt, **filters)
+            stmt = self._apply_alive_filter(stmt, include_deleted)
+            res = await self.session.execute(stmt)
+            obj = res.scalars().first()
+            if not obj:
+                return None
         if self._has_soft_delete() and not include_deleted and getattr(obj, "is_deleted", False):
-            raise NotFoundError(f"{self.model.__name__}({id_}) not found")
+            raise NotFoundError(f"{self.model.__name__}({getattr(obj, 'id', '?')}) deleted")
         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):
+    async def try_get(self, id_: Any = None, *, include_deleted: bool = False, **filters) -> Optional[T]:
+        """
+        Как get(), но не выбрасывает исключение при отсутствии объекта.
+        """
+        try:
+            return await self.get(id_=id_, include_deleted=include_deleted, **filters)
+        except NotFoundError:
             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 add(self, data: dict) -> T:
+        stmt = (
+            insert(self.model)
+            .values(**data)
+            .returning(self.model.id)
+        )
+        res = await self.session.execute(stmt)
+        new_id = res.scalar_one()
+        await self.session.commit()
+        data["id"] = new_id
+        return data
+
+    async def update(
+            self,
+            data: dict,
+            *,
+            include_deleted: bool = False,
+            expect_one: bool = False,
+            **filters,
+    ) -> Optional[T]:
+        """
+        Обновляет запись(и) по произвольным фильтрам.
+        - data: словарь обновляемых полей -> значений
+        - include_deleted: если модель имеет is_deleted, включать ли удалённые
+        - expect_one: если True — бросит ValueError, если затронуто != 1 строк
+        - **filters: произвольные фильтры вида field=value
+        Возвращает DTO одной обновлённой строки (если ровно одна) или None.
+        """
+        if not data:
+            raise ValueError("`data` не может быть пустым.")
+        if not filters:
+            raise ValueError("Нужен хотя бы один фильтр (например, id=1 или username='foo').")
 
-    async def update(self, entity: T) -> T:
-        await self.session.flush()
-        await self.session.refresh(entity)
-        return entity
+        values = {self._resolve_column(k).key: v for k, v in data.items()}
+
+        conditions = [self._resolve_column(k) == v for k, v in filters.items()]
+
+        if self._has_soft_delete() and not include_deleted:
+            conditions.append(self.model.is_deleted == False)
+
+        stmt = (
+            update(self.model)
+            .where(and_(*conditions))
+            .values(**values)
+            .returning(self.model)
+        )
+
+        res = await self.session.execute(stmt)
+        updated_obj = res.scalar_one_or_none()
+
+        if expect_one:
+            rowcount = res.rowcount
+            if rowcount != 1:
+                await self.session.rollback()
+                raise ValueError(f"Ожидалась ровно 1 строка, затронуто: {rowcount}")
+
+        if updated_obj is not None:
+            await self.session.commit()
+            return self._to_dto(updated_obj)
+
+        await self.session.rollback()
+        return None
 
     async def remove(self, entity: Optional[T] = None, id: Optional[Any] = None) -> bool:
         if entity is None and id is None:
             raise ValueError("remove() requires either entity or id")
-    
+
         if id is not None:
             return await self._delete_by_id(id)
-        
+
         insp = inspect(entity, raiseerr=False)
         if not (insp and (insp.persistent or insp.pending)):
             pk = getattr(entity, "id", None)
@@ -310,10 +491,9 @@ class SAAsyncRepository(Generic[T]):
             setattr(entity, "is_deleted", True)
         else:
             await self.session.delete(entity)
-            
+
         return True
 
-    
     async def _delete_by_id(self, id_: Any) -> bool:
         obj = await self.session.get(self.model, id_)
         if not obj:
@@ -321,7 +501,8 @@ class SAAsyncRepository(Generic[T]):
         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
+    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)
@@ -340,14 +521,14 @@ class SAAsyncRepository(Generic[T]):
         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
+            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)
@@ -363,11 +544,11 @@ class SAAsyncRepository(Generic[T]):
     # 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
+            self,
+            defaults: Optional[dict] = None,
+            **unique_filters
     ) -> tuple[T, bool]:
         stmt = select(self.model).filter_by(**unique_filters)
         if hasattr(self.model, "is_deleted"):
@@ -437,4 +618,4 @@ class SAAsyncRepository(Generic[T]):
             setattr(obj, "is_deleted", False)
             await self.session.flush()
             return True
-        return False
+        return False

sarepo-0.1.8.dist-info/METADATA

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: SARepo
+Version: 0.1.8
+Summary: Minimal, explicit Repository & Unit-of-Work layer over SQLAlchemy 2.x
+Author: nurbergenovv
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: SQLAlchemy>=2.0
+Dynamic: license-file
+
+# SARepo
+
+**Minimal, explicit Repository + Unit of Work layer on top of SQLAlchemy 2.x (sync & async).**  
+No magic method names — just clean typed APIs, composable specs, pagination, and optional soft-delete.
+
+---
+
+## 🚀 Quick Start (Sync)
+
+```python
+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
+from SARepo.specs import and_specs, ilike
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class Request(Base):
+    __tablename__ = "requests"
+
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    title: Mapped[str] = mapped_column(String(255))
+    status: Mapped[str] = mapped_column(String(50))
+
+
+# Setup database
+engine = create_engine("sqlite+pysqlite:///:memory:", echo=False)
+Base.metadata.create_all(engine)
+SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
+
+# Usage
+with SessionLocal() as session:
+    repo = SARepository(Request, session)
+
+    # Create
+    r = repo.add(Request(title="Hello", status="NEW"))
+    session.commit()
+
+    # Query + Paginate
+    page = repo.page(PageRequest(0, 10), spec=ilike(Request.title, "%He%"))
+    print(page.total, [i.title for i in page.items])
+```
+
+---
+
+## ⚙️ Async Quick Start
+
+```python
+import asyncio
+from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker
+
+from SARepo.sa_repo import SAAsyncRepository
+from SARepo.base import PageRequest
+
+
+async def main():
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:", echo=False)
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+    SessionLocal = async_sessionmaker(bind=engine, expire_on_commit=False)
+
+    async with SessionLocal() as session:
+        repo = SAAsyncRepository(Request, session)
+
+        await repo.add(Request(title="Hello", status="NEW"))
+        await session.commit()
+
+        page = await repo.page(PageRequest(0, 10))
+        print(page.total)
+
+
+asyncio.run(main())
+```
+
+---
+
+## 🧠 Features
+
+✅ **SARepository / SAAsyncRepository**
+- Clean CRUD operations (`get`, `add`, `update`, `remove`, etc.)
+- `page()` method with total count
+
+✅ **Composable Specs**
+- Combine filters easily (`eq`, `ilike`, `and_specs`, `not_deleted`)
+
+✅ **Soft Delete**
+- Automatically filters out rows with `is_deleted=True` if the model has this column
+
+✅ **Typed Protocol Interface**
+- `CrudRepository` protocol for structural typing & IDE autocompletion
+
+✅ **Unit of Work**
+- Minimal sync & async helpers for transactional operations
+
+---
+
+## 🧩 Example: Spec Composition
+
+```python
+from SARepo.specs import eq, ilike, and_specs
+
+spec = and_specs(
+    eq(Request.status, "NEW"),
+    ilike(Request.title, "%Hello%")
+)
+
+page = repo.page(PageRequest(0, 10), spec=spec)
+```
+
+---
+
+## 📜 License
+
+**MIT License**  
+Copyright (c) 2025  
+
+---
+
+## 🧭 Project Structure (Example)
+
+```
+SARepo/
+│
+├── sa_repo.py         # Core Repository classes (sync & async)
+├── base.py            # Pagination, PageRequest, DTO helpers
+├── specs.py           # Composable query specs
+├── uow.py             # Optional Unit of Work layer
+├── __init__.py
+```
+
+---
+
+### ✅ Philosophy
+
+- No ORM “magic” — only explicit SQLAlchemy 2.0 APIs  
+- One repository → one model  
+- Predictable transaction scope  
+- Works with Pydantic DTOs or dataclasses  
+- 100 % type-safe

sarepo-0.1.8.dist-info/RECORD

@@ -0,0 +1,12 @@
+SARepo/__init__.py,sha256=tNYbuUDloC1qVnXq7uomS3jRcaPUvy0VEZiMdYR6x1M,183
+SARepo/base.py,sha256=UbAdZ9WYh_o93mrCVL3D8Q0tY_8mvm0HspO_L5m0GTQ,874
+SARepo/models.py,sha256=ypSmbKAijvNH4WjSeJBgyNT8mKa_e_7-I5kiNisjGAI,570
+SARepo/repo.py,sha256=bjxK5gzSrMZcYHnj688UTL2KVbg_9t8bNT2hLfWWAa8,2821
+SARepo/sa_repo.py,sha256=MY8RkXfrtahb9J96VXroq_OueSrixE02noxVzbc9UCc,24007
+SARepo/specs.py,sha256=e-X1cCkva3e71M37hcfbjNDMezZAaOkkRaPToUzhEeU,687
+SARepo/uow.py,sha256=yPlvi7PoH9x2pLNt6hEin9zT5qG9axUKn_TkZcIuz1s,859
+sarepo-0.1.8.dist-info/licenses/LICENSE,sha256=px90NOQCrnZ77qoFT8IvAiNS1CXQ2OU27uVBKbki9DM,131
+sarepo-0.1.8.dist-info/METADATA,sha256=CM2j9zHkVD4TaWFFDG3DypvuxlA3aOonNSNHxrJ-Z0Y,3768
+sarepo-0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sarepo-0.1.8.dist-info/top_level.txt,sha256=0k952UYVZLIIv3kZzFlxI0yzBMusZo3-XCQtxms_kS0,7
+sarepo-0.1.8.dist-info/RECORD,,

sarepo-0.1.6.dist-info/METADATA

@@ -1,90 +0,0 @@
-Metadata-Version: 2.4
-Name: SARepo
-Version: 0.1.6
-Summary: Minimal, explicit Repository & Unit-of-Work layer over SQLAlchemy 2.x
-Author: nurbergenovv
-License: MIT
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: SQLAlchemy>=2.0
-Dynamic: license-file
-
-
-# SARepo
-
-Minimal, explicit **Repository** + **Unit of Work** layer on top of **SQLAlchemy 2.x** (sync & async).
-No magic method-names, just clean typed APIs, composable specs, pagination, and optional soft-delete.
-
-## Install (editable)
-
-```bash
-pip install -e .
-```
-
-## Quick Start (sync)
-
-```python
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker, Mapped, mapped_column
-from sqlalchemy.orm import DeclarativeBase
-from sqlalchemy import String
-
-from SARepo.sa_repo import SARepository
-from SARepo.base import PageRequest
-from SARepo.specs import and_specs, ilike
-
-class Base(DeclarativeBase): pass
-
-class Request(Base):
-    __tablename__ = "requests"
-    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
-    title: Mapped[str] = mapped_column(String(255))
-    status: Mapped[str] = mapped_column(String(50))
-
-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(Request, session)
-    # create
-    r = repo.add(Request(title="Hello", status="NEW"))
-    session.commit()
-
-    # search + paginate
-    page = repo.page(PageRequest(0, 10), spec=ilike(Request.title, "%He%"))
-    print(page.total, [i.title for i in page.items])
-```
-
-## Async Quick Start
-
-```python
-import asyncio
-from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker
-from SARepo.sa_repo import SAAsyncRepository
-from SARepo.base import PageRequest
-
-async def main():
-    engine = create_async_engine("sqlite+aiosqlite:///:memory:", echo=False)
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
-    SessionLocal = async_sessionmaker(bind=engine, expire_on_commit=False)
-    async with SessionLocal() as session:
-        repo = SAAsyncRepository(Request, session)
-        await repo.add(Request(title="Hello", status="NEW"))
-        await session.commit()
-        page = await repo.page(PageRequest(0, 10))
-        print(page.total)
-
-asyncio.run(main())
-```
-
-## Features
-- `SARepository` and `SAAsyncRepository` (CRUD, `page()` with total count)
-- Composable **specs** (`eq`, `ilike`, `and_specs`, `not_deleted`)
-- Optional **soft-delete** if the entity has `is_deleted: bool`
-- Minimal **Unit of Work** helpers (sync & async)
-
-## License
-MIT

sarepo-0.1.6.dist-info/RECORD

@@ -1,12 +0,0 @@
-SARepo/__init__.py,sha256=tNYbuUDloC1qVnXq7uomS3jRcaPUvy0VEZiMdYR6x1M,183
-SARepo/base.py,sha256=UbAdZ9WYh_o93mrCVL3D8Q0tY_8mvm0HspO_L5m0GTQ,874
-SARepo/models.py,sha256=ypSmbKAijvNH4WjSeJBgyNT8mKa_e_7-I5kiNisjGAI,570
-SARepo/repo.py,sha256=q99K9odCVuxJ9HIKwgVpu3p9-hyzxmGlE-wkiCp9tbg,1820
-SARepo/sa_repo.py,sha256=iPJan94ALJ3N58aU1D6rgO6uhqLDUxcHXvORpQrAt9c,17258
-SARepo/specs.py,sha256=e-X1cCkva3e71M37hcfbjNDMezZAaOkkRaPToUzhEeU,687
-SARepo/uow.py,sha256=yPlvi7PoH9x2pLNt6hEin9zT5qG9axUKn_TkZcIuz1s,859
-sarepo-0.1.6.dist-info/licenses/LICENSE,sha256=px90NOQCrnZ77qoFT8IvAiNS1CXQ2OU27uVBKbki9DM,131
-sarepo-0.1.6.dist-info/METADATA,sha256=4Yfl0Eh0h8Sb2Lrs_DxZRfPJuZzGTg7-I9blRPva9aw,2691
-sarepo-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sarepo-0.1.6.dist-info/top_level.txt,sha256=0k952UYVZLIIv3kZzFlxI0yzBMusZo3-XCQtxms_kS0,7
-sarepo-0.1.6.dist-info/RECORD,,