debug: (inference) yeah, given up

inference.py

@@ -1,272 +1 @@
-import asyncio
-import os
-import sys
-import json
-import subprocess
-import time
-import threading
-from pathlib import Path
-
-try :
-
-    import httpx
-    from dotenv import load_dotenv
-    from openai import OpenAI
-except Exception as e:
-    print("WHATTTTT : ", e)
-    sys.exit(0)
-
-try:
-    ROOT = Path(__file__).parent.resolve()
-    if str(ROOT) not in sys.path:
-        sys.path.insert(0, str(ROOT))
-
-except Exception as e:
-    print("BRUH : ", e)
-    sys.exit(0)
-
-
-try:
-    TASK_DIR = ROOT / "tasks"
-    from cloudenv.client import ClientEnvironment
-    from cloudenv.models import CloudEnvAction, CloudEnvObservation
-
-    load_dotenv()
-
-    HF_TOKEN = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
-    API_BASE_URL = os.getenv("API_BASE_URL", "https://api.openai.com/v1")
-    MODEL_NAME = os.getenv("MODEL_NAME", "gpt-4o")
-
-    MAX_STEPS = int(os.getenv("MAX_STEPS", "20"))
-    TEMPERATURE = float(os.getenv("TEMPERATURE", "0.3"))
-    MAX_TOKENS = int(os.getenv("MAX_TOKENS", "300"))
-
-    SERVER_URL = "http://127.0.0.1:8000"
-
-    TASK_ORDER = ["easy-task", "medium-task", "hard-task"]
-
-    client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
-    SYSTEM_PROMPT = 'Return ONLY JSON: {"service":"","operation":"","instance_id":null,"payload":{}}'
-except Exception as e:
-    print("At this point, I give up : ", e)
-    sys.exit(0)
-
-
-def start_ministack():
-    try:
-        proc = subprocess.Popen(
-            ["uv", "run", "ministack"],
-            cwd=ROOT,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
-        time.sleep(3)
-        return proc
-    except Exception as e:
-        print(f"[MINISTACK START ERROR] {e}", flush=True)
-        raise
-
-
-def start_server():
-    try:
-        proc = subprocess.Popen(
-            ["uv", "run", "server"],
-            cwd=ROOT,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            text=True,
-            bufsize=1,
-        )
-
-        def stream():
-            try:
-                for line in proc.stdout:
-                    print(f"[SERVER] {line}", end="")
-            except Exception as e:
-                print(f"[SERVER STREAM ERROR] {e}", flush=True)
-
-        threading.Thread(target=stream, daemon=True).start()
-
-        for _ in range(40):
-            try:
-                r = httpx.get(f"{SERVER_URL}/docs", timeout=1)
-                if r.status_code == 200:
-                    print("[INFO] server ready", flush=True)
-                    return proc
-            except Exception:
-                time.sleep(1)
-
-        raise RuntimeError("server failed to start")
-
-    except Exception as e:
-        print(f"[SERVER START ERROR] {e}", flush=True)
-        raise
-
-
-def load_task(name: str):
-    try:
-        return json.loads((TASK_DIR / f"{name}.json").read_text())
-    except Exception as e:
-        print(f"[TASK LOAD ERROR] {name}: {e}", flush=True)
-        raise
-
-
-def register_pipeline(task):
-    try:
-        url = f"{SERVER_URL}/api/pipelines"
-        with httpx.Client(timeout=20) as http:
-            r = http.post(url, json=task)
-
-            if r.status_code == 400:
-                try:
-                    detail = r.json().get("detail", "")
-                    if "already exists" in detail:
-                        http.delete(f"{url}/{task['pipeline_id']}")
-                        http.post(url, json=task)
-                except Exception:
-                    pass
-
-            r.raise_for_status()
-    except Exception as e:
-        print(f"[REGISTER ERROR] {e}", flush=True)
-
-
-def parse_action(raw: str, task_id: str, episode_id: str) -> CloudEnvAction:
-    try:
-        raw = raw.strip()
-        raw = raw[raw.find("{") : raw.rfind("}") + 1]
-        d = json.loads(raw)
-        return CloudEnvAction(
-            task_id=task_id,
-            episode_id=episode_id,
-            service=d.get("service", "internal"),
-            instance_id=d.get("instance_id"),
-            operation=d.get("operation", "GetCallerIdentity"),
-            payload=d.get("payload", {}),
-            principal_arn=d.get("principal_arn"),
-            intent=d.get("intent"),
-        )
-    except Exception:
-        return CloudEnvAction(
-            task_id=task_id,
-            episode_id=episode_id,
-            service="internal",
-            operation="GetCallerIdentity",
-            payload={},
-        )
-
-
-def call_model(step, state, broken, ideal, history):
-    try:
-        prompt = f"""
-STEP {step}
-STATE {json.dumps(state)[:1000]}
-BROKEN {json.dumps(broken)[:1000]}
-IDEAL {json.dumps(ideal)[:1000]}
-HISTORY {history[-5:]}
-"""
-        res = client.chat.completions.create(
-            model=MODEL_NAME,
-            messages=[
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user", "content": prompt},
-            ],
-            temperature=TEMPERATURE,
-            max_tokens=MAX_TOKENS,
-        )
-        return (res.choices[0].message.content or "").strip()
-    except Exception as e:
-        print(f"[MODEL ERROR] {e}", flush=True)
-        return "{}"
-
-
-async def run_episode(task):
-    try:
-        pipeline_id = task["pipeline_id"]
-        task_id = pipeline_id
-        episode_id = f"{pipeline_id}-episode-1"
-
-        env = ClientEnvironment(base_url=SERVER_URL)
-
-        try:
-            register_pipeline(task)
-        except Exception as e:
-            print(f"[REGISTER ERROR] {e}", flush=True)
-
-        try:
-            result = await env.initialize_environment(
-                task_id=task_id,
-                episode_id=episode_id,
-            )
-        except Exception as e:
-            print(f"[INIT ERROR] {e}", flush=True)
-            return
-
-        obs = result.observation
-
-        history = []
-        rewards = []
-
-        for step in range(MAX_STEPS):
-            try:
-                if obs.done:
-                    break
-
-                raw = call_model(
-                    step,
-                    obs.current_pipeline_state,
-                    task["broken_pipeline"],
-                    task["ideal_pipeline"],
-                    history,
-                )
-
-                action = parse_action(raw, task_id, episode_id)
-
-                result = await env.step(action)
-                obs = result.observation
-
-                rewards.append(float(obs.reward or 0))
-                history.append(raw)
-
-            except Exception as e:
-                print(f"[STEP ERROR] {e}", flush=True)
-                break
-
-        score = sum(rewards) / (len(rewards) or 1)
-        print(f"[END] task={task_id} score={score:.3f}", flush=True)
-
-    except Exception as e:
-        print(f"[EPISODE ERROR] {e}", flush=True)
-
-
-async def main():
-    try:
-        miniproc = start_ministack()
-        serverproc = start_server()
-
-        try:
-            for name in TASK_ORDER:
-                try:
-                    task = load_task(name)
-                    await run_episode(task)
-                except Exception as e:
-                    print(f"[TASK ERROR] {name}: {e}", flush=True)
-        finally:
-            try:
-                miniproc.terminate()
-            except Exception:
-                pass
-            try:
-                serverproc.terminate()
-            except Exception:
-                pass
-
-    except Exception as e:
-        print(f"[FATAL ERROR] {e}", flush=True)
-
-
-if __name__ == "__main__":
-    try:
-        asyncio.run(main())
-    except Exception as e:
-        print(f"[UNHANDLED TOP LEVEL ERROR] {e}", flush=True)
+print("REACHED")