runbooks 1.1.4__py3-none-any.whl → 1.1.5__py3-none-any.whl

runbooks/validation/terraform_citations_validator.py

@@ -39,13 +39,16 @@ import hashlib
 # For PDF support
 try:
     import PyPDF2
+
     PDF_SUPPORT = True
 except ImportError:
     PDF_SUPPORT = False
 
+
 @dataclass
 class TerraformFact:
     """A fact extracted from terraform state with citation metadata."""
+
     resource_type: str
     resource_id: str
     attribute: str
@@ -53,62 +56,63 @@ class TerraformFact:
     terraform_file: str
     line_number: int
     citation_id: str
-    
+
     def to_citation(self) -> Dict[str, Any]:
         """Convert to Claude Citations API format."""
         return {
             "id": self.citation_id,
             "source": f"terraform-aws/{self.terraform_file}:{self.line_number}",
             "text": f"{self.resource_type}.{self.resource_id}.{self.attribute} = {self.value}",
-            "type": "terraform_state"
+            "type": "terraform_state",
         }
 
+
 class TerraformCitationsValidator:
     """Validates runbooks outputs with terraform facts using Citations API pattern."""
-    
+
     def __init__(self, terraform_dir: str = "/Volumes/Working/1xOps/CloudOps-Runbooks/terraform-aws"):
         """Initialize with terraform-aws directory path."""
         self.terraform_dir = Path(terraform_dir)
         self.facts_db: Dict[str, TerraformFact] = {}
         self.citations: List[Dict[str, Any]] = []
         self.external_knowledge_dir = Path("/Volumes/Working/1xOps/CloudOps-Runbooks/knowledge-external")
-        
+
     def extract_terraform_facts(self) -> Dict[str, TerraformFact]:
         """Extract facts from terraform source files (.tf) for citation."""
         facts = {}
-        
+
         # Find all terraform source files (.tf) as requested by user
         tf_files = list(self.terraform_dir.rglob("*.tf"))
-        
+
         for tf_file in tf_files:
             try:
-                with open(tf_file, 'r') as f:
+                with open(tf_file, "r") as f:
                     tf_content = f.read()
-                
+
                 # Parse terraform source for resource definitions
                 tf_facts = self._parse_terraform_source(tf_content, tf_file)
                 facts.update(tf_facts)
-                                
+
             except Exception as e:
                 print(f"Error parsing {tf_file}: {e}")
-                
+
         self.facts_db = facts
         return facts
-    
+
     def _parse_terraform_source(self, tf_content: str, tf_file: Path) -> Dict[str, TerraformFact]:
         """Parse terraform source file for resource definitions and citations."""
         facts = {}
-        lines = tf_content.split('\n')
-        
+        lines = tf_content.split("\n")
+
         current_resource = None
         current_resource_name = None
         brace_count = 0
-        
+
         for line_num, line in enumerate(lines, 1):
             line = line.strip()
-            
+
             # Detect resource blocks
-            if line.startswith('resource '):
+            if line.startswith("resource "):
                 # Extract resource type and name: resource "aws_nat_gateway" "example" {
                 parts = line.split()
                 if len(parts) >= 3:
@@ -117,98 +121,93 @@ class TerraformCitationsValidator:
                     current_resource = resource_type
                     current_resource_name = resource_name
                     brace_count = 0
-                    
+
             # Track braces to know when we're inside a resource block
-            if '{' in line:
-                brace_count += line.count('{')
-            if '}' in line:
-                brace_count -= line.count('}')
+            if "{" in line:
+                brace_count += line.count("{")
+            if "}" in line:
+                brace_count -= line.count("}")
                 if brace_count == 0:
                     current_resource = None
                     current_resource_name = None
-            
+
             # Extract cost-relevant attributes from within resource blocks
-            if current_resource and current_resource_name and '=' in line:
+            if current_resource and current_resource_name and "=" in line:
                 # Parse attribute assignments
-                if 'instance_type' in line:
+                if "instance_type" in line:
                     value = self._extract_tf_value(line)
                     fact = TerraformFact(
                         resource_type=current_resource,
                         resource_id=current_resource_name,
-                        attribute='instance_type',
+                        attribute="instance_type",
                         value=value,
                         terraform_file=str(tf_file.relative_to(self.terraform_dir)),
                         line_number=line_num,
                         citation_id=hashlib.md5(
                             f"{current_resource}.{current_resource_name}.instance_type".encode()
-                        ).hexdigest()[:8]
+                        ).hexdigest()[:8],
                     )
                     facts[fact.citation_id] = fact
-                    
-                elif 'size' in line and current_resource == 'aws_ebs_volume':
+
+                elif "size" in line and current_resource == "aws_ebs_volume":
                     value = self._extract_tf_value(line)
                     fact = TerraformFact(
                         resource_type=current_resource,
                         resource_id=current_resource_name,
-                        attribute='size',
+                        attribute="size",
                         value=value,
                         terraform_file=str(tf_file.relative_to(self.terraform_dir)),
                         line_number=line_num,
                         citation_id=hashlib.md5(
                             f"{current_resource}.{current_resource_name}.size".encode()
-                        ).hexdigest()[:8]
+                        ).hexdigest()[:8],
                     )
                     facts[fact.citation_id] = fact
