SARepo 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

SARepo/repo.py

@@ -1,16 +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]) -> List[T]: ...
-    def get(self, id_: Any) -> T: ...
-    def try_get(self, id_: Any) -> Optional[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=None, order_by=None) -> Page[T]: ...
+    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/sa_repo.py

@@ -2,11 +2,11 @@
 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 sqlalchemy import inspect, select, func, text
 from .base import PageRequest, Page, NotFoundError
 
 T = TypeVar("T")
-Spec = Callable  # aliased to match specs.Spec
+Spec = Callable
 
 class SARepository(Generic[T]):
     """Synchronous repository implementation for SQLAlchemy 2.x."""
@@ -14,25 +14,52 @@ class SARepository(Generic[T]):
         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 getAll(self, limit: Optional[int] = None) -> List[T]:
+    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()
+        return result.scalars().all()    
     
-    def get(self, id_: Any) -> T:
+    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) -> Optional[T]:
-        return self.session.get(self.model, id_)
-
+    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()
@@ -65,44 +92,185 @@ class SARepository(Generic[T]):
         self.remove(obj)
         return True
 
-    def page(self, page: PageRequest, spec: Optional[Spec] = None, order_by=None) -> Page[T]:
-        stmt = self._select()
+    def page(self, page: PageRequest, spec: Optional[Spec] = None, order_by=None, *, include_deleted: bool = False) -> Page[T]:
+        base = self._select()
         if spec:
-            stmt = spec(stmt)
+            base = spec(base)
+        base = self._apply_alive_filter(base, include_deleted)
         if order_by is not None:
-            stmt = stmt.order_by(order_by)
+            base = base.order_by(order_by)
+
         total = self.session.execute(
-            select(func.count()).select_from(stmt.subquery())
+            select(func.count()).select_from(base.subquery())
         ).scalar_one()
+
         items = self.session.execute(
-            stmt.offset(page.page * page.size).limit(page.size)
+            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
-        
-    async def getAll(self, limit: Optional[int] = None) -> List[T]:
+    
+    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()
 
-    def _select(self):
-        return select(self.model)
-
-    async def get(self, id_: Any) -> T:
+    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) -> Optional[T]:
-        return await self.session.get(self.model, id_)
+    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)
@@ -136,17 +304,120 @@ class SAAsyncRepository(Generic[T]):
         await self.remove(obj)
         return True
 
-    async def page(self, page: PageRequest, spec: Optional[Spec] = None, order_by=None) -> Page[T]:
-        stmt = self._select()
+    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:
-            stmt = spec(stmt)
+            base = spec(base)
+        base = self._apply_alive_filter(base, include_deleted)
         if order_by is not None:
-            stmt = stmt.order_by(order_by)
+            base = base.order_by(order_by)
+
         total = (await self.session.execute(
-            select(func.count()).select_from(stmt.subquery())
+            select(func.count()).select_from(base.subquery())
         )).scalar_one()
+
         res = await self.session.execute(
-            stmt.offset(page.page * page.size).limit(page.size)
+            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.dist-info → sarepo-0.1.5.dist-info}/METADATA

@@ -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.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=N_LaqguNE3Y_9vZBPBvqQreu-6Sy9-BZFR3-pZl5eT4,1777
+SARepo/sa_repo.py,sha256=iIscSTNoZGb8XMTY66_fiooWPVwGMOMYAL9BC_xS7bI,16691
+SARepo/specs.py,sha256=e-X1cCkva3e71M37hcfbjNDMezZAaOkkRaPToUzhEeU,687
+SARepo/uow.py,sha256=yPlvi7PoH9x2pLNt6hEin9zT5qG9axUKn_TkZcIuz1s,859
+sarepo-0.1.5.dist-info/licenses/LICENSE,sha256=px90NOQCrnZ77qoFT8IvAiNS1CXQ2OU27uVBKbki9DM,131
+sarepo-0.1.5.dist-info/METADATA,sha256=m9z_QHD-D1dN95nAGWvpFGAUT7hCad990Lb-nNS5two,2691
+sarepo-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sarepo-0.1.5.dist-info/top_level.txt,sha256=0k952UYVZLIIv3kZzFlxI0yzBMusZo3-XCQtxms_kS0,7
+sarepo-0.1.5.dist-info/RECORD,,

sarepo-0.1.3.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=5Af4SLfbKOMJdX7MOev4OcGIGQ0HzN6QDUktURjasyU,597
-SARepo/sa_repo.py,sha256=feuwBHAEdW_STJ6fHxYlSO0KvSruoqiB_v1sTCRy6JE,5332
-SARepo/specs.py,sha256=e-X1cCkva3e71M37hcfbjNDMezZAaOkkRaPToUzhEeU,687
-SARepo/uow.py,sha256=yPlvi7PoH9x2pLNt6hEin9zT5qG9axUKn_TkZcIuz1s,859
-sarepo-0.1.3.dist-info/licenses/LICENSE,sha256=px90NOQCrnZ77qoFT8IvAiNS1CXQ2OU27uVBKbki9DM,131
-sarepo-0.1.3.dist-info/METADATA,sha256=FXf9N-SsghCIQGucviE8GVVxh1viF0BV0FhKkMeg2HQ,2691
-sarepo-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sarepo-0.1.3.dist-info/top_level.txt,sha256=0k952UYVZLIIv3kZzFlxI0yzBMusZo3-XCQtxms_kS0,7
-sarepo-0.1.3.dist-info/RECORD,,