dazpy 2.9.0__tar.gz → 2.9.3__tar.gz

{dazpy-2.9.0 → dazpy-2.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dazpy
-Version: 2.9.0
+Version: 2.9.3
 Summary: Python SDK for the DAZ Studio Script Server
 License: MIT
 Project-URL: Homepage, https://github.com/bluemoonfoundry/daz-script-server
@@ -17,7 +17,7 @@ Requires-Dist: httpx>=0.24; extra == "aio"
 
 # DazScript Server
 
-**Version 2.9.0** | DAZ Studio 4.5+ | DAZ Studio 6.25+ | Windows & macOS
+**Version 2.9.3** | DAZ Studio 4.5+ | DAZ Studio 6.25+ | Windows & macOS
 
 [![Docs](https://img.shields.io/badge/docs-dazpy%20SDK-blue)](https://bluemoonfoundry.github.io/daz-script-server/)
 [![HTTP API](https://img.shields.io/badge/docs-HTTP%20API%20reference-blue)](https://bluemoonfoundry.github.io/daz-script-server/api-reference/)
@@ -80,6 +80,20 @@ print(response.json())
 
 ---
 
+## Examples
+
+**Complete example collection:** [daz-script-server-examples repository](https://github.com/bluemoonfoundry/daz-script-server-examples)
+
+Production-ready examples ranging from beginner tutorials to advanced pipeline implementations:
+- **48 examples** across 9 categories
+- Individual READMEs with skill level classification
+- Requirements.txt per example
+- Comprehensive searchable table
+
+Categories: fundamentals, character, animation, rendering, geometry, export, ml_data, ai_vision, bvh
+
+---
+
 ## 📋 Table of Contents
 
 ### Getting Started
@@ -242,7 +256,7 @@ Async frameworks (FastAPI, FastMCP, ComfyUI custom nodes, asyncio/Temporal
 workflows) previously had to wrap every `DazClient` call in
 `asyncio.to_thread()` or hand-roll an `httpx.AsyncClient` wrapper.
 `dazpy.aio.AsyncDazClient` mirrors `DazClient`'s full method surface —
-`execute`, `execute_file`, async submit/status/result/list/cancel, render
+`execute`, `execute_file`, inline/file async submit/status/result/list/cancel, render
 submit/batch/animation, USD export, and server-health endpoints — as
 native `async def` methods backed by `httpx.AsyncClient`, including the
 same `retry_on_busy`/`max_wait` backoff semantics (via `asyncio.sleep`
@@ -253,8 +267,9 @@ from dazpy.aio import AsyncDazClient
 
 async def main():
     async with AsyncDazClient() as client:
-        result = await client.execute("1 + 1;")
-        print(result.value)
+        request_id = await client.execute_file_async_submit("C:/jobs/pose-probe.dsa")
+        result = await client.get_request_result(request_id, wait=True)
+        print(result)
 ```
 
 Requires the optional `httpx` dependency: `pip install dazpy[aio]`.
@@ -787,7 +802,7 @@ See the [full migration guide](MIGRATION.md) for upgrade steps and rollback inst
 
 Long-running operations (renders, exports, batch jobs) no longer need to block the HTTP connection:
 
-- **`POST /execute/async`** — Submit any inline script asynchronously; returns a `request_id` immediately
+- **`POST /execute/async`** — Submit inline `script` or host-side `scriptFile` work asynchronously; returns a `request_id` immediately
 - **`POST /scripts/:id/async`** — Submit a registered script asynchronously
 - **`GET /requests/:id/status`** — Poll for progress (`queued`, `running`, `completed`, `failed`, `cancelled`)
 - **`GET /requests/:id/result`** — Fetch the final result; supports `?wait=true` to long-poll until complete
@@ -1771,10 +1786,36 @@ result = requests.get(f"{BASE}/requests/{req_id}/result?wait=true&timeout=300",
 
 ### `POST /execute/async`
 
-**Purpose:** Submit an inline script for asynchronous execution
+**Purpose:** Submit an inline script or host-side script file for asynchronous execution
 **Authentication:** Required (if enabled)
 
-**Request Body:** Same as `POST /execute`
+**Request Body:** Same as `POST /execute`, plus optional `reportFile` for
+structured job observation.
+
+`reportFile` is an absolute host-side path to a JSONL file owned by this job.
+The server truncates it when the request is accepted. The script may then write
+one JSON object per line. The path is injected into the script's argument object
+as reserved field `getArguments()[0].__dssReportFile`, so callers do not have to
+duplicate it inside `args`:
+
+```jsonl
+{"type":"progress","value":0.25,"current":1,"total":4,"phase":"render","message":"Plate 1"}
+{"type":"log","level":"info","message":"Loaded scene"}
+{"type":"output","path":"C:/renders/run/plate-1.png","kind":"image","label":"plate"}
+```
+
+Progress events require either `value` (0–1) or `current` plus `total`. Log
+events require `message`. Output events require `path`; repeating a path updates
+that manifest entry. A `manifest` event may provide an `outputs` array. Use a
+unique report file for every job.
+`reportFile` may not be the submitted `scriptFile`, because the server owns and
+truncates the former before the job is queued.
+
+DAZ Studio 6 ingests report events from polling workers, so progress, logs, and
+outputs are visible while the main thread is occupied by the script. DAZ Studio
+4's JSON parser is main-thread-only; Studio 4 therefore ingests the final report
+after execution returns and does not expose report-driven progress while the job
+is still running.
 
 **Response (immediate):**
 ```json
@@ -1808,7 +1849,15 @@ result = requests.get(f"{BASE}/requests/{req_id}/result?wait=true&timeout=300",
 {
   "request_id": "a3f2b891",
   "status": "running",
-  "progress": 0.0,
+  "progress": 0.25,
+  "observation": {
+    "progress": {"value": 0.25, "current": 1, "total": 4, "phase": "render"},
+    "log_tail": [{"level": "info", "source": "script", "message": "Loaded scene"}],
+    "log_total": 1,
+    "log_truncated": false,
+    "output_manifest": {"count": 0, "outputs": []},
+    "report_file": "C:/renders/run/job.jsonl"
+  },
   "elapsed_ms": 1240,
   "queue_position": 0
 }
@@ -1846,6 +1895,11 @@ result = requests.get(f"{BASE}/requests/{req_id}/result?wait=true&timeout=300",
 }
 ```
 
+Completed, failed, and cancelled results also include `observation`. The log
+tail is capped at the newest 100 entries; `log_total` and `log_truncated` make
+the loss explicit. Ordinary captured `print()` output is folded into the same
+tail at completion while remaining available in the legacy `output` field.
+
 Returns HTTP 404 if the request ID is unknown or has been purged (TTL: 1 hour).
 
 ---

{dazpy-2.9.0 → dazpy-2.9.3}/README.md

@@ -1,6 +1,6 @@
 # DazScript Server
 
-**Version 2.9.0** | DAZ Studio 4.5+ | DAZ Studio 6.25+ | Windows & macOS
+**Version 2.9.3** | DAZ Studio 4.5+ | DAZ Studio 6.25+ | Windows & macOS
 
 [![Docs](https://img.shields.io/badge/docs-dazpy%20SDK-blue)](https://bluemoonfoundry.github.io/daz-script-server/)
 [![HTTP API](https://img.shields.io/badge/docs-HTTP%20API%20reference-blue)](https://bluemoonfoundry.github.io/daz-script-server/api-reference/)
@@ -63,6 +63,20 @@ print(response.json())
 
 ---
 
+## Examples
+
+**Complete example collection:** [daz-script-server-examples repository](https://github.com/bluemoonfoundry/daz-script-server-examples)
+
+Production-ready examples ranging from beginner tutorials to advanced pipeline implementations:
+- **48 examples** across 9 categories
+- Individual READMEs with skill level classification
+- Requirements.txt per example
+- Comprehensive searchable table
+
+Categories: fundamentals, character, animation, rendering, geometry, export, ml_data, ai_vision, bvh
+
+---
+
 ## 📋 Table of Contents
 
 ### Getting Started
@@ -225,7 +239,7 @@ Async frameworks (FastAPI, FastMCP, ComfyUI custom nodes, asyncio/Temporal
 workflows) previously had to wrap every `DazClient` call in
 `asyncio.to_thread()` or hand-roll an `httpx.AsyncClient` wrapper.
 `dazpy.aio.AsyncDazClient` mirrors `DazClient`'s full method surface —
-`execute`, `execute_file`, async submit/status/result/list/cancel, render
+`execute`, `execute_file`, inline/file async submit/status/result/list/cancel, render
 submit/batch/animation, USD export, and server-health endpoints — as
 native `async def` methods backed by `httpx.AsyncClient`, including the
 same `retry_on_busy`/`max_wait` backoff semantics (via `asyncio.sleep`
@@ -236,8 +250,9 @@ from dazpy.aio import AsyncDazClient
 
 async def main():
     async with AsyncDazClient() as client:
-        result = await client.execute("1 + 1;")
-        print(result.value)
+        request_id = await client.execute_file_async_submit("C:/jobs/pose-probe.dsa")
+        result = await client.get_request_result(request_id, wait=True)
+        print(result)
 ```
 
 Requires the optional `httpx` dependency: `pip install dazpy[aio]`.
@@ -770,7 +785,7 @@ See the [full migration guide](MIGRATION.md) for upgrade steps and rollback inst
 
 Long-running operations (renders, exports, batch jobs) no longer need to block the HTTP connection:
 
-- **`POST /execute/async`** — Submit any inline script asynchronously; returns a `request_id` immediately
+- **`POST /execute/async`** — Submit inline `script` or host-side `scriptFile` work asynchronously; returns a `request_id` immediately
 - **`POST /scripts/:id/async`** — Submit a registered script asynchronously
 - **`GET /requests/:id/status`** — Poll for progress (`queued`, `running`, `completed`, `failed`, `cancelled`)
 - **`GET /requests/:id/result`** — Fetch the final result; supports `?wait=true` to long-poll until complete
@@ -1754,10 +1769,36 @@ result = requests.get(f"{BASE}/requests/{req_id}/result?wait=true&timeout=300",
 
 ### `POST /execute/async`
 
-**Purpose:** Submit an inline script for asynchronous execution
+**Purpose:** Submit an inline script or host-side script file for asynchronous execution
 **Authentication:** Required (if enabled)
 
-**Request Body:** Same as `POST /execute`
+**Request Body:** Same as `POST /execute`, plus optional `reportFile` for
+structured job observation.
+
+`reportFile` is an absolute host-side path to a JSONL file owned by this job.
+The server truncates it when the request is accepted. The script may then write
+one JSON object per line. The path is injected into the script's argument object
+as reserved field `getArguments()[0].__dssReportFile`, so callers do not have to
+duplicate it inside `args`:
+
+```jsonl
+{"type":"progress","value":0.25,"current":1,"total":4,"phase":"render","message":"Plate 1"}
+{"type":"log","level":"info","message":"Loaded scene"}
+{"type":"output","path":"C:/renders/run/plate-1.png","kind":"image","label":"plate"}
+```
+
+Progress events require either `value` (0–1) or `current` plus `total`. Log
+events require `message`. Output events require `path`; repeating a path updates
+that manifest entry. A `manifest` event may provide an `outputs` array. Use a
+unique report file for every job.
+`reportFile` may not be the submitted `scriptFile`, because the server owns and
+truncates the former before the job is queued.
+
+DAZ Studio 6 ingests report events from polling workers, so progress, logs, and
+outputs are visible while the main thread is occupied by the script. DAZ Studio
+4's JSON parser is main-thread-only; Studio 4 therefore ingests the final report
+after execution returns and does not expose report-driven progress while the job
+is still running.
 
 **Response (immediate):**
 ```json
@@ -1791,7 +1832,15 @@ result = requests.get(f"{BASE}/requests/{req_id}/result?wait=true&timeout=300",
 {
   "request_id": "a3f2b891",
   "status": "running",
-  "progress": 0.0,
+  "progress": 0.25,
+  "observation": {
+    "progress": {"value": 0.25, "current": 1, "total": 4, "phase": "render"},
+    "log_tail": [{"level": "info", "source": "script", "message": "Loaded scene"}],
+    "log_total": 1,
+    "log_truncated": false,
+    "output_manifest": {"count": 0, "outputs": []},
+    "report_file": "C:/renders/run/job.jsonl"
+  },
   "elapsed_ms": 1240,
   "queue_position": 0
 }
@@ -1829,6 +1878,11 @@ result = requests.get(f"{BASE}/requests/{req_id}/result?wait=true&timeout=300",
 }
 ```
 
+Completed, failed, and cancelled results also include `observation`. The log
+tail is capped at the newest 100 entries; `log_total` and `log_truncated` make
+the loss explicit. Ordinary captured `print()` output is folded into the same
+tail at completion while remaining available in the legacy `output` field.
+
 Returns HTTP 404 if the request ID is unknown or has been purged (TTL: 1 hour).
 
 ---

{dazpy-2.9.0 → dazpy-2.9.3}/dazpy/__init__.py

@@ -13,7 +13,7 @@ Typical usage::
     figure.find_bone("r_forearm").set_local_rotation(0, 0, 45)
 """
 
-__version__ = "2.9.0"
+__version__ = "2.9.3"
 
 from ._client import DazClient
 from ._scene import DazScene

dazpy-2.9.3/dazpy/_batch.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+from ._client import DazClient
+from .exceptions import BatchLimitExceededError
+
+DEFAULT_MAX_OPERATIONS = 500
+DEFAULT_MAX_SCRIPT_LENGTH = 900_000  # stays under the server's default 1MB script cap
+
+
+def build_operations_script(operations: list[tuple[list[str], str]]) -> str:
+    """Build one IIFE script from a list of (body_lines, result_expression) pairs.
+
+    Shared by :meth:`Batch._build_script` and
+    :meth:`~dazpy.DazClient.execute_batch_async` so both produce scripts with
+    identical shape (keyed return object over ``_r0``, ``_r1``, ...).
+    """
+    body_lines = []
+    return_parts = []
+    for i, (lines, result_expression) in enumerate(operations):
+        key = f"_r{i}"
+        body_lines.extend(lines)
+        body_lines.append(f"var {key} = {result_expression};")
+        return_parts.append(f'"{key}": {key}')
+    return_obj = "{" + ", ".join(return_parts) + "}"
+    body_lines.append(f"return {return_obj};")
+    body = "\n".join(body_lines)
+    return f"(function(){{\n{body}\n}})()"
+
+
+class BatchFuture:
+    """Placeholder for a single result within a :class:`Batch` execution.
+
+    Created by :meth:`Batch.add` or :meth:`Batch.add_operation`; the
+    :attr:`value` property blocks until the batch has been executed.
+    """
+
+    def __init__(self, key: str):
+        self._key = key
+        self._resolved = False
+        self._value = None
+
+    @property
+    def value(self) -> object:
+        """The result value.
+
+        Raises:
+            RuntimeError: If :meth:`Batch.execute` has not been called yet.
+        """
+        if not self._resolved:
+            raise RuntimeError("Batch has not been executed yet")
+        return self._value
+
+    def _resolve(self, value: object) -> None:
+        self._value = value
+        self._resolved = True
+
+
+class Batch:
+    """Collect multiple DazScript operations and execute them in a single HTTP round-trip.
+
+    Usage as a context manager (recommended)::
+
+        with Batch(client) as b:
+            pos_future  = b.add(["var pos = Scene.findNode('Figure').getWSPos();",
+                                  "var pos = [pos.x, pos.y, pos.z];"])
+            name_future = b.add(["var name = Scene.findNode('Figure').getName();"])
+        # Both futures resolved after the `with` block
+        print(pos_future.value, name_future.value)
+
+    Or manually::
+
+        b = Batch(client)
+        f = b.add(["var x = 42;"])
+        b.execute()
+        print(f.value)
+
+    High-level helpers that generate operations programmatically should use
+    :meth:`add_operation` instead of :meth:`add` — it does not require the
+    caller to know the internally generated result-variable name, and
+    :meth:`add_prelude` lets multiple operations share one setup block (e.g.
+    a node lookup) emitted only once.
+
+    Args:
+        client: The :class:`~dazpy.DazClient` to use.
+        max_operations: Maximum number of queued operations before
+            :meth:`add_operation` raises :class:`~dazpy.exceptions.BatchLimitExceededError`.
+        max_script_length: Maximum generated script length (characters)
+            before :meth:`execute` raises :class:`~dazpy.exceptions.BatchLimitExceededError`.
+    """
+
+    def __init__(
+        self,
+        client: DazClient,
+        max_operations: int = DEFAULT_MAX_OPERATIONS,
+        max_script_length: int = DEFAULT_MAX_SCRIPT_LENGTH,
+    ):
+        self._client = client
+        self._ops: list[tuple[str, list[str], BatchFuture]] = []
+        self._preludes: dict[str, list[str]] = {}
+        self._prelude_order: list[str] = []
+        self._counter = 0
+        self._max_operations = max_operations
+        self._max_script_length = max_script_length
+
+    def add(self, lines: list[str]) -> BatchFuture:
+        """Queue a list of DazScript lines to be included in the batch.
+
+        The last line in *lines* should assign the desired result to a
+        variable named after the internally generated key (``_r0``, ``_r1``,
+        ... in call order) — inspect a prior :meth:`execute` call's generated
+        script if the exact naming matters, or prefer :meth:`add_operation`,
+        which does not require guessing the key name.
+
+        Args:
+            lines: DazScript source lines (no ``return`` needed).
+
+        Returns:
+            A :class:`BatchFuture` that resolves after :meth:`execute`.
+        """
+        key = f"_r{self._counter}"
+        self._counter += 1
+        future = BatchFuture(key)
+        self._ops.append((key, lines, future))
+        return future
+
+    def add_prelude(self, prelude_key: str, lines: list[str]) -> None:
+        """Register a shared setup block, emitted once per unique *prelude_key*.
+
+        Call this before :meth:`add_operation` calls whose bodies depend on
+        the prelude's bound variable(s) (e.g. a node lookup bound to
+        ``_node_Fig``). Repeated calls with the same *prelude_key* are no-ops
+        after the first — use this instead of re-emitting an identical lookup
+        once per operation.
+
+        Args:
+            prelude_key: Stable identifier for this setup block (e.g.
+                ``"node:Fig"``). Callers must pick keys that collide exactly
+                when — and only when — the generated lines are identical.
+            lines: DazScript source lines for the shared setup.
+        """
+        if prelude_key not in self._preludes:
+            self._preludes[prelude_key] = list(lines)
+            self._prelude_order.append(prelude_key)
+
+    def add_operation(self, body_lines: list[str], result_expression: str) -> BatchFuture:
+        """Queue an operation whose result the builder assigns internally.
+
+        Unlike :meth:`add`, the caller does not need to know the generated
+        key name — pass the JS expression that yields the result
+        (*result_expression*, e.g. a variable set inside *body_lines*, or a
+        literal expression), and the builder emits
+        ``var _rN = <result_expression>;`` itself.
+
+        Args:
+            body_lines: DazScript source lines with no trailing result
+                assignment (side effects only, e.g. property writes).
+            result_expression: A JS expression evaluated once, immediately
+                after *body_lines* run, and used as this operation's result.
+                Mutation-only operations should pass ``"null"``.
+
+        Returns:
+            A :class:`BatchFuture` that resolves after :meth:`execute`.
+
+        Raises:
+            BatchLimitExceededError: If this call would exceed the batch's
+                configured ``max_operations``.
+        """
+        if len(self._ops) >= self._max_operations:
+            raise BatchLimitExceededError(
+                f"Batch already has {len(self._ops)} operations "
+                f"(max_operations={self._max_operations})"
+            )
+        key = f"_r{self._counter}"
+        self._counter += 1
+        future = BatchFuture(key)
+        lines = list(body_lines) + [f"var {key} = {result_expression};"]
+        self._ops.append((key, lines, future))
+        return future
+
+    def _build_script(self) -> str:
+        body_lines = []
+        for prelude_key in self._prelude_order:
+            body_lines.extend(self._preludes[prelude_key])
+        return_parts = []
+        for key, lines, _ in self._ops:
+            body_lines.extend(lines)
+            return_parts.append(f'"{key}": {key}')
+        return_obj = "{" + ", ".join(return_parts) + "}"
+        body_lines.append(f"return {return_obj};")
+        body = "\n".join(body_lines)
+        return f"(function(){{\n{body}\n}})()"
+
+    def execute(self) -> None:
+        """Execute all queued operations in a single HTTP request and resolve all futures.
+
+        Raises:
+            BatchLimitExceededError: If the generated script exceeds
+                ``max_script_length``. Raised before any HTTP call.
+        """
+        if not self._ops:
+            return
+        script = self._build_script()
+        if len(script) > self._max_script_length:
+            raise BatchLimitExceededError(
+                f"Generated batch script is {len(script)} characters "
+                f"(max_script_length={self._max_script_length})"
+            )
+        result = self._client.execute(script)
+        data = result.value or {}
+        for key, _, future in self._ops:
+            future._resolve(data.get(key))
+
+    def __enter__(self) -> "Batch":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
+        if exc_type is None:
+            self.execute()
+        return False

{dazpy-2.9.0 → dazpy-2.9.3}/dazpy/_client.py

@@ -262,13 +262,16 @@ class DazClient:
         return self._with_busy_retry(_do, retry_on_busy, max_wait)
 
     def execute_async_submit(
-        self, script: str, args: object = None, *, retry_on_busy: bool = False, max_wait: float = 30.0
+        self, script: str, args: object = None, *, report_file: str | None = None,
+        retry_on_busy: bool = False, max_wait: float = 30.0
     ) -> str:
         """Submit a script for asynchronous execution and return immediately.
 
         Args:
             script: DazScript source code.
             args: Optional argument for the script.
+            report_file: Optional host-side JSONL file used by the script to
+                report structured progress, logs, and output artefacts.
             retry_on_busy: If ``True``, transparently retry with backoff when
                 the server reports ``StudioBusyError``/``ConcurrencyLimitError``,
                 instead of raising immediately.
@@ -292,6 +295,8 @@ class DazClient:
         payload: dict = {"script": script}
         if args is not None:
             payload["args"] = args
+        if report_file is not None:
+            payload["reportFile"] = report_file
 
         def _do():
             resp = self._post("/execute/async", payload)
@@ -300,6 +305,53 @@ class DazClient:
 
         return self._with_busy_retry(_do, retry_on_busy, max_wait)
 
+    def execute_file_async_submit(
+        self, script_file: str, args: object = None, *, report_file: str | None = None,
+        retry_on_busy: bool = False, max_wait: float = 30.0
+    ) -> str:
+        """Submit a host-side ``.dsa`` file for asynchronous execution.
+
+        The file is loaded by DAZ Studio when the queued job starts, preserving
+        its filename for ``getScriptFileName()`` and relative ``include()``
+        calls. Returns the server-assigned request id immediately; use the
+        request status/result/cancel methods to manage its lifecycle.
+        """
+        payload: dict = {"scriptFile": script_file}
+        if args is not None:
+            payload["args"] = args
+        if report_file is not None:
+            payload["reportFile"] = report_file
+
+        def _do():
+            resp = self._post("/execute/async", payload)
+            _raise_for_error(resp)
+            return resp.json().get("request_id", "")
+
+        return self._with_busy_retry(_do, retry_on_busy, max_wait)
+
+    def execute_batch_async(
+        self, operations: list[dict], args: object = None, *, report_file: str | None = None
+    ) -> str:
+        """Submit multiple operations as one async request (one queue slot, one script).
+
+        Args:
+            operations: List of ``{"body_lines": [...], "result_expression": "..."}``
+                dicts — same shape as :meth:`~dazpy.Batch.add_operation`'s arguments.
+            args: Optional argument passed to the combined script.
+            report_file: Optional host-side JSONL file used for structured job
+                observation, as in :meth:`execute_async_submit`.
+
+        Returns:
+            The server-assigned ``request_id``. Poll it like any other async
+            request; the result's ``result`` field is a dict keyed ``"_r0"``,
+            ``"_r1"``, ... in submission order.
+        """
+        from ._batch import build_operations_script
+
+        pairs = [(op["body_lines"], op["result_expression"]) for op in operations]
+        script = build_operations_script(pairs)
+        return self.execute_async_submit(script, args=args, report_file=report_file)
+
     def get_request_status(self, request_id: str) -> dict:
         """Return the current status of an async request.
 
@@ -307,7 +359,9 @@ class DazClient:
             request_id: The ID returned by :meth:`execute_async_submit`.
 
         Returns:
-            A dict with at least a ``"status"`` key.  Possible values:
+            A dict with at least ``"status"`` and ``"observation"`` keys.
+            Observation contains structured progress, the bounded log tail,
+            and the output manifest. Possible status values:
             ``"queued"``, ``"running"``, ``"completed"``, ``"failed"``,
             ``"cancelled"``, or ``"not_found"``.
         """
@@ -328,7 +382,7 @@ class DazClient:
 
         Returns:
             A dict containing ``success``, ``result``, ``output``, ``error``,
-            ``duration_ms``, and ``status`` keys.
+            ``duration_ms``, ``status``, and ``observation`` keys.
         """
         params = {}
         if wait:

{dazpy-2.9.0 → dazpy-2.9.3}/dazpy/_client_aio.py

@@ -127,12 +127,15 @@ class AsyncDazClient:
         return await self._with_busy_retry(_do, retry_on_busy, max_wait)
 
     async def execute_async_submit(
-        self, script: str, args: object = None, *, retry_on_busy: bool = False, max_wait: float = 30.0
+        self, script: str, args: object = None, *, report_file: str | None = None,
+        retry_on_busy: bool = False, max_wait: float = 30.0
     ) -> str:
         """Submit a script for async execution. See :meth:`dazpy.DazClient.execute_async_submit`."""
         payload: dict = {"script": script}
         if args is not None:
             payload["args"] = args
+        if report_file is not None:
+            payload["reportFile"] = report_file
 
         async def _do():
             resp = await self._post("/execute/async", payload)
@@ -141,6 +144,39 @@ class AsyncDazClient:
 
         return await self._with_busy_retry(_do, retry_on_busy, max_wait)
 
+    async def execute_file_async_submit(
+        self, script_file: str, args: object = None, *, report_file: str | None = None,
+        retry_on_busy: bool = False, max_wait: float = 30.0
+    ) -> str:
+        """Submit a host-side ``.dsa`` file asynchronously.
+
+        See :meth:`dazpy.DazClient.execute_file_async_submit`.
+        """
+        payload: dict = {"scriptFile": script_file}
+        if args is not None:
+            payload["args"] = args
+        if report_file is not None:
+            payload["reportFile"] = report_file
+
+        async def _do():
+            resp = await self._post("/execute/async", payload)
+            _raise_for_error(resp)
+            return resp.json().get("request_id", "")
+
+        return await self._with_busy_retry(_do, retry_on_busy, max_wait)
+
+    async def execute_batch_async(
+        self, operations: list[dict], args: object = None, *, report_file: str | None = None
+    ) -> str:
+        """Submit multiple operations as one async request. See :meth:`dazpy.DazClient.execute_batch_async`."""
+        from ._batch import build_operations_script
+
+        pairs = [(op["body_lines"], op["result_expression"]) for op in operations]
+        script = build_operations_script(pairs)
+        return await self.execute_async_submit(
+            script, args=args, report_file=report_file
+        )
+
     async def get_request_status(self, request_id: str) -> dict:
         """See :meth:`dazpy.DazClient.get_request_status`."""
         resp = await self._get(f"/requests/{request_id}/status")