syscred 2.2.0__py3-none-any.whl

syscred/test_graphrag.py

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+"""
+Test Script for GraphRAG
+========================
+Verifies that the GraphRAG module can correctly:
+1. Connect to an in-memory ontology.
+2. Retrieve context for a domain that has history.
+"""
+
+import sys
+import os
+
+# Add parent directory to path to allow imports
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from syscred.ontology_manager import OntologyManager
+from syscred.graph_rag import GraphRAG
+
+def test_graphrag_retrieval():
+    print("=== Testing GraphRAG Retrieval Logic ===\n")
+
+    # 1. Setup In-Memory Ontology
+    print("[1] Initializing in-memory Ontology...")
+    om = OntologyManager(base_ontology_path=None, data_path=None)
+    
+    # 2. Add Fake History (Memory)
+    print("[2] Injecting test memory for 'lemonde.fr'...")
+    fake_report = {
+        'scoreCredibilite': 0.95,
+        'informationEntree': 'https://www.lemonde.fr/article/test',
+        'resumeAnalyse': "Reliable source.",
+        'reglesAppliquees': {
+            'source_analysis': {'reputation': 'High', 'domain': 'lemonde.fr'}
+        }
+    }
+    # Add it 3 times to simulate history
+    om.add_evaluation_triplets(fake_report)
+    om.add_evaluation_triplets(fake_report)
+    om.add_evaluation_triplets(fake_report)
+    print("    -> Added 3 evaluation records.")
+
+    # 3. Initialize GraphRAG
+    rag = GraphRAG(om)
+
+    # 4. Query Context
+    domain = "lemonde.fr"
+    print(f"\n[3] Querying GraphRAG for domain: '{domain}'...")
+    context = rag.get_context(domain)
+    
+    print("\n--- Result Context (Domain History) ---")
+    print(context['full_text'])
+    print("---------------------------------------\n")
+    
+    # 5. Validation 1 (History)
+    if "Analyzed 3 times" in context['full_text']:
+        print("✅ SUCCESS: GraphRAG correctly remembered the history.")
+    else:
+        print("❌ FAILURE: GraphRAG did not return the expected history count.")
+
+    # 6. Test Similar Claims (New Feature)
+    print(f"\n[4] Testing 'Similar Claims' for keywords: ['lemonde', 'fake']...")
+    # The previous injection didn't use 'fake', let's check what it finds or if we need to inject more
+    # Our fake_report had content: 'https://www.lemonde.fr/article/test'
+    # The new logic searches regex in 'informationContent'
+    
+    # Let's add a specifically claim-like entry
+    fake_claim = {
+        'scoreCredibilite': 0.1,
+        'informationEntree': 'The earth is flat and fake',
+        'resumeAnalyse': "False claim.",
+        'reglesAppliquees': {'source_analysis': {'reputation': 'Low'}}
+    }
+    om.add_evaluation_triplets(fake_claim)
+    
+    # Search for 'flat'
+    similar_context = rag.get_context("unknown.com", keywords=["flat", "earth"])
+    print("\n--- Result Context (Similar Claims) ---")
+    print(similar_context['full_text'])
+    print("---------------------------------------\n")
+
+    if "Found 1 similar claims" in similar_context['full_text'] or "The earth is flat" in similar_context['full_text']:
+        print("✅ SUCCESS: GraphRAG found similar claims by keywords.")
+    else:
+        print("❌ FAILURE: GraphRAG did not find the injected similar claim.")
+
+if __name__ == "__main__":
+    test_graphrag_retrieval()

syscred/test_phase1.py

@@ -0,0 +1,28 @@
+import sys
+import os
+
+# Add project root to path
+sys.path.insert(0, os.getcwd())
+
+from syscred.api_clients import ExternalAPIClients
+
+def test_backlinks():
+    client = ExternalAPIClients()
+    
+    test_urls = [
+        "https://www.lemonde.fr", # High + Old
+        "https://www.infowars.com", # Low + Old
+        "https://example.com", # Unknown + Old
+        "https://new-suspicious-site.xyz" # Unknown + New (likely)
+    ]
+    
+    print("=== Testing Backlink Estimation Heuristic ===")
+    for url in test_urls:
+        print(f"\nTesting: {url}")
+        res = client.estimate_backlinks(url)
+        print(f"  Count: {res['estimated_count']}")
+        print(f"  Method: {res['method']}")
+        print(f"  Note: {res['note']}")
+
+if __name__ == "__main__":
+    test_backlinks()

syscred/test_phase2.py

