Update app.py

app.py

@@ -18,10 +18,7 @@ def load_it_model():
     Se nessun modello è installato, restituisce (None, None) e una istruzione per l'utente.
     """
     if spacy is None:
-        return None, None, (
-            "La libreria spaCy non è installata. "
-            "Installa spaCy: pip install spacy"
-        )
+        return None, None, ("La libreria spaCy non è installata. Installa spaCy: pip install spacy")
 
     candidates = ["it_core_news_lg", "it_core_news_md", "it_core_news_sm"]
     last_err = None
@@ -31,12 +28,10 @@ def load_it_model():
             return nlp, name, None
         except Exception as e:
             last_err = e
-    # nessun modello trovato -> non fallare l'import, ma restituire messaggio utile
     suggestion = (
         "Impossibile caricare un modello italiano spaCy. "
         "Installa almeno uno tra: it_core_news_lg / it_core_news_md / it_core_news_sm.\n"
-        "Esempio: python -m spacy download it_core_news_lg\n"
-        f"Dettagli ultimo errore: {last_err}"
+        f"Esempio: python -m spacy download it_core_news_lg\nDettagli ultimo errore: {last_err}"
     )
     return None, None, suggestion
 
@@ -60,10 +55,7 @@ SPIEGAZIONI_POS_IT = {
 }
 
 SPIEGAZIONI_ENT_IT = {
-    "PER": "Persona: Nomi di persone reali o fittizie.",
-    "LOC": "Luogo: Nomi di luoghi geografici come paesi, città, stati.",
-    "ORG": "Organizzazione: Nomi di aziende, istituzioni, governi.",
-    "MISC": "Miscellanea: Entità che non rientrano nelle altre categorie (eventi, nazionalità, prodotti)."
+    "PER": "Persona", "LOC": "Luogo", "ORG": "Organizzazione", "MISC": "Miscellanea"
 }
 
 # ------------------------------
@@ -73,22 +65,17 @@ KEY_MAP = {
     "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",
+    "Case": "Caso", "Poss": "Possessivo", "Reflex": "Riflessivo", "Aspect": "Aspetto", "Voice": "Voce",
 }
-
 VALUE_MAP = {
-    "Masc": "Maschile", "Fem": "Femminile", "Sing": "Singolare", "Plur": "Plurale",
-    "Cnd": "Condizionale", "Sub": "Congiuntivo", "Ind": "Indicativo", "Imp": "Imperfetto",
-    "Inf": "Infinito", "Part": "Participio", "Ger": "Gerundio", "Fin": "Finita",
-    "Pres": "Presente", "Past": "Passato", "Fut": "Futuro", "Pqp": "Trapassato",
-    "1": "1ª", "2": "2ª", "3": "3ª", "Prs": "Personale", "Rel": "Relativo", "Int": "Interrogativo",
-    "Dem": "Dimostrativo", "Art": "Articolativo", "Yes": "Sì", "No": "No", "Def": "Determinato",
-    "Indef": "Indefinito", "Abs": "Assoluto", "Cmp": "Comparativo", "Sup": "Superlativo",
-    "Nom": "Nominativo", "Acc": "Accusativo", "Gen": "Genitivo", "Dat": "Dativo",
-    "Perf": "Perfetto", "Prog": "Progressivo", "Act": "Attiva", "Pass": "Passiva",
+    "Masc": "Maschile", "Fem": "Femminile", "Sing": "Singolare", "Plur": "Plurale", "Cnd": "Condizionale",
+    "Sub": "Congiuntivo", "Ind": "Indicativo", "Imp": "Imperfetto", "Inf": "Infinito", "Part": "Participio",
+    "Ger": "Gerundio", "Fin": "Finita", "Pres": "Presente", "Past": "Passato", "Fut": "Futuro", "Pqp": "Trapassato",
+    "1": "1ª", "2": "2ª", "3": "3ª", "Prs": "Personale", "Rel": "Relativo", "Int": "Interrogativo", "Dem": "Dimostrativo",
+    "Art": "Articolativo", "Yes": "Sì", "No": "No", "Def": "Determinato", "Indef": "Indefinito", "Abs": "Assoluto",
+    "Cmp": "Comparativo", "Sup": "Superlativo", "Nom": "Nominativo", "Acc": "Accusativo", "Gen": "Genitivo",
+    "Dat": "Dativo", "Perf": "Perfetto", "Prog": "Progressivo", "Act": "Attiva", "Pass": "Passiva",
 }
-
 PAIR_VALUE_MAP = {
     ("Mood", "Imp"): "Imperativo", ("Tense", "Imp"): "Imperfetto",
     ("Mood", "Ind"): "Indicativo", ("Definite", "Ind"): "Indeterminato",
@@ -124,25 +111,26 @@ MAPPA_DEP = {
 # ------------------------------
 
 def spiega_in_italiano(tag, tipo='pos'):
-    if tipo == 'pos':
-        return SPIEGAZIONI_POS_IT.get(tag, tag)
-    return SPIEGAZIONI_ENT_IT.get(tag, tag)
+    if tipo == 'pos': return SPIEGAZIONI_POS_IT.get(tag, tag)
+    if tipo == 'ent': return f"{SPIEGAZIONI_ENT_IT.get(tag, tag)}: {SPIEGAZIONI_ENT_IT.get(tag, {}).get('description', '')}"
+    return tag
 
 def traduci_morfologia(morph_str: str) -> str:
     if not morph_str or morph_str == "___": return "Non disponibile"
-    parti_tradotte = []
-    for parte in morph_str.split('|'):
+    parti = morph_str.split('|')
+    parti_tradotte = set()
+    for parte in parti:
         if '=' not in parte: continue
         chiave, valore = parte.split('=', 1)
         chiave_trad = KEY_MAP.get(chiave, chiave)
         valore_trad = PAIR_VALUE_MAP.get((chiave, valore), VALUE_MAP.get(valore, valore))
-        parti_tradotte.append(f"{chiave_trad}: {valore_trad}")
-    return ", ".join(sorted(list(set(parti_tradotte)))) or "Non disponibile"
-
+        parti_tradotte.add(f"{chiave_trad}: {valore_trad}")
+    return ", ".join(sorted(list(parti_tradotte))) or "Non disponibile"
 
 def ottieni_tipo_complemento_con_dettagli(token):
-    preposizione = next((t.text.lower() for t in token.children if t.dep_ == "case"), None)
-    if not preposizione: return MAPPA_DEP.get("obl")
+    case_token = next((child for child in token.children if child.dep_ == 'case'), None)
+    if not case_token: return MAPPA_DEP.get("obl")
+    preposizione = case_token.text.lower()
 
     mappa = {
         "di": ("Complemento di Specificazione", "Risponde alla domanda: di chi? / di che cosa?"),
@@ -156,104 +144,75 @@ def ottieni_tipo_complemento_con_dettagli(token):
         "fra": ("Complemento Partitivo / Luogo", "Risponde alla domanda: fra chi? / fra cosa?"),
     }
     
-    # Gestione preposizioni articolate
     for base, (label, desc) in mappa.items():
         if preposizione.startswith(base):
-            label_final = label
-            desc_final = desc
-            # Check per complemento d'agente
             if base == "da" and any(c.dep_ == "aux:pass" for c in token.head.children):
-                label_final = "Complemento d'Agente"
-                desc_final = "Indica da chi è compiuta l'azione in una frase passiva."
-            return {"label": label_final, "description": desc_final}
+                return {"label": "Complemento d'Agente", "description": "Indica da chi è compiuta l'azione in una frase passiva."}
+            return {"label": label, "description": desc}
             
     return MAPPA_DEP.get("obl")
 
-
-def costruisci_sintagmi_con_dettagli(tokens_proposizione):
+def get_full_phrase_for_token(token):
     """
