Badge Generation & Template Sync Pipeline Architecture

import hashlib
import json
import logging
import time
import uuid
from dataclasses import dataclass, field
from enum import Enum
from typing import Any, Dict, Optional

# Configure structured logging for observability
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s"
)
logger = logging.getLogger("badge_pipeline")

class PipelineError(Exception):
    """Base exception for pipeline failures."""
    pass

class ValidationError(PipelineError):
    pass

class TemplateSyncError(PipelineError):
    pass

@dataclass
class BadgePayload:
    attendee_id: str
    full_name: str
    tier: str
    session_ids: list[str]
    dietary_flags: list[str] = field(default_factory=list)

@dataclass
class PipelineResult:
    success: bool
    badge_id: str
    error: Optional[str] = None
    retry_count: int = 0

class BadgePipeline:
    def __init__(self, max_retries: int = 3, base_delay: float = 0.5):
        self.max_retries = max_retries
        self.base_delay = base_delay
        self._template_version: str = "v1.0.0"
        self._template_hash: str = "a1b2c3d4e5f6"  # Simulated registry hash

    def validate_payload(self, raw: Dict[str, Any]) -> BadgePayload:
        """Strict contract enforcement with explicit error paths."""
        try:
            required = {"attendee_id", "full_name", "tier", "session_ids"}
            missing = required - set(raw.keys())
            if missing:
                raise ValidationError(f"Missing required fields: {missing}")
            
            if not isinstance(raw["session_ids"], list):
                raise ValidationError("session_ids must be a list")
                
            return BadgePayload(
                attendee_id=str(raw["attendee_id"]).strip().upper(),
                full_name=str(raw["full_name"]).strip().title(),
                tier=str(raw["tier"]).strip().upper(),
                session_ids=[str(s).strip() for s in raw["session_ids"]],
                dietary_flags=[str(f).strip().lower() for f in raw.get("dietary_flags", [])]
            )
        except ValidationError as e:
            logger.error("Validation failed | correlation_id=%s | error=%s", raw.get("correlation_id"), e)
            raise
        except Exception as e:
            raise ValidationError(f"Unexpected validation error: {e}") from e

    def sync_template(self, registry_hash: str) -> None:
        """Atomic template synchronization with drift prevention."""
        if registry_hash != self._template_hash:
            logger.warning("Template drift detected | expected=%s | received=%s", self._template_hash, registry_hash)
            # In production: fetch new template, verify checksum, run dry-run
            try:
                # Simulate dry-run validation
                self._run_dry_run()
                self._template_hash = registry_hash
                self._template_version = f"v{time.time():.0f}"
                logger.info("Template promoted | version=%s", self._template_version)
            except Exception as e:
                raise TemplateSyncError(f"Template sync failed: {e}") from e

    def _run_dry_run(self) -> None:
        """Synthetic validation before deployment."""
        logger.info("Executing dry-run validation against synthetic dataset...")
        # Simulate coordinate alignment check
        time.sleep(0.01)

    def render_and_route(self, payload: BadgePayload) -> PipelineResult:
        """Idempotent rendering with explicit retry logic."""
        correlation_id = str(uuid.uuid4())
        attempt = 0
        while attempt <= self.max_retries:
            try:
                logger.info("Rendering badge | attendee=%s | attempt=%d", payload.attendee_id, attempt)
                
                # Simulate QR/Barcode generation & PDF assembly
                self._generate_assets(payload)
                
                # Simulate routing to print queue
                self._dispatch_to_queue(payload)
                
                return PipelineResult(success=True, badge_id=f"BDG-{payload.attendee_id}", retry_count=attempt)
            except Exception as e:
                attempt += 1
                if attempt > self.max_retries:
                    logger.critical("Render exhausted retries | attendee=%s | error=%s", payload.attendee_id, e)
                    return PipelineResult(success=False, badge_id="", error=str(e), retry_count=attempt)
                
                delay = self.base_delay * (2 ** (attempt - 1))
                logger.warning("Render failed, retrying | delay=%.2fs | error=%s", delay, e)
                time.sleep(delay)
        return PipelineResult(success=False, badge_id="", error="Unknown failure", retry_count=attempt)

    def _generate_assets(self, payload: BadgePayload) -> None:
        """Deterministic asset generation with explicit bounds."""
        if not payload.full_name:
            raise PipelineError("Name field empty after normalization")
        # In production: call rendering engine, embed QR/barcode, validate PDF/A compliance
        pass

    def _dispatch_to_queue(self, payload: BadgePayload) -> None:
        """Queue dispatch with backpressure awareness."""
        # In production: check printer buffer, apply circuit breaker if saturated
        pass

def run_pipeline(raw_payload: Dict[str, Any], template_hash: str) -> PipelineResult:
    pipeline = BadgePipeline(max_retries=3, base_delay=0.5)
    try:
        validated = pipeline.validate_payload(raw_payload)
        pipeline.sync_template(template_hash)
        return pipeline.render_and_route(validated)
    except ValidationError as e:
        return PipelineResult(success=False, badge_id="", error=str(e))
    except TemplateSyncError as e:
        return PipelineResult(success=False, badge_id="", error=str(e))

# Example execution
if __name__ == "__main__":
    test_payload = {
        "attendee_id": "ATT-9921",
        "full_name": "  jane doe  ",
        "tier": "vip",
        "session_ids": ["KEY-01", "WS-04"],
        "dietary_flags": ["vegan", "gluten-free"],
        "correlation_id": "req-8832"
    }
    result = run_pipeline(test_payload, "a1b2c3d4e5f6")
    print(json.dumps(result.__dict__, indent=2))