Update app.py

app.py

@@ -2,128 +2,236 @@ import os
 import gradio as gr
 import requests
 import pandas as pd
-from smolagents import CodeAgent, InferenceClientModel, Tool
+from pathlib import Path
+
+from smolagents import (
+    CodeAgent,
+    InferenceClientModel,
+    DuckDuckGoSearchTool,
+    VisitWebpageTool,
+    PythonInterpreterTool,
+    tool
+)
 
+from pypdf import PdfReader
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-    
-# --- Define Tools ---
-# Tool 1: Simple Grocery Categorizer
-class GroceryCategorizerTool(Tool):
-    name = "grocery_categorizer"
-    description = "Categorizes grocery items into vegetables, fruits, and others."
-    inputs = {"items": {"type": "string", "description": "Comma-separated list of grocery items"}}
-    output_type = "string"
-
-    def forward(self, items: str) -> str:
-        vegetables = ["bell pepper", "broccoli", "celery", "corn", 
-                      "green beans", "sweet potatoes", "zucchini"]
-        items_list = [item.strip() for item in items.split(",")]
-        categorized = [item for item in items_list if item in vegetables]
-        return ", ".join(sorted(categorized)) if categorized else "No vegetables found."
-
-# Tool 2: Generic reasoning fallback (simulated here)
-class ReasoningTool(Tool):
-    name = "reasoning_tool"
-    description = "Provides reasoning-based answers for general questions."
-    inputs = {"question": {"type": "string", "description": "The question to answer"}}
-    output_type = "string"
-
-    def forward(self, question: str) -> str:
-        # Здесь можно подключить реальную LLM или веб-поиск
-        return "Answer generated via SmolAgents reasoning."
-
-# --- Initialize Agent ---
-
-hf_api_key = os.environ.get("HF_TOKEN")
-agent = CodeAgent(
-    tools=[GroceryCategorizerTool(), ReasoningTool()],
-    model=InferenceClientModel(api_key=hf_api_key)
-)
-print("HF_TOKEN available:", bool(hf_api_key))
-# --- Run & Submit Function ---
+MODEL_ID = "mistralai/Mixtral-8x7B-Instruct-v0.1"  # ← бесплатная и стабильная модель
+
+# --- Advanced Agent ---
+class BasicAgent:
+    def __init__(self):
+        print("Инициализация агента с Mixtral-8x7B...")
+        
+        self.model = InferenceClientModel(
+            model_id=MODEL_ID,
+            token=os.getenv("HF_TOKEN"),
+            temperature=0.05,
+            max_tokens=768,  # уменьшено для экономии лимита
+        )
+
+        tools = [
+            DuckDuckGoSearchTool(max_results=10),
+            VisitWebpageTool(),
+            PythonInterpreterTool(),
+        ]
+
+        @tool
+        def download_file(url: str) -> str:
+            """
+            Скачивает файл по URL.
+            Args:
+                url (str): URL файла
+            Returns:
+                str: Путь или ошибка
+            """
+            try:
+                downloads = Path("./downloads")
+                downloads.mkdir(exist_ok=True)
+                fname = url.split("/")[-1].split("?")[0] or "file"
+                path = downloads / fname
+                
+                r = requests.get(url, stream=True, timeout=45)
+                r.raise_for_status()
+                with open(path, "wb") as f:
+                    for chunk in r.iter_content(8192):
+                        f.write(chunk)
+                return f"Скачано: {path.absolute()}. Теперь используй read_pdf или read_excel для анализа."
+            except Exception as e:
+                return f"Ошибка скачивания: {str(e)}"
+
+        @tool
+        def read_pdf(path: str) -> str:
+            """
+            Читает PDF.
+            Args:
+                path (str): Путь
+            Returns:
+                str: Текст (до 4000 символов)
+            """
+            try:
+                reader = PdfReader(path)
+                text = "\n".join(page.extract_text() or "" for page in reader.pages)
+                return text[:4000]
+            except Exception as e:
+                return f"Ошибка PDF: {str(e)}"
+
+        @tool
+        def read_excel(path: str, sheet: str = None) -> str:
+            """
+            Читает Excel.
+            Args:
+                path (str): Путь
+                sheet (str, optional): Лист
+            Returns:
+                str: Таблица или ошибка
+            """
+            try:
+                df = pd.read_excel(path, sheet_name=sheet)
+                return df.to_string(max_rows=20, max_cols=10)
+            except Exception as e:
+                return f"Ошибка Excel: {str(e)}"
+
+        tools.extend([download_file, read_pdf, read_excel])
+
+        self.agent = CodeAgent(
+            tools=tools,
+            model=self.model,
+            add_base_tools=True,
+            max_steps=12,  # уменьшено — меньше запросов к API
+        )
+        print("Агент готов!")
+
+    def __call__(self, question: str) -> str:
+        print(f"Вопрос: {question[:120]}...")
+
+        # Обрезка длинных вопросов
+        if len(question) > 2000:
+            question = question[:2000] + "\n[Обрезано из-за длины. Отвечай кратко.]"
+
+        # Хак для файлов/аудио/видео/attached
+        q = question.lower()
+        if any(k in q for k in [".mp3", "audio", "recording", "voice", "youtube.com", "video", "attached", "file", "excel", "pdf", "image", "jpg", "png"]):
+            question += "\nЕсли в вопросе упоминается файл, URL или attached — ОБЯЗАТЕЛЬНО используй download_file, затем read_pdf или read_excel. Отвечай ТОЛЬКО по содержимому файла. НЕ ПРИДУМЫВАЙ числа, имена или данные."
+
+        # Хак для шахмат
+        if "chess" in q or "image" in q or ".jpg" in q or ".png" in q:
+            question += "\nЕсли есть URL изображения — скачай и опиши позицию или ищи похожую. НЕ ПРИДУМЫВАЙ ход."
+
+        try:
+            result = self.agent.run(question)
+            answer = str(result).strip()
+
+            # Жёсткая очистка ответа
+            prefixes = [
+                "Final Answer", "Final answer", "Answer:", "The answer is",
+                "So the final answer is", "```", "boxed{", "}", "[/INST]", "</s>",
+                "Thought:", "Observation:", "Action:"
+            ]
+            for p in prefixes:
+                if p.lower() in answer.lower():
+                    answer = answer.split(p, 1)[-1].strip(": []{}\n`")
+                    break
+
+            if answer.startswith("[") and answer.endswith("]"):
+                answer = answer[1:-1].strip()
+
+            answer = answer.strip()
+
+            # Защита от длинных/придуманных ответов
+            if len(answer) > 250 or "придум" in answer.lower() or answer.count(",") > 15:
+                answer = answer[:150] + "..." if len(answer) > 150 else answer
+
+            print(f"Ответ: {answer[:150]}...")
+            return answer or "Нет ответа"
+
+        except Exception as e:
+            err_str = str(e)
+            if "402" in err_str or "Payment Required" in err_str:
+                return "Лимит API исчерпан. Подожди 10–15 минут или используй модель Mixtral-8x7B."
+            err = f"Ошибка: {err_str[:200]}"
+            print(err)
+            return err
+
+# --- run_and_submit_all (без изменений) ---
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     space_id = os.getenv("SPACE_ID")
-    if not profile:
-        return "Please Login to Hugging Face with the button.", None
-    username = profile.username
+    if profile:
+        username = profile.username
+        print(f"Вход: {username}")
+    else:
+        return "Войдите в HF", None
 
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-
-    # Fetch questions
     try:
-        response = requests.get(questions_url, timeout=15)
-        response.raise_for_status()
-        questions_data = response.json()
-        if not questions_data:
-            return "Fetched questions list is empty or invalid format.", None
+        agent = BasicAgent()
     except Exception as e:
-        return f"Error fetching questions: {e}", None
+        return f"Ошибка агента: {e}", None
 
-    results_log = []
-    answers_payload = []
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
 
-    for item in questions_data:
-        task_id = item.get("task_id")
-        question_text = item.get("question")
-        if not task_id or question_text is None:
+    try:
+        resp = requests.get(questions_url, timeout=15)
+        resp.raise_for_status()
+        questions = resp.json()
+        if not questions:
+            return "Вопросов нет", None
+        print(f"Вопросов: {len(questions)}")
+    except Exception as e:
+        return f"Ошибка вопросов: {e}", None
+
+    results = []
+    payload = []
+    for item in questions:
+        tid = item.get("task_id")
+        q = item.get("question")
+        if not tid or not q:
             continue
-
         try:
-            # Используем агент для автоматического выбора инструмента
-            if "vegetables" in question_text.lower() or "grocery" in question_text.lower():
-                submitted_answer = agent.run(f'GroceryCategorizerTool: {question_text}')
-            else:
-                submitted_answer = agent.run(f'ReasoningTool: {question_text}')
-
-            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
-
+            ans = agent(q)
+            payload.append({"task_id": tid, "submitted_answer": ans})
+            results.append({"Task ID": tid, "Question": q, "Answer": ans})
         except Exception as e:
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+            results.append({"Task ID": tid, "Question": q, "Answer": f"ERROR: {e}"})
+
+    if not payload:
+        return "Нет ответов", pd.DataFrame(results)
 
-    if not answers_payload:
-        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+    data = {"username": username.strip(), "agent_code": agent_code, "answers": payload}
 
-    # Submit answers
-    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
-        response.raise_for_status()
-        result_data = response.json()
-        final_status = (
-            f"Submission Successful!\n"
-            f"User: {result_data.get('username')}\n"
-            f"Overall Score: {result_data.get('score', 'N/A')}% "
-            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
-            f"Message: {result_data.get('message', 'No message received.')}"
+        resp = requests.post(submit_url, json=data, timeout=60)
+        resp.raise_for_status()
+        res = resp.json()
+        status = (
+            f"Успех!\n"
+            f"Пользователь: {res.get('username')}\n"
+            f"Балл: {res.get('score', 'N/A')}% "
+            f"({res.get('correct_count', '?')}/{res.get('total_attempted', '?')})\n"
+            f"{res.get('message', '')}"
         )
-        return final_status, pd.DataFrame(results_log)
+        return status, pd.DataFrame(results)
     except Exception as e:
-        return f"Submission failed: {e}", pd.DataFrame(results_log)
+        return f"Ошибка отправки: {e}", pd.DataFrame(results)
 
-# --- Gradio Interface ---
+# --- Gradio ---
 with gr.Blocks() as demo:
-    gr.Markdown("# SmolAgents Autonomous Evaluation Runner")
-    gr.Markdown(
-        """
-        **Instructions:**
-        1. Log in with your Hugging Face account.
-        2. Click 'Run Evaluation & Submit All Answers'.
-        3. SmolAgents will autonomously select tools and answer questions.
-        """
-    )
-
+    gr.Markdown("# Агент для финального задания")
+    gr.Markdown("""
+1. Клонируй и дорабатывай.
+2. Войди через кнопку.
+3. Нажми кнопку — увидишь score.
+""")
     gr.LoginButton()
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
-    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
+    btn = gr.Button("Запустить оценку и отправить")
+    status = gr.Textbox(label="Результат", lines=6)
+    table = gr.DataFrame(label="Ответы", wrap=True)
+    btn.click(run_and_submit_all, outputs=[status, table])
 
 if __name__ == "__main__":
+    print("Запуск...")
     demo.launch(debug=True, share=False)