update

app.py

@@ -21,6 +21,33 @@ app = Flask(__name__)
 # Abilita la Condivisione delle Risorse tra Origini Diverse (CORS)
 CORS(app)
 
+# --- INIZIO SEZIONE TRADUZIONI ---
+# Mappe per le traduzioni in italiano delle spiegazioni di spaCy
+SPIEGAZIONI_POS_IT = {
+    "ADJ": "Aggettivo", "ADP": "Preposizione", "ADV": "Avverbio", "AUX": "Ausiliare",
+    "CONJ": "Congiunzione", "CCONJ": "Congiunzione Coordinante", "SCONJ": "Congiunzione Subordinante",
+    "DET": "Determinante", "INTJ": "Interiezione", "NOUN": "Sostantivo", "NUM": "Numerale",
+    "PART": "Particella", "PRON": "Pronome", "PROPN": "Nome Proprio", "PUNCT": "Punteggiatura",
+    "SPACE": "Spazio", "SYM": "Simbolo", "VERB": "Verbo", "X": "Altro",
+}
+
+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 (es. eventi, nazionalità, prodotti)."
+}
+
+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)
+    if tipo == 'ent':
+        return SPIEGAZIONI_ENT_IT.get(tag, tag)
+    # Ritorna il tag originale se non trova una spiegazione
+    return tag
+# --- FINE SEZIONE TRADUZIONI ---
+
 # Mappatura delle etichette di dipendenza di spaCy alle nostre etichette di analisi logica con spiegazioni
 MAPPA_DEP = {
     "nsubj": {"label": "Soggetto", "description": "Indica chi o cosa compie l'azione o si trova in un certo stato."},
@@ -41,12 +68,10 @@ MAPPA_DEP = {
 def ottieni_tipo_complemento_con_dettagli(token):
     """Affina il tipo di complemento basandosi sulla preposizione precedente e fornisce dettagli."""
     preposizione = ""
-    # Cerca una preposizione ('case') come figlio del token
     for figlio in token.children:
         if figlio.dep_ == "case":
             preposizione = figlio.text.lower()
             break
-    # Soluzione alternativa per alcune strutture dove la preposizione è un fratello
     if not preposizione and token.head.dep_ == 'obl':
         for figlio in token.head.children:
             if figlio.dep_ == "case":
@@ -58,7 +83,6 @@ def ottieni_tipo_complemento_con_dettagli(token):
     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"]:
-        # Controlla la costruzione passiva per il Complemento d'Agente
         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."}
@@ -73,14 +97,11 @@ def ottieni_tipo_complemento_con_dettagli(token):
     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."}
 
-    # Valore predefinito se non viene trovata una preposizione specifica
     return {"label": "Complemento Indiretto", "description": "Fornisce un'informazione generica non classificata in modo più specifico."}
 
 def ottieni_testo_completo(token):
     """Costruisce ricorsivamente il testo completo di un sintagma, partendo da un token principale."""
-    # Raccoglie il token principale e i modificatori direttamente correlati (determinanti, aggettivi, preposizioni)
     token_sintagma = [token] + sorted([t for t in token.children if t.dep_ in ('det', 'amod', 'case', 'advmod')], key=lambda x: x.i)
-    # Ordina tutti i token in base alla loro posizione nella frase per ottenere l'ordine corretto
     token_sintagma.sort(key=lambda x: x.i)
     return " ".join(t.text for t in token_sintagma)
 
@@ -88,17 +109,14 @@ def costruisci_sintagmi_con_dettagli(lista_token):
     """Aggrega i token in sintagmi grammaticali significativi con spiegazioni dettagliate."""
     mappa_sintagmi = {}
     
-    # Crea una mappa di token importanti (le teste dei sintagmi)
     for token in lista_token:
-        # Esclude i token non importanti che verranno uniti in seguito
         if token.dep_ not in ['det', 'case', 'amod', 'punct', 'aux', 'cop', 'mark']:
             mappa_sintagmi[token.i] = {
                 "text": ottieni_testo_completo(token),
-                # Aggiunge informazioni grammaticali dettagliate con spiegazioni
                 "token_details": {
                     "lemma": token.lemma_,
-                    "pos": f"{token.pos_}: {spacy.explain(token.pos_)}",
-                    "tag": f"{token.tag_}: {spacy.explain(token.tag_)}",
+                    "pos": f"{token.pos_}: {spiega_in_italiano(token.pos_, 'pos')}",
+                    "tag": f"{token.tag_}: {spiega_in_italiano(token.tag_, 'pos')}", # Usa 'pos' per la spiegazione del tag più generica
                     "morph": str(token.morph) if token.morph else "Non disponibile"
                 },
                 "label_info": {},
@@ -108,7 +126,7 @@ def costruisci_sintagmi_con_dettagli(lista_token):
     risultato_analisi = []
     indici_elaborati = set()
     
-    for indice, sintagma in mappa_sintagmi.items():
+    for indice, sintagma in sorted(mappa_sintagmi.items()):
         if indice in indici_elaborati:
             continue
             
@@ -117,45 +135,37 @@ def costruisci_sintagmi_con_dettagli(lista_token):
         info_etichetta = {}
 
         if dep == "ROOT":
-            # Controlla la presenza di un predicato nominale (es. "è bello")
             e_nominale = any(c.dep_ == 'cop' for c in token.children)
             if e_nominale:
                 copula = [c for c in token.children if c.dep_ == 'cop'][0]
                 nome_del_predicato = ottieni_testo_completo(token)
-                # Aggiunge la copula separatamente
                 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_}: {spacy.explain(copula.pos_)}",
-                         "tag": f"{copula.tag_}: {spacy.explain(copula.tag_)}",
+                         "pos": f"{copula.pos_}: {spiega_in_italiano(copula.pos_, 'pos')}",
+                         "tag": f"{copula.tag_}: {spiega_in_italiano(copula.tag_, 'pos')}",
                          "morph": str(copula.morph) if copula.morph else "Non disponibile"
                     }
                 })
