Infographic Generator

[
  {
    "template": "infographic-hero",
    "data": {
      "stat": "26%",
      "label": "Mortality Reduction",
      "context": "HR 0.74 (95% CI 0.65-0.85)",
      "source": "PARADIGM-HF Trial",
      "icon": "chart-down",
      "tag": "LANDMARK TRIAL",
      "theme": "primary"
    },
    "output": "outputs/infographics/batch-hero-paradigm.png"
  },
  {
    "template": "infographic-comparison",
    "data": {
      "tag": "TREATMENT COMPARISON",
      "title": "ACE-I vs ARB in HFrEF",
      "left": {
        "label": "ACE Inhibitors",
        "stat": "22%",
        "statLabel": "Mortality Reduction",
        "icon": "pill",
        "bullets": [
          "First-line therapy",
          "More cough (10-15%)"
        ],
        "theme": "primary"
      },
      "right": {
        "label": "ARBs",
        "stat": "18%",
        "statLabel": "Mortality Reduction",
        "icon": "shield",
        "bullets": [
          "ACE-I intolerant",
          "Better tolerated"
        ],
        "theme": "accent"
      },
      "source": "Meta-analysis, Circulation 2022"
    },
    "output": "outputs/infographics/batch-comparison-acei.png"
  },
  {
    "template": "infographic-myth",
    "data": {
      "tag": "MYTH BUSTED",
      "title": "Statins cause muscle damage in everyone",
      "myth": {
        "text": "Taking statins will definitely give you muscle pain and weakness",
        "icon": "cross"
      },
      "truth": {
        "text": "Only 5-10% experience symptoms, most can continue therapy with monitoring",
        "icon": "check"
      },
      "evidence": "Meta-analysis of 19 RCTs (n=71,000)",
      "source": "Lancet 2022"
    },
    "output": "outputs/infographics/batch-myth-statins.png"
  },
  {
    "template": "infographic-process",
    "data": {
      "tag": "TREATMENT ALGORITHM",
      "title": "Starting SGLT2 Inhibitors in HFrEF",
      "subtitle": "Step-by-step initiation guide",
      "steps": [
        {
          "title": "Screen",
          "description": "Confirm HFrEF diagnosis, check baseline eGFR",
          "icon": "magnify"
        },
        {
          "title": "Initiate",
          "description": "Start at recommended dose (no titration needed)",
          "icon": "pill"
        },
        {
          "title": "Monitor",
          "description": "Check creatinine and volume status at 1-2 weeks",
          "icon": "chart-up"
        },
        {
          "title": "Continue",
          "description": "Maintain therapy unless contraindications develop",
          "icon": "target"
        }
      ],
      "note": "eGFR ≥20 mL/min/1.73m² for most agents"
    },
    "output": "outputs/infographics/batch-process-sglt2.png"
  },
  {
    "template": "infographic-dense",
    "data": {
      "tag": "PATIENT GUIDE",
      "title": "Heart Failure Warning Signs",
      "subtitle": "When to call your doctor",
      "icon": "warning",
      "sections": [
        {
          "title": "Immediate Attention",
          "bullets": [
            "Sudden severe shortness of breath",
            "Chest pain or pressure",
            "Confusion or altered mental state"
          ],
          "icon": "ambulance",
          "accent": "danger"
        },
        {
          "title": "Call Within 24 Hours",
          "bullets": [
            "Weight gain >2 kg in 1 week",
            "Increasing leg swelling",
            "Can't sleep flat anymore"
          ],
          "icon": "warning",
          "accent": "accent"
        },
        {
          "title": "Routine Follow-up",
          "bullets": [
            "Mild exercise intolerance",
            "Medication side effects",
            "Diet questions"
          ],
          "icon": "clock",
          "accent": "teal"
        }
      ],
      "callout": {
        "label": "Remember",
        "text": "Early intervention prevents hospitalization"
      }
    },
    "output": "outputs/infographics/batch-dense-warning.png"
  },
  {
    "template": "infographic-checklist",
    "data": {
      "tag": "PATIENT CHECKLIST",
      "title": "Before Your Stress Test",
      "subtitle": "Complete preparation guide",
      "icon": "heart-pulse",
      "categories": [
        {
          "title": "24 Hours Before",
          "items": [
            {"text": "Avoid caffeine (coffee, tea, chocolate)"},
            {"text": "Continue all medications unless told otherwise"},
            {"text": "Get good sleep (7-8 hours)"}
          ]
        },
        {
          "title": "Day of Test",
          "items": [
            {"text": "Wear comfortable shoes and loose clothing"},
            {"text": "Bring list of current medications"},
            {"text": "Light meal 2-3 hours before (avoid heavy foods)"},
            {"text": "Arrive 15 minutes early"}
          ]
        },
        {
          "title": "What to Bring",
          "items": [
            {"text": "Photo ID and insurance card"},
            {"text": "Medication list"},
            {"text": "Previous test results if available"}
          ]
        }
      ],
      "callout": {
        "icon": "warning",
        "text": "Tell staff immediately if you experience chest pain, dizziness, or severe shortness of breath"
      }
    },
    "output": "outputs/infographics/batch-checklist-stress.png"
  }
]

