update

app.py

@@ -4,25 +4,25 @@ from flask_cors import CORS
 import spacy
 import traceback
 
-# --- CORRECTED MODEL LOADING SECTION ---
+# --- SEZIONE CARICAMENTO MODELLO ---
 try:
-    # Laad het Italiaanse model van spaCy
+    # Carica il modello italiano di spaCy
     nlp = spacy.load("it_core_news_sm")
 except OSError:
     raise RuntimeError(
-        "Could not find the 'it_core_news_sm' model. "
-        "Please ensure it is listed and installed from your requirements.txt file."
+        "Impossibile trovare il modello 'it_core_news_sm'. "
+        "Assicurati che sia elencato e installato dal tuo file requirements.txt."
     )
-# --- END SECTION ---
+# --- FINE SEZIONE ---
 
-# Initialiseer de Flask-app
+# Inizializza l'app Flask
 app = Flask(__name__)
 
-# Schakel Cross-Origin Resource Sharing (CORS) in
+# Abilita la Condivisione delle Risorse tra Origini Diverse (CORS)
 CORS(app)
 
-# Een mapping van spaCy dependency-labels naar onze logische analyse-labels met uitleg
-DEP_MAP = {
+# 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."},
     "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."},
@@ -38,63 +38,63 @@ DEP_MAP = {
     "csubj": {"label": "Proposizione Subordinata Soggettiva", "description": "Frase che funge da soggetto del verbo della principale."}
 }
 
-def get_complement_type_with_details(token):
-    """Verfijnt het complementtype op basis van het voorgaande voorzetsel en geeft details."""
-    preposition = ""
-    # Zoek naar een voorzetsel ('case') als een kind van het token
-    for child in token.children:
-        if child.dep_ == "case":
-            preposition = child.text.lower()
+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
-    # Fallback voor sommige structuren waar het voorzetsel een zuster is
-    if not preposition and token.head.dep_ == 'obl':
-        for child in token.head.children:
-            if child.dep_ == "case":
-                preposition = child.text.lower()
+    # 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":
+                preposizione = figlio.text.lower()
                 break
 
-    if preposition in ["di", "del", "dello", "della", "dei", "degli", "delle"]:
+    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 preposition in ["a", "al", "allo", "alla", "ai", "agli", "alle"]:
+    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 preposition in ["da", "dal", "dallo", "dalla", "dai", "dagli", "dalle"]:
-        # Controleer op passieve constructie voor Complemento d'Agente
-        if any(child.dep_ == 'aux:pass' for child in token.head.children):
+    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."}
-    if preposition in ["in", "nel", "nello", "nella", "nei", "negli", "nelle"]:
+    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 preposition in ["con", "col", "coi"]:
+    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 preposition in ["su", "sul", "sullo", "sulla", "sui", "sugli", "sulle"]:
+    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 preposition in ["per"]:
+    if preposizione in ["per"]:
         return {"label": "Complemento di Fine o Causa", "description": "Indica lo scopo o la causa di un'azione."}
-    if preposition in ["tra", "fra"]:
+    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."}
 
-    # Standaard als geen specifiek voorzetsel wordt gevonden
+    # 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 get_full_text(token):
-    """Bouwt recursief de volledige tekst van een zinsdeel op, beginnend bij een hoofdtoken."""
-    # Verzamel het hoofdtoken en de direct gerelateerde modifiers (determiners, adjectieven, voorzetsels)
-    phrase_tokens = [token] + sorted([t for t in token.children if t.dep_ in ('det', 'amod', 'case', 'advmod')], key=lambda x: x.i)
-    # Sorteer alle tokens op basis van hun positie in de zin om de juiste volgorde te krijgen
-    phrase_tokens.sort(key=lambda x: x.i)
-    return " ".join(t.text for t in phrase_tokens)
-
-def build_phrases_with_details(tokens):
-    """Voegt tokens samen tot betekenisvolle grammaticale zinsdelen met gedetailleerde uitleg."""
-    phrase_map = {}
+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)
+
+def costruisci_sintagmi_con_dettagli(lista_token):
+    """Aggrega i token in sintagmi grammaticali significativi con spiegazioni dettagliate."""
+    mappa_sintagmi = {}
     
