syscred 2.2.0__py3-none-any.whl

syscred/debug_factcheck.py

@@ -0,0 +1,43 @@
+import os
+import requests
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv(dotenv_path='/Users/bk280625/documents041025/MonCode/syscred/.env')
+
+API_KEY = os.getenv('SYSCRED_GOOGLE_API_KEY')
+print(f"Loaded API Key: {API_KEY[:5]}...{API_KEY[-5:] if API_KEY else 'None'}")
+
+if not API_KEY:
+    print("❌ Error: API Key not found in .env")
+    exit(1)
+
+query = "La terre est plate"
+url = "https://factchecktools.googleapis.com/v1alpha1/claims:search"
+params = {
+    'key': API_KEY,
+    'query': query,
+}
+
+print(f"\nSending request for query: '{query}'...")
+try:
+    response = requests.get(url, params=params)
+    print(f"Status Code: {response.status_code}")
+    
+    if response.status_code == 200:
+        data = response.json()
+        claims = data.get('claims', [])
+        print(f"✅ Success! Found {len(claims)} claims.")
+        for i, claim in enumerate(claims[:3]):
+            print(f"\n--- Result {i+1} ---")
+            print(f"Claim: {claim.get('text')}")
+            print(f"Claimant: {claim.get('claimant')}")
+            reviews = claim.get('claimReview', [])
+            if reviews:
+                print(f"Rating: {reviews[0].get('textualRating')}")
+                print(f"URL: {reviews[0].get('url')}")
+    else:
+        print(f"❌ API Error: {response.text}")
+
+except Exception as e:
+    print(f"❌ Connection Error: {e}")

syscred/debug_graph_json.py

@@ -0,0 +1,58 @@
+import sys
+from pathlib import Path
+import json
+
+# Add project root to path (one level up from this script)
+sys.path.append(str(Path(__file__).parent.parent))
+
+from syscred.ontology_manager import OntologyManager
+from syscred.config import config
+
+def debug_graph():
+    print("=== Debugging Ontology Graph Extraction ===")
+    
+    # Initialize manager
+    base_path = str(config.ONTOLOGY_BASE_PATH)
+    data_path = str(config.ONTOLOGY_DATA_PATH)
+    
+    print(f"Loading data from: {data_path}")
+    manager = OntologyManager(base_ontology_path=base_path, data_path=data_path)
+    
+    # Get Stats
+    stats = manager.get_statistics()
+    print(f"Total Triples: {stats['total_triples']}")
+    print(f"Evaluations: {stats.get('total_evaluations', 'N/A')}")
+    
+    # Try getting graph JSON
+    print("\nExtracting Graph JSON...")
+    graph_data = manager.get_graph_json()
+    
+    nodes = graph_data.get('nodes', [])
+    links = graph_data.get('links', [])
+    
+    print(f"Nodes found: {len(nodes)}")
+    print(f"Links found: {len(links)}")
+    
+    if len(nodes) > 0:
+        print("\n--- Sample Nodes ---")
+        for n in nodes[:3]:
+            print(json.dumps(n, indent=2))
+    else:
+        print("\n❌ No nodes found! Checking latest report query...")
+        # Manually run the query to see what's wrong
+        query = """
+        PREFIX cred: <http://www.dic9335.uqam.ca/ontologies/credibility-verification#>
+        SELECT ?report ?timestamp WHERE {
+            ?report a cred:RapportEvaluation .
+            ?report cred:completionTimestamp ?timestamp .
+        }
+        ORDER BY DESC(?timestamp)
+        LIMIT 5
+        """
+        print(f"Running SPARQL:\n{query}")
+        results = manager.data_graph.query(query)
+        for row in results:
+            print(f"Found Report: {row.report} at {row.timestamp}")
+
+if __name__ == "__main__":
+    debug_graph()

syscred/debug_init.py

