Update app.py

app.py

@@ -4,23 +4,21 @@ from flask_cors import CORS
 import spacy
 import traceback
 
-# --- SEZIONE CARICAMENTO MODELLO ---
+# --- CARICAMENTO MODELLO ---
 try:
-    # 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_lg'. "
-        "Assicurati che sia elencato e installato dal tuo file requirements.txt. "
-        "Puoi scaricarlo con: python -m spacy download it_core_news_lg"
+        "Assicurati che sia elencato e installato nel tuo requirements.txt.\n"
+        "Comando per installarlo localmente: python -m spacy download it_core_news_lg"
     )
-# --- FINE SEZIONE ---
 
-# Inizializza l'app Flask
+# --- INIZIALIZZAZIONE APP ---
 app = Flask(__name__)
 CORS(app)
 
-# --- INIZIO SEZIONE TRADUZIONI ---
+# --- MAPPE DI TRADUZIONE / SPIEGAZIONI ---
 SPIEGAZIONI_POS_IT = {
     "ADJ": "Aggettivo", "ADP": "Preposizione", "ADV": "Avverbio", "AUX": "Ausiliare",
     "CONJ": "Congiunzione", "CCONJ": "Congiunzione Coordinante", "SCONJ": "Congiunzione Subordinante",
@@ -36,60 +34,26 @@ SPIEGAZIONI_ENT_IT = {
     "MISC": "Miscellanea: Entità che non rientrano nelle altre categorie (es. eventi, nazionalità, prodotti)."
 }
 
-# Dizionario per le traduzioni morfologiche (espanso per coprire più casi)
 TRADUZIONI_MORFOLOGIA = {
-    # Chiavi
+    # 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",
+    "Clitic": "Clitico", "Definite": "Definizione", "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", "Pqp": "Trapassato",
-    "1": "1ª", "2": "2ª", "3": "3ª",
+    "Aspect": "Aspetto", "Voice": "Voce", "Polarity": "Polarità",
+    # valori
+    "Masc": "Maschile", "Fem": "Femminile", "Sing": "Singolare", "Plur": "Plurale",
+    "Ind": "Indicativo", "Sub": "Congiuntivo", "Cnd": "Condizionale", "Imp": "Imperativo",
+    "Pres": "Presente", "Past": "Passato", "Fut": "Futuro", "Pqp": "Trapassato",
     "Fin": "Finita", "Inf": "Infinito", "Part": "Participio", "Ger": "Gerundio",
-    "Prs": "Personale", "Rel": "Relativo", "Int": "Interrogativo", "Dem": "Dimostrativo", "Art": "Articolativo", "Ind": "Indefinito",
-    "Yes": "Sì", "No": "No",
-    "Ind": "Indeterminato", "Def": "Determinato",
+    "Prs": "Personale", "Rel": "Relativo", "Int": "Interrogativo", "Dem": "Dimostrativo",
+    "Art": "Articolativo", "Indf": "Indeterminato", "Yes": "Sì", "No": "No",
     "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':
-        # 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 or morph_str == "___":
-        return "Non disponibile"
-    
-    parti = morph_str.split('|')
-    parti_tradotte = []
-    for parte in parti:
-        if '=' in parte:
-            chiave, valore = parte.split('=', 1)
-            chiave_tradotta = TRADUZIONI_MORFOLOGIA.get(chiave, chiave)
-            valore_tradotto = TRADUZIONI_MORFOLOGIA.get(valore, valore)
-            parti_tradotte.append(f"{chiave_tradotta}: {valore_tradotto}")
-        else:
-            parti_tradotte.append(TRADUZIONI_MORFOLOGIA.get(parte, parte))
-    
-    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."},
@@ -110,12 +74,81 @@ MAPPA_DEP = {
     "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."}
+    "cc": {"label": "Congiunzione Coordinante", "description": "Congiunzione che collega elementi coordinati."},
+    "parataxis": {"label": "Paratassi", "description": "Frasi coordinate senza connettore esplicito."}
 }
 
+# --- FUNZIONI DI UTILITÀ ---
+
+def spiega_in_italiano(tag, tipo='pos'):
+    """
+    Fornisce spiegazione per POS o entità.
+    - tipo == 'pos' => tag dovrebbe essere token.pos_ (es. VERB, NOUN)
+    - tipo == 'ent' => ent label (PER, LOC, ORG...)
+    """
+    if tipo == 'pos':
+        key = tag.upper().split(":")[0]  # normalizza caso e rimuove eventuali dettagli
+        return SPIEGAZIONI_POS_IT.get(key, key)
+    if tipo == 'ent':
+        return SPIEGAZIONI_ENT_IT.get(tag, tag)
+    return tag
+
+def traduci_morfologia_from_token(token):
+    """
+    Usa token.morph (meglio token.morph.to_dict()) per costruire una descrizione leggibile.
+    """
+    try:
+        morph_dict = token.morph.to_dict()
+    except Exception:
+        # Fallback alla stringa originale
+        morph_str = str(token.morph)
+        if not morph_str:
+            return "Non disponibile"
+        parti = morph_str.split("|")
+        mappate = []
+        for parte in parti:
+            if "=" in parte:
+                k, v = parte.split("=", 1)
+                mappate.append(f"{TRADUZIONI_MORFOLOGIA.get(k,k)}: {TRADUZIONI_MORFOLOGIA.get(v, v)}")
+            else:
+                mappate.append(TRADUZIONI_MORFOLOGIA.get(parte, parte))
+        return ", ".join(mappate) if mappate else "Non disponibile"
+
+    parti_tradotte = []
+    for k, v in sorted(morph_dict.items()):
+        k_tr = TRADUZIONI_MORFOLOGIA.get(k, k)
+        if isinstance(v, (list, tuple)):
+            v_str = ", ".join(TRADUZIONI_MORFOLOGIA.get(x, x) for x in v)
+        else:
+            v_str = TRADUZIONI_MORFOLOGIA.get(v, v)
+        parti_tradotte.append(f"{k_tr}: {v_str}")
+    return ", ".join(parti_tradotte) if parti_tradotte else "Non disponibile"
+
+def get_verb_phrase(token):
+    """
+    Costruisce la 'verb phrase' completa: aggiunge ausiliari, negazioni, particelle legate.
+    Ordina i token per indice per mantenere la sequenza corretta.
+    """
+    verb_related = []
+    # includi token stesso se è verbo o copula
+    if token.pos_ in ("VERB", "AUX") or token.dep_ in ("cop", "ROOT"):
+        verb_related.append(token)
+    # cerca ausiliari, negazioni e copula fra i figli e nella testa (se la testa è verbo)
+    for t in list(token.children):
+        if t.dep_ in ('aux', 'aux:pass', 'neg', 'cop', 'prt'):
+            verb_related.append(t)
+    # talvolta l'ausiliare è head (in casi particolari); includi ausiliari nella testa che hanno head==token or viceversa
+    # includi anche eventuali elementi nella subtree stretta che sono parte del verbo
+    for t in token.subtree:
+        if t.dep_ in ('aux', 'aux:pass', 'neg', 'cop', 'prt') and t not in verb_related:
+            verb_related.append(t)
+
+    # rimuovi duplicati e ordina
+    verb_related = sorted(set(verb_related), key=lambda x: x.i)
+    return " ".join(t.text for t in verb_related).strip() or token.text
+
 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()
@@ -126,144 +159,144 @@ def ottieni_tipo_complemento_con_dettagli(token):
                 preposizione = figlio.text.lower()
                 break
 
-    # 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)",
+        "del": "Complemento di Specificazione", "dello": "Complemento di Specificazione",
+        "della": "Complemento di Specificazione", "dei": "Complemento di Specificazione",
+        "a": "Complemento di Termine", "al": "Complemento di Termine",
+        "da": "Complemento di Moto da Luogo", "dal": "Complemento di Moto da Luogo",
+        "in": "Complemento di Stato in Luogo", "nel": "Complemento di Stato in Luogo",
+        "con": "Complemento di Compagnia o Mezzo", "su": "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):
+    if preposizione.startswith("da") and any(figlio.dep_ in ('aux:pass','aux') 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):
-    # Raccogli il sintagma completo ricorsivamente per includere modificatori nidificati
+    """
+    Raccoglie il sintagma completo includendo determinanti, aggettivi, apposizioni, complementi stretti.
+    """
     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 = []
+        for f in t.children:
+            if f.dep_ in ('det', 'amod', 'case', 'advmod', 'nmod', 'appos', 'acl', 'compound', 'flat', 'nummod'):
+                figli.append(f)
                 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
+    token_sintagma = sorted(set(token_sintagma), key=lambda x: x.i)
     return " ".join(t.text for t in token_sintagma if not t.is_punct).strip()
 
 def costruisci_sintagmi_con_dettagli(lista_token):
+    """
+    Costruisce la lista di sintagmi (soggetto, predicato, complementi) con dettagli per ogni token significativo.
+    Non scartiamo ausiliari e copula: li rappresentiamo opportunamente.
+    """
     mappa_sintagmi = {}
-    
+
+    # selezioniamo token utili (scartiamo solo punteggiatura e spazi)
     for token in lista_token:
-        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))
-                },
-                "label_info": {},
-                "token": token
-            }
-            
+        if token.is_punct or token.is_space:
+            continue
+        mappa_sintagmi[token.i] = {
+            "text": ottieni_testo_completo(token),
+            "token_details": {
+                "text": token.text,
+                "lemma": token.lemma_,
+                "pos": token.pos_,
+                "pos_explanation": spiega_in_italiano(token.pos_, 'pos'),
+                "tag": token.tag_,
+                "morph_raw": str(token.morph),
+                "morph": traduci_morfologia_from_token(token)
+            },
+            "label_info": {},
+            "token": token
+        }
+
     risultato_analisi = []
     indici_elaborati = set()
