Update app.py

app.py

@@ -1,65 +1,215 @@
-da smolagents importa CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, strumento
- importa datetime
- importa richieste
- importa pytz
- importa yaml
- da tools.final_answer importa FinalAnswerTool
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
+import datetime
+import requests
+import pytz
+import yaml
+from tools.final_answer import FinalAnswerTool
 
-da Gradio_UI importa GradioUI
+from Gradio_UI import GradioUI
 
 # Di seguito è riportato un esempio di uno strumento che non fa nulla. Stupiscici con la tua creatività! 
+@tool 
+def my_custom_tool(arg1: str, arg2: int) -> str: # è importante specificare il tipo di ritorno 
+    """Uno strumento personalizzato che combina una stringa e un numero
+    Argomenti:
+        arg1: una stringa da elaborare
+        arg2: un numero intero da utilizzare come parametro
+    """
+    result = f"Input elaborato: {arg1} ripetuto {arg2} volte = {arg1 * arg2}"
+    return result
 
-def  my_custom_tool ( arg1: str , arg2: int )-> str : # è importante specificare il tipo di ritorno 
-    # Mantieni questo formato per la descrizione dello strumento / descrizione degli argomenti ma sentiti libero di modificare lo strumento 
-    """Uno strumento che non fa ancora nulla
+@tool 
+def get_current_time_in_timezone(timezone: str) -> str:
+    """Uno strumento che recupera l'ora locale corrente in un fuso orario specificato.
     Argomenti:
