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

runbooks/finops/helpers.py

@@ -35,10 +35,10 @@ styles = getSampleStyleSheet()
 def format_currency(amount) -> str:
     """
     Format currency for business display in notebooks.
-    
+
     Args:
         amount: Numeric amount to format
-        
+
     Returns:
         Formatted currency string
     """
@@ -56,162 +56,165 @@ def format_currency(amount) -> str:
 def create_business_summary_table(scenarios: Dict[str, Any], rich_console: Optional[Console] = None) -> str:
     """
     Create a business-friendly summary table for notebook display.
-    
+
     Args:
         scenarios: Dictionary of business scenarios
         rich_console: Optional Rich console for enhanced formatting
-        
+
     Returns:
         Formatted table string suitable for notebook display
     """
     output = []
-    
+
     # Header
     output.append("Business Case Summary")
     output.append("=" * 60)
     output.append(f"{'Scenario':<25} | {'Annual Savings':<15} | {'Status':<15}")
     output.append("-" * 60)
-    
+
     # Process scenarios
     for key, scenario in scenarios.items():
-        if key == 'metadata':
+        if key == "metadata":
             continue
-            
+
         # Extract scenario info
-        title = scenario.get('title', scenario.get('description', key))[:24]
-        
+        title = scenario.get("title", scenario.get("description", key))[:24]
+
         # Format savings
-        if 'actual_savings' in scenario:
-            savings = format_currency(scenario['actual_savings'])
-        elif 'savings_range' in scenario:
-            range_data = scenario['savings_range']
+        if "actual_savings" in scenario:
+            savings = format_currency(scenario["actual_savings"])
+        elif "savings_range" in scenario:
+            range_data = scenario["savings_range"]
             savings = f"{format_currency(range_data['min'])}-{format_currency(range_data['max'])}"
         else:
             savings = "Under investigation"
-        
+
         # Status
-        status = scenario.get('status', 'Analysis ready')[:14]
-        
+        status = scenario.get("status", "Analysis ready")[:14]
+
         output.append(f"{title:<25} | {savings:<15} | {status:<15}")
-    
+
     # Footer
-    if 'metadata' in scenarios:
+    if "metadata" in scenarios:
         output.append("-" * 60)
         output.append(f"Generated: {scenarios['metadata'].get('generated_at', 'Unknown')}")
         output.append(f"Source: {scenarios['metadata'].get('data_source', 'Unknown')}")
-    
+
     return "\n".join(output)
 
 
 def export_scenarios_to_notebook_html(scenarios: Dict[str, Any], title: str = "FinOps Analysis") -> str:
     """
     Export scenarios as HTML suitable for Jupyter notebook display.
-    
+
     Args:
         scenarios: Dictionary of business scenarios
         title: HTML document title
-        
+
     Returns:
         HTML string for notebook display
     """
     html = []
-    
+
     # HTML header
     html.append(f"""
     <div style="font-family: Arial, sans-serif; margin: 20px;">
     <h2 style="color: #2c5aa0;">{title}</h2>
     """)
-    
+
     # Process scenarios
     for key, scenario in scenarios.items():
-        if key == 'metadata':
+        if key == "metadata":
             continue
-            
-        title_text = scenario.get('title', scenario.get('description', key))
-        
+
+        title_text = scenario.get("title", scenario.get("description", key))
+
         html.append(f'<div style="border: 1px solid #ddd; margin: 10px 0; padding: 15px; border-radius: 5px;">')
         html.append(f'<h3 style="color: #1f4788; margin-top: 0;">{title_text}</h3>')
-        
+
         # Savings information
-        if 'actual_savings' in scenario:
-            savings = format_currency(scenario['actual_savings'])
-            html.append(f'<p><strong>💰 Annual Savings:</strong> {savings}</p>')
-        elif 'savings_range' in scenario:
-            range_data = scenario['savings_range']
-            min_savings = format_currency(range_data['min'])
-            max_savings = format_currency(range_data['max'])
-            html.append(f'<p><strong>💰 Annual Savings:</strong> {min_savings} - {max_savings}</p>')
+        if "actual_savings" in scenario:
+            savings = format_currency(scenario["actual_savings"])
+            html.append(f"<p><strong>💰 Annual Savings:</strong> {savings}</p>")
+        elif "savings_range" in scenario:
+            range_data = scenario["savings_range"]
+            min_savings = format_currency(range_data["min"])
+            max_savings = format_currency(range_data["max"])
+            html.append(f"<p><strong>💰 Annual Savings:</strong> {min_savings} - {max_savings}</p>")
         else:
