rb-commons 0.3.7__py3-none-any.whl → 0.4.0__py3-none-any.whl

rb_commons/orm/managers.py

@@ -64,52 +64,94 @@ class BaseManager(Generic[ModelType]):
 
         return instance
 
+    def _apply_eager_loading(self, stmt, load_all_relations: bool = False):
+        """
+        Apply selectinload for eager loading relationships.
+
+        :param stmt: SQLAlchemy select statement
+        :param load_all_relations: If True, load all relationships
+        :return: Modified statement with eager loading applied
+        """
+        if load_all_relations:
+            mapper = inspect(self.model)
+            load_relations = [rel.key for rel in mapper.relationships()]
+
+            if load_relations:
+                for rel in load_relations:
+                    stmt = stmt.options(selectinload(getattr(self.model, rel)))
+
+        return stmt
+
     def filter(self, **kwargs) -> 'BaseManager[ModelType]':
         """
-           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
-       """
+           Dynamically apply filters to the query.
+
+           Supported operators:
+             - __eq       (e.g., field__eq=value) or just field=value
+             - __ne       (field__ne=value)
+             - __gt       (field__gt=value)
+             - __lt       (field__lt=value)
+             - __gte      (field__gte=value)
+             - __lte      (field__lte=value)
+             - __in       (field__in=[val1, val2, ...])
+             - __contains (field__contains='text')
+
+           Additionally supports nested paths, e.g.,
+             product__shop_id=None
+             product__shop__country='US'
+        """
         self._filtered = True
         self.filters = []
 
+        allowed_operators = {"eq", "ne", "gt", "lt", "gte", "lte", "in", "contains"}
+
         for key, value in kwargs.items():
-            if '__' in key:
-                field_name, operator = key.split('__', 1)
+            parts = key.split("__")
+
+            if parts[-1] in allowed_operators:
+                operator = parts[-1]
+                field_path = parts[:-1]
             else:
-                field_name, operator = key, 'eq'
+                operator = "eq"
+                field_path = parts
+
+            current_attr = self.model
+            for idx, field_name in enumerate(field_path):
+                current_attr = getattr(current_attr, field_name, None)
+                if current_attr is None:
+                    raise ValueError(f"Invalid filter field: {'.'.join(field_path)}")
 
-            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 not isinstance(current_attr, InstrumentedAttribute):
+                raise ValueError(f"Invalid filter field: {'.'.join(field_path)}")
 
             if operator == "eq":
-                self.filters.append(column == value)
+                # e.g., column == value
+                self.filters.append(current_attr == value)
+
             elif operator == "ne":
-                self.filters.append(column != value)
+                # e.g., column != value
+                self.filters.append(current_attr != value)
+
             elif operator == "gt":
-                self.filters.append(column > value)
+                self.filters.append(current_attr > value)
+
             elif operator == "lt":
-                self.filters.append(column < value)
+                self.filters.append(current_attr < value)
+
             elif operator == "gte":
-                self.filters.append(column >= value)
+                self.filters.append(current_attr >= value)
+
             elif operator == "lte":
-                self.filters.append(column <= value)
-            elif operator == "in" and isinstance(value, list):
+                self.filters.append(current_attr <= value)
+
+            elif operator == "in":
                 if not isinstance(value, list):
-                    raise ValueError(f"`{field_name}__in` requires a list, got {type(value)}")
+                    raise ValueError(f"{'.'.join(field_path)}__in requires a list, got {type(value)}")
+                self.filters.append(current_attr.in_(value))
 
-                self.filters.append(column.in_(value))
             elif operator == "contains":
-                self.filters.append(column.ilike(f"%{value}%"))
+                # e.g., column ILIKE %value%
+                self.filters.append(current_attr.ilike(f"%{value}%"))
 
         return self
 
@@ -118,13 +160,11 @@ class BaseManager(Generic[ModelType]):
         if not self._filtered:
             raise RuntimeError("You must call `filter()` before using this method.")
 
-    async def all(self) -> List[ModelType]:
-        """Return all results based on applied filters."""
+    async def all(self, load_all_relations: bool = False) -> List[ModelType]:
         self._ensure_filtered()
 
-        query = select(self.model)
-        if self.filters:
-            query = query.filter(and_(*self.filters))
+        query = select(self.model).filter(and_(*self.filters))
+        query = self._apply_eager_loading(query, load_all_relations)
 
         result = await self.session.execute(query)
         return list(result.scalars().all())

rb_commons/orm/services.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Awaitable
+from abc import ABCMeta
+from typing import Any, Callable, Awaitable, Dict
 
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -6,27 +7,34 @@ from rb_commons.http.exceptions import ForbiddenException
 from rb_commons.schemes.jwt import Claims
 
 
-class BaseService:
+class FeignClientMeta(ABCMeta):
+    def __new__(cls, name, bases, namespace):
+        feign_clients = namespace.get('feign_clients', {})
+
+        for client_name, init_func in feign_clients.items():
+            method_name = f'get_{client_name}'
+
+            async def getter(self, name=client_name, init_func=init_func):
+                attr_name = f'_{name}'
+                if getattr(self, attr_name, None) is None:
+                    client = await init_func()
+                    setattr(self, attr_name, client)
+                return getattr(self, attr_name)
+
+            namespace[method_name] = getter
+
+        return super().__new__(cls, name, bases, namespace)
+
+
+class BaseService(metaclass=FeignClientMeta):
+    feign_clients: Dict[str, Callable[[], Awaitable[Any]]] = {}
+
     def __init__(self, claims: Claims, session: AsyncSession):
         self.claims = claims
         self.session = session
-        self._feign_clients = {}
-
-    def register_feign_client(self, name: str, init_func: Callable[[], Awaitable[Any]]):
-        """
-            Dynamically adds a get_<name>() method that lazy-loads the client.
-        """
-        attr_name = f"_{name}"
-
-        async def getter(self):
-            if getattr(self, attr_name, None) is None:
-                client = await init_func()
-                setattr(self, attr_name, client)
-            return getattr(self, attr_name)
-
-        method_name = f"get_{name}"
-        bound_method = getter.__get__(self, self.__class__)
-        setattr(self, method_name, bound_method)
+
+        for name in self.feign_clients:
+            setattr(self, f'_{name}', None)
 
     def _verify_shop_permission(self, target: Any, raise_exception: bool = True) -> bool:
         if self.claims.shop_id != getattr(target, "shop_id", None):

{rb_commons-0.3.7.dist-info → rb_commons-0.4.0.dist-info}/METADATA

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

{rb_commons-0.3.7.dist-info → rb_commons-0.4.0.dist-info}/RECORD

@@ -11,15 +11,15 @@ rb_commons/http/consul.py,sha256=Ioq72VD1jGwoC96set7n2SgxN40olzI-myA2lwKkYi4,186
 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=iAlsBfcxVt_GUfbJckTiFgTCIDYzWcXqyyat8qC4ThQ,12475
-rb_commons/orm/services.py,sha256=41AcjOmi-GUdm-J38Rk_1OOAO_QTscMpGZ29Q2hmq2M,1325
+rb_commons/orm/managers.py,sha256=IktMS_oq0drkt_MwBZTYPE179YgjkQB1HfaDcvnr5Zw,13928
+rb_commons/orm/services.py,sha256=71eRcJ4TxZvzNz-hLXo12X4U7PGK54ZfbLAb27AjZi8,1589
 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.3.7.dist-info/METADATA,sha256=NQXtdUfCsyrUaa5NjGO94qvvGckzOLf2e_vWmVknjg0,6570
-rb_commons-0.3.7.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-rb_commons-0.3.7.dist-info/top_level.txt,sha256=HPx_WAYo3_fbg1WCeGHsz3wPGio1ucbnrlm2lmqlJog,11
-rb_commons-0.3.7.dist-info/RECORD,,
+rb_commons-0.4.0.dist-info/METADATA,sha256=MrBcay1HyOdGBeKwC8yohoDXLFi0tsjsMdk_S39Lcag,6570
+rb_commons-0.4.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+rb_commons-0.4.0.dist-info/top_level.txt,sha256=HPx_WAYo3_fbg1WCeGHsz3wPGio1ucbnrlm2lmqlJog,11
+rb_commons-0.4.0.dist-info/RECORD,,