simrig 0.2.2__py3-none-any.whl

simrig/__init__.py

@@ -0,0 +1,82 @@
+"""SimRig public API."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from simrig._version import __version__
+from simrig.core import (
+    BackendInfo,
+    EnvInspectionReport,
+    ModelInspectionReport,
+    RunConfig,
+    SmokeResult,
+    TrainabilityStatus,
+)
+from simrig.mujoco_backend import inspect_model, list_models
+from simrig.playground_backend import (
+    demo_policy,
+    eval_policy,
+    inspect_env,
+    list_envs,
+    smoke_env,
+    train_ppo,
+)
+from simrig.scaffold import new_env
+from simrig.validate_env import EnvValidationResult, validate_env
+
+__all__ = [
+    "__version__",
+    "BackendInfo",
+    "EnvInspectionReport",
+    "EnvValidationResult",
+    "ModelInspectionReport",
+    "RunConfig",
+    "SmokeResult",
+    "TrainabilityStatus",
+    "demo_policy",
+    "eval_policy",
+    "inspect_env",
+    "inspect_model",
+    "is_env_module_path",
+    "list_envs",
+    "list_models",
+    "LiveWebViewer",
+    "load_custom_env",
+    "load_env",
+    "new_env",
+    "smoke_env",
+    "serve_model_view",
+    "serve_policy_preview",
+    "train_ppo",
+    "validate_env",
+]
+
+
+def __getattr__(name: str) -> Any:
+    """Lazy-load browser helpers so core imports work without numpy/mujoco."""
+    if name == "LiveWebViewer":
+        from simrig.live_view import LiveWebViewer
+
+        return LiveWebViewer
+    if name == "serve_model_view":
+        from simrig.model_view import serve_model_view
+
+        return serve_model_view
+    if name == "serve_policy_preview":
+        from simrig.preview import serve_policy_preview
+
+        return serve_policy_preview
+    if name == "is_env_module_path":
+        from simrig.custom_env import is_env_module_path
+
+        return is_env_module_path
+    if name == "load_custom_env":
+        from simrig.custom_env import load_custom_env
+
+        return load_custom_env
+    if name == "load_env":
+        from simrig.playground_backend import load_env
+
+        return load_env
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

simrig/_version.py

@@ -0,0 +1,3 @@
+"""Single source of truth for the SimRig package version."""
+
+__version__ = "0.2.2"

simrig/browser_render.py

@@ -0,0 +1,145 @@
+"""Background MuJoCo frame rendering for browser viewers."""
+
+from __future__ import annotations
+
+import threading
+import time
+from typing import Any, Callable
+
+import numpy as np
+
+from simrig.rendering import CameraState, create_mujoco_renderer
+
+
+def encode_jpeg(image_module: Any, frame: np.ndarray, *, quality: int = 72) -> bytes:
+    from io import BytesIO
+
+    image = image_module.fromarray(np.asarray(frame))
+    output = BytesIO()
+    image.save(output, format="JPEG", quality=quality, optimize=True)
+    return output.getvalue()
+
+
+class MujocoFramePump:
+    """Render MuJoCo frames on a dedicated thread and serve cached JPEGs."""
+
+    def __init__(
+        self,
+        mujoco: Any,
+        model: Any,
+        mj_data: Any,
+        *,
+        width: int,
+        height: int,
+        camera: Any,
+        camera_state: CameraState,
+        image_module: Any,
+        fps: int = 24,
+        jpeg_quality: int = 72,
+        render_mode: str = "mujoco",
+        scene_lock: threading.Lock | None = None,
+        before_render: Callable[[], None] | None = None,
+        fallback_frame: Callable[[], np.ndarray] | None = None,
+        error_frame: Callable[[str], np.ndarray] | None = None,
+    ) -> None:
+        self.mujoco = mujoco
+        self.model = model
+        self.mj_data = mj_data
+        self.width = width
+        self.height = height
+        self.camera = camera
+        self.camera_state = camera_state
+        self.image_module = image_module
+        self.fps = max(1, int(fps))
+        self.jpeg_quality = jpeg_quality
+        self.render_mode = render_mode.lower()
+        self.scene_lock = scene_lock or threading.Lock()
+        self.before_render = before_render
+        self.fallback_frame = fallback_frame
+        self.error_frame = error_frame
+
+        self.renderer_error: str | None = None
+        self._latest_jpeg: bytes = b""
+        self._camera_lock = threading.Lock()
+        self._running = True
+        self._thread = threading.Thread(target=self._run, name="simrig-frame-pump", daemon=True)
+        self._thread.start()
+
+    def set_camera_from_query(self, query: dict[str, list[str]]) -> None:
+        with self._camera_lock:
+            self.camera_state.update_from_query(query)
+            self.camera_state.apply(self.camera)
+
+    def get_jpeg(self) -> bytes:
+        return self._latest_jpeg
+
+    def stats(self) -> dict[str, Any]:
+        return {
+            "fps_target": self.fps,
+            "renderer_error": self.renderer_error,
+            "camera": self.camera_state.to_dict(),
+        }
+
+    def close(self) -> None:
+        self._running = False
+        self._thread.join(timeout=2.0)
+
+    def _run(self) -> None:
+        renderer = None
+        interval = 1.0 / self.fps
+        placeholder = np.zeros((self.height, self.width, 3), dtype=np.uint8)
+        self._latest_jpeg = encode_jpeg(self.image_module, placeholder, quality=self.jpeg_quality)
+
+        if self.render_mode == "mujoco":
+            try:
+                renderer = create_mujoco_renderer(
+                    self.mujoco,
+                    self.model,
+                    height=self.height,
+                    width=self.width,
+                )
+            except Exception as exc:
+                self.renderer_error = str(exc)
+
+        while self._running:
+            started = time.monotonic()
+            try:
+                with self.scene_lock:
+                    if self.before_render is not None:
+                        self.before_render()
+                    if self.render_mode == "topdown":
+                        if self.fallback_frame is None:
+                            raise RuntimeError("topdown mode requires fallback_frame.")
+                        frame = self.fallback_frame()
+                    elif renderer is None:
+                        message = self.renderer_error or "MuJoCo renderer unavailable."
+                        if self.error_frame is None:
+                            raise RuntimeError(message)
+                        frame = self.error_frame(message)
+                    else:
+                        with self._camera_lock:
+                            camera = self.camera_state.apply(self.camera)
+                        renderer.update_scene(self.mj_data, camera=camera)
+                        frame = renderer.render()
+                        self.renderer_error = None
+                self._latest_jpeg = encode_jpeg(
+                    self.image_module,
+                    frame,
+                    quality=self.jpeg_quality,
+                )
+            except Exception as exc:
+                self.renderer_error = str(exc)
+                if self.error_frame is not None:
+                    self._latest_jpeg = encode_jpeg(
+                        self.image_module,
+                        self.error_frame(str(exc)),
+                        quality=self.jpeg_quality,
+                    )
+            elapsed = time.monotonic() - started
+            time.sleep(max(0.0, interval - elapsed))
+
+        if renderer is not None:
+            try:
+                renderer.close()
+            except Exception:
+                pass

simrig/browser_shell.py

@@ -0,0 +1,130 @@
+"""Shared browser viewer HTML/CSS/JS for SimRig localhost tools."""
+
+from __future__ import annotations
+
+
+def viewer_styles(*, sidebar_width: int = 360) -> str:
+    return f"""
+    :root {{ color-scheme: dark; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }}
+    body {{ margin: 0; background: #111; color: #eee; display: grid; grid-template-columns: 1fr {sidebar_width}px; min-height: 100vh; }}
+    main {{ display: grid; place-items: stretch; background: #050505; position: relative; }}
+    #viewport {{ position: relative; width: 100%; height: 100vh; }}
+    #frame {{ width: 100%; height: 100%; object-fit: contain; background: #000; display: block; cursor: grab; user-select: none; touch-action: none; }}
+    #frame.dragging {{ cursor: grabbing; }}
+    #hint {{ position: absolute; left: 16px; bottom: 16px; color: #aaa; font-size: 12px; background: rgba(0,0,0,0.55); padding: 8px 10px; border-radius: 6px; pointer-events: none; }}
+    aside {{ padding: 16px; border-left: 1px solid #333; background: #181818; overflow: auto; max-height: 100vh; }}
+    h1 {{ font-size: 18px; margin: 0 0 12px; }}
+    label {{ display: block; margin: 10px 0 4px; color: #bbb; font-size: 13px; }}
+    input {{ width: 100%; box-sizing: border-box; background: #0d0d0d; color: #eee; border: 1px solid #444; padding: 8px; }}
+    button {{ margin: 8px 6px 0 0; padding: 8px 10px; background: #2d6cdf; color: white; border: 0; cursor: pointer; }}
+    button.secondary {{ background: #333; }}
+    pre {{ white-space: pre-wrap; background: #0d0d0d; border: 1px solid #333; padding: 10px; font-size: 12px; }}
+    .meta {{ color: #aaa; font-size: 12px; margin-bottom: 12px; }}
+    .control {{ margin: 0 0 14px; padding-bottom: 10px; border-bottom: 1px solid #2a2a2a; }}
+    .control label {{ margin-top: 0; }}
+    .control input[type=range] {{ width: 100%; }}
+    .value {{ color: #8ab4ff; font-size: 12px; margin-top: 4px; }}
+    """
+
+
+def camera_interaction_script() -> str:
+    return """
+    let cameraAzimuth = 135;
+    let cameraElevation = -20;
+    let cameraDistance = 2.4;
+    let cameraInteractive = true;
+    let dragging = false;
+    let lastX = 0;
+    let lastY = 0;
+    let cameraTimer = null;
+
+    function clamp(value, min, max) {
+      return Math.max(min, Math.min(max, value));
+    }
+
+    async function pushCamera() {
+      if (!cameraInteractive) return;
+      const params = new URLSearchParams({
+        azimuth: String(cameraAzimuth),
+        elevation: String(cameraElevation),
+        distance: String(cameraDistance),
+      });
+      try {
+        await fetch('/camera?' + params.toString(), {cache: 'no-store'});
+      } catch (err) {
+        console.warn('camera update failed', err);
+      }
+    }
+
+    function scheduleCameraPush() {
+      clearTimeout(cameraTimer);
+      cameraTimer = setTimeout(pushCamera, 30);
+    }
+
+    function bindCameraControls(frame) {
+      frame.addEventListener('mousedown', (event) => {
+        if (!cameraInteractive || event.button !== 0) return;
+        dragging = true;
+        frame.classList.add('dragging');
+        lastX = event.clientX;
+        lastY = event.clientY;
+      });
+      window.addEventListener('mouseup', () => {
+        if (!dragging) return;
+        dragging = false;
+        frame.classList.remove('dragging');
+        pushCamera();
+      });
+      window.addEventListener('mousemove', (event) => {
+        if (!dragging || !cameraInteractive) return;
+        const dx = event.clientX - lastX;
+        const dy = event.clientY - lastY;
+        lastX = event.clientX;
+        lastY = event.clientY;
+        cameraAzimuth = (cameraAzimuth + dx * 0.35) % 360;
+        cameraElevation = clamp(cameraElevation - dy * 0.25, -89, 89);
+        scheduleCameraPush();
+      });
+      frame.addEventListener('wheel', (event) => {
+        if (!cameraInteractive) return;
+        event.preventDefault();
+        const scale = event.deltaY > 0 ? 1.08 : 0.92;
+        cameraDistance = clamp(cameraDistance * scale, 0.4, 12.0);
+        scheduleCameraPush();
+      }, {passive: false});
+    }
+
+    function applyCameraFromStatus(status) {
+      if (!status || !status.camera) return;
+      cameraAzimuth = status.camera.azimuth ?? cameraAzimuth;
+      cameraElevation = status.camera.elevation ?? cameraElevation;
+      cameraDistance = status.camera.distance ?? cameraDistance;
+      cameraInteractive = status.camera.interactive !== false;
+    }
+    """
+
+
+def frame_poll_script(*, poll_ms: int = 33) -> str:
+    return f"""
+    let frameTimer = null;
+    let frameUrl = null;
+
+    async function refreshFrame() {{
+      clearTimeout(frameTimer);
+      try {{
+        const res = await fetch('/frame.jpg?t=' + Date.now(), {{cache: 'no-store'}});
+        if (!res.ok) throw new Error('frame request failed');
+        const blob = await res.blob();
+        const url = URL.createObjectURL(blob);
+        frame.onload = () => {{
+          if (frameUrl) URL.revokeObjectURL(frameUrl);
+          frameUrl = url;
+        }};
+        frame.src = url;
+      }} catch (err) {{
+        console.warn('frame refresh failed', err);
+      }} finally {{
+        frameTimer = setTimeout(refreshFrame, {poll_ms});
+      }}
+    }}
+    """