matrx-orm 3.1.34__tar.gz → 3.1.35__tar.gz

{matrx_orm-3.1.34 → matrx_orm-3.1.35}/CLAUDE.md

@@ -26,6 +26,7 @@ Every table that becomes a Model needs row identity: a single-column primary key
 - **Upsert writes only what the caller supplied.** `upsert` / `bulk_upsert` / `upsert_with_conflict` materialize every field's Python default so the **INSERT** half is complete — but `ON CONFLICT DO UPDATE SET` covers **only the columns present in the caller's `data`** (an explicit `update_fields` still wins). Letting defaults reach the UPDATE half silently RESET every defaulted column on each re-upsert of an existing row: it once reset scraped-and-analyzed `research.rs_source` rows to `scrape_status='pending', server_attempts=0` (a watchdog then finalized them `'failed'`) and undid users' manual `is_included=false`. A caller-supplied `None` is excluded too — it is dropped from the INSERT, and `EXCLUDED.<col>` on an omitted column resolves to that column's **DEFAULT**. An upsert of only conflict keys means "ensure this row exists" and reconciles to a no-op self-assignment, never a raise (a bare `DO NOTHING` would break `RETURNING *`). Pinned by `tests/level1/test_upsert_default_leak.py`.
 - **Read-only models** (`_read_only = True`): a model that can be queried but NEVER written through the ORM — every write path raises `ReadOnlyModelError` (enforced at `QueryExecutor.insert/bulk_insert/upsert/update/delete`, so it covers all of `create`/`save`/`update`/`delete`/`update_where`/`delete_where`/`upsert`/`bulk_*`). Used for DB-managed tables the app must not mutate. The canonical **`auth.users`** model is baked into the schema generator (`get_string_user_model`) as the full, curated Supabase auth schema (safe columns only — no password/token fields), `_read_only`, bound per-database. Read a user's profile/metadata there; mutate users only through Supabase Auth (GoTrue).
 - **Connection-level type codecs** (`async_db_manager._init_connection_default`): every pooled connection decodes **uuid → `str`**, **vector → `list[float]`**, and **json/jsonb → `dict`/`list`** at the driver boundary — the TYPE decides the decode, never the call path. So `call_function` scalar/rows, raw fetches, and field hydration all agree; a caller must **never `json.loads` a fetched json/jsonb value** (it's already decoded; the 2026-07-13 `build_agent_context` crash was a jsonb RPC fetched pre-codec as a raw string). Encoding: a pre-serialised JSON `str` passes through untouched; a native dict/list is dumped (`_encode_json`). Pinned by `tests/level1/test_connection_codecs.py`.
+- **Connection pools are event-loop-owned.** `AsyncDatabaseManager.get_pool()` recreates a pool when a caller arrives on a different loop. If the former owner loop is already closed, stale-pool termination and cleanup discard that pool without trying to schedule callbacks onto the dead loop; unrelated runtime errors still raise. Pinned by `tests/level1/test_pool_loop_recreation.py`.
 - **Query layer**: `QueryBuilder`, typed predicates/projections (`F`, `Q`,
   `Predicate`, `Projection`), window functions, QueryBuilder-backed CTEs, and
   subqueries. SQL-shaped strings fail closed: plain strings name validated

{matrx_orm-3.1.34 → matrx_orm-3.1.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrx-orm
-Version: 3.1.34
+Version: 3.1.35
 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.34 → matrx_orm-3.1.35}/matrx_orm/core/async_db_manager.py

@@ -39,6 +39,18 @@ from matrx_orm.exceptions import (
 logger = logging.getLogger("matrx_orm.async_db_manager")
 
 
+def _terminate_pool_after_loop_change(pool: Any, config_name: str) -> None:
+    try:
+        pool.terminate()
+    except RuntimeError as exc:
+        if "event loop is closed" not in str(exc).lower():
+            raise
+        logger.warning(
+            "[matrx_orm] Discarded stale pool for '%s' after its owner event loop closed",
+            config_name,
+        )
+
+
 # asyncpg SQLSTATE class 42 "undefined …" — the SQL named something the live DB
 # does not have. All siblings of SyntaxOrAccessError; PostgresSyntaxError is
 # caught separately (it's an ORM-bug shape, not a schema-drift shape). These map
@@ -323,15 +335,15 @@ class AsyncDatabaseManager:
 
                                 def _dispose_old_pool() -> None:
                                     old_task.cancel()
-                                    old_pool.terminate()
+                                    _terminate_pool_after_loop_change(old_pool, config_name)
 
                                 owner_loop.call_soon_threadsafe(_dispose_old_pool)
                             else:
-                                old_pool.terminate()
+                                _terminate_pool_after_loop_change(old_pool, config_name)
                         except RuntimeError:
-                            old_pool.terminate()
+                            _terminate_pool_after_loop_change(old_pool, config_name)
                     else:
-                        old_pool.terminate()
+                        _terminate_pool_after_loop_change(old_pool, config_name)
 
                     # Remove the old pool so we can create a new one
                     del cls._pools[config_name]
@@ -1116,6 +1128,21 @@ class AsyncDatabaseManager:
             for config_name, pool in list(cls._pools.items()):
                 try:
                     await pool.close()
+                except RuntimeError as e:
+                    if "event loop is closed" in str(e).lower():
+                        logger.warning(
+                            "[matrx_orm] Discarded stale pool for '%s' during cleanup "
+                            "after its owner event loop closed",
+                            config_name,
+                        )
+                        continue
+                    raise StateError(
+                        model=None,
+                        operation="cleanup_pools",
+                        reason=f"Failed to close pool for {config_name}",
+                        details={"config_name": config_name},
+                        original_error=e,
+                    ) from e
                 except Exception as e:
                     raise StateError(
                         model=None,

{matrx_orm-3.1.34 → matrx_orm-3.1.35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "matrx-orm"
-version = "3.1.34"
+version = "3.1.35"
 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.34 → matrx_orm-3.1.35}/tests/level1/test_bulk_upsert_increment_set_fields.py

@@ -23,10 +23,10 @@ No DB needed — a stub ``connection``/execute_write captures the rendered SQL
 
 from __future__ import annotations
 
+from datetime import timedelta
 from typing import Any
 
 import pytest
-from matrx_orm import Now
 from matrx_orm.core.base import Model, ModelMeta
 from matrx_orm.core.expressions import Case, Compare, Excluded, F, Interval, Is, Now, When
 from matrx_orm.core.fields import DateTimeField, FloatField, UUIDField
@@ -138,7 +138,7 @@ async def test_window_roll_case_set_fields_shifts_params_past_values() -> None:
     assert f"({table}.cost_used_usd + $" in sql
     assert "updated_at = NOW()" in sql
     assert len(params) == 8
-    assert params[4:6] == ("24 hours", "24 hours")
+    assert params[4:6] == (timedelta(hours=24), timedelta(hours=24))
     assert params[6:] == (2.5, 2.5)
 
 

matrx_orm-3.1.35/tests/level1/test_pool_loop_recreation.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from matrx_orm.core.async_db_manager import (
+    AsyncDatabaseManager,
+    _terminate_pool_after_loop_change,
+)
+
+
+class _ClosedLoopPool:
+    def __init__(self) -> None:
+        self.terminate_calls = 0
+        self.close_calls = 0
+
+    def terminate(self) -> None:
+        self.terminate_calls += 1
+        raise RuntimeError("Event loop is closed")
+
+    async def close(self) -> None:
+        self.close_calls += 1
+        raise RuntimeError("Event loop is closed")
+
+
+def test_stale_pool_termination_tolerates_closed_owner_loop() -> None:
+    pool = _ClosedLoopPool()
+
+    _terminate_pool_after_loop_change(pool, "main")
+
+    assert pool.terminate_calls == 1
+
+
+def test_stale_pool_termination_preserves_other_runtime_errors() -> None:
+    class _BrokenPool:
+        def terminate(self) -> None:
+            raise RuntimeError("unexpected pool corruption")
+
+    with pytest.raises(RuntimeError, match="unexpected pool corruption"):
+        _terminate_pool_after_loop_change(_BrokenPool(), "main")
+
+
+@pytest.mark.asyncio
+async def test_cleanup_discards_pool_owned_by_closed_loop(monkeypatch: Any) -> None:
+    pool = _ClosedLoopPool()
+    monkeypatch.setattr(AsyncDatabaseManager, "_pools", {"main": pool})
+    monkeypatch.setattr(AsyncDatabaseManager, "_pool_loops", {"main": 1})
+    monkeypatch.setattr(AsyncDatabaseManager, "_locks", {"main": object()})
+    monkeypatch.setattr(AsyncDatabaseManager, "_growth_locks", {"main": object()})
+    monkeypatch.setattr(AsyncDatabaseManager, "_keepalive_tasks", {})
+
+    await AsyncDatabaseManager.cleanup()
+
+    assert pool.close_calls == 1
+    assert AsyncDatabaseManager._pools == {}
+    assert AsyncDatabaseManager._pool_loops == {}