matrx-orm 3.1.166__tar.gz → 3.1.167__tar.gz

{matrx_orm-3.1.166 → matrx_orm-3.1.167}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: matrx-orm
-Version: 3.1.166
+Version: 3.1.167
 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.166 → matrx_orm-3.1.167}/matrx_orm/operations/create.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 from typing import Any, TYPE_CHECKING, Union
 
 from matrx_orm.state import StateManager
@@ -20,6 +21,19 @@ if TYPE_CHECKING:
 OnConflictArg = Union[list[str], "ConflictTarget"]
 
 
+def _prepare_instance_data(model_cls: type[Model], instance: Model) -> dict[str, Any]:
+    """Coerce a single insert row without occupying the request event loop."""
+    data: dict[str, Any] = {}
+    for field_name, field in model_cls._fields.items():
+        if isinstance(field, Field):
+            value = getattr(instance, field_name)
+            if value is None and field.default is not None:
+                value = field.get_default()
+            if value is not None:
+                data[field_name] = field.get_db_prep_value(value)
+    return data
+
+
 def _normalise_on_conflict(on_conflict: OnConflictArg) -> tuple[list[str], ConflictTarget | None]:
     """Internal: unify the two acceptable shapes.
 
@@ -85,14 +99,10 @@ async def save(instance: Model, *, statement_timeout: float | None = None) -> Mo
     model_cls = instance.__class__
     await pre_create.send(model_cls, instance=instance)
 
-    data: dict[str, Any] = {}
-    for field_name, field in model_cls._fields.items():
-        if isinstance(field, Field):
-            value = getattr(instance, field_name)
-            if value is None and field.default is not None:
-                value = field.get_default()
-            if value is not None:
-                data[field_name] = field.get_db_prep_value(value)
+    # JSONB conversion can recursively walk a large OCR/PDF payload and take
+    # seconds.  This is a shared write boundary, so every single-row create
+    # gets the same event-loop protection as the existing bulk write paths.
+    data = await asyncio.to_thread(_prepare_instance_data, model_cls, instance)
 
     query = QueryBuilder(model_cls)._build_query()
     query["data"] = data

{matrx_orm-3.1.166 → matrx_orm-3.1.167}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "matrx-orm"
-version = "3.1.166"
+version = "3.1.167"
 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.166 → matrx_orm-3.1.167}/tests/level1/test_query_timeout.py

@@ -10,7 +10,10 @@ dict, and the adapter call (via a fake adapter — no DB).
 
 from __future__ import annotations
 
+import asyncio
 from contextlib import asynccontextmanager
+import threading
+import time
 from typing import Any
 from unittest.mock import AsyncMock
 
@@ -273,3 +276,49 @@ class TestInsertStatementTimeout:
         )
 
         assert seen["statement_timeout"] == 30.0
+
+    @pytest.mark.asyncio
+    async def test_model_create_prepares_a_slow_json_payload_off_the_event_loop(self, monkeypatch):
+        """Single-row JSONB coercion must not freeze unrelated requests."""
+        from matrx_orm.operations import create as create_ops
+
+        entity = _make_entity_model()
+        worker_thread_ids: list[int] = []
+
+        def slow_prepare(model_cls, instance):
+            worker_thread_ids.append(threading.get_ident())
+            time.sleep(0.08)
+            return {"id": instance.id, "kind": instance.kind}
+
+        class _Recorder:
+            def __init__(self, query: dict[str, Any]) -> None:
+                pass
+
+            async def insert(self, query: dict[str, Any]) -> dict[str, Any]:
+                return {"id": query["data"]["id"]}
+
+        monkeypatch.setattr(create_ops, "_prepare_instance_data", slow_prepare)
+        monkeypatch.setattr(create_ops, "QueryExecutor", _Recorder)
+
+        ticks = 0
+        stop = asyncio.Event()
+
+        async def heartbeat() -> None:
+            nonlocal ticks
+            while not stop.is_set():
+                ticks += 1
+                await asyncio.sleep(0.005)
+
+        heartbeat_task = asyncio.create_task(heartbeat())
+        try:
+            await create_ops.create(
+                entity,
+                id="00000000-0000-0000-0000-000000000001",
+                kind="person",
+            )
+        finally:
+            stop.set()
+            await heartbeat_task
+
+        assert worker_thread_ids and worker_thread_ids[0] != threading.get_ident()
+        assert ticks >= 5