-            html.append('<p><strong>💰 Annual Savings:</strong> Under investigation</p>')
-        
+            html.append("<p><strong>💰 Annual Savings:</strong> Under investigation</p>")
+
         # Implementation details
-        if 'implementation_time' in scenario:
-            html.append(f'<p><strong>⏱️ Implementation:</strong> {scenario["implementation_time"]}</p>')
-        
-        if 'risk_level' in scenario:
-            html.append(f'<p><strong>🛡️ Risk Level:</strong> {scenario["risk_level"]}</p>')
-        
-        html.append('</div>')
-    
+        if "implementation_time" in scenario:
+            html.append(f"<p><strong>⏱️ Implementation:</strong> {scenario['implementation_time']}</p>")
+
+        if "risk_level" in scenario:
+            html.append(f"<p><strong>🛡️ Risk Level:</strong> {scenario['risk_level']}</p>")
+
+        html.append("</div>")
+
     # Metadata footer
-    if 'metadata' in scenarios:
-        metadata = scenarios['metadata']
+    if "metadata" in scenarios:
+        metadata = scenarios["metadata"]
         html.append('<div style="margin-top: 20px; padding: 10px; background-color: #f8f9fa; border-radius: 5px;">')
-        html.append(f'<small><strong>Data Source:</strong> {metadata.get("data_source", "Unknown")}<br>')
-        html.append(f'<strong>Generated:</strong> {metadata.get("generated_at", "Unknown")}</small>')
-        html.append('</div>')
-    
-    html.append('</div>')
-    
-    return ''.join(html)
+        html.append(f"<small><strong>Data Source:</strong> {metadata.get('data_source', 'Unknown')}<br>")
+        html.append(f"<strong>Generated:</strong> {metadata.get('generated_at', 'Unknown')}</small>")
+        html.append("</div>")
+
+    html.append("</div>")
+
+    return "".join(html)
 
 
 def create_roi_analysis_table(business_cases: List[Dict[str, Any]]) -> str:
     """
     Create ROI analysis table for business decision making.
-    
+
     Args:
         business_cases: List of business case dictionaries
-        
+
     Returns:
         Formatted ROI analysis table
     """
     output = []
-    
+
     # Header
     output.append("ROI Analysis Summary")
     output.append("=" * 80)
     output.append(f"{'Business Case':<25} | {'Annual Savings':<12} | {'ROI %':<8} | {'Risk':<8} | {'Payback':<10}")
     output.append("-" * 80)
-    
+
     total_savings = 0
-    
+
     # Process business cases
     for case in business_cases:
-        title = case.get('title', 'Unknown Case')[:24]
-        
+        title = case.get("title", "Unknown Case")[:24]
+
         # Extract financial metrics
-        savings = case.get('annual_savings', case.get('actual_savings', 0))
-        roi = case.get('roi_percentage', 0)
-        risk = case.get('risk_level', 'Medium')[:7]
-        payback = case.get('payback_months', 0)
-        
+        savings = case.get("annual_savings", case.get("actual_savings", 0))
+        roi = case.get("roi_percentage", 0)
+        risk = case.get("risk_level", "Medium")[:7]
+        payback = case.get("payback_months", 0)
+
         # Format values
         savings_str = format_currency(savings)[:11]
         roi_str = f"{roi:.0f}%" if roi < 9999 else ">999%"
         payback_str = f"{payback:.1f}mo" if payback > 0 else "Immediate"
-        
+
         output.append(f"{title:<25} | {savings_str:<12} | {roi_str:<8} | {risk:<8} | {payback_str:<10}")
-        
+
         if isinstance(savings, (int, float)):
             total_savings += savings
