Spaces:

printf-sourav
/

CICD

Sleeping

App Files Files Community

printf-sourav commited on Apr 6

Commit

74d797b

1 Parent(s): 3a8da1e

Add FastAPI server to fix 404

Browse files

Files changed (2) hide show

requirements.txt +5 -1
server/app.py +416 -170

requirements.txt CHANGED Viewed

@@ -1,5 +1,9 @@
 pyyaml
 fastapi
-uvicorn
 openenv-core
 openai

 pyyaml
 fastapi
+uvicorn[standard]
 openenv-core
 openai
+pydantic>=2.0.0
+transformers>=4.30.0
+torch>=2.0.0
+pytest>=7.0.0

server/app.py CHANGED Viewed

@@ -1,176 +1,422 @@
-from __future__ import annotations
-from dataclasses import dataclass
 import os
-from typing import Any
-from fastapi import FastAPI
-from fastapi import HTTPException
-from pydantic import BaseModel, Field
-import uvicorn
-from env.environment import CICDDebuggerEnvironment, MAX_STEPS
-from env.models import Action, Observation, Reward
-app = FastAPI(title="CI/CD Debugger OpenEnv Server")
-class ResetRequest(BaseModel):
-    task_id: str | None = None
-    difficulty: str | None = None
-    max_steps: int = Field(default=MAX_STEPS, ge=1, le=100)
-class StepRequest(BaseModel):
-    action: Action | str | dict[str, Any]
-class StepResponse(BaseModel):
-    task_id: str
-    step_count: int
-    reward: float
-    reward_model: Reward
-    done: bool
-    observation: Observation
-    last_action: str | None = None
-    info: dict[str, Any] = Field(default_factory=dict)
-class StateResponse(BaseModel):
-    initialized: bool
-    task_id: str | None = None
-    step_count: int = 0
-    done: bool = False
-    last_action: str | None = None
-    observation: Observation | None = None
-    internal_state: dict[str, Any] = Field(default_factory=dict)
-@dataclass
-class RuntimeSession:
-    env: CICDDebuggerEnvironment
-    task_id: str
-    step_count: int = 0
-    done: bool = False
-    last_action: str | None = None
-    last_reward: float = 0.0
-    last_observation: dict[str, Any] | None = None
-    last_info: dict[str, Any] | None = None
-runtime_session: RuntimeSession | None = None
-def _as_observation_model(observation: dict[str, Any] | Observation) -> Observation:
-    if isinstance(observation, Observation):
-        return observation
-    return Observation.model_validate(observation)
-def _build_step_response(session: RuntimeSession) -> StepResponse:
-    observation = session.last_observation or {}
-    info_payload = session.last_info or {}
-    reward_payload = info_payload.get("reward_model")
-    if isinstance(reward_payload, dict):
-        reward_model = Reward.model_validate(reward_payload)
-    else:
-        reward_model = Reward(value=float(session.last_reward), components={"total": float(session.last_reward)})
-    return StepResponse(
-        task_id=session.task_id,
-        step_count=int(observation.get("step_count") or session.step_count),
-        reward=float(session.last_reward),
-        reward_model=reward_model,
-        done=bool(session.done),
-        observation=_as_observation_model(observation),
-        last_action=session.last_action,
-        info=info_payload,
-    )
 @app.get("/health")
