dazpy 2.6.0__tar.gz → 2.7.0__tar.gz

{dazpy-2.6.0 → dazpy-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dazpy
-Version: 2.6.0
+Version: 2.7.0
 Summary: Python SDK for the DAZ Studio Script Server
 License: MIT
 Project-URL: Homepage, https://github.com/bluemoonfoundry/daz-script-server

{dazpy-2.6.0 → dazpy-2.7.0}/dazpy/__init__.py

@@ -13,7 +13,7 @@ Typical usage::
     figure.find_bone("r_forearm").set_local_rotation(0, 0, 45)
 """
 
-__version__ = "2.6.0"
+__version__ = "2.7.0"
 
 from ._client import DazClient
 from ._scene import DazScene
@@ -25,8 +25,9 @@ from ._light import DazLight
 from ._material import DazMaterial
 from ._modifier import DazModifier
 from ._morph import DazMorph
+from ._dforce import DazDForce
 from ._geometry import DazGeometry
-from ._render import DazRenderSettings
+from ._render import DazRenderSettings, Canvas, RenderOutcome
 from ._viewport import DazViewport
 from ._timeline import DazTimeline
 from ._property import DazProperty
@@ -57,6 +58,9 @@ from ._interaction import (
     build_rig_profile,
     build_rig_profiles_from_snapshot,
     build_fight_recipe,
+    build_face_each_other_recipe,
+    build_handshake_recipe,
+    build_hug_recipe,
     build_kiss_recipe,
     build_sit_recipe,
     build_touch_recipe,
@@ -70,6 +74,7 @@ from ._interaction import (
 )
 from ._undo import UndoGroup
 from ._pose import DazPose
+from ._scene_state import DazSceneState
 from ._animation import DazAnimation
 from .math3 import Vec3, Quat, BoundingBox
 from ._result import ExecutionResult
@@ -83,6 +88,7 @@ from ._render_api import (
     render_variants,
 )
 from .exceptions import RenderError
+from ._scene_events import SceneEvent, watch_scene_events, wait_for_scene_event
 from . import exceptions
 
 __all__ = [
@@ -97,8 +103,11 @@ __all__ = [
     "DazMaterial",
     "DazModifier",
     "DazMorph",
+    "DazDForce",
     "DazGeometry",
     "DazRenderSettings",
+    "Canvas",
+    "RenderOutcome",
     "DazViewport",
     "DazTimeline",
     "DazProperty",
@@ -129,6 +138,9 @@ __all__ = [
     "build_rig_profile",
     "build_rig_profiles_from_snapshot",
     "build_fight_recipe",
+    "build_face_each_other_recipe",
+    "build_handshake_recipe",
+    "build_hug_recipe",
     "build_kiss_recipe",
     "build_sit_recipe",
     "build_touch_recipe",
@@ -141,6 +153,7 @@ __all__ = [
     "resolve_interaction_target",
     "UndoGroup",
     "DazPose",
+    "DazSceneState",
     "DazAnimation",
     "Vec3",
     "Quat",
@@ -154,5 +167,8 @@ __all__ = [
     "RenderError",
     "render",
     "render_variants",
+    "SceneEvent",
+    "watch_scene_events",
+    "wait_for_scene_event",
     "exceptions",
 ]

{dazpy-2.6.0 → dazpy-2.7.0}/dazpy/_camera.py

@@ -45,6 +45,33 @@ class DazCamera(DazNode):
     def depth_of_field(self, value: bool) -> None:
         self.set_property("Depth of Field", value)
 
+    @property
+    def lens_shift_x(self) -> float | None:
+        """Horizontal lens shift in millimetres (read/write).
+
+        Confirmed against a live instance: backed by ``DzCamera``'s
+        "Lens Shift X (mm)" property (``getLensShiftXControl()``), the same
+        value the render engine uses -- needed to match depth-based effects
+        (fog, DOF-driven line weight) to the actual render.
+        """
+        return self.get_property("Lens Shift X (mm)")
+
+    @lens_shift_x.setter
+    def lens_shift_x(self, value: float) -> None:
+        self.set_property("Lens Shift X (mm)", float(value))
+
+    @property
+    def lens_shift_y(self) -> float | None:
+        """Vertical lens shift in millimetres (read/write).
+
+        See :attr:`lens_shift_x`.
+        """
+        return self.get_property("Lens Shift Y (mm)")
+
+    @lens_shift_y.setter
+    def lens_shift_y(self, value: float) -> None:
+        self.set_property("Lens Shift Y (mm)", float(value))
+
     @property
     def frame_width(self) -> float | None:
         """Sensor / film-gate width in millimetres (read-only)."""

{dazpy-2.6.0 → dazpy-2.7.0}/dazpy/_client.py

@@ -37,11 +37,12 @@ def _map_response(resp: _requests.Response, script: str = "") -> ExecutionResult
 
     if not data.get("success", True):
         error_msg = data.get("error", "Script failed")
+        output = data.get("output", [])
         # SyntaxError comes from the parser; runtime errors (TypeError, ReferenceError,
         # Error, etc.) also include "Line N:" but never say "SyntaxError" explicitly.
         if "SyntaxError" in error_msg:
-            raise ScriptSyntaxError(error_msg, script=script, request_id=request_id)
-        raise ScriptRuntimeError(error_msg, script=script, request_id=request_id)
+            raise ScriptSyntaxError(error_msg, script=script, request_id=request_id, output=output)
+        raise ScriptRuntimeError(error_msg, script=script, request_id=request_id, output=output)
 
     return ExecutionResult(
         value=data.get("result"),
@@ -228,6 +229,25 @@ class DazClient:
             return {"status": "not_found"}
         return resp.json()
 
+    def list_requests(self, status: str | None = None) -> dict:
+        """List all tracked async requests (script and render) with their status.
+
+        Args:
+            status: Optional filter, one of ``"queued"``, ``"running"``,
+                ``"completed"``, ``"failed"``, ``"cancelled"``. Omit to list
+                requests in every status.
+
+        Returns:
+            A dict with a ``"requests"`` list (each item has ``request_id``,
+            ``status``, ``progress``, ``submitted_at``) plus ``total`` and a
+            per-status count for every status value.
+        """
+        params = {"status": status} if status else None
+        resp = self._get("/requests", params=params)
+        if resp.status_code in (401, 403):
+            raise AuthenticationError(f"HTTP {resp.status_code}: {resp.text[:200]}")
+        return resp.json()
+
     def cancel_request(self, request_id: str) -> bool:
         """Cancel a queued or running async request.
 
@@ -273,7 +293,7 @@ class DazClient:
             width: Image width in pixels (must be paired with *height*).
             height: Image height in pixels (must be paired with *width*).
             camera: Camera label to render from.
-            engine: Render engine (``"iray"``, ``"3delight"``, ``"filament"``).
+            engine: Render engine (``"iray"``, ``"filament"``).
             iray_samples: iRay sample count (0 = use scene default).
             reset_morphs: If ``True``, reset all morphs to defaults before applying.
 
@@ -331,6 +351,63 @@ class DazClient:
             raise AuthenticationError(f"HTTP {resp.status_code}: {resp.text[:200]}")
         return resp.json()
 
+    def render_animation_submit(
+        self,
+        output_path: str,
+        start_frame: int,
+        end_frame: int,
+        *,
+        frame_padding: int = 4,
+        width: int = 0,
+        height: int = 0,
+        camera: str = "",
+        engine: str = "",
+    ) -> dict:
+        """Submit an animation render job spanning a frame range and return immediately.
+
+        Renders each frame in ``[start_frame, end_frame]`` to a separate file,
+        as a single trackable async request (mirrors :meth:`render_submit`'s
+        request-tracking shape, not :meth:`render_batch_submit`'s fan-out).
+
+        Args:
+            output_path: Output path pattern containing the literal token
+                ``"{frame}"``, e.g. ``r"C:\\tmp\\anim\\frame_{frame}.png"``.
+                The token is replaced with the frame number, zero-padded to
+                *frame_padding* digits.
+            start_frame: First frame to render (inclusive).
+            end_frame: Last frame to render (inclusive).
+            frame_padding: Zero-padding width for the frame number (default ``4``).
+            width: Image width in pixels (must be paired with *height*).
+            height: Image height in pixels (must be paired with *width*).
+            camera: Camera label to render from.
+            engine: Render engine (``"iray"``, ``"filament"``).
+
+        Returns:
+            A dict with ``request_id``, ``status`` (``"queued"``), and
+            ``submitted_at`` keys.
+
+        Raises:
+            ConnectionError: If the server cannot be reached.
+            AuthenticationError: On HTTP 401/403.
+        """
+        payload: dict = {
+            "output_path": output_path,
+            "start_frame": start_frame,
+            "end_frame": end_frame,
+            "frame_padding": frame_padding,
+        }
+        if width and height:
+            payload["width"] = width
+            payload["height"] = height
+        if camera:
+            payload["camera"] = camera
+        if engine:
+            payload["engine"] = engine
+        resp = self._post("/render/animation", payload)
+        if resp.status_code in (401, 403):
+            raise AuthenticationError(f"HTTP {resp.status_code}: {resp.text[:200]}")
+        return resp.json()
+
     def cancel_render(self, request_id: str) -> bool:
         """Cancel a queued or running render job.
 
@@ -369,6 +446,40 @@ class DazClient:
         except _requests.exceptions.RequestException:
             return None
 
+    def stream_scene_events(
+        self,
+        categories: "list[str] | None" = None,
+        stream_timeout: "float | None" = None,
+    ) -> "object | None":
+        """Open the SSE stream for general scene-change events (GET /scene/events).
+
+        Args:
+            categories: Optional subset of event categories to subscribe to
+                (``"node"``, ``"skeleton"``, ``"light"``, ``"camera"``,
+                ``"selection"``, ``"scene"``, ``"time"``, ``"render"``).
+                ``None`` (default) subscribes to all categories.
+            stream_timeout: Socket timeout in seconds. ``None`` (default)
+                waits indefinitely — the server sends a keepalive comment
+                every 15 seconds, so the connection never idles out.
+
+        Returns:
+            A streaming :class:`requests.Response` on success, or ``None``
+            if the endpoint is unavailable. Callers must close the response
+            when done (e.g. via a ``with`` statement).
+        """
+        try:
+            params = {"filter": ",".join(categories)} if categories else None
+            resp = _requests.get(
+                f"{self._base}/scene/events",
+                headers=self._headers,
+                params=params,
+                stream=True,
+                timeout=stream_timeout,
+            )
+            return resp if resp.status_code == 200 else None
+        except _requests.exceptions.RequestException:
+            return None
+
     # ── USD export ────────────────────────────────────────────────────────────
 
     def export_usd_submit(
@@ -440,13 +551,34 @@ class DazClient:
     # ── Server health ─────────────────────────────────────────────────────────
 
     def status(self) -> dict:
-        """Return the server status dict from ``GET /status``."""
-        return self._get("/status").json()
+        """Return the server status dict from ``GET /status``.
+
+        Raises:
+            AuthenticationError: On HTTP 401/403.
+        """
+        resp = self._get("/status")
+        if resp.status_code in (401, 403):
+            raise AuthenticationError(f"HTTP {resp.status_code}: {resp.text[:200]}")
+        return resp.json()
 
     def health(self) -> dict:
-        """Return the health check dict from ``GET /health``."""
-        return self._get("/health").json()
+        """Return the health check dict from ``GET /health``.
+
+        Raises:
+            AuthenticationError: On HTTP 401/403.
+        """
+        resp = self._get("/health")
+        if resp.status_code in (401, 403):
+            raise AuthenticationError(f"HTTP {resp.status_code}: {resp.text[:200]}")
+        return resp.json()
 
     def metrics(self) -> dict:
-        """Return the metrics dict from ``GET /metrics``."""
-        return self._get("/metrics").json()
+        """Return the metrics dict from ``GET /metrics``.
+
+        Raises:
+            AuthenticationError: On HTTP 401/403.
+        """
+        resp = self._get("/metrics")
+        if resp.status_code in (401, 403):
+            raise AuthenticationError(f"HTTP {resp.status_code}: {resp.text[:200]}")
+        return resp.json()

dazpy-2.7.0/dazpy/_dforce.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from ._modifier import DazModifier
+from ._script_builder import ScriptBuilder
+
+
+class DazDForce(DazModifier):
+    """Proxy for a ``DzDForceModifier`` (cloth/hair dForce simulation modifier).
+
+    Returned by :meth:`DazNode.modifiers`, :meth:`DazNode.find_modifier`,
+    :meth:`DazNode.find_modifier_by_label`, and :meth:`DazNode.dforce_modifiers`
+    when the underlying DAZ modifier is a ``DzDForceModifier``.
+
+    Simulation tunables not covered by :attr:`freeze_simulation` (e.g.
+    ``"Dynamics Strength"``, ``"Contraction-Expansion Ratio"``, the various
+    stiffness weight maps) are still reachable through the inherited
+    :meth:`~dazpy.DazElement.get_property` / :meth:`~dazpy.DazElement.set_property`,
+    which look properties up by their Parameters-pane label.
+    """
+
+    @property
+    def freeze_simulation(self) -> bool | None:
+        """Whether the simulated result is frozen onto the mesh (read/write).
+
+        Freezing detaches the mesh from the live dForce solve so it holds its
+        current shape without needing to re-simulate — this is DAZ Studio's
+        equivalent of "baking" a dForce result.
+        """
+        script = ScriptBuilder.iife(f"""
+            var m = {self._locator};
+            if (!m) return null;
+            var p = m.findPropertyByLabel("Freeze Simulation");
+            return p ? p.getValue() : null;
+        """)
+        return self._client.execute(script).value
+
+    @freeze_simulation.setter
+    def freeze_simulation(self, value: bool) -> None:
+        flag = "true" if value else "false"
+        script = ScriptBuilder.iife(f"""
+            var m = {self._locator};
+            if (!m) return;
+            var p = m.findPropertyByLabel("Freeze Simulation");
+            if (p) p.setValue({flag});
+        """)
+        self._client.execute(script)
+
+    def freeze(self) -> None:
+        """Bake the current simulated result onto the mesh (sets ``freeze_simulation`` on)."""
+        self.freeze_simulation = True
+
+    def unfreeze(self) -> None:
+        """Release a frozen simulation so it resumes following the dForce solve."""
+        self.freeze_simulation = False

{dazpy-2.6.0 → dazpy-2.7.0}/dazpy/_element.py

@@ -78,6 +78,40 @@ class DazElement:
         """)
         return self._client.execute(script).value or []
 