-    
+
     for indice, sintagma in sorted(mappa_sintagmi.items()):
         if indice in indici_elaborati:
             continue
-            
+
         token = sintagma['token']
         dep = token.dep_
         info_etichetta = MAPPA_DEP.get(dep, {"label": dep, "description": "Relazione non mappata."})
 
+        # gestione ROOT e predicato nominale con copula
         if dep == "ROOT":
-            # 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 = copula_children[0]
-                nome_del_predicato = ottieni_testo_completo(token)
+            # trova eventuali copule collegate (cop o aux:cop)
+            copula_children = [c for c in token.children if c.dep_ in ('cop', 'aux:cop')]
+            if copula_children:
+                cop = copula_children[0]
+                # copula come verbo
                 risultato_analisi.append({
-                    "text": copula.text,
-                    "label_info": {"label": "Copula", "description": "Verbo 'essere' che collega il soggetto alla parte nominale."},
+                    "text": cop.text,
+                    "label_info": {"label": "Copula", "description": "Verbo 'essere' che collega soggetto e 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))
+                        "lemma": cop.lemma_,
+                        "pos": cop.pos_,
+                        "pos_explanation": spiega_in_italiano(cop.pos_, 'pos'),
+                        "tag": cop.tag_,
+                        "morph": traduci_morfologia_from_token(cop),
+                        "verb_phrase": get_verb_phrase(cop)
                     }
                 })
