rb-commons 0.7.14__tar.gz → 0.7.16__tar.gz

{rb_commons-0.7.14 → rb_commons-0.7.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rb-commons
-Version: 0.7.14
+Version: 0.7.16
 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.14 → rb_commons-0.7.16}/rb_commons/orm/managers.py

@@ -43,6 +43,16 @@ def query_mutator(func: F) -> F:
     return wrapper
 
 
+AGG_MAP: dict[str, Callable[[Any], Any]] = {
+    "sum": func.sum,
+    "avg": func.avg,
+    "mean": func.avg,
+    "min": func.min,
+    "max": func.max,
+    "count": func.count,
+    "first": lambda c: c,
+}
+
 class BaseManager(Generic[ModelType]):
     model: Type[ModelType]
 
@@ -126,6 +136,34 @@ class BaseManager(Generic[ModelType]):
 
     def _parse_lookup(self, lookup: str, value: Any):
         parts, operator, rel_attr, col_attr = self._parse_lookup_meta(lookup)
+
+        if rel_attr is not None and col_attr is None:
+            uselist = rel_attr.property.uselist
+            primaryjoin = rel_attr.property.primaryjoin
+
+            if uselist:
+                target_cls = rel_attr.property.mapper.class_
+                cnt = (
+                    select(func.count("*"))
+                    .select_from(target_cls)
+                    .where(primaryjoin)
+                    .correlate(self.model)
+                    .scalar_subquery()
+                )
+                return self._build_comparison(cnt, operator, value)
+            else:
+                exists_expr = (
+                    select(1)
+                    .where(primaryjoin)
+                    .correlate(self.model)
+                    .exists()
+                )
+                if operator in {"eq", "lte"} and str(value) in {"0", "False", "false"}:
+                    return ~exists_expr
+                if operator in {"gt", "gte", "eq"} and str(value) in {"1", "True", "true"}:
+                    return exists_expr
+                return self._build_comparison(exists_expr, operator, bool(value))
+
         expr = self._build_comparison(col_attr, operator, value)
 
         if rel_attr:
@@ -525,27 +563,116 @@ class BaseManager(Generic[ModelType]):
         self._filtered = True
         return self
 
-    @query_mutator
-    def sort_by(self, tokens: Sequence[str]) -> "BaseManager[ModelType]":
+    def _infer_default_agg(self, column) -> str:
+        try:
+            from sqlalchemy import Integer, BigInteger, SmallInteger, Float, Numeric
+            if hasattr(column, "type") and isinstance(column.type, (Integer, BigInteger, SmallInteger, Float, Numeric)):
+                return "sum"
+        except Exception:
+            pass
+        return "max"
+    def _order_expr_for_path(self, token: str):
         """
-        Dynamically apply ORDER BY clauses based on a list of "field" or "-field" tokens.
-        Unknown fields are collected for Python-side sorting later.
+        token grammar:
+          [-]<path>[:<agg>][!first|!last]
+            <path> := "field" | "relation__field" (one hop)
+            <agg>  := sum|avg|min|max|count|first  (required for uselist=True; optional otherwise)
+        Examples:
+          "category__title"
+          "-reviews__rating:avg!last"
+          "stocks__sold:sum"
         """
-        self._invalid_sort_tokens = []
-        self._order_by = []
-        model = self.model
 
-        for tok in tokens:
-            if not tok:
-                continue
-            direction = desc if tok.startswith("-") else asc
-            name = tok.lstrip("-")
-            col = getattr(model, name, None)
+        # strip leading '-' (handled by caller), and parse nulls placement
+        core = token.lstrip("-")
+        nulls_placement = None
+        if core.endswith("!first"):
+            core, nulls_placement = core[:-6], "first"
+        elif core.endswith("!last"):
+            core, nulls_placement = core[:-5], "last"
+
+        # split aggregate suffix if present
+        if ":" in core:
+            path, agg_name = core.split(":", 1)
+            agg_name = agg_name.lower().strip()
+        else:
+            path, agg_name = core, None
+
+        # base column on the model (no relation hop)
+        if "__" not in path and "." not in path:
+            col = getattr(self.model, path, None)
             if col is None:
-                self._invalid_sort_tokens.append(tok)
-                continue
-            self._order_by.append(direction(col))
+                raise ValueError(f"Invalid order_by field '{path}' for {self.model.__name__}")
+            expr = col
+            if nulls_placement == "first":
+                expr = expr.nullsfirst()
+            elif nulls_placement == "last":
+                expr = expr.nullslast()
+            return expr
+
+        # relation hop (exactly one)
+        parts = re.split(r"\.|\_\_", path)
+        if len(parts) != 2:
+            raise ValueError(f"Only one relation hop supported in order_by: {path!r}")
+
+        rel_name, col_name = parts
+        rel_attr = getattr(self.model, rel_name, None)
+        if rel_attr is None or not hasattr(rel_attr, "property"):
+            raise ValueError(f"Invalid relationship '{rel_name}' on {self.model.__name__}")
+
+        target_mapper = rel_attr.property.mapper
+        target_cls = target_mapper.class_
+        target_col = getattr(target_cls, col_name, None)
+        if target_col is None:
+            raise ValueError(f"Invalid column '{col_name}' on related model {target_cls.__name__}")
+
+        primaryjoin = rel_attr.property.primaryjoin
+        uselist = rel_attr.property.uselist
+
+        # One-to-many (or many-to-many via association): require aggregate (or infer)
+        if uselist:
+            agg_name = agg_name or self._infer_default_agg(target_col)
+            agg_fn = AGG_MAP.get(agg_name)
+            if agg_fn is None:
+                raise ValueError(f"Unsupported aggregate '{agg_name}' in order_by for {path!r}")
+
+            # SELECT agg(related.col) WHERE primaryjoin  (correlated)
+            subq = (
+                select(agg_fn(target_col))
+                .where(primaryjoin)
+                .correlate(self.model)  # tie to outer row
+                .scalar_subquery()
+            )
+            expr = subq
+
+        else:
+            if agg_name and agg_name != "first":
+                agg_fn = AGG_MAP.get(agg_name)
+                if agg_fn is None:
+                    raise ValueError(f"Unsupported aggregate '{agg_name}' in order_by for {path!r}")
+                select_expr = agg_fn(target_col)
+            else:
+                select_expr = target_col
+
+            sub = select(select_expr).where(primaryjoin).correlate(self.model)
+            if agg_name == "first":
+                sub = sub.limit(1)
+            expr = sub.scalar_subquery()
+
+        if nulls_placement == "first":
+            expr = expr.nullsfirst()
+        elif nulls_placement == "last":
+            expr = expr.nullslast()
 
+        return expr
+
+    @query_mutator
+    def sort_by(self, tokens):
+        self._order_by = []
+        for tok in tokens or []:
+            direction = desc if tok.startswith("-") else asc
+            name = tok.lstrip("-")
+            self._order_by.append(direction(self._order_expr_for_path(name)))
         return self
 
     def model_to_dict(self, instance: ModelType, exclude: set[str] = None) -> dict:

{rb_commons-0.7.14 → rb_commons-0.7.16}/rb_commons.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rb-commons
-Version: 0.7.14
+Version: 0.7.16
 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.14 → rb_commons-0.7.16}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="rb-commons",
-    version="0.7.14",
+    version="0.7.16",
     author="Abdulvoris",
     author_email="erkinovabdulvoris101@gmail.com",
     description="Commons of project and simplified orm based on sqlalchemy.",