gradient

utils/export_manager.py

@@ -188,7 +188,6 @@ class ExportManager:
                     f"  - Type: {domain_info['classification']}",
                     f"  - Connected IPs: {len(domain_info['ips'])}",
                     f"  - Certificate Status: {domain_info['cert_status']}",
-                    f"  - Relationship Confidence: {domain_info['avg_confidence']:.2f}",
                 ])
                 
                 if domain_info['security_notes']:
@@ -247,11 +246,9 @@ class ExportManager:
             ])
             
             for rel in key_relationships[:8]:  # Top 8 relationships
-                confidence_desc = self._describe_confidence(rel['confidence'])
                 report.extend([
                     f"• {rel['source']} → {rel['target']}",
                     f"  - Relationship: {self._humanize_relationship_type(rel['type'])}",
-                    f"  - Evidence Strength: {confidence_desc} ({rel['confidence']:.2f})",
                     f"  - Discovery Method: {rel['provider']}",
                     ""
                 ])
@@ -291,17 +288,8 @@ class ExportManager:
             "Data Quality Assessment:",
             f"• Total API Requests: {audit_trail.get('session_metadata', {}).get('total_requests', 0)}",
             f"• Data Providers Used: {len(audit_trail.get('session_metadata', {}).get('providers_used', []))}",
-            f"• Relationship Confidence Distribution:",
         ])
         
-        # Confidence distribution
-        confidence_dist = self._calculate_confidence_distribution(edges)
-        for level, count in confidence_dist.items():
-            percentage = (count / len(edges) * 100) if edges else 0
-            report.extend([
-                f"  - {level.title()} Confidence (≥{self._get_confidence_threshold(level)}): {count} ({percentage:.1f}%)",
-            ])
-        
         report.extend([
             "",
             "Correlation Analysis:",
@@ -375,9 +363,7 @@ class ExportManager:
             if len(connected_ips) > 5:
                 security_notes.append("Multiple IP endpoints")
             
-            # Average confidence
             domain_edges = [e for e in edges if e['from'] == domain['id']]
-            avg_confidence = sum(e['confidence_score'] for e in domain_edges) / len(domain_edges) if domain_edges else 0
             
             domain_analysis.append({
                 'domain': domain['id'],
@@ -385,7 +371,6 @@ class ExportManager:
                 'ips': connected_ips,
                 'cert_status': cert_status,
                 'security_notes': security_notes,
-                'avg_confidence': avg_confidence
             })
         
         # Sort by number of connections (most connected first)
@@ -480,7 +465,7 @@ class ExportManager:
     
     def _identify_key_relationships(self, edges: List[Dict]) -> List[Dict[str, Any]]:
         """Identify the most significant relationships in the infrastructure."""
-        # Score relationships by confidence and type importance
+        # Score relationships by type importance
         relationship_importance = {
             'dns_a_record': 0.9,
             'dns_aaaa_record': 0.9,
@@ -493,15 +478,12 @@ class ExportManager:
         
         scored_edges = []
         for edge in edges:
-            base_confidence = edge.get('confidence_score', 0)
             type_weight = relationship_importance.get(edge.get('label', ''), 0.5)
-            combined_score = (base_confidence * 0.7) + (type_weight * 0.3)
             
             scored_edges.append({
                 'source': edge['from'],
                 'target': edge['to'],
                 'type': edge.get('label', ''),
-                'confidence': base_confidence,
                 'provider': edge.get('source_provider', ''),
                 'score': combined_score
             })
@@ -570,19 +552,6 @@ class ExportManager:
         else:
             return "Mixed Status"
     
-    def _describe_confidence(self, confidence: float) -> str:
-        """Convert confidence score to descriptive text."""
-        if confidence >= 0.9:
-            return "Very High"
-        elif confidence >= 0.8:
-            return "High"
-        elif confidence >= 0.6:
-            return "Medium"
-        elif confidence >= 0.4:
-            return "Low"
-        else:
-            return "Very Low"
-    
     def _humanize_relationship_type(self, rel_type: str) -> str:
         """Convert technical relationship types to human-readable descriptions."""
         type_map = {
@@ -599,26 +568,6 @@ class ExportManager:
         }
         return type_map.get(rel_type, rel_type.replace('_', ' ').title())
     
-    def _calculate_confidence_distribution(self, edges: List[Dict]) -> Dict[str, int]:
-        """Calculate confidence score distribution."""
-        distribution = {'high': 0, 'medium': 0, 'low': 0}
-        
-        for edge in edges:
-            confidence = edge.get('confidence_score', 0)
-            if confidence >= 0.8:
-                distribution['high'] += 1
-            elif confidence >= 0.6:
-                distribution['medium'] += 1
-            else:
-                distribution['low'] += 1
-        
-        return distribution
-    
-    def _get_confidence_threshold(self, level: str) -> str:
-        """Get confidence threshold for a level."""
-        thresholds = {'high': '0.80', 'medium': '0.60', 'low': '0.00'}
-        return thresholds.get(level, '0.00')
-    
     def _count_cross_validated_relationships(self, edges: List[Dict]) -> int:
         """Count relationships verified by multiple providers."""
         # Group edges by source-target pair