+                # parte nominale (il nome/aggettivo che segue)
                 risultato_analisi.append({
-                    "text": nome_del_predicato,
-                    "label_info": {"label": "Parte Nominale del Predicato", "description": "Aggettivo o nome che descrive il soggetto."},
+                    "text": sintagma["text"],
+                    "label_info": {"label": "Parte Nominale del Predicato", "description": "Parte nominale che descrive il soggetto."},
                     "token_details": sintagma["token_details"]
                 })
                 indici_elaborati.add(indice)
                 continue
             else:
-                info_etichetta = MAPPA_DEP.get(dep, {})
-        elif dep in ('obl', 'obl:agent'):
+                # ROOT come verbo principale: mostriamo verb phrase completa
+                sintagma_da_aggiungere = {
+                    "text": sintagma['text'],
+                    "label_info": info_etichetta,
+                    "token_details": dict(sintagma['token_details'])
+                }
+                # se è verbo, aggiungi la verb_phrase
+                if token.pos_ in ("VERB", "AUX"):
+                    sintagma_da_aggiungere["token_details"]["verb_phrase"] = get_verb_phrase(token)
+                    sintagma_da_aggiungere["token_details"]["verb_morph"] = traduci_morfologia_from_token(token)
+                risultato_analisi.append(sintagma_da_aggiungere)
+                indici_elaborati.add(indice)
+                continue
+
+        # gestione complementi obl e agent
+        if dep in ('obl', 'obl:agent', 'obl:mod'):
             info_etichetta = ottieni_tipo_complemento_con_dettagli(token)