-    Costruisce una lista di componenti logici (sintagmi) da una lista di token spaCy.
-    Questa versione è più precisa e robusta, evitando di raggruppare erroneamente i componenti.
+    FIXED: Costruisce un sintagma in modo preciso, raccogliendo solo i modificatori
+    strettamente collegati e gli elementi coordinati.
     """
+    phrase_tokens = []
     
-    def get_phrase_and_indices(token):
-        """Costruisce il testo di un sintagma e restituisce gli indici dei token usati."""
-        # Raccoglie ricorsivamente i token coordinati (es. "libri e quaderni")
-        conjuncts = [c for c in token.children if c.dep_ == 'conj']
-        tokens_nel_sintagma = [token]
-        for conj in conjuncts:
-            tokens_nel_sintagma.append(conj)
-            # Aggiunge anche le congiunzioni (es. "e", "o")
-            cc = next((c for c in conj.children if c.dep_ == 'cc'), None)
-            if cc: tokens_nel_sintagma.append(cc)
-        
-        # Per ogni token principale, raccoglie i suoi modificatori diretti (articoli, aggettivi, etc.)
-        all_phrase_tokens = []
-        for t in tokens_nel_sintagma:
-            subtree = list(t.subtree)
-            # Filtra per tenere solo i modificatori strettamente legati
-            modificatori = [n for n in subtree if n.head == t and n.dep_ in ('det', 'amod', 'advmod', 'case', 'compound', 'appos', 'nmod')]
-            all_phrase_tokens.extend([t] + modificatori)
-
-        # Assicura che la congiunzione sia inclusa se presente
-        all_phrase_tokens.extend(c for c in token.children if c.dep_ == 'cc')
-
-        # Ordina i token e crea la stringa finale
-        tokens_ordinati = sorted(list(set(all_phrase_tokens)), key=lambda x: x.i)
-        testo_sintagma = " ".join(t.text for t in tokens_ordinati)
-        indici_usati = {t.i for t in tokens_ordinati}
-        
-        return testo_sintagma, indici_usati
+    # Funzione interna per raccogliere i token di un singolo elemento e i suoi figli diretti
+    def collect_children(t):
+        # Raccoglie i modificatori diretti (articoli, aggettivi, preposizioni)
+        children = [t]
+        for child in t.children:
+            if child.dep_ in ('det', 'amod', 'case', 'compound', 'advmod', 'appos'):
+                children.extend(collect_children(child)) # Raccoglie anche i figli dei figli (es. avverbi di aggettivi)
+        return children
+
+    # Raccoglie i token per il token principale
+    phrase_tokens.extend(collect_children(token))
+
+    # Gestisce la coordinazione (es. "libri e quaderni")
+    for child in token.children:
+        if child.dep_ == 'conj':
+            # Aggiunge la congiunzione (es. "e", "o")
+            cc = next((c for c in child.children if c.dep_ == 'cc'), None)
+            if cc:
+                phrase_tokens.append(cc)
+            # Aggiunge l'intero sintagma coordinato
+            phrase_tokens.extend(get_full_phrase_for_token(child))
+
+    # Ordina i token in base alla loro posizione originale e rimuove duplicati
+    unique_tokens = sorted(list(set(phrase_tokens)), key=lambda t: t.i)
+    text = " ".join(t.text for t in unique_tokens)
+    indices = {t.i for t in unique_tokens}
+    return text, indices
 
+def costruisci_sintagmi_con_dettagli(tokens_proposizione):
+    """
+    FIXED: L'algoritmo ora processa ogni componente logico separatamente e con precisione.
+    """
     risultato_analisi = []
     indici_elaborati = set()
     
-    # Token da non processare come "teste" di un sintagma (verranno inclusi dai loro "genitori")
-    SKIP_DEPS = {'det', 'case', 'punct', 'aux', 'cop', 'mark', 'cc', 'aux:pass', 'amod', 'advmod'}
+    # Definisce le dipendenze che non sono "teste" di un sintagma ma parti di esso
+    DEPS_DA_SALTARE = {'det', 'amod', 'case', 'aux', 'aux:pass', 'cop', 'mark', 'cc', 'advmod', 'compound', 'appos'}
 
     for token in tokens_proposizione:
-        if token.i in indici_elaborati or token.dep_ in SKIP_DEPS:
+        if token.i in indici_elaborati or token.dep_ in DEPS_DA_SALTARE:
             continue
-
-        # Gestione speciale per la copula in predicati nominali
-        if token.dep_ == "ROOT" and any(c.dep_ == 'cop' for c in token.children):
-            cop_token = next(c for c in token.children if c.dep_ == 'cop')
             
-            # 1. Aggiungi il soggetto
-            soggetto = next((s for s in token.head.children if s.dep_.startswith('nsubj')), None)
-            if soggetto and soggetto.i not in indici_elaborati:
-                s_text, s_indices = get_phrase_and_indices(soggetto)
-                risultato_analisi.append({
-                    "text": s_text, "label_info": MAPPA_DEP['nsubj'],
-                    "token_details": {"lemma": soggetto.lemma_, "pos": spiega_in_italiano(soggetto.pos_), "morph": traduci_morfologia(str(soggetto.morph))}
-                })
-                indici_elaborati.update(s_indices)
-            
-            # 2. Aggiungi la copula
-            risultato_analisi.append({
-                "text": cop_token.text, "label_info": MAPPA_DEP['cop'],
-                "token_details": {"lemma": cop_token.lemma_, "pos": spiega_in_italiano(cop_token.pos_), "morph": traduci_morfologia(str(cop_token.morph))}
-            })
-            indici_elaborati.add(cop_token.i)
-            
-            # 3. Aggiungi la parte nominale
-            pn_text, pn_indices = get_phrase_and_indices(token)
-            risultato_analisi.append({
-                "text": pn_text, "label_info": {"label": "Parte Nominale del Predicato", "description": "Aggettivo o nome che descrive il soggetto."},
-                "token_details": {"lemma": token.lemma_, "pos": spiega_in_italiano(token.pos_), "morph": traduci_morfologia(str(token.morph))}
-            })
-            indici_elaborati.update(pn_indices)
-            continue
-            
-        # Logica standard per tutti gli altri componenti
-        testo_sintagma, indici_usati = get_phrase_and_indices(token)
+        testo_sintagma, indici_usati = get_full_phrase_for_token(token)
         
         dep = token.dep_
-        if dep in ('obl', 'obl:agent'):
+        if dep in ('obl', 'obl:agent', 'nmod'):
             info_etichetta = ottieni_tipo_complemento_con_dettagli(token)
         else:
             info_etichetta = MAPPA_DEP.get(dep, {"label": dep.capitalize(), "description": "Relazione non mappata."})
 
+        # Caso speciale per predicato nominale
+        if dep == "ROOT" and any(c.dep_ == 'cop' for c in token.children):
+            info_etichetta = {"label": "Parte Nominale del Predicato", "description": "Aggettivo o nome che descrive il soggetto."}
+
         risultato_analisi.append({
             "text": testo_sintagma,
             "label_info": info_etichetta,
@@ -262,35 +221,43 @@ def costruisci_sintagmi_con_dettagli(tokens_proposizione):
                 "pos": f"{token.pos_}: {spiega_in_italiano(token.pos_)}",
                 "tag": f"{token.tag_}: {spiega_in_italiano(token.tag_)}",
                 "morph": traduci_morfologia(str(token.morph))
-            }
+            },
+            "token_index": token.i
         })
         indici_elaborati.update(indici_usati)
 
-    # Ordina i risultati in base alla loro apparizione nella frase
-    risultato_analisi.sort(key=lambda x: x['text'].split()[0] in [t.text for t in tokens_proposizione] and [t.text for t in tokens_proposizione].index(x['text'].split()[0]))
+    # Aggiungi componenti saltati (es. copula, congiunzioni) che sono importanti
+    for token in tokens_proposizione:
+        if token.i not in indici_elaborati and token.dep_ in ('cop', 'cc'):
+            risultato_analisi.append({
+                "text": token.text,
+                "label_info": MAPPA_DEP.get(token.dep_),
+                "token_details": { "lemma": token.lemma_, "pos": f"{token.pos_}: {spiega_in_italiano(token.pos_)}", "morph": traduci_morfologia(str(token.morph)) },
+                "token_index": token.i
+            })
+
+    # Ordina i risultati finali in base all'indice del token principale
+    risultato_analisi.sort(key=lambda x: x['token_index'])
     return risultato_analisi
 
-def analizza_proposizione_con_dettagli(token_proposizione):
-    token_validi = [t for t in token_proposizione if not t.is_punct and not t.is_space]
-    return costruisci_sintagmi_con_dettagli(token_validi)
+def analizza_proposizione_con_dettagli(tokens):
+    tokens_validi = [t for t in tokens if not t.is_punct and not t.is_space]
+    return costruisci_sintagmi_con_dettagli(tokens_validi)
 
 # ------------------------------
 # Routes
 # ------------------------------
 @app.route("/")
 def home():
-    status = "ok" if nlp is not None else "model_missing"
+    status = "ok" if nlp else "model_missing"
     return jsonify({
-        "messaggio": "API analisi logica in esecuzione",
-        "modello_spacy": IT_MODEL if IT_MODEL else "Nessuno",
-        "model_status": status,
-        "model_error": MODEL_LOAD_ERROR,
-        "endpoint": "/api/analyze"
+        "messaggio": "API analisi logica in esecuzione", "modello_spacy": IT_MODEL or "Nessuno",
+        "model_status": status, "model_error": MODEL_LOAD_ERROR, "endpoint": "/api/analyze"
     })
 
 @app.route('/api/analyze', methods=['POST'])
 def analizza_frase():
-    if nlp is None:
+    if not nlp:
         return jsonify({"errore": "Modello spaCy non caricato.", "dettagli": MODEL_LOAD_ERROR}), 503
 
     try:
@@ -301,22 +268,20 @@ def analizza_frase():
 
         doc = nlp(frase)
         
-        proposizioni_subordinate = []
-        indici_subordinate = set()
+        proposizioni_subordinate, indici_subordinate = [], set()
         SUBORD_DEPS = {"acl:relcl", "advcl", "ccomp", "csubj", "xcomp", "acl", "parataxis"}
 
         for token in doc:
-            if token.dep_ in SUBORD_DEPS:
+            if token.dep_ in SUBORD_DEPS and token.i not in indici_subordinate:
                 subtree = list(token.subtree)
-                subtree_indices = {t.i for t in subtree}
-                if not indici_subordinate.intersection(subtree_indices):
-                    indici_subordinate.update(subtree_indices)
-                    info_tipo = MAPPA_DEP.get(token.dep_, {"label": "Proposizione Subordinata", "description": "Frase che dipende da un'altra."})
-                    proposizioni_subordinate.append({
-                        "type_info": info_tipo,
-                        "text": " ".join(t.text for t in subtree),
-                        "analysis": analizza_proposizione_con_dettagli(subtree)
-                    })
+                indici_subtree = {t.i for t in subtree}
+                indici_subordinate.update(indici_subtree)
+                info_tipo = MAPPA_DEP.get(token.dep_, {"label": "Proposizione Subordinata", "description": "Frase che dipende da un'altra."})
+                proposizioni_subordinate.append({
+                    "type_info": info_tipo,
+                    "text": " ".join(t.text for t in subtree if not t.is_punct).strip(),
+                    "analysis": analizza_proposizione_con_dettagli(subtree)
+                })
 
         token_principale = [t for t in doc if t.i not in indici_subordinate]
         
@@ -324,18 +289,16 @@ def analizza_frase():
         visti = set()
         for ent in doc.ents:
             if ent.text not in visti:
+                visti.add(ent.text)
                 entita_nominate.append({
-                    "text": ent.text,
-                    "label": ent.label_,
-                    "explanation": spiega_in_italiano(ent.label_, 'ent')
+                    "text": ent.text, "label": ent.label_,
+                    "explanation": f"{SPIEGAZIONI_ENT_IT.get(ent.label_, ent.label_)}"
                 })
-                visti.add(ent.text)
 
         analisi_finale = {
-            "full_sentence": frase,
-            "model": IT_MODEL,
+            "full_sentence": frase, "model": IT_MODEL,
             "main_clause": {
-                "text": " ".join(t.text for t in token_principale),
+                "text": " ".join(t.text for t in token_principale if not t.is_punct).strip(),
                 "analysis": analizza_proposizione_con_dettagli(token_principale)
             },
             "subordinate_clauses": proposizioni_subordinate,