#!/usr/bin/env python3
"""
Batch Infographic Generator

Generate multiple infographics from a batch configuration file.
Useful for creating complete content sets for articles, social media campaigns,
or systematic documentation.

Usage:
    # From JSON file
    python batch_generate.py --config batch_config.json

    # From YAML file
    python batch_generate.py --config batch_config.yaml --parallel 4

    # From inline JSON
    python batch_generate.py --json '[{"template": "infographic-hero", "data": {...}, "output": "hero.png"}]'

Example Config (JSON):
    [
        {
            "template": "infographic-hero",
            "data": {
                "stat": "26%",
                "label": "Mortality Reduction",
                "source": "PARADIGM-HF",
                "icon": "chart-down",
                "tag": "CLINICAL TRIAL"
            },
            "output": "outputs/hero-paradigm.png"
        },
        {
            "template": "infographic-comparison",
            "data": {
                "tag": "TREATMENT CHOICE",
                "title": "ACE-I vs ARB",
                "left": {...},
                "right": {...}
            },
            "output": "outputs/comparison-acei.png"
        }
    ]

Example Config (YAML):
    - template: infographic-hero
      data:
        stat: "26%"
        label: "Mortality Reduction"
        source: "PARADIGM-HF"
      output: "outputs/hero.png"

    - template: infographic-myth
      data:
        tag: "MYTH BUSTED"
        title: "Statins cause muscle damage"
        myth:
          text: "Taking statins will give you muscle pain"
        truth:
          text: "Only 5-10% experience symptoms"
      output: "outputs/myth-statins.png"
"""

import argparse
import json
import sys
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
from typing import Any, Dict, List
import importlib.util

# Import the generator
ROOT = Path(__file__).resolve().parents[1]
GENERATOR_PATH = ROOT.parent / "visual-design-system/scripts/generate_infographic.py"


def load_generator():
    """Load the infographic generator module."""
    if not GENERATOR_PATH.exists():
        raise FileNotFoundError(f"Missing generator: {GENERATOR_PATH}")

    spec = importlib.util.spec_from_file_location("generate_infographic", GENERATOR_PATH)
    module = importlib.util.module_from_spec(spec)
    if spec.loader is None:
        raise RuntimeError("Failed to load generator module")
    spec.loader.exec_module(module)
    return module


def load_config(config_path: Path) -> List[Dict[str, Any]]:
    """
    Load batch configuration from JSON or YAML file.

    Args:
        config_path: Path to config file (.json or .yaml/.yml)

    Returns:
        List of infographic configs
    """
    if not config_path.exists():
        raise FileNotFoundError(f"Config file not found: {config_path}")

    content = config_path.read_text()

    if config_path.suffix == '.json':
        return json.loads(content)
    elif config_path.suffix in ['.yaml', '.yml']:
        try:
            import yaml
            return yaml.safe_load(content)
        except ImportError:
            print("Error: PyYAML not installed. Install with: pip install pyyaml")
            sys.exit(1)
    else:
        raise ValueError(f"Unsupported config format: {config_path.suffix}")


