path

app.py

@@ -348,6 +348,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         return f"An unexpected error occurred fetching questions: {e}", None
 
     # 3. Run your Agent
+    
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")

tools.py

@@ -10,75 +10,103 @@ from langchain.schema import HumanMessage
 import regex as re
 import time
 
-def web_search_tool(state: AgentState) -> AgentState:
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+
+def _download_file_for_task(task_id: str, ext: str) -> str:
     """
-    Expects: state["web_search_query"] is a non‐empty string.
-    Returns: {"web_search_query": None, "web_search_result": <string>}
-    We also clear web_search_query so we don’t loop forever.
-    If the result is a DuckDuckGo 202 Ratelimit error, retry up to 5 times with a 5 second sleep between attempts.
+    Helper: attempt to GET the remote file for a given task_id.
+    Saves under ./hf_files/{task_id}.{ext}. Returns the local path if successful,
+    or an empty string if no file / download failed.
     """
-    # print("reached web search tool")
-    query = state.get("web_search_query", "")
-    if not query:
-        return {}  # nothing to do
-    
-    ddg = DuckDuckGoSearchRun()
-    max_retries = 5
-    for attempt in range(max_retries):
-        result_text = ddg.run(query)
-        if "202 Ratelimit" not in result_text:
-            break
-        if attempt < max_retries - 1:
-            print(f"web_search_result: rate limit error, retrying in 10 seconds")
-            time.sleep(3)
-    print(f"web_search_result reached ")
-    return {
-        "web_search_query": None,
-        "web_search_result": result_text
-    }
+    os.makedirs("hf_files", exist_ok=True)
+    local_path = os.path.join("hf_files", f"{task_id}.{ext}")
+    url = f"{DEFAULT_API_URL}/files/{task_id}"
+
+    try:
+        resp = requests.get(url, timeout=10)
+        if resp.status_code == 200 and resp.content:
+            with open(local_path, "wb") as f:
+                f.write(resp.content)
+            return local_path
+    except Exception:
+        pass
+
+    # If we get here, either 404 or download error
+    return ""
+
 
 def ocr_image_tool(state: AgentState) -> AgentState:
     """
-    Expects: state["ocr_path"] is a path to an image file.
-    Returns: {"ocr_path": None, "ocr_result": <string>}.
+    Expects state["ocr_path"] to be either:
+      • A real local image path (e.g. "./hf_files/abc.png"), or
+      • A Task ID string like "abc123", in which case we GET /files/abc123.
+    Returns:
+      { "ocr_path": None, "ocr_result": "<OCRed text or error string>" }
     """
-    print("reached ocr image tool")
-    path = state.get("ocr_path", "")
-    if not path:
+    path_or_id = state.get("ocr_path", "")
+    if not path_or_id:
         return {}
+
+    # 1) If local file exists, use it. Otherwise, treat "path_or_id" as task_id and download.
+    if os.path.exists(path_or_id):
+        local_img = path_or_id
+    else:
+        # Assume it's a task_id; try to download a PNG or JPG
+        # (We don’t know extension, so try common ones in order)
+        local_img = ""
+        for ext in ("png", "jpg", "jpeg"):
+            candidate = _download_file_for_task(path_or_id, ext)
+            if candidate:
+                local_img = candidate
+                break
+
+    if not local_img or not os.path.exists(local_img):
+        return {
+            "ocr_path": None,
+            "ocr_result": "Error: No image file found (neither local nor downloadable)."
+        }
+
+    # 2) Run OCR
     try:
-        img = Image.open(path)
-        text = pytesseract.image_to_string(img)
-        text = text.strip() or "(no visible text)"
+        img = Image.open(local_img)
+        text = pytesseract.image_to_string(img).strip() or "(no visible text)"
     except Exception as e:
         text = f"Error during OCR: {e}"
-    print(f"ocr_result: {text}")
+
     return {
         "ocr_path": None,
         "ocr_result": text
     }
 
+
 def parse_excel_tool(state: AgentState) -> AgentState:
     """
-    Attempts to read an actual .xlsx file at state["excel_path"]. If the file isn’t found,
-    scans the conversation history for a Markdown‐style table and returns that instead.
+    Expects state["excel_path"] to be either:
+      • A real local .xlsx path, or
+      • A Task ID string (e.g. "abc123"), in which case we GET /files/abc123.xlsx.
     Returns:
       {
         "excel_path": None,
         "excel_sheet_name": None,
-        "excel_result": "<either CSV‐like text or extracted Markdown table>"
+        "excel_result": "<stringified records or Markdown table>"
       }
-    If neither a real file nor a table block is found, returns an error message.
     """
-    path = state.get("excel_path", "")
+    path_or_id = state.get("excel_path", "")
     sheet = state.get("excel_sheet_name", "")
-    if not path:
+    if not path_or_id:
         return {}
 
