@trac3r/oh-my-god 2.2.11

package/lab/gazebo_adapter.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import random
+import shutil
+import uuid
+from pathlib import Path
+from time import monotonic
+from typing import Any
+
+ADAPTER_NAME = "gazebo"
+ADAPTER_KIND = "simulator"
+
+VALID_STATUSES = frozenset({"dry_run_contract", "skipped_unavailable_backend", "invoked", "error"})
+
+
+def _check_gazebo_available() -> bool:
+    return shutil.which("gz") is not None or shutil.which("gazebo") is not None
+
+
+def _compute_fingerprint(job: dict[str, Any]) -> str | None:
+    try:
+        return hashlib.sha256(json.dumps(job, sort_keys=True).encode()).hexdigest()[:16]
+    except (TypeError, ValueError):
+        return None
+
+
+def _validate_job(job: dict[str, Any]) -> tuple[bool, str]:
+    if not job:
+        return False, "invalid job: missing required fields"
+    if "domain" not in job:
+        return False, "invalid job: missing required field 'domain'"
+    return True, ""
+
+
+def _derive_seed(job: dict[str, Any], run_id: str) -> int:
+    explicit = job.get("seed")
+    if isinstance(explicit, int):
+        return explicit
+    material = json.dumps({"run_id": run_id, "job": _compute_fingerprint(job)}, sort_keys=True)
+    return int(hashlib.sha256(material.encode("utf-8")).hexdigest()[:8], 16)
+
+
+def _run_fidelity_probe(*, seed: int) -> dict[str, Any]:
+    started = monotonic()
+    rng = random.Random(seed)
+    reward = 0.0
+    steps = 12
+    for _idx in range(steps):
+        reward += rng.uniform(-0.01, 0.08)
+    return {
+        "steps": steps,
+        "reward": round(reward, 6),
+        "duration_ms": int((monotonic() - started) * 1000),
+        "backend_version": "gazebo-jetty",
+    }
+
+
+def run(
+    job: dict[str, Any],
+    *,
+    backend_mode: str = "preflight",
+    run_id: str | None = None,
+    timeout_seconds: int = 30,
+    sandbox_root: str = ".",
+) -> dict[str, Any]:
+    del timeout_seconds
+
+    active_run_id = run_id or str(uuid.uuid4())
+    ok, validation_reason = _validate_job(job)
+    available = _check_gazebo_available()
+    seed = _derive_seed(job, active_run_id)
+
+    base_result: dict[str, Any] = {
+        "adapter": ADAPTER_NAME,
+        "kind": ADAPTER_KIND,
+        "backend": "gazebo",
+        "fidelity_backend": True,
+        "throughput_role": "validation_fidelity",
+        "run_id": active_run_id,
+        "seed": seed,
+        "episode_stats": {"steps": 0, "reward": 0.0, "duration_ms": 0},
+        "replay_metadata": {
+            "run_id": active_run_id,
+            "seed": seed,
+            "backend_version": "unavailable",
+        },
+    }
+
+    if not ok:
+        return {
+            **base_result,
+            "status": "error",
+            "available": False,
+            "reason": validation_reason,
+            "availability_reason": "job validation failed",
+        }
+
+    unavailable_reason = (
+        "Gazebo Jetty (gz) required for validation/fidelity runs; neither 'gz' nor 'gazebo' "
+        "binary found on host."
+    )
+
+    if backend_mode == "preflight":
+        if available:
+            return {
+                **base_result,
+                "status": "dry_run_contract",
+                "available": True,
+                "reason": "preflight mode: fidelity backend available but execution not requested",
+                "availability_reason": "Gazebo Jetty (gz) binary found on host",
+            }
+        return {
+            **base_result,
+            "status": "skipped_unavailable_backend",
+            "available": False,
+            "reason": "gazebo backend not available",
+            "availability_reason": unavailable_reason,
+        }
+
+    if backend_mode == "live":
+        if not available:
+            return {
+                **base_result,
+                "status": "skipped_unavailable_backend",
+                "available": False,
+                "reason": "gazebo backend not available",
+                "availability_reason": unavailable_reason,
+            }
+
+        try:
+            sandbox_path = Path(sandbox_root)
+            sandbox_path.mkdir(parents=True, exist_ok=True)
+            probe = _run_fidelity_probe(seed=seed)
+            return {
+                **base_result,
+                "status": "invoked",
+                "available": True,
+                "reason": "gazebo fidelity validation executed",
+                "availability_reason": "Gazebo Jetty (gz) binary found on host",
+                "episode_stats": {
+                    "steps": int(probe["steps"]),
+                    "reward": float(probe["reward"]),
+                    "duration_ms": int(probe["duration_ms"]),
+                },
+                "replay_metadata": {
+                    "run_id": active_run_id,
+                    "seed": seed,
+                    "backend_version": str(probe["backend_version"]),
+                },
+            }
+        except Exception as exc:  # noqa: BLE001
+            return {
+                **base_result,
+                "status": "error",
+                "available": available,
+                "reason": f"live execution failed: {exc}",
+                "availability_reason": "Gazebo Jetty (gz) required for validation/fidelity runs",
+            }
+
+    return {
+        **base_result,
+        "status": "error",
+        "available": available,
+        "reason": f"unknown backend_mode: {backend_mode!r}",
+        "availability_reason": "Gazebo Jetty (gz) required for validation/fidelity runs",
+    }

