pandoraspec 0.1.1__py3-none-any.whl

pandoraspec/cli.py

@@ -0,0 +1,70 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from .core import AuditEngine
+from .reporting import generate_report
+
+app = typer.Typer(help="DORA Audit CLI - Verify Compliance of OpenAI Specs")
+console = Console()
+
+@app.command(name="scan")
+def scan(
+    schema_url: str = typer.Argument(..., help="URL or path to OpenAPI schema"),
+    api_key: str = typer.Option(None, "--key", "-k", help="API Key for authenticated endpoints"),
+    vendor: str = typer.Option("Vendor", "--vendor", "-v", help="Vendor name for the report")
+):
+    """
+    Run a DORA audit against an OpenAPI schema.
+    """
+    console.print(Panel(f"[bold blue]Starting DORA Audit for {vendor}[/bold blue]", border_style="blue"))
+    console.print(f"🔎 Scanning [bold]{schema_url}[/bold]...")
+
+    try:
+        engine = AuditEngine(schema_url=schema_url, api_key=api_key)
+        
+        # We need a progress spinner, but AuditEngine is synchronous and prints logs.
+        # For MVP CLI, we'll let AuditEngine logs show or suppress them?
+        # The user requested "Rich terminal output".
+        # Let's run it.
+        
+        results = engine.run_full_audit()
+        
+        # Display Summary Table
+        table = Table(title="Audit Summary")
+        table.add_column("Module", style="cyan", no_wrap=True)
+        table.add_column("Status", style="bold")
+        table.add_column("Issues (Pass/Fail)", style="magenta")
+
+        # Drift
+        drift_pass = len([r for r in results["drift_check"] if r.get("status") == "PASS"])
+        drift_fail = len([r for r in results["drift_check"] if r.get("status") != "PASS"])
+        drift_status = "[bold red]FAIL[/bold red]" if drift_fail > 0 else "[bold green]PASS[/bold green]"
+        table.add_row("Module A: Integrity", drift_status, f"{drift_pass} / {drift_fail}")
+
+        # Resilience
+        res_pass = len([r for r in results["resilience"] if r.get("status") == "PASS"])
+        res_fail = len([r for r in results["resilience"] if r.get("status") != "PASS"])
+        res_status = "[bold red]FAIL[/bold red]" if res_fail > 0 else "[bold green]PASS[/bold green]"
+        table.add_row("Module B: Resilience", res_status, f"{res_pass} / {res_fail}")
+
+        # Security
+        sec_pass = len([r for r in results["security"] if r.get("status") == "PASS"])
+        sec_fail = len([r for r in results["security"] if r.get("status") != "PASS"])
+        sec_status = "[bold red]FAIL[/bold red]" if sec_fail > 0 else "[bold green]PASS[/bold green]"
+        table.add_row("Module C: Security", sec_status, f"{sec_pass} / {sec_fail}")
+
+        console.print(table)
+
+        # Generate Report
+        report_path = generate_report(vendor, results)
+        
+        console.print(Panel(f"[bold green]Audit Complete![/bold green]\n📄 Report generated: [link={report_path}]{report_path}[/link]", border_style="green"))
+
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {str(e)}")
+        raise typer.Exit(code=1)
+
+if __name__ == "__main__":
+    app()

pandoraspec/core.py

