dominus-sdk-python 2.13.4__tar.gz → 2.15.0__tar.gz

{dominus_sdk_python-2.13.4 → dominus_sdk_python-2.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dominus-sdk-python
-Version: 2.13.4
+Version: 2.15.0
 Summary: Python SDK for the Dominus Orchestrator Platform
 Author-email: CareBridge Systems <dev@carebridge.io>
 License: Proprietary

{dominus_sdk_python-2.13.4 → dominus_sdk_python-2.15.0}/dominus/__init__.py

@@ -152,7 +152,7 @@ from .errors import (
     TimeoutError as DominusTimeoutError,
 )
 
-__version__ = "2.13.2"
+__version__ = "2.15.0"
 __all__ = [
     # Main SDK instance
     "dominus",

{dominus_sdk_python-2.13.4 → dominus_sdk_python-2.15.0}/dominus/helpers/console_capture.py

@@ -1,12 +1,11 @@
 """
 Console Capture - Auto-forwards print() and logging.* to Dominus Logs Worker.
 
-Activated by DOMINUS_CAPTURE_CONSOLE=true environment variable.
+Enabled by default. Set DOMINUS_CAPTURE_CONSOLE=false to disable.
 Preserves original output and never throws errors.
 
 Usage:
-    # Automatic (via env var):
-    # Set DOMINUS_CAPTURE_CONSOLE=true before importing SDK
+    # Automatic (default, disable with DOMINUS_CAPTURE_CONSOLE=false)
 
     # Manual:
     from dominus import dominus
@@ -56,10 +55,10 @@ def _fire_log(level: str, message: str) -> None:
     global _sending
     if _sending or not _logs_ref:
         return
-    _sending = True
 
     async def _send():
         global _sending
+        _sending = True
         try:
             if level == "debug":
                 await _logs_ref.debug(message, {"source": "console"}, "console")
@@ -79,8 +78,8 @@ def _fire_log(level: str, message: str) -> None:
         loop = asyncio.get_running_loop()
         loop.create_task(_send())
     except RuntimeError:
-        # No running event loop - skip (can't do async without one)
-        _sending = False
+        # No running event loop - skip silently
+        pass
 
 
 def _patched_print(*args, **kwargs):

{dominus_sdk_python-2.13.4 → dominus_sdk_python-2.15.0}/dominus/namespaces/auth.py

@@ -210,6 +210,132 @@ class AuthNamespace:
             body=body
         )
 
+    async def get_user_attribute(self, attribute_id: str) -> Dict[str, Any]:
+        """Get a user attribute by ID."""
+        return await self._client._request(
+            endpoint=f"/api/guardian/user-attributes/{attribute_id}",
+            method="GET"
+        )
+
+    async def list_user_attributes(
+        self,
+        user_id: Optional[str] = None,
+        attribute_type: Optional[str] = None,
+        attribute_key: Optional[str] = None,
+        attribute_value: Optional[str] = None,
+        active: Optional[bool] = None,
+        verified: Optional[bool] = None,
+        limit: int = 100,
+        offset: int = 0,
+        order_by: str = "created_at",
+        order_desc: bool = True,
+    ) -> Dict[str, Any]:
+        """List user attributes with optional filters."""
+        params = f"?limit={limit}&offset={offset}&order_by={order_by}&order_desc={str(order_desc).lower()}"
+        if user_id:
+            params += f"&user_id={user_id}"
+        if attribute_type:
+            params += f"&attribute_type={attribute_type}"
+        if attribute_key:
+            params += f"&attribute_key={attribute_key}"
+        if attribute_value:
+            params += f"&attribute_value={attribute_value}"
+        if active is not None:
+            params += f"&active={str(active).lower()}"
+        if verified is not None:
+            params += f"&verified={str(verified).lower()}"
+
+        return await self._client._request(
+            endpoint=f"/api/guardian/user-attributes{params}",
+            method="GET"
+        )
+
+    async def create_user_attribute(
+        self,
+        user_id: str,
+        attribute_type: str,
+        attribute_key: str,
+        attribute_value: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        active: Optional[bool] = None,
+        verified: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        """Create a user attribute."""
+        body: Dict[str, Any] = {
+            "user_id": user_id,
+            "attribute_type": attribute_type,
+            "attribute_key": attribute_key,
+            "attribute_value": attribute_value,
+        }
+        if metadata is not None:
+            body["metadata"] = metadata
+        if active is not None:
+            body["active"] = active
+        if verified is not None:
+            body["verified"] = verified
+
+        return await self._client._request(
+            endpoint="/api/guardian/user-attributes",
+            body=body
+        )
+
+    async def update_user_attribute(
+        self,
+        attribute_id: str,
+        attribute_type: Optional[str] = None,
+        attribute_key: Optional[str] = None,
+        attribute_value: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        active: Optional[bool] = None,
+        verified: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        """Update a user attribute."""
+        body: Dict[str, Any] = {}
+        if attribute_type is not None:
+            body["attribute_type"] = attribute_type
+        if attribute_key is not None:
+            body["attribute_key"] = attribute_key
+        if attribute_value is not None:
+            body["attribute_value"] = attribute_value
+        if metadata is not None:
+            body["metadata"] = metadata
+        if active is not None:
+            body["active"] = active
+        if verified is not None:
+            body["verified"] = verified
+
+        return await self._client._request(
+            endpoint=f"/api/guardian/user-attributes/{attribute_id}",
+            method="PUT",
+            body=body
+        )
+
+    async def delete_user_attribute(self, attribute_id: str) -> Dict[str, Any]:
+        """Delete a user attribute."""
+        return await self._client._request(
+            endpoint=f"/api/guardian/user-attributes/{attribute_id}",
+            method="DELETE"
+        )
+
+    async def find_by_attribute(
+        self,
+        attribute_type: str,
+        attribute_value: str,
+        active: Optional[bool] = None,
+        verified: Optional[bool] = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> Dict[str, Any]:
+        """Find user attributes by attribute type and value."""
+        return await self.list_user_attributes(
+            attribute_type=attribute_type,
+            attribute_value=attribute_value,
+            active=active,
+            verified=verified,
+            limit=limit,
+            offset=offset,
+        )
+
     # User junction tables
     async def get_user_roles(self, user_id: str) -> List[Dict[str, Any]]:
         """Get roles assigned to user."""

dominus_sdk_python-2.15.0/dominus/namespaces/db.py

@@ -0,0 +1,392 @@
+"""
+Database Namespace - DB Worker data CRUD operations.
+
+Routes all database operations through the DB Worker (Cloudflare Worker)
+via the gateway at /svc/database/*.
+
+Parity target: dominus-sdk-nodejs/src/namespaces/db.ts v1.28.0
+"""
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..start import Dominus
+
+
+class DbNamespace:
+    """
+    Database CRUD namespace.
+
+    All data operations go through /api/database/* endpoints via the gateway.
+    The gateway routes these to the dominus-db-worker (Cloudflare Worker).
+
+    Usage:
+        # List schemas
+        schemas = await dominus.db.schemas()
+
+        # Query with filters
+        result = await dominus.db.query("users", filters={"status": "active"})
+
+        # Query shared hub tables
+        companies = await dominus.db.query("hub_companies", use_shared=True)
+
+        # Insert data
+        await dominus.db.insert("users", {"name": "John", "email": "john@example.com"})
+
+        # Raw SQL
+        result = await dominus.db.raw("SELECT * FROM auth.users WHERE id = $1", [user_id])
+
+        # Transaction
+        result = await dominus.db.transaction([
+            {"sql": "UPDATE accounts SET balance = balance - $1 WHERE id = $2", "params": [100, from_id]},
+            {"sql": "UPDATE accounts SET balance = balance + $1 WHERE id = $2", "params": [100, to_id]},
+        ])
+    """
+
+    def __init__(self, client: "Dominus"):
+        self._client = client
+
+    async def schemas(self, use_shared: bool = False, open: bool = False) -> List[str]:
+        """
+        List accessible schemas.
+
+        Returns schemas that the current user can access (public, tenant_*, etc.)
+        Excludes system schemas (pg_catalog, information_schema, etc.)
+        """
+        body: Dict[str, Any] = {}
+        if use_shared:
+            body["use_shared"] = True
+        if open:
+            body["open"] = True
+
+        result = await self._client._request(
+            endpoint="/api/database/schemas",
+            body=body,
+            use_gateway=True
+        )
+        if isinstance(result, dict):
+            return result.get("schemas", [])
+        return result if isinstance(result, list) else []
+
+    async def tables(self, schema: str = "public", use_shared: bool = False, open: bool = False) -> List[Dict[str, Any]]:
+        """
+        List tables in a schema.
+
+        Args:
+            schema: Schema name (default: "public")
+            use_shared: If True, query the shared project database
+            open: If True, use the open (user-facing) database role
+        """
+        body: Dict[str, Any] = {"schema": schema}
+        if use_shared:
+            body["use_shared"] = True
+        if open:
+            body["open"] = True
+
+        result = await self._client._request(
+            endpoint="/api/database/tables",
+            body=body,
+            use_gateway=True
+        )
+        if isinstance(result, dict):
+            return result.get("tables", [])
+        return result if isinstance(result, list) else []
+
+    async def columns(self, table: str, schema: str = "public", use_shared: bool = False, open: bool = False) -> List[Dict[str, Any]]:
+        """
+        List columns in a table.
+
+        Args:
+            table: Table name
+            schema: Schema name (default: "public")
+            use_shared: If True, query the shared project database
+            open: If True, use the open (user-facing) database role
+        """
+        body: Dict[str, Any] = {"table": table, "schema": schema}
+        if use_shared:
+            body["use_shared"] = True
+        if open:
+            body["open"] = True
+
+        result = await self._client._request(
+            endpoint="/api/database/columns",
+            body=body,
+            use_gateway=True
+        )
+        if isinstance(result, dict):
+            return result.get("columns", [])
+        return result if isinstance(result, list) else []
+
+    async def query(
+        self,
+        table: str,
+        schema: str = "public",
+        filters: Optional[Dict[str, Any]] = None,
+        sort_by: Optional[str] = None,
+        sort_order: str = "ASC",
+        limit: int = 100,
+        offset: int = 0,
+        use_shared: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Query table data with filtering, sorting, and pagination.
+
+        Args:
+            table: Table name
+            schema: Schema name (default: "public")
+            filters: Column:value filter dictionary (sent as 'where' to DB Worker)
+            sort_by: Column to sort by
+            sort_order: "ASC" or "DESC"
+            limit: Maximum rows to return (default: 100)
+            offset: Rows to skip (default: 0)
+            use_shared: If True, query the shared project database
+
+        Returns:
+            Dict with "rows" and "total" keys
+        """
+        order_by = [{"column": sort_by, "direction": sort_order}] if sort_by else None
+
+        body: Dict[str, Any] = {
+            "table": table,
+            "schema": schema,
+            "where": filters,
+            "order_by": order_by,
+            "limit": limit,
+            "offset": offset,
+        }
+        if use_shared:
+            body["use_shared"] = True
+
+        result = await self._client._request(
+            endpoint="/api/database/select",
+            body=body,
+            use_gateway=True
+        )
+
+        return {
+            "rows": result.get("rows", []) if isinstance(result, dict) else [],
+            "total": result.get("row_count", 0) if isinstance(result, dict) else 0,
+        }
+
+    async def insert(
+        self,
+        table: str,
+        data: Dict[str, Any],
+        schema: str = "public",
+        use_shared: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Insert a row into a table.
+
+        Args:
+            table: Table name
+            data: Column:value dictionary
+            schema: Schema name (default: "public")
+            use_shared: If True, write to the shared project database
+
+        Returns:
+            Inserted row data
+        """
+        body: Dict[str, Any] = {
+            "table": table,
+            "schema": schema,
+            "data": data,
+            "returning": ["*"],
+        }
+        if use_shared:
+            body["use_shared"] = True
+
+        result = await self._client._request(
+            endpoint="/api/database/insert",
+            body=body,
+            use_gateway=True
+        )
+
+        if isinstance(result, dict) and "rows" in result:
+            return result["rows"][0] if result["rows"] else result
+        return result
+
+    async def update(
+        self,
+        table: str,
+        data: Dict[str, Any],
+        filters: Dict[str, Any],
+        schema: str = "public",
+        use_shared: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Update rows matching filters.
+
+        Args:
+            table: Table name
+            data: Column:value dictionary of updates
+            filters: Column:value dictionary for WHERE clause (sent as 'where' to DB Worker)
+            schema: Schema name (default: "public")
+            use_shared: If True, write to the shared project database
+
+        Returns:
+            Dict with "affected_rows" count
+        """
+        body: Dict[str, Any] = {
+            "table": table,
+            "schema": schema,
+            "data": data,
+            "where": filters,
+            "returning": ["*"],
+        }
+        if use_shared:
+            body["use_shared"] = True
+
+        result = await self._client._request(
+            endpoint="/api/database/update",
+            body=body,
+            use_gateway=True
+        )
+
+        return {"affected_rows": result.get("row_count", 0) if isinstance(result, dict) else 0}
+
+    async def delete(
+        self,
+        table: str,
+        filters: Dict[str, Any],
+        schema: str = "public",
+        use_shared: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Delete rows matching filters.
+
+        Args:
+            table: Table name
+            filters: Column:value dictionary for WHERE clause (sent as 'where' to DB Worker)
+            schema: Schema name (default: "public")
+            use_shared: If True, delete from the shared project database
+
+        Returns:
+            Dict with "affected_rows" count
+        """
+        body: Dict[str, Any] = {
+            "table": table,
+            "schema": schema,
+            "where": filters,
+            "returning": ["*"],
+        }
+        if use_shared:
+            body["use_shared"] = True
+
+        result = await self._client._request(
+            endpoint="/api/database/delete",
+            body=body,
+            use_gateway=True
+        )
+
+        return {"affected_rows": result.get("row_count", 0) if isinstance(result, dict) else 0}
+
+    async def raw(
+        self,
+        sql: str,
+        params: Optional[List[Any]] = None,
+        schema: str = "public",
+        use_shared: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Execute raw SQL queries.
+
+        Args:
+            sql: SQL query with $1, $2 style placeholders
+            params: Parameter values for placeholders
+            schema: Schema name (default: "public")
+            use_shared: If True, query the shared project database
+
+        Returns:
+            Dict with "rows" and "total" keys
+        """
+        body: Dict[str, Any] = {
+            "sql": sql,
+            "params": params or [],
+            "schema": schema,
+        }
+        if use_shared:
+            body["use_shared"] = True
+
+        result = await self._client._request(
+            endpoint="/api/database/raw",
+            body=body,
+            use_gateway=True
+        )
+
+        return {
+            "rows": result.get("rows", []) if isinstance(result, dict) else [],
+            "total": result.get("row_count", 0) if isinstance(result, dict) else 0,
+        }
+
+    async def bulk_insert(
+        self,
+        table: str,
+        rows: List[Dict[str, Any]],
+        schema: str = "public",
+        use_shared: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Insert multiple rows at once using a raw SQL transaction.
+
+        Args:
+            table: Table name
+            rows: List of column:value dictionaries
+            schema: Schema name (default: "public")
+            use_shared: If True, write to the shared project database
+
+        Returns:
+            Dict with "inserted_count" and optionally "rows"
+        """
+        if not rows:
+            return {"inserted_count": 0, "rows": []}
+
+        columns = list(rows[0].keys())
+        quoted_cols = ", ".join(f'"{c}"' for c in columns)
+        params: List[Any] = []
+        value_clauses: List[str] = []
+
+        for row in rows:
+            placeholders = []
+            for col in columns:
+                params.append(row.get(col))
+                placeholders.append(f"${len(params)}")
+            value_clauses.append(f"({', '.join(placeholders)})")
+
+        sql = f'INSERT INTO "{table}" ({quoted_cols}) VALUES {", ".join(value_clauses)} RETURNING *'
+
+        result = await self.raw(sql, params, schema=schema, use_shared=use_shared)
+
+        return {
+            "inserted_count": result.get("total", 0),
+            "rows": result.get("rows", []),
+        }
+
+    async def transaction(
+        self,
+        statements: List[Dict[str, Any]],
+        schema: str = "public",
+        use_shared: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Execute multiple SQL statements in a single atomic transaction.
+
+        Args:
+            statements: List of dicts with 'sql' and optional 'params' keys
+            schema: Schema name (default: "public")
+            use_shared: If True, execute against the shared project database
+
+        Returns:
+            Dict with "results" array containing rows and row_count per statement
+        """
+        body: Dict[str, Any] = {
+            "statements": statements,
+            "schema": schema,
+        }
+        if use_shared:
+            body["use_shared"] = True
+
+        return await self._client._request(
+            endpoint="/api/database/transaction",
+            body=body,
+            use_gateway=True
+        )

{dominus_sdk_python-2.13.4 → dominus_sdk_python-2.15.0}/dominus/start.py

@@ -378,8 +378,8 @@ class Dominus:
         # Cache for JWT public key
         self._public_key_cache = None
 
-        # Auto-activate console capture if env var is set
-        if os.environ.get("DOMINUS_CAPTURE_CONSOLE") == "true":
+        # Auto-activate console capture (opt-out with DOMINUS_CAPTURE_CONSOLE=false)
+        if os.environ.get("DOMINUS_CAPTURE_CONSOLE", "true").lower() != "false":
             from .helpers.console_capture import install_console_capture
             install_console_capture(self.logs)
 

{dominus_sdk_python-2.13.4 → dominus_sdk_python-2.15.0}/dominus_sdk_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dominus-sdk-python
-Version: 2.13.4
+Version: 2.15.0
 Summary: Python SDK for the Dominus Orchestrator Platform
 Author-email: CareBridge Systems <dev@carebridge.io>
 License: Proprietary

{dominus_sdk_python-2.13.4 → dominus_sdk_python-2.15.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dominus-sdk-python"
-version = "2.13.4"
+version = "2.15.0"
 description = "Python SDK for the Dominus Orchestrator Platform"
 readme = "README.md"
 license = {text = "Proprietary"}

dominus_sdk_python-2.13.4/dominus/namespaces/db.py

@@ -1,292 +0,0 @@
-"""
-Database Namespace - Scribe data CRUD operations.
-
-Provides data operations for all schemas with support for secure table access.
-"""
-from typing import Any, Dict, List, Optional, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ..start import Dominus
-
-
-class DbNamespace:
-    """
-    Database CRUD namespace.
-
-    All data operations go through /api/scribe/data/* endpoints.
-    Secure tables (registered in auth.secure_tables) require a `reason` parameter.
-
-    Usage:
-        # List tables
-        tables = await dominus.db.tables()
-        tables = await dominus.db.tables(schema="tenant_acme")
-
-        # Query with filters
-        users = await dominus.db.query("users", filters={"status": "active"})
-
-        # Query secure table (requires reason)
-        patients = await dominus.db.query(
-            "patients",
-            schema="tenant_acme",
-            reason="Reviewing chart for appointment #123",
-            actor=current_user_id
-        )
-
-        # Insert data
-        await dominus.db.insert("users", {"name": "John", "email": "john@example.com"})
-
-        # Update rows
-        await dominus.db.update("users", {"status": "inactive"}, filters={"id": user_id})
-
-        # Delete rows
-        await dominus.db.delete("users", filters={"id": user_id})
-    """
-
-    def __init__(self, client: "Dominus"):
-        self._client = client
-
-    async def schemas(self) -> List[str]:
-        """
-        List accessible schemas.
-
-        Returns schemas that the current user can access (public, tenant_*, etc.)
-        Excludes system schemas (auth, logs, meta, object, etc.)
-
-        Returns:
-            List of schema names
-        """
-        result = await self._client._request(
-            endpoint="/api/scribe/schema/list",
-            method="GET"
-        )
-        if isinstance(result, list):
-            return result
-        return result.get("schemas", [])
-
-    async def tables(self, schema: str = "public") -> List[Dict[str, Any]]:
-        """
-        List tables in a schema.
-
-        Args:
-            schema: Schema name (default: "public")
-
-        Returns:
-            List of table metadata
-        """
-        result = await self._client._request(
-            endpoint=f"/api/scribe/data/{schema}/tables",
-            method="GET"
-        )
-        return result.get("tables", result) if isinstance(result, dict) else result
-
-    async def columns(self, table: str, schema: str = "public") -> List[Dict[str, Any]]:
-        """
-        List columns in a table.
-
-        Args:
-            table: Table name
-            schema: Schema name (default: "public")
-
-        Returns:
-            List of column metadata
-        """
-        result = await self._client._request(
-            endpoint=f"/api/scribe/data/{schema}/{table}/columns",
-            method="GET"
-        )
-        return result.get("columns", result) if isinstance(result, dict) else result
-
-    async def query(
-        self,
-        table: str,
-        schema: str = "public",
-        filters: Optional[Dict[str, Any]] = None,
-        sort_by: Optional[str] = None,
-        sort_order: str = "ASC",
-        limit: int = 100,
-        offset: int = 0,
-        reason: Optional[str] = None,
-        actor: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """
-        Query table data with filtering, sorting, and pagination.
-
-        Args:
-            table: Table name
-            schema: Schema name (default: "public")
-            filters: Column:value filter dictionary
-            sort_by: Column to sort by
-            sort_order: "ASC" or "DESC"
-            limit: Maximum rows to return (default: 100)
-            offset: Rows to skip (default: 0)
-            reason: Access justification (required for secure tables)
-            actor: User ID or "machine" for audit trail
-
-        Returns:
-            Dict with "rows" and "total" keys
-
-        Raises:
-            SecureTableError: If accessing secure table without reason
-        """
-        body = {
-            "filters": filters,
-            "sort_by": sort_by,
-            "sort_order": sort_order,
-            "limit": limit,
-            "offset": offset
-        }
-
-        if reason:
-            body["reason"] = reason
-        if actor:
-            body["actor"] = actor
-
-        # Backend returns {items, total, limit, offset} but we normalize to {rows, total}
-        result = await self._client._request(
-            endpoint=f"/api/scribe/data/{schema}/{table}/query",
-            body=body
-        )
-
-        # Normalize response - map 'items' to 'rows' for consistent interface
-        return {
-            "rows": result.get("items", result.get("rows", [])),
-            "total": result.get("total", 0)
-        }
-
-    async def insert(
-        self,
-        table: str,
-        data: Dict[str, Any],
-        schema: str = "public",
-        reason: Optional[str] = None,
-        actor: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """
-        Insert a row into a table.
-
-        Args:
-            table: Table name
-            data: Column:value dictionary
-            schema: Schema name (default: "public")
-            reason: Access justification (required for secure tables)
-            actor: User ID or "machine" for audit trail
-
-        Returns:
-            Inserted row data
-        """
-        body = {"data": data}
-
-        if reason:
-            body["reason"] = reason
-        if actor:
-            body["actor"] = actor
-
-        return await self._client._request(
-            endpoint=f"/api/scribe/data/{schema}/{table}/insert",
-            body=body
-        )
-
-    async def update(
-        self,
-        table: str,
-        data: Dict[str, Any],
-        filters: Dict[str, Any],
-        schema: str = "public",
-        reason: Optional[str] = None,
-        actor: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """
-        Update rows matching filters.
-
-        Args:
-            table: Table name
-            data: Column:value dictionary of updates
-            filters: Column:value dictionary for WHERE clause
-            schema: Schema name (default: "public")
-            reason: Access justification (required for secure tables)
-            actor: User ID or "machine" for audit trail
-
-        Returns:
-            Dict with "affected_rows" count
-        """
-        body = {
-            "data": data,
-            "filters": filters
-        }
-
-        if reason:
-            body["reason"] = reason
-        if actor:
-            body["actor"] = actor
-
-        return await self._client._request(
-            endpoint=f"/api/scribe/data/{schema}/{table}/update",
-            body=body
-        )
-
-    async def delete(
-        self,
-        table: str,
-        filters: Dict[str, Any],
-        schema: str = "public",
-        reason: Optional[str] = None,
-        actor: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """
-        Delete rows matching filters.
-
-        Args:
-            table: Table name
-            filters: Column:value dictionary for WHERE clause
-            schema: Schema name (default: "public")
-            reason: Access justification (required for secure tables)
-            actor: User ID or "machine" for audit trail
-
-        Returns:
-            Dict with "affected_rows" count
-        """
-        body = {"filters": filters}
-
-        if reason:
-            body["reason"] = reason
-        if actor:
-            body["actor"] = actor
-
-        return await self._client._request(
-            endpoint=f"/api/scribe/data/{schema}/{table}/delete",
-            body=body
-        )
-
-    async def bulk_insert(
-        self,
-        table: str,
-        rows: List[Dict[str, Any]],
-        schema: str = "public",
-        reason: Optional[str] = None,
-        actor: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """
-        Insert multiple rows at once.
-
-        Args:
-            table: Table name
-            rows: List of column:value dictionaries
-            schema: Schema name (default: "public")
-            reason: Access justification (required for secure tables)
-            actor: User ID or "machine" for audit trail
-
-        Returns:
-            Dict with "inserted_count" and optionally "rows"
-        """
-        body = {"rows": rows}
-
-        if reason:
-            body["reason"] = reason
-        if actor:
-            body["actor"] = actor
-
-        return await self._client._request(
-            endpoint=f"/api/scribe/data/{schema}/{table}/bulk-insert",
-            body=body
-        )
-