Fix: Self-contained graders and spec compliance

core/graders.py

@@ -1,49 +1,69 @@
 """
 drone_delivery_env/core/graders.py
 Evaluation logic for scoring Drone Delivery missions.
+
+NOTE: This module is intentionally self-contained with NO external package imports.
+The OpenEnv validator imports grader functions directly via the module path
+(e.g. drone_env.core.graders:grade_easy). Any import failure here means the
+validator counts 0 working graders — causing "Not enough tasks with graders" error.
 """
-from drone_env.models import DroneState
 
 
-def compute_grade(state: DroneState, max_steps: float) -> float:
+def _get_attr(state, key, default=0):
+    """Safely get an attribute from a state object or dict."""
+    if isinstance(state, dict):
+        return state.get(key, default)
+    return getattr(state, key, default)
+
+
+def compute_grade(state, max_steps: float) -> float:
     """
     Unified grade calculation:
-    - 70% weighted by deliveries completed.
-    - 30% weighted by efficiency (remaining battery and steps).
+    - 80% weighted by deliveries completed.
+    - 20% weighted by efficiency (remaining battery and steps).
+    Accepts any object or dict with the required fields.
     """
-    if state.deliveries_total == 0: return 1.0
-    
-    delivery_ratio = state.deliveries_done / state.deliveries_total
-    
+    deliveries_total = _get_attr(state, "deliveries_total", 0)
+    deliveries_done  = _get_attr(state, "deliveries_done",  0)
+    battery          = _get_attr(state, "battery",          1.0)
+    step_count       = _get_attr(state, "step_count",       0)
+
+    if deliveries_total == 0:
+        return 0.5  # neutral score when no deliveries configured
+
+    delivery_ratio = deliveries_done / deliveries_total
+
     # Efficiency factor (0.0 to 1.0)
-    # Penalize if steps taken > average or battery is very low
-    efficiency = state.battery * 0.5 + (1.0 - (state.step_count / max_steps)) * 0.5
+    efficiency = float(battery) * 0.5 + (1.0 - (float(step_count) / float(max_steps))) * 0.5
     efficiency = max(0.0, min(1.0, efficiency))
-    
+
     score = (delivery_ratio * 0.8) + (efficiency * 0.2)
-    
-    # If not all deliveries are done, the maximum score is capped
-    if state.deliveries_done < state.deliveries_total:
+
+    # Cap score if not all deliveries are done
+    if deliveries_done < deliveries_total:
         score = min(score, 0.49)
-        
+
     # Hackathon Requirement: Score must be strictly between 0.0 and 1.0
     return max(0.01, min(0.99, float(score)))
 
 
-def grade_easy(state: DroneState) -> float:
+def grade_easy(state) -> float:
+    """Grader for easy_delivery task (10x10 grid, 1 delivery, 60 max steps)."""
     return compute_grade(state, 60.0)
 
 
-def grade_medium(state: DroneState) -> float:
+def grade_medium(state) -> float:
+    """Grader for medium_delivery task (14x14 grid, 3 deliveries, 100 max steps)."""
     return compute_grade(state, 100.0)
 
 
-def grade_hard(state: DroneState) -> float:
+def grade_hard(state) -> float:
+    """Grader for hard_delivery task (18x18 grid, 5 deliveries, 160 max steps)."""
     return compute_grade(state, 160.0)
 
 
 GRADERS = {
-    "drone_env.core.graders:grade_easy": grade_easy,
+    "drone_env.core.graders:grade_easy":   grade_easy,
     "drone_env.core.graders:grade_medium": grade_medium,
-    "drone_env.core.graders:grade_hard": grade_hard
+    "drone_env.core.graders:grade_hard":   grade_hard,
 }

data/memory.json