@@ -0,0 +1,354 @@
+import schemathesis
+from typing import List, Dict
+import requests
+from schemathesis import checks
+from schemathesis.specs.openapi import checks as oai_checks
+from schemathesis.checks import CheckContext, ChecksConfig
+import html
+import os
+
+class AuditEngine:
+    def __init__(self, schema_url: str, base_url: str = None, api_key: str = None):
+        self.schema_url = schema_url
+        self.api_key = api_key
+        
+        # --- FIXED LOCALHOST HANDLING ---
+        # If running in Docker (implied by this environment), 'localhost' refers to the container.
+        # We need to try to reach the host machine.
+        working_schema_url = schema_url
+        if "localhost" in schema_url or "127.0.0.1" in schema_url:
+            # Try host.docker.internal first (standard for Docker Desktop)
+            # We DON'T change self.schema_url so the report still shows what the user entered.
+            try:
+                print(f"DEBUG: Attempting to resolve localhost URL using host.docker.internal")
+                test_url = schema_url.replace("localhost", "host.docker.internal").replace("127.0.0.1", "host.docker.internal")
+                requests.head(test_url, timeout=2) # Quick check
+                working_schema_url = test_url
+                print(f"DEBUG: Successfully resolved to {working_schema_url}")
+            except Exception:
+                print(f"DEBUG: Failed to reach host.docker.internal, trying original")
+                pass
+
+        try:
+            if os.path.exists(working_schema_url) and os.path.isfile(working_schema_url):
+                 print(f"DEBUG: Loading schema from local file: {working_schema_url}")
+                 self.schema = schemathesis.openapi.from_path(working_schema_url)
+            else:
+                 self.schema = schemathesis.openapi.from_url(working_schema_url)
+            
+            # 1. Use explicitly provided base_url if available
+            if base_url:
+                self.schema.base_url = base_url
+                self.base_url = base_url
+            else:
+                # 2. Priority 1: Extract from the 'servers' field in the spec
+                resolved_url = None
+                if hasattr(self.schema, "raw_schema"):
+                    servers = self.schema.raw_schema.get("servers", [])
+                    if servers and isinstance(servers, list) and len(servers) > 0:
+                        spec_server_url = servers[0].get("url")
+                        if spec_server_url:
+                            resolved_url = spec_server_url
+                            print(f"DEBUG: Found server URL in specification: {resolved_url}")
+                
+                # 3. Priority 2: Use whatever schemathesis resolved automatically (fallback)
+                if not resolved_url:
+                    resolved_url = getattr(self.schema, "base_url", None)
+                    print(f"DEBUG: Falling back to Schemathesis resolved base_url: {resolved_url}")
+
+                if not resolved_url and self.schema_url:
+                    # Fallback: Derive from schema_url (e.g., remove swagger.json)
+                    try:
+                        from urllib.parse import urlparse, urlunparse
+                        parsed = urlparse(self.schema_url)
+                        path_parts = parsed.path.split('/')
+                        # Simple heuristic: remove the last segment (e.g. swagger.json) to get base
+                        if '.' in path_parts[-1]: 
+                            path_parts.pop()
+                        new_path = '/'.join(path_parts)
+                        resolved_url = urlunparse(parsed._replace(path=new_path))
+                        print(f"DEBUG: Derived base_url from schema_url: {resolved_url}")
+                    except Exception as e:
+                        print(f"DEBUG: Failed to derive base_url from schema_url: {e}")
+
+                print(f"DEBUG: Final resolved base_url for engine: {resolved_url}")
+                
+                 # Fix base_url if it's localhost as well
+                if resolved_url and ("localhost" in resolved_url or "127.0.0.1" in resolved_url):
+                     print(f"DEBUG: Adjusting base_url '{resolved_url}' for Docker environment")
+                     resolved_url = resolved_url.replace("localhost", "host.docker.internal").replace("127.0.0.1", "host.docker.internal")
+
+                self.base_url = resolved_url
+                if resolved_url:
+                    try:
+                        self.schema.base_url = resolved_url
+                    except Exception:
+                         pass
+
+        except Exception as e:
+            if isinstance(e, AttributeError) and "base_url" in str(e):
+                 self.base_url = None
+            else:
+                raise ValueError(f"Failed to load OpenAPI schema from {schema_url}. Error: {str(e)}")
+
+    def run_drift_check(self) -> List[Dict]:
+        """
+        Module A: The 'Docs vs. Code' Drift Check (The Integrity Test)
+        Uses schemathesis to verify if the API implementation matches the spec.
+        """
+        results = []
+        # Mapping check names to actual functions
+        check_map = {
+            "not_a_server_error": checks.not_a_server_error,
+            "status_code_conformance": oai_checks.status_code_conformance,
+            "response_schema_conformance": oai_checks.response_schema_conformance
+        }
+        check_names = list(check_map.keys())
+        
+        # Schemathesis 4.x checks require a context object
+        checks_config = ChecksConfig()
+        check_ctx = CheckContext(
+            override=None,
+            auth=None,
+            headers=None,
+            config=checks_config,
+            transport_kwargs=None,
+        )
+        
+        for op in self.schema.get_all_operations():
+            # Handle Result type (Ok/Err) wrapping if present
+            operation = op.ok() if hasattr(op, "ok") else op
+            
+            operation_path = f"{operation.method.upper()} {operation.path}"
+            print(f"AUDIT LOG: Testing endpoint {operation_path}")
+            
+            try:
+                # Generate test case
+                try:
+                    case = operation.as_strategy().example()
+                except (AttributeError, Exception):
+                    try:
+                        cases = list(operation.make_case())
+                        case = cases[0] if cases else None
+                    except (AttributeError, Exception):
+                        case = None
+                
+                if not case:
+                    continue
+
+                # Prepare headers
+                headers = {}
+                if self.api_key:
+                    auth_header = self.api_key if self.api_key.lower().startswith("bearer ") else f"Bearer {self.api_key}"
+                    headers["Authorization"] = auth_header
+
+                # Call the API
+                target_url = f"{self.base_url.rstrip('/')}/{operation.path.lstrip('/')}"
+                print(f"AUDIT LOG: Calling {operation.method.upper()} {target_url}")
+                
+                response = case.call(base_url=self.base_url, headers=headers)
+                print(f"AUDIT LOG: Response Status Code: {response.status_code}")
+                
+                # --- FIXED VALIDATION LOGIC ---
+                # We manually call the check function to ensure arguments are passed correctly.
+                for check_name in check_names:
+                    check_func = check_map[check_name]
+                    try:
+                        # Direct call: check_func(ctx, response, case)
+                        check_func(check_ctx, response, case)
+                        
+                        # If we get here, the check passed
+                        results.append({
+                            "module": "A",
+                            "endpoint": f"{operation.method.upper()} {operation.path}",
+                            "issue": f"{check_name} - Passed",
+                            "status": "PASS",
+                            "severity": "INFO",
+                            "details": f"Status: {response.status_code}"
+                        })
+
+                    except AssertionError as e:
+                        # This catches actual drift (e.g., Schema validation failed)
+                        # Capture and format detailed error info
+                        validation_errors = []
+                        
+                        # Safely get causes if they exist and are iterable
+                        causes = getattr(e, "causes", None)
+                        if causes:
+                            for cause in causes:
+                                if hasattr(cause, "message"):
+                                    validation_errors.append(cause.message)
+                                else:
+                                    validation_errors.append(str(cause))
+                        
+                        if not validation_errors:
+                            validation_errors.append(str(e) or "Validation failed")
+                        
+                        err_msg = "<br>".join(validation_errors)
+                        safe_err = html.escape(err_msg)
+                        
+                        # Add helpful context (Status & Body Preview)
+                        context_msg = f"Status: {response.status_code}"
+                        try:
+                            if response.content:
+                                preview = response.text[:500]
+                                safe_preview = html.escape(preview)
+                                context_msg += f"<br>Response: {safe_preview}"
+                        except Exception:
+                            pass
+                            
+                        full_details = f"<strong>Error:</strong> {safe_err}<br><br><strong>Context:</strong><br>{context_msg}"
+
+                        print(f"AUDIT LOG: Validation {check_name} failed: {err_msg}")
+                        results.append({
+                            "module": "A",
+                            "endpoint": f"{operation.method.upper()} {operation.path}",
+                            "issue": f"Schema Drift Detected ({check_name})",
+                            "status": "FAIL",
+                            "details": full_details,
+                            "severity": "HIGH"
+                        })
+                    except Exception as e:
+                        # This catches unexpected coding errors
+                        print(f"AUDIT LOG: Error executing check {check_name}: {str(e)}")
+                        results.append({
+                            "module": "A",
+                            "endpoint": f"{operation.method.upper()} {operation.path}",
+                            "issue": f"Check Execution Error ({check_name})",
+                            "status": "FAIL",
+                            "details": str(e),
+                            "severity": "HIGH"
+                        })
+                        
+            except Exception as e:
+                print(f"AUDIT LOG: Critical Error during endpoint test: {str(e)}")
+                continue
+                
+        return results
+
+    def run_resilience_tests(self) -> List[Dict]:
+        """
+        Module B: The 'Resilience' Stress Test (Art. 24 & 25)
+        Checks for Rate Limiting and Timeout gracefully handling.
+        """
+        results = []
+        ops = list(self.schema.get_all_operations())
+        if not ops:
+            return []
+        
+        operation = ops[0].ok() if hasattr(ops[0], "ok") else ops[0]
+        
+        # Simulate flooding
+        responses = []
+        for _ in range(50): 
+            try:
+                case = operation.as_strategy().example()
+            except (AttributeError, Exception):
+                try:
+                    cases = list(operation.make_case())
+                    case = cases[0] if cases else None
+                except (AttributeError, Exception):
+                    case = None
+            
+            if case:
+                headers = {}
+                if self.api_key:
+                    auth_header = self.api_key if self.api_key.lower().startswith("bearer ") else f"Bearer {self.api_key}"
+                    headers["Authorization"] = auth_header
+                    
+                responses.append(case.call(base_url=self.base_url, headers=headers))
+        
+        has_429 = any(r.status_code == 429 for r in responses)
+        has_500 = any(r.status_code == 500 for r in responses)
+        
+        if not has_429 and has_500:
+            results.append({
+                "module": "B",
+                "issue": "Poor Resilience: 500 Error during flood",
+                "status": "FAIL",
+                "details": "The API returned 500 Internal Server Error instead of 429 Too Many Requests when flooded.",
+                "severity": "CRITICAL"
+            })
+        elif not has_429:
+             results.append({
+                "module": "B",
+                "issue": "No Rate Limiting Enforced",
+                "status": "FAIL",
+                "details": "The API did not return 429 Too Many Requests during high volume testing.",
+                "severity": "MEDIUM"
+            })
+        else:
+            results.append({
+                "module": "B",
+                "issue": "Rate Limiting Functional",
+                "status": "PASS",
+                "details": "The API correctly returned 429 Too Many Requests when flooded.",
+                "severity": "INFO"
+            })
+            
+        if not has_500:
+             results.append({
+                "module": "B",
+                "issue": "Stress Handling",
+                "status": "PASS",
+                "details": "No 500 Internal Server Errors were observed during stress testing.",
+                "severity": "INFO"
+            })
+
+        return results
+
+    def run_security_hygiene(self) -> List[Dict]:
+        """
+        Module C: Security Hygiene Check
+        Checks for TLS and Auth leakage in URL.
+        """
+        results = []
+        print(f"AUDIT LOG: Checking Security Hygiene for base URL: {self.base_url}")
+        if self.base_url and not self.base_url.startswith("https"):
+            results.append({
+                "module": "C",
+                "issue": "Insecure Connection (No TLS)",
+                "status": "FAIL",
+                "details": "The API base URL does not use HTTPS.",
+                "severity": "CRITICAL"
+            })
+        else:
+             results.append({
+                "module": "C",
+                "issue": "Secure Connection (TLS)",
+                "status": "PASS",
+                "details": "The API uses HTTPS.",
+                "severity": "INFO"
+            })
+        
+        auth_leakage_found = False
+        for op in self.schema.get_all_operations():
+            operation = op.ok() if hasattr(op, "ok") else op
+            endpoint = operation.path
+            if "key" in endpoint.lower() or "token" in endpoint.lower():
+                auth_leakage_found = True
+                results.append({
+                    "module": "C",
+                    "issue": "Auth Leakage Risk",
+                    "status": "FAIL",
+                    "details": f"Endpoint '{endpoint}' indicates auth tokens might be passed in the URL.",
+                    "severity": "HIGH"
+                })
+        
+        if not auth_leakage_found:
+            results.append({
+                "module": "C",
+                "issue": "No Auth Leakage in URLs",
+                "status": "PASS",
+                "details": "No endpoints found with 'key' or 'token' in the path, suggesting safe header-based auth.",
+                "severity": "INFO"
+            })
+        
+        return results
+
+    def run_full_audit(self) -> Dict:
+        return {
+            "drift_check": self.run_drift_check(),
+            "resilience": self.run_resilience_tests(),
+            "security": self.run_security_hygiene()
+        }

