Update app.py

app.py

@@ -6,12 +6,13 @@ import traceback
 
 # --- SEZIONE CARICAMENTO MODELLO ---
 try:
-    # Carica il modello italiano di spaCy
-    nlp = spacy.load("it_core_news_sm")
+    # Carica un modello più accurato per l'italiano di spaCy (usa 'lg' per maggiore precisione)
+    nlp = spacy.load("it_core_news_lg")
 except OSError:
     raise RuntimeError(
-        "Impossibile trovare il modello 'it_core_news_sm'. "
-        "Assicurati che sia elencato e installato dal tuo file requirements.txt."
+        "Impossibile trovare il modello 'it_core_news_lg'. "
+        "Assicurati che sia elencato e installato dal tuo file requirements.txt. "
+        "Puoi scaricarlo con: python -m spacy download it_core_news_lg"
     )
 # --- FINE SEZIONE ---
 
@@ -35,36 +36,43 @@ SPIEGAZIONI_ENT_IT = {
     "MISC": "Miscellanea: Entità che non rientrano nelle altre categorie (es. eventi, nazionalità, prodotti)."
 }
 
-# NUOVA SEZIONE: Dizionario per le traduzioni morfologiche
+# Dizionario per le traduzioni morfologiche (espanso per coprire più casi)
 TRADUZIONI_MORFOLOGIA = {
     # Chiavi
     "Gender": "Genere", "Number": "Numero", "Mood": "Modo", "Tense": "Tempo",
     "Person": "Persona", "VerbForm": "Forma del Verbo", "PronType": "Tipo di Pronome",
     "Clitic": "Clitico", "Definite": "Definitezza", "Degree": "Grado",
+    "Case": "Caso", "Poss": "Possessivo", "Reflex": "Riflessivo",
+    "Aspect": "Aspetto", "Voice": "Voce",
     # Valori
     "Masc": "Maschile", "Fem": "Femminile",
     "Sing": "Singolare", "Plur": "Plurale",
     "Ind": "Indicativo", "Sub": "Congiuntivo", "Cnd": "Condizionale", "Imp": "Imperativo", "Inf": "Infinito", "Part": "Participio", "Ger": "Gerundio",
-    "Pres": "Presente", "Past": "Passato", "Fut": "Futuro", "Imp": "Imperfetto",
+    "Pres": "Presente", "Past": "Passato", "Fut": "Futuro", "Imp": "Imperfetto", "Pqp": "Trapassato",
     "1": "1ª", "2": "2ª", "3": "3ª",
     "Fin": "Finita", "Inf": "Infinito", "Part": "Participio", "Ger": "Gerundio",
-    "Prs": "Personale", "Rel": "Relativo", "Int": "Interrogativo", "Dem": "Dimostrativo", "Art": "Articolativo",
-    "Yes": "Sì",
+    "Prs": "Personale", "Rel": "Relativo", "Int": "Interrogativo", "Dem": "Dimostrativo", "Art": "Articolativo", "Ind": "Indefinito",
+    "Yes": "Sì", "No": "No",
     "Ind": "Indeterminato", "Def": "Determinato",
-    "Abs": "Assoluto", "Cmp": "Comparativo",
+    "Abs": "Assoluto", "Cmp": "Comparativo", "Sup": "Superlativo",
+    "Nom": "Nominativo", "Acc": "Accusativo", "Gen": "Genitivo", "Dat": "Dativo",
+    "Perf": "Perfetto", "Prog": "Progressivo",
+    "Act": "Attiva", "Pass": "Passiva",
 }
 
 def spiega_in_italiano(tag, tipo='pos'):
     """Fornisce una spiegazione in italiano per un tag POS o di entità."""
     if tipo == 'pos':
-        return SPIEGAZIONI_POS_IT.get(tag, tag)
+        # Per i tag dettagliati, estrai la parte POS principale se necessario
+        pos_base = tag.split("__")[0] if "__" in tag else tag
+        return SPIEGAZIONI_POS_IT.get(pos_base, tag)
     if tipo == 'ent':
         return SPIEGAZIONI_ENT_IT.get(tag, tag)
     return tag
 
 def traduci_morfologia(morph_str):
     """Traduce la stringa morfologica in un formato leggibile in italiano."""
