Update src/aibom_generator/utils.py

src/aibom_generator/utils.py

@@ -1,21 +1,17 @@
 """
 Utility functions for the AIBOM Generator.
 """
+
 import json
 import logging
 import os
 import re
 import uuid
-import requests
-import jsonschema
 from typing import Dict, List, Optional, Any, Union, Tuple
 from enum import Enum
 
 logger = logging.getLogger(__name__)
 
-# CycloneDX schema URL for version 1.6
-CYCLONEDX_SCHEMA_URL = "https://raw.githubusercontent.com/CycloneDX/specification/master/schema/bom-1.6.schema.json"
-
 # Validation severity levels
 class ValidationSeverity(Enum):
     ERROR = "error"
@@ -107,73 +103,6 @@ def validate_spdx(license_entry):
     return license_entry in spdx_licenses
 
 
-def _load_cyclonedx_schema():
-    """
-    Load the CycloneDX JSON schema from the specified URL.
-    
-    Returns:
-        dict: The loaded schema or a minimal schema if loading fails
-    """
-    try:
-        response = requests.get(CYCLONEDX_SCHEMA_URL)
-        response.raise_for_status()
-        schema = response.json()
-        logger.info(f"Successfully loaded CycloneDX schema from {CYCLONEDX_SCHEMA_URL}")
-        return schema
-    except Exception as e:
-        logger.error(f"Failed to load CycloneDX schema: {e}")
-        # Fallback to a minimal schema validation
-        return {
-            "type": "object",
-            "required": ["bomFormat", "specVersion", "serialNumber", "version"]
-        }
-
-
-def _validate_schema(aibom: Dict[str, Any], schema: Dict[str, Any]) -> List[Dict[str, Any]]:
-    """
-    Validate an AIBOM against the CycloneDX JSON schema.
-    
-    Args:
-        aibom: The AIBOM to validate
-        schema: The CycloneDX schema
-        
-    Returns:
-        List of validation issues
-    """
-    issues = []
-    
-    if not schema:
-        issues.append({
-            "severity": ValidationSeverity.WARNING.value,
-            "code": "SCHEMA_UNAVAILABLE",
-            "message": "CycloneDX schema unavailable, performing minimal validation",
-            "path": "$"
-        })
-        return issues
-        
-    try:
-        jsonschema.validate(instance=aibom, schema=schema)
-    except jsonschema.exceptions.ValidationError as e:
-        # Extract the JSON path where the validation error occurred
-        path = ".".join(str(p) for p in e.path) if e.path else "$"
-        
-        issues.append({
-            "severity": ValidationSeverity.ERROR.value,
-            "code": "SCHEMA_VALIDATION_ERROR",
-            "message": str(e),
-            "path": path
-        })
-    except Exception as e:
-        issues.append({
-            "severity": ValidationSeverity.ERROR.value,
-            "code": "SCHEMA_VALIDATION_EXCEPTION",
-            "message": f"Unexpected error during schema validation: {str(e)}",
-            "path": "$"
-        })
-        
-    return issues
-
-
 def _validate_ai_requirements(aibom: Dict[str, Any]) -> List[Dict[str, Any]]:
     """
     Validate AI-specific requirements for an AIBOM.
@@ -379,13 +308,94 @@ def _generate_validation_recommendations(issues: List[Dict[str, Any]]) -> List[s
     return recommendations
 
 
+def validate_aibom(aibom: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Validate an AIBOM against AI-specific requirements.
+    
+    Args:
+        aibom: The AIBOM to validate
+        
+    Returns:
+        Validation report with issues and recommendations
+    """
+    # Initialize validation report
+    report = {
+        "valid": True,
+        "ai_valid": True,
+        "issues": [],
+        "recommendations": [],
+        "summary": {
+            "error_count": 0,
+            "warning_count": 0,
+            "info_count": 0
+        }
+    }
+    
+    # Validate AI-specific requirements
+    ai_issues = _validate_ai_requirements(aibom)
+    if ai_issues:
+        report["ai_valid"] = False
+        report["valid"] = False
+        report["issues"].extend(ai_issues)
+        
+    # Generate recommendations
+    report["recommendations"] = _generate_validation_recommendations(report["issues"])
+    
+    # Update summary counts
+    for issue in report["issues"]:
+        if issue["severity"] == ValidationSeverity.ERROR.value:
+            report["summary"]["error_count"] += 1
+        elif issue["severity"] == ValidationSeverity.WARNING.value:
+            report["summary"]["warning_count"] += 1
+        elif issue["severity"] == ValidationSeverity.INFO.value:
+            report["summary"]["info_count"] += 1
+            
+    return report
+
+
+def get_validation_summary(report: Dict[str, Any]) -> str:
+    """
+    Get a human-readable summary of the validation report.
+    
+    Args:
+        report: Validation report
+        
+    Returns:
+        Human-readable summary
+    """
+    if report["valid"]:
+        summary = "✅ AIBOM is valid and complies with AI requirements.\n"
+    else:
+        summary = "❌ AIBOM validation failed.\n"
+        
+    summary += f"\nSummary:\n"
+    summary += f"- Errors: {report['summary']['error_count']}\n"
+    summary += f"- Warnings: {report['summary']['warning_count']}\n"
+    summary += f"- Info: {report['summary']['info_count']}\n"
+    
+    if not report["valid"]:
+        summary += "\nIssues:\n"
+        for issue in report["issues"]:
+            severity = issue["severity"].upper()
+            code = issue["code"]
+            message = issue["message"]
+            path = issue["path"]
+            summary += f"- [{severity}] {code}: {message} (at {path})\n"
+        
+        summary += "\nRecommendations:\n"
+        for i, recommendation in enumerate(report["recommendations"], 1):
+            summary += f"{i}. {recommendation}\n"
+            
+    return summary
+
+
 def calculate_completeness_score(aibom: Dict[str, Any], validate: bool = True) -> Dict[str, Any]:
     """
-    Calculate completeness score for an AIBOM and optionally validate against CycloneDX schema.
+    Calculate completeness score for an AIBOM and optionally validate against AI requirements.
     
     Args:
         aibom: The AIBOM to score and validate
-        validate: Whether to perform validation against CycloneDX schema
+        validate: Whether to perform validation
         
     Returns:
         Dictionary containing score and validation results
@@ -517,98 +527,6 @@ def calculate_completeness_score(aibom: Dict[str, Any], validate: bool = True) -
     return result
 
 
-def validate_aibom(aibom: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Validate an AIBOM against the CycloneDX schema and AI-specific requirements.
-    
-    Args:
-        aibom: The AIBOM to validate
-        
-    Returns:
-        Validation report with issues and recommendations
-    """
-    # Initialize validation report
-    report = {
-        "valid": True,
-        "schema_valid": True,
-        "ai_valid": True,
-        "issues": [],
-        "recommendations": [],
-        "summary": {
-            "error_count": 0,
-            "warning_count": 0,
-            "info_count": 0
-        }
-    }
-    
-    # Load schema
-    schema = _load_cyclonedx_schema()
-    
-    # Validate against CycloneDX schema
-    schema_issues = _validate_schema(aibom, schema)
-    if schema_issues:
-        report["schema_valid"] = False
-        report["valid"] = False
-        report["issues"].extend(schema_issues)
-        
-    # Validate AI-specific requirements
-    ai_issues = _validate_ai_requirements(aibom)
-    if ai_issues:
-        report["ai_valid"] = False
-        report["valid"] = False
-        report["issues"].extend(ai_issues)
-        
-    # Generate recommendations
-    report["recommendations"] = _generate_validation_recommendations(report["issues"])
-    
-    # Update summary counts
-    for issue in report["issues"]:
-        if issue["severity"] == ValidationSeverity.ERROR.value:
-            report["summary"]["error_count"] += 1
-        elif issue["severity"] == ValidationSeverity.WARNING.value:
-            report["summary"]["warning_count"] += 1
-        elif issue["severity"] == ValidationSeverity.INFO.value:
-            report["summary"]["info_count"] += 1
-            
-    return report
-
-
-def get_validation_summary(report: Dict[str, Any]) -> str:
-    """
-    Get a human-readable summary of the validation report.
-    
-    Args:
-        report: Validation report
-        
-    Returns:
-        Human-readable summary
-    """
-    if report["valid"]:
-        summary = "✅ AIBOM is valid and complies with CycloneDX schema and AI requirements.\n"
-    else:
-        summary = "❌ AIBOM validation failed.\n"
-        
-    summary += f"\nSummary:\n"
-    summary += f"- Errors: {report['summary']['error_count']}\n"
-    summary += f"- Warnings: {report['summary']['warning_count']}\n"
-    summary += f"- Info: {report['summary']['info_count']}\n"
-    
-    if not report["valid"]:
-        summary += "\nIssues:\n"
-        for issue in report["issues"]:
-            severity = issue["severity"].upper()
-            code = issue["code"]
-            message = issue["message"]
-            path = issue["path"]
-            summary += f"- [{severity}] {code}: {message} (at {path})\n"
-        
-        summary += "\nRecommendations:\n"
-        for i, recommendation in enumerate(report["recommendations"], 1):
-            summary += f"{i}. {recommendation}\n"
-            
-    return summary
-
-
 def merge_metadata(primary: Dict[str, Any], secondary: Dict[str, Any]) -> Dict[str, Any]:
     result = secondary.copy()
     for key, value in primary.items():