rb-commons 0.7.4__py3-none-any.whl → 0.7.6__py3-none-any.whl

rb_commons/orm/managers.py

@@ -2,68 +2,18 @@ from __future__ import annotations
 
 import re
 import uuid
-from typing import TypeVar, Type, Generic, Optional, List, Dict, Literal, Union, Sequence, Any, Iterable
+from typing import TypeVar, Type, Generic, Optional, List, Dict, Literal, Union, Sequence, Any, Iterable, Callable
 from sqlalchemy import select, delete, update, and_, func, desc, inspect, or_, asc, true
 from sqlalchemy.exc import IntegrityError, SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import declarative_base, selectinload, RelationshipProperty, Load
 from rb_commons.http.exceptions import NotFoundException
 from rb_commons.orm.exceptions import DatabaseException, InternalException
-from functools import lru_cache
-
+from functools import lru_cache, wraps
+from rb_commons.orm.querysets import Q, QJSON
 
 ModelType = TypeVar('ModelType', bound=declarative_base())
 
-class QJSON:
-    def __init__(self, field: str, key: str, operator: str, value: Any):
-        self.field = field
-        self.key = key
-        self.operator = operator
-        self.value = value
-
-    def __repr__(self):
-        return f"QJSON(field={self.field}, key={self.key}, op={self.operator}, value={self.value})"
-
-class Q:
-    """Boolean logic container that can be combined with `&`, `|`, and `~`."""
-
-    def __init__(self, **lookups: Any) -> None:
-        self.lookups: Dict[str, Any] = lookups
-        self.children: List[Q] = []
-        self._operator: str = "AND"
-        self.negated: bool = False
-
-    def _combine(self, other: "Q", operator: str) -> "Q":
-        combined = Q()
-        combined.children = [self, other]
-        combined._operator = operator
-        return combined
-
-    def __or__(self, other: "Q") -> "Q":
-        return self._combine(other, "OR")
-
-    def __and__(self, other: "Q") -> "Q":
-        return self._combine(other, "AND")
-
-    def __invert__(self) -> "Q":
-        clone = Q()
-        clone.lookups = self.lookups.copy()
-        clone.children = list(self.children)
-        clone._operator = self._operator
-        clone.negated = not self.negated
-        return clone
-
-    def __repr__(self) -> str:
-        if self.lookups:
-            base = f"Q({self.lookups})"
-        else:
-            base = "Q()"
-        if self.children:
-            base += f" {self._operator} {self.children}"
-        if self.negated:
-            base = f"NOT({base})"
-        return base
-
 def with_transaction_error_handling(func):
     async def wrapper(self, *args, **kwargs):
         try:
@@ -79,6 +29,20 @@ def with_transaction_error_handling(func):
             raise InternalException(f"Unexpected error: {str(e)}") from e
     return wrapper
 
+F = TypeVar("F", bound=Callable[..., Any])
+
+def query_mutator(func: F) -> F:
+    """
+    Make a query‑builder method clone‑on‑write without touching its body.
+    """
+    @wraps(func)
+    def wrapper(self: "BaseManager[Any]", *args, **kwargs):
+        clone = self._clone()
+        result = func(clone, *args, **kwargs)
+        return result if result is not None else clone
+    return wrapper
+
+
 class BaseManager(Generic[ModelType]):
     model: Type[ModelType]
 
@@ -93,6 +57,18 @@ class BaseManager(Generic[ModelType]):
         mapper = inspect(self.model)
         self._column_keys = [c.key for c in mapper.mapper.column_attrs]
 
+    def _clone(self) -> "BaseManager[ModelType]":
+        """
+        Shallow‑copy all mutable query state into a new manager instance.
+        """
+        clone = self.__class__(self.session)
+        clone.filters = list(self.filters)
+        clone._order_by = list(self._order_by)
+        clone._limit = self._limit
+        clone._joins = set(self._joins)
+        clone._filtered = self._filtered
+        return clone
+
     async def _smart_commit(self, instance: Optional[ModelType] = None) -> Optional[ModelType]:
         if not self.session.in_transaction():
             await self.session.commit()
