chore: lint-clean mjlab/maniskill tasks + make tooling paths portable

Pre-push cleanup of the unpushed mjlab/maniskill/robotwin work so it passes
the pre-commit gate and contains no machine-specific paths:

- ruff: add docstrings to mjlab task/MDP public API, replace diagnostic
  print() with loguru log, fix ambiguous unicode, Optional->| None, lambda
  ->def, warnings.warn stacklevel, np.sqrt default-arg, unused imports.
  Full pre-commit (ruff + ruff-format + hooks) now passes on all changed files.
- tooling: remove 53 hardcoded /home/ghr absolute paths from tools/**;
  repo root via rootutils, reports dir via ROBOVERSE_REPORTS_DIR (rel fallback),
  external mjlab via MJLAB_DIR (~/projects/mjlab fallback), conda via
  $(conda info --base). No library code referenced local paths.

Smoke: all edited modules import; mjlab v2 backward-compat 12/12 mujoco +
12/12 newton. No runtime behavior changed.

Author: geng-haoran

roboverse_pack/robots/mjlab_go1_cfg.py

@@ -26,6 +26,7 @@
     "RL_calf_joint",
 )
 
+
 # Default stance — MUST match mjlab INIT_STATE (go1_constants.py): thigh=0.9,
 # calf=-1.8, and asymmetric hips R_hip=+0.1 / L_hip=-0.1. The earlier symmetric
 # hip=0.0 here (Newton path never got the r7 ±0.1 fix) gave an unstable stance
@@ -80,5 +81,9 @@ class MjlabGo1Cfg(RobotCfg):
     default_joint_positions: dict[str, float] = _GO1_DEFAULTS
     default_joint_velocities: dict[str, float] = {n: 0.0 for n in _GO1_JOINTS}
     control_type: dict[str, Literal["position", "effort"]] = {n: "position" for n in _GO1_JOINTS}
-    default_pos: tuple[float, float, float] = (0.0, 0.0, 0.278)  # mjlab INIT_STATE height (was 0.42 -> 14cm drop -> collapse)
+    default_pos: tuple[float, float, float] = (
+        0.0,
+        0.0,
+        0.278,
+    )  # mjlab INIT_STATE height (was 0.42 -> 14cm drop -> collapse)
     default_rot: tuple[float, float, float, float] = (1.0, 0.0, 0.0, 0.0)

roboverse_pack/tasks/_passthrough_index.py

@@ -31,6 +31,7 @@
 def list_passthrough_envs() -> dict[str, list[str]]:
     """Return {benchmark_name: [env_id, ...]} for all currently-registered passthrough envs."""
     import gymnasium as gym
+
     out: dict[str, list[str]] = {}
     for prefix in PASSTHROUGH_PREFIXES:
         bench = prefix.rstrip("/")
@@ -44,9 +45,9 @@ def print_passthrough_summary() -> None:
     """Print a one-line summary per benchmark."""
     envs = list_passthrough_envs()
     total = sum(len(v) for v in envs.values())
-    print(f"# RoboVerse Passthrough — {total} envs across {len(envs)} benchmarks")
-    print()
+    print(f"# RoboVerse Passthrough - {total} envs across {len(envs)} benchmarks")  # noqa: T201
+    print()  # noqa: T201
     for bench, ids in envs.items():
-        print(f"  {bench:25s} {len(ids):4d}  example: {ids[0]}")
-    print()
-    print(f"  TOTAL                     {total}")
+        print(f"  {bench:25s} {len(ids):4d}  example: {ids[0]}")  # noqa: T201
+    print()  # noqa: T201
+    print(f"  TOTAL                     {total}")  # noqa: T201

roboverse_pack/tasks/dm_control/_passthrough.py

@@ -5,12 +5,15 @@
 from typing import Any
 
 import numpy as np
+from loguru import logger as log
 
 
 def register_dm_control_passthrough(prefix: str = "DMControl/") -> list[str]:
     """Register all dm_control suite tasks under DMControl/<domain>-<task> namespace."""
     from gymnasium.envs.registration import register, registry
+
     import dm_control.suite as suite
+
     registered = []
     failed = []
     for domain, task in suite.ALL_TASKS:
@@ -28,7 +31,7 @@ def register_dm_control_passthrough(prefix: str = "DMControl/") -> list[str]:
         except Exception as e:
             failed.append((ns_id, str(e)))
     if failed:
-        print(f"[dm_control_passthrough] {len(failed)} failures")
+        log.warning(f"[dm_control_passthrough] {len(failed)} failures")
     return registered
 
 
@@ -43,18 +46,24 @@ class _DMControlGymWrapper(gym.Env):
     def __init__(self, domain: str, task: str, **kwargs):
         super().__init__()
         from dm_control import suite
-        self._env = suite.load(domain_name=domain, task_name=task,
-                                visualize_reward=kwargs.pop("visualize_reward", False))
+
+        self._env = suite.load(
+            domain_name=domain, task_name=task, visualize_reward=kwargs.pop("visualize_reward", False)
+        )
         spec = self._env.observation_spec()
         # Concatenate all obs into a single Box (typical practice for dm_control)
         import gymnasium as gym
+
         self._obs_keys = sorted(spec.keys())
         obs_dim = sum(int(np.prod(spec[k].shape)) for k in self._obs_keys)
         self.observation_space = gym.spaces.Box(low=-np.inf, high=np.inf, shape=(obs_dim,), dtype=np.float32)
         a_spec = self._env.action_spec()
-        self.action_space = gym.spaces.Box(low=a_spec.minimum.astype(np.float32),
-                                           high=a_spec.maximum.astype(np.float32),
-                                           shape=a_spec.shape, dtype=np.float32)
+        self.action_space = gym.spaces.Box(
+            low=a_spec.minimum.astype(np.float32),
+            high=a_spec.maximum.astype(np.float32),
+            shape=a_spec.shape,
+            dtype=np.float32,
+        )
         self._domain = domain
         self._task = task
 
@@ -63,7 +72,6 @@ def _flatten_obs(self, obs):
 
     def reset(self, *, seed=None, options=None):
         if seed is not None:
-            import dm_control.rl.control as ctl  # for seeding if available
             self._env.task.random.seed(seed)
         ts = self._env.reset()
         return self._flatten_obs(ts.observation), {}

roboverse_pack/tasks/gym_robotics/_passthrough.py

@@ -6,15 +6,17 @@
 
 
 def _ensure_imported():
-    import gymnasium_robotics
     import gymnasium as gym
+    import gymnasium_robotics
+
     gym.register_envs(gymnasium_robotics)
     return gymnasium_robotics
 
 
 def register_gymnasium_robotics_passthrough(prefix: str = "GymRobotics/") -> list[str]:
     """Register all gymnasium-robotics envs under GymRobotics/<env_id> namespace."""
     from gymnasium.envs.registration import register, registry
+
     _ensure_imported()
     import gymnasium as gym
 
@@ -47,4 +49,5 @@ def register_gymnasium_robotics_passthrough(prefix: str = "GymRobotics/") -> lis
 def _make_env(base_id: str, **kwargs: Any):
     _ensure_imported()
     import gymnasium as gym
+
     return gym.make(base_id, **kwargs)

roboverse_pack/tasks/maniskill/__init__.py

@@ -32,6 +32,7 @@ def _auto_import_submodules() -> None:
 # Auto-register ManiSkill 3 envs under ManiSkill3/<env_id> namespace
 try:
     from roboverse_pack.tasks.maniskill._passthrough_v3 import register_maniskill3_passthrough
+
     register_maniskill3_passthrough()
 except Exception:
     pass  # mani_skill not installed or registration issue

roboverse_pack/tasks/maniskill/_dense_rl.py

@@ -26,7 +26,7 @@ class DenseRLResetMixin:
     """Randomized resets (cube on table + goal pose) without demo data."""
 
     cube_z: float = 0.02
-    xy_range: float = 0.1            # object xy ~ uniform[-xy_range, xy_range]
+    xy_range: float = 0.1  # object xy ~ uniform[-xy_range, xy_range]
     goal_z_range: tuple[float, float] = (0.02, 0.02)  # on-table by default
     reset_seed: int = 0
     # Dense RL tasks generate their own randomized initial states, so they
@@ -35,7 +35,7 @@ class DenseRLResetMixin:
 
     # Skip ManiskillBaseTask's demo-trajectory download — call BaseTaskEnv
     # directly so the dense task doesn't depend on replay data.
-    def __init__(self, scenario, device=None) -> None:  # noqa: D401
+    def __init__(self, scenario, device=None) -> None:
         BaseTaskEnv.__init__(self, scenario, device)
 
     def _get_initial_states(self) -> list[dict]:
@@ -55,13 +55,15 @@ def u(lo: float, hi: float) -> float:
             objs: dict[str, dict] = {}
             for name in obj_names:
                 if "goal" in name.lower():
-                    pos = torch.tensor([u(-self.xy_range, self.xy_range),
-                                        u(-self.xy_range, self.xy_range),
-                                        u(*self.goal_z_range)], dtype=torch.float32)
+                    pos = torch.tensor(
+                        [u(-self.xy_range, self.xy_range), u(-self.xy_range, self.xy_range), u(*self.goal_z_range)],
+                        dtype=torch.float32,
+                    )
                 else:  # cube / manipuland — rest on the table surface
-                    pos = torch.tensor([u(-self.xy_range, self.xy_range),
-                                        u(-self.xy_range, self.xy_range),
-                                        self.cube_z], dtype=torch.float32)
+                    pos = torch.tensor(
+                        [u(-self.xy_range, self.xy_range), u(-self.xy_range, self.xy_range), self.cube_z],
+                        dtype=torch.float32,
+                    )
                 objs[name] = {"pos": pos, "rot": torch.tensor([1.0, 0.0, 0.0, 0.0])}
             states.append({
                 "objects": objs,

roboverse_pack/tasks/maniskill/_passthrough_v3.py

@@ -17,14 +17,17 @@
 from __future__ import annotations
 
 import os
-from typing import Any, Optional
+from typing import Any
+
+from loguru import logger as log
 
 
 def _ensure_maniskill_imported():
     """Triggers ManiSkill envs registration."""
     os.environ.setdefault("MUJOCO_GL", "egl")
     import mani_skill
-    import mani_skill.envs  # noqa: F401 — triggers env registry side-effect
+    import mani_skill.envs
+
     return mani_skill
 
 
@@ -35,6 +38,7 @@ def list_maniskill3_envs() -> list[str]:
     """Return all ManiSkill 3-registered env IDs (after triggering import)."""
     _ensure_maniskill_imported()
     import gymnasium as gym
+
     ids = []
     for spec in gym.envs.registry.values():
         ep = spec.entry_point
@@ -50,17 +54,19 @@ def register_maniskill3_passthrough(prefix: str = "ManiSkill3/") -> list[str]:
     Idempotent. Returns list of registered (or already-present) env ids.
     """
     from gymnasium.envs.registration import register, registry
-    _ensure_maniskill_imported()
-    import gymnasium as gym
 
+    _ensure_maniskill_imported()
     # Find all mani_skill envs. ManiSkill 3 wraps with functools.partial(mani_skill.envs.make).
     # Identify by the additional_wrappers field which references mani_skill, or by name pattern.
     import functools
+
+    import gymnasium as gym
+
     base_ids = []
     for spec in list(gym.envs.registry.values()):
         is_ms = False
         # 1. Check additional_wrappers (ManiSkill always wraps with MSTimeLimit)
-        for w in (getattr(spec, "additional_wrappers", None) or []):
+        for w in getattr(spec, "additional_wrappers", None) or []:
             if "mani_skill" in str(getattr(w, "entry_point", "")):
                 is_ms = True
                 break
@@ -82,21 +88,22 @@ def register_maniskill3_passthrough(prefix: str = "ManiSkill3/") -> list[str]:
         try:
             register(
                 id=ns_id,
-                entry_point=f"roboverse_pack.tasks.maniskill._passthrough_v3:_make_maniskill_env",
+                entry_point="roboverse_pack.tasks.maniskill._passthrough_v3:_make_maniskill_env",
                 kwargs={"base_id": base_id},
             )
             registered.append(ns_id)
         except Exception as e:
             failed.append((ns_id, str(e)))
     if failed:
-        print(f"[maniskill_passthrough] {len(failed)} registration failures:")
+        log.warning(f"[maniskill_passthrough] {len(failed)} registration failures:")
         for ns_id, err in failed[:3]:
-            print(f"  {ns_id}: {err}")
+            log.warning(f"  {ns_id}: {err}")
     return registered
 
 
 def _make_maniskill_env(base_id: str, **kwargs: Any):
     """Factory for namespaced env — just gym.make the underlying base id."""
     _ensure_maniskill_imported()
     import gymnasium as gym
+
     return gym.make(base_id, **kwargs)

roboverse_pack/tasks/maniskill/lift_peg_upright.py

@@ -63,8 +63,8 @@ def reset(self, states=None, env_ids=None):
 # ``compute_dense_reward`` (mani_skill/envs/tasks/tabletop/lift_peg_upright.py).
 # ---------------------------------------------------------------------------
 
-_LP_HALF_LENGTH = 0.12   # peg_length / 2 — target z when upright
-_LP_HALF_WIDTH = 0.025   # peg_widdth / 2 — rest height lying flat
+_LP_HALF_LENGTH = 0.12  # peg_length / 2 — target z when upright
+_LP_HALF_WIDTH = 0.025  # peg_widdth / 2 — rest height lying flat
 _LP_TCP_OFFSET = (0.0, 0.0, 0.10312)
 _LP_UPRIGHT_COS = float(torch.cos(torch.tensor(0.08)))  # ManiSkill 0.08 rad tol
 

roboverse_pack/tasks/maniskill/pick_cube_v1.py

@@ -129,6 +129,7 @@ class PickCubeV1DenseTask(DenseRLResetMixin, PickCubeV1Task):
 
     def _reward(self, env_states):
         import torch
+
         from metasim.utils.math import quat_rotate
 
         rs = env_states.robots["franka"]

roboverse_pack/tasks/maniskill/pick_single_ycb.py

@@ -66,10 +66,10 @@ class PickSingleYcbDenseTask(DenseRLResetMixin, _PickSingleYcbBaseTask):
     goal_z_range = (0.10, 0.30)
     scenario = ScenarioCfg(
         objects=[
-            PrimitiveCubeCfg(name="obj", size=(0.04, 0.04, 0.04), mass=0.02,
-                             physics=PhysicStateType.RIGIDBODY, color=(1.0, 0.5, 0.0)),
-            PrimitiveSphereCfg(name="goal_site", radius=0.025,
-                               physics=PhysicStateType.XFORM, color=(0.0, 1.0, 0.0)),
+            PrimitiveCubeCfg(
+                name="obj", size=(0.04, 0.04, 0.04), mass=0.02, physics=PhysicStateType.RIGIDBODY, color=(1.0, 0.5, 0.0)
+            ),
+            PrimitiveSphereCfg(name="goal_site", radius=0.025, physics=PhysicStateType.XFORM, color=(0.0, 1.0, 0.0)),
         ],
         robots=["franka"],
     )