pandoraspec/reporting.py

@@ -0,0 +1,209 @@
+import os
+from datetime import datetime
+from jinja2 import Environment, FileSystemLoader
+from weasyprint import HTML
+
+TEMPLATE_DIR = os.path.join(os.path.dirname(__file__), "templates")
+REPORTS_DIR = "reports"
+
+if not os.path.exists(REPORTS_DIR):
+    os.makedirs(REPORTS_DIR)
+
+def generate_report(vendor_name: str, audit_results: dict) -> str:
+    """
+    Module D: The Compliance Report (The Deliverable)
+    Generates a branded PDF report.
+    """
+    # Calculate score (simple MVP logic)
+    # Filter out PASS results for scoring
+    drift_issues = [r for r in audit_results["drift_check"] if r.get("status") != "PASS"]
+    resilience_issues = [r for r in audit_results["resilience"] if r.get("status") != "PASS"]
+    security_issues = [r for r in audit_results["security"] if r.get("status") != "PASS"]
+
+    drift_score = max(0, 100 - len(drift_issues) * 10)
+    resilience_score = max(0, 100 - len(resilience_issues) * 15)
+    security_score = max(0, 100 - len(security_issues) * 20)
+    
+    total_score = (drift_score + resilience_score + security_score) / 3
+    
+    # Pass/Fail based on score
+    is_compliant = total_score >= 80
+
+    context = {
+        "vendor_name": vendor_name,
+        "date": datetime.now().strftime("%Y-%m-%d"),
+        "score": round(total_score),
+        "is_compliant": is_compliant,
+        "results": audit_results
+    }
+
+    # Helper to render findings tables
+    def render_findings_table(module_name, findings):
+        if not findings:
+            return f"<p class='no-issues'>✅ No issues found in {module_name}.</p>"
+        
+        rows = ""
+        for f in findings:
+            endpoint = f.get('endpoint', 'Global')
+            status = f.get('status', 'FAIL')
+            
+            if status == "PASS":
+                severity_class = "pass"
+                severity_text = "PASS"
+            else:
+                severity_class = f.get('severity', 'LOW').lower()
+                severity_text = f.get('severity')
+
+            rows += f"""
+            <tr>
+                <td><span class="badge badge-{severity_class}">{severity_text}</span></td>
+                <td><code>{endpoint}</code></td>
+                <td><strong>{f.get('issue')}</strong></td>
+                <td>{f.get('details')}</td>
+            </tr>
+            """
+        
+        return f"""
+        <table>
+            <thead>
+                <tr>
+                    <th style="width: 10%">Status</th>
+                    <th style="width: 25%">Endpoint</th>
+                    <th style="width: 25%">Issue</th>
+                    <th>Technical Details</th>
+                </tr>
+            </thead>
+            <tbody>
+                {rows}
+            </tbody>
+        </table>
+        """
+
+    html_content = f"""
+    <html>
+    <head>
+        <style>
+            @page {{ margin: 50px; }}
+            body {{ font-family: 'Inter', 'Helvetica Neue', Helvetica, Arial, sans-serif; color: #1e293b; line-height: 1.5; }}
+            .header {{ 
+                background: linear-gradient(135deg, #1e1b4b 0%, #4338ca 100%); 
+                color: white; 
+                padding: 40px; 
+                text-align: center; 
+                border-radius: 12px;
+                margin-bottom: 40px;
+            }}
+            .header h1 {{ margin: 0; font-size: 28px; letter-spacing: -0.5px; }}
+            .header p {{ margin: 10px 0 0; opacity: 0.8; font-size: 16px; }}
+            
+            .summary-grid {{ display: flex; justify-content: space-between; margin-bottom: 40px; }}
+            .summary-card {{ 
+                background: #f8fafc; 
+                padding: 20px; 
+                border-radius: 8px; 
+                width: 45%; 
+                border: 1px solid #e2e8f0;
+            }}
+            
+            .score-big {{ font-size: 56px; font-weight: 800; margin: 10px 0; }}
+            .status-badge {{ 
+                display: inline-block; 
+                padding: 6px 16px; 
+                border-radius: 99px; 
+                font-weight: 700; 
+                text-transform: uppercase;
+                font-size: 14px;
+            }}
+            .status-pass {{ background: #dcfce7; color: #166534; }}
+            .status-fail {{ background: #fee2e2; color: #991b1b; }}
+            
+            .section {{ margin-top: 40px; page-break-inside: avoid; }}
+            .section h3 {{ border-bottom: 2px solid #e2e8f0; padding-bottom: 10px; color: #0f172a; margin-bottom: 20px; }}
+            
+            table {{ width: 100%; border-collapse: collapse; margin-top: 10px; font-size: 12px; table-layout: fixed; word-wrap: break-word; }}
+            th, td {{ padding: 12px; text-align: left; border-bottom: 1px solid #e2e8f0; vertical-align: top; }}
+            td {{ word-break: break-word; white-space: pre-wrap; }}
+            th {{ background-color: #f1f5f9; color: #475569; font-weight: 600; text-transform: uppercase; letter-spacing: 0.5px; }}
+            
+            .badge {{ 
+                padding: 4px 8px; 
+                border-radius: 4px; 
+                font-size: 10px; 
+                font-weight: 700; 
+                color: white; 
+                text-transform: uppercase; 
+            }}
+            .badge-critical {{ background: #ef4444; }}
+            .badge-high {{ background: #f97316; }}
+            .badge-medium {{ background: #eab308; }}
+            .badge-low {{ background: #3b82f6; }}
+            .badge-pass {{ background: #16a34a; }}
+            
+            .no-issues {{ color: #059669; font-weight: 500; padding: 10px 0; }}
+            code {{ font-family: 'Courier New', monospace; background: #f1f5f9; padding: 2px 4px; border-radius: 3px; font-size: 11px; }}
+            
+            footer {{ margin-top: 50px; text-align: center; color: #94a3b8; font-size: 10px; border-top: 1px solid #e2e8f0; padding-top: 20px; }}
+        </style>
+    </head>
+    <body>
+        <div class="header">
+            <h1>DORA ICT Third-Party Risk Assessment</h1>
+            <p>Vendor Compliance Audit for <strong>{vendor_name}</strong></p>
+            <p>Report Date: {datetime.now().strftime("%B %d, %Y")}</p>
+        </div>
+
+        <div class="summary-grid">
+            <div class="summary-card">
+                <p style="margin:0; color:#64748b; font-weight:600;">Overall Risk Score</p>
+                <div class="score-big" style="color: {'#166534' if is_compliant else '#991b1b'}">{round(total_score)}<span style="font-size: 24px; color:#94a3b8; font-weight:400;">/100</span></div>
+            </div>
+            <div class="summary-card">
+                <p style="margin:0; color:#64748b; font-weight:600;">Compliance Status</p>
+                <div style="margin-top: 20px;">
+                    <span class="status-badge {'status-pass' if is_compliant else 'status-fail'}">
+                        {'COMPLIANT (PASS)' if is_compliant else 'NON-COMPLIANT (FAIL)'}
+                    </span>
+                </div>
+            </div>
+        </div>
+
+        <div class="section">
+            <h3>Technical Findings - Module A: Schema Integrity (Docs vs. Code)</h3>
+            <p style="font-size: 13px; color: #64748b; margin-bottom: 15px;">
+                This check verifies if the actual API implementation adheres to the provided OpenAPI specification.
+                Discrepancies here indicate "Schema Drift," which violates DORA requirements for accurate ICT documentation.
+            </p>
+            {render_findings_table("Module A", audit_results['drift_check'])}
+        </div>
+
+        <div class="section">
+            <h3>Technical Findings - Module B: Resilience Stress Test</h3>
+            <p style="font-size: 13px; color: #64748b; margin-bottom: 15px;">
+                Assesses high-load behavior and error handling (DORA Art. 24 & 25).
+                Checks if the system gracefully handles request flooding with appropriate 429 status codes.
+            </p>
+            {render_findings_table("Module B", audit_results['resilience'])}
+        </div>
+
+        <div class="section">
+            <h3>Technical Findings - Module C: Security Hygiene</h3>
+            <p style="font-size: 13px; color: #64748b; margin-bottom: 15px;">
+                Evaluates baseline security controls including TLS encryption and sensitive information leakage in URLs.
+            </p>
+            {render_findings_table("Module C", audit_results['security'])}
+        </div>
+
+        <footer>
+            <p>CONFIDENTIAL - FOR INTERNAL AUDIT PURPOSES ONLY</p>
+            <p>Generated by PanDoraSpec</p>
+        </footer>
+    </body>
+    </html>
+    """
+
+    filename = f"{vendor_name.replace(' ', '_')}_{datetime.now().strftime('%Y%m%d%H%M%S')}.pdf"
+    filepath = os.path.join(REPORTS_DIR, filename)
+    
+    HTML(string=html_content).write_pdf(filepath)
+    
+    return filepath

