Upload folder using huggingface_hub

inference.py

@@ -2,12 +2,21 @@ import os
 import re
 import json
 import asyncio
+import logging
 from typing import List, Optional
 from openai import OpenAI
 from dotenv import load_dotenv
 
 load_dotenv()
 
+# --- Logging (inference.py) ---
+_LOG_LEVEL = (os.getenv("LOG_LEVEL") or "INFO").upper()
+logging.basicConfig(
+    level=getattr(logging, _LOG_LEVEL, logging.INFO),
+    format="%(asctime)s %(levelname)s %(name)s - %(message)s",
+)
+logger = logging.getLogger("rust_coder.inference")
+
 # --- Competition Configuration ---
 API_BASE_URL = os.getenv("API_BASE_URL") or "https://router.huggingface.co/v1"
 MODEL_NAME = os.getenv("MODEL_NAME") or "Qwen/Qwen2.5-72B-Instruct"
@@ -41,6 +50,13 @@ def log_end(success: bool, steps: int, score: float, rewards: List[float]):
 async def get_model_code(prompt: str, client: OpenAI) -> str:
     """Call the LLM to get a Rust solution."""
     try:
+        logger.info(
+            "LLM call start model=%s base_url=%s prompt_chars=%d token_present=%s",
+            MODEL_NAME,
+            API_BASE_URL,
+            len(prompt or ""),
+            bool(HF_TOKEN),
+        )
         completion = client.chat.completions.create(
             model=MODEL_NAME,
             messages=[
@@ -50,6 +66,7 @@ async def get_model_code(prompt: str, client: OpenAI) -> str:
             temperature=0.1,
         )
         text = (completion.choices[0].message.content or "").strip()
+        logger.debug("LLM raw response chars=%d", len(text))
 
         # Extract code from markdown
         if "```rust" in text:
@@ -58,16 +75,18 @@ async def get_model_code(prompt: str, client: OpenAI) -> str:
             text = text.split("```")[1].split("```")[0]
         text = text.strip()
         if not text:
+            logger.warning("LLM returned empty code after cleanup.")
             return "// Error: empty response (no code returned)."
+        logger.info("LLM call end: returned_code_chars=%d", len(text))
         return text
     except Exception as e:
-        print(f"[DEBUG] LLM Request failed: {e}", flush=True)
+        logger.exception("LLM Request failed.")
         return f"// Error: {e}"
 
 # --- Main Evaluation Loop ---
 async def main():
     if not HF_TOKEN:
-        print("Error: HF_TOKEN/API_KEY not found in environment.")
+        logger.error("HF_TOKEN/API_KEY not found in environment.")
         return
 
     client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
@@ -100,6 +119,7 @@ async def main():
             code_solution = await get_model_code(prompt, client)
 
             # 2. Environment step
+            logger.debug("Submitting to env.step code_chars=%d", len(code_solution or ""))
             result = await env.step(RustCoderAction(code=code_solution))
             obs = result.observation
             reward = result.reward or 0.0
@@ -117,14 +137,14 @@ async def main():
         success = score >= SUCCESS_SCORE_THRESHOLD
 
     except Exception as e:
-        print(f"[DEBUG] Runtime error: {e}", flush=True)
+        logger.exception("Runtime error.")
         log_step(step=steps_taken + 1, action="error", reward=0.0, done=True, error=str(e))
 
     finally:
         try:
             await env.close()
         except Exception as e:
-            print(f"[DEBUG] env.close() error: {e}", flush=True)
+            logger.exception("env.close() error.")
         log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
 
 if __name__ == "__main__":

server/app.py

@@ -10,6 +10,7 @@ Endpoints:
 """
 
 import os
+import logging
 import gradio as gr
 from openai import OpenAI
 from dotenv import load_dotenv
@@ -20,6 +21,14 @@ from server.rust_coder_environment import RustCoderEnvironment
 
 load_dotenv()
 
+# --- Logging (server/app.py) ---
+_LOG_LEVEL = (os.getenv("LOG_LEVEL") or "INFO").upper()
+logging.basicConfig(
+    level=getattr(logging, _LOG_LEVEL, logging.INFO),
+    format="%(asctime)s %(levelname)s %(name)s - %(message)s",
+)
+logger = logging.getLogger("rust_coder.server")
+
 # --- Core OpenEnv Server Setup ---
 # Use a distinct name for the OpenEnv FastAPI instance
 openenv_app = create_app(
@@ -43,6 +52,13 @@ HF_TOKEN = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
 def get_llm_solution(problem_desc: str):
     """Call LLM to get a Rust solution"""
     try:
+        logger.info(
+            "LLM call start model=%s base_url=%s prompt_chars=%d token_present=%s",
+            MODEL_NAME,
+            API_BASE_URL,
+            len(problem_desc or ""),
+            bool(HF_TOKEN),
+        )
         client_llm = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
         completion = client_llm.chat.completions.create(
             model=MODEL_NAME,
@@ -53,6 +69,7 @@ def get_llm_solution(problem_desc: str):
             temperature=0.2,
         )
         text = (completion.choices[0].message.content or "").strip()
+        logger.debug("LLM raw response chars=%d", len(text))
         # Clean markdown code blocks
         if "```rust" in text:
             text = text.split("```rust")[1].split("```")[0]
@@ -60,9 +77,12 @@ def get_llm_solution(problem_desc: str):
             text = text.split("```")[1].split("```")[0]
         text = text.strip()
         if not text:
+            logger.warning("LLM returned empty code after cleanup.")
             return "// LLM Error: empty response (no code returned)."
+        logger.info("LLM call end: returned_code_chars=%d", len(text))
         return text
     except Exception as e:
+        logger.exception("LLM call failed.")
         return f"// LLM Error: {e}"
 
 def evaluate_single(problem_id, code=None):
@@ -70,19 +90,36 @@ def evaluate_single(problem_id, code=None):
     try:
         idx = int(problem_id.split(":")[0]) - 1
         problem = RustCoderEnvironment().problems[idx]
+        logger.info(
+            "evaluate_single start problem_id=%s idx=%d code_provided=%s",
+            problem_id,
+            idx,
+            code is not None,
+        )
 
         # 1. Get code from LLM if not provided
         solution_code = code if code else get_llm_solution(problem["description"])
 
         # 2. Guard: If LLM failed, do not evaluate
         if not solution_code.strip() or solution_code.startswith("// LLM Error"):
+            logger.warning(
+                "evaluate_single abort: empty_or_error_code=%s chars=%d",
+                solution_code.startswith("// LLM Error"),
+                len(solution_code or ""),
+            )
             return solution_code, {"error": "LLM failed to generate a solution. Check your HF_TOKEN."}
 
         # 3. Evaluate properly
         env = RustCoderEnvironment()
         # Reset to the specifically requested index
         state = env.reset(start_index=idx)
+        logger.debug("evaluate_single step() submitting chars=%d", len(solution_code))
         state = env.step(RustCoderAction(code=solution_code))
+        logger.info(
+            "evaluate_single end reward=%.4f compilation_success=%s",
+            float(state.reward or 0.0),
+            bool(state.compilation_success),
+        )
 
         metrics = {
             "Total Reward": f"{state.reward:.2f}",
@@ -91,6 +128,7 @@ def evaluate_single(problem_id, code=None):
         }
         return solution_code, metrics
     except Exception as e:
+        logger.exception("evaluate_single crashed.")
         return f"// Error: {e}", {"error": f"Evaluation system error: {e}"}
 
 def run_benchmark(progress=gr.Progress()):

server/rust_coder_environment.py

@@ -12,6 +12,7 @@ import re
 import subprocess
 import tempfile
 import time
+import logging
 from typing import Dict, List, Optional, Tuple
 
 from openenv.core.env_server.interfaces import Environment
@@ -63,6 +64,7 @@ class RustCoderEnvironment(Environment):
 
     def __init__(self) -> None:
         """Initialize environment and load problems from JSON."""
+        self._logger = logging.getLogger("rust_coder.env")
         self.problems: List[Dict] = self._load_problems()
         self.current_problem_idx: int = 0
         self.step_count: int = 0
@@ -119,6 +121,12 @@ class RustCoderEnvironment(Environment):
 
         if not code.strip():
             # Invalid/empty submission: do not advance the problem index.
+            self._logger.warning(
+                "Empty code submitted step_count=%d problem_id=%s title=%s",
+                self.step_count,
+                problem.get("id"),
+                problem.get("title"),
+            )
             done = False
             return RustCoderObservation(
                 problem_description=problem["description"],