Program Manager

#!/usr/bin/env python3
"""Milestone Tracker - Track program milestones with status and trend analysis.

Reads milestone data and produces a timeline view with status indicators,
critical path highlighting, and schedule health assessment.

Usage:
    python milestone_tracker.py --milestones milestones.json
    python milestone_tracker.py --milestones milestones.json --json
    python milestone_tracker.py --example
"""

import argparse
import json
import sys
from datetime import datetime, timedelta


def load_data(path: str) -> dict:
    """Load milestone data from JSON file."""
    with open(path, "r") as f:
        return json.load(f)


def parse_date(s: str) -> datetime:
    """Parse date string."""
    for fmt in ("%Y-%m-%d", "%Y-%m-%dT%H:%M:%S"):
        try:
            return datetime.strptime(s, fmt)
        except ValueError:
            continue
    raise ValueError(f"Cannot parse date: {s}")


def analyze_milestones(data: dict) -> dict:
    """Analyze milestone status and trends."""
    program = data.get("program", "Unknown")
    milestones = data.get("milestones", [])
    today = datetime.now()

    results = []
    total = len(milestones)
    completed = 0
    on_track = 0
    at_risk = 0
    overdue = 0
    total_variance_days = 0

    for ms in milestones:
        name = ms.get("name", "Unknown")
        project = ms.get("project", "Unknown")
        planned_str = ms.get("planned_date", "")
        actual_str = ms.get("actual_date", "")
        status = ms.get("status", "Not Started")
        is_critical = ms.get("critical_path", False)
        dependencies = ms.get("dependencies", [])

        planned = parse_date(planned_str) if planned_str else None
        actual = parse_date(actual_str) if actual_str else None

        # Calculate variance
        variance_days = 0
        if status == "Complete" and planned and actual:
            variance_days = (actual - planned).days
            completed += 1
        elif status == "In Progress" and planned:
            days_until = (planned - today).days
            if days_until < 0:
                variance_days = days_until
                overdue += 1
            elif days_until <= 7:
                at_risk += 1
            else:
                on_track += 1
        elif status == "Not Started" and planned:
            days_until = (planned - today).days
            if days_until < 0:
                variance_days = days_until
                overdue += 1
            else:
                on_track += 1

        total_variance_days += abs(variance_days)

        # RAG for this milestone
        if status == "Complete":
            if variance_days <= 0:
                rag = "GREEN"
            elif variance_days <= 5:
                rag = "AMBER"
            else:
                rag = "RED"
        elif status == "In Progress":
            if planned and (planned - today).days < 0:
                rag = "RED"
            elif planned and (planned - today).days <= 7:
                rag = "AMBER"
            else:
                rag = "GREEN"
        else:
            if planned and (planned - today).days < 0:
                rag = "RED"
            else:
                rag = "GREEN"

        results.append({
            "name": name,
            "project": project,
            "planned_date": planned_str,
            "actual_date": actual_str if actual_str else None,
            "status": status,
            "rag": rag,
            "variance_days": variance_days,
            "critical_path": is_critical,
            "dependencies": dependencies,
        })

    # Sort by planned date
    results.sort(key=lambda x: x["planned_date"] if x["planned_date"] else "9999-99-99")

    # Schedule health
    not_completed = total - completed
    if overdue > 0:
        schedule_health = "AT RISK"
    elif at_risk > not_completed * 0.3:
        schedule_health = "CAUTION"
    else:
        schedule_health = "ON TRACK"

    # Critical path analysis
    critical_milestones = [m for m in results if m["critical_path"]]
    critical_overdue = [m for m in critical_milestones if m["rag"] == "RED"]

    # Recommendations
    recs = []
    if critical_overdue:
        recs.append(f"{len(critical_overdue)} critical-path milestone(s) are overdue. This directly impacts the program end date -- escalate immediately.")
    if overdue > 0:
        recs.append(f"{overdue} milestone(s) overdue. Review scope, add resources, or negotiate new dates with stakeholders.")
    if at_risk > 0:
        recs.append(f"{at_risk} milestone(s) due within 7 days. Confirm delivery readiness and clear any blockers.")

    upcoming_7d = [m for m in results if m["status"] != "Complete" and m["planned_date"] and 0 <= (parse_date(m["planned_date"]) - today).days <= 7]
    if upcoming_7d:
        recs.append(f"Upcoming this week: {', '.join(m['name'] for m in upcoming_7d)}")

    return {
        "program": program,
        "date": today.strftime("%Y-%m-%d"),
        "schedule_health": schedule_health,
        "total_milestones": total,
        "completed": completed,
        "on_track": on_track,
        "at_risk": at_risk,
        "overdue": overdue,
        "completion_pct": round(completed / total * 100, 1) if total > 0 else 0,
        "milestones": results,
        "critical_path_count": len(critical_milestones),
        "critical_overdue": len(critical_overdue),
        "recommendations": recs,
    }