-                    
+
         return facts
-    
+
     def _extract_tf_value(self, line: str) -> str:
         """Extract value from terraform assignment line."""
-        if '=' in line:
-            value_part = line.split('=', 1)[1].strip()
+        if "=" in line:
+            value_part = line.split("=", 1)[1].strip()
             # Remove quotes and trailing characters
-            value_part = value_part.strip('"').strip("'").rstrip(',').strip()
+            value_part = value_part.strip('"').strip("'").rstrip(",").strip()
             return value_part
         return ""
-    
-    def _create_fact_from_resource(self, resource: Dict, instance: Dict, 
-                                   state_file: Path) -> Optional[TerraformFact]:
+
+    def _create_fact_from_resource(self, resource: Dict, instance: Dict, state_file: Path) -> Optional[TerraformFact]:
         """Create a citeable fact from terraform resource."""
         try:
             # Extract cost-relevant attributes
-            if resource['type'] == 'aws_nat_gateway':
+            if resource["type"] == "aws_nat_gateway":
                 return TerraformFact(
-                    resource_type=resource['type'],
-                    resource_id=resource['name'],
-                    attribute='monthly_cost',
+                    resource_type=resource["type"],
+                    resource_id=resource["name"],
+                    attribute="monthly_cost",
                     value=32.4,  # Would be calculated from terraform state
                     terraform_file=str(state_file.relative_to(self.terraform_dir)),
                     line_number=1,  # Would parse actual line
-                    citation_id=hashlib.md5(
-                        f"{resource['type']}.{resource['name']}".encode()
-                    ).hexdigest()[:8]
+                    citation_id=hashlib.md5(f"{resource['type']}.{resource['name']}".encode()).hexdigest()[:8],
                 )
-            elif resource['type'] == 'aws_ebs_volume':
-                size = instance['attributes'].get('size', 0)
-                volume_type = instance['attributes'].get('type', 'gp2')
+            elif resource["type"] == "aws_ebs_volume":
+                size = instance["attributes"].get("size", 0)
+                volume_type = instance["attributes"].get("type", "gp2")
                 return TerraformFact(
-                    resource_type=resource['type'],
-                    resource_id=resource['name'],
-                    attribute='size_gb',
+                    resource_type=resource["type"],
+                    resource_id=resource["name"],
+                    attribute="size_gb",
                     value=size,
                     terraform_file=str(state_file.relative_to(self.terraform_dir)),
                     line_number=1,
-                    citation_id=hashlib.md5(
-                        f"{resource['type']}.{resource['name']}".encode()
-                    ).hexdigest()[:8]
+                    citation_id=hashlib.md5(f"{resource['type']}.{resource['name']}".encode()).hexdigest()[:8],
                 )
         except Exception:
             return None
-    
+
     def validate_with_citations(self, runbook_output: Dict[str, Any]) -> Dict[str, Any]:
         """
         Validate runbook output with terraform facts and provide citations.
-        
+
         This demonstrates how Citations API would work:
         1. Runbook produces cost calculation
         2. Validator finds relevant terraform facts
@@ -220,56 +219,53 @@ class TerraformCitationsValidator:
             "validated": True,
             "accuracy": 0.0,
             "citations": [],
-            "drift_detected": []
+            "drift_detected": [],
         }
-        
+
         # Example: Validate NAT Gateway cost calculation
-        if 'nat_gateway_cost' in runbook_output:
-            cited_fact = self._find_citation_for_cost(
-                'aws_nat_gateway', 
-                runbook_output['nat_gateway_cost']
-            )
+        if "nat_gateway_cost" in runbook_output:
+            cited_fact = self._find_citation_for_cost("aws_nat_gateway", runbook_output["nat_gateway_cost"])
             if cited_fact:
-                validation_result['citations'].append(cited_fact.to_citation())
-                
+                validation_result["citations"].append(cited_fact.to_citation())
+
         # Example: Validate EBS volume costs
-        if 'ebs_costs' in runbook_output:
-            for volume_id, cost in runbook_output['ebs_costs'].items():
+        if "ebs_costs" in runbook_output:
+            for volume_id, cost in runbook_output["ebs_costs"].items():
                 cited_fact = self._find_citation_for_volume(volume_id)
                 if cited_fact:
-                    validation_result['citations'].append(cited_fact.to_citation())
-                    
+                    validation_result["citations"].append(cited_fact.to_citation())
+
         # Calculate accuracy based on citations
-        if validation_result['citations']:
-            validation_result['accuracy'] = len(validation_result['citations']) / len(runbook_output) * 100
-            
+        if validation_result["citations"]:
+            validation_result["accuracy"] = len(validation_result["citations"]) / len(runbook_output) * 100
+
         return validation_result
-    
+
     def _find_citation_for_cost(self, resource_type: str, cost: float) -> Optional[TerraformFact]:
         """Find terraform fact to cite for a cost calculation."""
         for fact_id, fact in self.facts_db.items():
             if fact.resource_type == resource_type:
                 return fact
         return None
-    
+
     def _find_citation_for_volume(self, volume_id: str) -> Optional[TerraformFact]:
         """Find terraform fact for an EBS volume."""
         for fact_id, fact in self.facts_db.items():
-            if fact.resource_type == 'aws_ebs_volume' and volume_id in fact.resource_id:
+            if fact.resource_type == "aws_ebs_volume" and volume_id in fact.resource_id:
                 return fact
         return None
-    
+
     def validate_with_pdf_knowledge(self, pdf_path: str) -> Dict[str, Any]:
         """
         Validate using PDF documents from knowledge-external directory.