@@ -1,54 +1,4 @@
 [
-  {
-    "task": "drone_env.core.graders:grade_easy",
-    "steps": [
-      {
-        "step": 1,
-        "x": 1,
-        "y": 1,
-        "action": "RIGHT",
-        "reward": -0.05,
-        "battery": 0.9833
-      },
-      {
-        "step": 2,
-        "x": 2,
-        "y": 1,
-        "action": "RIGHT",
-        "reward": -0.1,
-        "battery": 0.9667
-      },
-      {
-        "step": 3,
-        "x": 2,
-        "y": 0,
-        "action": "UP",
-        "reward": -0.05,
-        "battery": 0.95
-      },
-      {
-        "step": 4,
-        "x": 3,
-        "y": 0,
-        "action": "RIGHT",
-        "reward": 0.95,
-        "battery": 0.9333
-      }
-    ],
-    "grid_meta": {
-      "width": 10,
-      "height": 10
-    },
-    "delivery_positions": [
-      [
-        3,
-        0
-      ]
-    ],
-    "deliveries_done": 1,
-    "total_reward": 0.75,
-    "total_steps": 4
-  },
   {
     "task": "drone_env.core.graders:grade_easy",
     "steps": [
@@ -17940,5 +17890,59 @@
     "deliveries_done": 3,
     "total_reward": 5.9,
     "total_steps": 20
+  },
+  {
+    "task": "drone_env.core.graders:grade_easy",
+    "steps": [
+      {
+        "step": 1,
+        "x": 4,
+        "y": 2,
+        "action": "LEFT",
+        "reward": 0.1,
+        "battery": 0.9833,
+        "message": "On road \ud83d\udee3\ufe0f"
+      },
+      {
+        "step": 2,
+        "x": 3,
+        "y": 2,
+        "action": "LEFT",
+        "reward": 0.1,
+        "battery": 0.9667,
+        "message": "On road \ud83d\udee3\ufe0f"
+      },
+      {
+        "step": 3,
+        "x": 3,
+        "y": 1,
+        "action": "UP",
+        "reward": 0.1,
+        "battery": 0.95,
+        "message": "On road \ud83d\udee3\ufe0f"
+      },
+      {
+        "step": 4,
+        "x": 2,
+        "y": 1,
+        "action": "LEFT",
+        "reward": 1.05,
+        "battery": 0.9333,
+        "message": "\u2705 Delivery 1/1 done!"
+      }
+    ],
+    "grid_meta": {
+      "width": 10,
+      "height": 10
+    },
+    "delivery_positions": [
+      [
+        2,
+        1
+      ]
+    ],
+    "deliveries_done": 1,
+    "total_reward": 1.35,
+    "total_steps": 4
   }
 ]

openenv.yaml

@@ -11,8 +11,3 @@ tasks:
     grader: drone_env.core.graders:grade_medium
   - id: hard_delivery
     grader: drone_env.core.graders:grade_hard
-graders:
-  - id: drone_env.core.graders:grade_easy
-  - id: drone_env.core.graders:grade_medium
-  - id: drone_env.core.graders:grade_hard
-

server/app.py

@@ -90,17 +90,27 @@ async def step(action: DroneAction):
 async def get_state():
     return _env.state
 
+# Task ID → grader key mapping (matches openenv.yaml task ids)
+TASK_ID_TO_GRADER = {
+    "easy_delivery":  "drone_env.core.graders:grade_easy",
+    "medium_delivery": "drone_env.core.graders:grade_medium",
+    "hard_delivery":  "drone_env.core.graders:grade_hard",
+}
+
 @app.get("/grade/{task_name}")
 async def grade(task_name: str):
-    if task_name not in GRADERS:
+    # Accept both short task IDs ("easy_delivery") and full grader keys
+    grader_key = TASK_ID_TO_GRADER.get(task_name, task_name)
+    if grader_key not in GRADERS:
         raise HTTPException(404, detail=f"Unknown task: {task_name}")
-    return {"task": task_name, "score": float(GRADERS[task_name](_env.state))}
+    return {"task": task_name, "score": float(GRADERS[grader_key](_env.state))}
 
 @app.get("/analyse/{task_name}")
 async def analyse(task_name: str):
-    if task_name not in TASK_CONFIG:
+    grader_key = TASK_ID_TO_GRADER.get(task_name, task_name)
+    if grader_key not in TASK_CONFIG:
          raise HTTPException(404, detail=f"Unknown task: {task_name}")
-    return PathLearner.analyse_episodes(task_name)
+    return PathLearner.analyse_episodes(grader_key)
 
 @app.get("/path_history")
 async def path_history():
@@ -108,11 +118,24 @@ async def path_history():
 
 @app.get("/tasks")
 async def list_tasks():
-    return {"tasks": [{"name": k, **v} for k, v in TASK_CONFIG.items()]}
+    return {"tasks": [{
+        "id": tid,
+        "name": tid,
+        "grader": gkey,
+        **TASK_CONFIG[gkey]
+    } for tid, gkey in TASK_ID_TO_GRADER.items()]}
 
 @app.get("/graders")
 async def list_graders():
-    return {"graders": list(GRADERS.keys())}
+    # Return task IDs (the submission system expects these to match openenv.yaml task ids)
+    return {"graders": list(TASK_ID_TO_GRADER.keys())}
+
+@app.post("/grade/{task_name}")
+async def grade_post(task_name: str):
+    grader_key = TASK_ID_TO_GRADER.get(task_name, task_name)
+    if grader_key not in GRADERS:
+        raise HTTPException(404, detail=f"Unknown task: {task_name}")
+    return {"task": task_name, "score": float(GRADERS[grader_key](_env.state))}
 
 @app.get("/logs")
 async def get_logs():

server/grid_world_environment.py

@@ -49,14 +49,24 @@ class DroneDeliveryEnvironment(Environment):
         if self._step_records and self._state.episode_id and not self._state.done:
              self._persist_episode()
 
+        # Map short task IDs (from openenv.yaml) to full grader keys
+        _TASK_ID_MAP = {
+            "easy_delivery":   "drone_env.core.graders:grade_easy",
+            "medium_delivery": "drone_env.core.graders:grade_medium",
+            "hard_delivery":   "drone_env.core.graders:grade_hard",
+        }
         task = "drone_env.core.graders:grade_easy"
-        if action and action.task_name and action.task_name in TASK_CONFIG:
-            task = action.task_name
-        elif action and action.task_name:
-            # handle cases like "easy" instead of "easy_delivery"
-            for k in TASK_CONFIG:
-                if k.startswith(action.task_name):
-                    task = k; break
+        if action and action.task_name:
+            name = action.task_name
+            if name in _TASK_ID_MAP:
+                task = _TASK_ID_MAP[name]
+            elif name in TASK_CONFIG:
+                task = name
+            else:
+                # handle partial matches like "easy"
+                for k in TASK_CONFIG:
+                    if k.startswith(name):
+                        task = k; break
 
         self._cfg = TASK_CONFIG[task]
         self._rng.manual_seed(random.randint(0, 2**31))