-        arg1: il primo argomento
-        arg2: il secondo argomento
+        timezone: una stringa che rappresenta un fuso orario valido (ad esempio, 'America/New_York').
     """ 
-    ritorna  "Quale magia costruirai?"
+    try:
+        # Crea oggetto fuso orario
+        tz = pytz.timezone(timezone)
+        # Ottieni l'ora corrente in quel fuso orario 
+        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+        return f"L'ora locale corrente in {timezone} è: {local_time}" 
+    except Exception as e:
+        return f"Errore durante il recupero dell'ora per il fuso orario '{timezone}': {str(e)}"
 
+@tool
+def analyze_sentiment(text: str) -> str:
+    """Analizza il sentimento di un testo fornito.
+    Argomenti:
+        text: il testo da analizzare
+    """
+    try:
+        # Implementazione semplificata, in produzione utilizzare una libreria NLP come transformers
+        positive_words = ["buono", "ottimo", "eccellente", "felice", "positivo", "meraviglioso"]
+        negative_words = ["cattivo", "terribile", "triste", "negativo", "pessimo", "orribile"]
+        
+        text_lower = text.lower()
+        positive_count = sum(1 for word in positive_words if word in text_lower)
+        negative_count = sum(1 for word in negative_words if word in text_lower)
+        
+        if positive_count > negative_count:
+            sentiment = "positivo"
+        elif negative_count > positive_count:
+            sentiment = "negativo"
+        else:
+            sentiment = "neutro"
+            
+        return f"Analisi del sentimento: {sentiment} (parole positive: {positive_count}, parole negative: {negative_count})"
+    except Exception as e:
+        return f"Errore durante l'analisi del sentimento: {str(e)}"
 
-def  get_current_time_in_timezone ( timezone: str ) -> str :
-     """Uno strumento che recupera l'ora locale corrente in un fuso orario specificato.
+@tool
+def extract_entities(text: str) -> str:
+    """Estrae entità come nomi, luoghi e organizzazioni da un testo.
     Argomenti:
-        fuso orario: una stringa che rappresenta un fuso orario valido (ad esempio, 'America/New_York').
-    """ 
-    prova :
-         # Crea oggetto fuso orario
-        tz = pytz.timezone(fuso orario)
-        # Ottieni l'ora corrente in quel fuso orario 
-        local_time = datetime.datetime.now(tz).strftime( "%Y-%m-%d %H:%M:%S" )
-         return  f"L'ora locale corrente in {timezone} è: {local_time} " 
+        text: il testo da cui estrarre le entità
+    """
+    try:
+        # Implementazione semplificata, in produzione utilizzare spaCy o Hugging Face transformers
+        common_names = ["Mario", "Luigi", "Giovanni", "Maria", "Anna", "Giuseppe"]
+        common_places = ["Roma", "Milano", "Napoli", "Firenze", "Venezia", "Italia"]
+        common_orgs = ["Google", "Microsoft", "Apple", "Amazon", "Facebook", "Twitter"]
+        
+        text_words = text.split()
+        names = [word for word in text_words if word in common_names]
+        places = [word for word in text_words if word in common_places]
+        orgs = [word for word in text_words if word in common_orgs]
+        
+        result = {
+            "nomi": names,
+            "luoghi": places,
+            "organizzazioni": orgs
+        }
+        
+        return f"Entità estratte: {result}"
+    except Exception as e:
+        return f"Errore durante l'estrazione delle entità: {str(e)}"
+
+@tool
+def image_classification(image_url: str) -> str:
+    """Classifica un'immagine da un URL.
+    Argomenti:
+        image_url: URL dell'immagine da classificare
+    """
+    try:
+        # Simulazione di classificazione, in produzione utilizzare un modello di vision come ViT
+        if not image_url.startswith("http"):
+            return "Errore: fornire un URL valido che inizia con http:// o https://"
+            
+        # Controlla se l'URL è accessibile
+        response = requests.head(image_url, timeout=5)
+        if response.status_code != 200:
+            return f"Errore: impossibile accedere all'URL dell'immagine (status code: {response.status_code})"
+            
+        # Simuliamo la classificazione
+        if "dog" in image_url.lower() or "cane" in image_url.lower():
+            return "Classificazione immagine: Cane (probabilità: 0.92)"
+        elif "cat" in image_url.lower() or "gatto" in image_url.lower():
+            return "Classificazione immagine: Gatto (probabilità: 0.89)"
+        else:
+            return "Classificazione immagine: Oggetto generico (probabilità: 0.75)"
     except Exception as e:
-         return  f"Errore durante il recupero dell'ora per il fuso orario ' {timezone} ': { str (e)} "
+        return f"Errore durante la classificazione dell'immagine: {str(e)}"
 
+@tool
+def translate_text(text: str, target_language: str) -> str:
+    """Traduce un testo in una lingua di destinazione.
+    Argomenti:
+        text: il testo da tradurre
+        target_language: la lingua di destinazione (es. 'en', 'fr', 'es', 'de')
+    """
+    try:
+        # Implementazione semplificata, in produzione utilizzare API come Google Translate o modelli NLP
+        language_map = {
+            'en': 'inglese',
+            'fr': 'francese',
+            'es': 'spagnolo',
+            'de': 'tedesco',
+            'it': 'italiano'
+        }
+        
+        if target_language not in language_map:
+            return f"Errore: lingua di destinazione '{target_language}' non supportata. Lingue supportate: {', '.join(language_map.keys())}"
+            
+        return f"Testo tradotto in {language_map.get(target_language, target_language)}: [Simulazione di traduzione per '{text}']"
+    except Exception as e:
+        return f"Errore durante la traduzione: {str(e)}"
 
-risposta_finale = StrumentoRispostaFinale()
-modello = HfApiModel(
-numero massimo di token = 2096 ,
-temperatura= 0,5 ,
-model_id= 'Qwen/Qwen2.5-Coder-32B-Istruzione' ,
-custom_role_conversions= Nessuno ,
-)
+@tool
+def summarize_text(text: str, max_length: int = 100) -> str:
+    """Riassume un testo lungo in una versione più breve.
+    Argomenti:
+        text: il testo da riassumere
+        max_length: lunghezza massima del riassunto in caratteri (default: 100)
+    """
+    try:
+        if len(text) <= max_length:
+            return f"Il testo è già abbastanza breve: {text}"
+            
+        # Implementazione semplificata, in produzione utilizzare un modello NLP
+        words = text.split()
+        sentences = []
+        current_sentence = []
+        
+        for word in words:
+            current_sentence.append(word)
+            if word.endswith('.') or word.endswith('!') or word.endswith('?'):
+                sentences.append(' '.join(current_sentence))
+                current_sentence = []
+                
+        if current_sentence:
+            sentences.append(' '.join(current_sentence))
+            
+        # Seleziona solo la prima frase o frasi fino al limite
+        summary = ""
+        for sentence in sentences:
+            if len(summary + sentence) <= max_length:
+                summary += sentence + " "
+            else:
+                break
+                
+        return f"Riassunto: {summary.strip()}"
+    except Exception as e:
+        return f"Errore durante il riassunto del testo: {str(e)}"
+
+final_answer = FinalAnswerTool()
+search_tool = DuckDuckGoSearchTool()
 
+model = HfApiModel(
+    max_tokens=2096,
+    temperature=0.5,
+    model_id='Qwen/Qwen2.5-Coder-32B-Instruction',
+    custom_role_conversions=None,
+)
 
 # Strumento di importazione dall'hub 
-image_generation_tool = load_tool( "agents-course/text-to-image" , trust_remote_code= True )
+image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
 
-con  open ( "prompts.yaml" , 'r' ) come flusso:
-    prompt_templates = yaml.safe_load(flusso)
+with open("prompts.yaml", 'r') as stream:
+    prompt_templates = yaml.safe_load(stream)
     
-agente = CodeAgent(
-    modello=modello,
-    tools=[final_answer], # aggiungi i tuoi strumenti qui (non rimuovere final_answer) 
-    max_steps= 6 ,
-    livello_di_verbosità= 1 ,
-    grammatica= Nessuna ,
-    planning_interval= Nessuno ,
-    nome= Nessuno ,
-    descrizione= Nessuno ,
-    prompt_templates=template_prompt
+agent = CodeAgent(
+    model=model,
+    tools=[
+        final_answer,
+        my_custom_tool,
+        get_current_time_in_timezone,
+        analyze_sentiment,
+        extract_entities,
+        image_classification,
+        translate_text,
+        summarize_text,
+        search_tool,
+        image_generation_tool
+    ],
+    max_steps=6,
+    verbosity_level=1,
+    grammar=None,
+    planning_interval=None,
+    name="AssistenteNLPCV",
+    description="Un assistente AI specializzato in NLP e Computer Vision con capacità di ricerca e generazione di immagini",
+    prompt_templates=prompt_templates
 )
 
-
-GradioUI(agente).launch()
+GradioUI(agent).launch()