fff

my_tools.py

@@ -5,14 +5,18 @@ import math
 import time
 import asyncio
 import subprocess
+import requests
 import pandas as pd
+from io import StringIO
+from bs4 import BeautifulSoup
 from duckduckgo_search import DDGS
 import wikipedia
 from pydantic import Field
 import google.generativeai as genai
 
+# LlamaIndex imports
 from llama_index.core.llms import ChatMessage, LLMMetadata, LLM, CompletionResponse
-# Monkey-patch para evitar el error de .message faltante
+# Monkey-patch ChatMessage to satisfy .message
 ChatMessage.message = property(lambda self: self)
 from llama_index.core.tools import FunctionTool
 from llama_index.core.agent import ReActAgent
@@ -80,7 +84,7 @@ class GeminiLLM(LLM):
             acc = ""
             for chunk in stream:
                 delta = getattr(chunk, "text", "")
-                if not delta and chunk.parts:
+                if not delta and hasattr(chunk, 'parts') and chunk.parts:
                     delta = chunk.parts[0].text
                 if delta:
                     acc += delta
@@ -103,7 +107,7 @@ class GeminiLLM(LLM):
             acc = ""
             for chunk in stream:
                 delta = getattr(chunk, "text", "")
-                if not delta and chunk.parts:
+                if not delta and hasattr(chunk, 'parts') and chunk.parts:
                     delta = chunk.parts[0].text
                 if delta:
                     acc += delta
@@ -113,9 +117,7 @@ class GeminiLLM(LLM):
     async def astream_complete(self, prompt, formatted=False, **kwargs):
         return await asyncio.to_thread(self.stream_complete, prompt, formatted=formatted, **kwargs)
 
-    # <<< METODO ADICIONAL PARA CUMPLIR con LLM.abstractmethod >>>
     def astream_chat(self, messages: list[ChatMessage], **kwargs):
-        # reutilizamos stream_chat existente
         return self.stream_chat(messages, **kwargs)
 
 # -------------------------------------------------------------------
@@ -137,34 +139,49 @@ def buscar_web(query: str, max_attempts: int = 2) -> str:
             else:
                 return f"Error buscar_web tras {max_attempts} intentos: {e}"
 
+
 def reverse_text(text: str) -> str:
     return text[::-1]
 
+
 def analyze_table(table_md: str, question: str) -> str:
     try:
-        lines = [l.strip() for l in table_md.strip().splitlines() if l.strip()]
-        content = [l for l in lines if not set(l) <= set("|- ")]
-        rows = [[c.strip() for c in r.split("|")[1:-1]] for r in content]
+        # Remove alignment row and parse header/body
+        lines = [l for l in table_md.splitlines() if l.strip()]
+        # Filter out divider line
+        lines = [l for l in lines if not l.strip().startswith('|') or '---' not in l]
+        # Convert markdown to CSV-like
+        rows = []
+        for l in lines:
+            parts = [c.strip() for c in l.strip().strip('|').split('|')]
+            rows.append(parts)
         df = pd.DataFrame(rows[1:], columns=rows[0])
-        if "no conmut" in question.lower():
-            S = df.columns.tolist()
+        if 'conmut' in question.lower():
+            S = rows[0][1:]
             counter = set()
             for x in S:
                 for y in S:
-                    a = df.loc[df[rows[0][0]]==x, y].values[0]
-                    b = df.loc[df[rows[0][0]]==y, x].values[0]
+                    a = df.loc[df[rows[0][0]]==x, y].iat[0]
+                    b = df.loc[df[rows[0][0]]==y, x].iat[0]
                     if a != b:
                         counter.update([x, y])
-            return ", ".join(sorted(counter)) or "No hay contraejemplos"
+            return ', '.join(sorted(counter)) or 'No hay contraejemplos'
         return df.to_csv(index=False)
     except Exception as e:
         return f"Error analyze_table: {e}"
 
+
 def execute_code(code: str) -> str:
     try:
+        # Try eval for simple expressions
+        try:
+            val = eval(code, {'__builtins__': None, 'math': math}, math.__dict__)
+            return str(val)
+        except:
+            pass
+        # Fallback to subprocess
         res = subprocess.run(
-            ["python", "-c", code],
-            capture_output=True, text=True, timeout=5
+            ["python", "-c", code], capture_output=True, text=True, timeout=5
         )
         if res.stderr:
             return f"Error código: {res.stderr.strip()}"
@@ -172,46 +189,58 @@ def execute_code(code: str) -> str:
     except Exception as e:
         return f"Error ejecutar código: {e}"
 
+
 def no_tool_solution(query: str) -> str:
     return "Procedo con conocimiento interno."
 
 