-def health() -> dict[str, str]:
-    return {"status": "ok"}
-@app.post("/reset", response_model=StepResponse)
-async def reset(payload: ResetRequest | None = None) -> StepResponse:
-    global runtime_session
-    request = payload or ResetRequest()
-    env = CICDDebuggerEnvironment(max_steps=int(request.max_steps))
-    observation = await env.reset(task_id=request.task_id, difficulty=request.difficulty)
-    runtime_session = RuntimeSession(
-        env=env,
-        task_id=str(observation.get("task_id", request.task_id or "cicd-debugger-task")),
-        step_count=0,
-        done=False,
-        last_action=None,
-        last_reward=0.0,
-        last_observation=observation,
-        last_info={
-            "message": "environment reset",
-            "tool": "reset",
-            "error": None,
-            "reward_model": Reward(value=0.0, components={"total": 0.0}).model_dump(),
         },
-    )
-    return _build_step_response(runtime_session)
-@app.post("/step", response_model=StepResponse)
-async def step(payload: StepRequest) -> StepResponse:
-    global runtime_session
-    if runtime_session is None:
-        raise HTTPException(status_code=400, detail="Environment not initialized. Call /reset first.")
-    if runtime_session.done:
-        return _build_step_response(runtime_session)
-    observation, reward, done, info = await runtime_session.env.step(payload.action)
-    runtime_session.step_count = int(observation.get("step_count", runtime_session.step_count + 1))
-    runtime_session.done = bool(done)
-    runtime_session.last_action = payload.action if isinstance(payload.action, str) else str(payload.action)
-    runtime_session.last_reward = float(reward)
-    runtime_session.last_observation = observation
-    runtime_session.last_info = dict(info or {})
-    return _build_step_response(runtime_session)
-@app.get("/state", response_model=StateResponse)
-async def state() -> StateResponse:
-    if runtime_session is None:
-        return StateResponse(initialized=False)
-    observation = None
-    if runtime_session.last_observation is not None:
-        observation = _as_observation_model(runtime_session.last_observation)
-    return StateResponse(
-        initialized=True,
-        task_id=runtime_session.task_id,
-        step_count=runtime_session.step_count,
-        done=runtime_session.done,
-        last_action=runtime_session.last_action,
-        observation=observation,
-        internal_state=runtime_session.env.state(),
-    )
-@app.post("/state", response_model=StateResponse)
-async def state_post() -> StateResponse:
-    return await state()
-def main() -> None:
-    port = int(os.getenv("PORT", "7860"))
-    uvicorn.run(app, host="0.0.0.0", port=port)
 if __name__ == "__main__":
-    main()

+"""
+FastAPI Server for CI/CD Debugger Environment
+This wraps the OpenEnv environment in HTTP endpoints for HuggingFace Spaces
+"""
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional
+import sys
 import os
