debug: (inference) yeah, given up fully

Author: vishvam-cstk

inference.py

@@ -7,265 +7,185 @@
 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)
+import httpx
+from dotenv import load_dotenv
+from openai import OpenAI
 
-try:
-    ROOT = Path(__file__).parent.resolve()
-    if str(ROOT) not in sys.path:
-        sys.path.insert(0, str(ROOT))
+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)
+TASK_DIR = ROOT / "tasks"
 
+from cloudenv.client import ClientEnvironment # noqa
+from cloudenv.models import CloudEnvAction, CloudEnvObservation # noqa
 
-try:
-    TASK_DIR = ROOT / "tasks"
-    from cloudenv.client import ClientEnvironment
-    from cloudenv.models import CloudEnvAction, CloudEnvObservation
+load_dotenv()
 
-    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")
 
-    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"))
 
-    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"
 
-    SERVER_URL = "http://127.0.0.1:8000"
+TASK_ORDER = ["easy-task", "medium-task", "hard-task"]
 
-    TASK_ORDER = ["easy-task", "medium-task", "hard-task"]
+client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
 
-    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)
+SYSTEM_PROMPT = '{"service":"","operation":"","instance_id":null,"payload":{}}'
 
 
 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
+    proc = subprocess.Popen(
+        ["uv", "run", "ministack"],
+        cwd=ROOT,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    time.sleep(3)
+    return proc
 
 
 def start_server():
-    try:
-        proc = subprocess.Popen(
-            ["uv", "run", "server"],
-            cwd=ROOT,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            text=True,
-            bufsize=1,
-        )
+    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)
+    def stream():
+        for line in proc.stdout:
+            print(f"[SERVER] {line}", end="")
 
-        threading.Thread(target=stream, daemon=True).start()
+    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)
+    for _ in range(40):
+        r = httpx.get(f"{SERVER_URL}/docs", timeout=1)
+        if r.status_code == 200:
+            print("[INFO] server ready")
+            return proc
+        time.sleep(1)
 
-        raise RuntimeError("server failed to start")
-
-    except Exception as e:
-        print(f"[SERVER START ERROR] {e}", flush=True)
-        raise
+    raise RuntimeError("server failed")
 
 
 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
+    return json.loads((TASK_DIR / f"{name}.json").read_text())
 
 
 def register_pipeline(task):
-    try:
-        url = f"{SERVER_URL}/api/pipelines"
-        with httpx.Client(timeout=20) as http:
-            r = http.post(url, json=task)
+    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
+        if r.status_code == 400:
+            detail = r.json().get("detail", "")
+            if "already exists" in detail:
+                http.delete(f"{url}/{task['pipeline_id']}")
+                http.post(url, json=task)
 
-            r.raise_for_status()
-    except Exception as e:
-        print(f"[REGISTER ERROR] {e}", flush=True)
+        r.raise_for_status()
 
 
 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={},
-        )
+    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"),
+    )
 
 
 def call_model(step, state, broken, ideal, history):
-    try:
-        prompt = f"""
+    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
+    res = client.chat.completions.create(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": prompt},
+        ],
+        temperature=TEMPERATURE,
+        max_tokens=MAX_TOKENS,
+    )
 
-        history = []
-        rewards = []
+    return (res.choices[0].message.content or "").strip()
 
-        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,
-                )
+def run_episode(task):
+    pipeline_id = task["pipeline_id"]
+    task_id = pipeline_id
+    episode_id = f"{pipeline_id}-episode-1"
 
-                action = parse_action(raw, task_id, episode_id)
+    env = ClientEnvironment(base_url=SERVER_URL)
 
-                result = await env.step(action)
-                obs = result.observation
+    register_pipeline(task)
 
-                rewards.append(float(obs.reward or 0))
-                history.append(raw)
+    result = asyncio.run(
+        env.initialize_environment(task_id=task_id, episode_id=episode_id)
+    )
 
-            except Exception as e:
-                print(f"[STEP ERROR] {e}", flush=True)
-                break
+    obs = result.observation
+
+    history = []
+    rewards = []
+
+    for step in range(MAX_STEPS):
+        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 = asyncio.run(env.step(action))
+        obs = result.observation
 
-        score = sum(rewards) / (len(rewards) or 1)
-        print(f"[END] task={task_id} score={score:.3f}", flush=True)
+        rewards.append(float(obs.reward or 0))
+        history.append(raw)
 
-    except Exception as e:
-        print(f"[EPISODE ERROR] {e}", flush=True)
+    score = sum(rewards) / (len(rewards) or 1)
+    print(f"[END] task={task_id} score={score:.3f}")
 
 
-async def main():
-    try:
-        miniproc = start_ministack()
-        serverproc = start_server()
+def main():
+    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
+    for name in TASK_ORDER:
+        task = load_task(name)
+        run_episode(task)
 
-    except Exception as e:
-        print(f"[FATAL ERROR] {e}", flush=True)
+    miniproc.terminate()
+    serverproc.terminate()
 
 
 if __name__ == "__main__":
-    try:
-        asyncio.run(main())
-    except Exception as e:
-        print(f"[UNHANDLED TOP LEVEL ERROR] {e}", flush=True)
+    main()