pandoraspec-0.1.1.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: pandoraspec
+Version: 0.1.1
+Summary: DORA Compliance Auditor for OpenAPI Specs
+Author-email: Ulises Merlan <ulimerlan@gmail.com>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi
+Requires-Dist: schemathesis==4.9.1
+Requires-Dist: typer[all]
+Requires-Dist: rich
+Requires-Dist: weasyprint
+Requires-Dist: jinja2
+Requires-Dist: requests
+
+# PanDoraSpec
+
+**The Open DORA Compliance Engine for OpenAPI Specs.**
+
+PanDoraSpec is a CLI tool that performs deep technical due diligence on your APIs to verify compliance with **DORA (Digital Operational Resilience Act)** requirements. It compares your OpenAPI/Swagger specifications against real-world implementation to detect schema drift, resilience gaps, and security issues.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install pandoraspec
+```
+
+## 🚀 Usage
+
+Run the audit directly from your terminal.
+
+### Basic Scan
+```bash
+pandoraspec https://petstore.swagger.io/v2/swagger.json
+```
+
+### With Options
+```bash
+pandoraspec https://api.example.com/spec.json --vendor "Stripe" --key "sk_live_..."
+```
+
+### Local File
+```bash
+pandoraspec ./openapi.yaml
+```
+
+---
+
+## 🛡️ What It Checks
+
+### Module A: The Integrity Test (Drift)
+Checks if your API implementation matches your documentation.
+- **Why?** DORA requires you to monitor if the service effectively supports your critical functions. If the API behaves differently than documented, it's a risk.
+
+### Module B: The Resilience Test
+Stress tests the API to ensure it handles invalid inputs gracefully (`4xx` vs `5xx`).
+- **Why?** DORA Article 25 calls for "Digital operational resilience testing".
+
+### Module C: Security Hygiene
+Checks for common security headers and configurations.
+
+### Module D: The Report
+Generates a branded PDF report: **"DORA ICT Third-Party Technical Risk Assessment"**.
+
+---
+
+## 📄 License
+
+MIT

pandoraspec-0.1.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+pandoraspec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandoraspec/cli.py,sha256=sJsVHMmQ_UHQf_lap--aLuf99_HUS_0rOAA5nTAxF54,3087
+pandoraspec/core.py,sha256=bKoPYSfqQa4Yn7CxOX6QPCZXCLMLoiagD8aMfzLtC6o,16059
+pandoraspec/reporting.py,sha256=aAFImWkhi5Ho6AQUCANJy-9MpIbzCJlsCWBSRmivOSQ,8804
+pandoraspec-0.1.1.dist-info/METADATA,sha256=-YMhZl-uwnYuBS64UhgYZrr0oQgluAqCOiZR-w5Jq8k,1892
+pandoraspec-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pandoraspec-0.1.1.dist-info/entry_points.txt,sha256=gmXGBQNpfy0IeOjB_SqunmaitLbyFsUZdgfwQOto2P0,52
+pandoraspec-0.1.1.dist-info/top_level.txt,sha256=8It7kimNf30-5ZUI7CZl6kCBeImIG8H49ZjSU26dRuc,12
+pandoraspec-0.1.1.dist-info/RECORD,,

pandoraspec-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pandoraspec-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pandoraspec = pandoraspec.cli:app

pandoraspec-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pandoraspec