def print_report(result: dict) -> None:
    """Print human-readable milestone report."""
    print(f"\nMilestone Tracker: {result['program']}")
    print(f"Date: {result['date']}")
    print("=" * 75)
    print(f"Schedule Health: {result['schedule_health']}")
    print(f"Milestones: {result['completed']}/{result['total_milestones']} complete ({result['completion_pct']:.0f}%)")
    print(f"  On Track: {result['on_track']}  |  At Risk: {result['at_risk']}  |  Overdue: {result['overdue']}")
    print(f"  Critical Path: {result['critical_path_count']} milestones ({result['critical_overdue']} overdue)")

    print(f"\nTimeline:")
    print(f"  {'Status':<6} {'Milestone':<30} {'Project':<15} {'Planned':<12} {'Actual':<12} {'Var':>5} {'CP'}")
    print(f"  {'-'*6} {'-'*30} {'-'*15} {'-'*12} {'-'*12} {'-'*5} {'-'*3}")
    for m in result["milestones"]:
        name = m["name"][:28] + ".." if len(m["name"]) > 30 else m["name"]
        project = m["project"][:13] + ".." if len(m["project"]) > 15 else m["project"]
        actual = m["actual_date"] if m["actual_date"] else "---"
        var = f"{m['variance_days']:+d}d" if m["variance_days"] != 0 else "0d"
        cp = "*" if m["critical_path"] else ""
        rag_icon = {"GREEN": "[G]", "AMBER": "[A]", "RED": "[R]"}.get(m["rag"], "[?]")
        print(f"  {rag_icon:<6} {name:<30} {project:<15} {m['planned_date']:<12} {actual:<12} {var:>5} {cp}")

    if result["recommendations"]:
        print(f"\nRecommendations:")
        for i, r in enumerate(result["recommendations"], 1):
            print(f"  {i}. {r}")
    print()


def print_example() -> None:
    """Print example milestone data JSON."""
    example = {
        "program": "Digital Transformation",
        "milestones": [
            {"name": "Requirements Complete", "project": "API Migration", "planned_date": "2026-02-01", "actual_date": "2026-02-03", "status": "Complete", "critical_path": True, "dependencies": []},
            {"name": "API v2 Released", "project": "API Migration", "planned_date": "2026-03-15", "actual_date": "2026-03-14", "status": "Complete", "critical_path": True, "dependencies": ["Requirements Complete"]},
            {"name": "Beta Launch", "project": "Frontend Rebuild", "planned_date": "2026-04-01", "status": "In Progress", "critical_path": True, "dependencies": ["API v2 Released"]},
            {"name": "Data Schema Finalized", "project": "Analytics Platform", "planned_date": "2026-03-20", "status": "In Progress", "critical_path": False, "dependencies": []},
            {"name": "UAT Complete", "project": "Frontend Rebuild", "planned_date": "2026-04-15", "status": "Not Started", "critical_path": True, "dependencies": ["Beta Launch"]},
            {"name": "Go Live", "project": "Frontend Rebuild", "planned_date": "2026-05-01", "status": "Not Started", "critical_path": True, "dependencies": ["UAT Complete"]},
        ],
    }
    print(json.dumps(example, indent=2))


def main():
    parser = argparse.ArgumentParser(
        description="Track program milestones with status and trend analysis."
    )
    parser.add_argument("--milestones", type=str, help="Path to milestones JSON file")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")
    parser.add_argument("--example", action="store_true", help="Print example milestones JSON and exit")
    args = parser.parse_args()

    if args.example:
        print_example()
        return

    if not args.milestones:
        parser.error("--milestones is required (use --example to see the expected format)")

    data = load_data(args.milestones)
    result = analyze_milestones(data)

    if args.json:
        print(json.dumps(result, indent=2))
    else:
        print_report(result)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Portfolio Dashboard - Generate program portfolio status dashboard.