@@ -0,0 +1,55 @@
+import sys
+import os
+
+# Add project root to path
+sys.path.insert(0, os.path.dirname(os.getcwd())) # Assumes running from syscred/
+
+try:
+    from syscred.verification_system import CredibilityVerificationSystem
+except ImportError:
+    # Just in case of path issues
+    sys.path.append(os.getcwd())
+    from verification_system import CredibilityVerificationSystem
+
+def test_nlp_fallbacks():
+    print("=== Testing NLP Hybrid Fallbacks ===")
+    
+    # Initialize without loading standard ML (to test our new hybrid logic)
+    # Note: verification_system uses HAS_ML flag, but we want to test specific methods
+    syscred = CredibilityVerificationSystem(load_ml_models=False)
+    
+    # Test 1: Coherence
+    print("\n[Test 1] Coherence")
+    coherent_text = "The quick brown fox jumps over the lazy dog. The dog was not amused. It barked loudly."
+    incoherent_text = "The quick brown fox. Banana republic creates clouds. Jump over the moon."
+    
+    score1 = syscred._calculate_coherence(coherent_text)
+    score2 = syscred._calculate_coherence(incoherent_text)
+    
+    print(f"  Coherent Text Score: {score1}")
+    print(f"  Incoherent Text Score: {score2}")
+    
+    if score1 > score2:
+        print("  ✓ Coherence logic working (Metric discriminates)")
+    else:
+        print("  ! Coherence scores inconclusive (Might be heuristic limitations)")
+
+    # Test 2: Bias
+    print("\n[Test 2] Bias")
+    neutral_text = "The government announced a new policy today regarding taxation."
+    biased_text = "The corrupt regime stands accused of treason against the people by radical idiots."
+    
+    res1 = syscred._analyze_bias(neutral_text)
+    res2 = syscred._analyze_bias(biased_text)
+    
+    print(f"  Neutral: {res1['label']} (Score: {res1['score']:.2f})")
+    print(f"  Biased: {res2['label']} (Score: {res2['score']:.2f})")
+    print(f"  Method Used: {res1.get('method', 'Unknown')}")
+    
+    if res2['score'] > res1['score']:
+        print("  ✓ Bias detection working")
+    else:
+        print("  ! Bias detection inconclusive")
+
+if __name__ == "__main__":
+    test_nlp_fallbacks()

syscred/test_suite.py

@@ -0,0 +1,64 @@
+import unittest
+import sys
+import os
+
+# Point to parent directory (MonCode) so we can import 'syscred' package
+# Current file is in MonCode/syscred/test_suite.py
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from syscred.verification_system import CredibilityVerificationSystem
+from syscred.api_clients import ExternalAPIClients
+
+class TestSysCRED(unittest.TestCase):
+    
+    @classmethod
+    def setUpClass(cls):
+        print("\n[TestSysCRED] Setting up system...")
+        cls.system = CredibilityVerificationSystem(load_ml_models=False)
+        cls.client = cls.system.api_clients
+        
+    def test_backlink_estimation_heuristic(self):
+        """Test that backlink estimation respects reputation."""
+        lemonde = self.client.estimate_backlinks("https://www.lemonde.fr")
+        infowars = self.client.estimate_backlinks("https://infowars.com")
+        
+        self.assertGreater(lemonde['estimated_count'], infowars['estimated_count'], 
+                           "High reputation should have more backlinks than Low")
+        self.assertEqual(lemonde['method'], 'heuristic_v2.1')
+
+    def test_coherence_heuristic(self):
+        """Test coherence scoring heuristic."""
+        good_text = "This is a coherent sentence. It follows logically."
+        bad_text = "This is. Random words. Banana. Cloud."
+        
+        score_good = self.system._calculate_coherence(good_text)
+        score_bad = self.system._calculate_coherence(bad_text)
+        
+        self.assertTrue(0 <= score_good <= 1)
+        # Note: Heuristic using sentence length variance might be sensitive
+        # bad_text has very short sentences, so average length is small -> penalty
+        # good_text has normal length
+        self.assertGreaterEqual(score_good, score_bad, "Coherent text should score >= incoherent")
+
+    def test_bias_heuristic(self):
+        """Test bias detection heuristic."""
+        neutral = "The economy grew by 2%."
+        biased = "The radical corrupt regime is destroying us!"
+        
+        res_neutral = self.system._analyze_bias(neutral)
+        res_biased = self.system._analyze_bias(biased)
+        
+        self.assertLess(res_neutral['score'], res_biased['score'])
+        self.assertIn("biased", res_biased['label'].lower())
+
+    def test_full_pipeline(self):
+        """Test the full verification pipeline (integration test)."""
+        input_data = "https://www.example.com"
+        result = self.system.verify_information(input_data)
+        
+        self.assertIn('scoreCredibilite', result)
+        self.assertIn('resumeAnalyse', result)
+        self.assertIsNotNone(result['scoreCredibilite'])
+
+if __name__ == '__main__':
+    unittest.main()