@@ -200,6 +176,66 @@ class BaseManager(Generic[ModelType]):
             return json_expr.in_(qjson.value)
         raise ValueError(f"Unsupported QJSON operator: {qjson.operator}")
 
+    def _build_relation_loaders(
+            self,
+            model: Any,
+            relations: Sequence[str] | None = None
+    ) -> List[Load]:
+        """
+        Given e.g. ["media", "properties.property", "properties__property"],
+        returns [
+            selectinload(Product.media),
+            selectinload(Product.properties).selectinload(Property.property)
+        ].
+
+        If `relations` is None or empty, recurse *all* relationships once (cycle-safe).
+        """
+        loaders: List[Load] = []
+
+        if relations:
+            for path in relations:
+                parts = re.split(r"\.|\_\_", path)
+                current_model = model
+                loader: Load | None = None
+
+                for part in parts:
+                    attr = getattr(current_model, part, None)
+                    if attr is None or not hasattr(attr, "property"):
+                        raise ValueError(f"Invalid relationship path: {path!r}")
+                    loader = selectinload(attr) if loader is None else loader.selectinload(attr)
+                    current_model = attr.property.mapper.class_
+
+                loaders.append(loader)
+
+            return loaders
+
+        visited = set()
+
+        def recurse(curr_model: Any, curr_loader: Load | None = None):
+            mapper = inspect(curr_model)
+            if mapper in visited:
+                return
+            visited.add(mapper)
+
+            for rel in mapper.relationships:
+                attr = getattr(curr_model, rel.key)
+                loader = (
+                    selectinload(attr)
+                    if curr_loader is None
+                    else curr_loader.selectinload(attr)
+                )
+                loaders.append(loader)
+                recurse(rel.mapper.class_, loader)
+
+        recurse(model)
+        return loaders
+
+    async def _execute_query(self, stmt):
+        result = await self.session.execute(stmt)
+        rows = result.scalars().all()
+        return list({obj.id: obj for obj in rows}.values())
+
+    @query_mutator
     def order_by(self, *columns: Any):
         """Collect ORDER BY clauses.
         """
@@ -216,6 +252,7 @@ class BaseManager(Generic[ModelType]):
 
         return self
 
+    @query_mutator
     def filter(self, *expressions: Any, **lookups: Any) -> "BaseManager":
         self._filtered = True
 
@@ -236,6 +273,7 @@ class BaseManager(Generic[ModelType]):
 
         return self
 
+    @query_mutator
     def or_filter(self, *expressions: Any, **lookups: Any) -> "BaseManager[ModelType]":
         """Add one OR group (shortcut for `filter(Q() | Q())`)."""
 
@@ -254,6 +292,7 @@ class BaseManager(Generic[ModelType]):
             self.filters.append(or_(*or_clauses))
         return self
 
