Stakeholder Communication and Translation Questions

import json

# Example inputs (structured)
release_notes = {
    "version": "2.3.0",
    "summary": "Major performance improvements & new auth flow",
    "changes": [
        {"id": "C1", "title": "New OAuth pipeline", "type": "feature", "owner": "alice@example.com"},
        {"id": "C2", "title": "DB index for queries", "type": "improvement", "owner": "bob@example.com"},
        {"id": "C3", "title": "Deprecated legacy API", "type": "breaking", "owner": "carol@example.com"}
    ],
    "risks": ["Rollback complexity for DB migration", "Client SDK compatibility"],
    "migration": ["Run migration script v2", "Notify clients", "Feature flag rollout"]
}

stakeholders = [
    {"name": "Product Manager", "role": "pm", "email": "pm@example.com"},
    {"name": "Engineering Manager", "role": "eng_mgr", "email": "engmgr@example.com"},
    {"name": "Customer Success", "role": "cs", "email": "cs@example.com"}
]

# Role -> slides mapping
ROLE_SLIDES = {
    "pm": ["Executive Summary", "Key Changes", "Impact", "Owners"],
    "eng_mgr": ["Executive Summary", "Key Changes", "Risks", "Migration Plan", "Owners"],
    "cs": ["Executive Summary", "Key Changes", "Impact"]
}

def one_line_purpose(slide, notes):
    if slide == "Executive Summary":
        return f"High-level summary of {notes['version']}: {notes['summary']}"
    if slide == "Key Changes":
        return f"List and short descriptions of {len(notes['changes'])} changes"
    if slide == "Impact":
        return "Who and what is affected by these changes (users, infra, SLAs)"
    if slide == "Risks":
        return "Known risks and mitigation plans"
    if slide == "Migration Plan":
        return "Step-by-step migration/checklist and rollback strategy"
    if slide == "Owners":
        return "Responsible owners for each change and contact info"
    return ""

def build_slide_deck(release_notes, stakeholders):
    # aggregate owners from changes
    owners = {}
    for c in release_notes.get("changes", []):
        owners[c["owner"]] = owners.get(c["owner"], []) + [c["title"]]
    # create per-role decks
    decks = {}
    for s in stakeholders:
        slides = ROLE_SLIDES.get(s["role"], ["Executive Summary", "Key Changes"])
        deck = []
        for slide in slides:
            item = {
                "title": slide,
                "purpose": one_line_purpose(slide, release_notes),
                "content_summary": summarize_slide(slide, release_notes),  # helper below
            }
            if slide == "Owners":
                item["owners"] = owners
            deck.append(item)
        decks[s["role"]] = {"owner": s["email"], "slides": deck}
    return decks

def summarize_slide(slide, notes):
    # concise summaries for content generation
    if slide == "Key Changes":
        return [{"id": c["id"], "title": c["title"], "type": c["type"]} for c in notes["changes"]]
    if slide == "Risks":
        return notes.get("risks", [])
    if slide == "Migration Plan":
        return notes.get("migration", [])
    if slide == "Impact":
        # derive simple impact bullets
        impacts = []
        for c in notes["changes"]:
            if c["type"] == "breaking":
                impacts.append(f"{c['title']} may require client updates")
        impacts.append("Performance improved for read-heavy queries")
        return impacts
    if slide == "Executive Summary":
        return {"version": notes["version"], "summary": notes["summary"]}
    return []

# produce JSON
deck_json = json.dumps(build_slide_deck(release_notes, stakeholders), indent=2)
print(deck_json)

from typing import List, Dict

def rank_features(features: List[Dict], stakeholders: Dict[str, float]) -> List[Dict]:
    """
    Return top 3 features by weighted score.
    Each feature: {'id': ..., 'value_by_stakeholder': {stakeholder: value, ...}}
    stakeholders: {stakeholder: weight, ...}
    Returns list of {'id': id, 'score': score} sorted by score desc.
    """
    results = []
    # Precompute stakeholder keys to iterate (weights missing => 0)
    stakeholder_keys = list(stakeholders.keys())

    for f in features:
        fid = f.get('id')
        values = f.get('value_by_stakeholder', {})
        score = 0.0
        # Sum over stakeholders with defined weights; missing values default to 0
        for s in stakeholder_keys:
            weight = stakeholders.get(s, 0.0)
            val = values.get(s, 0.0)
            score += val * weight
        results.append({'id': fid, 'score': score})

    # Sort descending by score, tiebreaker by id for determinism
    results.sort(key=lambda x: (-x['score'], x['id']))
    return results[:3]