fully tested

run.py

@@ -0,0 +1,13 @@
+import sys
+import os
+
+# Add project root and OpenEnv to path
+BASE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, BASE)
+sys.path.insert(0, os.path.join(BASE, "OpenEnv"))
+sys.path.insert(0, os.path.join(BASE, "OpenEnv", "src"))
+
+import uvicorn
+
+if __name__ == "__main__":
+    uvicorn.run("server.app:app", host="127.0.0.1", port=7860, reload=True)

server/app.py

@@ -1,16 +1,13 @@
 # server/app.py
-# FastAPI server exposing the OpenEnv standard endpoints.
-# Port 7860 required for Hugging Face Spaces.
-
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse
 from typing import Optional
 from pydantic import BaseModel
+import os
 
 from server.environment import CodeDebugEnvironment
 from models import DebugAction, DebugObservation, DebugState
-from fastapi.responses import HTMLResponse
-import os
 
 app = FastAPI(
     title="Code Debug Environment",
@@ -28,20 +25,24 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# One global environment instance (single session)
-# For concurrent sessions, instantiate per-request with a session dict
 env = CodeDebugEnvironment()
+
+
 @app.get("/", response_class=HTMLResponse)
 async def root():
+    """Homepage with live tester UI."""
     html_path = os.path.join(os.path.dirname(__file__), "static", "index.html")
-    with open(html_path, "r") as f:
+    with open(html_path, "r", encoding="utf-8") as f:
         return f.read()
 
 
-# ─── Request Models ─────────────────────────────────────────────────────────
+@app.get("/health")
+async def health():
+    return {"status": "ok", "environment": "code-debug-env", "version": "1.0.0"}
+
 
 class ResetRequest(BaseModel):
-    difficulty: Optional[str] = None  # "easy" | "medium" | "hard" | None (random)
+    difficulty: Optional[str] = None
 
 
 class StepRequest(BaseModel):
@@ -49,53 +50,27 @@ class StepRequest(BaseModel):
     explanation: Optional[str] = None
 
 
-# ─── Response wrapper matching OpenEnv StepResult shape ──────────────────────
-
 class StepResponse(BaseModel):
     observation: dict
     reward: float
     done: bool
 
 
-# ─── Endpoints ───────────────────────────────────────────────────────────────
-
-@app.get("/health")
-async def health():
-    """Health check endpoint — must return 200 for submission validation."""
-    return {"status": "ok", "environment": "code-debug-env", "version": "1.0.0"}
-
-
 @app.post("/reset")
 async def reset(request: ResetRequest = ResetRequest()) -> dict:
-    """
-    Reset the environment to start a new episode.
-    Optionally pass difficulty: 'easy' | 'medium' | 'hard'
-    """
     try:
         observation = env.reset(difficulty=request.difficulty)
-        return {
-            "observation": observation.model_dump(),
-            "reward": 0.0,
-            "done": False,
-        }
+        return {"observation": observation.model_dump(), "reward": 0.0, "done": False}
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Reset failed: {str(e)}")
 
 
 @app.post("/step")
 async def step(request: StepRequest) -> StepResponse:
-    """
-    Submit a code fix (and optional explanation for hard tasks).
-    Returns observation with reward (0.0–1.0), feedback, and done flag.
-    """
     if not request.fixed_code or not request.fixed_code.strip():
         raise HTTPException(status_code=400, detail="fixed_code must not be empty.")
-
     try:
-        action = DebugAction(
-            fixed_code=request.fixed_code,
-            explanation=request.explanation,
-        )
+        action = DebugAction(fixed_code=request.fixed_code, explanation=request.explanation)
         observation = env.step(action)
         return StepResponse(
             observation=observation.model_dump(),
@@ -108,17 +83,14 @@ async def step(request: StepRequest) -> StepResponse:
 
 @app.get("/state")
 async def state() -> dict:
-    """Return the current episode state."""
     try:
-        s = env.state
-        return s.model_dump()
+        return env.state.model_dump()
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"State failed: {str(e)}")
 
 
 @app.get("/tasks")
 async def list_tasks() -> dict:
-    """List available task IDs per difficulty (for inspection)."""
     from server.tasks.task_easy import EASY_TASKS
     from server.tasks.task_medium import MEDIUM_TASKS
     from server.tasks.task_hard import HARD_TASKS
@@ -129,16 +101,10 @@ async def list_tasks() -> dict:
         "total": len(EASY_TASKS) + len(MEDIUM_TASKS) + len(HARD_TASKS),
     }
 
-@app.get("/")
-async def root():
-    return {
-        "name": "Code Debug Environment",
-        "version": "1.0.0",
-        "endpoints": {
-            "health": "/health",
-            "reset": "/reset",
-            "step": "/step",
-            "state": "/state",
-            "docs": "/docs"
-        }
-    }
+
+# ─── Run directly with: python server/app.py ─────────────────────────────────
+if __name__ == "__main__":
+    import sys
+    import uvicorn
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    uvicorn.run("server.app:app", host="127.0.0.1", port=7860, reload=True)

server/graders/grader_easy.py

@@ -28,8 +28,16 @@ def _run_code_safely(code: str, func_name: str, test_input):
         func = funcs[0]
 
     try:
-        if isinstance(test_input, list):
+        if isinstance(test_input, list) and len(test_input) > 0 and isinstance(test_input[0], list):
+            # List of lists = multiple arguments e.g. [[1,2,3], 2] → func([1,2,3], 2)
             result = func(*test_input)
+        elif isinstance(test_input, list):
+            # Try passing as single list argument first
+            try:
+                result = func(test_input)
+            except TypeError:
+                # Fallback: unpack as multiple args
+                result = func(*test_input)
         else:
             result = func(test_input)
         return result, None
@@ -71,14 +79,14 @@ def grade_easy(fixed_code: str, task: dict) -> Tuple[float, int, int, str, List[
 
         if error:
             results.append({"test_id": i + 1, "passed": False, "expected": str(expected), "got": f"ERROR: {error}"})
-            feedback_lines.append(f"Test {i+1}: ❌ Error — {error}")
+            feedback_lines.append(f"Test {i+1}: ❌ Error\n   Input    : {inp!r}\n   Expected : {expected!r}\n   Error    : {error}")
         elif got == expected:
             passed += 1
             results.append({"test_id": i + 1, "passed": True, "expected": str(expected), "got": str(got)})
-            feedback_lines.append(f"Test {i+1}: ✅ Passed — got {got!r}")
+            feedback_lines.append(f"Test {i+1}: ✅ Passed\n   Input    : {inp!r}\n   Expected : {expected!r}\n   Got      : {got!r}")
         else:
             results.append({"test_id": i + 1, "passed": False, "expected": str(expected), "got": str(got)})
-            feedback_lines.append(f"Test {i+1}: ❌ Failed — expected {expected!r}, got {got!r}")
+            feedback_lines.append(f"Test {i+1}: ❌ Failed\n   Input    : {inp!r}\n   Expected : {expected!r}\n   Got      : {got!r}")
 
     reward = round(passed / total, 2)
     feedback = "\n".join(feedback_lines)
@@ -87,4 +95,4 @@ def grade_easy(fixed_code: str, task: dict) -> Tuple[float, int, int, str, List[
     else:
         feedback += f"\n{passed}/{total} tests passed. Review the failing cases."
 
-    return reward, passed, total, feedback, results
+    return reward, passed, total, feedback, results