Reads program/project data and produces a RAG-status dashboard with
milestone tracking, budget analysis, and risk summary.

Usage:
    python portfolio_dashboard.py --portfolio portfolio.json
    python portfolio_dashboard.py --portfolio portfolio.json --json
    python portfolio_dashboard.py --example
"""

import argparse
import json
import sys
from datetime import datetime


def load_data(path: str) -> dict:
    """Load portfolio data from JSON file."""
    with open(path, "r") as f:
        return json.load(f)


def classify_rag(schedule_variance_days: int, budget_pct: float, risks_high: int) -> str:
    """Classify project RAG status."""
    if schedule_variance_days > 15 or budget_pct > 110 or risks_high >= 3:
        return "RED"
    elif schedule_variance_days > 5 or budget_pct > 100 or risks_high >= 1:
        return "AMBER"
    return "GREEN"


def analyze_portfolio(data: dict) -> dict:
    """Analyze portfolio and produce dashboard data."""
    portfolio_name = data.get("name", "Unknown Portfolio")
    programs = data.get("programs", [])

    program_results = []
    total_budget = 0
    total_spent = 0
    all_milestones = 0
    completed_milestones = 0
    rag_counts = {"GREEN": 0, "AMBER": 0, "RED": 0}

    for prog in programs:
        name = prog.get("name", "Unknown")
        projects = prog.get("projects", [])

        prog_budget = prog.get("budget", 0)
        prog_spent = prog.get("spent", 0)
        budget_pct = round(prog_spent / prog_budget * 100, 1) if prog_budget > 0 else 0

        schedule_var = prog.get("schedule_variance_days", 0)
        high_risks = prog.get("high_risks", 0)
        rag = classify_rag(schedule_var, budget_pct, high_risks)
        rag_counts[rag] = rag_counts.get(rag, 0) + 1

        total_budget += prog_budget
        total_spent += prog_spent

        # Project details
        project_details = []
        for proj in projects:
            p_milestones = proj.get("milestones_total", 0)
            p_completed = proj.get("milestones_completed", 0)
            all_milestones += p_milestones
            completed_milestones += p_completed

            p_pct = round(p_completed / p_milestones * 100) if p_milestones > 0 else 0
            project_details.append({
                "name": proj.get("name", "Unknown"),
                "status": proj.get("status", "In Progress"),
                "completion_pct": p_pct,
                "next_milestone": proj.get("next_milestone", "N/A"),
                "next_milestone_date": proj.get("next_milestone_date", "TBD"),
            })

        # Benefits
        benefits_target = prog.get("benefits_target", 0)
        benefits_realized = prog.get("benefits_realized", 0)
        benefits_pct = round(benefits_realized / benefits_target * 100, 1) if benefits_target > 0 else 0

        program_results.append({
            "name": name,
            "rag_status": rag,
            "schedule_variance_days": schedule_var,
            "budget": prog_budget,
            "spent": prog_spent,
            "budget_pct": budget_pct,
            "high_risks": high_risks,
            "benefits_target": benefits_target,
            "benefits_realized": benefits_realized,
            "benefits_pct": benefits_pct,
            "projects": project_details,
            "phase": prog.get("phase", "Execution"),
        })

    # Portfolio-level metrics
    portfolio_budget_pct = round(total_spent / total_budget * 100, 1) if total_budget > 0 else 0
    milestone_pct = round(completed_milestones / all_milestones * 100, 1) if all_milestones > 0 else 0

    # Overall portfolio health
    if rag_counts.get("RED", 0) > 0:
        portfolio_health = "AT RISK"
    elif rag_counts.get("AMBER", 0) > len(programs) / 2:
        portfolio_health = "CAUTION"
    else:
        portfolio_health = "ON TRACK"

    # Recommendations
    recs = []
    red_programs = [p for p in program_results if p["rag_status"] == "RED"]
    if red_programs:
        for rp in red_programs:
            recs.append(f"'{rp['name']}' is RED -- escalate to steering committee with recovery plan.")
    amber_long = [p for p in program_results if p["rag_status"] == "AMBER" and p["schedule_variance_days"] > 10]
    if amber_long:
        recs.append(f"{len(amber_long)} program(s) trending toward RED. Review scope and resource options.")
    if portfolio_budget_pct > 90:
        recs.append(f"Portfolio budget is {portfolio_budget_pct:.0f}% consumed. Review remaining scope against available budget.")

    return {
        "portfolio": portfolio_name,
        "date": datetime.now().strftime("%Y-%m-%d"),
        "health": portfolio_health,
        "program_count": len(programs),
        "rag_distribution": rag_counts,
        "budget": {"total": total_budget, "spent": total_spent, "pct": portfolio_budget_pct},
        "milestones": {"total": all_milestones, "completed": completed_milestones, "pct": milestone_pct},
        "programs": program_results,
        "recommendations": recs,
    }


def print_report(result: dict) -> None:
    """Print human-readable portfolio dashboard."""
    print(f"\nPortfolio Dashboard: {result['portfolio']}")
    print(f"Date: {result['date']}  |  Programs: {result['program_count']}")
    print("=" * 70)
    print(f"Portfolio Health: {result['health']}")

    rag = result["rag_distribution"]
    print(f"RAG: GREEN={rag.get('GREEN',0)} | AMBER={rag.get('AMBER',0)} | RED={rag.get('RED',0)}")

    b = result["budget"]
    print(f"Budget: ${b['spent']:,.0f} / ${b['total']:,.0f} ({b['pct']:.1f}%)")

    m = result["milestones"]
    print(f"Milestones: {m['completed']}/{m['total']} ({m['pct']:.1f}%)")

    for prog in result["programs"]:
        print(f"\n  [{prog['rag_status']}] {prog['name']}  (Phase: {prog['phase']})")
        print(f"       Schedule: {prog['schedule_variance_days']:+d} days  |  Budget: {prog['budget_pct']:.0f}%  |  Risks: {prog['high_risks']} high")
        print(f"       Benefits: ${prog['benefits_realized']:,.0f} / ${prog['benefits_target']:,.0f} ({prog['benefits_pct']:.0f}%)")
        for proj in prog["projects"]:
            print(f"         - {proj['name']}: {proj['status']} ({proj['completion_pct']}%)  Next: {proj['next_milestone']} ({proj['next_milestone_date']})")

    if result["recommendations"]:
        print(f"\nRecommendations:")
        for i, r in enumerate(result["recommendations"], 1):
            print(f"  {i}. {r}")
    print()


def print_example() -> None:
    """Print example portfolio JSON."""
    example = {
        "name": "Digital Transformation Portfolio",
        "programs": [
            {
                "name": "Customer Platform Modernization",
                "phase": "Execution",
                "budget": 2000000,
                "spent": 1400000,
                "schedule_variance_days": -3,
                "high_risks": 1,
                "benefits_target": 5000000,
                "benefits_realized": 1200000,
                "projects": [
                    {"name": "API Migration", "status": "Complete", "milestones_total": 4, "milestones_completed": 4, "next_milestone": "N/A", "next_milestone_date": "Done"},
                    {"name": "Frontend Rebuild", "status": "In Progress", "milestones_total": 5, "milestones_completed": 3, "next_milestone": "Beta Release", "next_milestone_date": "2026-04-15"},
                ],
            },
            {
                "name": "Data Analytics Platform",
                "phase": "Planning",
                "budget": 800000,
                "spent": 120000,
                "schedule_variance_days": 0,
                "high_risks": 0,
                "benefits_target": 2000000,
                "benefits_realized": 0,
                "projects": [
                    {"name": "Data Lake Setup", "status": "In Progress", "milestones_total": 3, "milestones_completed": 1, "next_milestone": "Schema Design Complete", "next_milestone_date": "2026-04-01"},
                ],
            },
        ],
    }
    print(json.dumps(example, indent=2))


def main():
    parser = argparse.ArgumentParser(
        description="Generate program portfolio status dashboard."
    )
    parser.add_argument("--portfolio", type=str, help="Path to portfolio data JSON file")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")
    parser.add_argument("--example", action="store_true", help="Print example portfolio JSON and exit")
    args = parser.parse_args()

    if args.example:
        print_example()
        return

    if not args.portfolio:
        parser.error("--portfolio is required (use --example to see the expected format)")

    data = load_data(args.portfolio)
    result = analyze_portfolio(data)

    if args.json:
        print(json.dumps(result, indent=2))
    else:
        print_report(result)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Resource Allocator - Analyze and optimize resource allocation across projects.

Reads resource allocation data and identifies over-allocation, conflicts,
utilization gaps, and produces rebalancing recommendations.

Usage:
    python resource_allocator.py --resources resources.json
    python resource_allocator.py --resources resources.json --json
    python resource_allocator.py --example
"""

