Update app.py

app.py

@@ -1,65 +1,111 @@
-from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
-import datetime
 import requests
-import pytz
-import yaml
-from tools.final_answer import FinalAnswerTool
+from bs4 import BeautifulSoup
+from functools import wraps
+from typing import Callable, Any, List, Union
 
-from Gradio_UI import GradioUI
+class Tool:
+    """
+    Représente un outil réutilisable pour l'agent.
 
-# Below is an example of a tool that does nothing. Amaze us with your creativity!
-@tool
-def my_custom_tool(arg1:str, arg2:int)-> str: # it's important to specify the return type
-    # Keep this format for the tool description / args description but feel free to modify the tool
-    """A tool that does nothing yet 
-    Args:
-        arg1: the first argument
-        arg2: the second argument
+    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.
     """
-    return "What magic will you build ?"
+    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
 
-@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').
+    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):
     """
-    try:
-        # Create timezone object
-        tz = pytz.timezone(timezone)
-        # Get current time in that 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:
-        return f"Error fetching time for timezone '{timezone}': {str(e)}"
+    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.
 
-final_answer = FinalAnswerTool()
-model = HfApiModel(
-max_tokens=2096,
-temperature=0.5,
-model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
-custom_role_conversions=None,
-)
+    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)
+        # Retourne une instance de Tool associée à la fonction
+        return Tool(
+            name=tool_name,
+            description=description or func.__doc__,
+            func=func,
+            arguments=tool_arguments,
+            outputs=tool_outputs
+        )
+    return decorator
 
+@tool(
+    name="RechercheLegifrance",
+    description="Outil pour effectuer une recherche sur Légifrance 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 Légifrance un mot-clé donné.
 
-# Import tool from Hub
-image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
+    Args:
+        query (str): Le mot-clé à rechercher.
 
-with open("prompts.yaml", 'r') as stream:
-    prompt_templates = yaml.safe_load(stream)
+    Returns:
+        dict: Dictionnaire contenant l'URL et le titre du premier résultat.
+    """
+    # URL de base pour la recherche (à adapter selon la structure réelle du site)
+    url_search = "https://www.legifrance.gouv.fr/search"
+    params = {"query": query}
     
-agent = CodeAgent(
-    model=model,
-    tools=[final_answer], # add your tools here (don't remove final_answer)
-    max_steps=6,
-    verbosity_level=1,
-    grammar=None,
-    planning_interval=None,
-    name=None,
-    description=None,
-    prompt_templates=prompt_templates
-)
+    response = requests.get(url_search, params=params)
+    if response.status_code != 200:
+        raise Exception("Erreur lors de la requête vers Légifrance")
+    
+    soup = BeautifulSoup(response.text, 'html.parser')
+    # Analyse du HTML pour trouver le bloc contenant les résultats.
+    # Ici, on suppose que chaque résultat se trouve dans une balise <div class="result">
+    results = soup.find_all("div", class_="result")
+    
+    if not results:
+        return {"url": None, "titre": None}
+    
+    # Extraction du premier résultat
+    premier = results[0]
+    a_tag = premier.find("a")
+    url_result = a_tag.get("href")
+    titre = a_tag.get_text(strip=True)
+    
+    # Compléter l'URL si elle est relative
+    if url_result and not url_result.startswith("http"):
+        url_result = "https://www.legifrance.gouv.fr" + url_result
+    
+    return {"url": url_result, "titre": titre}
 
+# On peut maintenant utiliser la fonction décorée comme un outil
+outil_recherche = recherche
 
-GradioUI(agent).launch()
+# Exemple de test :
+if __name__ == "__main__":
+    try:
+        result = outil_recherche.run("contrat de travail")
+        print("Résultat de la recherche :", result)
+    except Exception as e:
+        print("Erreur :", e)