+# Add parent directory to path so we can import from env/
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from env.environment import CICDDebuggerEnv
+from env.models import Action, ActionType, Observation, Reward, StepInfo
+app = FastAPI(
+    title="CI/CD Pipeline Debugger",
+    description="OpenEnv-compliant RL environment for CI/CD debugging",
+    version="1.0.0"
+)
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+# Global environment instance
+env_instance = None
+@app.get("/", response_class=HTMLResponse)
+async def home():
+    """Landing page - fixes 404 error"""
+    return """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>CI/CD Debugger - OpenEnv</title>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <style>
+            * { margin: 0; padding: 0; box-sizing: border-box; }
+            body {
+                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                min-height: 100vh;
+                padding: 20px;
+            }
+            .container {
+                max-width: 900px;
+                margin: 50px auto;
+                background: white;
+                border-radius: 20px;
+                box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+                overflow: hidden;
+            }
+            .header {
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                color: white;
+                padding: 40px;
+                text-align: center;
+            }
+            .header h1 {
+                font-size: 2.5em;
+                margin-bottom: 10px;
+                font-weight: 700;
+            }
+            .status {
+                display: inline-block;
+                padding: 8px 20px;
+                background: rgba(255,255,255,0.2);
+                border-radius: 20px;
+                font-weight: 600;
+                margin-top: 10px;
+            }
+            .content { padding: 40px; }
+            .section {
+                margin-bottom: 30px;
+            }
+            .section h2 {
+                color: #2c3e50;
+                margin-bottom: 15px;
+                font-size: 1.5em;
+                border-bottom: 3px solid #667eea;
+                padding-bottom: 10px;
+            }
+            .endpoint {
+                background: #f8f9fa;
+                padding: 15px 20px;
+                margin: 10px 0;
+                border-left: 4px solid #667eea;
+                font-family: 'Courier New', monospace;
+                border-radius: 5px;
+                display: flex;
+                align-items: center;
+            }
+            .endpoint .method {
+                background: #667eea;
+                color: white;
+                padding: 4px 12px;
+                border-radius: 4px;
+                margin-right: 15px;
+                font-weight: bold;
+                font-size: 0.85em;
+            }
+            .stats {
+                display: grid;
+                grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+                gap: 20px;
+                margin: 20px 0;
+            }
+            .stat-card {
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                color: white;
+                padding: 20px;
+                border-radius: 10px;
+                text-align: center;
+            }
+            .stat-card .number {
+                font-size: 2.5em;
+                font-weight: bold;
+                margin-bottom: 5px;
+            }
+            .stat-card .label {
+                opacity: 0.9;
+                font-size: 0.9em;
+            }
+            button {
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                color: white;
+                border: none;
+                padding: 15px 30px;
+                border-radius: 10px;
+                cursor: pointer;
+                font-size: 16px;
+                font-weight: 600;
+                margin: 10px 10px 10px 0;
+                transition: transform 0.2s, box-shadow 0.2s;
+            }
+            button:hover {
+                transform: translateY(-2px);
+                box-shadow: 0 10px 20px rgba(102, 126, 234, 0.4);
+            }
+            button:active {
+                transform: translateY(0);
+            }
+            pre {
+                background: #2c3e50;
+                color: #ecf0f1;
+                padding: 20px;
+                border-radius: 10px;
+                overflow-x: auto;
+                font-size: 0.9em;
+                line-height: 1.6;
+            }
+            .links {
+                display: flex;
+                flex-wrap: wrap;
+                gap: 15px;
+                margin-top: 20px;
+            }
+            .links a {
+                display: inline-flex;
+                align-items: center;
+                padding: 12px 24px;
+                background: #f8f9fa;
+                color: #667eea;
+                text-decoration: none;
+                border-radius: 8px;
+                font-weight: 600;
+                transition: all 0.2s;
+                border: 2px solid transparent;
+            }
+            .links a:hover {
+                background: #667eea;
+                color: white;
+                border-color: #667eea;
+            }
+            .footer {
+                background: #f8f9fa;
+                padding: 20px;
+                text-align: center;
+                color: #7f8c8d;
+                font-size: 0.9em;
+            }
+            .loading {
+                display: inline-block;
+                width: 20px;
+                height: 20px;
+                border: 3px solid rgba(255,255,255,.3);
+                border-radius: 50%;
+                border-top-color: #667eea;
+                animation: spin 1s ease-in-out infinite;
+            }
+            @keyframes spin {
+                to { transform: rotate(360deg); }
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="header">
+                <h1>🚀 CI/CD Pipeline Debugger</h1>
+                <p>OpenEnv-Compliant Reinforcement Learning Environment</p>
+                <div class="status">✅ Status: Online & Ready</div>
+            </div>
+            <div class="content">
+                <div class="section">
+                    <h2>📊 Environment Stats</h2>
+                    <div class="stats">
+                        <div class="stat-card">
+                            <div class="number">13</div>
+                            <div class="label">Total Tasks</div>
+                        </div>
+                        <div class="stat-card">
+                            <div class="number">3</div>
+                            <div class="label">Difficulty Levels</div>
+                        </div>
+                        <div class="stat-card">
+                            <div class="number">5</div>
+                            <div class="label">Anti-Hack Traps</div>
+                        </div>
+                        <div class="stat-card">
+                            <div class="number">7</div>
+                            <div class="label">Action Types</div>
+                        </div>
+                    </div>
+                </div>
+                <div class="section">
+                    <h2>🔌 API Endpoints</h2>
+                    <div class="endpoint">
+                        <span class="method">POST</span>
+                        <span>/reset - Initialize new debugging episode</span>
+                    </div>
+                    <div class="endpoint">
+                        <span class="method">POST</span>
+                        <span>/step - Execute action and receive reward</span>
+                    </div>
+                    <div class="endpoint">
+                        <span class="method">GET</span>
+                        <span>/state - Get current environment state</span>
+                    </div>
+                    <div class="endpoint">
+                        <span class="method">GET</span>
+                        <span>/health - Health check endpoint</span>
+                    </div>
+                </div>
+                <div class="section">
+                    <h2>🧪 Quick Test</h2>
+                    <button onclick="testReset()">🔄 Test Reset</button>
+                    <button onclick="testHealth()">❤️ Health Check</button>
+                    <button onclick="clearOutput()">🗑️ Clear Output</button>
+                    <pre id="output">Click a button above to test the API endpoints...</pre>
+                </div>
+                <div class="section">
+                    <h2>📚 Resources</h2>
+                    <div class="links">
+                        <a href="/docs">📖 Interactive API Docs (Swagger)</a>
+                        <a href="/redoc">📚 API Documentation (ReDoc)</a>
+                        <a href="https://github.com/yourusername/cicd-debugger" target="_blank">💻 GitHub Repository</a>
+                    </div>
+                </div>
+            </div>
+            <div class="footer">
+                <p><strong>Built for OpenEnv Hackathon 2026</strong></p>
+                <p>Features: Multi-step debugging | LLM Judge | Reward Shaping | Anti-Hacking Detection</p>
+            </div>
+        </div>
+        <script>
+        async function testReset() {
+            const output = document.getElementById('output');
+            output.innerHTML = '<div class="loading"></div> Testing /reset endpoint...';
+            try {
+                const res = await fetch('/reset', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' }
+                });
+                const data = await res.json();
+                output.textContent = JSON.stringify(data, null, 2);
+            } catch(e) {
+                output.textContent = '❌ Error: ' + e.message;
+            }
+        }
+        async function testHealth() {
+            const output = document.getElementById('output');
+            output.innerHTML = '<div class="loading"></div> Checking health status...';
+            try {
+                const res = await fetch('/health');
+                const data = await res.json();
+                output.textContent = JSON.stringify(data, null, 2);
+            } catch(e) {
+                output.textContent = '❌ Error: ' + e.message;
+            }
+        }
+        function clearOutput() {
+            document.getElementById('output').textContent = 'Output cleared. Click a button to test...';
+        }
+        </script>
+    </body>
+    </html>
+    """
 @app.get("/health")