@@ -0,0 +1,33 @@
+
+import sys
+import os
+import traceback
+
+# Setup path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from syscred.verification_system import CredibilityVerificationSystem
+from syscred.config import config
+from syscred.seo_analyzer import SEOAnalyzer
+
+print("=== DEBUG INITIALIZATION ===")
+try:
+    print("[1] Config check:")
+    print(f"    Base Ontology: {config.ONTOLOGY_BASE_PATH}")
+    print(f"    Data Path: {config.ONTOLOGY_DATA_PATH}")
+    
+    print("\n[2] Initializing SEO Analyzer...")
+    seo = SEOAnalyzer()
+    print("    OK")
+    
+    print("\n[3] Initializing Verification System...")
+    sys = CredibilityVerificationSystem(
+        ontology_base_path=config.ONTOLOGY_BASE_PATH,
+        ontology_data_path=config.ONTOLOGY_DATA_PATH,
+        load_ml_models=False # Disable ML for basic init test
+    )
+    print("    OK - System initialized successfully.")
+
+except Exception as e:
+    print(f"\n❌ FATAL ERROR: {e}")
+    traceback.print_exc()

syscred/debug_local_server.py

@@ -0,0 +1,25 @@
+import requests
+import json
+
+url = "http://localhost:5001/api/verify"
+payload = {
+    "input_data": "la terre est plate",
+    "include_seo": True
+}
+headers = {'Content-Type': 'application/json'}
+
+try:
+    print(f"Sending POST to {url} with payload: {payload}")
+    response = requests.post(url, json=payload, headers=headers)
+    print(f"Status: {response.status_code}")
+    
+    if response.status_code == 200:
+        data = response.json()
+        print("\n--- JSON RESPONSE PARTIAL ---")
+        facts = data.get('reglesAppliquees', {}).get('fact_checking', [])
+        print(f"Fact Checks Count: {len(facts)}")
+        print("Fact Checks Items:", json.dumps(facts, indent=2, ensure_ascii=False))
+    else:
+        print("Error:", response.text)
+except Exception as e:
+    print(f"Connection failed: {e}")

syscred/diagnose_imports.py

@@ -0,0 +1,37 @@
+
+import sys
+import os
+import traceback
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+print("--- DIAGNOSTIC START ---")
+try:
+    print("[1] Importing config...")
+    from syscred.config import config
+    print("    OK")
+except Exception:
+    traceback.print_exc()
+
+try:
+    print("[2] Importing database...")
+    from syscred.database import init_db
+    print("    OK")
+except Exception:
+    traceback.print_exc()
+
+try:
+    print("[3] Importing ontology_manager...")
+    from syscred.ontology_manager import OntologyManager
+    print("    OK")
+except Exception:
+    traceback.print_exc()
+
+try:
+    print("[4] Importing verification_system...")
+    from syscred.verification_system import CredibilityVerificationSystem
+    print("    OK")
+except Exception:
+    traceback.print_exc()
+
+print("--- DIAGNOSTIC END ---")

syscred/eval_metrics.py

