sim2sim-onepass 0.1.0__py3-none-any.whl

sim2sim_onepass/__init__.py

@@ -0,0 +1,3 @@
+from .version import __version__
+
+__all__ = ["__version__"]

sim2sim_onepass/cli.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from sim2sim_onepass.paths import get_repo_paths
+from sim2sim_onepass.utils.docs import first_lines, load_doc, repo_file_summary
+from sim2sim_onepass.version import __version__
+from sim2sim_onepass.wrappers.availability import report_environment, simulator_layout_available
+from sim2sim_onepass.wrappers.quick_sanity import resolve_default_paths, run_quick_sanity, run_quick_sanity_demo
+from sim2sim_onepass.wrappers.rollout import run_rollout_check
+
+
+def print_json(payload: object) -> int:
+    print(json.dumps(payload, indent=2))
+    return 0
+
+
+def cmd_info(_: argparse.Namespace) -> int:
+    paths = get_repo_paths()
+    payload = {
+        "project": "Sim2Sim-OnePass",
+        "version": __version__,
+        "package_identity": "lightweight companion package",
+        "repo_root": str(paths.root),
+        "canonical_outputs": str(paths.canonical_pass),
+        "pypi": "https://pypi.org/project/sim2sim-onepass/",
+        "docs": {label: str(path) for label, path in repo_file_summary()},
+        "website_branch": "gh-pages",
+        "package_scope": [
+            "repo navigation",
+            "embedded docs access",
+            "environment checks",
+            "quick sanity checks on paired datasets",
+            "thin rollout-check wrapper",
+            "guarded simulator workflow wrappers",
+        ],
+    }
+    return print_json(payload)
+
+
+def cmd_doc(name: str) -> int:
+    print(first_lines(load_doc(name), limit=80))
+    return 0
+
+
+def cmd_docs(_: argparse.Namespace) -> int:
+    for label, path in repo_file_summary():
+        print(f"{label}: {path}")
+    return 0
+
+
+def cmd_check_env(_: argparse.Namespace) -> int:
+    return print_json(report_environment())
+
+
+def cmd_quick_sanity(args: argparse.Namespace) -> int:
+    paths = get_repo_paths()
+    if args.demo:
+        return print_json(run_quick_sanity_demo())
+    default_b, default_m = resolve_default_paths(paths.root)
+    if args.bullet and args.mujoco:
+        bullet = Path(args.bullet)
+        mujoco = Path(args.mujoco)
+    elif default_b.exists() and default_m.exists():
+        bullet = default_b
+        mujoco = default_m
+    else:
+        raise RuntimeError(
+            "This command requires paired dataset inputs and does not run from package-only install by default.\n"
+            "Provide --bullet and --mujoco, or run `sim2sim-onepass quick-sanity --demo`."
+        )
+    return print_json(run_quick_sanity(bullet, mujoco))
+
+
+def cmd_alignment_gate(_: argparse.Namespace) -> int:
+    if not simulator_layout_available():
+        print(
+            "This command requires the full curated Sim2Sim-OnePass repository layout.\n"
+            "It also requires simulator dependencies and public-repo workflow files.\n"
+            "This command is not available in lightweight package-only mode.",
+            file=sys.stderr,
+        )
+        return 2
+    print(
+        "This command requires the full curated Sim2Sim-OnePass repository layout and simulator dependencies.\n"
+        "Use the source workspace command preserved in QUICKSTART.md.",
+        file=sys.stderr,
+    )
+    return 2
+
+
+def cmd_alignment_report(_: argparse.Namespace) -> int:
+    print(
+        "This command requires the full curated Sim2Sim-OnePass repository layout.\n"
+        "It depends on simulator collection scripts, paired dataset generation, and workflow files.\n"
+        "This command is not available in lightweight package-only mode.",
+        file=sys.stderr,
+    )
+    return 2
+
+
+def cmd_rollout_check(args: argparse.Namespace) -> int:
+    result = run_rollout_check(
+        bullet=Path(args.bullet),
+        mujoco=Path(args.mujoco),
+        model_path=Path(args.model),
+        norm_path=Path(args.norm),
+        horizon=args.horizon,
+        nstart=args.nstart,
+    )
+    return print_json(result)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="sim2sim-onepass",
+        description=(
+            "A lightweight companion package for the Sim2Sim-OnePass public research release.\n"
+            "It provides CLI access to documentation, results navigation, environment checks, and selected curated utilities."
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog=(
+            "Command categories:\n"
+            "  Standalone: info, quickstart, repo-map, results-summary, visual-index, docs, check-env\n"
+            "  Dataset-dependent: quick-sanity, rollout-check\n"
+            "  Full repo / simulator dependent: alignment-gate, alignment-report"
+        ),
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    sub.add_parser("info", help="[standalone] show package and repo overview")
+    sub.add_parser("quickstart", help="[standalone] print quickstart guidance")
+    sub.add_parser("repo-map", help="[standalone] print repo structure guidance")
+    sub.add_parser("results-summary", help="[standalone] print canonical result summary")
+    sub.add_parser("visual-index", help="[standalone] print visual evidence index")
+    sub.add_parser("docs", help="[standalone] list key packaged docs")
+    sub.add_parser("check-env", help="[standalone] report Python and optional dependency availability")
+    sub.add_parser(
+        "alignment-gate",
+        help="[full repo] guarded simulator workflow wrapper; not standalone",
+        description="Full repo / simulator dependent command.",
+    )
+    sub.add_parser(
+        "alignment-report",
+        help="[full repo] guarded report wrapper; not standalone",
+        description="Full repo / simulator dependent command.",
+    )
+
+    quick = sub.add_parser(
+        "quick-sanity",
+        help="[dataset] inspect paired datasets or run tiny built-in demo",
+        description="Dataset-dependent command. Use --demo for the tiny standalone fixture.",
+    )
+    quick.add_argument("--bullet", default="")
+    quick.add_argument("--mujoco", default="")
+    quick.add_argument("--demo", action="store_true", help="run the tiny built-in synthetic paired fixture")
+
+    rollout = sub.add_parser(
+        "rollout-check",
+        help="[dataset+rollout extra] run rollout error check from paired data/model/norm",
+        description="Dataset-dependent command. Requires paired data, model, norm file, and the optional rollout extra.",
+    )
+    rollout.add_argument("--bullet", required=True)
+    rollout.add_argument("--mujoco", required=True)
+    rollout.add_argument("--model", required=True)
+    rollout.add_argument("--norm", required=True)
+    rollout.add_argument("--horizon", type=int, default=50)
+    rollout.add_argument("--nstart", type=int, default=50)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    mapping = {
+        "info": cmd_info,
+        "quickstart": lambda _: cmd_doc("QUICKSTART.md"),
+        "repo-map": lambda _: cmd_doc("REPO_MAP.md"),
+        "results-summary": lambda _: cmd_doc("RESULTS_SUMMARY.md"),
+        "visual-index": lambda _: cmd_doc("VISUAL_INDEX.md"),
+        "docs": cmd_docs,
+        "check-env": cmd_check_env,
+        "quick-sanity": cmd_quick_sanity,
+        "alignment-gate": cmd_alignment_gate,
+        "alignment-report": cmd_alignment_report,
+        "rollout-check": cmd_rollout_check,
+    }
+    try:
+        return mapping[args.command](args)
+    except FileNotFoundError as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+    except RuntimeError as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sim2sim_onepass/paths.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+def find_repo_root(start: Path | None = None) -> Path:
+    here = (start or Path(__file__)).resolve()
+    for candidate in [here, *here.parents]:
+        if (candidate / "README.md").exists() and (candidate / "RESULTS_SUMMARY.md").exists():
+            return candidate
+    return here.parents[2]
+
+
+@dataclass(frozen=True)
+class RepoPaths:
+    root: Path
+    readme: Path
+    quickstart: Path
+    repo_map: Path
+    results_summary: Path
+    visual_index: Path
+    package_notes: Path
+    outputs: Path
+    canonical_pass: Path
+    scripts: Path
+    configs: Path
+
+
+def get_repo_paths(start: Path | None = None) -> RepoPaths:
+    root = find_repo_root(start)
+    return RepoPaths(
+        root=root,
+        readme=root / "README.md",
+        quickstart=root / "QUICKSTART.md",
+        repo_map=root / "REPO_MAP.md",
+        results_summary=root / "RESULTS_SUMMARY.md",
+        visual_index=root / "VISUAL_INDEX.md",
+        package_notes=root / "PYPI_PACKAGE_NOTES.md",
+        outputs=root / "outputs",
+        canonical_pass=root / "outputs" / "canonical_pass",
+        scripts=root / "scripts",
+        configs=root / "configs",
+    )

sim2sim_onepass/resources/QUICKSTART.md

@@ -0,0 +1,30 @@
+# Quickstart
+
+Install editable from the repo:
+
+```powershell
+python -m pip install -e .
+```
+
+Published PyPI install:
+
+```powershell
+python -m pip install sim2sim-onepass
+```
+
+Package page:
+
+```text
+https://pypi.org/project/sim2sim-onepass/
+```
+
+Standalone-safe first commands:
+
+```powershell
+sim2sim-onepass info
+sim2sim-onepass check-env
+sim2sim-onepass quickstart
+sim2sim-onepass quick-sanity --demo
+```
+
+For the full canonical docs and media paths, use the source repository checkout.

sim2sim_onepass/resources/README.md

@@ -0,0 +1,19 @@
+# Sim2Sim-OnePass Companion Package
+
+This installed package is a lightweight companion package for the public Sim2Sim-OnePass research release.
+
+It provides:
+
+- installable CLI access
+- embedded docs access
+- results navigation
+- environment checks
+- selected lightweight utilities
+- published package access via `https://pypi.org/project/sim2sim-onepass/`
+
+It does not provide by default:
+
+- full simulator environments
+- full datasets
+- full video/report artifacts
+- complete standalone simulator reproduction from pip install alone

sim2sim_onepass/resources/REPO_MAP.md

@@ -0,0 +1,8 @@
+# Repo Map
+
+This package ships a lightweight CLI and embedded markdown docs.
+
+- standalone package code lives under `src/sim2sim_onepass/`
+- canonical public docs stay in the source repository
+- heavy outputs and media are intentionally not embedded in the wheel
+- the website remains repo-based and is published separately

sim2sim_onepass/resources/RESULTS_SUMMARY.md

@@ -0,0 +1,9 @@
+# Results Summary
+
+The package can navigate to the canonical public results, but it does not embed the heavy media payload.
+
+Use the source repository checkout to inspect:
+
+- `RESULTS_SUMMARY.md`
+- `VISUAL_INDEX.md`
+- `outputs/canonical_pass/`

sim2sim_onepass/resources/VISUAL_INDEX.md

@@ -0,0 +1,10 @@
+# Visual Index
+
+The wheel keeps lightweight markdown only.
+
+For the full visual proof bundle, use the source repository checkout and inspect:
+
+- `VISUAL_INDEX.md`
+- `outputs/canonical_pass/preview/`
+- `outputs/canonical_pass/videos/`
+- `outputs/canonical_pass/plots/`

sim2sim_onepass/resources/__init__.py

@@ -0,0 +1 @@
+"""Embedded fallback docs for installed package users."""

sim2sim_onepass/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility helpers for the public package."""

sim2sim_onepass/utils/docs.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from importlib import resources
+from pathlib import Path
+
+from sim2sim_onepass.paths import get_repo_paths
+
+
+def load_doc(name: str) -> str:
+    paths = get_repo_paths()
+    repo_candidate = paths.root / name
+    if repo_candidate.exists():
+        return repo_candidate.read_text(encoding="utf-8")
+    return resources.files("sim2sim_onepass.resources").joinpath(name).read_text(encoding="utf-8")
+
+
+def first_lines(text: str, limit: int = 40) -> str:
+    lines = text.strip().splitlines()
+    return "\n".join(lines[:limit]).strip() + ("\n..." if len(lines) > limit else "")
+
+
+def repo_file_summary() -> list[tuple[str, Path]]:
+    paths = get_repo_paths()
+    return [
+        ("README", paths.readme),
+        ("QUICKSTART", paths.quickstart),
+        ("REPO_MAP", paths.repo_map),
+        ("RESULTS_SUMMARY", paths.results_summary),
+        ("VISUAL_INDEX", paths.visual_index),
+        ("PYPI_PACKAGE_NOTES", paths.package_notes),
+    ]

sim2sim_onepass/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

sim2sim_onepass/wrappers/__init__.py

@@ -0,0 +1 @@
+"""Thin public wrappers for curated workflows."""

sim2sim_onepass/wrappers/availability.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+
+from sim2sim_onepass.paths import get_repo_paths
+
+
+def python_info() -> dict[str, str]:
+    return {
+        "python": sys.executable,
+        "version": sys.version.split()[0],
+    }
+
+
+def module_available(name: str) -> bool:
+    return importlib.util.find_spec(name) is not None
+
+
+def simulator_layout_available() -> bool:
+    paths = get_repo_paths()
+    required = [
+        paths.root / "pybullet_panda_gap",
+        paths.root / "mujoco_panda_gap",
+        paths.root / "plans",
+    ]
+    return all(path.exists() for path in required)
+
+
+def report_environment() -> dict[str, object]:
+    paths = get_repo_paths()
+    return {
+        "python": python_info(),
+        "repo_root": str(paths.root),
+        "repo_docs_present": all(
+            p.exists()
+            for p in [
+                paths.readme,
+                paths.quickstart,
+                paths.repo_map,
+                paths.results_summary,
+                paths.visual_index,
+            ]
+        ),
+        "numpy": module_available("numpy"),
+        "torch": module_available("torch"),
+        "yaml": module_available("yaml"),
+        "simulator_layout": simulator_layout_available(),
+        "canonical_outputs": paths.canonical_pass.exists(),
+    }

sim2sim_onepass/wrappers/quick_sanity.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Tuple
+
+import numpy as np
+
+
+def demo_fixture() -> tuple[dict[str, np.ndarray], dict[str, np.ndarray]]:
+    S = np.array(
+        [
+            np.linspace(0.0, 0.36, 37, dtype=np.float32),
+            np.linspace(0.1, 0.46, 37, dtype=np.float32),
+            np.linspace(0.2, 0.56, 37, dtype=np.float32),
+        ],
+        dtype=np.float32,
+    )
+    A = np.array(
+        [
+            np.linspace(0.0, 0.06, 7, dtype=np.float32),
+            np.linspace(0.02, 0.08, 7, dtype=np.float32),
+            np.linspace(0.04, 0.10, 7, dtype=np.float32),
+        ],
+        dtype=np.float32,
+    )
+    bullet = {"S": S, "A": A, "S_next": S + 0.01}
+    mujoco = {"S": S + 0.001, "A": A, "S_next": S + 0.0125}
+    return bullet, mujoco
+
+
+def resolve_default_paths(root: Path) -> Tuple[Path, Path]:
+    candidates = [
+        (root / "data" / "paired_bullet_seed0.npz", root / "data" / "paired_mujoco_seed0.npz"),
+        (root / "data_pybullet" / "paired_bullet_seed0.npz", root / "data_mujoco" / "paired_mujoco_seed0.npz"),
+        (
+            root / "outputs" / "canonical_pass" / "source_stress_metrics.json",
+            root / "outputs" / "canonical_pass" / "source_stress_metrics.json",
+        ),
+    ]
+    for b, m in candidates[:2]:
+        if b.exists() and m.exists():
+            return b, m
+    return candidates[1]
+
+
+def load_npz(path: Path) -> tuple[np.lib.npyio.NpzFile, list[str]]:
+    data = np.load(path)
+    return data, list(data.keys())
+
+
+def describe_array(x: np.ndarray) -> dict[str, object]:
+    x = np.asarray(x)
+    finite = x[np.isfinite(x)]
+    return {
+        "shape": tuple(x.shape),
+        "dtype": str(x.dtype),
+        "nan": int(np.isnan(x).sum()),
+        "inf": int(np.isinf(x).sum()),
+        "min": float(finite.min()) if finite.size else None,
+        "max": float(finite.max()) if finite.size else None,
+        "mean": float(finite.mean()) if finite.size else None,
+        "std": float(finite.std()) if finite.size else None,
+    }
+
+
+def run_quick_sanity(bullet_path: Path, mujoco_path: Path) -> dict[str, object]:
+    if not bullet_path.exists():
+        raise FileNotFoundError(f"Bullet NPZ not found: {bullet_path}")
+    if not mujoco_path.exists():
+        raise FileNotFoundError(f"MuJoCo NPZ not found: {mujoco_path}")
+
+    b, bk = load_npz(bullet_path)
+    m, mk = load_npz(mujoco_path)
+
+    found = None
+    for s_key, a_key, sn_key in [("S", "A", "S_next"), ("obs", "act", "obs_next"), ("states", "actions", "next_states")]:
+        if s_key in b and a_key in b and sn_key in b and s_key in m and a_key in m and sn_key in m:
+            found = (s_key, a_key, sn_key)
+            break
+    if not found:
+        raise RuntimeError(f"Could not find canonical paired keys. Bullet keys={bk}; MuJoCo keys={mk}")
+
+    s_key, a_key, sn_key = found
+    Sb, Ab, Snb = b[s_key], b[a_key], b[sn_key]
+    Sm, Am, Snm = m[s_key], m[a_key], m[sn_key]
+
+    if Sb.shape != Sm.shape:
+        raise RuntimeError(f"State shape mismatch: {Sb.shape} vs {Sm.shape}")
+    if Ab.shape != Am.shape:
+        raise RuntimeError(f"Action shape mismatch: {Ab.shape} vs {Am.shape}")
+    if Snb.shape != Snm.shape:
+        raise RuntimeError(f"Next-state shape mismatch: {Snb.shape} vs {Snm.shape}")
+
+    drift_mean = np.abs(Sb.mean(axis=0) - Sm.mean(axis=0))
+    drift_std = np.abs(Sb.std(axis=0) - Sm.std(axis=0))
+    drift_score = drift_mean + drift_std
+    top = np.argsort(-drift_score)[:10]
+    err = np.linalg.norm(Snb - Snm, axis=1)
+
+    return {
+        "mode": "dataset",
+        "keys": {"bullet": bk, "mujoco": mk, "selected": [s_key, a_key, sn_key]},
+        "bullet": {
+            s_key: describe_array(Sb),
+            a_key: describe_array(Ab),
+            sn_key: describe_array(Snb),
+        },
+        "mujoco": {
+            s_key: describe_array(Sm),
+            a_key: describe_array(Am),
+            sn_key: describe_array(Snm),
+        },
+        "one_step": {
+            "mean": float(err.mean()),
+            "median": float(np.median(err)),
+            "p95": float(np.quantile(err, 0.95)),
+            "max": float(err.max()),
+        },
+        "top_drift_dims": [
+            {
+                "dim": int(i),
+                "score": float(drift_score[i]),
+                "mean_gap": float(drift_mean[i]),
+                "std_gap": float(drift_std[i]),
+            }
+            for i in top
+        ],
+    }
+
+
+def run_quick_sanity_demo() -> dict[str, object]:
+    b, m = demo_fixture()
+    Sb, Ab, Snb = b["S"], b["A"], b["S_next"]
+    Sm, Am, Snm = m["S"], m["A"], m["S_next"]
+    drift_mean = np.abs(Sb.mean(axis=0) - Sm.mean(axis=0))
+    drift_std = np.abs(Sb.std(axis=0) - Sm.std(axis=0))
+    drift_score = drift_mean + drift_std
+    top = np.argsort(-drift_score)[:10]
+    err = np.linalg.norm(Snb - Snm, axis=1)
+
+    return {
+        "mode": "demo",
+        "keys": {"bullet": ["S", "A", "S_next"], "mujoco": ["S", "A", "S_next"], "selected": ["S", "A", "S_next"]},
+        "bullet": {"S": describe_array(Sb), "A": describe_array(Ab), "S_next": describe_array(Snb)},
+        "mujoco": {"S": describe_array(Sm), "A": describe_array(Am), "S_next": describe_array(Snm)},
+        "one_step": {
+            "mean": float(err.mean()),
+            "median": float(np.median(err)),
+            "p95": float(np.quantile(err, 0.95)),
+            "max": float(err.max()),
+        },
+        "top_drift_dims": [
+            {
+                "dim": int(i),
+                "score": float(drift_score[i]),
+                "mean_gap": float(drift_mean[i]),
+                "std_gap": float(drift_std[i]),
+            }
+            for i in top
+        ],
+        "note": "Built-in tiny synthetic paired fixture for package-only smoke testing.",
+    }

sim2sim_onepass/wrappers/rollout.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import numpy as np
+
+from sim2sim_onepass.wrappers.state_project import project_state
+
+
+def _require_torch():
+    try:
+        import torch
+        import torch.nn as nn
+    except ImportError as exc:
+        raise RuntimeError("rollout-check requires PyTorch. Install with `pip install sim2sim-onepass[rollout]`.") from exc
+    return torch, nn
+
+
+def load_npz(path: Path) -> dict[str, np.ndarray]:
+    data = np.load(path)
+    return {k: data[k] for k in data.files}
+
+
+class DeltaMLP:
+    def __init__(self, nn, in_dim: int, out_dim: int) -> None:
+        self.net = nn.Sequential(
+            nn.Linear(in_dim, 256),
+            nn.ReLU(),
+            nn.Linear(256, 256),
+            nn.ReLU(),
+            nn.Linear(256, out_dim),
+        )
+
+    def __call__(self, x):
+        return self.net(x)
+
+
+def build_model(nn, in_dim: int, out_dim: int):
+    class DeltaMoE(nn.Module):
+        def __init__(self) -> None:
+            super().__init__()
+            self.free = DeltaMLP(nn, in_dim, out_dim).net
+            self.contact = DeltaMLP(nn, in_dim, out_dim).net
+            self.gate = nn.Sequential(
+                nn.Linear(in_dim, 128),
+                nn.ReLU(),
+                nn.Linear(128, 1),
+                nn.Sigmoid(),
+            )
+
+        def forward(self, x):
+            gate = self.gate(x)
+            free_pred = self.free(x)
+            contact_pred = self.contact(x)
+            return contact_pred * gate + free_pred * (1.0 - gate)
+
+    return DeltaMoE()
+
+
+def decide_units(pred: np.ndarray, delta_std: np.ndarray) -> str:
+    pred_std = pred.std(axis=0).mean()
+    delta_std_mean = delta_std.mean()
+    if delta_std_mean == 0:
+        return "ambiguous"
+    ratio = pred_std / delta_std_mean
+    if 0.3 <= ratio <= 3.0:
+        return "original"
+    if 0.03 <= ratio < 0.3:
+        return "normalized"
+    return "ambiguous"
+
+
+def run_rollout_check(
+    bullet: Path,
+    mujoco: Path,
+    model_path: Path,
+    norm_path: Path,
+    horizon: int = 50,
+    nstart: int = 50,
+) -> dict[str, float | str]:
+    torch, nn = _require_torch()
+    b = load_npz(bullet)
+    m = load_npz(mujoco)
+    for key in ("S", "A", "S_next", "episode_id", "t"):
+        if key not in b or key not in m:
+            raise RuntimeError(f"missing key {key}")
+
+    Sb = b["S"].astype(np.float32)
+    Ab = b["A"].astype(np.float32)
+    Snb = b["S_next"].astype(np.float32)
+    Snm = m["S_next"].astype(np.float32)
+    ep = b["episode_id"].astype(int)
+    t = b["t"].astype(int)
+
+    in_dim = Sb.shape[1] + Ab.shape[1]
+    out_dim = Snb.shape[1]
+    model = build_model(nn, in_dim, out_dim)
+    model.load_state_dict(torch.load(model_path, map_location="cpu"))
+    model.eval()
+
+    norm = json.loads(norm_path.read_text(encoding="utf-8"))
+    delta_mean = np.array(norm.get("delta_mean"), dtype=np.float32)
+    delta_std = np.array(norm.get("delta_std"), dtype=np.float32)
+
+    unique_eps = np.unique(ep)
+    rng = np.random.default_rng(0)
+    starts: list[int] = []
+    for e in unique_eps:
+        idx = np.where(ep == e)[0]
+        if idx.size < horizon + 1:
+            continue
+        order = np.argsort(t[idx])
+        idx = idx[order]
+        max_start = idx.size - horizon
+        if max_start <= 0:
+            continue
+        for _ in range(2):
+            starts.append(int(idx[rng.integers(0, max_start)]))
+    if not starts:
+        raise RuntimeError("no valid rollout starts")
+    rng.shuffle(starts)
+    starts = starts[:nstart]
+
+    sample_idx = np.array(starts[: min(len(starts), 10)])
+    X_sample = np.concatenate([Sb[sample_idx], Ab[sample_idx]], axis=1)
+    with torch.no_grad():
+        pred_sample = model(torch.from_numpy(X_sample).float()).numpy()
+    units = decide_units(pred_sample, delta_std)
+    if units == "ambiguous":
+        raise RuntimeError("cannot confidently determine model output units")
+
+    def pred_delta(x: np.ndarray) -> np.ndarray:
+        with torch.no_grad():
+            pred = model(torch.from_numpy(x).float()).numpy()
+        if units == "normalized":
+            return pred * delta_std + delta_mean
+        return pred
+
+    errs: list[float] = []
+    for s in starts:
+        e = ep[s]
+        idx = np.where(ep == e)[0]
+        order = np.argsort(t[idx])
+        idx = idx[order]
+        pos = int(np.where(idx == s)[0][0])
+        if pos + horizon > idx.size:
+            continue
+        for k in range(horizon):
+            i = idx[pos + k]
+            x = np.concatenate([Sb[i], Ab[i]], axis=0)[None, :]
+            delta = pred_delta(x)[0]
+            pred_state = project_state(Snb[i] + delta)
+            if not np.isfinite(pred_state).all():
+                raise RuntimeError(f"NaN/Inf at start={s} step={k}")
+            errs.append(float(np.linalg.norm(pred_state - Snm[i])))
+
+    if not errs:
+        raise RuntimeError("no rollout errors computed")
+    arr = np.asarray(errs, dtype=np.float32)
+    return {
+        "horizon": int(horizon),
+        "nstart": int(nstart),
+        "units": units,
+        "mean": float(arr.mean()),
+        "p95": float(np.quantile(arr, 0.95)),
+        "max": float(arr.max()),
+    }

sim2sim_onepass/wrappers/state_project.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import numpy as np
+
+STATE_DIM = 37
+Q_SLICE = slice(0, 7)
+DQ_SLICE = slice(7, 14)
+EE_POS_SLICE = slice(14, 17)
+EE_QUAT_SLICE = slice(17, 21)
+OBJ_POS_SLICE = slice(21, 24)
+OBJ_QUAT_SLICE = slice(24, 28)
+OBJ_LINVEL_SLICE = slice(28, 31)
+OBJ_ANGVEL_SLICE = slice(31, 34)
+CONTACT_FLAG_IDX = 34
+CONTACT_FORCE_IDX = 35
+MIN_DIST_IDX = 36
+VEL_LIMIT = 5.0
+
+
+def _wrap_angles(x: np.ndarray) -> np.ndarray:
+    return (x + np.pi) % (2.0 * np.pi) - np.pi
+
+
+def _renorm_quat(q: np.ndarray) -> np.ndarray:
+    norm = np.linalg.norm(q, axis=-1, keepdims=True)
+    safe = norm[..., 0] >= 1e-6
+    qn = np.zeros_like(q, dtype=np.float32)
+    qn[safe] = q[safe] / norm[safe]
+    qn[~safe] = np.array([0.0, 0.0, 0.0, 1.0], dtype=np.float32)
+    return qn
+
+
+def project_state(state: np.ndarray) -> np.ndarray:
+    state = np.asarray(state, dtype=np.float32)
+    if state.shape[-1] != STATE_DIM:
+        raise ValueError(f"Expected last dim {STATE_DIM}, got {state.shape}")
+    squeeze = state.ndim == 1
+    if squeeze:
+        state = state[None, :]
+    out = state.copy()
+    out[:, Q_SLICE] = _wrap_angles(out[:, Q_SLICE])
+    out[:, EE_QUAT_SLICE] = _renorm_quat(out[:, EE_QUAT_SLICE])
+    out[:, OBJ_QUAT_SLICE] = _renorm_quat(out[:, OBJ_QUAT_SLICE])
+    out[:, EE_POS_SLICE] = np.clip(out[:, EE_POS_SLICE], -2.0, 2.0)
+    out[:, OBJ_POS_SLICE] = np.clip(out[:, OBJ_POS_SLICE], -2.0, 2.0)
+    out[:, DQ_SLICE] = np.clip(out[:, DQ_SLICE], -VEL_LIMIT, VEL_LIMIT)
+    out[:, OBJ_LINVEL_SLICE] = np.clip(out[:, OBJ_LINVEL_SLICE], -VEL_LIMIT, VEL_LIMIT)
+    out[:, OBJ_ANGVEL_SLICE] = np.clip(out[:, OBJ_ANGVEL_SLICE], -VEL_LIMIT, VEL_LIMIT)
+    out[:, CONTACT_FLAG_IDX] = np.clip(out[:, CONTACT_FLAG_IDX], 0.0, 1.0)
+    out[:, CONTACT_FORCE_IDX] = np.clip(out[:, CONTACT_FORCE_IDX], 0.0, 50.0)
+    out[:, MIN_DIST_IDX] = np.clip(out[:, MIN_DIST_IDX], 0.0, 2.0)
+    return out[0] if squeeze else out

sim2sim_onepass-0.1.0.dist-info/METADATA

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: sim2sim-onepass
+Version: 0.1.0
+Summary: A lightweight companion package for the Sim2Sim-OnePass public research release.
+Author: ANTHONY-OLEVESTER
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/ANTHONY-OLEVESTER/Robotics_sim-to-sim_OnePass
+Project-URL: Repository, https://github.com/ANTHONY-OLEVESTER/Robotics_sim-to-sim_OnePass
+Project-URL: Documentation, https://github.com/ANTHONY-OLEVESTER/Robotics_sim-to-sim_OnePass
+Project-URL: Issues, https://github.com/ANTHONY-OLEVESTER/Robotics_sim-to-sim_OnePass/issues
+Keywords: robotics,simulation,mujoco,pybullet,research
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Provides-Extra: rollout
+Requires-Dist: torch>=2.0; extra == "rollout"
+Provides-Extra: alignment
+Requires-Dist: PyYAML>=6.0; extra == "alignment"
+Provides-Extra: dev
+Requires-Dist: build>=1.2.2; extra == "dev"
+Requires-Dist: twine>=5.1.1; extra == "dev"
+Dynamic: license-file
+
+# Sim2Sim-OnePass Public Release
+
+This curated layer is the fast path through the repository. It is designed so a new visitor can understand the claim, watch the evidence, inspect the canonical PASS artifacts, and run the shortest validation path without digging through the full development history.
+
+## Companion Package
+
+This branch adds a PyPI-ready package layer named `sim2sim-onepass`. It is a lightweight companion package for the public research release, not a standalone robotics simulator system. It provides an installable CLI, embedded docs access, results navigation, environment checks, and selected lightweight utilities around the curated repo.
+
+Local editable install:
+
+```powershell
+python -m pip install -e .
+```
+
+Published PyPI install:
+
+```powershell
+python -m pip install sim2sim-onepass
+```
+
+PyPI package page:
+
+```text
+https://pypi.org/project/sim2sim-onepass/
+```
+
+CLI entrypoint:
+
+```powershell
+sim2sim-onepass --help
+```
+
+What the package does provide:
+
+- repo navigation and public documentation access
+- embedded lightweight markdown docs
+- environment checking
+- quick sanity checks on paired datasets
+- rollout-check wrapper for model + norm + paired data paths
+- guarded simulator workflow commands with clear errors when the full simulator stack is not present
+
+What the package does not provide by default:
+
+- full simulator environments
+- full datasets
+- giant reports dumps
+- replay videos and large binary outputs
+- local environments and machine-specific folders
+- the full simulator env trees and internal training workspace
+
+## Command Capability Levels
+
+| Command | Category | Requirements |
+| --- | --- | --- |
+| `info` | Standalone | package install only |
+| `quickstart` | Standalone | package install only |
+| `repo-map` | Standalone | package install only |
+| `results-summary` | Standalone | package install only |
+| `visual-index` | Standalone | package install only |
+| `docs` | Standalone | package install only |
+| `check-env` | Standalone | package install only |
+| `quick-sanity` | Dataset-dependent | paired datasets, or `--demo` for the tiny built-in fixture |
+| `rollout-check` | Dataset-dependent | paired datasets, model, norm file, and optional extra `sim2sim-onepass[rollout]` |
+| `alignment-gate` | Full repo / simulator dependent | full curated repo layout plus simulator dependencies |
+| `alignment-report` | Full repo / simulator dependent | full curated repo layout plus simulator dependencies and workflow files |
+
+## Pick Your Route
+
+| If you want to... | Open this |
+| --- | --- |
+| See the project in one screen | [RESULTS_SUMMARY.md](RESULTS_SUMMARY.md) |
+| Watch the visual evidence first | [VISUAL_INDEX.md](VISUAL_INDEX.md) |
+| Run the shortest validation path | [QUICKSTART.md](QUICKSTART.md) |
+| Inspect the packaged PASS bundle | [outputs/canonical_pass/](outputs/canonical_pass/) |
+| Understand how the repo is organized | [REPO_MAP.md](REPO_MAP.md) |
+
+## See It Before You Read It
+
+| Triptych preview | Rollout figure |
+| --- | --- |
+| [![Triptych preview](outputs/canonical_pass/preview/triptych_frame0.png)](outputs/canonical_pass/preview/triptych_frame0.png) | [![Rollout figure](outputs/canonical_pass/plots/rollout_phys_p95.png)](outputs/canonical_pass/plots/rollout_phys_p95.png) |
+
+Open the full visual package here:
+
+- [VISUAL_INDEX.md](VISUAL_INDEX.md)
+- [outputs/canonical_pass/videos/compare_triptych.mp4](outputs/canonical_pass/videos/compare_triptych.mp4)
+- [outputs/canonical_pass/report.md](outputs/canonical_pass/report.md)
+
+## The Claim In Plain Terms
+
+After enforcing deterministic cross-simulator alignment between PyBullet and MuJoCo, this repo learns a residual next-state correction that:
+
+- reduces Bullet-to-MuJoCo one-step physical error,
+- remains stable under long-horizon rollout checks,
+- passes holdout and alignment gates,
+- and can be inspected visually through replay videos, triptychs, and overlay plots.
+
+## Canonical Story
+
+1. Deterministic paired plans are executed in PyBullet and MuJoCo.
+2. A strict alignment gate blocks training if reset state, timing, or first-step consistency drift.
+3. A residual model predicts the MuJoCo-minus-Bullet next-state gap.
+4. Hard-mode stress evaluation verifies one-step accuracy, holdouts, and rollout stability.
+5. Behavioral acceptance exports replay videos, triptychs, and overlay plots for inspection.
+
+## Canonical Evidence
+
+- Quantitative anchor: packaged in `outputs/canonical_pass/source_stress_report.md` and `outputs/canonical_pass/source_stress_metrics.json`
+- Visual anchor: packaged in `outputs/canonical_pass/source_behavioral_report.md` and the copied videos and preview images
+- Public-facing copied bundle: [outputs/canonical_pass/](outputs/canonical_pass/)
+- Provenance map: [configs/canonical_sources.json](configs/canonical_sources.json)
+
+## Exact Quickstart
+
+This public repo is optimized for inspection first. Open [QUICKSTART.md](QUICKSTART.md) for the shortest path through the packaged evidence and for command references preserved from the source workspace.
+
+## What Lives Where
+
+- [outputs/canonical_pass/](outputs/canonical_pass/) contains the reviewer-facing proof artifacts.
+- [examples/canonical_commands.ps1](examples/canonical_commands.ps1) contains exact rerun commands.
+- [docs/CANONICAL_SOURCES.md](docs/CANONICAL_SOURCES.md) records provenance.
+- [docs/PUBLISHING.md](docs/PUBLISHING.md) defines what to ship in a public release.
+- The interactive website is published from the `gh-pages` branch.
+- Package implementation lives under `src/sim2sim_onepass/`.
+- License is [Apache-2.0](LICENSE).

sim2sim_onepass-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+sim2sim_onepass/__init__.py,sha256=v3x5oBkxwKJEZLv62QqSmP3iqNKLtZgrWZfH8eFzlQg,60
+sim2sim_onepass/cli.py,sha256=XlXSmzxnQjrjSXkRmNuChKR-pPKnqZSXWGjyB6rlFAg,7671
+sim2sim_onepass/paths.py,sha256=RexqsR1JtFlnXErnMrsz0rZ91tpmPkSTGJlRNrjbc1Q,1236
+sim2sim_onepass/version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+sim2sim_onepass/resources/QUICKSTART.md,sha256=_UtBSMQnReExxYay7wsczpcRpnx8GaQutU8WQZxO29w,488
+sim2sim_onepass/resources/README.md,sha256=EAUFsHtI6WpYEmp5YZfDxhJ5S2v2ctT5mAY5Ggfri58,535
+sim2sim_onepass/resources/REPO_MAP.md,sha256=2gL5G-3dQP3PwCpZouvAoxLiEvYUpVwTrbFmYs4A1-M,324
+sim2sim_onepass/resources/RESULTS_SUMMARY.md,sha256=WMpT0yL6J6SEVR-mrl8OewJ884X8TYgXBSqogV5OeJ0,244
+sim2sim_onepass/resources/VISUAL_INDEX.md,sha256=dYLu0mOQX2Gbf6qRcmgKBpE6ytwGJv_a_jObAYqwspA,268
+sim2sim_onepass/resources/__init__.py,sha256=yzu-6U8H6kSaYEdsxuy0Ed-WrUfHxpnSJ1wAKQAhZF8,58
+sim2sim_onepass/utils/__init__.py,sha256=kVHealcnpW7tQIPTax1nEOF_WPAMYSV8dg0P_LhzHu0,46
+sim2sim_onepass/utils/docs.py,sha256=46PU5c5GMbPn_qdUOQs1w28TlAvHnCekDAUGwB8LYw8,978
+sim2sim_onepass/wrappers/__init__.py,sha256=1QvoS4C-g77eI8c74Wur-JQ9qtUNOU87DjqKd2dY9iM,50
+sim2sim_onepass/wrappers/availability.py,sha256=zfr1amaw6z4RW5yBb6W3w_hbk5bocSLJM68nuMM8w44,1329
+sim2sim_onepass/wrappers/quick_sanity.py,sha256=nEdue9EtldtFYQTHkCNqc5DgLBhEPsoCiHuDg16p_hw,5776
+sim2sim_onepass/wrappers/rollout.py,sha256=YMAfPyIA_m_1XPasCIHWg3X0ViadDfA8_w9FxB05rEI,5165
+sim2sim_onepass/wrappers/state_project.py,sha256=mfevHUcpyc0KWrne0FhqsspMyJEkzIouIYPBYxs8xOM,1914
+sim2sim_onepass-0.1.0.dist-info/licenses/LICENSE,sha256=lJ0vnK1Rqyj2IWRh9eU4g5hm7BA2Hl986eP9foo9jac,6131
+sim2sim_onepass-0.1.0.dist-info/METADATA,sha256=fvd7nXH5rR_8_wgh0S0f1WymMvB7A5EPWUCiCXsa2OU,7094
+sim2sim_onepass-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sim2sim_onepass-0.1.0.dist-info/entry_points.txt,sha256=mYsgd-l4YxpXMa1Hj6dmz2aflkq47e15XlaKfTccaZI,61
+sim2sim_onepass-0.1.0.dist-info/top_level.txt,sha256=Lr7UmBESV7svgOH8JVEsF2QjwVLtpvYUNYhCGo-0atA,16
+sim2sim_onepass-0.1.0.dist-info/RECORD,,

sim2sim_onepass-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sim2sim_onepass-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sim2sim-onepass = sim2sim_onepass.cli:main

sim2sim_onepass-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,118 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+"Control" means (i) the power, direct or indirect, to cause the direction or
+management of such entity, whether by contract or otherwise, or (ii) ownership
+of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial
+ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work.
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner.
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License,
+each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section) patent
+license to make, have made, use, offer to sell, sell, import, and otherwise
+transfer the Work.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and in
+Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You
+distribute, all copyright, patent, trademark, and attribution notices from the
+Source form of the Work, excluding those notices that do not pertain to any part
+of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution, then
+any Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License, without any
+additional terms or conditions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as required
+for reasonable and customary use in describing the origin of the Work.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied, including, without
+limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT,
+MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible
+for determining the appropriateness of using or redistributing the Work.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+tort (including negligence), contract, or otherwise, unless required by
+applicable law, shall any Contributor be liable to You for damages, including
+any direct, indirect, special, incidental, or consequential damages of any
+character arising as a result of this License or out of the use or inability to
+use the Work.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or
+Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations.
+
+END OF TERMS AND CONDITIONS

sim2sim_onepass-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sim2sim_onepass