Delete agent.py

agent.py

@@ -1,177 +0,0 @@
-import os
-import re
-import io
-import base64
-import requests
-import pandas as pd
-from openai import OpenAI
-from word2number import w2n
-from langchain_community.tools import DuckDuckGoSearchRun
-
-class GaiaAgent:
-    def __init__(self):
-        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-        self.api_url = "https://agents-course-unit4-scoring.hf.space"
-        self.search_tool = DuckDuckGoSearchRun()
-
-    def fetch_file(self, task_id):
-        try:
-            url = f"{self.api_url}/files/{task_id}"
-            r = requests.get(url, timeout=10)
-            r.raise_for_status()
-            return r.content, r.headers.get("Content-Type", "")
-        except:
-            return None, None
-
-    def ask(self, prompt):
-        try:
-            r = self.client.chat.completions.create(
-                model="gpt-4-turbo",
-                messages=[{"role": "user", "content": prompt}],
-                temperature=0
-            )
-            return r.choices[0].message.content.strip()
-        except:
-            return "[ERROR: ask failed]"
-
-    def search_context(self, query):
-        try:
-            result = self.search_tool.run(query)
-            return result[:2000] if result else "[NO RESULT]"
-        except:
-            return "[WEB ERROR]"
-
-    def handle_file(self, content, ctype, question):
-        try:
-            if "image" in ctype:
-                b64 = base64.b64encode(content).decode("utf-8")
-                result = self.client.chat.completions.create(
-                    model="gpt-4o",
-                    messages=[
-                        {"role": "system", "content": "You're a chess assistant. Give the best move in algebraic notation (e.g., Qd1#)."},
-                        {"role": "user", "content": [
-                            {"type": "text", "text": question},
-                            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
-                        ]}
-                    ]
-                )
-                return result.choices[0].message.content.strip()
-
-            if "audio" in ctype:
-                with open("/tmp/audio.mp3", "wb") as f:
-                    f.write(content)
-                result = self.client.audio.transcriptions.create(model="whisper-1", file=open("/tmp/audio.mp3", "rb"))
-                return result.text
-
-            if "excel" in ctype:
-                df = pd.read_excel(io.BytesIO(content), engine="openpyxl")
-                df.columns = [c.lower().strip() for c in df.columns]
-                if 'sales' in df.columns:
-                    df['sales'] = pd.to_numeric(df['sales'], errors='coerce')
-                    if 'category' in df.columns:
-                        df = df[df['category'].astype(str).str.lower().str.contains('food')]
-                    return f"${df['sales'].sum():.2f}"
-                return "$0.00"
-
-            return content.decode("utf-8", errors="ignore")[:3000]
-        except:
-            return "[FILE ERROR]"
-
-    def extract_ingredients(self, text):
-        try:
-            tokens = re.findall(r"[a-zA-Z]+(?:\s[a-zA-Z]+)?", text)
-            blocked = {"add", "combine", "cook", "stir", "remove", "cool", "mixture", "saucepan", "until", "heat", "dash"}
-            filtered = [t.lower() for t in tokens if t.lower() not in blocked and len(t.split()) <= 3]
-            return ", ".join(sorted(set(filtered)))
-        except:
-            return text[:100]
-
-    def extract_pages(self, text):
-        try:
-            pages = sorted(set(re.findall(r"\b\d+\b", text)), key=int)
-            return ", ".join(pages)
-        except:
-            return text
-
-    def sanitize_commutative_set(self, raw):
-        s = re.findall(r"\b[a-e]\b", raw)
-        return ", ".join(sorted(set(s))) if s else raw
-
-    def format_answer(self, answer, question):
-        q = question.lower()
-        raw = answer.strip().strip("\"'")
-        if "ingredient" in q:
-            return self.extract_ingredients(raw)
-        if "commutative" in q:
-            return self.sanitize_commutative_set(raw)
-        if "algebraic notation" in q or "chess" in q:
-            m = re.search(r"[KQBNR]?[a-h]?[1-8]?x?[a-h][1-8][+#]?", raw)
-            return m.group(0) if m else raw
-        if "usd" in q or "at bat" in q:
-            m = re.search(r"\$?\d+(\.\d{2})?", raw)
-            return f"${m.group()}" if m else "$0.00"
-        if "year" in q or "when" in q:
-            m = re.search(r"\b(\d{4})\b", raw)
-            return m.group(0) if m else raw
-        if "award number" in q:
-            m = re.search(r"80NSSC[0-9A-Z]+", raw)
-            return m.group(0) if m else raw
-        if "ioc" in q:
-            m = re.search(r"\b[A-Z]{3}\b", raw)
-            return m.group(0) if m else raw
-        if "first name" in q:
-            return raw.split()[0]
-        if "page number" in q or "pages" in q:
-            return self.extract_pages(raw)
-        try:
-            return str(w2n.word_to_num(raw))
-        except:
-            m = re.search(r"\d+", raw)
-            return m.group(0) if m else raw
-
-    def reverse_sentence_logic(self, question):
-        try:
-            reversed_sentence = ''.join(reversed(question.strip('.'))).split()
-            return reversed_sentence[-1]
-        except:
-            return "[REVERSE ERROR]"
-
-    def answer_from_youtube(self, question):
-        try:
-            context = self.search_context(question)
-            return self.ask(f"Use this transcript or context to answer:\n{context}\n\n{question}\nAnswer:")
-        except:
-            return "[YOUTUBE ERROR]"
-
-    def __call__(self, question, task_id=None):
-        try:
-            q_lower = question.lower()
-
-            if q_lower.startswith('.rewsna'):
-                return self.reverse_sentence_logic(question)
-
-            if "youtube.com" in question:
-                return self.answer_from_youtube(question)
-
-            if "malko" in q_lower:
-                ctx = self.search_context("20th century Malko winner country that no longer exists")
-                fname = re.findall(r"\b[A-Z][a-z]{2,}", ctx)
-                return fname[0] if fname else "[MALKO ERROR]"
-
-            file_content, ctype = self.fetch_file(task_id) if task_id else (None, None)
-            if file_content:
-                context = self.handle_file(file_content, ctype, question)
-            else:
-                context = self.search_context(question)
-
-            prompt = f"Use this context to answer the question:\n{context}\n\nQuestion:\n{question}\nAnswer:"
-            answer = self.ask(prompt)
-
-            if not answer or "[ERROR" in answer or "step execution failed" in answer:
-                fallback = self.search_context(question)
-                retry_prompt = f"Use this context to answer:\n{fallback}\n\n{question}"
-                answer = self.ask(retry_prompt)
-
-            return self.format_answer(answer, question)
-        except Exception as e:
-            return f"[AGENT ERROR: {e}]"