@@ -0,0 +1,349 @@
+# -*- coding: utf-8 -*-
+"""
+Evaluation Metrics Module - SysCRED
+====================================
+Information Retrieval evaluation metrics for TREC-style experiments.
+
+Metrics:
+- MAP (Mean Average Precision)
+- NDCG (Normalized Discounted Cumulative Gain)
+- P@K (Precision at K)
+- Recall@K
+- MRR (Mean Reciprocal Rank)
+
+Based on pytrec_eval for official TREC evaluation.
+
+(c) Dominique S. Loyer - PhD Thesis Prototype
+Citation Key: loyerEvaluationModelesRecherche2025
+"""
+
+import math
+from typing import Dict, List, Tuple, Any
+from collections import defaultdict
+
+# Check for pytrec_eval
+try:
+    import pytrec_eval
+    HAS_PYTREC_EVAL = True
+except ImportError:
+    HAS_PYTREC_EVAL = False
+    print("[EvalMetrics] pytrec_eval not installed. Using built-in metrics.")
+
+
+class EvaluationMetrics:
+    """
+    IR Evaluation metrics using pytrec_eval or built-in implementations.
+    
+    Supports TREC-style evaluation with:
+    - Official pytrec_eval (if available)
+    - Fallback pure-Python implementations
+    """
+    
+    def __init__(self):
+        """Initialize the metrics calculator."""
+        self.use_pytrec = HAS_PYTREC_EVAL
+    
+    # --- Built-in Metric Implementations ---
+    
+    @staticmethod
+    def precision_at_k(retrieved: List[str], relevant: set, k: int) -> float:
+        """
+        Calculate Precision@K.
+        
+        P@K = |relevant ∩ retrieved[:k]| / k
+        """
+        if k <= 0:
+            return 0.0
+        retrieved_k = retrieved[:k]
+        relevant_retrieved = len([d for d in retrieved_k if d in relevant])
+        return relevant_retrieved / k
+    
+    @staticmethod
+    def recall_at_k(retrieved: List[str], relevant: set, k: int) -> float:
+        """
+        Calculate Recall@K.
+        
+        R@K = |relevant ∩ retrieved[:k]| / |relevant|
+        """
+        if not relevant:
+            return 0.0
+        retrieved_k = retrieved[:k]
+        relevant_retrieved = len([d for d in retrieved_k if d in relevant])
+        return relevant_retrieved / len(relevant)
+    
+    @staticmethod
+    def average_precision(retrieved: List[str], relevant: set) -> float:
+        """
+        Calculate Average Precision for a single query.
+        
+        AP = (1/|relevant|) × Σ (P@k × rel(k))
+        """
+        if not relevant:
+            return 0.0
+        
+        hits = 0
+        sum_precision = 0.0
+        
+        for i, doc in enumerate(retrieved):
+            if doc in relevant:
+                hits += 1
+                sum_precision += hits / (i + 1)
+        
+        return sum_precision / len(relevant)
+    
+    @staticmethod
+    def dcg_at_k(retrieved: List[str], relevance: Dict[str, int], k: int) -> float:
+        """
+        Calculate DCG@K (Discounted Cumulative Gain).
+        
+        DCG@K = Σ (2^rel(i) - 1) / log2(i + 2)
+        """
+        dcg = 0.0
+        for i, doc in enumerate(retrieved[:k]):
+            rel = relevance.get(doc, 0)
+            dcg += (2 ** rel - 1) / math.log2(i + 2)
+        return dcg
+    
+    @staticmethod
+    def ndcg_at_k(retrieved: List[str], relevance: Dict[str, int], k: int) -> float:
+        """
+        Calculate NDCG@K (Normalized DCG).
+        
+        NDCG@K = DCG@K / IDCG@K
+        """
+        dcg = EvaluationMetrics.dcg_at_k(retrieved, relevance, k)
+        
+        # Calculate IDCG (ideal DCG)
+        sorted_rels = sorted(relevance.values(), reverse=True)[:k]
+        idcg = 0.0
+        for i, rel in enumerate(sorted_rels):
+            idcg += (2 ** rel - 1) / math.log2(i + 2)
+        
+        return dcg / idcg if idcg > 0 else 0.0
+    
+    @staticmethod
+    def reciprocal_rank(retrieved: List[str], relevant: set) -> float:
+        """
+        Calculate Reciprocal Rank.
+        
+        RR = 1 / rank of first relevant document
+        """
+        for i, doc in enumerate(retrieved):
+            if doc in relevant:
+                return 1.0 / (i + 1)
+        return 0.0
+    
+    # --- TREC-Style Evaluation ---
+    
+    def evaluate_run(
+        self,
+        run: Dict[str, List[Tuple[str, float]]],
+        qrels: Dict[str, Dict[str, int]],
+        metrics: List[str] = None
+    ) -> Dict[str, Dict[str, float]]:
+        """
+        Evaluate a run against qrels (relevance judgments).
+        
+        Args:
+            run: {query_id: [(doc_id, score), ...]}
+            qrels: {query_id: {doc_id: relevance}}
+            metrics: List of metrics to compute
+                     ['map', 'ndcg', 'P_5', 'P_10', 'recall_100']
+        
+        Returns:
+            {query_id: {metric: value}}
+        """
+        if metrics is None:
+            metrics = ['map', 'ndcg', 'P_5', 'P_10', 'P_20', 'recall_100', 'recip_rank']
+        
+        if self.use_pytrec and HAS_PYTREC_EVAL:
+            return self._evaluate_pytrec(run, qrels, metrics)
+        else:
+            return self._evaluate_builtin(run, qrels, metrics)
+    
+    def _evaluate_pytrec(
+        self,
+        run: Dict[str, List[Tuple[str, float]]],
+        qrels: Dict[str, Dict[str, int]],
+        metrics: List[str]
+    ) -> Dict[str, Dict[str, float]]:
+        """Evaluate using pytrec_eval."""
+        # Convert run format for pytrec_eval
+        pytrec_run = {}
+        for qid, docs in run.items():
+            pytrec_run[qid] = {doc_id: score for doc_id, score in docs}
+        
+        # Create evaluator
+        evaluator = pytrec_eval.RelevanceEvaluator(qrels, set(metrics))
+        
+        # Evaluate
+        results = evaluator.evaluate(pytrec_run)
+        
+        return results
+    
+    def _evaluate_builtin(
+        self,
+        run: Dict[str, List[Tuple[str, float]]],
+        qrels: Dict[str, Dict[str, int]],
+        metrics: List[str]
+    ) -> Dict[str, Dict[str, float]]:
+        """Evaluate using built-in implementations."""
+        results = {}
+        
+        for qid, docs_scores in run.items():
+            if qid not in qrels:
+                continue
+            
+            q_results = {}
+            retrieved = [doc_id for doc_id, _ in docs_scores]
+            relevance = qrels[qid]
+            relevant = set(doc_id for doc_id, rel in relevance.items() if rel > 0)
+            
+            for metric in metrics:
+                if metric == 'map':
+                    q_results['map'] = self.average_precision(retrieved, relevant)
+                elif metric == 'ndcg':
+                    q_results['ndcg'] = self.ndcg_at_k(retrieved, relevance, 1000)
+                elif metric.startswith('ndcg_cut_'):
+                    k = int(metric.split('_')[-1])
+                    q_results[metric] = self.ndcg_at_k(retrieved, relevance, k)
+                elif metric.startswith('P_'):
+                    k = int(metric.split('_')[-1])
+                    q_results[metric] = self.precision_at_k(retrieved, relevant, k)
+                elif metric.startswith('recall_'):
+                    k = int(metric.split('_')[-1])
+                    q_results[metric] = self.recall_at_k(retrieved, relevant, k)
+                elif metric == 'recip_rank':
+                    q_results['recip_rank'] = self.reciprocal_rank(retrieved, relevant)
+            
+            results[qid] = q_results
+        
+        return results
+    
+    def compute_aggregate(
+        self,
+        results: Dict[str, Dict[str, float]]
+    ) -> Dict[str, float]:
+        """
+        Compute aggregate metrics across all queries.
+        
+        Returns mean values for each metric.
+        """
+        if not results:
+            return {}
+        
+        aggregated = defaultdict(list)
+        for qid, metrics in results.items():
+            for metric, value in metrics.items():
+                aggregated[metric].append(value)
+        
+        return {metric: sum(values) / len(values) 
+                for metric, values in aggregated.items()}
+    
+    def format_results(
+        self,
+        results: Dict[str, Dict[str, float]],
+        include_per_query: bool = False
+    ) -> str:
+        """Format results as a readable string."""
+        lines = []
+        
+        # Aggregate
+        agg = self.compute_aggregate(results)
+        lines.append("=" * 50)
+        lines.append("AGGREGATE METRICS")
+        lines.append("=" * 50)
+        for metric, value in sorted(agg.items()):
+            lines.append(f"  {metric:20s}: {value:.4f}")
+        
+        # Per-query (optional)
+        if include_per_query:
+            lines.append("")
+            lines.append("=" * 50)
+            lines.append("PER-QUERY METRICS")
+            lines.append("=" * 50)
+            for qid in sorted(results.keys()):
+                lines.append(f"\nQuery {qid}:")
+                for metric, value in sorted(results[qid].items()):
+                    lines.append(f"  {metric:20s}: {value:.4f}")
+        
+        return '\n'.join(lines)
+
+
+def parse_qrels_file(filepath: str) -> Dict[str, Dict[str, int]]:
+    """
+    Parse a TREC qrels file.
+    
+    Format: query_id 0 doc_id relevance
+    """
+    qrels = defaultdict(dict)
+    with open(filepath, 'r') as f:
+        for line in f:
+            parts = line.strip().split()
+            if len(parts) >= 4:
+                qid, _, docid, rel = parts[:4]
+                qrels[qid][docid] = int(rel)
+    return dict(qrels)
+
+
+def parse_run_file(filepath: str) -> Dict[str, List[Tuple[str, float]]]:
+    """
+    Parse a TREC run file.
+    
+    Format: query_id Q0 doc_id rank score run_tag
+    """
+    run = defaultdict(list)
+    with open(filepath, 'r') as f:
+        for line in f:
+            parts = line.strip().split()
+            if len(parts) >= 5:
+                qid, _, docid, rank, score = parts[:5]
+                run[qid].append((docid, float(score)))
+    
+    # Sort by score descending
+    for qid in run:
+        run[qid].sort(key=lambda x: x[1], reverse=True)
+    
+    return dict(run)
+
+
+# --- Testing ---
+if __name__ == "__main__":
+    print("=" * 60)
+    print("SysCRED Evaluation Metrics - Tests")
+    print("=" * 60)
+    
+    metrics = EvaluationMetrics()
+    print(f"\nUsing pytrec_eval: {metrics.use_pytrec}")
+    
+    # Test data
+    retrieved = ['doc1', 'doc2', 'doc3', 'doc4', 'doc5', 'doc6', 'doc7', 'doc8', 'doc9', 'doc10']
+    relevant = {'doc1', 'doc3', 'doc5', 'doc8'}
+    relevance = {'doc1': 2, 'doc3': 1, 'doc5': 2, 'doc8': 1}
+    
+    print("\n--- Built-in Metrics Tests ---")
+    print(f"P@5:  {metrics.precision_at_k(retrieved, relevant, 5):.4f}")
+    print(f"P@10: {metrics.precision_at_k(retrieved, relevant, 10):.4f}")
+    print(f"R@5:  {metrics.recall_at_k(retrieved, relevant, 5):.4f}")
+    print(f"R@10: {metrics.recall_at_k(retrieved, relevant, 10):.4f}")
+    print(f"AP:   {metrics.average_precision(retrieved, relevant):.4f}")
+    print(f"NDCG@10: {metrics.ndcg_at_k(retrieved, relevance, 10):.4f}")
+    print(f"RR:   {metrics.reciprocal_rank(retrieved, relevant):.4f}")
+    
+    # Test run evaluation
+    print("\n--- Run Evaluation Test ---")
+    run = {
+        'Q1': [(doc, 10-i) for i, doc in enumerate(retrieved)],
+        'Q2': [('doc2', 10), ('doc1', 9), ('doc4', 8), ('doc3', 7)]
+    }
+    qrels = {
+        'Q1': relevance,
+        'Q2': {'doc1': 1, 'doc3': 2}
+    }
+    
+    results = metrics.evaluate_run(run, qrels)
+    print(metrics.format_results(results))
+    
+    print("\n" + "=" * 60)
+    print("Tests complete!")
+    print("=" * 60)