rb-commons 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

rb_commons/configs/config.py

@@ -20,6 +20,10 @@ class CommonConfigs(BaseSettings):
     POSTGRES_DB: Optional[str] = None
     DB_ALEMBIC_URL: Optional[str] = None
 
+    DIGITALOCEAN_STORAGE_BUCKET_NAME: Optional[str] = None
+    DIGITALOCEAN_S3_ENDPOINT_URL: Optional[str] = None
+
+
     @property
     def database_url(self) -> Optional[str]:
         """Construct the database URL if all required fields are present."""

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/utils/media.py

@@ -0,0 +1,9 @@
+from rb_commons.configs.config import configs
+
+class MediaUtils:
+
+    @staticmethod
+    def url_builder(key: str):
+        return "{endpoint_url}/{bucket_name}/{key}" \
+            .format(endpoint_url=configs.DIGITALOCEAN_S3_ENDPOINT_URL,
+                    bucket_name=configs.DIGITALOCEAN_STORAGE_BUCKET_NAME, key=key)

{rb_commons-0.1.21.dist-info → rb_commons-0.1.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rb-commons
-Version: 0.1.21
+Version: 0.1.23
 Summary: Commons of project and simplified orm based on sqlalchemy.
 Home-page: https://github.com/RoboSell-organization/rb-commons
 Author: Abdulvoris

{rb_commons-0.1.21.dist-info → rb_commons-0.1.23.dist-info}/RECORD

@@ -1,17 +1,19 @@
 rb_commons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rb_commons/configs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rb_commons/configs/config.py,sha256=tpqC1V9PXx88m0N5L13WqkoalPUk6SthjxgL_lmf-lE,1439
+rb_commons/configs/config.py,sha256=dlsf1GDT81B_gOJkMHnnU5uHiCHiTIlvXNIdTu52E5k,1559
 rb_commons/configs/injections.py,sha256=6B1EOgIGnkWv3UrFaV9PRgG0-CJAbLu1UZ3kq-SjPVU,273
 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-0.1.21.dist-info/METADATA,sha256=llsCrcIKFe3bm6GSCf5_Ooe0JHhvg1l1ExupHjP0PSc,6533
-rb_commons-0.1.21.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-rb_commons-0.1.21.dist-info/top_level.txt,sha256=HPx_WAYo3_fbg1WCeGHsz3wPGio1ucbnrlm2lmqlJog,11
-rb_commons-0.1.21.dist-info/RECORD,,
+rb_commons/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rb_commons/utils/media.py,sha256=KNY_9SdRa3Rp7d3B1tZaXkhmzVa65RcS62BYwZP1bVM,332
+rb_commons-0.1.23.dist-info/METADATA,sha256=CXoN6dhyHB73CL8dVDWQP68ry2SJaTa4VmmernuYV1I,6533
+rb_commons-0.1.23.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+rb_commons-0.1.23.dist-info/top_level.txt,sha256=HPx_WAYo3_fbg1WCeGHsz3wPGio1ucbnrlm2lmqlJog,11
+rb_commons-0.1.23.dist-info/RECORD,,

{rb_commons-0.1.21.dist-info → rb_commons-0.1.23.dist-info}/WHEEL

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