-    if not morph_str:
+    if not morph_str or morph_str == "___":
         return "Non disponibile"
     
     parti = morph_str.split('|')
@@ -76,15 +84,15 @@ def traduci_morfologia(morph_str):
             valore_tradotto = TRADUZIONI_MORFOLOGIA.get(valore, valore)
             parti_tradotte.append(f"{chiave_tradotta}: {valore_tradotto}")
         else:
-            # Gestisce i casi in cui non c'è una coppia chiave=valore
             parti_tradotte.append(TRADUZIONI_MORFOLOGIA.get(parte, parte))
-            
-    return ", ".join(parti_tradotte)
+    
+    return ", ".join(sorted(set(parti_tradotte))) or "Non disponibile"  # Sort and unique for cleanliness
 # --- FINE SEZIONE TRADUZIONI ---
 
 
 MAPPA_DEP = {
     "nsubj": {"label": "Soggetto", "description": "Indica chi o cosa compie l'azione o si trova in un certo stato."},
+    "nsubj:pass": {"label": "Soggetto (Passivo)", "description": "Soggetto in una costruzione passiva."},
     "ROOT": {"label": "Predicato Verbale", "description": "Esprime l'azione o lo stato del soggetto."},
     "obj": {"label": "Complemento Oggetto", "description": "Indica l'oggetto diretto dell'azione del verbo."},
     "iobj": {"label": "Complemento di Termine", "description": "Indica a chi o a cosa è destinata l'azione."},
@@ -96,59 +104,107 @@ MAPPA_DEP = {
     "acl:relcl": {"label": "Proposizione Subordinata Relativa", "description": "Frase che espande un nome, introdotta da un pronome relativo."},
     "advcl": {"label": "Proposizione Subordinata Avverbiale", "description": "Frase che funziona come un avverbio, modificando il verbo della principale."},
     "ccomp": {"label": "Proposizione Subordinata Oggettiva", "description": "Frase che funge da complemento oggetto del verbo della principale."},
-    "csubj": {"label": "Proposizione Subordinata Soggettiva", "description": "Frase che funge da soggetto del verbo della principale."}
+    "csubj": {"label": "Proposizione Subordinata Soggettiva", "description": "Frase che funge da soggetto del verbo della principale."},
+    "xcomp": {"label": "Complemento Predicativo", "description": "Complemento che completa il significato del verbo."},
+    "acl": {"label": "Modificatore Relativo", "description": "Clausola che modifica un nome."},
+    "compound": {"label": "Composto", "description": "Parte di un composto nominale."},
+    "flat": {"label": "Nome Piatto", "description": "Parte di un nome proprio o espressione fissa."},
+    "conj": {"label": "Congiunzione Coordinata", "description": "Elemento coordinato con un altro."},
+    "cc": {"label": "Congiunzione Coordinante", "description": "Congiunzione che collega elementi coordinati."}
 }
 
 def ottieni_tipo_complemento_con_dettagli(token):
     preposizione = ""
+    # Cerca la preposizione nei figli o nel contesto
     for figlio in token.children:
         if figlio.dep_ == "case":
             preposizione = figlio.text.lower()
             break
-    if not preposizione and token.head.dep_ == 'obl':
+    if not preposizione and token.dep_ == 'obl':
         for figlio in token.head.children:
-            if figlio.dep_ == "case":
+            if figlio.dep_ == "case" and figlio.head == token:
                 preposizione = figlio.text.lower()
                 break
 
-    if preposizione in ["di", "del", "dello", "della", "dei", "degli", "delle"]:
-        return {"label": "Complemento di Specificazione", "description": "Risponde alla domanda 'di chi?', 'di che cosa?'."}
-    if preposizione in ["a", "al", "allo", "alla", "ai", "agli", "alle"]:
-        return {"label": "Complemento di Termine", "description": "Risponde alla domanda 'a chi?', 'a che cosa?'."}
-    if preposizione in ["da", "dal", "dallo", "dalla", "dai", "dagli", "dalle"]:
-        if any(figlio.dep_ == 'aux:pass' for figlio in token.head.children):
-            return {"label": "Complemento d'Agente", "description": "Indica da chi è compiuta l'azione in una frase passiva."}
-        return {"label": "Complemento di Moto da Luogo", "description": "Indica il luogo da cui inizia un movimento."}
-    if preposizione in ["in", "nel", "nello", "nella", "nei", "negli", "nelle"]:
-        return {"label": "Complemento di Stato in Luogo", "description": "Indica il luogo in cui si svolge un'azione o ci si trova."}
-    if preposizione in ["con", "col", "coi"]:
-        return {"label": "Complemento di Compagnia o Mezzo", "description": "Indica la persona/animale con cui si compie l'azione o lo strumento utilizzato."}
-    if preposizione in ["su", "sul", "sullo", "sulla", "sui", "sugli", "sulle"]:
-        return {"label": "Complemento di Argomento o Luogo", "description": "Indica l'argomento di cui si parla o il luogo su cui si trova qualcosa."}
-    if preposizione in ["per"]:
-        return {"label": "Complemento di Fine o Causa", "description": "Indica lo scopo o la causa di un'azione."}
-    if preposizione in ["tra", "fra"]:
-        return {"label": "Complemento di Luogo o Tempo (Partitivo)", "description": "Indica una posizione intermedia o una scelta all'interno di un gruppo."}
-
-    return {"label": "Complemento Indiretto", "description": "Fornisce un'informazione generica non classificata in modo più specifico."}
+    # Mappa preposizioni a complementi (espansa per più varianti e casi)
+    mappa_preposizioni = {
+        "di": "Complemento di Specificazione",
+        "del": "Complemento di Specificazione",
+        "dello": "Complemento di Specificazione",
+        "della": "Complemento di Specificazione",
+        "dei": "Complemento di Specificazione",
+        "degli": "Complemento di Specificazione",
+        "delle": "Complemento di Specificazione",
+        "a": "Complemento di Termine",
+        "al": "Complemento di Termine",
+        "allo": "Complemento di Termine",
+        "alla": "Complemento di Termine",
+        "ai": "Complemento di Termine",
+        "agli": "Complemento di Termine",
+        "alle": "Complemento di Termine",
+        "da": "Complemento di Moto da Luogo",
+        "dal": "Complemento di Moto da Luogo",
+        "dallo": "Complemento di Moto da Luogo",
+        "dalla": "Complemento di Moto da Luogo",
+        "dai": "Complemento di Moto da Luogo",
+        "dagli": "Complemento di Moto da Luogo",
+        "dalle": "Complemento di Moto da Luogo",
+        "in": "Complemento di Stato in Luogo",
+        "nel": "Complemento di Stato in Luogo",
+        "nello": "Complemento di Stato in Luogo",
+        "nella": "Complemento di Stato in Luogo",
+        "nei": "Complemento di Stato in Luogo",
+        "negli": "Complemento di Stato in Luogo",
+        "nelle": "Complemento di Stato in Luogo",
+        "con": "Complemento di Compagnia o Mezzo",
+        "col": "Complemento di Compagnia o Mezzo",
+        "coi": "Complemento di Compagnia o Mezzo",
+        "su": "Complemento di Argomento o Luogo",
+        "sul": "Complemento di Argomento o Luogo",
+        "sullo": "Complemento di Argomento o Luogo",
+        "sulla": "Complemento di Argomento o Luogo",
+        "sui": "Complemento di Argomento o Luogo",
+        "sugli": "Complemento di Argomento o Luogo",
+        "sulle": "Complemento di Argomento o Luogo",
+        "per": "Complemento di Fine o Causa",
+        "tra": "Complemento di Luogo o Tempo (Partitivo)",
+        "fra": "Complemento di Luogo o Tempo (Partitivo)",
+    }
+
+    label = mappa_preposizioni.get(preposizione, "Complemento Indiretto")
+    description = "Fornisce un'informazione generica non classificata in modo più specifico." if label == "Complemento Indiretto" else "Risponde alla domanda appropriata per il tipo di complemento."
+
+    if preposizione.startswith("da") and any(figlio.dep_ == 'aux:pass' for figlio in token.head.children):
+        label = "Complemento d'Agente"
+        description = "Indica da chi è compiuta l'azione in una frase passiva."
+
+    return {"label": label, "description": description}
 
 def ottieni_testo_completo(token):
-    token_sintagma = [token] + sorted([t for t in token.children if t.dep_ in ('det', 'amod', 'case', 'advmod')], key=lambda x: x.i)
-    token_sintagma.sort(key=lambda x: x.i)
-    return " ".join(t.text for t in token_sintagma)
+    # Raccogli il sintagma completo ricorsivamente per includere modificatori nidificati
+    def raccogli_figli(t):
+        figli = list(t.children)
+        for f in figli:
+            if f.dep_ in ('det', 'amod', 'case', 'advmod', 'nmod', 'appos', 'acl', 'compound', 'flat'):
+                figli.extend(raccogli_figli(f))
+        return figli
+
+    token_sintagma = [token] + raccogli_figli(token)
+    token_sintagma = sorted(set(token_sintagma), key=lambda x: x.i)  # Ordina e rimuovi duplicati
+    return " ".join(t.text for t in token_sintagma if not t.is_punct).strip()
 
 def costruisci_sintagmi_con_dettagli(lista_token):
     mappa_sintagmi = {}
     
     for token in lista_token:
-        if token.dep_ not in ['det', 'case', 'amod', 'punct', 'aux', 'cop', 'mark']:
+        if token.dep_ not in ['det', 'case', 'amod', 'punct', 'aux', 'cop', 'mark', 'cc', 'advmod', 'aux:pass']:  # Espanso per skipping più elementi ausiliari
             mappa_sintagmi[token.i] = {
                 "text": ottieni_testo_completo(token),
                 "token_details": {
                     "lemma": token.lemma_,
                     "pos": f"{token.pos_}: {spiega_in_italiano(token.pos_, 'pos')}",
                     "tag": f"{token.tag_}: {spiega_in_italiano(token.tag_, 'pos')}",
-                    "morph": traduci_morfologia(str(token.morph)) # AGGIORNATO
+                    "morph": traduci_morfologia(str(token.morph))
                 },
                 "label_info": {},
                 "token": token
@@ -163,35 +219,39 @@ def costruisci_sintagmi_con_dettagli(lista_token):
             
         token = sintagma['token']
         dep = token.dep_
-        info_etichetta = {}
+        info_etichetta = MAPPA_DEP.get(dep, {"label": dep, "description": "Relazione non mappata."})
 
         if dep == "ROOT":
-            e_nominale = any(c.dep_ == 'cop' for c in token.children)
+            # Gestione predicato nominale migliorata
+            copula_children = [c for c in token.children if c.dep_ == 'cop']
+            e_nominale = bool(copula_children)
             if e_nominale:
-                copula = [c for c in token.children if c.dep_ == 'cop'][0]
+                copula = copula_children[0]
                 nome_del_predicato = ottieni_testo_completo(token)
                 risultato_analisi.append({
                     "text": copula.text,
                     "label_info": {"label": "Copula", "description": "Verbo 'essere' che collega il soggetto alla parte nominale."},
                     "token_details": {
-                         "lemma": copula.lemma_,
-                         "pos": f"{copula.pos_}: {spiega_in_italiano(copula.pos_, 'pos')}",
-                         "tag": f"{copula.tag_}: {spiega_in_italiano(copula.tag_, 'pos')}",
-                         "morph": traduci_morfologia(str(copula.morph)) # AGGIORNATO
+                        "lemma": copula.lemma_,
+                        "pos": f"{copula.pos_}: {spiega_in_italiano(copula.pos_, 'pos')}",
+                        "tag": f"{copula.tag_}: {spiega_in_italiano(copula.tag_, 'pos')}",
+                        "morph": traduci_morfologia(str(copula.morph))
                     }
                 })
                 risultato_analisi.append({
                     "text": nome_del_predicato,
                     "label_info": {"label": "Parte Nominale del Predicato", "description": "Aggettivo o nome che descrive il soggetto."},
-                     "token_details": sintagma["token_details"]
+                    "token_details": sintagma["token_details"]
                 })
+                indici_elaborati.add(indice)
+                continue
             else:
                 info_etichetta = MAPPA_DEP.get(dep, {})
-        elif dep == 'obl':
+        elif dep in ('obl', 'obl:agent'):
             info_etichetta = ottieni_tipo_complemento_con_dettagli(token)
-        elif dep in MAPPA_DEP:
-            info_etichetta = MAPPA_DEP[dep]
-        
+        elif dep == 'nsubj:pass':
+            info_etichetta = MAPPA_DEP.get('nsubj:pass', MAPPA_DEP['nsubj'])
+
         if info_etichetta:
             sintagma_da_aggiungere = {
                 "text": sintagma['text'],
@@ -203,10 +263,17 @@ def costruisci_sintagmi_con_dettagli(lista_token):
 
         indici_elaborati.add(indice)
         
-    return risultato_analisi
+    # Rimuovi duplicati dal risultato finale
+    risultato_unico = []
+    testi_visti = set()
+    for item in risultato_analisi:
+        if item['text'] not in testi_visti:
+            risultato_unico.append(item)
+            testi_visti.add(item['text'])
+    return risultato_unico
 
 def analizza_proposizione_con_dettagli(token_proposizione):
-    token_nella_proposizione = [t for t in token_proposizione if t.dep_ != 'mark']
+    token_nella_proposizione = [t for t in token_proposizione if t.dep_ != 'mark' and not t.is_punct and not t.is_space]
     return costruisci_sintagmi_con_dettagli(token_nella_proposizione)
 
 @app.route("/")
@@ -220,14 +287,17 @@ def analizza_frase():
         if not dati or 'sentence' not in dati:
             return jsonify({"errore": "Frase non fornita"}), 400
 
-        frase = dati['sentence']
+        frase = dati['sentence'].strip()
+        if not frase:
+            return jsonify({"errore": "Frase vuota"}), 400
+
         doc = nlp(frase)
         
         proposizioni_subordinate = []
         indici_subordinate = set()
         
         for token in doc:
-            if token.dep_ in ["acl:relcl", "advcl", "ccomp", "csubj"]:
+            if token.dep_ in ["acl:relcl", "advcl", "ccomp", "csubj", "xcomp", "acl", "parataxis"]:  # Espanso per più tipi, inclusa parataxis per coordinate
                 token_proposizione_subordinata = list(token.subtree)
                 for t in token_proposizione_subordinata:
                     indici_subordinate.add(t.i)
@@ -239,7 +309,7 @@ def analizza_frase():
 
                 proposizioni_subordinate.append({
                     "type_info": info_tipo_subordinata,
-                    "text": " ".join(t.text for t in token_proposizione_subordinata if not t.is_punct),
+                    "text": " ".join(t.text for t in token_proposizione_subordinata if not t.is_punct and not t.is_space).strip(),
                     "intro": intro,
                     "analysis": analizza_proposizione_con_dettagli(token_proposizione_subordinata)
                 })
@@ -252,14 +322,22 @@ def analizza_frase():
             "explanation": spiega_in_italiano(ent.label_, 'ent')
         } for ent in doc.ents]
 
+        # Rimuovi duplicati dalle entità
+        entita_unica = []
+        testi_ent_visti = set()
+        for ent in entita_nominate:
+            if ent['text'] not in testi_ent_visti:
+                entita_unica.append(ent)
+                testi_ent_visti.add(ent['text'])
+
         analisi_finale = {
             "full_sentence": frase,
             "main_clause": {
-                "text": " ".join(t.text for t in token_proposizione_principale if not t.is_punct),
+                "text": " ".join(t.text for t in token_proposizione_principale if not t.is_punct and not t.is_space).strip(),
                 "analysis": analizza_proposizione_con_dettagli(token_proposizione_principale)
             },
             "subordinate_clauses": proposizioni_subordinate,
-            "named_entities": entita_nominate
+            "named_entities": entita_unica
         }
         
         return jsonify(analisi_finale)
@@ -267,8 +345,8 @@ def analizza_frase():
     except Exception as e:
         print(f"Errore durante l'analisi: {e}")
         traceback.print_exc()
-        return jsonify({"errore": "Si è verificato un errore interno."}), 500
+        return jsonify({"errore": "Si è verificato un errore interno.", "dettagli": str(e)}), 500
 
 if __name__ == '__main__':
     porta = int(os.environ.get("PORT", 8080))
-    app.run(host="0.0.0.0", port=porta, debug=True)
+    app.run(host="0.0.0.0", port=porta, debug=False, threaded=True)  # Threaded per gestire più richieste