-        
+
         PDF SUPPORT FEASIBILITY:
         YES - PDF support is highly valuable for this runbooks project:
         1. AWS pricing documentation in PDF format
         2. Compliance reports and audit documents
         3. Architecture diagrams and cost models
         4. External knowledge validation sources
-        
+
         USE CASES:
         - Validate pricing against AWS official PDFs
         - Cross-reference compliance requirements
@@ -278,38 +274,36 @@ class TerraformCitationsValidator:
         """
         if not PDF_SUPPORT:
             return {"error": "PyPDF2 not installed for PDF support"}
-            
-        validation_result = {
-            "pdf_source": pdf_path,
-            "extracted_facts": [],
-            "validation_status": "pending"
-        }
-        
+
+        validation_result = {"pdf_source": pdf_path, "extracted_facts": [], "validation_status": "pending"}
+
         try:
             pdf_file = self.external_knowledge_dir / pdf_path
             if pdf_file.exists():
-                with open(pdf_file, 'rb') as f:
+                with open(pdf_file, "rb") as f:
                     pdf_reader = PyPDF2.PdfReader(f)
-                    
+
                     # Extract text from PDF for validation
                     for page_num, page in enumerate(pdf_reader.pages):
                         text = page.extract_text()
-                        
+
                         # Look for pricing information
-                        if 'NAT Gateway' in text and '$' in text:
-                            validation_result['extracted_facts'].append({
-                                "page": page_num + 1,
-                                "fact": "NAT Gateway pricing found",
-                                "citation": f"{pdf_path}:page_{page_num+1}"
-                            })
-                            
-                validation_result['validation_status'] = 'completed'
-                
+                        if "NAT Gateway" in text and "$" in text:
+                            validation_result["extracted_facts"].append(
+                                {
+                                    "page": page_num + 1,
+                                    "fact": "NAT Gateway pricing found",
+                                    "citation": f"{pdf_path}:page_{page_num + 1}",
+                                }
+                            )
+
+                validation_result["validation_status"] = "completed"
+
         except Exception as e:
-            validation_result['error'] = str(e)
-            
+            validation_result["error"] = str(e)
+
         return validation_result
-    
+
     def generate_citation_report(self) -> str:
         """Generate a report with all citations for audit trail."""
         report = []
@@ -318,14 +312,14 @@ class TerraformCitationsValidator:
         report.append(f"Terraform Directory: {self.terraform_dir}")
         report.append(f"Total Facts Extracted: {len(self.facts_db)}")
         report.append("")
-        
+
         report.append("## Extracted Terraform Facts")
         for fact_id, fact in self.facts_db.items():
             report.append(f"- [{fact.citation_id}] {fact.resource_type}.{fact.resource_id}")
             report.append(f"  Source: {fact.terraform_file}:{fact.line_number}")
             report.append(f"  Value: {fact.attribute} = {fact.value}")
             report.append("")
-            
+
         report.append("## Citations API Integration")
         report.append("```python")
         report.append("# Example usage with runbooks API:")
@@ -334,30 +328,25 @@ class TerraformCitationsValidator:
         report.append("result = validator.validate_with_citations(runbook_output)")
         report.append("print(f'Validation accuracy: {result[\"accuracy\"]}%')")
         report.append("```")
-        
+
         return "\n".join(report)
 
+
 # Example usage demonstrating Citations API integration
 if __name__ == "__main__":
     validator = TerraformCitationsValidator()
-    
+
     # Extract facts from terraform state
     facts = validator.extract_terraform_facts()
     print(f"Extracted {len(facts)} terraform facts for citation")
-    
+
     # Example runbook output to validate
-    example_output = {
-        "nat_gateway_cost": 32.4,
-        "ebs_costs": {
-            "vol-12345": 8.0,
-            "vol-67890": 10.0
-        }
-    }
-    
+    example_output = {"nat_gateway_cost": 32.4, "ebs_costs": {"vol-12345": 8.0, "vol-67890": 10.0}}
+
     # Validate with citations
     validation = validator.validate_with_citations(example_output)
     print(f"Validation result: {validation}")
-    
+
     # Generate report
     report = validator.generate_citation_report()
-    print(report)
+    print(report)