-                # Aggiunge la parte nominale del predicato
                 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"]
                 })
             else:
-                # È un predicato verbale
                 info_etichetta = MAPPA_DEP.get(dep, {})
         elif dep == 'obl':
-            # Usa la funzione speciale per determinare il tipo di complemento indiretto
             info_etichetta = ottieni_tipo_complemento_con_dettagli(token)
         elif dep in MAPPA_DEP:
-            # Recupera l'etichetta e la descrizione dalla mappa
             info_etichetta = MAPPA_DEP[dep]
         
-        # Aggiunge il sintagma analizzato alla lista dei risultati
         if info_etichetta:
             sintagma_da_aggiungere = {
                 "text": sintagma['text'],
                 "label_info": info_etichetta
             }
-            # Aggiunge i dettagli del token se esistono
             if sintagma.get("token_details"):
                 sintagma_da_aggiungere["token_details"] = sintagma["token_details"]
             risultato_analisi.append(sintagma_da_aggiungere)
@@ -166,7 +176,6 @@ def costruisci_sintagmi_con_dettagli(lista_token):
 
 def analizza_proposizione_con_dettagli(token_proposizione):
     """Analizza una singola proposizione (principale o subordinata) con dettagli."""
-    # Rimuove le congiunzioni (marcatori) dall'analisi dei sintagmi stessi
     token_nella_proposizione = [t for t in token_proposizione if t.dep_ != 'mark']
     return costruisci_sintagmi_con_dettagli(token_nella_proposizione)
 
@@ -186,38 +195,35 @@ def analizza_frase():
         frase = dati['sentence']
         doc = nlp(frase)
         
-        token_proposizione_principale = []
         proposizioni_subordinate = []
+        indici_subordinate = set()
         
-        # Identifica e separa le proposizioni subordinate
         for token in doc:
             if token.dep_ in ["acl:relcl", "advcl", "ccomp", "csubj"]:
                 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."})
                 
-                # Trova la parola introduttiva (es. "che", "quando", "perché")
                 marcatore = [figlio for figlio in token.children if figlio.dep_ == 'mark']
                 intro = marcatore[0].text if marcatore else ""
 
                 proposizioni_subordinate.append({
                     "type_info": info_tipo_subordinata,
-                    "text": " ".join(t.text for t in token_proposizione_subordinata),
+                    "text": " ".join(t.text for t in token_proposizione_subordinata if not t.is_punct),
                     "intro": intro,
                     "analysis": analizza_proposizione_con_dettagli(token_proposizione_subordinata)
                 })
 
-        # Determina i token della proposizione principale escludendo quelli delle subordinate
-        indici_subordinate = {token.i for prop in proposizioni_subordinate for token in nlp(prop["text"])}
         token_proposizione_principale = [token for token in doc if token.i not in indici_subordinate]
 
-        # Estrae le Entità Nominate (Named Entities) con spiegazione
         entita_nominate = [{
             "text": ent.text,
             "label": ent.label_,
-            "explanation": spacy.explain(ent.label_) # Fornisce la spiegazione
+            "explanation": spiega_in_italiano(ent.label_, 'ent')
         } for ent in doc.ents]
 
-        # Compone l'analisi finale
         analisi_finale = {
             "full_sentence": frase,
             "main_clause": {
@@ -231,12 +237,10 @@ def analizza_frase():
         return jsonify(analisi_finale)
 
     except Exception as e:
-        # Gestione migliorata degli errori
         print(f"Errore durante l'analisi: {e}")
         traceback.print_exc()
         return jsonify({"errore": "Si è verificato un errore interno."}), 500
 
 if __name__ == '__main__':
-    # Ottiene la porta dalle variabili d'ambiente per facilitare il deployment
     porta = int(os.environ.get("PORT", 8080))
     app.run(host="0.0.0.0", port=porta, debug=True)