-# -------------------------------------------------------------------
-# 3) Encapsular como FunctionTool
-# -------------------------------------------------------------------
-search_tool   = FunctionTool.from_defaults(fn=buscar_web,     name="web_search",       description="Búsqueda DDG (3 resultados).")
-reverse_tool  = FunctionTool.from_defaults(fn=reverse_text,   name="reverse_text",     description="Invierte texto.")
-table_tool    = FunctionTool.from_defaults(fn=analyze_table, name="analyze_table",    description="Parses Markdown tables y responde conmutatividad.")
-code_tool     = FunctionTool.from_defaults(fn=execute_code,  name="execute_code",     description="Ejecuta Python para cálculos.")
-fallback_tool = FunctionTool.from_defaults(fn=no_tool_solution,name="no_tool_solution", description="Fallback: conocimiento interno.")
+def scrape_wikipedia_table(query: str, section: str) -> str:
+    """
+    Busca una página de Wikipedia y extrae la tabla HTML bajo la sección dada.
+    Devuelve CSV de la tabla.
+    """
+    try:
+        page = wikipedia.page(query)
+        html = page.html()
+        soup = BeautifulSoup(html, 'html.parser')
+        sec = None
+        for header in soup.find_all(['h2','h3']):
+            if section.lower() in header.get_text().lower():
+                sec = header
+                break
+        if not sec:
+            return f"Sección '{section}' no encontrada en '{query}'."
+        table = sec.find_next('table', {'class':'wikitable'})
+        if not table:
+            return "No se encontró tabla wikitable después de la sección."
+        df = pd.read_html(str(table))[0]
+        return df.to_csv(index=False)
+    except Exception as e:
+        return f"Error scrape_wikipedia_table: {e}"
 
-all_tools = [search_tool, reverse_tool, table_tool, code_tool, fallback_tool]
+# Encapsular herramientas
+search_tool   = FunctionTool.from_defaults(fn=buscar_web,           name="web_search",           description="Búsqueda DDG (3 resultados).")
+reverse_tool  = FunctionTool.from_defaults(fn=reverse_text,         name="reverse_text",        description="Invierte texto.")
+table_tool    = FunctionTool.from_defaults(fn=analyze_table,        name="analyze_table",       description="Procesa tablas Markdown y verifica conmutatividad.")
+code_tool     = FunctionTool.from_defaults(fn=execute_code,         name="execute_code",        description="Ejecuta Python para cálculos.")
+fallback_tool = FunctionTool.from_defaults(fn=no_tool_solution,     name="no_tool_solution",     description="Fallback: conocimiento interno.")
+scrape_tool   = FunctionTool.from_defaults(fn=scrape_wikipedia_table,name="scrape_wiki_table",   description="Extrae tabla de Wikipedia por sección.")
 
-# -------------------------------------------------------------------
-# 4) Prompt de sistema
-# -------------------------------------------------------------------
+all_tools = [search_tool, reverse_tool, table_tool, code_tool, scrape_tool, fallback_tool]
+
+# Prompt de sistema
 system_prompt = (
     "Eres Alfred, un agente ReAct que usa pasos de pensamiento claros y herramientas especializadas.\n"
-    "Sigue este flujo:\n"
-    "1) Analiza la pregunta.\n"
-    "2) Piensa paso a paso (internamente), luego decide qué acción tomar.\n"
-    "3) Si necesitas datos externos, usa web_search.\n"
-    "4) Si hay texto invertido, usa reverse_text.\n"
-    "5) Si hay tablas Markdown, usa analyze_table.\n"
-    "6) Para cálculos complejos, usa execute_code.\n"
-    "7) Si nada ayuda, llama no_tool_solution y responde con tu conocimiento.\n"
-    "8) Si la pregunta involucra audio, video o imágenes no procesables, informa que no puedes acceder.\n"
-    "9) Proporciona siempre una respuesta final clara al usuario.\n"
-    "\nHerramientas disponibles:\n{tool_descriptions}\n"
-    "No muestres tus pensamientos al usuario; solo la respuesta final."
-
+    "1) Analiza la pregunta. 2) Decide la herramienta más adecuada.\n"
+    "3) Usa web_search, reverse_text, analyze_table, execute_code o scrape_wiki_table.\n"
+    "4) Si nada aplica, usa no_tool_solution.\n"
+    "5) Si la pregunta involucra audio/video/imágenes no procesables, informa que no puedes acceder.\n"
+    "6) Responde final claro.\n"
+    "Herramientas:\n{tool_descriptions}"
 )
 
-# -------------------------------------------------------------------
-# 5) Inicializar agente con GeminiLLM
-# -------------------------------------------------------------------
+# Inicializar agente
 llm = GeminiLLM(model_name="models/gemini-1.5-flash-latest", temperature=0.0)
-
 alfred_agent = ReActAgent.from_tools(
     tools=all_tools,
     llm=llm,
@@ -220,9 +249,7 @@ alfred_agent = ReActAgent.from_tools(
     max_iterations=20
 )
 
-# -------------------------------------------------------------------
-# 6) Función pública
-# -------------------------------------------------------------------
+# Función pública
 def basic_agent_response(question: str) -> str:
     try:
         resp = alfred_agent.query(question)