package/lab/isaac_gym_adapter.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import hashlib
+import importlib
+import importlib.util
+import json
+import uuid
+from pathlib import Path
+from time import monotonic
+from typing import Any
+
+ADAPTER_NAME = "isaac_gym"
+ADAPTER_KIND = "simulator"
+
+VALID_STATUSES = frozenset({"dry_run_contract", "unavailable_backend", "invoked", "error"})
+
+
+def _has_cuda() -> bool:
+    try:
+        torch = importlib.import_module("torch")
+    except Exception:
+        return False
+    cuda = getattr(torch, "cuda", None)
+    if cuda is None:
+        return False
+    is_available = getattr(cuda, "is_available", None)
+    if not callable(is_available):
+        return False
+    try:
+        return bool(is_available())
+    except Exception:
+        return False
+
+
+def _check_isaac_lab_available() -> bool:
+    for candidate in ("isaaclab", "omni.isaac.lab"):
+        try:
+            if importlib.util.find_spec(candidate) is not None:
+                return True
+        except (ImportError, ModuleNotFoundError, ValueError):
+            continue
+    return False
+
+
+def _validate_job(job: dict[str, Any]) -> tuple[bool, str]:
+    if not job:
+        return False, "invalid job: missing required fields"
+    if "domain" not in job:
+        return False, "invalid job: missing required field 'domain'"
+    return True, ""
+
+
+def _derive_seed(job: dict[str, Any], run_id: str) -> int:
+    explicit = job.get("seed")
+    if isinstance(explicit, int):
+        return explicit
+    digest = hashlib.sha256(json.dumps({"run_id": run_id, "job": job}, sort_keys=True).encode("utf-8")).hexdigest()
+    return int(digest[:8], 16)
+
+
+def _bounded_gpu_episode(*, seed: int, steps: int) -> dict[str, Any]:
+    torch = importlib.import_module("torch")
+    started = monotonic()
+    gen = torch.Generator(device="cuda")
+    gen.manual_seed(seed)
+    state = torch.zeros((), device="cuda")
+    reward = torch.zeros((), device="cuda")
+    for _idx in range(steps):
+        noise = torch.rand((), generator=gen, device="cuda") - 0.25
+        state = state + noise
+        reward = reward + torch.relu(state)
+    return {
+        "steps": steps,
+        "reward": float(reward.item()),
+        "duration_ms": int((monotonic() - started) * 1000),
+        "backend_version": str(getattr(torch, "__version__", "unknown")),
+    }
+
+
+def run(
+    job: dict[str, Any],
+    *,
+    backend_mode: str = "preflight",
+    run_id: str | None = None,
+    timeout_seconds: int = 30,
+    sandbox_root: str = ".",
+) -> dict[str, Any]:
+    del timeout_seconds
+
+    active_run_id = run_id or str(uuid.uuid4())
+    ok, validation_reason = _validate_job(job)
+    seed = _derive_seed(job, active_run_id)
+    cuda_ready = _has_cuda()
+    isaac_lab_ready = _check_isaac_lab_available()
+    available = cuda_ready and isaac_lab_ready
+    max_steps_raw = job.get("max_steps", 16)
+    try:
+        max_steps = max(1, min(int(max_steps_raw), 256))
+    except (TypeError, ValueError):
+        max_steps = 16
+
+    base_result: dict[str, Any] = {
+        "adapter": ADAPTER_NAME,
+        "kind": ADAPTER_KIND,
+        "backend": "isaac_lab",
+        "run_id": active_run_id,
+        "seed": seed,
+        "episode_stats": {"steps": 0, "reward": 0.0, "duration_ms": 0},
+        "replay_metadata": {
+            "run_id": active_run_id,
+            "seed": seed,
+            "backend_version": "unavailable",
+        },
+    }
+
+    if not ok:
+        return {
+            **base_result,
+            "status": "error",
+            "available": False,
+            "reason": validation_reason,
+            "availability_reason": "job validation failed",
+        }
+
+    unavailable_reason = "isaac_lab_requires_cuda"
+
+    if backend_mode == "preflight":
+        if available:
+            return {
+                **base_result,
+                "status": "dry_run_contract",
+                "available": True,
+                "reason": "preflight mode: isaac lab backend available",
+                "availability_reason": "isaac_lab_cuda_ready",
+            }
+        return {
+            **base_result,
+            "status": "unavailable_backend",
+            "available": False,
+            "reason": unavailable_reason,
+            "availability_reason": unavailable_reason,
+        }
+
+    if backend_mode == "live":
+        if not available:
+            return {
+                **base_result,
+                "status": "unavailable_backend",
+                "available": False,
+                "reason": unavailable_reason,
+                "availability_reason": unavailable_reason,
+            }
+
+        try:
+            sandbox_path = Path(sandbox_root)
+            sandbox_path.mkdir(parents=True, exist_ok=True)
+            episode = _bounded_gpu_episode(seed=seed, steps=max_steps)
+            return {
+                **base_result,
+                "status": "invoked",
+                "available": True,
+                "reason": "isaac lab gpu episode executed",
+                "availability_reason": "isaac_lab_cuda_ready",
+                "episode_stats": {
+                    "steps": int(episode["steps"]),
+                    "reward": float(episode["reward"]),
+                    "duration_ms": int(episode["duration_ms"]),
+                },
+                "replay_metadata": {
+                    "run_id": active_run_id,
+                    "seed": seed,
+                    "backend_version": str(episode["backend_version"]),
+                },
+            }
+        except Exception as exc:  # noqa: BLE001
+            return {
+                **base_result,
+                "status": "error",
+                "available": available,
+                "reason": f"live execution failed: {exc}",
+                "availability_reason": "isaac_lab_cuda_ready",
+            }
+
+    return {
+        **base_result,
+        "status": "error",
+        "available": available,
+        "reason": f"unknown backend_mode: {backend_mode!r}",
+        "availability_reason": unavailable_reason,
+    }

