Update app.py

app.py

@@ -1,72 +1,20 @@
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
+import datetime
 import requests
-from bs4 import BeautifulSoup
-from functools import wraps
-from typing import Callable, Any, List, Union
-
-class Tool:
-    """
-    Représente un outil réutilisable pour l'agent.
-
-    Attributs:
-        name (str): Nom descriptif de l'outil.
-        description (str): Description détaillée de l'outil.
-        func (Callable): La fonction que l'outil exécute.
-        arguments (List[str]): Liste des arguments requis par la fonction.
-        outputs (Union[str, List[str]]): Description des sorties produites par l'outil.
-    """
-    def __init__(self, name: str, description: str, func: Callable, arguments: List[str], outputs: Union[str, List[str]]):
-        self.name = name
-        self.description = description
-        self.func = func
-        self.arguments = arguments
-        self.outputs = outputs
+import pytz
+import yaml
+from tools.final_answer import FinalAnswerTool
 
-    def run(self, *args, **kwargs) -> Any:
-        """Exécute la fonction associée à l'outil."""
-        return self.func(*args, **kwargs)
-
-def tool(name: str = None, description: str = "", arguments: List[str] = None, outputs: Union[str, List[str]] = None):
-    """
-    Décorateur pour transformer une fonction en instance de Tool.
-
-    Args:
-        name (str): Nom de l'outil. Si None, le nom de la fonction sera utilisé.
-        description (str): Description détaillée de l'outil.
-        arguments (List[str]): Liste des arguments requis par la fonction.
-        outputs (Union[str, List[str]]): Description des sorties produites par l'outil.
-
-    Returns:
-        Callable: Une instance de Tool contenant la fonction décorée.
-    """
-    def decorator(func: Callable) -> Tool:
-        tool_name = name if name is not None else func.__name__
-        tool_arguments = arguments if arguments is not None else []
-        tool_outputs = outputs if outputs is not None else ""
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            return func(*args, **kwargs)
-        return Tool(
-            name=tool_name,
-            description=description or func.__doc__,
-            func=func,
-            arguments=tool_arguments,
-            outputs=tool_outputs
-        )
-    return decorator
-
-@tool(
-    name="RechercheGoogle",
-    description="Outil pour effectuer une recherche sur Google par mot-clé et extraire le premier résultat.",
-    arguments=["query (str)"],
-    outputs="dict (contenant 'url' et 'titre')"
-)
-def recherche(query: str) -> dict:
-    """
-    Recherche sur Google un mot-clé donné.
+from Gradio_UI import GradioUI
+from bs4 import BeautifulSoup
 
+@tool
+def recherche_google(query: str) -> dict:
+    """Recherche sur Google un mot-clé donné.
+    
     Args:
-        query (str): Le mot-clé à rechercher.
-
+        query: Le mot-clé à rechercher.
+        
     Returns:
         dict: Dictionnaire contenant l'URL et le titre du premier résultat.
     """
@@ -75,30 +23,75 @@ def recherche(query: str) -> dict:
         "User-Agent": (
             "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
             "AppleWebKit/537.36 (KHTML, like Gecko) "
-            "Chrome/58.0.3029.110 Safari/537.3"
+            "Chrome/98.0.4758.102 Safari/537.36"
         )
     }
-    params = {"q": query}
+    params = {"q": query, "hl": "fr"}
     
     response = requests.get(url_search, params=params, headers=headers)
     if response.status_code != 200:
         raise Exception("Erreur lors de la requête vers Google")
     
-    soup = BeautifulSoup(response.text, 'html.parser')
-    # Utilisation d'un sélecteur CSS pour trouver le premier lien de résultat
-    result = soup.select_one('div.yuRUbf a')
-    if not result:
-        return {"url": None, "titre": None}
-    
-    url_result = result.get("href")
-    titre = result.get_text(strip=True)
-    
-    return {"url": url_result, "titre": titre}
+    soup = BeautifulSoup(response.text, "html.parser")
+    # Recherche des blocs de résultats ; la structure de Google pouvant varier,
+    # nous itérons sur les résultats pour trouver un lien valide.
+    results = soup.find_all("div", class_="g")
+    for result in results:
+        a_tag = result.find("a")
+        if a_tag:
+            url_result = a_tag.get("href")
+            titre = a_tag.get_text(strip=True)
+            if url_result and titre:
+                return {"url": url_result, "titre": titre}
+    return {"url": None, "titre": None}
 
-# Test de l'outil de recherche
-if __name__ == "__main__":
+@tool
+def my_custom_tool(arg1: str, arg2: int) -> str:
+    """A tool that does nothing yet 
+    Args:
+        arg1: the first argument
+        arg2: the second argument
+    """
+    return "What magic will you build ?"
+
+@tool
+def get_current_time_in_timezone(timezone: str) -> str:
+    """A tool that fetches the current local time in a specified timezone.
+    
+    Args:
+        timezone: A string representing a valid timezone (e.g., 'America/New_York').
+    """
     try:
-        result = recherche.run("contrat de travail")
-        print("Résultat de la recherche :", result)
+        tz = pytz.timezone(timezone)
+        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+        return f"The current local time in {timezone} is: {local_time}"
     except Exception as e:
-        print("Erreur :", e)
+        return f"Error fetching time for timezone '{timezone}': {str(e)}"
+
+final_answer = FinalAnswerTool()
+model = HfApiModel(
+    max_tokens=2096,
+    temperature=0.5,
+    model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
+    custom_role_conversions=None,
+)
+
+# Import tool from Hub (exemple d'outil de génération d'image)
+image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
+
+with open("prompts.yaml", 'r') as stream:
+    prompt_templates = yaml.safe_load(stream)
+    
+agent = CodeAgent(
+    model=model,
+    tools=[final_answer, recherche_google, my_custom_tool, get_current_time_in_timezone],
+    max_steps=6,
+    verbosity_level=1,
+    grammar=None,
+    planning_interval=None,
+    name=None,
+    description=None,
+    prompt_templates=prompt_templates
+)
+
+GradioUI(agent).launch()