-    # 1) Try reading the real file first
-    if os.path.exists(path):
+    # 1) If local .xlsx exists, use it. Otherwise, try downloading.
+    if os.path.exists(path_or_id):
+        local_xlsx = path_or_id
+    else:
+        local_xlsx = _download_file_for_task(path_or_id, "xlsx")
+
+    # 2) If we finally have a real file, read it
+    if local_xlsx and os.path.exists(local_xlsx):
         try:
-            xls = pd.ExcelFile(path)
+            xls = pd.ExcelFile(local_xlsx)
             if sheet and sheet in xls.sheet_names:
                 df = pd.read_excel(xls, sheet_name=sheet)
             else:
@@ -91,10 +119,10 @@ def parse_excel_tool(state: AgentState) -> AgentState:
                 "excel_result": text
             }
         except Exception as e:
-            # If there's an I/O or parsing error, fall through to table‐extraction
-            print(f">>> parse_excel_tool: Error reading Excel file {path}: {e}")
+            print(f">>> parse_excel_tool: Error reading Excel file {local_xlsx}: {e}")
+            # Fall back to scanning for Markdown below
 
-    # 2) Fallback: extract a Markdown table from any HumanMessage in state["messages"]
+    # 3) Fallback: scan any HumanMessage for a Markdown‐style table
     messages = state.get("messages", [])
     table_lines = []
     collecting = False
@@ -102,12 +130,10 @@ def parse_excel_tool(state: AgentState) -> AgentState:
     for msg in messages:
         if isinstance(msg, HumanMessage):
             for line in msg.content.splitlines():
-                # Start collecting when we see the first table header row
                 if re.match(r"^\s*\|\s*[-A-Za-z0-9]", line):
                     collecting = True
                 if collecting:
                     if not re.match(r"^\s*\|", line):
-                        # stop when the block ends (blank line or non‐table line)
                         collecting = False
                         break
                     table_lines.append(line)
@@ -121,7 +147,7 @@ def parse_excel_tool(state: AgentState) -> AgentState:
             "excel_result": "Error: No Excel file found and no Markdown table detected in prompt."
         }
 
-    # Remove any separator rows like "| ---- | ---- |"
+    # 4) Strip out separator rows and return the table block
     clean_rows = [row for row in table_lines if not re.match(r"^\s*\|\s*-+", row)]
     table_block = "\n".join(clean_rows).strip()
 
@@ -154,40 +180,60 @@ from state import AgentState
 
 def audio_transcriber_tool(state: AgentState) -> AgentState:
     """
-    LangGraph tool for transcribing audio via OpenAI’s hosted Whisper API.
-    Expects: state["audio_path"] to be a valid path to a .wav/.mp3/.m4a file.
+    LangGraph tool for transcribing audio via OpenAI’s Whisper API.
+    Expects: state["audio_path"] to be either:
+      • A local file path (e.g. "./hf_files/abc.mp3"), OR
+      • A Task ID (e.g. "abc123"), in which case we try downloading
+        GET {DEFAULT_API_URL}/files/{task_id} with .mp3, .wav, .m4a extensions.
+
     Returns:
       {
         "audio_path": None,
-        "transcript": "<transcribed text or error message>"
+        "transcript": "<text or error message>"
       }
-    If no valid audio_path is provided, returns {}.
     """
-    # print("reached audio transcriber tool")
-    path = state.get("audio_path", "")
-    if not path or not os.path.exists(path):
+    path_or_id = state.get("audio_path", "")
+    if not path_or_id:
         return {}
 
+    # 1) If local file exists, use it. Otherwise, treat path_or_id as task_id and try downloads:
+    if os.path.exists(path_or_id):
+        local_audio = path_or_id
+    else:
+        local_audio = ""
+        for ext in ("mp3", "wav", "m4a"):
+            candidate = _download_file_for_task(path_or_id, ext)
+            if candidate:
+                local_audio = candidate
+                break
+
+    if not local_audio or not os.path.exists(local_audio):
+        # Neither a real file nor a downloadable attachment
+        return {
+            "audio_path": None,
+            "transcript": "Error: No audio file found (neither local nor downloadable)."
+        }
+
+    # 2) Send to OpenAI Whisper
     try:
         openai.api_key = os.getenv("OPENAI_API_KEY")
         if not openai.api_key:
             raise RuntimeError("OPENAI_API_KEY is not set in environment.")
 
-        with open(path, "rb") as audio_file:
+        with open(local_audio, "rb") as audio_file:
             # For OpenAI Python library v0.27.0+:
             response = openai.Audio.transcribe("whisper-1", audio_file)
-            # If using an older OpenAI library, use:
+            # If you’re on an older library:
             # response = openai.Audio.create_transcription(file=audio_file, model="whisper-1")
 
-        text = response["text"].strip()
+        text = response.get("text", "").strip()
     except Exception as e:
         text = f"Error during transcription: {e}"
-    print(f"transcript: {text}")
+
     return {
         "audio_path": None,
         "transcript": text
     }
-
 # tools.py
 
 import re