Update app.py

app.py

@@ -1,32 +1,46 @@
 import os
+import traceback
 from flask import Flask, request, jsonify
 from flask_cors import CORS
-import spacy
-import traceback
+
+# Try to import spacy lazily and handle missing models gracefully
+try:
+    import spacy
+except Exception:
+    spacy = None
 
 # ------------------------------
-# Caricamento modello spaCy (con fallback)
+# Caricamento modello spaCy (con fallback non-bloccante)
 # ------------------------------
-
 def load_it_model():
-    """Prova a caricare un modello italiano in ordine di qualità.
-    Suggerisce il comando di installazione se non disponibile.
     """
+    Prova a caricare un modello italiano in ordine di qualità.
+    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"
+        )
+
     candidates = ["it_core_news_lg", "it_core_news_md", "it_core_news_sm"]
     last_err = None
     for name in candidates:
         try:
-            return spacy.load(name), name
+            nlp = spacy.load(name)
+            return nlp, name, None
         except Exception as e:
             last_err = e
-    raise RuntimeError(
+    # 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}"
     )
+    return None, None, suggestion
 
-nlp, IT_MODEL = load_it_model()
+nlp, IT_MODEL, MODEL_LOAD_ERROR = load_it_model()
 
 # ------------------------------
 # Flask App
@@ -53,7 +67,7 @@ SPIEGAZIONI_ENT_IT = {
 }
 
 # ------------------------------
-# Traduzioni Morfologia (UD) con mappatura consapevole chiave/valore
+# Traduzioni Morfologia (UD)
 # ------------------------------
 KEY_MAP = {
     "Gender": "Genere", "Number": "Numero", "Mood": "Modo", "Tense": "Tempo",
@@ -63,274 +77,222 @@ KEY_MAP = {
     "Aspect": "Aspetto", "Voice": "Voce",
 }
 
-# Valori generici (non ambigui)
 VALUE_MAP = {
-    "Masc": "Maschile", "Fem": "Femminile",
-    "Sing": "Singolare", "Plur": "Plurale",
+    "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",
+    "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",
+    "Perf": "Perfetto", "Prog": "Progressivo", "Act": "Attiva", "Pass": "Passiva",
 }
 
-# Coppie chiave/valore per risolvere ambiguità (es. Imp = Imperativo vs Imperfetto; Ind = Indicativo vs Indeterminato)
 PAIR_VALUE_MAP = {
-    ("Mood", "Imp"): "Imperativo",
-    ("Tense", "Imp"): "Imperfetto",
-    ("Mood", "Ind"): "Indicativo",
-    ("Definite", "Ind"): "Indeterminato",
+    ("Mood", "Imp"): "Imperativo", ("Tense", "Imp"): "Imperfetto",
+    ("Mood", "Ind"): "Indicativo", ("Definite", "Ind"): "Indeterminato",
 }
 
-
-def spiega_in_italiano(tag, tipo='pos'):
-    """Spiega un tag POS o NER in italiano."""
-    if tipo == 'pos':
-        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: str) -> str:
-    """Traduce la stringa morfologica UD in italiano con gestione delle ambiguità."""
-    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 = chiave.strip()
-            valore = valore.strip()
-            chiave_trad = KEY_MAP.get(chiave, chiave)
-            # priorità a mappa di coppia chiave/valore, altrimenti valore generico
-            valore_trad = PAIR_VALUE_MAP.get((chiave, valore), VALUE_MAP.get(valore, valore))
-            parti_tradotte.append(f"{chiave_trad}: {valore_trad}")
-        else:
-            # valore singolo
-            parti_tradotte.append(VALUE_MAP.get(parte.strip(), parte.strip()))
-
-    # non usare set() per non perdere ordine; rimuovi duplicati preservando l'ordine
-    visti = set()
-    puliti = []
-    for p in parti_tradotte:
-        if p not in visti:
-            puliti.append(p)
-            visti.add(p)
-    return ", ".join(puliti) if puliti else "Non disponibile"
-
 # ------------------------------
 # Mappature Dependency → Etichette italiane
 # ------------------------------
 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."},