+    @query_mutator
     def exclude(self, *expressions: Any, **lookups: Any) -> "BaseManager[ModelType]":
         """
         Exclude records that match the given conditions.
@@ -297,75 +336,11 @@ class BaseManager(Generic[ModelType]):
 
         return self
 
+    @query_mutator
     def limit(self, value: int) -> "BaseManager[ModelType]":
         self._limit = value
         return self
 
-    def _build_relation_loaders(
-            self,
-            model: Any,
-            relations: Sequence[str] | None = None
-    ) -> List[Load]:
-        """
-        Given e.g. ["media", "properties.property", "properties__property"],
-        returns [
-            selectinload(Product.media),
-            selectinload(Product.properties).selectinload(Property.property)
-        ].
-
-        If `relations` is None or empty, recurse *all* relationships once (cycle-safe).
-        """
-        loaders: List[Load] = []
-
-        if relations:
-            for path in relations:
-                parts = re.split(r"\.|\_\_", path)
-                current_model = model
-                loader: Load | None = None
-
-                for part in parts:
-                    attr = getattr(current_model, part, None)
-                    if attr is None or not hasattr(attr, "property"):
-                        raise ValueError(f"Invalid relationship path: {path!r}")
-                    loader = selectinload(attr) if loader is None else loader.selectinload(attr)
-                    current_model = attr.property.mapper.class_
-
-                loaders.append(loader)
-
-            return loaders
-
-        visited = set()
-
-        def recurse(curr_model: Any, curr_loader: Load | None = None):
-            mapper = inspect(curr_model)
-            if mapper in visited:
-                return
-            visited.add(mapper)
-
-            for rel in mapper.relationships:
-                attr = getattr(curr_model, rel.key)
-                loader = (
-                    selectinload(attr)
-                    if curr_loader is None
-                    else curr_loader.selectinload(attr)
-                )
-                loaders.append(loader)
-                recurse(rel.mapper.class_, loader)
-
-        recurse(model)
-        return loaders
-
-    async def _execute_query(self, stmt):
-        result = await self.session.execute(stmt)
-        rows = result.scalars().all()
-        return list({obj.id: obj for obj in rows}.values())
-
-    def _reset_state(self):
-        self.filters.clear()
-        self._filtered = False
-        self._limit = None
-        self._joins.clear()
-
     async def all(self, relations: Optional[List[str]] = None):
         stmt = select(self.model)
 
@@ -380,10 +355,7 @@ class BaseManager(Generic[ModelType]):
         if self._limit:
             stmt = stmt.limit(self._limit)
 
-        try:
-            return await self._execute_query(stmt)
-        finally:
-            self._reset_state()
+        return await self._execute_query(stmt)
 
     async def first(self, relations: Optional[Sequence[str]] = None):
         self._ensure_filtered()
@@ -397,22 +369,19 @@ class BaseManager(Generic[ModelType]):
             stmt = stmt.options(*opts)
 
         result = await self.session.execute(stmt)
-        self._reset_state()
         return result.scalars().first()
 
-
     async def last(self, relations: Optional[Sequence[str]] = None):
         self._ensure_filtered()
         stmt = select(self.model).filter(and_(*self.filters))
         order = self._order_by or [self.model.id.desc()]
-        stmt = stmt.order_by(*order[::-1])  # reverse for last
+        stmt = stmt.order_by(*order[::-1])
 
         if relations:
             opts = self._build_relation_loaders(self.model, relations)
             stmt = stmt.options(*opts)
 
         result = await self.session.execute(stmt)
-        self._reset_state()
         return result.scalars().first()
 
     async def count(self) -> int | None:
@@ -423,7 +392,6 @@ class BaseManager(Generic[ModelType]):
             stmt = stmt.where(and_(*self.filters))
 
         result = await self.session.execute(stmt)
-        self._reset_state()
         return int(result.scalar_one())
 
     async def paginate(self, limit: int = 10, offset: int = 0, relations: Optional[Sequence[str]] = None):
@@ -437,10 +405,7 @@ class BaseManager(Generic[ModelType]):
         if self._order_by:
             stmt = stmt.order_by(*self._order_by)
         stmt = stmt.limit(limit).offset(offset)
-        try:
-            return await self._execute_query(stmt)
-        finally:
-            self._reset_state()
+        return await self._execute_query(stmt)
 
     @with_transaction_error_handling
     async def create(self, **kwargs):
@@ -505,7 +470,6 @@ class BaseManager(Generic[ModelType]):
         stmt = delete(self.model).where(and_(*self.filters))
         await self.session.execute(stmt)
         await self.session.commit()
-        self._reset_state()
         return True
 
     @with_transaction_error_handling
@@ -523,7 +487,6 @@ class BaseManager(Generic[ModelType]):
         stmt = delete(self.model).where(and_(*self.filters))
         result = await self.session.execute(stmt)
         await self._smart_commit()
-        self._reset_state()
         return result.rowcount
 
     async def get(self, pk: Union[str, int, uuid.UUID], relations: Optional[Sequence[str]] = None) -> Any:
@@ -547,9 +510,9 @@ class BaseManager(Generic[ModelType]):
             .limit(1)
         )
         result = await self.session.execute(stmt)
-        self._reset_state()
         return result.scalars().first() is not None
 
+    @query_mutator
     def has_relation(self, relation_name: str):
         relationship = getattr(self.model, relation_name)
         subquery = (
@@ -562,6 +525,7 @@ class BaseManager(Generic[ModelType]):
         self._filtered = True
         return self
 
+    @query_mutator
     def sort_by(self, tokens: Sequence[str]) -> "BaseManager[ModelType]":
         """
         Dynamically apply ORDER BY clauses based on a list of "field" or "-field" tokens.