def validate_item(item: Dict[str, Any], index: int) -> Dict[str, str]:
    """
    Validate a single batch item.

    Args:
        item: Batch item config
        index: Item index (for error messages)

    Returns:
        Dict with validation errors (empty if valid)
    """
    errors = {}

    if 'template' not in item:
        errors['template'] = f"Item {index}: Missing 'template' field"

    if 'data' not in item:
        errors['data'] = f"Item {index}: Missing 'data' field"

    if 'output' not in item:
        errors['output'] = f"Item {index}: Missing 'output' field"

    return errors


def generate_one(generator, item: Dict[str, Any], index: int) -> Dict[str, Any]:
    """
    Generate a single infographic.

    Args:
        generator: Generator module
        item: Batch item config
        index: Item index

    Returns:
        Result dict with success status
    """
    template = item['template']
    data = item['data']
    output = item['output']
    width = item.get('width', 1080)
    height = item.get('height', 1350)

    print(f"[{index + 1}] Generating {template} → {output}")

    result = generator.generate(
        template,
        data,
        output,
        width=width,
        height=height
    )

    result['index'] = index
    result['template'] = template
    result['output'] = output

    return result


def generate_batch(
    items: List[Dict[str, Any]],
    parallel: int = 1,
    stop_on_error: bool = False
) -> Dict[str, Any]:
    """
    Generate multiple infographics.

    Args:
        items: List of batch item configs
        parallel: Number of parallel workers (1 = sequential)
        stop_on_error: Stop on first error if True

    Returns:
        Summary dict with success/failure counts
    """
    generator = load_generator()

    # Validate all items first
    print(f"Validating {len(items)} items...")
    all_errors = []
    for i, item in enumerate(items):
        errors = validate_item(item, i)
        if errors:
            all_errors.extend(errors.values())

    if all_errors:
        print("\nValidation errors:")
        for error in all_errors:
            print(f"  ❌ {error}")
        return {
            'success': False,
            'total': len(items),
            'completed': 0,
            'failed': len(items),
            'errors': all_errors
        }

    # Generate infographics
    print(f"\nGenerating {len(items)} infographics (parallel={parallel})...")

    results = {
        'success': True,
        'total': len(items),
        'completed': 0,
        'failed': 0,
        'items': []
    }

    if parallel == 1:
        # Sequential generation
        for i, item in enumerate(items):
            result = generate_one(generator, item, i)
            results['items'].append(result)

            if result.get('success'):
                results['completed'] += 1
                print(f"  ✅ {result['output']}")
            else:
                results['failed'] += 1
                print(f"  ❌ {result['output']}: {result.get('error')}")
                if stop_on_error:
                    results['success'] = False
                    break
    else:
        # Parallel generation
        with ThreadPoolExecutor(max_workers=parallel) as executor:
            futures = {
                executor.submit(generate_one, generator, item, i): i
                for i, item in enumerate(items)
            }

            for future in as_completed(futures):
                result = future.result()
                results['items'].append(result)

                if result.get('success'):
                    results['completed'] += 1
                    print(f"  ✅ {result['output']}")
                else:
                    results['failed'] += 1
                    print(f"  ❌ {result['output']}: {result.get('error')}")
                    if stop_on_error:
                        results['success'] = False
                        executor.shutdown(wait=False, cancel_futures=True)
                        break

    # Sort results by index
    results['items'].sort(key=lambda x: x.get('index', 0))

    return results


