matrx-orm 3.1.1__tar.gz → 3.1.3__tar.gz

{matrx_orm-3.1.1 → matrx_orm-3.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrx-orm
-Version: 3.1.1
+Version: 3.1.3
 Summary: Async-first PostgreSQL ORM with bidirectional migrations, schema introspection, many-to-many relationships, and built-in state caching
 Project-URL: Homepage, https://github.com/AI-Matrix-Engine/aidream-current
 Project-URL: Repository, https://github.com/AI-Matrix-Engine/aidream-current

{matrx_orm-3.1.1 → matrx_orm-3.1.3}/matrx_orm/query/executor.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import json
 import re
+from types import NotImplementedType
 from typing import TYPE_CHECKING, Any
 
 from matrx_utils import vcprint
@@ -27,6 +28,55 @@ _SKIP_PARAM = object()
 
 _PARAM_RE = re.compile(r"\$(\d+)")
 
+_TOP_LEVEL_WHERE_STOPPERS = (
+    "ORDER BY",
+    "GROUP BY",
+    "HAVING",
+    "LIMIT",
+    "OFFSET",
+    "FOR UPDATE",
+)
+
+
+def _strip_top_level_trailing_clauses(sql_fragment: str) -> str:
+    """Drop outer-query ORDER BY / LIMIT / … suffixes from a WHERE tail.
+
+    ``_extract_where_clause`` peels the WHERE tail off a built SELECT. The tail
+    must not include the SELECT's own trailing clauses — but it MUST keep any
+    LIMIT/ORDER BY that lives *inside* a subquery (``id IN (SELECT … LIMIT n)``).
+    Naïve ``.split("LIMIT")`` truncates at the inner LIMIT and breaks bounded
+    batch updates (admin_persistence dismiss/resolve).
+    """
+    if not sql_fragment:
+        return sql_fragment
+    depth = 0
+    cut_at: int | None = None
+    i = 0
+    n = len(sql_fragment)
+    while i < n:
+        ch = sql_fragment[i]
+        if ch == "(":
+            depth += 1
+            i += 1
+            continue
+        if ch == ")":
+            depth = max(0, depth - 1)
+            i += 1
+            continue
+        if depth == 0:
+            for stopper in _TOP_LEVEL_WHERE_STOPPERS:
+                slen = len(stopper)
+                if sql_fragment[i : i + slen] == stopper:
+                    before = sql_fragment[i - 1] if i > 0 else " "
+                    if before.isalnum() or before == "_":
+                        break
+                    cut_at = i if cut_at is None else min(cut_at, i)
+                    break
+        i += 1
+    if cut_at is not None:
+        return sql_fragment[:cut_at].strip()
+    return sql_fragment.strip()
+
 
 def _escape_like(value: Any) -> str:
     """Escape LIKE/ILIKE metacharacters so user input matches LITERALLY.
@@ -820,11 +870,7 @@ class QueryExecutor:
         where_clause = ""
         if "WHERE" in base_query:
             after_where = base_query.split("WHERE", 1)[1].strip()
-            # Strip trailing clauses
-            for stopper in ("ORDER BY", "GROUP BY", "HAVING", "LIMIT", "OFFSET", "FOR UPDATE"):
-                if stopper in after_where:
-                    after_where = after_where.split(stopper)[0].strip()
-            where_clause = after_where
+            where_clause = _strip_top_level_trailing_clauses(after_where)
         return where_clause, where_params
 
     async def _execute(self) -> list[dict[str, Any]]:
@@ -904,15 +950,14 @@ class QueryExecutor:
 
     async def _try_write_dict(
         self, query: dict[str, Any]
-    ) -> list[dict[str, Any]] | type[NotImplemented]:
+    ) -> list[dict[str, Any]] | NotImplementedType:
         """Call execute_write_dict on the adapter.
 
         Returns ``NotImplemented`` if the adapter does not override the hook
         (default ``BaseAdapter`` behaviour) so callers can fall through to the
         SQL path.
         """
-        result = await self.db.execute_write_dict(query)
-        return result  # type: ignore[return-value]
+        return await self.db.execute_write_dict(query)
 
     async def insert(self, query: dict[str, Any]) -> dict[str, Any]:
         """INSERT a single row, RETURNING *."""

{matrx_orm-3.1.1 → matrx_orm-3.1.3}/matrx_orm/session/dag.py

@@ -46,6 +46,9 @@ from matrx_orm.session.op import SessionOp
 
 logger = logging.getLogger("matrx_orm.session.dag")
 
+# (model, field) pairs already reported as unresolvable — see _resolve_fk_deps.
+_WARNED_UNRESOLVED_FKS: set[tuple[str, str]] = set()
+
 
 class DependencyCycleError(RuntimeError):
     """Raised when the Session ops describe a cyclic write dependency."""
@@ -144,14 +147,22 @@ def _resolve_fk_deps(
         try:
             related_model = fk_ref.related_model
         except ValueError as exc:
-            logger.warning(
-                "[matrx_orm.session] FK '%s.%s' did not resolve (%s) — no in-flush "
-                "dependency inferred for it. The write proceeds; fix the reference "
-                "(regenerate models) so the boot audit stays clean.",
-                getattr(op.model_cls, "__name__", "?"),
-                fk_field_name,
-                exc,
-            )
+            # Warn ONCE per (model, field). `related_model` is a cached_property and
+            # exceptions are not cached, so it re-raises on every op of every flush —
+            # an unresolvable FK on a hot table would otherwise flood app_log forever
+            # and bury the signal it exists to raise.
+            key = (getattr(op.model_cls, "__name__", "?"), fk_field_name)
+            if key not in _WARNED_UNRESOLVED_FKS:
+                _WARNED_UNRESOLVED_FKS.add(key)
+                logger.warning(
+                    "[matrx_orm.session] FK '%s.%s' did not resolve (%s) — no in-flush "
+                    "dependency inferred for it. The write proceeds; fix the reference "
+                    "(regenerate models) so the boot audit stays clean. This warns once "
+                    "per process.",
+                    key[0],
+                    key[1],
+                    exc,
+                )
             continue
         if related_model is None:
             continue

{matrx_orm-3.1.1 → matrx_orm-3.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "matrx-orm"
-version = "3.1.1"
+version = "3.1.3"
 description = "Async-first PostgreSQL ORM with bidirectional migrations, schema introspection, many-to-many relationships, and built-in state caching"
 readme = "README.md"
 license = { text = "MIT" }

{matrx_orm-3.1.1 → matrx_orm-3.1.3}/tests/level1/test_subquery_in_filter.py

@@ -51,10 +51,7 @@ class TestSubqueryInFilter:
     def test_renders_in_not_equals(self):
         Model_ = _make_model()
         inner = (
-            Model_.filter(recovered_at__isnull=True)
-            .order_by("-failed_at")
-            .limit(50)
-            .select("id")
+            Model_.filter(recovered_at__isnull=True).order_by("-failed_at").limit(50).select("id")
         )
 
         qb = Model_.filter(id__in=Subquery(inner))
@@ -98,3 +95,18 @@ class TestSubqueryInFilter:
         assert "recovered_at IS NULL" in cond
         assert "table_target = $" in cond
         assert "cx_message" in params
+
+    def test_extract_where_clause_preserves_inner_limit(self):
+        """Bounded batch dismiss/resolve: update_where(id__in=Subquery(...))
+        must not truncate the inner SELECT at its LIMIT."""
+        Model_ = _make_model()
+        inner = (
+            Model_.filter(recovered_at__isnull=True).order_by("-failed_at").limit(50).select("id")
+        )
+        qb = Model_.filter(id__in=Subquery(inner))
+        executor = qb._get_executor()
+        where_clause, where_params = executor._extract_where_clause()
+        assert where_clause.endswith(")")
+        assert "LIMIT $" in where_clause
+        assert "ORDER BY failed_at DESC" in where_clause
+        assert where_params == [50]

{matrx_orm-3.1.1 → matrx_orm-3.1.3}/tests/schema/test_composite_pk_fk_generation.py

@@ -1,7 +1,7 @@
 # Pins the generator behavior for composite primary keys whose columns are ALSO
 # foreign keys (live shape: platform.association_types — PK (source_type,
 # target_type), both FKs to platform.entity_types(token)). Regression context:
-# KNOWN_DEFECTS 2026-07-06 — a regenerate emitted AssociationTypes with no
+# FOUND_DEFECTS 2026-07-06 — a regenerate emitted AssociationTypes with no
 # primary_key=True and every db.models import crashed at boot. Root cause was a
 # PK-less live table; these tests pin BOTH layers: (1) FK+PK columns must emit
 # primary_key=True, (2) a PK-less table must fail generation loudly instead of

{matrx_orm-3.1.1 → matrx_orm-3.1.3}/tests/session/test_dag.py

@@ -103,6 +103,9 @@ class _UnresolvableFK:
     ],
 )
 def test_unresolvable_fk_reference_does_not_kill_the_write(FakeMessage, message):
+    from matrx_orm.session.dag import _WARNED_UNRESOLVED_FKS
+
+    _WARNED_UNRESOLVED_FKS.clear()
     """A NAME that won't resolve must never fail a WRITE.
 
     An unresolvable target cannot be a parent row in THIS flush, so it carries