import argparse
import json
import sys
from collections import defaultdict


def load_data(path: str) -> dict:
    """Load resource data from JSON file."""
    with open(path, "r") as f:
        return json.load(f)


def analyze_resources(data: dict) -> dict:
    """Analyze resource allocation and identify conflicts."""
    program = data.get("program", "Unknown")
    resources = data.get("resources", [])
    projects = data.get("projects", [])

    # Build allocation map: person -> list of allocations
    person_allocations = defaultdict(list)
    project_allocations = defaultdict(list)

    for alloc in data.get("allocations", []):
        person = alloc.get("person", "Unknown")
        project = alloc.get("project", "Unknown")
        pct = alloc.get("allocation_pct", 0)
        role = alloc.get("role", "Team Member")
        period = alloc.get("period", "Current")

        person_allocations[person].append({
            "project": project,
            "allocation_pct": pct,
            "role": role,
            "period": period,
        })
        project_allocations[project].append({
            "person": person,
            "allocation_pct": pct,
            "role": role,
        })

    # Person-level analysis
    person_results = []
    over_allocated = []
    under_allocated = []

    for person, allocs in person_allocations.items():
        total_pct = sum(a["allocation_pct"] for a in allocs)
        project_count = len(allocs)

        status = "Balanced"
        if total_pct > 100:
            status = "Over-Allocated"
            over_allocated.append({"person": person, "total_pct": total_pct, "projects": project_count})
        elif total_pct < 50:
            status = "Under-Utilized"
            under_allocated.append({"person": person, "total_pct": total_pct, "projects": project_count})
        elif total_pct < 70:
            status = "Available Capacity"

        # Context switching penalty
        switching_penalty = 0
        if project_count >= 4:
            switching_penalty = 40
        elif project_count == 3:
            switching_penalty = 20
        elif project_count == 2:
            switching_penalty = 10
        effective_capacity = max(0, total_pct - switching_penalty)

        person_results.append({
            "person": person,
            "total_allocation_pct": total_pct,
            "effective_capacity_pct": effective_capacity,
            "project_count": project_count,
            "context_switching_penalty_pct": switching_penalty,
            "status": status,
            "allocations": allocs,
        })

    person_results.sort(key=lambda x: x["total_allocation_pct"], reverse=True)

    # Project-level analysis
    project_results = []
    for proj_name in set(a["project"] for allocs in person_allocations.values() for a in allocs):
        allocs = project_allocations.get(proj_name, [])
        total_fte = sum(a["allocation_pct"] for a in allocs) / 100
        headcount = len(allocs)
        roles = list(set(a["role"] for a in allocs))

        project_results.append({
            "project": proj_name,
            "total_fte": round(total_fte, 1),
            "headcount": headcount,
            "roles": roles,
            "team": [{"person": a["person"], "pct": a["allocation_pct"], "role": a["role"]} for a in allocs],
        })

    project_results.sort(key=lambda x: x["total_fte"], reverse=True)

    # Summary metrics
    total_people = len(person_allocations)
    total_fte = sum(p["total_allocation_pct"] for p in person_results) / 100
    avg_utilization = sum(p["total_allocation_pct"] for p in person_results) / total_people if total_people > 0 else 0
    avg_projects_per_person = sum(p["project_count"] for p in person_results) / total_people if total_people > 0 else 0

    # Recommendations
    recs = []
    if over_allocated:
        for oa in over_allocated:
            recs.append(f"{oa['person']} is at {oa['total_pct']}% across {oa['projects']} projects. Reduce allocation to <=100% to prevent burnout and quality issues.")
    if under_allocated:
        names = [ua["person"] for ua in under_allocated]
        recs.append(f"Under-utilized: {', '.join(names)}. Consider reallocating to projects with resource gaps.")

    high_switching = [p for p in person_results if p["context_switching_penalty_pct"] >= 20]
    if high_switching:
        for hs in high_switching:
            recs.append(f"{hs['person']} works on {hs['project_count']} projects (effective capacity: {hs['effective_capacity_pct']}%). Consolidate to max 2 projects for productivity.")

    if avg_utilization > 95:
        recs.append("Team is near full utilization with no slack. Add buffer capacity (aim for 80-85% utilization) to absorb unplanned work.")

    if not recs:
        recs.append("Resource allocation looks balanced. Review monthly to catch emerging conflicts early.")

    return {
        "program": program,
        "summary": {
            "total_people": total_people,
            "total_fte": round(total_fte, 1),
            "avg_utilization_pct": round(avg_utilization, 1),
            "avg_projects_per_person": round(avg_projects_per_person, 1),
            "over_allocated_count": len(over_allocated),
            "under_utilized_count": len(under_allocated),
        },
        "people": person_results,
        "projects": project_results,
        "recommendations": recs,
    }