-        elif dep == 'nsubj:pass':
-            info_etichetta = MAPPA_DEP.get('nsubj:pass', MAPPA_DEP['nsubj'])
 
-        if info_etichetta:
-            sintagma_da_aggiungere = {
-                "text": sintagma['text'],
-                "label_info": info_etichetta
-            }
-            if sintagma.get("token_details"):
-                sintagma_da_aggiungere["token_details"] = sintagma["token_details"]
-            risultato_analisi.append(sintagma_da_aggiungere)
+        if dep == 'nsubj:pass':
+            info_etichetta = MAPPA_DEP.get('nsubj:pass', MAPPA_DEP['nsubj'])
 
+        sintagma_da_aggiungere = {
+            "text": sintagma['text'],
+            "label_info": info_etichetta
+        }
+        if sintagma.get("token_details"):
+            # se è un verbo o ausiliare aggiungiamo la verb_phrase
+            if token.pos_ in ("VERB", "AUX"):
+                sintagma['token_details']["verb_phrase"] = get_verb_phrase(token)
+                sintagma['token_details']["verb_morph"] = traduci_morfologia_from_token(token)
+            sintagma_da_aggiungere["token_details"] = sintagma["token_details"]
+
+        risultato_analisi.append(sintagma_da_aggiungere)
         indici_elaborati.add(indice)
-        
-    # Rimuovi duplicati dal risultato finale
+
+    # rimuovi duplicati (testo)
     risultato_unico = []
     testi_visti = set()
     for item in risultato_analisi:
@@ -273,9 +306,11 @@ def costruisci_sintagmi_con_dettagli(lista_token):
     return risultato_unico
 
 def analizza_proposizione_con_dettagli(token_proposizione):
-    token_nella_proposizione = [t for t in token_proposizione if t.dep_ != 'mark' and not t.is_punct and not t.is_space]
+    token_nella_proposizione = [t for t in token_proposizione if not t.is_punct and not t.is_space]
     return costruisci_sintagmi_con_dettagli(token_nella_proposizione)
 
+# --- ENDPOINT ---
+
 @app.route("/")
 def home():
     return jsonify({"messaggio": "L'API per l'analisi logica è in esecuzione. Usa l'endpoint /api/analyze."})
@@ -292,18 +327,17 @@ def analizza_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", "xcomp", "acl", "parataxis"]:  # Espanso per più tipi, inclusa parataxis per coordinate
+            if token.dep_ in ["acl:relcl", "advcl", "ccomp", "csubj", "xcomp", "acl", "parataxis", "parataxis:rel"]:
                 token_proposizione_subordinata = list(token.subtree)
                 for t in token_proposizione_subordinata:
                     indici_subordinate.add(t.i)
 
                 info_tipo_subordinata = MAPPA_DEP.get(token.dep_, {"label": "Proposizione Subordinata", "description": "Una frase che dipende da un'altra."})
-                
                 marcatore = [figlio for figlio in token.children if figlio.dep_ == 'mark']
                 intro = marcatore[0].text if marcatore else ""
 
@@ -339,14 +373,13 @@ def analizza_frase():
             "subordinate_clauses": proposizioni_subordinate,
             "named_entities": entita_unica
         }
-        
+
         return jsonify(analisi_finale)
 
     except Exception as e:
-        print(f"Errore durante l'analisi: {e}")
         traceback.print_exc()
         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=False, threaded=True)  # Threaded per gestire più richieste
+    app.run(host="0.0.0.0", port=porta, debug=False, threaded=True)