+async def health():
+    """Health check endpoint for monitoring"""
+    return {
+        "status": "healthy",
+        "service": "cicd-debugger-env",
+        "version": "1.0.0",
+        "openenv_compliant": True,
+        "endpoints": {
+            "reset": "/reset",
+            "step": "/step",
+            "state": "/state",
+            "docs": "/docs",
+            "redoc": "/redoc"
         },
+        "tasks": {
+            "easy": 5,
+            "medium": 5,
+            "hard": 3,
+            "total": 13
+        }
+    }
+@app.post("/reset")
+async def reset():
+    """
+    Reset environment to initial state
+    Returns: Initial observation
+    """
+    global env_instance
+    try:
+        env_instance = CICDDebuggerEnv()
+        obs = await env_instance.reset()
+        return JSONResponse(content=obs.dict())
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to reset environment: {str(e)}"
+        )
+@app.post("/step")
+async def step(action: dict):
+    """
+    Execute one step in the environment
+    Args:
+        action: Action dictionary with action_type and parameters
+    Returns:
+        observation, reward, done, info
+    """
+    global env_instance
+    try:
+        if env_instance is None:
+            raise HTTPException(
+                status_code=400,
+                detail="Environment not initialized. Call /reset first."
+            )
+        # Convert dict to Action object
+        action_obj = Action(**action)
+        # Execute step
+        obs, reward, done, info = await env_instance.step(action_obj)
+        return JSONResponse(content={
+            "observation": obs.dict(),
+            "reward": reward.dict(),
+            "done": done,
+            "info": info.dict()
+        })
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Step execution failed: {str(e)}"
+        )
+@app.get("/state")
+async def get_state():
+    """
+    Get current environment state
+    Returns:
+        Current state dictionary
+    """
+    global env_instance
+    try:
+        if env_instance is None:
+            raise HTTPException(
+                status_code=400,
+                detail="Environment not initialized. Call /reset first."
+            )
+        state = await env_instance.state()
+        return JSONResponse(content=state)
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to get state: {str(e)}"
+        )
+# For local development
 if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)