-    "obl": {"label": "Complemento Indiretto", "description": "Informazioni aggiuntive (luogo, tempo, modo, causa, ecc.)."},
-    "obl:agent": {"label": "Complemento d'Agente", "description": "Chi compie l'azione in una frase passiva."},
-    "nmod": {"label": "Complemento di Specificazione", "description": "Specificazione legata a un nome."},
-    "amod": {"label": "Attributo", "description": "Aggettivo che qualifica un nome."},
-    "advmod": {"label": "Complemento Avverbiale", "description": "Modifica verbo/aggettivo/avverbio."},
-    "appos": {"label": "Apposizione", "description": "Nome che ne chiarisce un altro."},
-    "acl:relcl": {"label": "Proposizione Subordinata Relativa", "description": "Frase introdotta da pronome relativo."},
-    "advcl": {"label": "Proposizione Subordinata Avverbiale", "description": "Frase che modifica il verbo della principale."},
-    "ccomp": {"label": "Proposizione Subordinata Oggettiva", "description": "Frase che funge da complemento oggetto."},
-    "csubj": {"label": "Proposizione Subordinata Soggettiva", "description": "Frase che funge da soggetto."},
-    "xcomp": {"label": "Complemento Predicativo", "description": "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/espressione fissa."},
-    "conj": {"label": "Congiunzione Coordinata", "description": "Elemento coordinato con un altro."},
-    "cc": {"label": "Congiunzione Coordinante", "description": "Congiunzione che collega elementi coordinati."}
+    "nsubj:pass": {"label": "Soggetto (Passivo)", "description": "Soggetto di una frase in forma passiva."},
+    "ROOT": {"label": "Predicato Verbale", "description": "Esprime l'azione, l'esistenza o lo stato del soggetto."},
+    "obj": {"label": "Complemento Oggetto", "description": "Indica l'oggetto diretto dell'azione. Risponde alla domanda: chi? / che cosa?"},
+    "iobj": {"label": "Complemento di Termine", "description": "Indica a chi o a cosa è destinata l'azione. Risponde alla domanda: a chi? / a che cosa?"},
+    "obl": {"label": "Complemento Indiretto", "description": "Fornisce informazioni aggiuntive (luogo, tempo, modo, causa, ecc.)."},
+    "obl:agent": {"label": "Complemento d'Agente", "description": "Indica chi compie l'azione in una frase passiva. Risponde alla domanda: da chi?"},
+    "nmod": {"label": "Complemento di Specificazione", "description": "Specifica o definisce un altro nome. Risponde alla domanda: di chi? / di che cosa?"},
+    "amod": {"label": "Attributo", "description": "Aggettivo che qualifica o descrive un nome a cui si riferisce."},
+    "advmod": {"label": "Complemento Avverbiale", "description": "Modifica o precisa il significato di un verbo, aggettivo o altro avverbio."},
+    "appos": {"label": "Apposizione", "description": "Sostantivo che si affianca a un altro per meglio identificarlo."},
+    "acl:relcl": {"label": "Proposizione Subordinata Relativa", "description": "Frase introdotta da un pronome relativo che espande un nome."},
+    "advcl": {"label": "Proposizione Subordinata Avverbiale", "description": "Frase che funziona come un complemento avverbiale per la 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."},
+    "xcomp": {"label": "Complemento Predicativo", "description": "Completa il significato del verbo riferendosi al soggetto o all'oggetto."},
+    "conj": {"label": "Elemento Coordinato", "description": "Elemento collegato a un altro con la stessa funzione logica."},
+    "cc": {"label": "Congiunzione Coordinante", "description": "Congiunzione (es. e, ma, o) che collega elementi con la stessa funzione."},
+    "cop": {"label": "Copula", "description": "Verbo 'essere' che collega il soggetto a un nome o aggettivo (parte nominale)."},
 }
 
-
 # ------------------------------
-# Utilità sintagmi / complementi
+# Utilità di Analisi
 # ------------------------------
 
