superset-showtime 0.1.0__py3-none-any.whl

showtime/core/circus.py

@@ -0,0 +1,285 @@
+"""
+🎪 Circus tent emoji label parsing and state management
+
+Core logic for parsing GitHub labels with circus tent emoji patterns.
+"""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import TYPE_CHECKING, List, Optional
+
+if TYPE_CHECKING:
+    from .github import GitHubInterface
+
+
+@dataclass
+class Show:
+    """Single ephemeral environment state from circus labels"""
+
+    pr_number: int
+    sha: str  # 7-char commit SHA
+    status: str  # building, running, updating, failed
+    ip: Optional[str] = None  # Environment IP address
+    created_at: Optional[str] = None  # ISO timestamp
+    ttl: str = "24h"  # 24h, 48h, close, etc.
+    requested_by: Optional[str] = None  # GitHub username
+    config: str = "standard"  # Configuration (alerts,debug)
+
+    @property
+    def aws_service_name(self) -> str:
+        """Deterministic ECS service name: pr-{pr_number}-{sha}"""
+        return f"pr-{self.pr_number}-{self.sha}"
+
+    @property
+    def aws_image_tag(self) -> str:
+        """Deterministic ECR image tag: pr-{pr_number}-{sha}-ci"""
+        return f"pr-{self.pr_number}-{self.sha}-ci"
+
+    @property
+    def is_active(self) -> bool:
+        """Check if this is the currently active show"""
+        return self.status == "running"
+
+    @property
+    def is_building(self) -> bool:
+        """Check if environment is currently building"""
+        return self.status == "building"
+
+    @property
+    def is_updating(self) -> bool:
+        """Check if environment is currently updating"""
+        return self.status == "updating"
+
+    def needs_update(self, latest_sha: str) -> bool:
+        """Check if environment needs update to latest SHA"""
+        return self.sha != latest_sha[:7]
+
+    def to_circus_labels(self) -> List[str]:
+        """Convert show state to circus tent emoji labels (per-SHA format)"""
+        if not self.created_at:
+            self.created_at = datetime.utcnow().strftime("%Y-%m-%dT%H-%M")
+
+        labels = [
+            f"🎪 {self.sha} 🚦 {self.status}",  # SHA-first status
+            f"🎪 🎯 {self.sha}",  # Active pointer (no value)
+            f"🎪 {self.sha} 📅 {self.created_at}",  # SHA-first timestamp
+            f"🎪 {self.sha} ⌛ {self.ttl}",  # SHA-first TTL
+        ]
+
+        if self.ip:
+            labels.append(f"🎪 {self.sha} 🌐 {self.ip}:8080")
+
+        if self.requested_by:
+            labels.append(f"🎪 {self.sha} 🤡 {self.requested_by}")
+
+        if self.config != "standard":
+            labels.append(f"🎪 {self.sha} ⚙️ {self.config}")
+
+        return labels
+
+    @classmethod
+    def from_circus_labels(cls, pr_number: int, labels: List[str], sha: str) -> Optional["Show"]:
+        """Create Show from circus tent labels for specific SHA"""
+        show_data = {
+            "pr_number": pr_number,
+            "sha": sha,
+            "status": "building",  # default
+        }
+
+        for label in labels:
+            if not label.startswith("🎪 "):
+                continue
+
+            parts = label.split(" ", 3)  # Split into 4 parts for per-SHA format
+
+            if len(parts) == 3:  # Old format: 🎪 🎯 sha
+                emoji, value = parts[1], parts[2]
+                if emoji == "🎯" and value == sha:  # Active pointer
+                    pass  # This SHA is active
+            elif len(parts) == 4:  # SHA-first format: 🎪 sha 🚦 status
+                label_sha, emoji, value = parts[1], parts[2], parts[3]
+
+                if label_sha != sha:  # Only process labels for this SHA
+                    continue
+
+                if emoji == "🚦":  # Status
+                    show_data["status"] = value
+                elif emoji == "📅":  # Timestamp
+                    show_data["created_at"] = value
+                elif emoji == "🌐":  # IP with port
+                    show_data["ip"] = value.replace(":8080", "")  # Remove port for storage
+                elif emoji == "⌛":  # TTL
+                    show_data["ttl"] = value
+                elif emoji == "🤡":  # User (clown!)
+                    show_data["requested_by"] = value
+                elif emoji == "⚙️":  # Config
+                    show_data["config"] = value
+
+        # Only return Show if we found relevant labels for this SHA
+        if any(label.endswith(f" {sha}") for label in labels if "🎯" in label or "🏗️" in label):
+            return cls(**show_data)
+
+        return None
+
+
+class PullRequest:
+    """GitHub PR with its shows parsed from circus labels"""
+
+    def __init__(self, pr_number: int, labels: List[str]):
+        self.pr_number = pr_number
+        self.labels = labels
+        self._shows = self._parse_shows_from_labels()
+
+    @property
+    def shows(self) -> List[Show]:
+        """All shows found in labels"""
+        return self._shows
+
+    @property
+    def current_show(self) -> Optional[Show]:
+        """The currently active show (from 🎯 label)"""
+        # Find the SHA that's marked as active (🎯)
+        active_sha = None
+        for label in self.labels:
+            if label.startswith("🎪 🎯 "):
+                active_sha = label.split(" ")[2]
+                break
+
+        if not active_sha:
+            return None
+
+        # Find the show with that SHA
+        for show in self.shows:
+            if show.sha == active_sha:
+                return show
+
+        return None
+
+    @property
+    def building_show(self) -> Optional[Show]:
+        """Show currently being built (from 🏗️ label)"""
+        building_sha = None
+        for label in self.labels:
+            if label.startswith("🎪 🏗️ "):
+                building_sha = label.split(" ")[2]
+                break
+
+        if not building_sha:
+            return None
+
+        for show in self.shows:
+            if show.sha == building_sha:
+                return show
+
+        return None
+
+    @property
+    def circus_labels(self) -> List[str]:
+        """All circus tent labels"""
+        return [label for label in self.labels if label.startswith("🎪 ")]
+
+    def has_shows(self) -> bool:
+        """Check if PR has any shows"""
+        return len(self.shows) > 0
+
+    def get_show_by_sha(self, sha: str) -> Optional[Show]:
+        """Get specific show by SHA"""
+        for show in self.shows:
+            if show.sha == sha[:7]:
+                return show
+        return None
+
+    def _parse_shows_from_labels(self) -> List[Show]:
+        """Parse all shows from circus labels"""
+        shows = []
+
+        # Find all unique SHAs mentioned in labels
+        shas = set()
+        for label in self.labels:
+            if label.startswith("🎪 🎯 ") or label.startswith("🎪 🏗️ "):
+                sha = label.split(" ")[2]
+                shas.add(sha)
+
+        # Create Show object for each SHA
+        for sha in shas:
+            show = Show.from_circus_labels(self.pr_number, self.labels, sha)
+            if show:
+                shows.append(show)
+
+        return shows
+
+    @classmethod
+    def from_id(cls, pr_number: int, github: "GitHubInterface") -> "PullRequest":
+        """Load PR with current labels from GitHub"""
+        labels = github.get_labels(pr_number)
+        return cls(pr_number, labels)
+
+    def refresh_labels(self, github: "GitHubInterface") -> None:
+        """Refresh labels from GitHub and reparse shows"""
+        self.labels = github.get_labels(self.pr_number)
+        self._shows = self._parse_shows_from_labels()
+
+
+# Utility functions for configuration label handling
+def is_configuration_label(label: str) -> bool:
+    """Check if label is a configuration command"""
+    return label.startswith("🎪 conf-")
+
+
+def parse_configuration_command(label: str) -> Optional[str]:
+    """
+    Parse configuration command from label
+
+    Args:
+        label: Label like "🎪 conf-enable-ALERTS"
+
+    Returns:
+        Command string like "enable-ALERTS" or None if not a config label
+    """
+    if not is_configuration_label(label):
+        return None
+
+    return label.replace("🎪 conf-", "")
+
+
+def merge_config(current_config: str, command: str) -> str:
+    """
+    Merge new configuration command into existing config
+
+    Args:
+        current_config: Current config string like "standard,alerts"
+        command: New command like "enable-DASHBOARD_RBAC" or "disable-ALERTS"
+
+    Returns:
+        Updated config string
+    """
+    configs = current_config.split(",") if current_config != "standard" else []
+
+    # Handle feature flag commands
+    if command.startswith("enable-"):
+        feature = command.replace("enable-", "").lower()
+        configs = [c for c in configs if not c.startswith(f"no-{feature}")]
+        configs.append(feature)
+
+    elif command.startswith("disable-"):
+        feature = command.replace("disable-", "").lower()
+        configs = [c for c in configs if c != feature]
+        configs.append(f"no-{feature}")
+
+    # Handle debug toggle commands
+    elif command == "debug-on":
+        configs = [c for c in configs if c != "debug"]
+        configs.append("debug")
+
+    elif command == "debug-off":
+        configs = [c for c in configs if c != "debug"]
+
+    # Handle size commands
+    elif command.startswith("size-"):
+        size = command  # Keep full size command
+        configs = [c for c in configs if not c.startswith("size-")]
+        configs.append(size)
+
+    # Return cleaned config
+    unique_configs = list(dict.fromkeys(configs))  # Remove duplicates, preserve order
+    return ",".join(unique_configs) if unique_configs else "standard"

