refactoring

api.py

@@ -120,6 +120,10 @@ def run_discovery(payload: DiscoveryRequest):
                 all_triples.extend(extraction_result.triples)
             if hasattr(extraction_result, 'entities') and extraction_result.entities:
                 all_entities.extend(extraction_result.entities)
+        
+        if i < len(chunks) - 1:
+            print(f"⏳ Pacing per Groq API: attesa 20s per non sforare i 30K TPM...")
+            time.sleep(20)
 
     if not all_triples:
         return {

app.py

@@ -171,6 +171,8 @@ with tab_gen:
         if st.session_state.pipeline_stage >= 1:
             chunks = st.session_state.chunks
             st.success(f"Chunking completato! Generati {len(chunks)} frammenti semantici.")
+            with st.expander("Vedi dettagli frammenti"):
+                st.json(chunks)
         else:
             if st.button("Avvia Semantic Splitter", type="primary"):
                 with st.spinner("Creazione chunks in corso..."):
@@ -193,7 +195,7 @@ with tab_gen:
     with st.container():
         color = "white" if is_step_b_unlocked else "gray"
         icon = "✅" if st.session_state.pipeline_stage >= 2 else ("2️⃣" if is_step_b_unlocked else "🔒")
-        st.markdown(f"<h3 style='color:{color}'>{icon} Fase 2: TDDT Extraction (Gemini)</h3>", unsafe_allow_html=True)
+        st.markdown(f"<h3 style='color:{color}'>{icon} Fase 2: TDDT Extraction</h3>", unsafe_allow_html=True)
 
         with st.expander("ℹ️ Cosa fa questa fase?"):
             st.write("Esegue l'estrazione gerarchica in due passaggi: prima classifica le entità usando le root dell'ontologia, poi estrae le relazioni passando all'LLM solo le proprietà ammesse (Domain Index).")
@@ -204,7 +206,7 @@ with tab_gen:
             data = st.session_state.extraction_data
             st.success(f"Estrazione TDDT completata! Identificate {len(data['entities'])} entità e {len(data['triples'])} triple.")
             with st.expander("Vedi dati estratti (Pre-Validazione)"):
-                st.write("Entità Inferite:", [e.model_dump() for e in data['entities']])
+                st.write("Entità Inferite:", data['entities'])
                 if data['triples']:
                     st.dataframe(pd.DataFrame([t.model_dump() for t in data['triples']]), hide_index=True)
         else:
@@ -228,6 +230,10 @@ with tab_gen:
                                     if res.triples: all_triples.extend(res.triples)
                                 
                                 prog_bar.progress((i+1)/len(chunks))
+
+                                if i < len(chunks) - 1:
+                                    print(f"⏳ Pacing per Groq API: attesa 20s per non sforare i 30K TPM...")
+                                    time.sleep(20)
                             
                             # Estraggo le entità univoche dalle triple per il Resolver
                             unique_entities = list(set([t.subject for t in all_triples] + [t.object for t in all_triples]))
@@ -267,6 +273,10 @@ with tab_gen:
                             raw_data = st.session_state.extraction_data
                             all_entities = raw_data.get("entities", [])
                             all_triples = raw_data.get("triples", [])
+
+                            persister = KnowledgeGraphPersister()
+                            persister.driver = driver
+                            persister._create_constraints()
                             
                             resolver = get_resolver()
                             resolver.driver = driver
@@ -296,8 +306,6 @@ with tab_gen:
                                     except Exception as e:
                                         st.error(f"Errore scrittura DLQ: {e}")
                             
-                            persister = KnowledgeGraphPersister()
-                            persister.driver = driver # Inietto il driver testato
                             # Salviamo SOLO le valide
                             persister.save_entities_and_triples(entities_to_save, valid_triples)
                             
@@ -321,12 +329,11 @@ with tab_val:
         cypher_val = """
         MATCH (s)-[r]->(o) 
         RETURN elementId(r) as id, 
-               COALESCE(s.label, s.name, head(labels(s))) as Soggetto, 
+               COALESCE(s["label"], s["name"], head(labels(s))) as Soggetto, 
                type(r) as Predicato, 
-               COALESCE(o.label, o.name, head(labels(o))) as Oggetto,
-               COALESCE(r.evidence, 'N/A') as Evidenza,
-               COALESCE(r.reasoning, 'N/A') as Ragionamento
-        LIMIT 100
+               COALESCE(o["label"], o["name"], head(labels(o))) as Oggetto,
+               COALESCE(r["evidence"], 'N/A') as Evidenza,
+               COALESCE(r["reasoning"], 'N/A') as Ragionamento
         """
         triples_data = run_query(driver, cypher_val)
         
@@ -353,9 +360,9 @@ with tab_vis:
             with st.spinner("Estrazione dati e generazione del grafo interattivo..."):
                 cypher_vis = """
                 MATCH (s)-[r]->(o) 
-                RETURN COALESCE(s.label, s.name, head(labels(s))) as src, 
+                RETURN COALESCE(s["label"], s["name"], head(labels(s))) as src, 
                        type(r) as rel, 
-                       COALESCE(o.label, o.name, head(labels(o))) as dst 
+                       COALESCE(o["label"], o["name"], head(labels(o))) as dst 
                 LIMIT 300
                 """
                 graph_data = run_query(driver, cypher_vis)

data/gold_standard/examples.json

@@ -1,70 +0,0 @@
-[
-  {
-    "text": "Il Menhir di Canne, situato lungo la strada provinciale, è un monolite calcareo che fungeva da segnacolo funerario o, secondo una teoria recente e dibattuta, da confine territoriale.",
-    "reasoning": "L'entità fisica e la localizzazione sono fatti certi (1.0). L'uso come segnacolo è consolidato ma non assoluto (0.9), mentre l'uso come confine è esplicitamente presentato come teoria incerta, quindi assegno un'ipotesi (0.6).",
-    "entities": [
-      "Menhir di Canne",
-      "Strada Provinciale",
-      "Segnacolo funerario",
-      "Confine territoriale"
-    ],
-    "triples": [
-      {"subject": "Menhir di Canne", "predicate": "core:hasType", "object": "arco:ArchaeologicalProperty", "confidence": 1.0},
-      {"subject": "Menhir di Canne", "predicate": "a-loc:isLocatedIn", "object": "Strada Provinciale", "confidence": 1.0},
-      {"subject": "Menhir di Canne", "predicate": "core:hasConcept", "object": "Segnacolo funerario", "confidence": 0.9},
-      {"subject": "Menhir di Canne", "predicate": "core:hasConcept", "object": "Confine territoriale", "confidence": 0.6}
-    ]
-  },
-  {
-    "text": "La Battaglia di Canne del 216 a.C. vide la vittoria dell'esercito cartaginese guidato da Annibale. Le dinamiche dell'accerchiamento fanno presumere una conoscenza pregressa del terreno fangoso da parte dei comandanti.",
-    "reasoning": "La battaglia, la data e gli agenti coinvolti sono certi (1.0). La conoscenza del terreno da parte di Annibale è una deduzione forte derivata dalle tattiche, quindi è un'inferenza logica (0.85).",
-    "entities": [
-      "Battaglia di Canne",
-      "216 a.C.",
-      "Esercito Cartaginese",
-      "Annibale",
-      "Conoscenza del terreno"
-    ],
-    "triples": [
-      {"subject": "Battaglia di Canne", "predicate": "core:hasType", "object": "core:Event", "confidence": 1.0},
-      {"subject": "Battaglia di Canne", "predicate": "ti:atTime", "object": "216 a.C.", "confidence": 1.0},
-      {"subject": "Battaglia di Canne", "predicate": "ro:involvesAgent", "object": "Esercito Cartaginese", "confidence": 1.0},
-      {"subject": "Annibale", "predicate": "core:hasConcept", "object": "Conoscenza del terreno", "confidence": 0.85}
-    ]
-  },
-  {
-    "text": "L'Antiquarium custodisce un prezioso corredo funerario proveniente dalla necropoli dauna. Alcuni dettagli pittorici sui vasi a figure rosse fanno sospettare un'influenza diretta della bottega del Pittore di Dario. All'ingresso della struttura è esposta anche una piccola stele iscritta.",
-    "reasoning": "Aggiunta un'entità isolata ('stele iscritta') che non ha relazioni esplicite nel testo con gli altri reperti, ma va comunque tracciata. L'attribuzione alla bottega rimane un'ipotesi (0.5).",
-    "entities": [
-      "Antiquarium",
-      "Corredo funerario",
-      "Vasi a figure rosse",
-      "Bottega del Pittore di Dario",
-      "Stele iscritta"
-    ],
-    "triples": [
-      {"subject": "Antiquarium", "predicate": "core:hasType", "object": "cis:CulturalInstituteOrSite", "confidence": 1.0},
-      {"subject": "Corredo funerario", "predicate": "a-loc:hasCurrentLocation", "object": "Antiquarium", "confidence": 1.0},
-      {"subject": "Corredo funerario", "predicate": "core:hasPart", "object": "Vasi a figure rosse", "confidence": 1.0},
-      {"subject": "Vasi a figure rosse", "predicate": "ro:hasAuthor", "object": "Bottega del Pittore di Dario", "confidence": 0.5}
-    ]
-  },
-  {
-    "text": "Durante i recenti scavi nell'area nord, sono state rinvenute tre monete puniche d'argento mescolate a ceneri vicino a una struttura di accampamento. In un settore adiacente è stato trovato un elmo in bronzo frammentario.",
-    "reasoning": "L'elmo in bronzo è un reperto rilevante ma nel testo non è relazionato direttamente a ceneri o monete. Lo estraggo come entità isolata. Le monete e le ceneri suggeriscono un accampamento cartaginese (0.8).",
-    "entities": [
-      "Area nord",
-      "Monete puniche d'argento",
-      "Struttura di accampamento",
-      "Accampamento Cartaginese",
-      "Evento di incendio",
-      "Elmo in bronzo"
-    ],
-    "triples": [
-      {"subject": "Area nord", "predicate": "core:hasPart", "object": "Monete puniche d'argento", "confidence": 1.0},
-      {"subject": "Area nord", "predicate": "core:hasPart", "object": "Struttura di accampamento", "confidence": 1.0},
-      {"subject": "Struttura di accampamento", "predicate": "core:hasConcept", "object": "Accampamento Cartaginese", "confidence": 0.8},
-      {"subject": "Area nord", "predicate": "core:hasConcept", "object": "Evento di incendio", "confidence": 0.75}
-    ]
-  }
-]

requirements.txt

@@ -4,6 +4,7 @@ langchain-community>=0.3.0
 langchain-google-genai>=2.0.0  # Per Gemini 2.0 Flash (TDDT)
 langchain-huggingface>=0.1.0   # Mantenuto per il Semantic Splitter
 langchain-core
+langchain-groq
 huggingface_hub
 
 # --- Data Validation ---
@@ -12,6 +13,7 @@ pyshacl
 
 # --- NLP & Semantic Chunking ---
 sentence-transformers
+torchvision
 scikit-learn
 numpy
 nltk

src/extraction/extractor.py

@@ -1,10 +1,12 @@
 import os
 import json
+import time
 from typing import List, Optional, Dict, Any
 from pydantic import BaseModel, Field, ValidationError
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
 from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_groq import ChatGroq
 from dotenv import load_dotenv
 
 load_dotenv()
@@ -53,18 +55,30 @@ class KnowledgeGraphExtraction(BaseModel):
 
 
 class NeuroSymbolicExtractor:
-    def __init__(self, index_path="../../ontology/schemas/domain_index.json"):
+    def __init__(self, index_path="./ontology/domain_index.json"):
         print("🧠 Inizializzazione TDDT Extractor (Type-Driven Domain Traversal)...")
         
-        google_api_key = os.getenv("GOOGLE_API_KEY")
-        if not google_api_key:
-            raise ValueError("❌ GOOGLE_API_KEY mancante. Richiesta per Gemini 2.0 Flash.")
-
-        # Inizializzo l'LLM primario. Temperatura 0 per massimizzare il determinismo.
-        self.llm = ChatGoogleGenerativeAI(
-            model="gemini-2.0-flash", 
+        # google_api_key = os.getenv("GOOGLE_API_KEY")
+        # if not google_api_key:
+        #     raise ValueError("❌ GOOGLE_API_KEY mancante. Richiesta per Gemini 2.0 Flash.")
+
+        # # Inizializzo l'LLM primario. Temperatura 0 per massimizzare il determinismo.
+        # self.llm = ChatGoogleGenerativeAI(
+        #     model="gemini-2.0-flash", 
+        #     temperature=0,
+        #     api_key=google_api_key
+        # )
+
+        groq_api_key = os.getenv("GROQ_API_KEY")
+        if not groq_api_key:
+            raise ValueError("❌ GROQ_API_KEY mancante nel file .env.")
+
+        # Inizializzo l'LLM primario su Groq. 
+        self.llm = ChatGroq(
+            model="meta-llama/llama-4-scout-17b-16e-instruct", 
             temperature=0,
-            api_key=google_api_key
+            api_key=groq_api_key,
+            max_retries=5 # Aumentiamo i retry interni di LangChain
         )
         
         # Inizializzo le chain con structured output
@@ -100,14 +114,24 @@ class NeuroSymbolicExtractor:
                 subclasses[uri] = data
         return subclasses
 
-    def _execute_with_retry(self, chain, prompt_messages, max_retries=3):
-        """Self-correction loop unificato."""
+    def _execute_with_retry(self, chain, prompt_messages, max_retries=4):
+        """Self-correction loop con Exponential Backoff per Rate Limits."""
+        base_delay = 5 
+        
         for attempt in range(max_retries):
             try:
                 result = chain.invoke(prompt_messages)
                 return result
             except Exception as e:
-                print(f"⚠️ Errore (Tentativo {attempt+1}/{max_retries}): {e}")
+                error_msg = str(e).upper()
+                print(error_msg)
+                if "429" in error_msg or "RESOURCE_EXHAUSTED" in error_msg:
+                    wait_time = base_delay * (2 ** attempt) 
+                    print(f"⏳ [Rate Limit] Quota superata. Attendo {wait_time}s prima di riprovare (Tentativo {attempt+1}/{max_retries})...")
+                    time.sleep(wait_time)
+                else:
+                    print(f"⚠️ Errore (Tentativo {attempt+1}/{max_retries}): {e}")
+                    
                 if attempt == max_retries - 1:
                     print("❌ Fallimento critico del task LLM.")
                     return None

src/graph/graph_loader.py

@@ -83,8 +83,6 @@ class KnowledgeGraphPersister:
 
         print(f"💾 Preparazione Batch di {len(triples)} triple...")
 
-        # Visto che non posso parametrizzare il predicato nella query Cypher,
-        # raggruppo le triple per tipo di relazione e lancio un batch per ognuna.
         batched_by_pred = defaultdict(list)
         
         for t in triples:
@@ -93,10 +91,13 @@ class KnowledgeGraphPersister:
             item = {
                 "subj_uri": self.sanitize_name(t.subject),
                 "subj_label": t.subject,
+                "subj_type": getattr(t, 'subject_type', '').replace(":", "_").replace("-", "_"),
                 "obj_uri": self.sanitize_name(t.object),
                 "obj_label": t.object,
-                "conf": float(t.confidence),
-                "src": t.source or "unknown"
+                "obj_type": getattr(t, 'object_type', '').replace(":", "_").replace("-", "_"),
+                "evidence": getattr(t, 'evidence', 'N/A'),
+                "reasoning": getattr(t, 'reasoning', 'N/A'),
+                "src": getattr(t, 'source', 'unknown') or 'unknown'
             }
             batched_by_pred[safe_pred].append(item)
 
@@ -154,7 +155,7 @@ class KnowledgeGraphPersister:
                 "MERGE (s:Resource {uri: row.subj_uri}) "
                 "ON CREATE SET s.label = row.subj_label, s.last_updated = datetime() "
                 "WITH s, row "
-                "CALL apoc.create.addLabels(s, [replace(row.obj_label, ':', '_')]) YIELD node "
+                "SET s:$( [replace(row.obj_label, ':', '_')] ) "
                 "RETURN count(node)"
             )
             tx.run(query, batch=batch_data)
@@ -168,8 +169,13 @@ class KnowledgeGraphPersister:
                 f"ON CREATE SET s.label = row.subj_label "
                 f"MERGE (o:Resource {{uri: row.obj_uri}}) "
                 f"ON CREATE SET o.label = row.obj_label "
+                f"WITH s, o, row, "
+                f"     CASE WHEN row.subj_type <> '' THEN [row.subj_type] ELSE [] END AS s_labels, "
+                f"     CASE WHEN row.obj_type <> '' THEN [row.obj_type] ELSE [] END AS o_labels "
+                f"SET s:$(s_labels), o:$(o_labels) "
                 f"MERGE (s)-[r:`{predicate}`]->(o) "
-                f"SET r.confidence = row.conf, "
+                f"SET r.evidence = row.evidence, "
+                f"    r.reasoning = row.reasoning, "
                 f"    r.source = row.src, "
                 f"    r.last_updated = datetime()"
             )

