Initial project structure for Meta PyTorch OpenEnv Hackathon

.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.py[cod]
+*.pyo
+.env
+.venv/
+venv/
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.mypy_cache/
+*.log
+.DS_Store

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 8000
+
+CMD ["uvicorn", "src.environment.server:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -0,0 +1,88 @@
+# Meta × PyTorch OpenEnv Hackathon 2026
+
+> Built for the **Meta PyTorch OpenEnv Hackathon x SST** — India's Biggest MEGA AI Hackathon.
+
+## Overview
+
+This repository contains a complete [OpenEnv](https://github.com/huggingface/openenv)-compliant environment that an AI agent can learn from through the standard `step()` / `reset()` / `state()` API.
+
+## Environment Description
+
+<!-- TODO: Describe your chosen environment here -->
+
+## Action & Observation Spaces
+
+<!-- TODO: Fill in after choosing your problem statement -->
+
+### Action Space
+```
+{
+  "action_type": str,
+  ...
+}
+```
+
+### Observation Space
+```
+{
+  "state": ...,
+  "reward": float,
+  "done": bool
+}
+```
+
+## Tasks
+
+| Task | Difficulty | Score Range |
+|------|-----------|-------------|
+| Task 1 | Easy | 0.0 – 1.0 |
+| Task 2 | Medium | 0.0 – 1.0 |
+| Task 3 | Hard | 0.0 – 1.0 |
+
+## Setup & Installation
+
+```bash
+# Clone the repo
+git clone https://github.com/YOUR_USERNAME/meta-pytorch-openenv-hackathon.git
+cd meta-pytorch-openenv-hackathon
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the environment
+python scripts/run_baseline.py
+```
+
+## Running with Docker
+
+```bash
+docker build -t openenv-hackathon .
+docker run -p 8000:8000 openenv-hackathon
+```
+
+## API Endpoints
+
+| Endpoint | Description |
+|----------|-------------|
+| `POST /reset` | Reset environment, returns initial state |
+| `POST /step` | Execute an action, returns next state + reward |
+| `GET /state` | Get current environment state |
+| `GET /tasks` | List all tasks and action schemas |
+| `GET /grader` | Get grader score after an episode |
+| `GET /baseline` | Run baseline inference and return scores |
+
+## Evaluation Criteria
+
+- ✅ HF Space deploys and responds to `reset()`
+- ✅ OpenEnv spec compliance (`openenv.yaml`, typed models)
+- ✅ Dockerfile builds
+- ✅ Baseline script runs without error
+- ✅ 3+ tasks with graders (scores in 0.0–1.0 range)
+
+## Submission Deadline
+
+**7th April 2026, 11:59 PM**
+
+## License
+
+MIT

openenv.yaml

@@ -0,0 +1,37 @@
+name: openenv-hackathon
+version: "1.0.0"
+description: "OpenEnv environment for Meta PyTorch Hackathon 2026"
+author: "Devesh B"
+
+# TODO: Fill in after choosing your problem statement
+environment:
+  type: custom
+  entry_point: src/environment/env.py
+  class: HackathonEnv
+
+tasks:
+  - id: task_easy
+    name: "Task 1 - Easy"
+    difficulty: easy
+    grader: src/graders/task_easy_grader.py
+
+  - id: task_medium
+    name: "Task 2 - Medium"
+    difficulty: medium
+    grader: src/graders/task_medium_grader.py
+
+  - id: task_hard
+    name: "Task 3 - Hard"
+    difficulty: hard
+    grader: src/graders/task_hard_grader.py
+
+api:
+  host: 0.0.0.0
+  port: 8000
+  endpoints:
+    - /reset
+    - /step
+    - /state
+    - /tasks
+    - /grader
+    - /baseline

requirements.txt

@@ -0,0 +1,9 @@
+fastapi>=0.110.0
+uvicorn>=0.29.0
+pydantic>=2.0.0
+numpy>=1.26.0
+torch>=2.2.0
+gymnasium>=0.29.0
+httpx>=0.27.0
+pytest>=8.0.0
+python-dotenv>=1.0.0

scripts/run_baseline.py

@@ -0,0 +1,34 @@
+"""
+Baseline inference script.
+Run this to produce reproducible scores before submission.
+Usage: python scripts/run_baseline.py
+"""
+import httpx
+import json
+
+BASE_URL = "http://localhost:8000"
+TASKS = ["task_easy", "task_medium", "task_hard"]
+
+
+def run_episode(task_id: str) -> float:
+    """Run a single episode for the given task and return score."""
+    httpx.post(f"{BASE_URL}/reset")
+    # TODO: Implement actual baseline agent logic here
+    score = httpx.get(f"{BASE_URL}/grader", params={"task_id": task_id}).json()["score"]
+    return score
+
+
+def main():
+    print("Running baseline inference...\n")
+    scores = {}
+    for task in TASKS:
+        score = run_episode(task)
+        scores[task] = score
+        print(f"  {task}: {score:.4f}")
+
+    print(f"\nBaseline scores: {json.dumps(scores, indent=2)}")
+    return scores
+
+
+if __name__ == "__main__":
+    main()

scripts/validate.py

@@ -0,0 +1,88 @@
+"""
+Pre-submission validation script.
+Run this before submitting to check all automated judge requirements.
+Usage: python scripts/validate.py
+"""
+import httpx
+import yaml
+import sys
+
+BASE_URL = "http://localhost:8000"
+PASS = "✅"
+FAIL = "❌"
+results = []
+
+
+def check(label: str, passed: bool, detail: str = ""):
+    icon = PASS if passed else FAIL
+    print(f"  {icon} {label}" + (f" — {detail}" if detail else ""))
+    results.append(passed)
+
+
+def main():
+    print("\n🔍 Pre-submission validation\n")
+
+    # 1. openenv.yaml exists and is valid
+    try:
+        with open("openenv.yaml") as f:
+            config = yaml.safe_load(f)
+        check("openenv.yaml valid", True)
+        tasks = config.get("tasks", [])
+        check("3+ tasks defined", len(tasks) >= 3, f"{len(tasks)} tasks found")
+    except Exception as e:
+        check("openenv.yaml valid", False, str(e))
+
+    # 2. Server reachable
+    try:
+        r = httpx.get(f"{BASE_URL}/tasks", timeout=5)
+        check("Server reachable", r.status_code == 200)
+    except Exception as e:
+        check("Server reachable", False, str(e))
+        print("\n⚠️  Start the server first: uvicorn src.environment.server:app --host 0.0.0.0 --port 8000")
+        sys.exit(1)
+
+    # 3. /reset responds
+    try:
+        r = httpx.post(f"{BASE_URL}/reset", timeout=5)
+        check("/reset returns 200", r.status_code == 200)
+    except Exception as e:
+        check("/reset returns 200", False, str(e))
+
+    # 4. /tasks lists 3+ tasks
+    try:
+        r = httpx.get(f"{BASE_URL}/tasks", timeout=5)
+        task_list = r.json().get("tasks", [])
+        check("/tasks returns 3+ tasks", len(task_list) >= 3, f"{len(task_list)} returned")
+    except Exception as e:
+        check("/tasks returns 3+ tasks", False, str(e))
+
+    # 5. /grader scores in 0.0–1.0 range
+    try:
+        r = httpx.get(f"{BASE_URL}/grader", params={"task_id": "task_easy"}, timeout=5)
+        score = r.json().get("score", -1)
+        check("Grader score in 0.0–1.0", 0.0 <= score <= 1.0, f"score={score}")
+    except Exception as e:
+        check("Grader score in 0.0–1.0", False, str(e))
+
+    # 6. /baseline runs
+    try:
+        r = httpx.get(f"{BASE_URL}/baseline", timeout=30)
+        check("/baseline returns 200", r.status_code == 200)
+    except Exception as e:
+        check("/baseline returns 200", False, str(e))
+
+    passed = sum(results)
+    total = len(results)
+    print(f"\n{'='*40}")
+    print(f"Result: {passed}/{total} checks passed")
+    if passed == total:
+        print("🎉 Ready to submit!")
+    else:
+        print("⚠️  Fix the failing checks before submitting.")
+    print("="*40 + "\n")
+
+    sys.exit(0 if passed == total else 1)
+
+
+if __name__ == "__main__":
+    main()

src/environment/env.py

@@ -0,0 +1,38 @@
+"""
+Base OpenEnv environment implementation.
+Implements the standard step() / reset() / state() API.
+"""
+from abc import ABC, abstractmethod
+from typing import Any
+from pydantic import BaseModel
+
+
+class StepResult(BaseModel):
+    observation: dict[str, Any]
+    reward: float
+    done: bool
+    info: dict[str, Any] = {}
+
+
+class HackathonEnv(ABC):
+    """
+    Base class for the hackathon OpenEnv environment.
+    TODO: Implement this with your chosen problem statement.
+    """
+
+    def __init__(self):
+        self._state: dict[str, Any] = {}
+
+    @abstractmethod
+    def reset(self) -> dict[str, Any]:
+        """Reset environment to initial state. Returns initial observation."""
+        ...
+
+    @abstractmethod
+    def step(self, action: dict[str, Any]) -> StepResult:
+        """Execute action. Returns observation, reward, done flag, info."""
+        ...
+
+    def state(self) -> dict[str, Any]:
+        """Return current environment state."""
+        return self._state

src/environment/server.py

@@ -0,0 +1,71 @@
+"""
+OpenEnv-compliant FastAPI server.
+Exposes all required endpoints: /reset, /step, /state, /tasks, /grader, /baseline
+"""
+from fastapi import FastAPI
+from pydantic import BaseModel
+from typing import Any
+
+app = FastAPI(title="OpenEnv Hackathon", version="1.0.0")
+
+# TODO: Import and instantiate your environment
+# from src.environment.env import YourEnv
+# env = YourEnv()
+
+
+class Action(BaseModel):
+    action_type: str
+    payload: dict[str, Any] = {}
+
+
+@app.post("/reset")
+def reset():
+    """Reset environment and return initial observation."""
+    # return env.reset()
+    return {"status": "ok", "observation": {}}
+
+
+@app.post("/step")
+def step(action: Action):
+    """Execute an action and return next state, reward, done."""
+    # return env.step(action.dict())
+    return {"observation": {}, "reward": 0.0, "done": False, "info": {}}
+
+
+@app.get("/state")
+def state():
+    """Get current environment state."""
+    # return env.state()
+    return {}
+
+
+@app.get("/tasks")
+def tasks():
+    """List all tasks and their action schemas."""
+    return {
+        "tasks": [
+            {"id": "task_easy",   "difficulty": "easy",   "action_schema": {}},
+            {"id": "task_medium", "difficulty": "medium", "action_schema": {}},
+            {"id": "task_hard",   "difficulty": "hard",   "action_schema": {}},
+        ]
+    }
+
+
+@app.get("/grader")
+def grader(task_id: str = "task_easy"):
+    """Return grader score for a completed episode."""
+    # TODO: Implement grader logic
+    return {"task_id": task_id, "score": 0.0}
+
+
+@app.get("/baseline")
+def baseline():
+    """Run baseline inference and return scores for all tasks."""
+    # TODO: Run actual baseline
+    return {
+        "scores": {
+            "task_easy":   0.0,
+            "task_medium": 0.0,
+            "task_hard":   0.0,
+        }
+    }