#!/usr/bin/env python3 """ OCI Deal Accelerator — Business Case Deck Generator (.pptx) Produces an 8-10 slide business case deck using the Oracle FY26 official PowerPoint template layouts. Target audience: customer CxO / decision-makers. Usage: python oci_bizcase_gen.py --spec business-case.yaml --output business-case.pptx Or import and use programmatically: from oci_bizcase_gen import BusinessCaseDeckGenerator gen = BusinessCaseDeckGenerator.from_spec(spec) gen.save("business-case.pptx") """ import yaml import argparse import re from datetime import datetime from pathlib import Path from typing import Optional, List, Dict from pptx.util import Inches, Pt from pptx.dml.color import RGBColor from pptx.enum.text import PP_ALIGN from pptx.enum.shapes import MSO_SHAPE, MSO_CONNECTOR from pptx.chart.data import ChartData from pptx.enum.chart import XL_CHART_TYPE, XL_LEGEND_POSITION try: from oci_pptx_base import Colors, Layouts, OraclePresBase from oci_business_case_model import ( enrich_adbs_to_adbd_business_case, write_bom_outputs, ) from pptx_validator import validate_pptx except ModuleNotFoundError: from tools.oci_pptx_base import Colors, Layouts, OraclePresBase from tools.oci_business_case_model import ( enrich_adbs_to_adbd_business_case, write_bom_outputs, ) from tools.pptx_validator import validate_pptx # ============================================================ # Defensive input helpers # ============================================================ def pick(mapping: dict, *keys, default=""): """Return the first non-empty value for any of the provided keys.""" if not isinstance(mapping, dict): return default for key in keys: if key in mapping: value = mapping.get(key) if value is not None: return value return default def pick_list(mapping: dict, *keys): """Return the first list-like field normalized to a list.""" if not isinstance(mapping, dict): return [] for key in keys: if key in mapping: value = mapping.get(key) if value is None: return [] if isinstance(value, list): return value return [value] return [] def _timeline_to_weeks(text: str) -> int | None: """Parse a simple duration phrase like '12 weeks' or '6 months'.""" if not text: return None value = str(text).lower() match = re.search(r"(\d+)\s*(week|weeks|month|months)", value) if not match: return None amount = int(match.group(1)) unit = match.group(2) return amount * 4 if unit.startswith("month") else amount def _extract_business_case_text(bc: dict) -> str: parts = [ pick(bc, "executive_summary", "summary"), pick(bc, "primary_driver", "main_driver"), ] drivers = bc.get("drivers", {}) if isinstance(drivers, dict): parts.extend([ pick(drivers, "primary", "primary_driver", "main_driver"), pick(drivers, "urgency", "why_now"), ]) coi = drivers.get("cost_of_inaction", {}) or {} if isinstance(coi, dict): parts.extend(coi.values()) return " ".join(str(p) for p in parts if p) def _infer_driver_headline(text: str) -> str: lowered = text.lower() if any(token in lowered for token in ("budget", "cost", "tco", "license", "refresh")): return "Reduce cost and avoid infrastructure refresh" if any(token in lowered for token in ("dr", "disaster recovery", "resilien", "rto", "rpo")): return "Improve resilience and business continuity" if any(token in lowered for token in ("pci", "regulator", "compliance", "data residency", "sovereignty")): return "Address compliance and sovereignty requirements" return "Modernize the platform on OCI" def _infer_driver_objective(text: str) -> str: """Return a noun phrase suitable for recommendation prose.""" lowered = text.lower() if any(token in lowered for token in ("budget", "cost", "tco", "license", "refresh")): return "the cost-reduction and refresh-avoidance case" if any(token in lowered for token in ("dr", "disaster recovery", "resilien", "rto", "rpo")): return "the resilience and business-continuity posture" if any(token in lowered for token in ("pci", "regulator", "compliance", "data residency", "sovereignty")): return "the compliance and sovereignty position" return "the OCI modernization approach" def _infer_business_case_drivers(text: str) -> dict: headline = _infer_driver_headline(text) urgency = "Use the current planning window to validate scope, commercials, and delivery readiness." if _timeline_to_weeks(text): urgency = f"Align the case with the stated delivery window ({_timeline_to_weeks(text)} weeks)." return { "primary": headline, "urgency": urgency, "cost_of_inaction": { "financial": "Continuing with the current platform preserves avoidable run costs and refresh exposure.", "operational": "The delivery team keeps spending time on manual operations instead of modernization work.", "strategic": "Delaying the decision extends technical debt and slows business change.", }, } def _infer_business_case_risks(text: str) -> dict: lowered = text.lower() migration = [ { "risk": "Migration scope may be larger than the initial discovery captured.", "mitigation": "Baseline applications, data stores, and dependencies before locking the plan.", }, { "risk": "Operating model changes may require team enablement before go-live.", "mitigation": "Define the target RACI and training plan during design.", }, ] if any(token in lowered for token in ("dr", "disaster recovery", "rto", "rpo")): migration.append({ "risk": "Resilience objectives may require rehearsal and explicit runbooks.", "mitigation": "Schedule failover validation before production cutover.", }) do_nothing = [ { "risk": "Technical debt and platform constraints continue to accumulate.", "impact": "Higher delivery risk and slower response to business demand.", }, { "risk": "Commercial and capacity assumptions remain unvalidated.", "impact": "Procurement or renewal decisions may be made without a current baseline.", }, ] return { "migration_risks": migration[:4], "do_nothing_risks": do_nothing[:4], } def _infer_business_case_roadmap(text: str) -> dict: total_weeks = _timeline_to_weeks(text) if total_weeks and total_weeks >= 6: define = max(1, round(total_weeks * 0.25)) design = max(1, round(total_weeks * 0.35)) deliver = max(1, total_weeks - define - design) total_duration = f"{total_weeks} weeks" else: define, design, deliver = 2, 4, 6 total_duration = "12 weeks (to validate)" return { "total_duration": total_duration, "phases": [ { "name": "Define", "duration": f"{define} weeks", "deliverables": ["Scope baseline", "Business case validation"], "milestones": ["Stakeholder alignment"], }, { "name": "Design", "duration": f"{design} weeks", "deliverables": ["Target architecture", "Security and operating model"], "milestones": ["Design sign-off"], }, { "name": "Deliver", "duration": f"{deliver} weeks", "deliverables": ["Migration execution", "Cutover and stabilization"], "milestones": ["Go-live readiness"], }, ], } def _infer_business_case_recommendation(text: str) -> dict: objective = _infer_driver_objective(text) return { "summary": f"Proceed to detailed design on OCI to validate {objective} with customer-specific sizing and commercials.", "next_steps": [ "Confirm scope, current-state baseline, and success criteria.", "Validate commercials, licensing assumptions, and target delivery model.", "Run a design workshop and prepare the first migration wave.", ], } def _enrich_sparse_business_case(spec: dict) -> dict: """Fill safe narrative sections so sparse business cases still render professionally.""" if not isinstance(spec, dict): return spec bc = spec.get("business_case", spec) if not isinstance(bc, dict): return spec text = _extract_business_case_text(bc) if not text.strip(): return spec enriched_bc = dict(bc) if "drivers" not in enriched_bc: enriched_bc["drivers"] = _infer_business_case_drivers(text) if "risks" not in enriched_bc: enriched_bc["risks"] = _infer_business_case_risks(text) if "roadmap" not in enriched_bc: enriched_bc["roadmap"] = _infer_business_case_roadmap(text) if "recommendation" not in enriched_bc: enriched_bc["recommendation"] = _infer_business_case_recommendation(text) if "business_case" in spec: enriched = dict(spec) enriched["business_case"] = enriched_bc return enriched return enriched_bc # ============================================================ # Business Case Deck Generator # ============================================================ class BusinessCaseDeckGenerator(OraclePresBase): """Generate business case decks using Oracle FY26 template layouts.""" # Use Teal accent for business case slides (finance / CxO audience) TITLE_ACCENT_COLOR = Colors.TEAL # ================================================================ # Slide Methods # ================================================================ def add_cover_slide(self, customer: str, subtitle: str = "", prepared_by: str = "", date: str = "", prepared_by_role: str = ""): """Slide 1: Cover using Dark Title_Pillar layout.""" slide = self._add_layout_slide(Layouts.COVER_DARK) self._set_placeholder(slide, 0, customer) # Title self._set_placeholder(slide, 33, subtitle or "Business Case for Oracle Cloud Infrastructure") date_str = date or datetime.now().strftime("%B %Y") self._set_placeholder(slide, 35, date_str) if prepared_by: byline = f"{prepared_by}, {prepared_by_role}" if prepared_by_role else prepared_by self._set_placeholder(slide, 34, f"Prepared by: {byline}") def add_executive_summary_slide(self, statement: str): """Slide 2: Executive Summary — controlled typography on blank slide.""" slide = self._add_blank_slide() self._add_title_bar(slide, "Executive Summary") # Body — large enough to read, small enough to fit the paragraph body_box = slide.shapes.add_textbox(Inches(0.8), Inches(1.3), Inches(11.7), Inches(4.5)) tf = body_box.text_frame tf.word_wrap = True p = tf.paragraphs[0] p.text = statement p.font.size = Pt(18) p.font.name = self.FONT p.font.color.rgb = Colors.PRIMARY_TEXT p.space_after = Pt(6) def add_business_drivers_slide(self, drivers: list): """Slide 3: Business Drivers — numbered cards on blank slide. drivers: list of up to 3 strings, each a driver statement (may include newline separating a bold headline from detail text). """ slide = self._add_blank_slide() self._add_title_bar(slide, "Business Drivers") card_colors = [Colors.TEAL, Colors.BURNT_ORANGE, Colors.FOREST] card_y_start = Inches(1.3) available_h = Inches(5.8) n = min(len(drivers), 3) card_h = available_h / n if n else available_h card_h = min(card_h, Inches(2.1)) for i, driver in enumerate(drivers[:3]): color = card_colors[i % len(card_colors)] y = card_y_start + i * card_h # Left accent bar accent = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, Inches(0.8), y + Inches(0.1), Inches(0.08), card_h - Inches(0.2)) accent.fill.solid() accent.fill.fore_color.rgb = color accent.line.fill.background() # Number badge self._add_textbox( slide, Inches(1.05), y + Inches(0.12), Inches(0.5), Inches(0.45), text=f"0{i+1}", font_size=18, bold=True, color=color, ) # Split driver into headline + detail (split on \n if present) parts = driver.split("\n", 1) headline = parts[0].strip() detail = parts[1].strip() if len(parts) > 1 else "" # Headline self._add_textbox( slide, Inches(1.6), y + Inches(0.1), Inches(11.0), Inches(0.5), text=headline, font_size=15, bold=True, color=Colors.PRIMARY_TEXT, ) # Detail if detail: self._add_textbox( slide, Inches(1.6), y + Inches(0.6), Inches(11.0), card_h - Inches(0.75), text=detail, font_size=13, color=Colors.SECONDARY_TEXT, ) def add_tco_slide(self, tco: dict): """Slide 4: TCO Comparison — table on blank slide. tco: dict from business-case.yaml with current_state and proposed_oci. """ slide = self._add_blank_slide() self._add_title_bar(slide, "Total Cost of Ownership") # Subtitle horizon = tco.get("horizon_years", 3) self._add_textbox( slide, Inches(0.8), Inches(1.1), Inches(11), Inches(0.4), text=tco.get("comparison_label", f"{horizon}-Year Comparison | Current State vs Oracle Cloud Infrastructure"), font_size=13, color=Colors.TEAL, bold=True, ) current = tco.get("current_state", {}) proposed = tco.get("proposed_oci", {}) savings = tco.get("savings", {}) ann_current = current.get("total_annual", 0) ann_oci = proposed.get("total_annual", 0) ann_savings = savings.get("annual", 0) or (ann_current - ann_oci) monthly_current = ann_current / 12 if ann_current else 0 monthly_oci = ann_oci / 12 if ann_oci else 0 kpi_labels = tco.get("kpi_labels", {}) if isinstance(tco.get("kpi_labels", {}), dict) else {} kpis = [ (f"${monthly_current:,.0f}/mo", kpi_labels.get("current", "Current state")), (f"${monthly_oci:,.0f}/mo", kpi_labels.get("proposed", "Proposed OCI")), (f"${abs(ann_savings) / 12:,.0f}/mo", kpi_labels.get("delta", "Monthly delta")), ] for idx, (value, label) in enumerate(kpis): x = Inches(0.8 + idx * 4.0) box = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, x, Inches(1.55), Inches(3.65), Inches(1.0)) box.fill.solid() box.fill.fore_color.rgb = Colors.TABLE_ALT_ROW box.line.color.rgb = Colors.MUTED_TEAL self._add_textbox(slide, x + Inches(0.15), Inches(1.68), Inches(3.35), Inches(0.4), text=value, font_size=20, bold=True, color=Colors.TEAL, alignment=PP_ALIGN.CENTER) self._add_textbox(slide, x + Inches(0.15), Inches(2.08), Inches(3.35), Inches(0.28), text=label, font_size=10, color=Colors.SECONDARY_TEXT, alignment=PP_ALIGN.CENTER) row_labels = tco.get("row_labels", {}) if isinstance(tco.get("row_labels", {}), dict) else {} rows_data = [ (row_labels.get("infrastructure", "Infrastructure"), current.get("annual_infrastructure", 0), proposed.get("annual_cloud_consumption", 0)), ("Licensing / Support", current.get("annual_licensing", 0), proposed.get("annual_licensing", 0)), ("Operations (People)", current.get("annual_operations", 0), proposed.get("annual_operations", 0)), ("Downtime Cost", current.get("annual_downtime_cost", 0), proposed.get("annual_downtime_cost", 0)), ("Compliance", current.get("annual_compliance_cost", 0), proposed.get("annual_compliance_cost", 0)), ] # Filter out zero rows rows_data = [(n, c, o) for n, c, o in rows_data if c or o] # Add migration one-time migration = proposed.get("migration_one_time", 0) num_rows = len(rows_data) + 3 # header + rows + annual total + horizon total table_top = Inches(3.0) table = self._add_table( slide, num_rows, 4, Inches(0.8), table_top, Inches(11.7), Inches(0.42 * num_rows), ) table.columns[0].width = Inches(3.5) table.columns[1].width = Inches(2.7) table.columns[2].width = Inches(2.7) table.columns[3].width = Inches(2.8) # Header column_labels = tco.get("column_labels", {}) if isinstance(tco.get("column_labels", {}), dict) else {} headers = [ "Cost Category", column_labels.get("current", "Current (Annual)"), column_labels.get("proposed", "OCI (Annual)"), column_labels.get("delta", "Savings"), ] for j, h in enumerate(headers): self._style_table_cell( table.cell(0, j), h, font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.TEAL, alignment=PP_ALIGN.CENTER if j > 0 else PP_ALIGN.LEFT, ) # Data rows for i, (name, curr, oci) in enumerate(rows_data): row = i + 1 bg = Colors.TABLE_ALT_ROW if row % 2 == 0 else None curr_val = curr if isinstance(curr, (int, float)) else 0 oci_val = oci if isinstance(oci, (int, float)) else 0 save_val = curr_val - oci_val self._style_table_cell(table.cell(row, 0), name, font_size=10, bg_color=bg) self._style_table_cell(table.cell(row, 1), f"${curr_val:,.0f}", font_size=10, bg_color=bg, alignment=PP_ALIGN.RIGHT) self._style_table_cell(table.cell(row, 2), f"${oci_val:,.0f}", font_size=10, bg_color=bg, alignment=PP_ALIGN.RIGHT) save_color = Colors.SUCCESS if save_val > 0 else Colors.ERROR self._style_table_cell(table.cell(row, 3), f"${save_val:,.0f}", font_size=10, bold=True, color=save_color, bg_color=bg, alignment=PP_ALIGN.RIGHT) # Annual total row total_row = len(rows_data) + 1 ann_current = ann_current or sum(r[1] for r in rows_data if isinstance(r[1], (int, float))) ann_oci = ann_oci or sum(r[2] for r in rows_data if isinstance(r[2], (int, float))) ann_savings = ann_savings or (ann_current - ann_oci) self._style_table_cell(table.cell(total_row, 0), "TOTAL ANNUAL", font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.TEAL) self._style_table_cell(table.cell(total_row, 1), f"${ann_current:,.0f}", font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.TEAL, alignment=PP_ALIGN.RIGHT) self._style_table_cell(table.cell(total_row, 2), f"${ann_oci:,.0f}", font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.TEAL, alignment=PP_ALIGN.RIGHT) self._style_table_cell(table.cell(total_row, 3), f"${ann_savings:,.0f}", font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.TEAL, alignment=PP_ALIGN.RIGHT) # Horizon total row h_row = total_row + 1 h_current = current.get("total_over_horizon", 0) or (ann_current * horizon) h_oci = proposed.get("total_over_horizon", 0) or (ann_oci * horizon + migration) h_savings = savings.get("over_horizon", 0) or (h_current - h_oci) pct = savings.get("percentage", 0) or (h_savings / h_current * 100 if h_current else 0) self._style_table_cell(table.cell(h_row, 0), f"TOTAL {horizon}-YEAR", font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.DARK_BG) self._style_table_cell(table.cell(h_row, 1), f"${h_current:,.0f}", font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.DARK_BG, alignment=PP_ALIGN.RIGHT) self._style_table_cell(table.cell(h_row, 2), f"${h_oci:,.0f}", font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.DARK_BG, alignment=PP_ALIGN.RIGHT) self._style_table_cell(table.cell(h_row, 3), f"${h_savings:,.0f} ({pct:.0f}%)", font_size=11, bold=True, color=Colors.GOLD, bg_color=Colors.DARK_BG, alignment=PP_ALIGN.RIGHT) # Migration note if migration: note_y = table_top + Inches(0.42 * num_rows) + Inches(0.15) self._add_textbox( slide, Inches(0.8), note_y, Inches(11), Inches(0.3), text=f"* Includes one-time migration investment of ${migration:,.0f} in Year 1", font_size=9, italic=True, color=Colors.SECONDARY_TEXT, ) # Assumptions assumptions = tco.get("assumptions", []) if assumptions: a_y = table_top + Inches(0.42 * num_rows) + Inches(0.45) self._add_textbox( slide, Inches(0.8), a_y, Inches(11), Inches(0.25), text="Assumptions:", font_size=9, bold=True, color=Colors.SECONDARY_TEXT, ) for idx, a in enumerate(assumptions[:7]): self._add_textbox( slide, Inches(1.0), a_y + Inches(0.25 + idx * 0.22), Inches(11), Inches(0.22), text=f"• {a}", font_size=7, italic=True, color=Colors.SECONDARY_TEXT, ) def add_roi_slide(self, roi: dict, headline: str = ""): """Slide 5: ROI — centered big number + 3 supporting metrics.""" slide = self._add_blank_slide() self._add_title_bar(slide, "Return on Investment") cards = roi.get("cards", []) if cards: metric_text = headline or pick(roi, "headline", default="ROI logic") self._add_textbox( slide, Inches(0.8), Inches(1.15), Inches(11.7), Inches(0.62), text=metric_text, font_size=34, bold=True, color=Colors.TEAL, alignment=PP_ALIGN.CENTER, ) summary = pick(roi, "label", "summary") if summary: self._add_textbox( slide, Inches(1.0), Inches(1.82), Inches(11.3), Inches(0.5), text=summary, font_size=13, color=Colors.SECONDARY_TEXT, alignment=PP_ALIGN.CENTER, ) card_w = Inches(3.65) card_h = Inches(2.25) gap = Inches(0.35) x0 = Inches(0.9) y0 = Inches(2.75) colors = [Colors.TEAL, Colors.BURNT_ORANGE, Colors.FOREST] for idx, card in enumerate(cards[:3]): x = x0 + idx * (card_w + gap) bg = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, x, y0, card_w, card_h) bg.fill.solid() bg.fill.fore_color.rgb = Colors.TABLE_ALT_ROW bg.line.color.rgb = colors[idx % len(colors)] self._add_textbox( slide, x + Inches(0.18), y0 + Inches(0.18), card_w - Inches(0.36), Inches(0.28), text=card.get("title", ""), font_size=11, bold=True, color=colors[idx % len(colors)], ) self._add_textbox( slide, x + Inches(0.18), y0 + Inches(0.58), card_w - Inches(0.36), Inches(0.48), text=card.get("metric", ""), font_size=18, bold=True, color=Colors.PRIMARY_TEXT, ) self._add_textbox( slide, x + Inches(0.18), y0 + Inches(1.14), card_w - Inches(0.36), Inches(0.88), text=card.get("detail", ""), font_size=8, color=Colors.SECONDARY_TEXT, ) note = pick(roi, "note") if note: self._add_textbox( slide, Inches(0.9), Inches(5.45), Inches(11.5), Inches(0.65), text=note, font_size=10, italic=True, color=Colors.SECONDARY_TEXT, alignment=PP_ALIGN.CENTER, ) return # Big centered ROI number pct = roi.get("three_year_roi_pct", 0) metric_text = headline or (f"{pct:.0f}%" if pct else "—") big_box = slide.shapes.add_textbox(Inches(0.8), Inches(1.4), Inches(11.7), Inches(2.4)) big_box.text_frame.word_wrap = False p = big_box.text_frame.paragraphs[0] p.text = metric_text p.font.size = Pt(96) p.font.bold = True p.font.name = self.FONT_HEADING p.font.color.rgb = Colors.TEAL p.alignment = PP_ALIGN.CENTER # Label under big number self._add_textbox( slide, Inches(0.8), Inches(3.75), Inches(11.7), Inches(0.4), text=roi.get("label", "3-Year Return on Investment"), font_size=16, color=Colors.SECONDARY_TEXT, alignment=PP_ALIGN.CENTER, ) # 3 supporting metric boxes payback = roi.get("payback_months", 0) investment = roi.get("total_investment", 0) benefit = roi.get("annual_net_benefit", 0) metrics = [] if payback: metrics.append((f"{payback} months", "Payback Period")) if investment: metrics.append((f"${investment:,.0f}", "Total Investment")) if benefit: metrics.append((f"${benefit:,.0f}/yr", "Annual Net Benefit")) box_w = Inches(3.5) gap = Inches(0.45) total_w = box_w * len(metrics) + gap * (len(metrics) - 1) x_start = (Inches(13.33) - total_w) / 2 y_box = Inches(4.4) for j, (value, label) in enumerate(metrics): x = x_start + j * (box_w + gap) # Background bg = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, x, y_box, box_w, Inches(1.4)) bg.fill.solid() bg.fill.fore_color.rgb = Colors.TABLE_ALT_ROW bg.line.color.rgb = Colors.MUTED_TEAL # Value self._add_textbox( slide, x, y_box + Inches(0.15), box_w, Inches(0.7), text=value, font_size=26, bold=True, color=Colors.TEAL, alignment=PP_ALIGN.CENTER, ) # Label self._add_textbox( slide, x, y_box + Inches(0.85), box_w, Inches(0.45), text=label, font_size=11, color=Colors.SECONDARY_TEXT, alignment=PP_ALIGN.CENTER, ) def add_tco_projection_slide( self, projection: list, title: str = "3-Year TCO Projection", storage_economics: dict | None = None, ): """Slide: multi-year TCO forecast with CPU and storage assumptions.""" if not projection: return slide = self._add_blank_slide() self._add_title_bar(slide, title) headers = ["Period", "CPU Demand", "Storage", "ADB-S As-Is", "ADB-D To-Be", "Delta", "Note"] rows = projection[:4] table = self._add_table( slide, len(rows) + 1, len(headers), Inches(0.55), Inches(1.35), Inches(12.25), Inches(0.55 * (len(rows) + 1)), ) widths = [1.05, 1.65, 1.8, 1.65, 1.65, 1.35, 3.1] for idx, width in enumerate(widths): table.columns[idx].width = Inches(width) for j, header in enumerate(headers): self._style_table_cell( table.cell(0, j), header, font_size=9, bold=True, color=Colors.WHITE, bg_color=Colors.TEAL, alignment=PP_ALIGN.CENTER if j else PP_ALIGN.LEFT, ) for i, row in enumerate(rows, start=1): bg = Colors.TABLE_ALT_ROW if i % 2 == 0 else None values = [ row.get("period", ""), row.get("cpu", ""), row.get("storage", ""), row.get("as_is", ""), row.get("to_be", ""), row.get("delta", ""), row.get("note", ""), ] for j, value in enumerate(values): self._style_table_cell( table.cell(i, j), value, font_size=8, bg_color=bg, alignment=PP_ALIGN.RIGHT if j in (3, 4, 5) else PP_ALIGN.LEFT, color=Colors.ERROR if j == 5 and str(value).startswith("+") else Colors.PRIMARY_TEXT, ) footnote = rows[0].get("footnote", "") if isinstance(rows[0], dict) else "" if footnote: self._add_textbox( slide, Inches(0.65), Inches(6.25), Inches(12.0), Inches(0.45), text=footnote, font_size=8, italic=True, color=Colors.SECONDARY_TEXT, ) if isinstance(storage_economics, dict) and storage_economics: y = Inches(4.35) box = slide.shapes.add_shape(MSO_SHAPE.ROUNDED_RECTANGLE, Inches(0.75), y, Inches(11.85), Inches(1.55)) box.fill.solid() box.fill.fore_color.rgb = Colors.TABLE_ALT_ROW box.line.color.rgb = Colors.MUTED_TEAL self._add_textbox( slide, Inches(0.95), y + Inches(0.12), Inches(11.45), Inches(0.26), text=pick(storage_economics, "headline", default="Storage economics"), font_size=10, bold=True, color=Colors.TEAL, ) cards = storage_economics.get("cards", []) if cards: card_w = Inches(3.55) for idx, card in enumerate(cards[:3]): x = Inches(0.95) + idx * Inches(3.8) self._add_textbox( slide, x, y + Inches(0.45), card_w, Inches(0.35), text=card.get("value", ""), font_size=15, bold=True, color=Colors.PRIMARY_TEXT, ) self._add_textbox( slide, x, y + Inches(0.82), card_w, Inches(0.34), text=card.get("label", ""), font_size=8, color=Colors.SECONDARY_TEXT, ) detail = card.get("detail", "") if detail: self._add_textbox( slide, x, y + Inches(1.13), card_w, Inches(0.28), text=detail, font_size=7, color=Colors.SECONDARY_TEXT, ) def add_tco_crossover_slide(self, chart_spec: dict): """Slide: show when ADB-D becomes cheaper than ADB-S.""" if not isinstance(chart_spec, dict): return categories = chart_spec.get("categories", []) as_is = chart_spec.get("as_is", []) to_be = chart_spec.get("to_be", []) if not categories or not as_is or not to_be: return slide = self._add_blank_slide() self._add_title_bar(slide, pick(chart_spec, "title", default="TCO Crossover")) subtitle = pick(chart_spec, "subtitle") if subtitle: self._add_textbox( slide, Inches(0.75), Inches(1.05), Inches(12.0), Inches(0.35), text=subtitle, font_size=13, color=Colors.SECONDARY_TEXT, ) # Draw the chart with native shapes so it remains visible in lightweight # renderers that do not paint embedded Office chart objects. y_min = float(chart_spec.get("y_axis_min", min(as_is + to_be) * 0.9)) y_max = float(chart_spec.get("y_axis_max", max(as_is + to_be) * 1.1)) y_step = float(chart_spec.get("y_axis_major_unit", 0.5)) plot_x, plot_y = Inches(0.95), Inches(1.8) plot_w, plot_h = Inches(7.75), Inches(4.2) axis_color = Colors.SECONDARY_TEXT grid_color = RGBColor(220, 218, 214) series_colors = [Colors.BURNT_ORANGE, Colors.TEAL] def x_pos(idx: int) -> int: if len(categories) == 1: return int(plot_x + plot_w / 2) return int(plot_x + idx * (plot_w / (len(categories) - 1))) def y_pos(value: float) -> int: ratio = (float(value) - y_min) / (y_max - y_min) return int(plot_y + plot_h - ratio * plot_h) # Grid and y labels. tick = y_min while tick <= y_max + 0.001: y = y_pos(tick) grid = slide.shapes.add_connector(MSO_CONNECTOR.STRAIGHT, plot_x, y, plot_x + plot_w, y) grid.line.color.rgb = grid_color grid.line.width = Pt(0.6) self._add_textbox( slide, Inches(0.52), y - Inches(0.1), Inches(0.35), Inches(0.2), text=f"${tick:.1f}M", font_size=7, color=Colors.SECONDARY_TEXT, alignment=PP_ALIGN.RIGHT, ) tick += y_step # Axes. x_axis = slide.shapes.add_connector(MSO_CONNECTOR.STRAIGHT, plot_x, plot_y + plot_h, plot_x + plot_w, plot_y + plot_h) x_axis.line.color.rgb = axis_color y_axis = slide.shapes.add_connector(MSO_CONNECTOR.STRAIGHT, plot_x, plot_y, plot_x, plot_y + plot_h) y_axis.line.color.rgb = axis_color baseline_y = y_pos(y_min) group_w = plot_w / len(categories) bar_w = min(Inches(0.28), group_w * 0.28) gap_w = Inches(0.06) for idx, category in enumerate(categories): center = int(plot_x + group_w * (idx + 0.5)) values = [as_is[idx], to_be[idx]] for s_idx, value in enumerate(values): color = series_colors[s_idx] x = center - bar_w - gap_w / 2 if s_idx == 0 else center + gap_w / 2 y = y_pos(value) h = baseline_y - y bar = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, int(x), int(y), int(bar_w), int(h)) bar.fill.solid() bar.fill.fore_color.rgb = color bar.line.fill.background() self._add_textbox( slide, int(x) - Inches(0.16), y - Inches(0.26), bar_w + Inches(0.32), Inches(0.2), text=f"${value:.2f}M", font_size=7, color=color, alignment=PP_ALIGN.CENTER, ) for idx, category in enumerate(categories): center = int(plot_x + group_w * (idx + 0.5)) self._add_textbox( slide, center - Inches(0.45), plot_y + plot_h + Inches(0.1), Inches(0.9), Inches(0.25), text=str(category), font_size=8, color=Colors.SECONDARY_TEXT, alignment=PP_ALIGN.CENTER, ) # Legend. legend_y = plot_y + plot_h + Inches(0.55) for idx, (label, color) in enumerate([ (pick(chart_spec, "as_is_label", default="ADB-S"), series_colors[0]), (pick(chart_spec, "to_be_label", default="ADB-D"), series_colors[1]), ]): x = plot_x + Inches(idx * 2.2) swatch = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, x, legend_y, Inches(0.18), Inches(0.08)) swatch.fill.solid() swatch.fill.fore_color.rgb = color swatch.line.fill.background() self._add_textbox(slide, x + Inches(0.25), legend_y - Inches(0.06), Inches(1.6), Inches(0.22), text=label, font_size=8, color=Colors.SECONDARY_TEXT) callout = pick(chart_spec, "callout", default="") if callout: box = slide.shapes.add_shape( MSO_SHAPE.ROUNDED_RECTANGLE, Inches(9.15), Inches(1.7), Inches(3.35), Inches(1.25), ) box.fill.solid() box.fill.fore_color.rgb = Colors.TEAL box.line.fill.background() self._add_textbox( slide, Inches(9.35), Inches(1.92), Inches(2.95), Inches(0.78), text=callout, font_size=17, bold=True, color=Colors.WHITE, alignment=PP_ALIGN.CENTER, ) bullets = chart_spec.get("bullets", []) y = Inches(3.25) for idx, bullet in enumerate(bullets[:4]): self._add_textbox( slide, Inches(9.2), y + idx * Inches(0.55), Inches(3.25), Inches(0.42), text=f"- {bullet}", font_size=9, color=Colors.SECONDARY_TEXT, ) note = pick(chart_spec, "note") if note: self._add_textbox( slide, Inches(0.85), Inches(6.35), Inches(11.8), Inches(0.35), text=note, font_size=8, italic=True, color=Colors.SECONDARY_TEXT, ) def add_cost_breakdown_slide(self, breakdown: dict): """Slide: explain how cloud services and operations costs are built.""" if not isinstance(breakdown, dict): return slide = self._add_blank_slide() self._add_title_bar(slide, pick(breakdown, "title", default="BOM + Operations Cost Breakdown")) scenarios = breakdown.get("scenarios", []) if not scenarios: return col_w = Inches(5.8) gap = Inches(0.55) x_positions = [Inches(0.75), Inches(0.75) + col_w + gap] colors = [Colors.TEAL, Colors.BURNT_ORANGE] for idx, scenario in enumerate(scenarios[:2]): x = x_positions[idx] y = Inches(1.3) color = colors[idx % len(colors)] header = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, x, y, col_w, Inches(0.45)) header.fill.solid() header.fill.fore_color.rgb = color header.line.fill.background() self._add_textbox( slide, x + Inches(0.15), y + Inches(0.06), col_w - Inches(0.3), Inches(0.32), text=pick(scenario, "name", default=f"Scenario {idx+1}"), font_size=12, bold=True, color=Colors.WHITE, ) rows = scenario.get("lines", []) table = self._add_table( slide, len(rows) + 2, 3, x, y + Inches(0.6), col_w, Inches(0.32 * (len(rows) + 2)), ) table.columns[0].width = Inches(3.0) table.columns[1].width = Inches(1.35) table.columns[2].width = Inches(1.45) for j, h in enumerate(["Cost Item", "Monthly", "Annual"]): self._style_table_cell( table.cell(0, j), h, font_size=8, bold=True, color=Colors.WHITE, bg_color=color, alignment=PP_ALIGN.RIGHT if j else PP_ALIGN.LEFT, ) for r_idx, row in enumerate(rows, start=1): bg = Colors.TABLE_ALT_ROW if r_idx % 2 == 0 else None self._style_table_cell(table.cell(r_idx, 0), row.get("item", ""), font_size=7, bg_color=bg) self._style_table_cell(table.cell(r_idx, 1), row.get("monthly", ""), font_size=7, bg_color=bg, alignment=PP_ALIGN.RIGHT) self._style_table_cell(table.cell(r_idx, 2), row.get("annual", ""), font_size=7, bg_color=bg, alignment=PP_ALIGN.RIGHT) total = scenario.get("total", {}) last = len(rows) + 1 self._style_table_cell(table.cell(last, 0), "TOTAL", font_size=8, bold=True, color=Colors.WHITE, bg_color=Colors.DARK_BG) self._style_table_cell(table.cell(last, 1), total.get("monthly", ""), font_size=8, bold=True, color=Colors.WHITE, bg_color=Colors.DARK_BG, alignment=PP_ALIGN.RIGHT) self._style_table_cell(table.cell(last, 2), total.get("annual", ""), font_size=8, bold=True, color=Colors.WHITE, bg_color=Colors.DARK_BG, alignment=PP_ALIGN.RIGHT) notes = breakdown.get("notes", []) if notes: y = Inches(6.0) self._add_textbox(slide, Inches(0.8), y, Inches(11.8), Inches(0.25), text="Assumptions:", font_size=8, bold=True, color=Colors.SECONDARY_TEXT) for idx, note in enumerate(notes[:4]): self._add_textbox( slide, Inches(1.0), y + Inches(0.23 + idx * 0.2), Inches(11.6), Inches(0.2), text=f"- {note}", font_size=7, color=Colors.SECONDARY_TEXT, ) def add_business_value_slide(self, value_case: dict): """Slide: risk-adjusted value / avoided downtime model.""" if not isinstance(value_case, dict): return slide = self._add_blank_slide() self._add_title_bar(slide, pick(value_case, "title", default="Risk-Adjusted Business Value")) headline = pick(value_case, "headline") if headline: self._add_textbox( slide, Inches(0.8), Inches(1.15), Inches(11.8), Inches(0.5), text=headline, font_size=16, bold=True, color=Colors.TEAL, ) rows = value_case.get("rows", []) if rows: headers = ["Value Area", "How to Measure", "Business Case Treatment"] table = self._add_table(slide, len(rows) + 1, 3, Inches(0.75), Inches(1.85), Inches(12.0), Inches(0.75 * (len(rows) + 1))) table.columns[0].width = Inches(2.6) table.columns[1].width = Inches(4.3) table.columns[2].width = Inches(5.1) for j, h in enumerate(headers): self._style_table_cell(table.cell(0, j), h, font_size=9, bold=True, color=Colors.WHITE, bg_color=Colors.TEAL) for i, row in enumerate(rows, start=1): bg = Colors.TABLE_ALT_ROW if i % 2 == 0 else None self._style_table_cell(table.cell(i, 0), row.get("area", ""), font_size=8, bg_color=bg) self._style_table_cell(table.cell(i, 1), row.get("measure", ""), font_size=8, bg_color=bg) self._style_table_cell(table.cell(i, 2), row.get("treatment", ""), font_size=8, bg_color=bg) break_even = value_case.get("break_even", []) if break_even: self._add_textbox( slide, Inches(0.8), Inches(5.25), Inches(11.8), Inches(0.3), text="Break-even avoided outage impact", font_size=10, bold=True, color=Colors.SECONDARY_TEXT, ) headers = ["Horizon", "Incremental TCO", "If avoiding 4h/year", "If avoiding 8h/year"] table = self._add_table(slide, len(break_even) + 1, 4, Inches(0.8), Inches(5.6), Inches(11.7), Inches(0.38 * (len(break_even) + 1))) for j, h in enumerate(headers): self._style_table_cell(table.cell(0, j), h, font_size=8, bold=True, color=Colors.WHITE, bg_color=Colors.BURNT_ORANGE) for i, row in enumerate(break_even, start=1): bg = Colors.TABLE_ALT_ROW if i % 2 == 0 else None values = [row.get("horizon", ""), row.get("investment", ""), row.get("four_hours", ""), row.get("eight_hours", "")] for j, value in enumerate(values): self._style_table_cell(table.cell(i, j), value, font_size=8, bg_color=bg, alignment=PP_ALIGN.RIGHT if j else PP_ALIGN.LEFT) def add_value_drivers_slide(self, drivers: list): """Slide 6: Value Drivers — 4 categories on blank slide. drivers: list of {"category": str, "title": str, "description": str, "quantified": str} """ drivers = [ {"title": driver, "description": ""} if isinstance(driver, str) else driver for driver in drivers ] slide = self._add_blank_slide() self._add_title_bar(slide, "Value Drivers") # 4 value cards in a 2x2 grid card_colors = [Colors.TEAL, Colors.FOREST, Colors.BURNT_ORANGE, Colors.ORACLE_RED] positions = [ (Inches(0.8), Inches(1.5)), # top-left (Inches(6.8), Inches(1.5)), # top-right (Inches(0.8), Inches(4.3)), # bottom-left (Inches(6.8), Inches(4.3)), # bottom-right ] card_w, card_h = Inches(5.5), Inches(2.5) for i, driver in enumerate(drivers[:4]): x, y = positions[i] color = card_colors[i % len(card_colors)] # Color accent bar bar = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, x, y, Inches(0.08), card_h) bar.fill.solid() bar.fill.fore_color.rgb = color bar.line.fill.background() # Title title = driver.get("title", driver.get("category", "").replace("_", " ").title()) self._add_textbox( slide, x + Inches(0.25), y + Inches(0.1), card_w - Inches(0.3), Inches(0.4), text=title, font_size=16, bold=True, color=color, ) # Quantified value (big) quantified = driver.get("quantified", "") if quantified: self._add_textbox( slide, x + Inches(0.25), y + Inches(0.55), card_w - Inches(0.3), Inches(0.5), text=quantified, font_size=22, bold=True, color=Colors.PRIMARY_TEXT, ) # Description desc = driver.get("description", "") if desc: self._add_textbox( slide, x + Inches(0.25), y + Inches(1.2), card_w - Inches(0.3), Inches(1.0), text=desc, font_size=11, color=Colors.SECONDARY_TEXT, ) def add_risk_slide(self, migration_risks: list, do_nothing_risks: list): """Slide 7: Risk Assessment — two-column table layout.""" slide = self._add_blank_slide() self._add_title_bar(slide, "Risk Assessment") col_w = Inches(5.6) col_gap = Inches(0.5) left_x = Inches(0.8) right_x = left_x + col_w + col_gap header_y = Inches(1.2) content_start_y = Inches(1.75) row_h = Inches(0.8) # height per risk block (title + detail) slide_h = Inches(7.1) # Stretch rows to fill available slide height n_rows = max(len(migration_risks[:5]), len(do_nothing_risks[:5])) if n_rows > 0: available = slide_h - content_start_y row_h = min(Inches(1.8), available / n_rows) # Column header backgrounds for x, color, label in [ (left_x, Colors.TEAL, "Migration Risks (Mitigated)"), (right_x, Colors.ERROR, "Risks of Inaction"), ]: bg = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, x, header_y, col_w, Inches(0.45)) bg.fill.solid() bg.fill.fore_color.rgb = color bg.line.fill.background() self._add_textbox( slide, x + Inches(0.15), header_y + Inches(0.05), col_w - Inches(0.2), Inches(0.38), text=label, font_size=13, bold=True, color=Colors.WHITE, ) # Left column: migration risks for i, risk in enumerate(migration_risks[:5]): r_text = risk.get("risk", str(risk)) if isinstance(risk, dict) else str(risk) mitigation = risk.get("mitigation", "") if isinstance(risk, dict) else "" y = content_start_y + i * row_h # Alternating row background if i % 2 == 0: row_bg = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, left_x, y, col_w, row_h) row_bg.fill.solid() row_bg.fill.fore_color.rgb = Colors.TABLE_ALT_ROW row_bg.line.fill.background() self._add_textbox( slide, left_x + Inches(0.15), y + Inches(0.07), col_w - Inches(0.25), Inches(0.4), text=f"- {r_text}", font_size=12, bold=True, color=Colors.PRIMARY_TEXT, ) if mitigation: self._add_textbox( slide, left_x + Inches(0.25), y + Inches(0.45), col_w - Inches(0.35), row_h - Inches(0.48), text=f"Mitigation: {mitigation}", font_size=11, italic=True, color=Colors.SECONDARY_TEXT, ) # Right column: do-nothing risks for i, risk in enumerate(do_nothing_risks[:5]): r_text = risk.get("risk", str(risk)) if isinstance(risk, dict) else str(risk) impact = risk.get("impact", "") if isinstance(risk, dict) else "" timeline = risk.get("timeline", "") if isinstance(risk, dict) else "" y = content_start_y + i * row_h if i % 2 == 0: row_bg = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, right_x, y, col_w, row_h) row_bg.fill.solid() row_bg.fill.fore_color.rgb = RGBColor(0xFF, 0xF3, 0xF3) row_bg.line.fill.background() self._add_textbox( slide, right_x + Inches(0.15), y + Inches(0.07), col_w - Inches(0.25), Inches(0.4), text=f"- {r_text}", font_size=12, bold=True, color=Colors.ERROR, ) detail_parts = [] if impact: detail_parts.append(f"Impact: {impact}") if timeline: detail_parts.append(f"By: {timeline}") if detail_parts: self._add_textbox( slide, right_x + Inches(0.25), y + Inches(0.45), col_w - Inches(0.35), row_h - Inches(0.48), text=" | ".join(detail_parts), font_size=10, italic=True, color=Colors.SECONDARY_TEXT, ) def add_roadmap_slide(self, phases: list, total_duration: str = ""): """Slide 8: Implementation Roadmap — timeline bars filling the slide.""" slide = self._add_blank_slide() title = "Implementation Roadmap" if total_duration: title += f" — {total_duration}" self._add_title_bar(slide, title) phase_colors = [Colors.TEAL, Colors.BURNT_ORANGE, Colors.FOREST, Colors.ORACLE_RED] content_start = Inches(1.25) available_h = Inches(5.9) n = min(len(phases), 4) row_h = available_h / n if n else available_h bar_left = Inches(3.6) bar_w = Inches(9.1) label_w = Inches(2.6) for i, phase in enumerate(phases[:4]): color = phase_colors[i % len(phase_colors)] y = content_start + i * row_h name = pick(phase, "name", "title", default=f"Phase {i+1}") duration = pick(phase, "duration", "weeks") deliverables = pick_list(phase, "deliverables", "outputs") quick_wins = pick_list(phase, "quick_wins", "milestones") # Alternating row background if i % 2 == 0: bg = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, Inches(0.8), y, Inches(12.0), row_h - Inches(0.08)) bg.fill.solid() bg.fill.fore_color.rgb = Colors.TABLE_ALT_ROW bg.line.fill.background() # Phase number circle accent dot = slide.shapes.add_shape(MSO_SHAPE.OVAL, Inches(0.82), y + (row_h - Inches(0.38)) / 2, Inches(0.38), Inches(0.38)) dot.fill.solid() dot.fill.fore_color.rgb = color dot.line.fill.background() dot.text_frame.paragraphs[0].text = str(i + 1) dot.text_frame.paragraphs[0].font.size = Pt(11) dot.text_frame.paragraphs[0].font.bold = True dot.text_frame.paragraphs[0].font.color.rgb = Colors.WHITE dot.text_frame.paragraphs[0].font.name = self.FONT dot.text_frame.paragraphs[0].alignment = PP_ALIGN.CENTER # Phase name self._add_textbox( slide, Inches(1.35), y + Inches(0.08), label_w, Inches(0.45), text=name, font_size=14, bold=True, color=color, ) # Duration bar bar_h = Inches(0.42) bar_y = y + (row_h - bar_h) / 2 bar = slide.shapes.add_shape(MSO_SHAPE.ROUNDED_RECTANGLE, bar_left, bar_y, bar_w * 0.55, bar_h) bar.fill.solid() bar.fill.fore_color.rgb = color bar.line.fill.background() bar.text_frame.paragraphs[0].text = duration bar.text_frame.paragraphs[0].font.size = Pt(12) bar.text_frame.paragraphs[0].font.bold = True bar.text_frame.paragraphs[0].font.color.rgb = Colors.WHITE bar.text_frame.paragraphs[0].font.name = self.FONT bar.text_frame.paragraphs[0].alignment = PP_ALIGN.CENTER # Deliverables — listed to the right of the bar items = quick_wins + deliverables if items: items_text = " • ".join(items[:3]) self._add_textbox( slide, bar_left + bar_w * 0.57, bar_y - Inches(0.02), bar_w * 0.43, bar_h + Inches(0.05), text=items_text, font_size=11, color=Colors.SECONDARY_TEXT, ) def add_recommendation_slide(self, summary: str, next_steps: list = None): """Slide 9: Recommendation — dark blank slide with controlled fonts.""" slide = self._add_blank_slide(dark=True) # "Recommendation" label in gold self._add_textbox( slide, Inches(0.8), Inches(0.45), Inches(11.7), Inches(0.5), text="Our Recommendation", font_size=13, bold=True, color=Colors.GOLD, font_name=self.FONT, ) # Gold accent bar acc = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, Inches(0.8), Inches(1.0), Inches(11.7), Inches(0.05)) acc.fill.solid() acc.fill.fore_color.rgb = Colors.GOLD acc.line.fill.background() # Main recommendation statement — 20pt, white, readable rec_box = slide.shapes.add_textbox(Inches(0.8), Inches(1.2), Inches(11.7), Inches(2.2)) tf = rec_box.text_frame tf.word_wrap = True p = tf.paragraphs[0] p.text = summary p.font.size = Pt(20) p.font.bold = True p.font.name = self.FONT_HEADING p.font.color.rgb = Colors.WHITE # Next steps section if next_steps: self._add_textbox( slide, Inches(0.8), Inches(3.6), Inches(4.0), Inches(0.4), text="NEXT STEPS", font_size=11, bold=True, color=Colors.GOLD, ) # Divider div = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, Inches(0.8), Inches(4.05), Inches(11.7), Inches(0.03)) div.fill.solid() div.fill.fore_color.rgb = RGBColor(0x55, 0x50, 0x4C) div.line.fill.background() y = Inches(4.15) for i, step in enumerate(next_steps[:4]): action = step.get("action", str(step)) if isinstance(step, dict) else str(step) owner = step.get("owner", "") if isinstance(step, dict) else "" deadline = step.get("deadline", "") if isinstance(step, dict) else "" # Number self._add_textbox( slide, Inches(0.8), y, Inches(0.4), Inches(0.5), text=str(i + 1), font_size=13, bold=True, color=Colors.GOLD, ) # Action text action_text = action meta_parts = [] if owner: meta_parts.append(owner) if deadline: meta_parts.append(deadline) meta = f" [{' · '.join(meta_parts)}]" if meta_parts else "" self._add_textbox( slide, Inches(1.25), y, Inches(11.2), Inches(0.5), text=action_text + meta, font_size=13, color=Colors.WHITE, ) y += Inches(0.6) def add_disclaimer_slide(self, disclaimer: str): """Final slide: commercial disclaimer for price-bearing business cases.""" if not disclaimer: return slide = self._add_blank_slide() self._add_title_bar(slide, "Commercial Disclaimer") body = slide.shapes.add_textbox(Inches(0.8), Inches(1.25), Inches(11.7), Inches(4.9)) tf = body.text_frame tf.word_wrap = True p = tf.paragraphs[0] p.text = disclaimer p.font.size = Pt(12) p.font.name = self.FONT p.font.color.rgb = Colors.PRIMARY_TEXT # ================================================================ # Build from YAML spec # ================================================================ @classmethod def from_spec(cls, spec: dict, template: Optional[str] = None) -> "BusinessCaseDeckGenerator": """Build a complete business case deck from a YAML specification.""" spec = enrich_adbs_to_adbd_business_case(spec) spec = _enrich_sparse_business_case(spec) bc = spec.get("business_case", spec) # Support both wrapped and unwrapped gen = cls(template=template) # Slide 1: Cover gen.add_cover_slide( customer=pick(bc, "customer_name", "customer"), subtitle=pick( bc, "cover_subtitle", "subtitle", default="ADB-S to ADB-D Migration Business Case", ), prepared_by=pick(bc, "prepared_by", "author"), prepared_by_role=pick(bc, "prepared_by_role", "role", "title"), date=pick(bc, "date", "generated_on"), ) # Slide 2: Executive Summary exec_summary = bc.get("executive_summary", "") if exec_summary: gen.add_executive_summary_slide(exec_summary) # Slide 3: Business Drivers drivers_data = bc.get("drivers", {}) # Accept primary_driver at the top level as well (common user shape) top_primary = pick(bc, "primary_driver", "main_driver") # Accept a plain string or list for drivers if isinstance(drivers_data, str): drivers_data = {"primary": drivers_data} elif isinstance(drivers_data, list): drivers_data = {"items": drivers_data} elif not isinstance(drivers_data, dict): drivers_data = {} if drivers_data or top_primary: driver_statements = [] primary = pick(drivers_data, "primary", "primary_driver", "main_driver") or top_primary urgency = pick(drivers_data, "urgency", "why_now") coi = drivers_data.get("cost_of_inaction", {}) or {} if primary: primary_text = primary if isinstance(primary, str) else str(primary) # Only rewrite snake_case enum tokens ("compliance_driven"); leave natural # language intact so values like "Soberanía de datos + compliance regulatorio" # render verbatim. if "_" in primary_text and " " not in primary_text and len(primary_text) <= 40: headline = f"Primary Driver: {primary_text.replace('_', ' ').title()}" else: headline = primary_text driver_statements.append(f"{headline}\n{urgency}" if urgency else headline) # Spec-provided additional cards take precedence over the inaction fallback extra_items = pick_list(drivers_data, "items", "additional", "secondary", "cards") for item in extra_items: if isinstance(item, str) and item.strip(): driver_statements.append(item.strip()) elif isinstance(item, dict): label = pick(item, "label", "headline", "title", "name") desc = pick(item, "detail", "description", "text", "body") if label and desc: driver_statements.append(f"{label}\n{desc}") elif label or desc: driver_statements.append(label or desc) if not extra_items: financial = pick(coi, "financial") operational = pick(coi, "operational") strategic = pick(coi, "strategic") if financial: driver_statements.append(f"Financial Impact of Inaction\n{financial}") if operational: driver_statements.append(f"Operational Impact\n{operational}") elif strategic: driver_statements.append(f"Strategic Risk\n{strategic}") if driver_statements: gen.add_business_drivers_slide(driver_statements) # Slide 4: TCO Comparison tco = bc.get("tco", {}) if tco and (tco.get("current_state") or tco.get("proposed_oci")): gen.add_tco_slide(tco) breakdown = tco.get("breakdown", {}) if breakdown: gen.add_cost_breakdown_slide(breakdown) projection = pick_list(tco, "projection", "forecast") if projection: gen.add_tco_projection_slide( projection, title=pick(tco, "projection_title", default="3-Year TCO Projection"), storage_economics=tco.get("storage_economics"), ) crossover_chart = tco.get("crossover_chart", {}) if crossover_chart: gen.add_tco_crossover_slide(crossover_chart) value_case = tco.get("business_value", {}) if value_case: gen.add_business_value_slide(value_case) # Slide 5: ROI roi = bc.get("roi", {}) if roi and (roi.get("cards") or any(roi.get(k) for k in ["three_year_roi_pct", "payback_months", "total_investment"])): gen.add_roi_slide(roi, headline=pick(roi, "headline")) # Slide 6: Value Drivers value_drivers = bc.get("value_drivers", []) if value_drivers: gen.add_value_drivers_slide(value_drivers) # Slide 7: Risk Assessment risks = bc.get("risks", {}) migration_risks = pick_list(risks, "migration_risks") do_nothing_risks = pick_list(risks, "do_nothing_risks") if migration_risks or do_nothing_risks: gen.add_risk_slide(migration_risks, do_nothing_risks) # Slide 8: Roadmap roadmap = bc.get("roadmap", {}) if roadmap.get("phases"): gen.add_roadmap_slide( phases=pick_list(roadmap, "phases"), total_duration=pick(roadmap, "total_duration"), ) # Slide 9: Recommendation rec = bc.get("recommendation", {}) if rec: summary = pick(rec, "summary") if not summary and rec.get("commitment_amount"): summary = f"Recommended: {rec['commitment_amount']} {rec.get('commitment_type', 'UCM')} commitment" if summary: gen.add_recommendation_slide( summary=summary, next_steps=pick_list(rec, "next_steps"), ) disclaimer = pick(bc, "commercial_disclaimer", "disclaimer") if disclaimer: gen.add_disclaimer_slide(disclaimer) return gen # ============================================================ # CLI # ============================================================ def main(): parser = argparse.ArgumentParser( description="Generate OCI business case slide deck (.pptx)" ) parser.add_argument( "--spec", required=True, help="Path to YAML business case spec file", ) parser.add_argument( "--output", default="business-case.pptx", help="Output .pptx file path", ) parser.add_argument( "--template", help="Path to Oracle FY26 .pptx template (default: templates/Oracle_PPT-template_FY26.pptx)", ) parser.add_argument( "--no-boms", action="store_true", help="Do not generate companion BOM YAML/XLSX files for ADB-S to ADB-D cases.", ) parser.add_argument( "--no-validate", action="store_true", help="Skip structural PPTX validation.", ) args = parser.parse_args() with open(args.spec, 'r') as f: spec = yaml.safe_load(f) bc = spec.get("business_case", spec) if not pick(bc, "commercial_disclaimer", "disclaimer"): catalog_path = Path(__file__).resolve().parent.parent / "kb" / "pricing" / "oci-sku-catalog.yaml" if catalog_path.exists(): catalog = yaml.safe_load(catalog_path.read_text(encoding="utf-8")) or {} disclaimer = catalog.get("disclaimer", "") if disclaimer: bc["commercial_disclaimer"] = disclaimer gen = BusinessCaseDeckGenerator.from_spec(spec, template=args.template) gen.save(args.output) print(f"Generated: {args.output}") print(f" Slides: {gen.slide_count}") print(f" Template: Oracle FY26") customer = spec.get("business_case", spec).get("customer_name", "") if customer: print(f" Customer: {customer}") adbd_config = bc.get("adbs_to_adbd") or bc.get("adb_s_to_adb_d") if isinstance(adbd_config, dict) and not args.no_boms: bom_dir = Path(args.output).with_suffix("").parent / f"{Path(args.output).stem}-boms" adbd_config = {**adbd_config, "customer_name": pick(bc, "customer_name", "customer"), "prepared_by": pick(bc, "prepared_by", "author")} saved = write_bom_outputs(adbd_config, bom_dir) print(f" BOM outputs: {len(saved)} files in {bom_dir}") if not args.no_validate: validation_cfg = bc.get("deck_validation", {}) if isinstance(bc.get("deck_validation"), dict) else {} required = validation_cfg.get("required_phrases") forbidden = validation_cfg.get("forbidden_phrases") expected_titles = validation_cfg.get("expected_titles") if required is None and isinstance(adbd_config, dict): required = [ "BYOL/PAYG model", "Discount", "GoldenGate bridge duration", "Workload ECPU demand", "ECPU capacity", "Storage break-even", "Crossover", ] if forbidden is None: forbidden = ["OCI Annual", "FTE-year"] if expected_titles is None and isinstance(adbd_config, dict): crossover_title = pick(adbd_config.get("crossover_chart") or {}, "title", default="TCO Crossover") expected_titles = [ "Total Cost of Ownership", "BOM + Operations Cost Breakdown", crossover_title, "Business Value Model", "Commercial Disclaimer", ] report = validate_pptx( args.output, expected_titles=expected_titles or [], required_phrases=required or [], forbidden_phrases=forbidden or [], min_slides=validation_cfg.get("min_slides"), max_slides=validation_cfg.get("max_slides"), exact_slides=validation_cfg.get("exact_slides"), disclaimer_last=bool(bc.get("commercial_disclaimer")), ) print(f" Deck validation: {report['status']} ({report['slide_count']} slides)") for issue in report["issues"]: print(f" - {issue['code']}: {issue['message']}") if __name__ == "__main__": main()