src/utils/build_schema.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from collections import defaultdict
 from rdflib import Graph, URIRef, BNode, RDF, RDFS, OWL, Namespace
 
-# --- MAPPA DEI NAMESPACE (Estesa con CIDOC-CRM) ---
+# --- MAPPA DEI NAMESPACE--
 ARCO_NAMESPACES = {
     "https://w3id.org/arco/ontology/arco/": "arco",
     "https://w3id.org/arco/ontology/core/": "core",
@@ -20,8 +20,12 @@ ARCO_NAMESPACES = {
     "https://w3id.org/italia/onto/RO/": "ro",
     "https://w3id.org/italia/onto/SM/": "sm",
     "https://w3id.org/italia/onto/MU/": "mu",
-    "http://www.cidoc-crm.org/cidoc-crm/": "crm",  # Aggiunto CIDOC-CRM
-    "http://www.w3.org/2002/07/owl#": "owl"
+    "http://www.cidoc-crm.org/cidoc-crm/": "crm", 
+    "http://www.w3.org/2002/07/owl#": "owl",
+    "http://www.w3.org/2000/01/rdf-schema#": "rdfs",
+    "http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf",
+    "http://www.w3.org/2001/XMLSchema#": "xsd",
+    "http://www.w3.org/2004/02/skos/core#": "skos"
 }
 
 def uri_to_qname(uri: URIRef) -> str:
@@ -39,11 +43,9 @@ def uri_to_qname(uri: URIRef) -> str:
     return uri_str.split('/')[-1]
 
 def get_union_classes(g: Graph, bnode: BNode):
-    """Estrae le classi da un costrutto owl:unionOf (usato spesso in ArCo per domini/range multipli)."""
     union_list = g.value(bnode, OWL.unionOf)
     classes = []
     if union_list:
-        # Naviga la lista RDF
         current = union_list
         while current and current != RDF.nil:
             item = g.value(current, RDF.first)
@@ -56,7 +58,6 @@ def build_domain_index_and_shacl(ontology_dir: str, output_json: str, output_sha
     print(f"⏳ Inizializzazione Graph e caricamento da {ontology_dir}...")
     g = Graph()
     
-    # 1. Carica tutti i file .owl
     owl_files = list(Path(ontology_dir).glob('**/*.owl'))
     for file_path in owl_files:
         try:
@@ -70,7 +71,6 @@ def build_domain_index_and_shacl(ontology_dir: str, output_json: str, output_sha
     classes_dict = {}
     properties_list = []
     
-    # 2. Estrazione Classi e Gerarchia
     for s in g.subjects(RDF.type, OWL.Class):
         if isinstance(s, BNode): continue
         
@@ -78,7 +78,6 @@ def build_domain_index_and_shacl(ontology_dir: str, output_json: str, output_sha
         label = g.value(s, RDFS.label)
         comment = g.value(s, RDFS.comment)
         
-        # Filtro lingua: preferisco italiano, altrimenti inglese (per CIDOC-CRM)
         label_str = str(label) if label else qname
         for lang_label in g.objects(s, RDFS.label):
             if lang_label.language == 'it': label_str = str(lang_label)
@@ -87,7 +86,6 @@ def build_domain_index_and_shacl(ontology_dir: str, output_json: str, output_sha
         for lang_comment in g.objects(s, RDFS.comment):
             if lang_comment.language == 'it': desc_str = str(lang_comment)
 
-        # Trova parent diretti
         parents = [uri_to_qname(p) for p in g.objects(s, RDFS.subClassOf) if isinstance(p, URIRef)]
         
         classes_dict[qname] = {
@@ -97,7 +95,6 @@ def build_domain_index_and_shacl(ontology_dir: str, output_json: str, output_sha
             "namespace": qname.split(":")[0] if ":" in qname else "unknown"
         }
 
-    # 3. Estrazione Proprietà
     for prop_type in [OWL.ObjectProperty, OWL.DatatypeProperty]:
         for s in g.subjects(RDF.type, prop_type):
             if isinstance(s, BNode): continue
@@ -106,7 +103,6 @@ def build_domain_index_and_shacl(ontology_dir: str, output_json: str, output_sha
             label = g.value(s, RDFS.label)
             label_str = str(label) if label else qname
             
-            # Dominio
             domain_node = g.value(s, RDFS.domain)
             domains = []
             if isinstance(domain_node, URIRef):
@@ -114,7 +110,6 @@ def build_domain_index_and_shacl(ontology_dir: str, output_json: str, output_sha
             elif isinstance(domain_node, BNode):
                 domains.extend(get_union_classes(g, domain_node))
                 
-            # Range
             range_node = g.value(s, RDFS.range)
             ranges = []
             if isinstance(range_node, URIRef):
@@ -129,10 +124,7 @@ def build_domain_index_and_shacl(ontology_dir: str, output_json: str, output_sha
                 "ranges": ranges
             })
 
-    # 4. Calcolo Ereditarietà Transitiva per il Domain Index
     properties_by_domain = defaultdict(list)
-    
-    # Mappo prima le proprietà ai domini espliciti
     for prop in properties_list:
         for d in prop["domains"]:
             properties_by_domain[d].append({
@@ -142,7 +134,6 @@ def build_domain_index_and_shacl(ontology_dir: str, output_json: str, output_sha
                 "inherited_from": d
             })
 
-    # Funzione ricorsiva per raccogliere proprietà dai parent
     def get_inherited_properties(class_qname, visited=None):
         if visited is None: visited = set()
         if class_qname in visited: return []
@@ -152,7 +143,6 @@ def build_domain_index_and_shacl(ontology_dir: str, output_json: str, output_sha
         for parent in classes_dict.get(class_qname, {}).get("parents", []):
             inherited = get_inherited_properties(parent, visited)
             for p in inherited:
-                # Evito duplicati
                 if not any(existing["id"] == p["id"] for existing in props):
                     props.append(p)
         return props
@@ -163,12 +153,10 @@ def build_domain_index_and_shacl(ontology_dir: str, output_json: str, output_sha
         if all_props:
             final_properties_by_domain[cls] = all_props
 
-    # 5. Generazione Text Embeddings Dictionary
     class_embeddings_texts = {
         k: f"{v['label']} - {v['description']}" for k, v in classes_dict.items() if v['description']
     }
 
-    # 6. Salvataggio domain_index.json
     domain_index = {
         "classes": classes_dict,
         "properties_by_domain": final_properties_by_domain,
@@ -180,7 +168,6 @@ def build_domain_index_and_shacl(ontology_dir: str, output_json: str, output_sha
         json.dump(domain_index, f, ensure_ascii=False, indent=2)
     print(f"💾 Salvato Indice di Dominio in: {output_json}")
 
-    # 7. Generazione auto_constraints.ttl per SHACL
     os.makedirs(os.path.dirname(output_shacl), exist_ok=True)
     with open(output_shacl, 'w', encoding='utf-8') as f:
         f.write("@prefix sh: <http://www.w3.org/ns/shacl#> .\n")
@@ -192,28 +179,31 @@ def build_domain_index_and_shacl(ontology_dir: str, output_json: str, output_sha
         shape_count = 0
         for prop in properties_list:
             safe_id = prop["id"].replace(":", "_").replace("-", "_")
-            
-            # Domain Shape (solo se domain esplicito singolo per non creare conflitti con le Union)
+        
             if len(prop["domains"]) == 1:
                 dom = prop["domains"][0]
-                f.write(f"ex:{safe_id}_DomainShape a sh:NodeShape ;\n")
-                f.write(f"    sh:targetSubjectsOf {prop['id']} ;\n")
-                f.write(f"    sh:class {dom} .\n\n")
-                shape_count += 1
+                if ":" in dom and ":" in prop["id"]:
+                    f.write(f"ex:{safe_id}_DomainShape a sh:NodeShape ;\n")
+                    f.write(f"    sh:targetSubjectsOf {prop['id']} ;\n")
+                    f.write(f"    sh:class {dom} .\n\n")
+                    shape_count += 1
                 
-            # Range Shape (solo se range esplicito singolo)
-            if len(prop["ranges"]) == 1 and "http" not in prop["ranges"][0]: # Evito XSD datatypes complessi
+            if len(prop["ranges"]) == 1:
                 rng = prop["ranges"][0]
-                f.write(f"ex:{safe_id}_RangeShape a sh:NodeShape ;\n")
-                f.write(f"    sh:targetObjectsOf {prop['id']} ;\n")
-                f.write(f"    sh:class {rng} .\n\n")
-                shape_count += 1
+                if ":" in rng and ":" in prop["id"]:
+                    f.write(f"ex:{safe_id}_RangeShape a sh:NodeShape ;\n")
+                    f.write(f"    sh:targetObjectsOf {prop['id']} ;\n")
+                    if rng.startswith("xsd:") or rng == "rdfs:Literal":
+                        f.write(f"    sh:datatype {rng} .\n\n")
+                    else:
+                        f.write(f"    sh:class {rng} .\n\n")
+                    shape_count += 1
 
     print(f"🛡️ Generato SHACL auto_constraints.ttl con {shape_count} regole rigorose in: {output_shacl}")
 
 if __name__ == "__main__":
-    ONTOLOGY_FOLDER = "../../ontology/" 
-    OUTPUT_JSON = "../../ontology/schemas/domain_index.json"
-    OUTPUT_SHACL = "../../ontology/schemas/auto_constraints.ttl"
+    ONTOLOGY_FOLDER = "./ontology/" 
+    OUTPUT_JSON = "./ontology/domain_index.json"
+    OUTPUT_SHACL = "./ontology/shapes/auto_constraints.ttl"
     
     build_domain_index_and_shacl(ONTOLOGY_FOLDER, OUTPUT_JSON, OUTPUT_SHACL)

src/validation/validator.py

@@ -1,11 +1,12 @@
 import os
+import re
 from pathlib import Path
 from rdflib import Graph, Literal, RDF, URIRef, Namespace
 from rdflib.namespace import SKOS, OWL
 from pyshacl import validate
 
 class SemanticValidator:
-    def __init__(self, ontology_dir="../../ontology", shapes_file="../../ontology/shapes/auto_constraints.ttl"):
+    def __init__(self, ontology_dir="./ontology", shapes_file="./ontology/shapes/auto_constraints.ttl"):
         self.shapes_file = shapes_file
         
         # Mappatura namespace
@@ -49,7 +50,12 @@ class SemanticValidator:
             if prefix in self.namespaces:
                 return self.namespaces[prefix][name]
         
-        clean_name = text_val.replace(" ", "_").replace("'", "").replace('"', "")
+        clean_name = text_val.replace(" ", "_")
+        clean_name = re.sub(r'[^a-zA-Z0-9_]', '', clean_name)
+        
+        if not clean_name:
+            clean_name = "UnknownEntity"
+            
         return self.namespaces["ex"][clean_name]
 
     def _json_to_rdf(self, entities, triples):