Download api/app.py from ThejasRao/openenv-content-moderation: direct link, hf CLI and curl.
- Browser
- Download file 10.5 kB
-
https://huggingface.co/spaces/ThejasRao/openenv-content-moderation/resolve/main/api/app.py
- Command line
-
hf download hf://spaces/ThejasRao/openenv-content-moderation/api/app.py
-
curl -L -o app.py https://huggingface.co/spaces/ThejasRao/openenv-content-moderation/resolve/main/api/app.py
10.5 kB
| """ | |
| OpenENV Moderation Environment β FastAPI application. | |
| Standard OpenEnv endpoints: | |
| WS /ws β persistent WebSocket session (primary client interface) | |
| GET /health β liveness check | |
| POST /reset β start a new episode | |
| POST /step β take an action | |
| GET /state β current observation / state | |
| GET /docs β OpenAPI documentation (auto-generated) | |
| Custom endpoints: | |
| GET /tasks β available tasks | |
| GET /grader β final episode score | |
| GET /baseline β run rule-based baseline agent and return its score | |
| POST /agent/run β run selected LLM agent on a full episode | |
| """ | |
| from __future__ import annotations | |
| import json | |
| import logging | |
| from dotenv import load_dotenv | |
| load_dotenv() # loads .env from project root before anything else | |
| from fastapi import FastAPI, HTTPException, Body, WebSocket, WebSocketDisconnect | |
| from fastapi.middleware.cors import CORSMiddleware | |
| from openenv.core.env_server.types import ( | |
| HealthResponse, | |
| HealthStatus, | |
| ResetRequest as OEResetRequest, | |
| ResetResponse, | |
| StepRequest, | |
| StepResponse, | |
| WSObservationResponse, | |
| WSStateResponse, | |
| WSErrorResponse, | |
| WSErrorCode, | |
| ) | |
| from data.tasks import TASKS | |
| from env.grader import Grader | |
| from env.state_manager import StateManager | |
| from models.schemas import ( | |
| Action, | |
| BaselineResult, | |
| EpisodeScore, | |
| ResetRequest, | |
| TaskConfig, | |
| ) | |
| logging.basicConfig(level=logging.INFO) | |
| logger = logging.getLogger(__name__) | |
| app = FastAPI( | |
| title="OpenENV β Content Moderation Environment", | |
| description=( | |
| "A multi-step RL environment for AI content moderation agents. " | |
| "Agents receive partial observations and must investigate context, " | |
| "classify violations, and make final moderation decisions." | |
| ), | |
| version="1.0.0", | |
| ) | |
| app.add_middleware( | |
| CORSMiddleware, | |
| allow_origins=["*"], # Open for HF Spaces + local dev | |
| allow_methods=["*"], | |
| allow_headers=["*"], | |
| ) | |
| # Single shared state manager (single-threaded MVP) | |
| _state_manager = StateManager() | |
| _grader = Grader() | |
| # --------------------------------------------------------------------------- | |
| # Endpoints | |
| # --------------------------------------------------------------------------- | |
| def health() -> HealthResponse: | |
| return HealthResponse(status=HealthStatus.HEALTHY) | |
| def list_tasks() -> dict[str, TaskConfig]: | |
| return TASKS | |
| def reset(request: OEResetRequest | None = Body(default=None)) -> ResetResponse: | |
| # task_id passed as extra field; fall back to episode_id or default | |
| extra = (request.model_extra or {}) if request else {} | |
| task_id = extra.get("task_id") or (request.episode_id if request else None) or "easy_harassment" | |
| seed = (request.seed if request else None) or 42 | |
| if task_id not in TASKS: | |
| raise HTTPException( | |
| status_code=400, | |
| detail=f"Unknown task_id '{task_id}'. Available: {list(TASKS.keys())}", | |
| ) | |
| task = TASKS[task_id] | |
| task = task.model_copy(update={"seed": seed}) | |
| obs = _state_manager.reset(task) | |
| return ResetResponse(observation=obs.model_dump(), reward=None, done=obs.done) | |
| def step(request: StepRequest) -> StepResponse: | |
| if not _state_manager.has_active_episode(): | |
| raise HTTPException(status_code=400, detail="No active episode. Call /reset first.") | |
| try: | |
| action = Action(**request.action) | |
| except Exception as exc: | |
| raise HTTPException(status_code=422, detail=str(exc)) | |
| try: | |
| result = _state_manager.step(action) | |
| except ValueError as exc: | |
| raise HTTPException(status_code=400, detail=str(exc)) | |
| logger.info( | |
| "Step %d: action=%s reward=%.3f done=%s", | |
| result.observation.step, | |
| action.action_type.value, | |
| result.reward, | |
| result.done, | |
| ) | |
| return StepResponse( | |
| observation=result.observation.model_dump(), | |
| reward=result.reward, | |
| done=result.done, | |
| ) | |
| def get_state() -> dict: | |
| if not _state_manager.has_active_episode(): | |
| raise HTTPException(status_code=400, detail="No active episode. Call /reset first.") | |
| return _state_manager.get_state().model_dump() | |
| async def websocket_endpoint(websocket: WebSocket) -> None: | |
| await websocket.accept() | |
| try: | |
| while True: | |
| try: | |
| raw = await websocket.receive_text() | |
| data = json.loads(raw) | |
| except json.JSONDecodeError: | |
| await websocket.send_text( | |
| WSErrorResponse(data={"message": "Invalid JSON", "code": WSErrorCode.INVALID_JSON}).model_dump_json() | |
| ) | |
| continue | |
| msg_type = data.get("type") | |
| if msg_type == "reset": | |
| reset_data = data.get("data", {}) | |
| task_id = reset_data.get("task_id") or reset_data.get("episode_id") or "easy_harassment" | |
| seed = reset_data.get("seed") or 42 | |
| if task_id not in TASKS: | |
| await websocket.send_text( | |
| WSErrorResponse(data={"message": f"Unknown task_id '{task_id}'", "code": WSErrorCode.VALIDATION_ERROR}).model_dump_json() | |
| ) | |
| continue | |
| task = TASKS[task_id].model_copy(update={"seed": seed}) | |
| obs = _state_manager.reset(task) | |
| await websocket.send_text( | |
| WSObservationResponse(data={"observation": obs.model_dump(), "reward": None, "done": obs.done}).model_dump_json() | |
| ) | |
| elif msg_type == "step": | |
| if not _state_manager.has_active_episode(): | |
| await websocket.send_text( | |
| WSErrorResponse(data={"message": "No active episode. Send reset first.", "code": WSErrorCode.SESSION_ERROR}).model_dump_json() | |
| ) | |
| continue | |
| action_data = data.get("data", {}) | |
| try: | |
| action = Action(**action_data) | |
| except Exception as exc: | |
| await websocket.send_text( | |
| WSErrorResponse(data={"message": str(exc), "code": WSErrorCode.VALIDATION_ERROR}).model_dump_json() | |
| ) | |
| continue | |
| try: | |
| result = _state_manager.step(action) | |
| except ValueError as exc: | |
| await websocket.send_text( | |
| WSErrorResponse(data={"message": str(exc), "code": WSErrorCode.EXECUTION_ERROR}).model_dump_json() | |
| ) | |
| continue | |
| await websocket.send_text( | |
| WSObservationResponse(data={"observation": result.observation.model_dump(), "reward": result.reward, "done": result.done}).model_dump_json() | |
| ) | |
| elif msg_type == "state": | |
| if not _state_manager.has_active_episode(): | |
| await websocket.send_text( | |
| WSErrorResponse(data={"message": "No active episode.", "code": WSErrorCode.SESSION_ERROR}).model_dump_json() | |
| ) | |
| continue | |
| obs = _state_manager.get_state() | |
| await websocket.send_text( | |
| WSStateResponse(data=obs.model_dump()).model_dump_json() | |
| ) | |
| elif msg_type == "close": | |
| break | |
| else: | |
| await websocket.send_text( | |
| WSErrorResponse(data={"message": f"Unknown message type: {msg_type!r}", "code": WSErrorCode.UNKNOWN_TYPE}).model_dump_json() | |
| ) | |
| except WebSocketDisconnect: | |
| pass | |
| def grade() -> EpisodeScore: | |
| if not _state_manager.has_active_episode(): | |
| raise HTTPException(status_code=400, detail="No active episode. Call /reset first.") | |
| episode = _state_manager.get_episode_state() | |
| if not episode.observation.done: | |
| raise HTTPException( | |
| status_code=400, | |
| detail="Episode is not finished yet. Complete the episode before grading.", | |
| ) | |
| score = _grader.score(episode) | |
| logger.info("Graded episode: total=%.4f", score.total) | |
| return score | |
| def baseline(task_id: str = "easy_harassment", seed: int | None = None) -> BaselineResult: | |
| """Run the built-in rule-based baseline agent and return its score.""" | |
| from baseline.agent import BaselineAgent | |
| if task_id not in TASKS: | |
| raise HTTPException( | |
| status_code=400, | |
| detail=f"Unknown task_id '{task_id}'. Available: {list(TASKS.keys())}", | |
| ) | |
| task = TASKS[task_id] | |
| if seed is not None: | |
| task = task.model_copy(update={"seed": seed}) | |
| agent = BaselineAgent(state_manager=_state_manager, grader=_grader) | |
| result = agent.run(task) | |
| return result | |
| def agent_run(request: ResetRequest) -> BaselineResult: | |
| """ | |
| Run the selected LLM agent (OpenAI or Gemini) on a full episode and return the graded result. | |
| Requires OPENAI_API_KEY, or GOOGLE_API_KEY/GEMINI_API_KEY depending on LLM_PROVIDER. | |
| """ | |
| import os | |
| from agent.openai_agent import OpenAIAgent | |
| from agent.gemini_agent import GeminiAgent | |
| provider = os.getenv("LLM_PROVIDER", "openai").lower() | |
| if request.task_id not in TASKS: | |
| raise HTTPException( | |
| status_code=400, | |
| detail=f"Unknown task_id '{request.task_id}'. Available: {list(TASKS.keys())}", | |
| ) | |
| task = TASKS[request.task_id] | |
| if request.seed is not None: | |
| task = task.model_copy(update={"seed": request.seed}) | |
| try: | |
| if provider == "gemini": | |
| agent = GeminiAgent(state_manager=_state_manager, grader=_grader) | |
| else: | |
| agent = OpenAIAgent(state_manager=_state_manager, grader=_grader) | |
| except EnvironmentError as exc: | |
| raise HTTPException(status_code=500, detail=str(exc)) | |
| result = agent.run(task) | |
| logger.info( | |
| "%s agent finished: task=%s total=%.4f", provider.capitalize(), task.task_id, result.score.total | |
| ) | |
| return result | |