def print_report(result: dict) -> None:
    """Print human-readable resource allocation report."""
    s = result["summary"]
    print(f"\nResource Allocation: {result['program']}")
    print("=" * 70)
    print(f"People: {s['total_people']}  |  Total FTE: {s['total_fte']}  |  Avg Utilization: {s['avg_utilization_pct']:.0f}%")
    print(f"Avg Projects/Person: {s['avg_projects_per_person']:.1f}  |  Over-allocated: {s['over_allocated_count']}  |  Under-utilized: {s['under_utilized_count']}")

    print(f"\nPerson Allocation:")
    print(f"  {'Person':<20} {'Total':>6} {'Effective':>10} {'Projects':>9} {'Status'}")
    print(f"  {'-'*20} {'-'*6} {'-'*10} {'-'*9} {'-'*15}")
    for p in result["people"]:
        print(f"  {p['person']:<20} {p['total_allocation_pct']:>5}% {p['effective_capacity_pct']:>9}% {p['project_count']:>9} {p['status']}")

    print(f"\nProject Staffing:")
    for proj in result["projects"]:
        print(f"  {proj['project']}: {proj['total_fte']:.1f} FTE ({proj['headcount']} people)")
        for member in proj["team"]:
            print(f"    - {member['person']}: {member['pct']}% ({member['role']})")

    if result["recommendations"]:
        print(f"\nRecommendations:")
        for i, r in enumerate(result["recommendations"], 1):
            print(f"  {i}. {r}")
    print()