def main() -> int:
    """CLI entry point."""
    parser = argparse.ArgumentParser(
        description="Generate multiple infographics from a batch config",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog=__doc__
    )

    parser.add_argument(
        '--config',
        type=Path,
        help='Path to batch config file (.json or .yaml)'
    )
    parser.add_argument(
        '--json',
        help='Inline JSON config string'
    )
    parser.add_argument(
        '--parallel',
        type=int,
        default=1,
        help='Number of parallel workers (default: 1 = sequential)'
    )
    parser.add_argument(
        '--stop-on-error',
        action='store_true',
        help='Stop on first error'
    )
    parser.add_argument(
        '--dry-run',
        action='store_true',
        help='Validate config without generating'
    )

    args = parser.parse_args()

    # Load config
    if args.config and args.json:
        print("Error: Specify only one of --config or --json")
        return 1

    if args.config:
        items = load_config(args.config)
    elif args.json:
        items = json.loads(args.json)
    else:
        print("Error: Must specify --config or --json")
        return 1

    if not items:
        print("Error: Config is empty")
        return 1

    # Dry run - validate only
    if args.dry_run:
        print(f"Validating {len(items)} items...")
        all_errors = []
        for i, item in enumerate(items):
            errors = validate_item(item, i)
            if errors:
                all_errors.extend(errors.values())

        if all_errors:
            print("\nValidation errors:")
            for error in all_errors:
                print(f"  ❌ {error}")
            return 1
        else:
            print(f"✅ All {len(items)} items valid")
            return 0

    # Generate
    results = generate_batch(
        items,
        parallel=args.parallel,
        stop_on_error=args.stop_on_error
    )

    # Print summary
    print("\n" + "=" * 60)
    print(f"Batch Generation Summary")
    print("=" * 60)
    print(f"Total:     {results['total']}")
    print(f"Completed: {results['completed']} ✅")
    print(f"Failed:    {results['failed']} ❌")
    print("=" * 60)

    if results['failed'] > 0:
        print("\nFailed items:")
        for item in results['items']:
            if not item.get('success'):
                print(f"  ❌ {item['template']} → {item['output']}")
                print(f"     {item.get('error')}")

    return 0 if results['success'] and results['failed'] == 0 else 1


if __name__ == "__main__":
    sys.exit(main())

#!/usr/bin/env python3
"""
Infographic CLI wrapper.

Defaults to 1080x1350 and routes generation through the visual-design-system
Satori pipeline.
"""

import argparse
import json
import sys
import importlib.util
from pathlib import Path
from typing import Optional

ROOT = Path(__file__).resolve().parents[4]
GENERATOR_PATH = ROOT / "skills/cardiology/visual-design-system/scripts/generate_infographic.py"
DEFAULT_OUT_DIR = ROOT / "skills/cardiology/visual-design-system/outputs/infographics"


def load_generator():
    if not GENERATOR_PATH.exists():
        raise FileNotFoundError(f"Missing generator script: {GENERATOR_PATH}")
    spec = importlib.util.spec_from_file_location("generate_infographic", GENERATOR_PATH)
    module = importlib.util.module_from_spec(spec)
    if spec.loader is None:
        raise RuntimeError("Failed to load infographic generator module")
    spec.loader.exec_module(module)
    return module


def read_data(args):
    if args.data and args.data_file:
        raise ValueError("Use only one of --data or --data-file")
    if args.data_file:
        data_path = Path(args.data_file)
        return json.loads(data_path.read_text())
    if args.data:
        return json.loads(args.data)
    raise ValueError("Missing infographic data. Provide --data or --data-file")


def resolve_output(path_value: Optional[str], template: str) -> Path:
    if path_value:
        return Path(path_value)
    DEFAULT_OUT_DIR.mkdir(parents=True, exist_ok=True)
    return DEFAULT_OUT_DIR / f"{template}.png"


def main() -> int:
    parser = argparse.ArgumentParser(
        description="Generate infographic outputs using the visual-design-system."
    )
    parser.add_argument("--template", help="Template name (stat-card, comparison, process-flow, trial-summary, key-finding)")
    parser.add_argument("--data", help="JSON data string")
    parser.add_argument("--data-file", help="Path to JSON file")
    parser.add_argument("--output", help="Output PNG path")
    parser.add_argument("--width", type=int, default=1080)
    parser.add_argument("--height", type=int, default=1350)
    parser.add_argument("--list", action="store_true", help="List available templates")

    args = parser.parse_args()

    module = load_generator()

    if args.list:
        templates = module.list_templates()
        print("Available templates:")
        for name in templates:
            print(f"- {name}")
        return 0

    if not args.template:
        print("Error: --template is required (or use --list)", file=sys.stderr)
        return 1

    try:
        data = read_data(args)
    except ValueError as exc:
        print(f"Error: {exc}", file=sys.stderr)
        return 1

    output_path = resolve_output(args.output, args.template)

    result = module.generate(
        args.template,
        data,
        str(output_path),
        width=args.width,
        height=args.height,
    )

    if result.get("success"):
        print(f"Generated: {result.get('output')}")
        return 0

    print(f"Error: {result.get('error')}", file=sys.stderr)
    if result.get("stdout"):
        print(result.get("stdout"), file=sys.stderr)
    return 1


if __name__ == "__main__":
    raise SystemExit(main())