-    
+
     # Summary
     output.append("-" * 80)
-    output.append(f"{'TOTAL PORTFOLIO':<25} | {format_currency(total_savings):<12} | {'N/A':<8} | {'Mixed':<8} | {'Varies':<10}")
-    
+    output.append(
+        f"{'TOTAL PORTFOLIO':<25} | {format_currency(total_savings):<12} | {'N/A':<8} | {'Mixed':<8} | {'Varies':<10}"
+    )
+
     return "\n".join(output)
 
+
 # Custom style for the footer
 audit_footer_style = ParagraphStyle(
     name="AuditFooter",
@@ -286,14 +289,14 @@ def export_audit_report_to_pdf(
             untagged_display = ""
             if row.get("untagged_count", 0) > 0:
                 # Format like reference: "EC2: us-east-1: i-1234567890"
-                account_id = row.get('account_id', 'unknown')
-                if account_id and account_id != 'unknown':
+                account_id = row.get("account_id", "unknown")
+                if account_id and account_id != "unknown":
                     untagged_display = f"EC2:\nus-east-1:\ni-{account_id[:10]}"
                 else:
                     untagged_display = f"EC2:\nus-east-1:\ni-unavailable"
                 if row.get("untagged_count", 0) > 1:
-                    account_id = row.get('account_id', 'unknown')
-                    if account_id and account_id != 'unknown':
+                    account_id = row.get("account_id", "unknown")
+                    if account_id and account_id != "unknown":
                         untagged_display += f"\n\nRDS:\nus-west-2:\ndb-{account_id[:10]}"
                     else:
                         untagged_display += f"\n\nRDS:\nus-west-2:\ndb-unavailable"
@@ -818,7 +821,9 @@ def export_cost_dashboard_to_markdown_legacy(
 
         # Footer
         markdown_lines.append("---")
-        markdown_lines.append("*Generated by CloudOps Runbooks FinOps Dashboard - Enterprise Cost Management Platform*")
+        markdown_lines.append(
+            "*Generated by CloudOps & FinOps Runbooks Dashboard - Enterprise Cost Management Platform*"
+        )
         markdown_lines.append("")
         markdown_lines.append(
             "For more information, visit: [CloudOps Documentation](https://github.com/1xOps/CloudOps-Runbooks)"
@@ -949,14 +954,36 @@ def export_cost_dashboard_to_pdf(
                 budget_limit = current_cost * 1.3  # 30% buffer
                 forecast = current_cost * 1.05  # 5% forecast increase
 
-                budget_name = f"{'DevOps' if 'dev' in profile_display else 'Production' if 'prod' in profile_display else 'QA'} Budget"
+                # Determine budget type for display
+                budget_type = "DevOps" if "dev" in profile_display else "Prod" if "prod" in profile_display else "QA"
+
+                # Calculate utilization for status determination
+                utilization = (current_cost / budget_limit) * 100 if budget_limit > 0 else 0
+
+                # Status icon based on utilization
+                if utilization >= 100:
+                    status_icon = "🚨"  # Over budget
+                elif utilization >= 85:
+                    status_icon = "⚠️"  # Near limit
+                elif utilization >= 70:
+                    status_icon = "🟡"  # Moderate usage
+                else:
+                    status_icon = "✅"  # Under budget
+
+                # Concise budget display with icons
+                budget_status = (
+                    f"{status_icon} {budget_type}\n💰 ${current_cost:.0f}/${budget_limit:.0f} ({utilization:.0f}%)"
+                )
 
-                budget_status = f"{budget_name}:\n\nLimit: ${budget_limit:.2f}\nActual: ${current_cost:.2f}\nForecast: ${forecast:.2f}"
+                # Add forecast only if significantly different
+                if abs(forecast - current_cost) > (current_cost * 0.05):  # 5% threshold
+                    trend_icon = "📈" if forecast > current_cost else "📉"
+                    budget_status += f"\n{trend_icon} Est: ${forecast:.0f}"
 
                 if len(data) > 2 and i == 2:  # Third row - show "No budgets found" like reference
-                    budget_status = "No budgets found.\nCreate a budget in the console."
+                    budget_status = "ℹ️  No budgets found\n💡 Create in console"
             else:
-                budget_status = "No budgets found.\nCreate a budget in the console."
+                budget_status = "ℹ️  No budgets found\n💡 Create in console"
 
             # Format EC2 instances like reference
             ec2_summary = ""
@@ -1108,192 +1135,9 @@ def load_config_file(file_path: str) -> Optional[Dict[str, Any]]:
         return None
 
 
-def generate_pdca_improvement_report(
-    pdca_metrics: List[Dict[str, Any]], file_name: str = "pdca_improvement", path: Optional[str] = None
-) -> Optional[str]:
-    """
-    Generate PDCA (Plan-Do-Check-Act) continuous improvement report.
-
-    :param pdca_metrics: List of PDCA metrics for each profile
-    :param file_name: The base name of the output file
-    :param path: Optional directory where the file will be saved
-    :return: Full path of the generated report or None on error
-    """
-    try:
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M")
-        base_filename = f"{file_name}_pdca_report_{timestamp}.json"
-
-        if path:
-            os.makedirs(path, exist_ok=True)
-            output_filename = os.path.join(path, base_filename)
-        else:
-            output_filename = base_filename
-
-        # Calculate aggregate metrics
-        total_risk = sum(m["risk_score"] for m in pdca_metrics)
-        avg_risk = total_risk / len(pdca_metrics) if pdca_metrics else 0
-
-        high_risk_accounts = [m for m in pdca_metrics if m["risk_score"] > 25]
-        medium_risk_accounts = [m for m in pdca_metrics if 10 < m["risk_score"] <= 25]
-        low_risk_accounts = [m for m in pdca_metrics if m["risk_score"] <= 10]
-
-        total_untagged = sum(m["untagged_count"] for m in pdca_metrics)
-        total_stopped = sum(m["stopped_count"] for m in pdca_metrics)
-        total_unused_volumes = sum(m["unused_volumes_count"] for m in pdca_metrics)
-        total_unused_eips = sum(m["unused_eips_count"] for m in pdca_metrics)
-        total_budget_overruns = sum(m["budget_overruns"] for m in pdca_metrics)
-
-        # Generate improvement recommendations
-        recommendations = []
-
-        # PLAN phase recommendations
-        if total_untagged > 50:
-            recommendations.append(
-                {
-                    "phase": "PLAN",
-                    "priority": "HIGH",
-                    "category": "Compliance",
-                    "issue": f"Found {total_untagged} untagged resources across all accounts",
-                    "action": "Implement mandatory tagging strategy using AWS Config rules",
-                    "expected_outcome": "100% resource compliance within 30 days",
-                    "owner": "Cloud Governance Team",
-                }
-            )
-
-        if total_unused_eips > 5:
-            recommendations.append(
-                {
-                    "phase": "PLAN",
-                    "priority": "MEDIUM",
-                    "category": "Cost Optimization",
-                    "issue": f"Found {total_unused_eips} unused Elastic IPs",
-                    "action": "Schedule monthly EIP cleanup automation",
-                    "expected_outcome": f"Save ~${total_unused_eips * 3.65:.2f}/month",
-                    "owner": "FinOps Team",
-                }
-            )
-
-        # DO phase recommendations
-        if high_risk_accounts:
-            recommendations.append(
-                {
-                    "phase": "DO",
-                    "priority": "CRITICAL",
-                    "category": "Risk Management",
-                    "issue": f"{len(high_risk_accounts)} accounts have critical risk scores",
-                    "action": "Execute immediate remediation on high-risk accounts",
-                    "expected_outcome": "Reduce risk scores by 70% within 2 weeks",
-                    "owner": "Security Team",
-                }
-            )
-
-        # CHECK phase recommendations
-        if avg_risk > 15:
-            recommendations.append(
-                {
-                    "phase": "CHECK",
-                    "priority": "HIGH",
-                    "category": "Monitoring",
-                    "issue": f"Average risk score ({avg_risk:.1f}) exceeds threshold",
-                    "action": "Implement automated risk scoring dashboard",
-                    "expected_outcome": "Real-time risk visibility and alerting",
-                    "owner": "DevOps Team",
-                }
-            )
-
-        # ACT phase recommendations
-        recommendations.append(
-            {
-                "phase": "ACT",
-                "priority": "MEDIUM",
-                "category": "Process Improvement",
-                "issue": "Need continuous improvement framework",
-                "action": "Establish monthly PDCA review cycles",
-                "expected_outcome": "25% reduction in average risk score per quarter",
-                "owner": "Cloud Center of Excellence",
-            }
-        )
-
-        # Create comprehensive PDCA report
-        pdca_report = {
-            "report_metadata": {
-                "generated_at": datetime.now().isoformat(),
-                "report_type": "PDCA Continuous Improvement Analysis",
-                "accounts_analyzed": len(pdca_metrics),
-                "framework_version": "v1.0",
-            },
-            "executive_summary": {
-                "overall_risk_score": total_risk,
-                "average_risk_score": round(avg_risk, 2),
-                "risk_distribution": {
-                    "critical_accounts": len(high_risk_accounts),
-                    "high_risk_accounts": len(medium_risk_accounts),
-                    "low_risk_accounts": len(low_risk_accounts),
-                },
-                "key_findings": {
-                    "untagged_resources": total_untagged,
-                    "stopped_instances": total_stopped,
-                    "unused_volumes": total_unused_volumes,
-                    "unused_elastic_ips": total_unused_eips,
-                    "budget_overruns": total_budget_overruns,
-                },
-            },
-            "pdca_analysis": {
-                "plan_phase": {
-                    "description": "Strategic planning based on current state analysis",
-                    "metrics_collected": len(pdca_metrics),
-                    "baseline_established": True,
-                },
-                "do_phase": {
-                    "description": "Implementation of audit data collection",
-                    "data_sources": ["EC2", "RDS", "Lambda", "ELBv2", "Budgets"],
-                    "regions_scanned": "All accessible regions",
-                },
-                "check_phase": {
-                    "description": "Analysis of collected audit data",
-                    "risk_assessment_completed": True,
-                    "trends_identified": True,
-                },
-                "act_phase": {
-                    "description": "Actionable recommendations for improvement",
-                    "recommendations_generated": len(recommendations),
-                    "prioritization_completed": True,
-                },
-            },
-            "detailed_metrics": pdca_metrics,
-            "improvement_recommendations": recommendations,
-            "next_steps": {
-                "immediate_actions": [
-                    "Review high-risk accounts within 48 hours",
-                    "Implement automated tagging for untagged resources",
-                    "Schedule EIP cleanup automation",
-                ],
-                "medium_term_goals": [
-                    "Establish monthly PDCA review cycle",
-                    "Implement risk scoring dashboard",
-                    "Create automated remediation workflows",
-                ],
-                "long_term_objectives": [
-                    "Achieve average risk score below 5",
-                    "Maintain 100% resource compliance",
-                    "Reduce cloud waste by 25%",
-                ],
-            },
-        }
-
-        # Export to JSON
-        with open(output_filename, "w", encoding="utf-8") as jsonfile:
-            json.dump(pdca_report, jsonfile, indent=4, default=str)
-
-        return os.path.abspath(output_filename)
-
-    except Exception as e:
-        console.print(f"[bold red]Error generating PDCA improvement report: {str(e)}[/]")
-        return None
-
-
-def export_scenario_results(results: Dict[str, Any], scenario_name: str,
-                           report_types: List[str], output_dir: Optional[str] = None) -> bool:
+def export_scenario_results(
+    results: Dict[str, Any], scenario_name: str, report_types: List[str], output_dir: Optional[str] = None
+) -> bool:
     """
     Export business scenario results in specified formats.
 
@@ -1307,7 +1151,7 @@ def export_scenario_results(results: Dict[str, Any], scenario_name: str,
         True if all exports succeeded
     """
     try:
-        from runbooks.common.rich_utils import print_success, print_error, print_info
+        from runbooks.common.rich_utils import print_error, print_info, print_success
 
         output_dir = output_dir or "."
         base_filename = f"finops-scenario-{scenario_name}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
@@ -1317,64 +1161,62 @@ def export_scenario_results(results: Dict[str, Any], scenario_name: str,
 
         for report_type in report_types:
             try:
-                if report_type == 'json':
+                if report_type == "json":
                     output_path = os.path.join(output_dir, f"{base_filename}.json")
-                    with open(output_path, 'w', encoding='utf-8') as f:
+                    with open(output_path, "w", encoding="utf-8") as f:
                         json.dump(results, f, indent=2, default=str)
                     print_info(f"📄 JSON export: {output_path}")
 
-                elif report_type == 'csv':
+                elif report_type == "csv":
                     output_path = os.path.join(output_dir, f"{base_filename}.csv")
                     # Extract key metrics for CSV export
-                    if 'business_impact' in results:
-                        business_data = results['business_impact']
-                        with open(output_path, 'w', newline='', encoding='utf-8') as f:
+                    if "business_impact" in results:
+                        business_data = results["business_impact"]
+                        with open(output_path, "w", newline="", encoding="utf-8") as f:
                             writer = csv.DictWriter(f, fieldnames=business_data.keys())
                             writer.writeheader()
                             writer.writerow(business_data)
                     print_info(f"📊 CSV export: {output_path}")
 
-                elif report_type == 'pdf':
+                elif report_type == "pdf":
                     output_path = os.path.join(output_dir, f"{base_filename}.pdf")
                     # Create basic PDF with scenario results
                     doc = SimpleDocTemplate(output_path, pagesize=letter)
                     story = []
 
                     # Title
-                    title = Paragraph(f"FinOps Business Scenario: {scenario_name.title()}",
-                                    styles['Heading1'])
+                    title = Paragraph(f"FinOps Business Scenario: {scenario_name.title()}", styles["Heading1"])
                     story.append(title)
                     story.append(Spacer(1, 12))
 
                     # Add results summary
-                    if 'business_impact' in results:
-                        business_data = results['business_impact']
+                    if "business_impact" in results:
+                        business_data = results["business_impact"]
                         for key, value in business_data.items():
-                            text = Paragraph(f"<b>{key.replace('_', ' ').title()}:</b> {value}",
-                                           styles['Normal'])
+                            text = Paragraph(f"<b>{key.replace('_', ' ').title()}:</b> {value}", styles["Normal"])
                             story.append(text)
 
                     doc.build(story)
                     print_info(f"📋 PDF export: {output_path}")
 
-                elif report_type == 'markdown':
+                elif report_type == "markdown":
                     output_path = os.path.join(output_dir, f"{base_filename}.md")
-                    with open(output_path, 'w', encoding='utf-8') as f:
+                    with open(output_path, "w", encoding="utf-8") as f:
                         f.write(f"# FinOps Business Scenario: {scenario_name.title()}\n\n")
                         f.write(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
 
                         # Add business impact section
-                        if 'business_impact' in results:
+                        if "business_impact" in results:
                             f.write("## Business Impact\n\n")
-                            business_data = results['business_impact']
+                            business_data = results["business_impact"]
                             for key, value in business_data.items():
                                 f.write(f"- **{key.replace('_', ' ').title()}**: {value}\n")
                             f.write("\n")
 
                         # Add technical details section
-                        if 'technical_details' in results:
+                        if "technical_details" in results:
                             f.write("## Technical Details\n\n")
-                            tech_data = results['technical_details']
+                            tech_data = results["technical_details"]
                             for key, value in tech_data.items():
                                 f.write(f"- **{key.replace('_', ' ').title()}**: {value}\n")
 

runbooks/finops/iam_guidance.py

@@ -313,7 +313,7 @@ def handle_cost_explorer_error(error: Exception, profile_name: Optional[str] = N
 
 def _display_single_account_cost_explorer_guidance(error: Exception, profile_name: Optional[str] = None):
     """Display context-aware guidance for single account Cost Explorer limitations."""
-    
+
     # Get dynamic date period for CLI examples
     start_date, end_date = get_aws_cli_example_period()