-def ottieni_tipo_complemento_con_dettagli(token):
-    preposizione = ""
-    # cerca preposizione nel figlio "case"
-    for figlio in token.children:
-        if figlio.dep_ == "case":
-            preposizione = figlio.text.lower()
-            break
-    if not preposizione and token.dep_ == 'obl':
-        for figlio in token.head.children:
-            if figlio.dep_ == "case" and figlio.head == token:
-                preposizione = figlio.text.lower()
-                break
-
-    mappa_preposizioni = {
-        # di → specificazione
-        "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 → termine
-        "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 → moto da luogo
-        "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 → stato in 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 → compagnia/mezzo
-        "con": "Complemento di Compagnia o Mezzo", "col": "Complemento di Compagnia o Mezzo", "coi": "Complemento di Compagnia o Mezzo",
-        # su → argomento/luogo
-        "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 → fine/causa
-        "per": "Complemento di Fine o Causa",
-        # tra/fra → luogo/tempo
-        "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."
-    )
-
-    # agente nelle passive (da + ausiliare passivo nelle vicinanze)
-    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):
-    """Raccoglie ricorsivamente il sintagma testuale del token (senza punteggiatura)."""
-    def raccogli_figli(t):
-        figli = list(t.children)
-        for f in list(figli):
-            if f.dep_ in ('det', 'amod', 'case', 'advmod', 'nmod', 'appos', 'acl', 'compound', 'flat'):  # includi modificatori utili
-                figli.extend(raccogli_figli(f))
-        return figli
-
-    token_sintagma = [token] + raccogli_figli(token)
-    # ordina per indice e rimuovi duplicati mantenendo l'ordine
-    visti = set()
-    ordinati = []
-    for t in sorted(token_sintagma, key=lambda x: x.i):
-        if t not in visti and not t.is_punct:
-            ordinati.append(t)
-            visti.add(t)
-    return " ".join(t.text for t in ordinati).strip()
-
+def spiega_in_italiano(tag, tipo='pos'):
+    if tipo == 'pos':
+        return SPIEGAZIONI_POS_IT.get(tag, tag)
+    return SPIEGAZIONI_ENT_IT.get(tag, tag)
 
-def costruisci_sintagmi_con_dettagli(lista_token):
-    mappa_sintagmi = {}
+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('|'):
+        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"
 
-    # Non scartare "advmod" (servono gli avverbi). Scarta elementi funzionali che non portano sintagmi autonomi.
-    SKIP = {'det', 'case', 'punct', 'aux', 'cop', 'mark', 'cc', 'aux:pass'}
 
-    for token in lista_token:
-        if token.dep_ in SKIP:
-            continue
-        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
-        }
+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")
+
+    mappa = {
+        "di": ("Complemento di Specificazione", "Risponde alla domanda: di chi? / di che cosa?"),
+        "a": ("Complemento di Termine", "Risponde alla domanda: a chi? / a che cosa?"),
+        "da": ("Complemento di Moto da Luogo", "Risponde alla domanda: da dove?"),
+        "in": ("Complemento di Stato in Luogo", "Risponde alla domanda: dove?"),
+        "con": ("Complemento di Compagnia o Mezzo", "Risponde alla domanda: con chi? / con che cosa?"),
+        "su": ("Complemento di Argomento o Luogo", "Risponde alla domanda: su chi? / su che cosa? / dove?"),
+        "per": ("Complemento di Fine o Causa", "Risponde alla domanda: per quale fine? / per quale causa?"),
+        "tra": ("Complemento Partitivo / Luogo", "Risponde alla domanda: tra chi? / tra cosa?"),
+        "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 MAPPA_DEP.get("obl")
+
+
+def costruisci_sintagmi_con_dettagli(tokens_proposizione):
+    """
+    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.
+    """
+    
+    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
 
     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'}
 
-    for indice, sintagma in sorted(mappa_sintagmi.items()):
-        if indice in indici_elaborati:
+    for token in tokens_proposizione:
+        if token.i in indici_elaborati or token.dep_ in SKIP_DEPS:
             continue
-        token = sintagma['token']
-        dep = token.dep_
-        info_etichetta = MAPPA_DEP.get(dep, {"label": dep, "description": "Relazione non mappata."})
-
-        if dep == "ROOT":
-            # Predicato verbale o nominale
-            copule = [c for c in token.children if c.dep_ == 'cop']
-            if copule:
-                cop = copule[0]
-                # aggiungi copula
-                risultato_analisi.append({
-                    "text": cop.text,
-                    "label_info": {"label": "Copula", "description": "Verbo 'essere' che collega il soggetto alla parte nominale."},
-                    "token_details": {
-                        "lemma": cop.lemma_,
-                        "pos": f"{cop.pos_}: {spiega_in_italiano(cop.pos_, 'pos')}",
-                        "tag": f"{cop.tag_}: {spiega_in_italiano(cop.tag_, 'pos')}",
-                        "morph": traduci_morfologia(str(cop.morph))
-                    }
-                })
-                # parte nominale del predicato
+
+        # 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": ottieni_testo_completo(token),
-                    "label_info": {"label": "Parte Nominale del Predicato", "description": "Aggettivo o nome che descrive il soggetto."},
-                    "token_details": sintagma["token_details"]
+                    "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.add(indice)
-                continue
-            # altrimenti predicato verbale standard → già etichettato come ROOT
-        elif dep in ('obl', 'obl:agent'):
+                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)
+        
+        dep = token.dep_
+        if dep in ('obl', 'obl:agent'):
             info_etichetta = ottieni_tipo_complemento_con_dettagli(token)
