Upload folder using huggingface_hub

server/app.py

@@ -3,25 +3,24 @@
 from __future__ import annotations
 
 import json
+import os
 import sys
-import traceback
 from pathlib import Path
 
-# Allow importing sibling modules when running from server/ dir
 sys.path.insert(0, str(Path(__file__).parent))
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 from fastapi import FastAPI, HTTPException
-from fastapi.responses import HTMLResponse
+from fastapi.responses import HTMLResponse, RedirectResponse
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 
 from models import FakeGangAction, FakeGangObservation, FakeGangState, ActionType
 from environment import FakeGangEnvironment
 
 # ---------------------------------------------------------------------------
-# App setup
+# App
 # ---------------------------------------------------------------------------
 
 app = FastAPI(
@@ -32,16 +31,14 @@ app = FastAPI(
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
+    allow_origins=["*"], allow_methods=["*"], allow_headers=["*"],
 )
 
 _env = FakeGangEnvironment()
 
 
 # ---------------------------------------------------------------------------
-# Request/response schemas
+# Schemas
 # ---------------------------------------------------------------------------
 
 class ResetRequest(BaseModel):
@@ -49,7 +46,6 @@ class ResetRequest(BaseModel):
     seed: Optional[int] = None
     episode_id: Optional[str] = None
 
-
 class StepResponse(BaseModel):
     observation: Dict[str, Any]
     done: bool
@@ -58,43 +54,29 @@ class StepResponse(BaseModel):
 
 
 # ---------------------------------------------------------------------------
-# API Endpoints
+# OpenEnv API endpoints
 # ---------------------------------------------------------------------------
 
 @app.get("/health")
-def health() -> Dict[str, str]:
+def health():
     return {"status": "healthy"}
 
-
 @app.post("/reset", response_model=StepResponse)
-def reset(req: ResetRequest) -> StepResponse:
+def reset(req: ResetRequest):
     obs = _env.reset(task=req.task, seed=req.seed, episode_id=req.episode_id)
-    return StepResponse(
-        observation=obs.model_dump(),
-        done=obs.done,
-        reward=obs.reward,
-        message=obs.message,
-    )
-
+    return StepResponse(observation=obs.model_dump(), done=obs.done, reward=obs.reward, message=obs.message)
 
 @app.post("/step", response_model=StepResponse)
-def step(action: FakeGangAction) -> StepResponse:
+def step(action: FakeGangAction):
     obs = _env.step(action)
-    return StepResponse(
-        observation=obs.model_dump(),
-        done=obs.done,
-        reward=obs.reward,
-        message=obs.message,
-    )
-
+    return StepResponse(observation=obs.model_dump(), done=obs.done, reward=obs.reward, message=obs.message)
 
 @app.get("/state")
-def state() -> Dict[str, Any]:
+def state():
     return _env.state.model_dump()
 
-
 @app.get("/tasks")
-def list_tasks() -> Dict[str, Any]:
+def list_tasks():
     return {
         "tasks": ["easy", "medium", "hard"],
         "descriptions": {
@@ -109,159 +91,90 @@ def list_tasks() -> Dict[str, Any]:
         "score_range": [0.0, 1.0],
     }
 
-
 @app.get("/grader")
-def grader() -> Dict[str, Any]:
+def grader():
     if not _env._done:
         raise HTTPException(status_code=400, detail="Episode not complete. Call SUBMIT first.")
-    return {
-        "score": _env._last_grader_score,
-        "task": _env._task,
-        "episode_id": _env._episode_id,
-    }
-
+    return {"score": _env._last_grader_score, "task": _env._task, "episode_id": _env._episode_id}
 
 @app.get("/metadata")
-def metadata() -> Dict[str, Any]:
+def metadata():
     return {
         "name": "graphstrike",
-        "description": (
-            "RL environment for detecting coordinated fake account rings in social networks. "
-            "An AI agent must identify all 10 members of a coordinated fake account ring "
-            "hidden inside a synthetic social network before they evade detection."
-        ),
-        "version": "1.0.0",
-        "author": "Pandago",
-        "tags": ["social-network", "fraud-detection", "graph", "rl", "fake-account-detection"],
+        "description": "RL environment for detecting coordinated fake account rings in social networks.",
+        "version": "1.0.0", "author": "Pandago",
+        "tags": ["social-network", "fraud-detection", "graph", "rl"],
     }
 
-
 @app.get("/schema")
-def schema() -> Dict[str, Any]:
+def schema():
     return {
         "action": FakeGangAction.model_json_schema(),
         "observation": FakeGangObservation.model_json_schema(),
         "state": FakeGangState.model_json_schema(),
     }
 
-
 @app.post("/mcp")
-def mcp(body: Dict[str, Any] = {}) -> Dict[str, Any]:
-    """Minimal MCP (Model Context Protocol) JSON-RPC 2.0 endpoint."""
+def mcp(body: Dict[str, Any] = {}):
     method = body.get("method", "")
     req_id = body.get("id", 1)
-
     if method == "tools/list":
-        return {
-            "jsonrpc": "2.0",
-            "id": req_id,
-            "result": {
-                "tools": [
-                    {
-                        "name": "reset",
-                        "description": "Reset the environment with a task and seed",
-                        "inputSchema": {
-                            "type": "object",
-                            "properties": {
-                                "task": {"type": "string", "enum": ["easy", "medium", "hard"]},
-                                "seed": {"type": "integer"},
-                            },
-                        },
-                    },
-                    {
-                        "name": "step",
-                        "description": "Take an action in the environment",
-                        "inputSchema": FakeGangAction.model_json_schema(),
-                    },
-                    {
-                        "name": "state",
-                        "description": "Get current episode state",
-                        "inputSchema": {"type": "object", "properties": {}},
-                    },
-                ]
-            },
-        }
-
-    return {
-        "jsonrpc": "2.0",
-        "id": req_id,
-        "result": {
-            "name": "graphstrike",
-            "version": "1.0.0",
-            "protocolVersion": "2024-11-05",
-        },
-    }
-
+        return {"jsonrpc": "2.0", "id": req_id, "result": {"tools": [
+            {"name": "reset", "description": "Reset the environment",
+             "inputSchema": {"type": "object", "properties": {"task": {"type": "string"}, "seed": {"type": "integer"}}}},
+            {"name": "step", "description": "Take an action", "inputSchema": FakeGangAction.model_json_schema()},
+            {"name": "state", "description": "Get episode state", "inputSchema": {"type": "object", "properties": {}}},
+        ]}}
+    return {"jsonrpc": "2.0", "id": req_id, "result": {"name": "graphstrike", "version": "1.0.0", "protocolVersion": "2024-11-05"}}
 
 @app.post("/baseline")
-def baseline() -> Dict[str, Any]:
+def baseline():
     sys.path.insert(0, str(Path(__file__).parent.parent))
-    from inference import run_rule_based_episode  # type: ignore[import]
-    scores: Dict[str, float] = {}
+    from inference import run_rule_based_episode
+    scores = {}
     for task in ["easy", "medium", "hard"]:
         scores[task] = run_rule_based_episode(_env, task=task, seed=0)
     return {"scores": scores, "agent": "rule_based"}
 
 
 # ---------------------------------------------------------------------------
-# Gradio web interface
+# Gradio web interface — mounted at /
 # ---------------------------------------------------------------------------
 
-_gradio_mounted = False
-
 try:
     import gradio as gr
-    print("[GraphStrike] Gradio found, building web UI...", flush=True)
-
-    _demo_env = _env
 
-    def _fmt_obs(obs_dict: dict) -> str:
+    def _fmt_obs(d: dict) -> str:
         lines = []
-        lines.append(
-            f"**Task:** {obs_dict.get('task', '?')}  |  "
-            f"**Done:** {obs_dict.get('done', False)}  |  "
-            f"**Steps remaining:** {obs_dict.get('steps_remaining', '?')}"
-        )
-        if obs_dict.get('reward') is not None:
-            lines.append(f"**Reward:** {obs_dict['reward']:.2f}")
-        lines.append(f"**Flagged ({len(obs_dict.get('flagged_ids', []))}/ 10):** {obs_dict.get('flagged_ids', [])}")
-        suspects = obs_dict.get('suspect_ids', [])
-        lines.append(f"**Suspects ({len(suspects)}):** {suspects}")
-        lines.append(f"**Visible accounts:** {len(obs_dict.get('visible_account_ids', []))} IDs")
-        lines.append(f"**Inspected:** {len(obs_dict.get('inspected_ids', []))} accounts")
-        if obs_dict.get('evasion_triggered'):
-            lines.append(f"**Evasion events fired:** {obs_dict.get('evasion_count', 0)}")
-        lines.append(f"**Message:** {obs_dict.get('message', '')}")
+        lines.append(f"**Task:** {d.get('task','?')}  |  **Done:** {d.get('done',False)}  |  **Steps remaining:** {d.get('steps_remaining','?')}")
+        if d.get('reward') is not None:
+            lines.append(f"**Reward:** {d['reward']:.2f}")
+        fl = d.get('flagged_ids', [])
+        lines.append(f"**Flagged ({len(fl)}/10):** {fl}")
+        su = d.get('suspect_ids', [])
+        lines.append(f"**Suspects ({len(su)}):** {su}")
+        lines.append(f"**Visible:** {len(d.get('visible_account_ids',[]))} IDs  |  **Inspected:** {len(d.get('inspected_ids',[]))} accounts")
+        if d.get('evasion_triggered'):
+            lines.append(f"**Evasion events:** {d.get('evasion_count',0)}")
+        lines.append(f"**Message:** {d.get('message','')}")
         return "\n\n".join(lines)
 
-    def _fmt_profiles(obs_dict: dict) -> str:
-        accounts = obs_dict.get("visible_accounts", [])
-        if not accounts:
-            return "No accounts inspected yet. Use **INSPECT** on an account to reveal its profile."
-        rows = []
-        rows.append("| Account | Status | Risk | Node | Beh. | Graph | Hub | Photo | Bio | F.Nbrs |")
-        rows.append("|---------|--------|------|------|------|-------|-----|-------|-----|--------|")
-        sorted_accs = sorted(accounts, key=lambda a: a.get("fake_risk_score", 0), reverse=True)
-        for a in sorted_accs[:25]:
-            rows.append(
-                f"| {a.get('account_id','')} "
-                f"| {a.get('status','?')} "
-                f"| {a.get('fake_risk_score',0):.3f} "
-                f"| {a.get('node_risk',0):.2f} "
-                f"| {a.get('behavior_risk',0):.2f} "
-                f"| {a.get('graph_risk',0):.2f} "
-                f"| {a.get('hub_legitimacy_score',0):.2f} "
-                f"| {a.get('photo_reuse_score',0):.2f} "
-                f"| {a.get('bio_template_score',0):.2f} "
-                f"| {a.get('flagged_neighbor_count',0)} |"
-            )
-        if len(accounts) > 25:
-            rows.append(f"| ... +{len(accounts) - 25} more | | | | | | | | | |")
+    def _fmt_profiles(d: dict) -> str:
+        accs = d.get("visible_accounts", [])
+        if not accs:
+            return "No accounts inspected yet. Use **INSPECT** to reveal profiles."
+        rows = ["| Account | Status | Risk | Node | Beh | Graph | Hub | Photo | Bio | F.Nbrs |",
+                "|---------|--------|------|------|-----|-------|-----|-------|-----|--------|"]
+        for a in sorted(accs, key=lambda x: x.get("fake_risk_score",0), reverse=True)[:25]:
+            rows.append(f"| {a.get('account_id','')} | {a.get('status','?')} | {a.get('fake_risk_score',0):.3f} "
+                        f"| {a.get('node_risk',0):.2f} | {a.get('behavior_risk',0):.2f} | {a.get('graph_risk',0):.2f} "
+                        f"| {a.get('hub_legitimacy_score',0):.2f} | {a.get('photo_reuse_score',0):.2f} "
+                        f"| {a.get('bio_template_score',0):.2f} | {a.get('flagged_neighbor_count',0)} |")
         return "\n".join(rows)
 
     def gr_reset(task, seed):
         try:
-            obs = _demo_env.reset(task=task, seed=int(seed))
+            obs = _env.reset(task=task, seed=int(seed))
             d = obs.model_dump()
             return _fmt_obs(d), _fmt_profiles(d), json.dumps(d, indent=2, default=str)
         except Exception as e:
@@ -271,27 +184,21 @@ try:
         try:
             acc = account_id.strip() if action_type != "submit" else None
             action = FakeGangAction(action_type=ActionType(action_type), account_id=acc)
-            obs = _demo_env.step(action)
+            obs = _env.step(action)
             d = obs.model_dump()
             return _fmt_obs(d), _fmt_profiles(d), json.dumps(d, indent=2, default=str)
         except Exception as e:
             return f"**Error:** {e}", "", "{}"
 
     def gr_grader():
-        if not _demo_env._done:
+        if not _env._done:
             return "Episode not complete. Call SUBMIT first."
-        return json.dumps({
-            "score": _demo_env._last_grader_score,
-            "task": _demo_env._task,
-            "episode_id": _demo_env._episode_id,
-        }, indent=2)
+        return json.dumps({"score": _env._last_grader_score, "task": _env._task, "episode_id": _env._episode_id}, indent=2)
 
     def gr_baseline():
         sys.path.insert(0, str(Path(__file__).parent.parent))
         from inference import run_rule_based_episode
-        scores = {}
-        for t in ["easy", "medium", "hard"]:
-            scores[t] = run_rule_based_episode(_demo_env, task=t, seed=0)
+        scores = {t: run_rule_based_episode(_env, task=t, seed=0) for t in ["easy", "medium", "hard"]}
         return json.dumps({"scores": scores, "agent": "rule_based"}, indent=2)
 
     with gr.Blocks(title="GraphStrike") as demo:
@@ -300,99 +207,61 @@ try:
             "### Coordinated Fake Account Ring Detection — OpenEnv RL Environment\n\n"
             "Detect all 10 members of a coordinated fake account ring hidden in a social network.\n"
             "Use **INSPECT** to reveal profiles, **FLAG** to mark fakes, **SUBMIT** to end.\n\n"
-            "**API endpoints:** `/reset`, `/step`, `/state`, `/grader`, `/baseline`, `/tasks`, `/health`"
+            "`/reset` `/step` `/state` `/grader` `/baseline` `/tasks` `/health` — [Swagger](/docs)"
         )
-
         with gr.Row():
-            with gr.Column(scale=1):
+            with gr.Column():
                 gr.Markdown("#### 1. Start Episode")
-                task_dd = gr.Dropdown(["easy", "medium", "hard"], value="easy", label="Task")
-                seed_input = gr.Number(value=0, label="Seed", precision=0)
+                task_dd = gr.Dropdown(["easy","medium","hard"], value="easy", label="Task")
+                seed_in = gr.Number(value=0, label="Seed", precision=0)
                 reset_btn = gr.Button("Reset Episode", variant="primary", size="lg")
-
-            with gr.Column(scale=1):
+            with gr.Column():
                 gr.Markdown("#### 2. Take Actions")
-                action_dd = gr.Dropdown(
-                    ["inspect", "investigate_network", "flag", "unflag", "submit"],
-                    value="inspect", label="Action Type"
-                )
-                acc_input = gr.Textbox(label="Account ID", placeholder="e.g. acc_0012")
+                action_dd = gr.Dropdown(["inspect","investigate_network","flag","unflag","submit"], value="inspect", label="Action Type")
+                acc_in = gr.Textbox(label="Account ID", placeholder="e.g. acc_0012")
                 step_btn = gr.Button("Step", variant="primary", size="lg")
 
-        obs_summary = gr.Markdown(value="*Click 'Reset Episode' to begin.*")
-
+        obs_md = gr.Markdown(value="*Click 'Reset Episode' to begin.*")
         with gr.Accordion("Account Profiles (sorted by risk)", open=True):
-            profiles_md = gr.Markdown(value="")
-
+            prof_md = gr.Markdown(value="")
         with gr.Row():
             grader_btn = gr.Button("Get Grader Score")
             baseline_btn = gr.Button("Run Baseline (all 3 tasks)")
         result_box = gr.Textbox(label="Result", lines=5, interactive=False)
-
-        with gr.Accordion("Raw JSON Observation", open=False):
+        with gr.Accordion("Raw JSON", open=False):
             raw_json = gr.Textbox(label="Raw JSON", lines=15, interactive=False)
 
-        reset_btn.click(gr_reset, [task_dd, seed_input], [obs_summary, profiles_md, raw_json])
-        step_btn.click(gr_step, [action_dd, acc_input], [obs_summary, profiles_md, raw_json])
+        reset_btn.click(gr_reset, [task_dd, seed_in], [obs_md, prof_md, raw_json])
+        step_btn.click(gr_step, [action_dd, acc_in], [obs_md, prof_md, raw_json])
         grader_btn.click(gr_grader, [], result_box)
         baseline_btn.click(gr_baseline, [], result_box)
 
     app = gr.mount_gradio_app(app, demo, path="/")
-    _gradio_mounted = True
     print("[GraphStrike] Gradio UI mounted at /", flush=True)
 
 except Exception as exc:
-    print(f"[GraphStrike] Gradio not available ({exc}), serving HTML fallback", flush=True)
-    traceback.print_exc()
+    print(f"[GraphStrike] Gradio unavailable: {exc}", flush=True)
 
+    @app.get("/", response_class=HTMLResponse)
+    def root_fallback():
+        return "<html><body><h1>GraphStrike</h1><p>API-only mode. <a href='/docs'>Swagger</a></p></body></html>"
 
-# ---------------------------------------------------------------------------
-# Fallback: if Gradio didn't load, serve a simple HTML page at /
-# ---------------------------------------------------------------------------
 
-if not _gradio_mounted:
-    @app.get("/", response_class=HTMLResponse)
-    def root_html():
-        return """<!DOCTYPE html>
-<html><head><title>GraphStrike</title>
-<style>body{font-family:system-ui;max-width:800px;margin:40px auto;padding:0 20px;background:#0d1117;color:#c9d1d9}
-a{color:#58a6ff}h1{color:#f0f6fc}code{background:#161b22;padding:2px 6px;border-radius:4px}
-pre{background:#161b22;padding:16px;border-radius:8px;overflow-x:auto}
-.ep{background:#161b22;padding:16px;border-radius:8px;margin:12px 0}</style></head>
-<body>
-<h1>GraphStrike</h1>
-<p><strong>Coordinated Fake Account Ring Detection</strong> &mdash; OpenEnv RL Environment</p>
-<h3>API Endpoints</h3>
-<div class="ep"><pre>GET  /health     — liveness check
-GET  /tasks      — task list + action schema
-POST /reset      — start episode  {"task":"easy","seed":0}
-POST /step       — take action    {"action_type":"inspect","account_id":"acc_0012"}
-GET  /state      — episode state
-GET  /grader     — score after SUBMIT
-POST /baseline   — rule-based agent on all 3 tasks
-GET  /metadata   — environment metadata
-GET  /schema     — action/observation/state schemas
-POST /mcp        — MCP JSON-RPC 2.0</pre></div>
-<h3>Quick Test</h3>
-<pre>curl -X POST /reset -H "Content-Type: application/json" -d '{"task":"easy","seed":0}'
-curl -X POST /step  -H "Content-Type: application/json" -d '{"action_type":"inspect","account_id":"acc_0000"}'
-curl -X POST /step  -H "Content-Type: application/json" -d '{"action_type":"submit"}'
-curl /grader</pre>
-<p><a href="/docs">Interactive API docs (Swagger)</a> &nbsp;|&nbsp; <a href="/redoc">ReDoc</a></p>
-</body></html>"""
+# HF Spaces probes /web — redirect to root (Gradio UI)
+@app.get("/web", response_class=RedirectResponse)
+def web_redirect():
+    return RedirectResponse(url="/")
 
 
 # ---------------------------------------------------------------------------
 # Entry point
 # ---------------------------------------------------------------------------
 
-def main() -> None:
-    """Start the environment server. PORT env var controls the port (default 7860)."""
-    import os
+def main():
     import uvicorn
     port = int(os.environ.get("PORT", 7860))
+    print(f"[GraphStrike] Starting on port {port}", flush=True)
     uvicorn.run("server.app:app", host="0.0.0.0", port=port, log_level="info", workers=1)
 
-
 if __name__ == "__main__":
     main()