rb_commons/orm/querysets.py

@@ -0,0 +1,56 @@
+from typing import Any
+
+from functools import wraps
+from typing import Callable, TypeVar, Any
+
+class QJSON:
+    def __init__(self, field: str, key: str, operator: str, value: Any):
+        self.field = field
+        self.key = key
+        self.operator = operator
+        self.value = value
+
+    def __repr__(self):
+        return f"QJSON(field={self.field}, key={self.key}, op={self.operator}, value={self.value})"
+
+class Q:
+    """Boolean logic container that can be combined with `&`, `|`, and `~`."""
+
+    def __init__(self, **lookups: Any) -> None:
+        self.lookups: Dict[str, Any] = lookups
+        self.children: List[Q] = []
+        self._operator: str = "AND"
+        self.negated: bool = False
+
+    def _combine(self, other: "Q", operator: str) -> "Q":
+        combined = Q()
+        combined.children = [self, other]
+        combined._operator = operator
+        return combined
+
+    def __or__(self, other: "Q") -> "Q":
+        return self._combine(other, "OR")
+
+    def __and__(self, other: "Q") -> "Q":
+        return self._combine(other, "AND")
+
+    def __invert__(self) -> "Q":
+        clone = Q()
+        clone.lookups = self.lookups.copy()
+        clone.children = list(self.children)
+        clone._operator = self._operator
+        clone.negated = not self.negated
+        return clone
+
+    def __repr__(self) -> str:
+        if self.lookups:
+            base = f"Q({self.lookups})"
+        else:
+            base = "Q()"
+        if self.children:
+            base += f" {self._operator} {self.children}"
+        if self.negated:
+            base = f"NOT({base})"
+        return base
+
+

{rb_commons-0.7.4.dist-info → rb_commons-0.7.6.dist-info}/METADATA

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

{rb_commons-0.7.4.dist-info → rb_commons-0.7.6.dist-info}/RECORD

@@ -13,7 +13,8 @@ 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=HXFOSeWH34QmvGMLnAS00HKBYKckpk5aSMdxU6TugPI,21314
+rb_commons/orm/managers.py,sha256=BrpMvOkRoAPKtUV1SfakXMYd73-RhqIaoj1Wmru1gAs,20319
+rb_commons/orm/querysets.py,sha256=Q4iY_TKZItpNnrbCAvlSwyCxJikhaX5qVF3Y2rVgAYQ,1666
 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=4dV89z6ggzLqCCiFYlMp7kQVJRESu6MHpkT5ZNjLo6A,1096
@@ -22,7 +23,7 @@ rb_commons/schemes/jwt.py,sha256=ZKLJ5D3fcEmEKySjzbxEgUcza4K-oPoHr14_Z0r9Yic,249
 rb_commons/schemes/pagination.py,sha256=8VZW1wZGJIPR9jEBUgppZUoB4uqP8ORudHkMwvEJSxg,1866
 rb_commons/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rb_commons/utils/media.py,sha256=J2Zi0J28DhcVQVzt-myNNVuzj9Msaetul53VjZtdDdc,820
-rb_commons-0.7.4.dist-info/METADATA,sha256=svR3AJDwNqIOlhSRWTzc-UeFaAmkbskkYFudWvpcuww,6570
-rb_commons-0.7.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rb_commons-0.7.4.dist-info/top_level.txt,sha256=HPx_WAYo3_fbg1WCeGHsz3wPGio1ucbnrlm2lmqlJog,11
-rb_commons-0.7.4.dist-info/RECORD,,
+rb_commons-0.7.6.dist-info/METADATA,sha256=w9fHfL7CavqLJeDqwzhW0hYF3PKfOO5F8byUhgrASUA,6570
+rb_commons-0.7.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rb_commons-0.7.6.dist-info/top_level.txt,sha256=HPx_WAYo3_fbg1WCeGHsz3wPGio1ucbnrlm2lmqlJog,11
+rb_commons-0.7.6.dist-info/RECORD,,