Update env.py

env.py

@@ -1,65 +1,12 @@
-# env.py
 
 from pathlib import Path
-import os
+import subprocess
 import sys
-import errno
-import yaml
 import gymnasium as gym
 from gymnasium import spaces
 import numpy as np
 from huggingface_hub import snapshot_download
-
-# Download the full repo and get its path
-_REPO_PATH = Path(snapshot_download(repo_id='lerobot/unitree-g1-mujoco', revision=None, cache_dir=None))
-
-# Add the repo to sys.path so we can import sim module
-if str(_REPO_PATH) not in sys.path:
-    sys.path.insert(0, str(_REPO_PATH))
-
-from sim.simulator_factory import SimulatorFactory, init_channel
-
-# lock file shared across processes
-_LOCK_PATH = Path.home() / ".unitree_g1_mujoco_sim.lock"
-
-
-def _acquire_lock():
-    """
-    try to create a lock file.
-    returns True if this process acquired the lock (i.e. we should start the sim),
-    False if some other process already did.
-    """
-    try:
-        fd = os.open(str(_LOCK_PATH), os.O_CREAT | os.O_EXCL | os.O_WRONLY)
-        os.close(fd)
-        return True
-    except OSError as e:
-        if e.errno == errno.EEXIST:
-            # lock already exists -> another process started the sim
-            return False
-        raise
-
-
-def _release_lock():
-    try:
-        _LOCK_PATH.unlink()
-    except FileNotFoundError:
-        pass
-
-
-class DummyEnv(gym.Env):
-    def __init__(self):
-        super().__init__()
-        self.action_space = spaces.Box(-1, 1, shape=(1,), dtype=np.float32)
-        self.observation_space = spaces.Box(-1, 1, shape=(1,), dtype=np.float32)
-
-    def reset(self, seed=None, options=None):
-        super().reset(seed=seed)
-        return np.zeros(1, dtype=np.float32), {}
-
-    def step(self, action):
-        return np.zeros(1, dtype=np.float32), 0.0, False, False, {}
-
+snapshot_download(repo_id='lerobot/unitree-g1-mujoco', revision=None, cache_dir=None)
 
 def make_env(
     n_envs=1,
@@ -70,78 +17,50 @@ def make_env(
     **kwargs,
 ):
     """
-    first caller (in any process) behaves exactly like run_sim.main():
-      - loads config
-      - prints banner
-      - init_channel
-      - creates simulator
-      - starts simulator (blocking, as_thread=False)
-
-    other callers in other processes see the lock and **do not** start the sim again,
-    they just return DummyEnv().
+    just launch run_sim.py as a subprocess (non-blocking)
+    then return a dummy gym env.
     """
-    # hard-override to the same defaults as run_sim.py
-    publish_images = True
-    camera_port = 5555
-    cameras = None
 
-    # only the process that acquires the lock starts the simulator
-    is_owner = _acquire_lock()
-    if is_owner:
-        try:
-            # --- run_sim.py: main() body ---
+    # path to this repo's run_sim.py
+    repo_dir = Path(__file__).parent
+    run_sim = repo_dir / "run_sim.py"
 
-            config_path = _REPO_PATH / "config.yaml"
-            with open(config_path) as f:
-                config = yaml.safe_load(f)
+    print("=" * 60)
+    print("launching run_sim.py as subprocess")
+    print("path:", run_sim)
+    print("=" * 60)
 
-            enable_offscreen = publish_images or config.get("ENABLE_OFFSCREEN", False)
+    # subprocess: completely independent simulator
+    proc = subprocess.Popen(
+        [sys.executable, str(run_sim)],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+    )
 
-            print("=" * 60)
-            print("🤖 Starting Unitree G1 MuJoCo Simulator")
-            print("=" * 60)
-            print(f"📁 Scene: {config['ROBOT_SCENE']}")
-            print(f"⏱️  Timestep: {config['SIMULATE_DT']}s ({int(1/config['SIMULATE_DT'])} Hz)")
-            print(f"👁️  Visualization: {'ON' if config.get('ENABLE_ONSCREEN', True) else 'OFF'}")
+    print(f"simulator started as pid={proc.pid}")
 
-            camera_configs = {}
-            if enable_offscreen:
-                camera_list = cameras or ["head_camera"]
-                for cam_name in camera_list:
-                    camera_configs[cam_name] = {"height": 480, "width": 640}
-                print(f"📷 Cameras: {', '.join(camera_list)} → ZMQ port {camera_port}")
+    # minimal env for envhub
+    class DummyEnv(gym.Env):
+        metadata = {"render_modes": []}
 
-            print("=" * 60)
+        def __init__(self, process):
+            super().__init__()
+            self.process = process
+            self.action_space = spaces.Box(-1, 1, shape=(1,), dtype=np.float32)
+            self.observation_space = spaces.Box(-1, 1, shape=(1,), dtype=np.float32)
 
-            init_channel(config=config)
+        def reset(self, seed=None, options=None):
+            return np.zeros(1, dtype=np.float32), {}
 
-            sim = SimulatorFactory.create_simulator(
-                config=config,
-                env_name="default",
-                onscreen=config.get("ENABLE_ONSCREEN", True),
-                offscreen=enable_offscreen,
-                camera_configs=camera_configs,
-            )
+        def step(self, action):
+            return np.zeros(1, dtype=np.float32), 0.0, False, False, {}
 
-            print("\nSimulator running. Press Ctrl+C to exit.")
-            if enable_offscreen and publish_images:
-                print(f"Camera images publishing on tcp://localhost:{camera_port}")
+        def close(self):
+            if self.process.poll() is None:
+                print("terminating simulator subprocess...")
+                self.process.terminate()
 
-            try:
-                SimulatorFactory.start_simulator(
-                    sim,
-                    as_thread=False,  # blocking, identical to run_sim.py
-                    enable_image_publish=publish_images,
-                    camera_port=camera_port,
-                )
-            except KeyboardInterrupt:
-                print("\nShutting down simulator...")
-                sim.close()
-        finally:
-            _release_lock()
-    else:
-        # another process already started the simulator; do nothing here
-        pass
+        def run(self):
+            pass
 
-    # after (or while) the sim is running/exited, return a dummy env
-    return DummyEnv()
+    return DummyEnv(proc)