showtime/core/config.py

@@ -0,0 +1,152 @@
+"""
+🎪 Showtime configuration management
+
+Handles configuration for GitHub API, AWS credentials, and showtime settings.
+"""
+
+import os
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Optional
+
+import yaml
+from rich.console import Console
+from rich.prompt import Prompt
+
+console = Console()
+
+
+@dataclass
+class ShowtimeConfig:
+    """Showtime configuration settings"""
+
+    # GitHub settings
+    github_token: str
+    github_org: str
+    github_repo: str
+
+    # AWS settings
+    aws_profile: str = "default"
+    aws_region: str = "us-west-2"
+
+    # Circus settings
+    default_ttl: str = "24h"
+    default_size: str = "standard"
+
+    # ECS settings
+    ecs_cluster: str = "superset-ci"
+    ecs_task_family: str = "superset-ci"
+    ecr_repository: str = "superset-ci"
+
+    @property
+    def config_path(self) -> Path:
+        """Path to configuration file"""
+        config_dir = Path.home() / ".showtime"
+        config_dir.mkdir(exist_ok=True)
+        return config_dir / "config.yml"
+
+    @classmethod
+    def get_config_path(cls) -> Path:
+        """Get path to configuration file"""
+        config_dir = Path.home() / ".showtime"
+        config_dir.mkdir(exist_ok=True)
+        return config_dir / "config.yml"
+
+    @classmethod
+    def load(cls) -> "ShowtimeConfig":
+        """Load configuration from file"""
+        config_path = cls.get_config_path()
+
+        if not config_path.exists():
+            raise FileNotFoundError(
+                f"Configuration file not found at {config_path}. "
+                f"Run 'showtime init' to create it."
+            )
+
+        with open(config_path) as f:
+            data = yaml.safe_load(f)
+
+        return cls(**data)
+
+    def save(self) -> None:
+        """Save configuration to file"""
+        with open(self.config_path, "w") as f:
+            yaml.safe_dump(asdict(self), f, default_flow_style=False)
+
+    @classmethod
+    def create_interactive(
+        cls,
+        github_token: Optional[str] = None,
+        aws_profile: Optional[str] = None,
+        region: Optional[str] = None,
+    ) -> "ShowtimeConfig":
+        """Create configuration interactively"""
+
+        console.print("🎪 [bold blue]Welcome to Showtime! Let's set up your circus...[/bold blue]")
+        console.print()
+
+        # GitHub configuration
+        if not github_token:
+            github_token = Prompt.ask(
+                "GitHub personal access token", default=os.getenv("GITHUB_TOKEN", ""), password=True
+            )
+
+        github_org = Prompt.ask("GitHub organization", default="apache")
+
+        github_repo = Prompt.ask("GitHub repository", default="superset")
+
+        # AWS configuration
+        if not aws_profile:
+            aws_profile = Prompt.ask("AWS profile", default="default")
+
+        if not region:
+            region = Prompt.ask("AWS region", default="us-west-2")
+
+        # Circus settings
+        default_ttl = Prompt.ask(
+            "Default environment TTL",
+            default="24h",
+            choices=["24h", "48h", "1w", "close", "manual"],
+        )
+
+        default_size = Prompt.ask(
+            "Default environment size", default="standard", choices=["standard", "large"]
+        )
+
+        # ECS settings (with smart defaults)
+        ecs_cluster = Prompt.ask("ECS cluster name", default="superset-ci")
+
+        console.print()
+        console.print("🎪 [bold green]Configuration complete![/bold green]")
+
+        return cls(
+            github_token=github_token,
+            github_org=github_org,
+            github_repo=github_repo,
+            aws_profile=aws_profile,
+            aws_region=region,
+            default_ttl=default_ttl,
+            default_size=default_size,
+            ecs_cluster=ecs_cluster,
+        )
+
+    def validate(self) -> bool:
+        """Validate configuration settings"""
+        errors = []
+
+        if not self.github_token:
+            errors.append("GitHub token is required")
+
+        if not self.github_org:
+            errors.append("GitHub organization is required")
+
+        if not self.github_repo:
+            errors.append("GitHub repository is required")
+
+        if errors:
+            console.print("🎪 [bold red]Configuration errors:[/bold red]")
+            for error in errors:
+                console.print(f"  • {error}")
+            return False
+
+        return True

