Upload folder using huggingface_hub

inference.py

@@ -9,82 +9,49 @@ from typing import List, Optional
 from openai import OpenAI
 from dotenv import load_dotenv
 
-# Load environment variables from the .env file BEFORE doing anything else
+# Load environment variables
 load_dotenv()
 
-# IMPORT THE CLIENT
 
 # --- MANDATORY ENV VARS ---
 API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
 MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
-
-# SECURE: No hardcoded token here. It will strictly pull from your .env file!
 HF_TOKEN = os.getenv("HF_TOKEN")
 
-LOCAL_IMAGE_NAME = os.getenv(
-    "LOCAL_IMAGE_NAME", "openenv-contract-validation:latest")
-
 BENCHMARK = "contract_validation"
 MAX_STEPS = 15
 
 
-# --- STRICT JSON LOGGING ---
-def log_start(task: str, env: str, model: str) -> None:
-    log_data = {
-        "event": "[START]",
-        "task_id": task,
-        "difficulty": task,
-        "env": env,
-        "model": model
-    }
-    print(json.dumps(log_data), flush=True)
-
-
-def log_step(task: str, step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
-    log_data = {
-        "event": "[STEP]",
-        "task_id": task,
-        "step": step,
-        "action": action,
-        # Clamp reward to prevent negative values breaking the OpenEnv grader
-        "reward": max(0.0, round(reward, 2)),
-        "done": done,
-        "error": error
-    }
-    print(json.dumps(log_data), flush=True)
-
-
-def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
-    log_data = {
-        "event": "[END]",
-        "success": success,
-        "steps": steps,
-        # Ensure score stays strictly within [0.0, 1.0]
-        "score": max(0.0, min(1.0, round(score, 2))),
-        "rewards": [max(0.0, round(r, 2)) for r in rewards]
-    }
-    print(json.dumps(log_data), flush=True)
+# --- THE STRICT FORMATTING FIX ---
+# The grader expects exact string matches, NOT JSON!
+def log_start(task: str) -> None:
+    print(f"[START] task={task}", flush=True)
+
+
+def log_step(step: int, reward: float) -> None:
+    # Reward must be numeric
+    clamped_reward = max(0.0, round(reward, 2))
+    print(f"[STEP] step={step} reward={clamped_reward}", flush=True)
+
+
+def log_end(task: str, score: float, steps: int) -> None:
+    # Score must be tightly clamped between 0.0 and 1.0
+    final_score = max(0.0, min(1.0, round(score, 2)))
+    print(f"[END] task={task} score={final_score} steps={steps}", flush=True)
 
 
 async def run_task(client: OpenAI, task_level: str):
-    # --- CONNECTION FIX ---
-    # Bypasses the grader's Docker-in-Docker restrictions by connecting
-    # directly to your live, validated Hugging Face Space.
+    # Direct connection to your live, validated Space
     space_url = "https://envarchitects-contract-validation-env.hf.space"
-
-    # We instantiate using the URL instead of spinning up a local container
     env = ContractValidationEnv(base_url=space_url)
 
     try:
-        # The rest of your code remains completely unchanged!
         result = await env.reset(task_level=task_level)
         obs = result.observation
-
         done = False
-        error = None
-        rewards: List[float] = []
 
-        log_start(task=task_level, env=BENCHMARK, model=MODEL_NAME)
+        # Output the exact START string
+        log_start(task=task_level)
 
         while not done and obs.step_count < MAX_STEPS:
             system_prompt = textwrap.dedent("""
@@ -110,7 +77,6 @@ async def run_task(client: OpenAI, task_level: str):
                 4. CRITICAL: If you have found all the risks (or if the remaining clauses are perfectly safe), you MUST end the review by setting "submit_final": true, "clause_id": 0, and "risk_type": "none".
             """).strip()
 
-            action_str = ""
             try:
                 response = client.chat.completions.create(
                     model=MODEL_NAME,
@@ -129,19 +95,15 @@ async def run_task(client: OpenAI, task_level: str):
                 risk_type = str(parsed.get("risk_type", "none"))
                 submit_final = bool(parsed.get("submit_final", False))
 
-                action_str = f"flag({clause_id}, '{risk_type}', submit={submit_final})"
-
                 action = ContractValidationAction(
                     clause_id=clause_id,
                     risk_type=risk_type,
                     submit_final=submit_final,
                     explanation=parsed.get("thoughts", "")
                 )
-                error = None
 
             except Exception as e:
-                error = str(e).replace("\n", " ")
-                action_str = "parse_error"
+                # Fallback action if the LLM hallucinated bad JSON
                 action = ContractValidationAction(
                     clause_id=0, risk_type="none", submit_final=False)
 
@@ -149,17 +111,15 @@ async def run_task(client: OpenAI, task_level: str):
             obs = result.observation
 
             step_reward = result.reward if result.reward is not None else 0.0
-            rewards.append(step_reward)
             done = result.done
 
-            log_step(task=task_level, step=obs.step_count, action=action_str,
-                     reward=step_reward, done=done, error=error)
+            # Output the exact STEP string
+            log_step(step=obs.step_count, reward=step_reward)
 
         score = obs.info.get("score", 0.0)
-        success = score == 1.0
 
-        log_end(success=success, steps=obs.step_count,
-                score=score, rewards=rewards)
+        # Output the exact END string
+        log_end(task=task_level, score=score, steps=obs.step_count)
 
     finally:
         try:
@@ -171,10 +131,11 @@ async def run_task(client: OpenAI, task_level: str):
 async def main():
     if not HF_TOKEN:
         print("CRITICAL WARNING: HF_TOKEN is missing! Make sure your .env file is set up correctly.")
-        return  # Stop execution if there is no token
+        return
 
     client = OpenAI(api_key=HF_TOKEN, base_url=API_BASE_URL)
 
+    # Must run the 3 requested tasks
     tasks = ["easy", "medium", "hard"]
     for t in tasks:
         await run_task(client, t)