-    # Maak een map van belangrijke tokens (hoofden van zinsdelen)
-    for token in tokens:
-        # Filter onbelangrijke tokens uit die later worden samengevoegd
+    # 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']:
-            phrase_map[token.i] = {
-                "text": get_full_text(token),
-                # Voeg gedetailleerde grammaticale informatie toe met uitleg
+            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_)}",
@@ -105,25 +105,25 @@ def build_phrases_with_details(tokens):
                 "token": token
             }
             
-    analysis_result = []
-    processed_indices = set()
+    risultato_analisi = []
+    indici_elaborati = set()
     
-    for index, phrase in phrase_map.items():
-        if index in processed_indices:
+    for indice, sintagma in mappa_sintagmi.items():
+        if indice in indici_elaborati:
             continue
             
-        token = phrase['token']
+        token = sintagma['token']
         dep = token.dep_
-        label_info = {}
+        info_etichetta = {}
 
         if dep == "ROOT":
-            # Controleer op een naamwoordelijk gezegde (bv. "è bello")
-            is_nominal = any(c.dep_ == 'cop' for c in token.children)
-            if is_nominal:
+            # 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]
-                predicate_name = get_full_text(token)
-                # Voeg de copula apart toe
-                analysis_result.append({
+                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": {
@@ -133,110 +133,110 @@ def build_phrases_with_details(tokens):
                          "morph": str(copula.morph) if copula.morph else "Non disponibile"
                     }
                 })
-                # Voeg het naamwoordelijk deel van het gezegde toe
-                analysis_result.append({
-                    "text": predicate_name,
+                # 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": phrase["token_details"]
+                     "token_details": sintagma["token_details"]
                 })
             else:
-                # Het is een werkwoordelijk gezegde
-                label_info = DEP_MAP.get(dep, {})
+                # È un predicato verbale
+                info_etichetta = MAPPA_DEP.get(dep, {})
         elif dep == 'obl':
-            # Gebruik de speciale functie om het type indirect complement te bepalen
-            label_info = get_complement_type_with_details(token)
-        elif dep in DEP_MAP:
-            # Haal het label en de beschrijving op uit de map
-            label_info = DEP_MAP[dep]
+            # 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]
         
-        # Voeg het geanalyseerde zinsdeel toe aan de resultatenlijst
-        if label_info:
-            phrase_to_add = {
-                "text": phrase['text'],
-                "label_info": label_info
+        # Aggiunge il sintagma analizzato alla lista dei risultati
+        if info_etichetta:
+            sintagma_da_aggiungere = {
+                "text": sintagma['text'],
+                "label_info": info_etichetta
             }
-            # Voeg de token-details toe als ze bestaan
-            if phrase.get("token_details"):
-                phrase_to_add["token_details"] = phrase["token_details"]
-            analysis_result.append(phrase_to_add)
+            # 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)
 
-        processed_indices.add(index)
+        indici_elaborati.add(indice)
         
-    return analysis_result
+    return risultato_analisi
 
-def analyze_clause_with_details(clause_tokens):
-    """Analyseert een enkele (hoofd- of bij-)zin met details."""
-    # Verwijder verbindingswoorden (markers) uit de analyse van de zinsdelen zelf
-    tokens_in_clause = [t for t in clause_tokens if t.dep_ != 'mark']
-    return build_phrases_with_details(tokens_in_clause)
+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)
 
 @app.route("/")
 def home():
-    """Geeft een eenvoudig welkomstbericht voor de API-root."""
-    return jsonify({"message": "API for logical analysis is running. Use the /api/analyze endpoint."})
+    """Restituisce un semplice messaggio di benvenuto per la radice dell'API."""
+    return jsonify({"messaggio": "L'API per l'analisi logica è in esecuzione. Usa l'endpoint /api/analyze."})
 
 @app.route('/api/analyze', methods=['POST'])
-def analyze_sentence():
-    """Hoofd-endpoint om een zin te ontvangen en de volledige logische analyse met details terug te sturen."""
+def analizza_frase():
+    """Endpoint principale per ricevere una frase e restituire l'analisi logica completa con dettagli."""
     try:
-        data = request.get_json()
-        if not data or 'sentence' not in data:
-            return jsonify({"error": "Sentence not provided"}), 400
+        dati = request.get_json()
+        if not dati or 'sentence' not in dati:
+            return jsonify({"errore": "Frase non fornita"}), 400
 
-        sentence = data['sentence']
-        doc = nlp(sentence)
+        frase = dati['sentence']
+        doc = nlp(frase)
         
-        main_clause_tokens = []
-        subordinate_clauses = []
+        token_proposizione_principale = []
+        proposizioni_subordinate = []
         
-        # Identificeer en scheid bijzinnen
+        # Identifica e separa le proposizioni subordinate
         for token in doc:
             if token.dep_ in ["acl:relcl", "advcl", "ccomp", "csubj"]:
-                sub_clause_tokens = list(token.subtree)
-                sub_clause_type_info = DEP_MAP.get(token.dep_, {"label": "Proposizione Subordinata", "description": "Una frase che dipende da un'altra."})
+                token_proposizione_subordinata = list(token.subtree)
+                info_tipo_subordinata = MAPPA_DEP.get(token.dep_, {"label": "Proposizione Subordinata", "description": "Una frase che dipende da un'altra."})
                 
-                # Vind het inleidende woord (bv. "che", "quando", "perché")
-                marker = [child for child in token.children if child.dep_ == 'mark']
-                intro = marker[0].text if marker else ""
+                # 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 ""
 
-                subordinate_clauses.append({
-                    "type_info": sub_clause_type_info,
-                    "text": " ".join(t.text for t in sub_clause_tokens),
+                proposizioni_subordinate.append({
+                    "type_info": info_tipo_subordinata,
+                    "text": " ".join(t.text for t in token_proposizione_subordinata),
                     "intro": intro,
-                    "analysis": analyze_clause_with_details(sub_clause_tokens)
+                    "analysis": analizza_proposizione_con_dettagli(token_proposizione_subordinata)
                 })
 
-        # Bepaal de tokens van de hoofdzin door de tokens van de bijzinnen uit te sluiten
-        subordinate_indices = {token.i for clause in subordinate_clauses for token in nlp(clause["text"])}
-        main_clause_tokens = [token for token in doc if token.i not in subordinate_indices]
+        # 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]
 
-        # Extraheer Named Entities met uitleg
-        named_entities = [{
+        # Estrae le Entità Nominate (Named Entities) con spiegazione
+        entita_nominate = [{
             "text": ent.text,
             "label": ent.label_,
-            "explanation": spacy.explain(ent.label_) # Zorg voor uitleg
+            "explanation": spacy.explain(ent.label_) # Fornisce la spiegazione
         } for ent in doc.ents]
 
-        # Stel de uiteindelijke analyse samen
-        final_analysis = {
-            "full_sentence": sentence,
+        # Compone l'analisi finale
+        analisi_finale = {
+            "full_sentence": frase,
             "main_clause": {
-                "text": " ".join(t.text for t in main_clause_tokens if not t.is_punct),
-                "analysis": analyze_clause_with_details(main_clause_tokens)
+                "text": " ".join(t.text for t in token_proposizione_principale if not t.is_punct),
+                "analysis": analizza_proposizione_con_dettagli(token_proposizione_principale)
             },
-            "subordinate_clauses": subordinate_clauses,
-            "named_entities": named_entities
+            "subordinate_clauses": proposizioni_subordinate,
+            "named_entities": entita_nominate
         }
         
-        return jsonify(final_analysis)
+        return jsonify(analisi_finale)
 
     except Exception as e:
-        # Verbeterde foutafhandeling
-        print(f"Error during analysis: {e}")
+        # Gestione migliorata degli errori
+        print(f"Errore durante l'analisi: {e}")
         traceback.print_exc()
-        return jsonify({"error": "An internal error occurred."}), 500
+        return jsonify({"errore": "Si è verificato un errore interno."}), 500
 
 if __name__ == '__main__':
-    # Haal de poort op uit de omgevingsvariabelen voor implementatiegemak
-    port = int(os.environ.get("PORT", 8080))
-    app.run(host="0.0.0.0", port=port, debug=True)
+    # 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)