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

SARepo/repo.py

@@ -1,4 +1,6 @@
-from typing import Generic, List, TypeVar, Type, Optional, Any, Protocol
+from __future__ import annotations
+
+from typing import Any, Generic, List, Optional, Protocol, Type, TypeVar, runtime_checkable
 
 from SARepo.sa_repo import Spec
 from .base import Page, PageRequest
@@ -6,69 +8,102 @@ from .base import Page, PageRequest
 T = TypeVar("T")
 
 
+@runtime_checkable
 class CrudRepository(Protocol, Generic[T]):
-    model: Type[T]
-
-    def getAll(self,
-               limit: Optional[int] = None,
-               *,
-               include_deleted: bool = False,
-               order_by=None,
-               **filters) -> List[T]: ...
-
-    def get(self, id_: Any = None, *, include_deleted: bool = False, **filters) -> T: ...
+    """
+    Контракт CRUD-репозитория для SQLAlchemy-подобной реализации.
+    Реализация должна соответствовать сигнатурам ниже.
+    """
 
-    def try_get(self, id_: Any = None, *, include_deleted: bool = False, **filters) -> 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: ...
+    model: Type[T]
 
-    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]: ...
+        self,
+        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
-    ) -> tuple[T, bool]: ...
+    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 raw_query(self, sql: str, params: Optional[dict] = None) -> list[dict]:
+        ...
 
-    def aggregate_avg(self, column_name: str, **filters) -> Optional[float]: ...
+    def aggregate_avg(self, column_name: str, **filters: Any) -> Optional[float]:
+        ...
 
-    def aggregate_min(self, column_name: str, **filters): ...
+    def aggregate_min(self, column_name: str, **filters: Any):
+        ...
 
-    def aggregate_max(self, column_name: str, **filters): ...
+    def aggregate_max(self, column_name: str, **filters: Any):
+        ...
 
-    def aggregate_sum(self, column_name: str, **filters): ...
+    def aggregate_sum(self, column_name: str, **filters: Any):
+        ...
 
-    def count(self, **filters) -> int: ...
+    def count(self, **filters: Any) -> int:
+        ...
 
-    def restore(self, id_: Any) -> bool: ...
+    def restore(self, id_: Any) -> bool:
+        ...

SARepo/sa_repo.py

@@ -1,7 +1,7 @@
-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")
@@ -9,12 +9,14 @@ 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)
@@ -26,6 +28,11 @@ 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)
 
@@ -37,14 +44,19 @@ class SARepository(Generic[T]):
             stmt = stmt.where(self.model.is_deleted == False)  # noqa: E712
         return stmt
 
+    # ---- CRUD/queries
+
     def getAll(
-            self,
-            limit: Optional[int] = None,
-            *,
-            include_deleted: bool = False,
-            order_by=None,
-            **filters
+        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)
@@ -55,11 +67,17 @@ class SARepository(Generic[T]):
         result = self.session.execute(stmt)
         return result.scalars().all()
 
-    def get(self, id_: Any = None, *, include_deleted: bool = False, **filters) -> T:
+    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:
-                raise NotFoundError(f"{self.model.__name__}({id_}) not found")
+                return None
         else:
             stmt = select(self.model)
             stmt = self._apply_filters(stmt, **filters)
@@ -67,29 +85,81 @@ class SARepository(Generic[T]):
             res = self.session.execute(stmt)
             obj = res.scalars().first()
             if not obj:
-                raise NotFoundError(f"{self.model.__name__} not found for {filters}")
+                return None
+
         if self._has_soft_delete() and not include_deleted and getattr(obj, "is_deleted", False):
             raise NotFoundError(f"{self.model.__name__}({getattr(obj, 'id', '?')}) deleted")
         return obj
 
     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
 
-    def add(self, entity: T) -> T:
-        self.session.add(entity)
-        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').")
 
-    def update(self, entity: T) -> T:
-        self.session.flush()
-        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)  # 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")
 
@@ -104,8 +174,10 @@ 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)
 
@@ -115,14 +187,23 @@ class SARepository(Generic[T]):
         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]:
+        return self.remove(obj)
+
+    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)
@@ -131,21 +212,22 @@ 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,
-            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,
+    ) -> List[T]:
         col = self._resolve_column(column_name)
         stmt = select(self.model).where(col == value)
         stmt = self._apply_alive_filter(stmt, include_deleted)
@@ -157,25 +239,22 @@ class SARepository(Generic[T]):
         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 дополняют поля при создании.
-        """
+        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 = 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)
@@ -184,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]:
@@ -225,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_)
@@ -266,6 +339,11 @@ class SAAsyncRepository(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)
 
@@ -298,7 +376,7 @@ class SAAsyncRepository(Generic[T]):
         result = await self.session.execute(stmt)
         return result.scalars().all()
 
-    async def get(self, id_: Any = None, *, include_deleted: bool = False, **filters) -> T:
+    async def get(self, id_: Any = None, *, include_deleted: bool = False, **filters) -> Optional[T]:
         """
         Получить один объект по id или по произвольным фильтрам.
         Пример:
@@ -309,7 +387,7 @@ class SAAsyncRepository(Generic[T]):
         if id_ is not None:
             obj = await self.session.get(self.model, id_)
             if not obj:
-                raise NotFoundError(f"{self.model.__name__}({id_}) not found")
+                return None
         else:
             stmt = select(self.model)
             stmt = self._apply_filters(stmt, **filters)
@@ -317,7 +395,7 @@ class SAAsyncRepository(Generic[T]):
             res = await self.session.execute(stmt)
             obj = res.scalars().first()
             if not obj:
-                raise NotFoundError(f"{self.model.__name__} not found for {filters}")
+                return None
         if self._has_soft_delete() and not include_deleted and getattr(obj, "is_deleted", False):
             raise NotFoundError(f"{self.model.__name__}({getattr(obj, 'id', '?')}) deleted")
         return obj
@@ -331,16 +409,68 @@ class SAAsyncRepository(Generic[T]):
         except NotFoundError:
             return None
 
-    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, entity: T) -> T:
-        await self.session.flush()
-        await self.session.refresh(entity)
-        return entity
+    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').")
+
+        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:

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.7.dist-info/METADATA

@@ -1,90 +0,0 @@
-Metadata-Version: 2.4
-Name: SARepo
-Version: 0.1.7
-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.7.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=2MsR21GFMYstXRimFVqShC9foG7KmAuzTFtqsjK3a-Q,2129
-SARepo/sa_repo.py,sha256=fUae3B1aDxN3E-oKuthi0joWnrpCAOaUFHCi9H3be8c,19052
-SARepo/specs.py,sha256=e-X1cCkva3e71M37hcfbjNDMezZAaOkkRaPToUzhEeU,687
-SARepo/uow.py,sha256=yPlvi7PoH9x2pLNt6hEin9zT5qG9axUKn_TkZcIuz1s,859
-sarepo-0.1.7.dist-info/licenses/LICENSE,sha256=px90NOQCrnZ77qoFT8IvAiNS1CXQ2OU27uVBKbki9DM,131
-sarepo-0.1.7.dist-info/METADATA,sha256=b3pMl6G85wJ8qN1LtB5dc-mGwj0vmQXWBaL66x2WazY,2691
-sarepo-0.1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sarepo-0.1.7.dist-info/top_level.txt,sha256=0k952UYVZLIIv3kZzFlxI0yzBMusZo3-XCQtxms_kS0,7
-sarepo-0.1.7.dist-info/RECORD,,