def print_example() -> None:
    """Print example resource data JSON."""
    example = {
        "program": "Digital Transformation",
        "allocations": [
            {"person": "Alice Chen", "project": "API Migration", "allocation_pct": 80, "role": "Tech Lead"},
            {"person": "Alice Chen", "project": "Frontend Rebuild", "allocation_pct": 20, "role": "Advisor"},
            {"person": "Bob Martinez", "project": "Frontend Rebuild", "allocation_pct": 100, "role": "Engineer"},
            {"person": "Carol Davis", "project": "API Migration", "allocation_pct": 50, "role": "Engineer"},
            {"person": "Carol Davis", "project": "Analytics Platform", "allocation_pct": 50, "role": "Engineer"},
            {"person": "Carol Davis", "project": "DevOps Modernization", "allocation_pct": 30, "role": "Consultant"},
            {"person": "Dave Wilson", "project": "Analytics Platform", "allocation_pct": 40, "role": "Data Engineer"},
        ],
    }
    print(json.dumps(example, indent=2))


def main():
    parser = argparse.ArgumentParser(
        description="Analyze and optimize resource allocation across projects."
    )
    parser.add_argument("--resources", type=str, help="Path to resource allocation JSON file")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")
    parser.add_argument("--example", action="store_true", help="Print example resource data and exit")
    args = parser.parse_args()

    if args.example:
        print_example()
        return

    if not args.resources:
        parser.error("--resources is required (use --example to see the expected format)")

    data = load_data(args.resources)
    result = analyze_resources(data)

    if args.json:
        print(json.dumps(result, indent=2))
    else:
        print_report(result)


if __name__ == "__main__":
    main()