Update src/core/inference_engine.py

src/core/inference_engine.py

@@ -1,8 +1,9 @@
 """
-MODULE: INFERENCE ENGINE
-========================
+MODULE: INFERENCE ENGINE (FORCE BRUTE)
+======================================
+Correction : Force le typage numérique pour trouver les HighValue.
 """
-from rdflib import Graph, Namespace
+from rdflib import Graph, Namespace, Literal, XSD
 
 VORTEX = Namespace("http://vortex.ai/ontology#")
 
@@ -11,32 +12,58 @@ class InferenceEngine:
         self.rdf_store = rdf_store
 
     def run_inference(self):
-        print("🧠 [R-BOX] Inférence...")
+        print("🧠 [R-BOX] Inférence (Mode Force Brute)...")
         initial_count = len(self.rdf_store.g)
         
-        # 1. Réciprocité
-        self._apply_rule("""
-        CONSTRUCT { ?pret vortex:a_emprunteur ?client . }
-        WHERE { ?client vortex:possede_pret ?pret . }
-        """, "Inverse: possede_pret")
+        # 1. HighValue : On force la conversion en Decimal pour la comparaison
+        # On cherche tout ce qui ressemble à un montant et qui dépasse 1 million
+        rule_risk = """
+        CONSTRUCT {
+            ?pret vortex:statut_risque "HighValue" .
+        }
+        WHERE {
+            ?pret a ?type .
+            ?pret ?p ?val_raw .
+            
+            # Détection large des colonnes montant/capital
+            FILTER(CONTAINS(LCASE(STR(?p)), "montant") || CONTAINS(LCASE(STR(?p)), "capital"))
+            
+            # Conversion sécurisée et test
+            BIND(xsd:decimal(?val_raw) AS ?val_num)
+            FILTER(?val_num > 1000000)
+        }
+        """
+        self._apply_rule(rule_risk, "Détection Risque (>1M)")
 
-        # 2. Règle HighValue (ROBUSTE)
-        # Cherche n'importe quelle propriété numérique > 1M
-        self._apply_rule("""
-        CONSTRUCT { ?pret vortex:statut_risque "HighValue" . }
+        # 2. Relations Inverses (Pour que Koulnan soit relié au prêt)
+        # Si A 'possede_pret' B, alors B 'a_emprunteur' A
+        rule_inverse = """
+        CONSTRUCT {
+            ?pret vortex:a_emprunteur ?client_label .
+        }
         WHERE {
-            ?pret a vortex:Pret .
-            ?pret ?p ?valeur .
-            FILTER(isNumeric(?valeur) && ?valeur > 1000000)
+            ?client vortex:possede_pret ?pret .
+            ?client rdfs:label ?client_label .
         }
-        """, "Risque: HighValue > 1M")
+        """
+        self._apply_rule(rule_inverse, "Lien Inverse (Client <-> Pret)")
 
-        print(f"✅ [R-BOX] +{len(self.rdf_store.g) - initial_count} faits déduits.")
+        final = len(self.rdf_store.g)
+        print(f"✅ [R-BOX] Terminé. {final - initial_count} nouveaux faits générés.")
 
     def _apply_rule(self, sparql, name):
         try:
-            full = f"PREFIX vortex: <http://vortex.ai/ontology#>\nPREFIX xsd: <http://www.w3.org/2001/XMLSchema#>\n{sparql}"
+            full = f"""
+            PREFIX vortex: <http://vortex.ai/ontology#>
+            PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+            PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            {sparql}
+            """
             res = self.rdf_store.g.query(full)
-            for t in res: self.rdf_store.g.add(t)
+            c = 0
+            for t in res:
+                self.rdf_store.g.add(t)
+                c += 1
+            if c > 0: print(f"   🔹 {name} : +{c} faits.")
         except Exception as e:
-            print(f"❌ Erreur Règle '{name}' : {e}")
+            print(f"   ❌ Erreur {name} : {e}")