Upload folder using huggingface_hub

README.md

@@ -1,8 +1,8 @@
 ---
 title: Maze Environment Server
-emoji: 💻
-colorFrom: red
-colorTo: gray
+emoji: 🖱️
+colorFrom: indigo
+colorTo: purple
 sdk: docker
 pinned: false
 app_port: 8000

pyproject.toml

@@ -17,7 +17,7 @@ dependencies = [
     # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
     # install from github
     "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
-    # "openenv-core[core]>=0.2.0",
+    #"openenv-core[core]>=0.2.0",
     # Environment-specific dependencies
     # Add all dependencies needed for your environment here
     # Examples:

server/maze_environment.py

@@ -1,42 +1,85 @@
+import random
 from openenv.core.env_server.interfaces import Environment
 from models import MazeAction, MazeObservation, MazeState
+from mazelib import Maze
+from mazelib.generate.BacktrackingGenerator import BacktrackingGenerator
+from mazelib.solve.ShortestPath import ShortestPath
+
+class MazeGenerator:
+    def __init__(self, w_range=(3, 5), h_range=(3, 5)):
+        self.w_range, self.h_range = w_range, h_range
+
+    def generate(self, max_attempts=100):
+        w, h = random.randint(*self.w_range), random.randint(*self.h_range)
+        min_path_len = (w + h) * 2 + random.randint(-3, 5)
+
+        m = Maze()
+        m.generator = BacktrackingGenerator(w, h)
+        m.solver = ShortestPath()
+
+        for _ in range(max_attempts):
+            m.generate()
+            m.generate_entrances()
+            m.solve()
+            if len(m.solutions[0]) >= min_path_len:
+                break
+
+        return (1 - m.grid).tolist(), list(m.start), list(m.end)
 
 class MazeEnvironment(Environment):
-    """Grid-based maze environment. Agent navigates from [0,0] to goal [3,3]."""
+    """Grid-based maze environment with random maze generation."""
     SUPPORTS_CONCURRENT_SESSIONS: bool = True
 
     def __init__(self):
-        self._maze = [[1,0,1,1], [1,1,0,1], [1,1,0,1], [1,1,1,1]]
-        self._agent_pos, self._goal_pos = [0,0], [3,3]
+        self.generator = MazeGenerator()
+        self._generate_new_maze()
+
+    def _generate_new_maze(self):
+        self._maze, self._agent_pos, self._goal_pos = self.generator.generate()
         self._step_count, self._episode_id = 0, None
-        self.row, self.col = 4, 4
+
+    @property
+    def row(self): return len(self._maze)
+    @property
+    def col(self): return len(self._maze[0])
 
     @property
     def state(self) -> MazeState:
-        return MazeState(maze=self._maze, agent_pos=self._agent_pos, 
-                         goal_pos=self._goal_pos, episode_id=self._episode_id, 
+        return MazeState(maze=self._maze, agent_pos=self._agent_pos,
+                         goal_pos=self._goal_pos, episode_id=self._episode_id,
                          step_count=self._step_count)
 
     def reset(self, seed=None, episode_id=None, **kwargs) -> MazeObservation:
-        self._agent_pos, self._step_count, self._episode_id = [0,0], 0, episode_id
+        if seed: random.seed(seed)
+        self._generate_new_maze()
+        self._episode_id = episode_id
         return MazeObservation(position=self._agent_pos, grid_view=self._render(), done=False, reward=0)
 
     def step(self, action: MazeAction, timeout_s=None, **kwargs) -> MazeObservation:
-        if action.direction in ["up","down","left","right"]: self._move(action.direction)
+        if action.direction in ["up", "down", "left", "right"]:
+            self._move(action.direction)
         self._step_count += 1
         done = self._agent_pos == self._goal_pos
-        return MazeObservation(position=self._agent_pos, grid_view=self._render(), 
+        return MazeObservation(position=self._agent_pos, grid_view=self._render(),
                                done=done, reward=10 if done else -1)
 
     def _move(self, d):
         i, j = self._agent_pos
-        if d=='up': i-=1
-        elif d=='down': i+=1
-        elif d=='left': j-=1
-        elif d=='right': j+=1
-        if 0<=i<self.row and 0<=j<self.col and self._maze[i][j]: self._agent_pos=[i,j]
+        if d == 'up': i -= 1
+        elif d == 'down': i += 1
+        elif d == 'left': j -= 1
+        elif d == 'right': j += 1
+        if 0 <= i < self.row and 0 <= j < self.col and self._maze[i][j]:
+            self._agent_pos = [i, j]
 
     def _render(self) -> str:
-        s = {0:'#', 1:'.'}
-        return "\n".join(" ".join("A" if [i,j]==self._agent_pos else "G" if [i,j]==self._goal_pos 
-                                   else s[self._maze[i][j]] for j in range(self.col)) for i in range(self.row))
+        symbols = {0: '#', 1: '.'}
+        lines = []
+        for i in range(self.row):
+            row = []
+            for j in range(self.col):
+                if [i, j] == self._agent_pos: row.append("A")
+                elif [i, j] == self._goal_pos: row.append("G")
+                else: row.append(symbols[self._maze[i][j]])
+            lines.append(" ".join(row))
+        return "\n".join(lines)