+    def numeric_properties(self) -> dict[str, object]:
+        """Return every numeric property on this element as ``{label: value}``.
+
+        Unlike :meth:`list_properties`, this fetches labels and current
+        values for all numeric (float/int/bool) properties in a single HTTP
+        round-trip — use it instead of calling :meth:`get_property` in a
+        loop over ``list_properties()`` results.
+
+        Returns:
+            A dict mapping each numeric property's display label to its
+            current value.
+        """
+        script = ScriptBuilder.iife(f"""
+            var obj = {self._locator};
+            if (!obj) return null;
+            var result = {{}};
+            for (var i = 0; i < obj.getNumProperties(); i++) {{
+                var p = obj.getProperty(i);
+                if (p.inherits("DzNumericProperty")) {{
+                    result[p.getLabel()] = p.getValue();
+                }}
+            }}
+            return result;
+        """)
+        return self._client.execute(script).value or {}
+
+    @property
+    def class_name(self) -> str | None:
+        """The DazScript class name of this element (e.g. ``"DzFigure"``, ``"DzSpotLight"``)."""
+        script = ScriptBuilder.iife(
+            f"var obj = {self._locator}; return obj ? obj.className() : null;"
+        )
+        return self._client.execute(script).value
+
     def snapshot(self, fields: list[str]) -> dict:
         """Read and cache a set of property values in a single call.
 

{dazpy-2.6.0 → dazpy-2.7.0}/dazpy/_interaction.py

@@ -27,7 +27,7 @@ AnchorRole = Literal[
     "custom",
 ]
 InteractionKind = Literal["PoseTarget", "ContactTarget", "LookAtTarget", "BalanceTarget", "HandTarget", "FootTarget"]
-RecipeKind = Literal["sit", "touch", "kiss", "fight", "custom"]
+RecipeKind = Literal["sit", "touch", "kiss", "fight", "handshake", "hug", "face_each_other", "custom"]
 
 
 def _normalize_name(value: str | None) -> str:
@@ -1815,6 +1815,66 @@ def build_kiss_recipe(
     )
 
 
+def build_handshake_recipe(
+    actor_a: str,
+    actor_b: str,
+    *,
+    a_anchor: str = "r_hand",
+    b_anchor: str = "r_hand",
+) -> InteractionRecipe:
+    """Build a mirrored hand-to-hand greeting preset for two figures."""
+
+    return InteractionRecipe(
+        kind="handshake",
+        actors=[actor_a, actor_b],
+        constraints=[
+            LookAtTarget(actor_a, "head", (0.0, 0.0, 0.0)),
+            LookAtTarget(actor_b, "head", (0.0, 0.0, 0.0)),
+            HandTarget(actor_a, a_anchor, target_figure=actor_b, target_anchor=b_anchor),
+            HandTarget(actor_b, b_anchor, target_figure=actor_a, target_anchor=a_anchor),
+        ],
+        metadata={"interaction": "handshake"},
+    )
+
+
+def build_hug_recipe(
+    actor_a: str,
+    actor_b: str,
+    *,
+    a_anchor: str = "r_hand",
+    b_anchor: str = "r_hand",
+) -> InteractionRecipe:
+    """Build a mutual arms-around-each-other embrace preset for two figures."""
+
+    a_far_shoulder = "l_shoulder" if _side_from_name(a_anchor) == "right" else "r_shoulder"
+    b_far_shoulder = "l_shoulder" if _side_from_name(b_anchor) == "right" else "r_shoulder"
+    return InteractionRecipe(
+        kind="hug",
+        actors=[actor_a, actor_b],
+        constraints=[
+            LookAtTarget(actor_a, "head", (0.0, 0.0, 0.0)),
+            LookAtTarget(actor_b, "head", (0.0, 0.0, 0.0)),
+            HandTarget(actor_a, a_anchor, target_figure=actor_b, target_anchor=a_far_shoulder),
+            HandTarget(actor_b, b_anchor, target_figure=actor_a, target_anchor=b_far_shoulder),
+        ],
+        metadata={"interaction": "hug"},
+    )
+
+
+def build_face_each_other_recipe(actor_a: str, actor_b: str) -> InteractionRecipe:
+    """Build a mutual eye-contact preset for two figures, with no limb contact."""
+
+    return InteractionRecipe(
+        kind="face_each_other",
+        actors=[actor_a, actor_b],
+        constraints=[
+            LookAtTarget(actor_a, "head", (0.0, 0.0, 0.0)),
+            LookAtTarget(actor_b, "head", (0.0, 0.0, 0.0)),
+        ],
+        metadata={"interaction": "face_each_other"},
+    )
+
+
 def build_fight_recipe(
     attacker: str,
     defender: str,