rb-commons 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

rb_commons/orm/managers.py

@@ -1,9 +1,9 @@
 import uuid
 from typing import TypeVar, Type, Generic, Optional, List, Dict, Literal, Union
-from sqlalchemy import select, delete, update
+from sqlalchemy import select, delete, update, and_
 from sqlalchemy.exc import IntegrityError, SQLAlchemyError, NoResultFound
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import declarative_base
+from sqlalchemy.orm import declarative_base, InstrumentedAttribute
 
 from rb_commons.http.exceptions import NotFoundException
 from rb_commons.orm.exceptions import DatabaseException, InternalException
@@ -16,7 +16,8 @@ class BaseManager(Generic[ModelType]):
     def __init__(self, session: AsyncSession) -> None:
         self.session = session
         self.data = None
-        self.filters = {}
+        self.filters = []
+        self._filtered = False
 
     async def get(self, pk: Union[str, int, uuid.UUID]) -> Optional[ModelType]:
         """
@@ -37,26 +38,82 @@ class BaseManager(Generic[ModelType]):
 
     def filter(self, **kwargs) -> 'BaseManager[ModelType]':
         """
-           Filter objects based on conditions
+           Apply filtering conditions dynamically.
+
+           Supports:
+           - `field__eq`: Equal (`=`)
+           - `field__ne`: Not Equal (`!=`)
+           - `field__gt`: Greater Than (`>`)
+           - `field__lt`: Less Than (`<`)
+           - `field__gte`: Greater Than or Equal (`>=`)
+           - `field__lte`: Less Than or Equal (`<=`)
+           - `field__in`: IN Query
+           - `field__contains`: LIKE Query
        """
-        self.filters.update(kwargs)
+        self._filtered = True
+        self.filters = []
+
+        for key, value in kwargs.items():
+            if '__' in key:
+                field_name, operator = key.split('__', 1)
+            else:
+                field_name, operator = key, 'eq'
+
+            column = getattr(self.model, field_name, None)
+            if column is None or not isinstance(column, InstrumentedAttribute):
+                raise ValueError(f"Invalid filter field: {field_name}")
+
+            if operator == "eq":
+                self.filters.append(column == value)
+            elif operator == "ne":
+                self.filters.append(column != value)
+            elif operator == "gt":
+                self.filters.append(column > value)
+            elif operator == "lt":
+                self.filters.append(column < value)
+            elif operator == "gte":
+                self.filters.append(column >= value)
+            elif operator == "lte":
+                self.filters.append(column <= value)
+            elif operator == "in" and isinstance(value, list):
+                if not isinstance(value, list):
+                    raise ValueError(f"`{field_name}__in` requires a list, got {type(value)}")
+
+                self.filters.append(column.in_(value))
+            elif operator == "contains":
+                self.filters.append(column.ilike(f"%{value}%"))
+
         return self
 
+    def _ensure_filtered(self):
+        """Ensure that `filter()` has been called before using certain methods."""
+        if not self._filtered:
+            raise RuntimeError("You must call `filter()` before using this method.")
+
     async def all(self) -> List[ModelType]:
-        """Return all filtered results."""
-        query = select(self.model).filter_by(**self.filters)
+        """Return all results based on applied filters."""
+        self._ensure_filtered()
+
+        query = select(self.model)
+        if self.filters:
+            query = query.filter(and_(*self.filters))
+
         result = await self.session.execute(query)
         return list(result.scalars().all())
 
     async def first(self) -> Optional[ModelType]:
         """Return the first matching object, or None."""
-        query = select(self.model).filter_by(**self.filters)
+        self._ensure_filtered()
+
+        query = select(self.model).filter(and_(*self.filters))
         result = await self.session.execute(query)
         return result.scalars().first()
 
     async def count(self) -> int:
         """Return the count of matching records."""
-        query = select(self.model).filter_by(**self.filters)
+        self._ensure_filtered()
+
+        query = select(self.model).filter(and_(*self.filters))
         result = await self.session.execute(query)
         return len(result.scalars().all())
 
@@ -83,37 +140,35 @@ class BaseManager(Generic[ModelType]):
             raise InternalException(f"Unexpected error during creation: {str(e)}") from e
 
 
-    async def delete(self, id: Optional[int] = None, **filters):
+    async def delete(self):
         """
         Delete object(s) with flexible filtering options
 