-        elif dep == 'nsubj:pass':
-            info_etichetta = MAPPA_DEP.get('nsubj:pass', MAPPA_DEP['nsubj'])
+        else:
+            info_etichetta = MAPPA_DEP.get(dep, {"label": dep.capitalize(), "description": "Relazione non mappata."})
 
-        # aggiungi il sintagma
-        sintagma_da_aggiungere = {
-            "text": sintagma['text'],
+        risultato_analisi.append({
+            "text": testo_sintagma,
             "label_info": info_etichetta,
-            "token_details": sintagma["token_details"]
-        }
-        risultato_analisi.append(sintagma_da_aggiungere)
-        indici_elaborati.add(indice)
-
-    # Rimuovi duplicati per testo preservando l'ordine
-    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
+            "token_details": {
+                "lemma": token.lemma_,
+                "pos": f"{token.pos_}: {spiega_in_italiano(token.pos_)}",
+                "tag": f"{token.tag_}: {spiega_in_italiano(token.tag_)}",
+                "morph": traduci_morfologia(str(token.morph))
+            }
+        })
+        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]))
+    return risultato_analisi
 
 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]
-    return costruisci_sintagmi_con_dettagli(token_nella_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)
 
 # ------------------------------
 # Routes
 # ------------------------------
 @app.route("/")
 def home():
+    status = "ok" if nlp is not None else "model_missing"
     return jsonify({
         "messaggio": "API analisi logica in esecuzione",
-        "modello_spacy": IT_MODEL,
+        "modello_spacy": IT_MODEL if IT_MODEL else "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:
+        return jsonify({"errore": "Modello spaCy non caricato.", "dettagli": MODEL_LOAD_ERROR}), 503
+
     try:
         dati = request.get_json(silent=True) or {}
         frase = (dati.get('sentence') or "").strip()
@@ -338,8 +300,7 @@ def analizza_frase():
             return jsonify({"errore": "Frase non fornita o vuota."}), 400
 
         doc = nlp(frase)
-
-        # individua subordinate/coordinate rilevanti
+        
         proposizioni_subordinate = []
         indici_subordinate = set()
         SUBORD_DEPS = {"acl:relcl", "advcl", "ccomp", "csubj", "xcomp", "acl", "parataxis"}
@@ -347,24 +308,18 @@ def analizza_frase():
         for token in doc:
             if token.dep_ in SUBORD_DEPS:
                 subtree = list(token.subtree)
-                for t in subtree:
-                    indici_subordinate.add(t.i)
-
-                info_tipo = MAPPA_DEP.get(token.dep_, {"label": "Proposizione Subordinata", "description": "Frase che dipende da un'altra."})
-                mark_token = next((f for f in token.children if f.dep_ == 'mark'), None)
-                intro = mark_token.text if mark_token else ""
-
-                proposizioni_subordinate.append({
-                    "type_info": info_tipo,
-                    "text": " ".join(t.text for t in subtree if not t.is_punct and not t.is_space).strip(),
-                    "intro": intro,
-                    "analysis": analizza_proposizione_con_dettagli(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)
+                    })
 
-        # principale = token non inclusi nelle subordinate
         token_principale = [t for t in doc if t.i not in indici_subordinate]
-
-        # entità nominate (senza duplicati)
+        
         entita_nominate = []
         visti = set()
         for ent in doc.ents:
@@ -380,7 +335,7 @@ def analizza_frase():
             "full_sentence": frase,
             "model": IT_MODEL,
             "main_clause": {
-                "text": " ".join(t.text for t in token_principale if not t.is_punct and not t.is_space).strip(),
+                "text": " ".join(t.text for t in token_principale),
                 "analysis": analizza_proposizione_con_dettagli(token_principale)
             },
             "subordinate_clauses": proposizioni_subordinate,
@@ -393,7 +348,6 @@ def analizza_frase():
         traceback.print_exc()
         return jsonify({"errore": "Si è verificato un errore interno.", "dettagli": str(e)}), 500
 
-
 if __name__ == '__main__':
     port = int(os.environ.get("PORT", 8080))
-    app.run(host="0.0.0.0", port=port, debug=False, threaded=True)
+    app.run(host="0.0.0.0", port=port, debug=False, threaded=True)