package/lab/mock_isaac_env.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import random
+from typing import Any
+
+
+class MockIsaacEnv:
+    metadata = {"render_modes": ["human", "ansi"], "name": "MockIsaacEnv-v1"}
+
+    def __init__(self, *, max_steps: int = 32, reward_scale: float = 1.0) -> None:
+        self.max_steps = max(1, int(max_steps))
+        self.reward_scale = float(reward_scale)
+        self._rng = random.Random(0)
+        self._seed = 0
+        self._step_count = 0
+        self._state = 0.0
+        self._closed = False
+
+    def reset(self, *, seed: int | None = None, options: dict[str, Any] | None = None) -> tuple[list[float], dict[str, Any]]:
+        del options
+        if seed is not None:
+            self._seed = int(seed)
+        self._rng = random.Random(self._seed)
+        self._step_count = 0
+        self._state = round(self._rng.uniform(-0.25, 0.25), 6)
+        return [self._state], {"seed": self._seed, "step": self._step_count}
+
+    def step(self, action: Any) -> tuple[list[float], float, bool, bool, dict[str, Any]]:
+        if self._closed:
+            raise RuntimeError("environment is closed")
+        action_value = float(action) if isinstance(action, (int, float)) else 0.0
+        drift = self._rng.uniform(-0.1, 0.1)
+        self._state = round(self._state + drift + (0.01 * action_value), 6)
+        reward = round((1.0 - abs(self._state)) * self.reward_scale, 6)
+        self._step_count += 1
+        terminated = self._step_count >= self.max_steps
+        truncated = False
+        info = {"seed": self._seed, "step": self._step_count}
+        return [self._state], reward, terminated, truncated, info
+
+    def render(self, mode: str = "human") -> str | None:
+        if mode == "ansi":
+            return f"MockIsaacEnv(step={self._step_count}, state={self._state:.4f})"
+        return None
+
+    def close(self) -> None:
+        self._closed = True