matrx-orm 3.1.7__tar.gz → 3.1.8__tar.gz

{matrx_orm-3.1.7 → matrx_orm-3.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrx-orm
-Version: 3.1.7
+Version: 3.1.8
 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.7 → matrx_orm-3.1.8}/matrx_orm/__init__.py

@@ -27,7 +27,7 @@ from .core.config import (
     resolve_database_name,
     resolve_pool_mode,
 )
-from .core.db_function import ArrayArg, call_function
+from .core.db_function import ArrayArg, call_function, call_function_sync
 from .entity import EntityCapabilityError, MatrxEntity
 from .core.diagnostics import collect_pool_diagnostics, log_pool_diagnostics
 from .core.introspection import introspect_columns, introspect_rls_policies, schema_exists
@@ -318,6 +318,7 @@ __all__ = [
     "install_asyncpg_idle_close_filter",
     # ── DB-side function calls (RPC) ──────────────────────────────────────────
     "call_function",
+    "call_function_sync",
     "MatrxEntity",
     "EntityCapabilityError",
     "ArrayArg",

{matrx_orm-3.1.7 → matrx_orm-3.1.8}/matrx_orm/core/base.py

@@ -1263,6 +1263,71 @@ class Model(RuntimeMixin, metaclass=ModelMeta):
 
         return run_sync(cls.filter(**kwargs).all())
 
+    @classmethod
+    def create_sync(cls, **kwargs: Any) -> Self:
+        """Synchronous twin of create(). Sync contexts only."""
+        try:
+            asyncio.get_running_loop()
+            raise RuntimeError(
+                "Model.create_sync() called in an async context. Use await Model.create(...) instead."
+            )
+        except RuntimeError as e:
+            if "no running event loop" not in str(e):
+                raise
+
+        return run_sync(cls.create(**kwargs))
+
+    @classmethod
+    def upsert_sync(
+        cls,
+        data: dict[str, Any],
+        conflict_fields: list[str] | None = None,
+        update_fields: list[str] | None = None,
+        *,
+        on_conflict: list[str] | ConflictTarget | None = None,  # noqa: F821
+    ) -> Self:
+        """Synchronous twin of upsert(). Sync contexts only."""
+        try:
+            asyncio.get_running_loop()
+            raise RuntimeError(
+                "Model.upsert_sync() called in an async context. Use await Model.upsert(...) instead."
+            )
+        except RuntimeError as e:
+            if "no running event loop" not in str(e):
+                raise
+
+        return run_sync(
+            cls.upsert(data, conflict_fields, update_fields, on_conflict=on_conflict)
+        )
+
+    @classmethod
+    def update_where_sync(cls, filters: dict[str, Any], **updates: Any) -> UpdateResult:
+        """Synchronous twin of update_where(). Sync contexts only."""
+        try:
+            asyncio.get_running_loop()
+            raise RuntimeError(
+                "Model.update_where_sync() called in an async context. Use await Model.update_where(...) instead."
+            )
+        except RuntimeError as e:
+            if "no running event loop" not in str(e):
+                raise
+
+        return run_sync(cls.update_where(filters, **updates))
+
+    @classmethod
+    def delete_where_sync(cls, **filters: Any) -> int:
+        """Synchronous twin of delete_where(). Sync contexts only."""
+        try:
+            asyncio.get_running_loop()
+            raise RuntimeError(
+                "Model.delete_where_sync() called in an async context. Use await Model.delete_where(...) instead."
+            )
+        except RuntimeError as e:
+            if "no running event loop" not in str(e):
+                raise
+
+        return run_sync(cls.delete_where(**filters))
+
     @classmethod
     async def all(cls) -> list[Self]:
         try:

{matrx_orm-3.1.7 → matrx_orm-3.1.8}/matrx_orm/core/db_function.py

@@ -70,7 +70,7 @@ from typing import Any, Literal
 from matrx_orm.core.async_db_manager import AsyncDatabaseManager
 from matrx_orm.core.transaction import get_active_connection
 
-__all__ = ["call_function", "ArrayArg"]
+__all__ = ["call_function", "call_function_sync", "ArrayArg"]
 
 # Postgres unquoted-identifier shape. Deliberately strict — this is the only
 # thing standing between a caller-supplied name and the query string, so a
@@ -195,3 +195,27 @@ async def call_function(
             rows = await conn.fetch(sql, *bound_args)
             return [dict(r) for r in rows]
         return await conn.fetchval(sql, *bound_args)
+
+
+def call_function_sync(
+    database: str,
+    schema: str,
+    function: str,
+    *args: Any,
+    mode: Literal["scalar", "none", "rows"] = "scalar",
+    field: str | None = None,
+) -> Any:
+    """Synchronous twin of :func:`call_function`. Sync contexts only."""
+    import asyncio
+
+    from matrx_orm.core.async_db_manager import run_sync
+
+    try:
+        asyncio.get_running_loop()
+        raise RuntimeError(
+            "call_function_sync() called in an async context. Use await call_function(...) instead."
+        )
+    except RuntimeError as e:
+        if "no running event loop" not in str(e):
+            raise
+    return run_sync(call_function(database, schema, function, *args, mode=mode, field=field))

{matrx_orm-3.1.7 → matrx_orm-3.1.8}/matrx_orm/query/builder.py

@@ -1055,6 +1055,38 @@ class QueryBuilder(Generic[ModelT]):
     # Synchronous wrappers
     # ------------------------------------------------------------------
 
+    def all_sync(self) -> list[ModelT]:
+        """Synchronous execution of the built query. Sync contexts only."""
+        import asyncio
+
+        from matrx_orm.core.async_db_manager import run_sync
+
+        try:
+            asyncio.get_running_loop()
+            raise RuntimeError(
+                "QueryBuilder.all_sync() called in an async context. Use await .all() instead."
+            )
+        except RuntimeError as e:
+            if "no running event loop" not in str(e):
+                raise
+        return run_sync(self.all())
+
+    def first_sync(self) -> ModelT | None:
+        """Synchronous twin of first(). Sync contexts only."""
+        import asyncio
+
+        from matrx_orm.core.async_db_manager import run_sync
+
+        try:
+            asyncio.get_running_loop()
+            raise RuntimeError(
+                "QueryBuilder.first_sync() called in an async context. Use await .first() instead."
+            )
+        except RuntimeError as e:
+            if "no running event loop" not in str(e):
+                raise
+        return run_sync(self.first())
+
     def values_sync(self, *fields: str) -> list[dict[str, Any]]:
         """Synchronous wrapper for values()."""
         try:

{matrx_orm-3.1.7 → matrx_orm-3.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "matrx-orm"
-version = "3.1.7"
+version = "3.1.8"
 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.8/tests/test_sync_twins_guard.py

@@ -0,0 +1,52 @@
+"""Guard tests for the sync-twin surface added 2026-07-13 (matrx-files Phase 2).
+
+The twins (Model.create_sync / upsert_sync / update_where_sync /
+delete_where_sync, QueryBuilder.all_sync / first_sync, call_function_sync)
+must exist and must REFUSE to run inside a live event loop — running a
+blocking pool call on the loop is the bug class the guard exists for.
+No database needed: the in-loop guard fires before any connection.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from matrx_orm import call_function_sync
+from matrx_orm.core.base import Model
+from matrx_orm.core.fields import TextField
+from matrx_orm.query.builder import QueryBuilder
+
+
+class _GuardModel(Model):
+    id = TextField(primary_key=True)
+    _database = "guard_test_db_never_registered"
+    _table_name = "guard_test_table"
+
+
+def test_sync_twins_exist() -> None:
+    for name in ("create_sync", "upsert_sync", "update_where_sync", "delete_where_sync"):
+        assert callable(getattr(_GuardModel, name)), name
+    for name in ("all_sync", "first_sync"):
+        assert callable(getattr(QueryBuilder, name)), name
+
+
+def test_sync_twins_refuse_async_context() -> None:
+    async def run() -> None:
+        with pytest.raises(RuntimeError, match="async context"):
+            _GuardModel.create_sync(id="x")
+        with pytest.raises(RuntimeError, match="async context"):
+            _GuardModel.upsert_sync({"id": "x"}, on_conflict=["id"])
+        with pytest.raises(RuntimeError, match="async context"):
+            _GuardModel.update_where_sync({"id": "x"}, id="y")
+        with pytest.raises(RuntimeError, match="async context"):
+            _GuardModel.delete_where_sync(id="x")
+        with pytest.raises(RuntimeError, match="async context"):
+            _GuardModel.filter(id="x").all_sync()
+        with pytest.raises(RuntimeError, match="async context"):
+            _GuardModel.filter(id="x").first_sync()
+        with pytest.raises(RuntimeError, match="async context"):
+            call_function_sync("db", "public", "fn")
+
+    asyncio.run(run())