showtime/core/emojis.py

@@ -0,0 +1,86 @@
+"""
+🎪 Emoji mappings and constants for circus tent state management
+
+Central place for all emoji meanings and mappings.
+"""
+
+# Core circus tent emoji
+CIRCUS_PREFIX = "🎪"
+
+# Meta emoji dictionary
+EMOJI_MEANINGS = {
+    # Status indicators
+    "🚦": "status",  # Traffic light for environment status
+    "🏗️": "building",  # Construction for building environments
+    "🎯": "active",  # Target for currently active environment
+    # Metadata
+    "📅": "created_at",  # Calendar for creation timestamp
+    "🌐": "ip",  # Globe for IP address
+    "⌛": "ttl",  # Hourglass for time-to-live
+    "🤡": "requested_by",  # Clown for who requested (circus theme!)
+    "⚙️": "config",  # Gear for configuration
+}
+
+# Reverse mapping for creating labels
+MEANING_TO_EMOJI = {v: k for k, v in EMOJI_MEANINGS.items()}
+
+# Status display emojis (for CLI output)
+STATUS_DISPLAY = {
+    "building": "🏗️",
+    "running": "🟢",
+    "updating": "🔄",
+    "failed": "❌",
+    "configuring": "⚙️",
+    "stopping": "🛑",
+}
+
+# Configuration command prefixes
+CONFIG_PREFIX = f"{CIRCUS_PREFIX} conf-"
+
+
+def create_circus_label(emoji_key: str, value: str) -> str:
+    """Create a circus tent label with proper spacing"""
+    emoji = MEANING_TO_EMOJI.get(emoji_key)
+    if not emoji:
+        raise ValueError(f"Unknown emoji key: {emoji_key}")
+
+    return f"{CIRCUS_PREFIX} {emoji} {value}"
+
+
+def parse_circus_label(label: str) -> tuple[str, str]:
+    """
+    Parse a circus tent label into emoji meaning and value
+
+    Args:
+        label: Label like "🎪 🚦 running"
+
+    Returns:
+        Tuple of (meaning, value) like ("status", "running")
+
+    Raises:
+        ValueError: If not a valid circus label
+    """
+    if not label.startswith(f"{CIRCUS_PREFIX} "):
+        raise ValueError(f"Not a circus label: {label}")
+
+    parts = label.split(" ", 2)
+    if len(parts) < 3:
+        raise ValueError(f"Invalid circus label format: {label}")
+
+    emoji, value = parts[1], parts[2]
+    meaning = EMOJI_MEANINGS.get(emoji)
+
+    if not meaning:
+        raise ValueError(f"Unknown circus emoji: {emoji}")
+
+    return meaning, value
+
+
+def is_circus_label(label: str) -> bool:
+    """Check if label is a circus tent label"""
+    return label.startswith(f"{CIRCUS_PREFIX} ")
+
+
+def is_configuration_command(label: str) -> bool:
+    """Check if label is a configuration command"""
+    return label.startswith(CONFIG_PREFIX)