-        :param id: Specific ID to delete
-        :param filters: Additional filter conditions
         :return: Number of deleted records or None
         """
-        try:
-            if id is not None:
-                filters['id'] = id
+        self._ensure_filtered()
 
-            delete_stmt = delete(self.model).filter_by(**filters)
+        try:
+            delete_stmt = delete(self.model).where(and_(*self.filters))
             result = await self.session.execute(delete_stmt)
             await self.session.commit()
-            return result
+            return result.rowcount
         except NoResultFound:
             return False
         except SQLAlchemyError as e:
             await self.session.rollback()
             raise DatabaseException(f"Delete operation failed: {str(e)}") from e
 
-    async def bulk_delete(self, **filters) -> int:
+    async def bulk_delete(self) -> int:
         """
         Bulk delete with flexible filtering
 
-        :param filters: Conditions for bulk deletion
         :return: Number of deleted records
         """
+        self._ensure_filtered()
+
         try:
-            delete_stmt = delete(self.model).filter_by(**filters)
+            delete_stmt = delete(self.model).where(and_(*self.filters))
             result = await self.session.execute(delete_stmt)
             await self.session.commit()
             return result.rowcount()

{rb_commons-0.1.22.dist-info → rb_commons-0.1.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: rb-commons
-Version: 0.1.22
+Version: 0.1.24
 Summary: Commons of project and simplified orm based on sqlalchemy.
 Home-page: https://github.com/RoboSell-organization/rb-commons
 Author: Abdulvoris
@@ -12,7 +12,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: annotated-types==0.7.0
 Requires-Dist: greenlet==3.1.1
-Requires-Dist: pydantic==2.10.4
+Requires-Dist: pydantic<3.0.0,>=1.7.4
 Requires-Dist: PyJWT==2.10.1
 Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: SQLAlchemy==2.0.36

{rb_commons-0.1.22.dist-info → rb_commons-0.1.24.dist-info}/RECORD

@@ -6,14 +6,14 @@ rb_commons/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rb_commons/http/exceptions.py,sha256=EGRMr1cRgiJ9Q2tkfANbf0c6-zzXf1CD6J3cmCaT_FA,1885
 rb_commons/orm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rb_commons/orm/exceptions.py,sha256=1aMctiEwrPjyehoXVX1l6ML5ZOhmDkmBISzlTD5ey1Y,509
-rb_commons/orm/managers.py,sha256=2RJyiW4uUYtgE_BzOS6Z3-TdHgXE0PPcFuQYt4Ze3MQ,7755
+rb_commons/orm/managers.py,sha256=aYwBAkewrw2tEEHKO_kBBnkkKR1lk8UKblr6YOMWr94,9805
 rb_commons/permissions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rb_commons/permissions/role_permissions.py,sha256=3ZTwKclavAKSheO58fybo2uLDeTkd-iluTY7hUEjRPk,957
 rb_commons/schemes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rb_commons/schemes/jwt.py,sha256=F66JJDhholuOPPzlKeoC6f1TL4gXg4oRUrV5yheNpyo,1675
 rb_commons/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rb_commons/utils/media.py,sha256=KNY_9SdRa3Rp7d3B1tZaXkhmzVa65RcS62BYwZP1bVM,332
-rb_commons-0.1.22.dist-info/METADATA,sha256=o7z8drcuIiQpTD8yPic5WTuskkxPZzRMpIzLAAyG7As,6533
-rb_commons-0.1.22.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-rb_commons-0.1.22.dist-info/top_level.txt,sha256=HPx_WAYo3_fbg1WCeGHsz3wPGio1ucbnrlm2lmqlJog,11
-rb_commons-0.1.22.dist-info/RECORD,,
+rb_commons-0.1.24.dist-info/METADATA,sha256=4LV30IZhpybCS8S5KXALPnQ7YqJVyIcjVKlPDkGh-Q8,6539
+rb_commons-0.1.24.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+rb_commons-0.1.24.dist-info/top_level.txt,sha256=HPx_WAYo3_fbg1WCeGHsz3wPGio1ucbnrlm2lmqlJog,11
+rb_commons-0.1.24.dist-info/RECORD,,

{rb_commons-0.1.22.dist-info → rb_commons-0.1.24.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any