superset-showtime 0.2.9__py3-none-any.whl → 0.4.2__py3-none-any.whl

showtime/core/show.py

@@ -0,0 +1,279 @@
+"""
+🎪 Show class - Individual ephemeral environment management
+
+Single environment operations: Docker build, AWS deployment, state transitions.
+"""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import List, Optional
+
+
+# Import interfaces for singleton access
+# Note: These will be imported when the module loads, creating singletons
+def get_interfaces():  # type: ignore
+    """Lazy-load interfaces to avoid circular imports"""
+    from .aws import AWSInterface
+    from .github import GitHubInterface
+
+    return GitHubInterface(), AWSInterface()
+
+
+@dataclass
+class Show:
+    """Single ephemeral environment state from circus labels"""
+
+    pr_number: int
+    sha: str  # 7-char commit SHA
+    status: str  # building, built, deploying, 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
+
+    @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 ecs_service_name(self) -> str:
+        """ECS service name with -service suffix"""
+        return f"{self.aws_service_name}-service"
+
+    @property
+    def aws_image_tag(self) -> str:
+        """Deterministic Docker image tag: pr-{pr_number}-{sha}-ci"""
+        return f"pr-{self.pr_number}-{self.sha}-ci"
+
+    @property
+    def short_sha(self) -> str:
+        """Return the short SHA (already short)"""
+        return self.sha
+
+    @property
+    def is_running(self) -> bool:
+        """Check if environment is currently running"""
+        return self.status == "running"
+
+    @property
+    def is_building(self) -> bool:
+        """Check if environment is currently building"""
+        return self.status == "building"
+
+    @property
+    def is_built(self) -> bool:
+        """Check if environment is built (Docker complete, ready for deploy)"""
+        return self.status == "built"
+
+    @property
+    def is_deploying(self) -> bool:
+        """Check if environment is currently deploying to AWS"""
+        return self.status == "deploying"
+
+    @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 is_expired(self, max_age_hours: int) -> bool:
+        """Check if this environment is expired based on age"""
+        if not self.created_at:
+            return False
+
+        try:
+            from datetime import datetime, timedelta
+
+            created_time = datetime.fromisoformat(self.created_at.replace("-", ":"))
+            expiry_time = created_time + timedelta(hours=max_age_hours)
+            return datetime.now() > expiry_time
+        except (ValueError, AttributeError):
+            return False  # If we can't parse, assume not expired
+
+    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}")
+
+        return labels
+
+    def build_docker(self, dry_run: bool = False) -> None:
+        """Build Docker image for this environment (atomic operation)"""
+        if not dry_run:
+            self._build_docker_image()  # Raises on failure
+
+    def deploy_aws(self, dry_run: bool = False) -> None:
+        """Deploy to AWS (atomic operation)"""
+        github, aws = get_interfaces()
+
+        if not dry_run:
+            result = aws.create_environment(
+                pr_number=self.pr_number,
+                sha=self.sha + "0" * (40 - len(self.sha)),  # Convert to full SHA
+                github_user=self.requested_by or "unknown",
+            )
+
+            if not result.success:
+                raise Exception(f"AWS deployment failed: {result.error}")
+
+            # Update with deployment results
+            self.ip = result.ip
+        else:
+            # Mock successful deployment for dry-run
+            self.ip = "52.1.2.3"
+
+    def stop(self, dry_run_github: bool = False, dry_run_aws: bool = False) -> None:
+        """Stop this environment (cleanup AWS resources)
+
+        Raises:
+            Exception: On cleanup failure
+        """
+        github, aws = get_interfaces()
+
+        # Delete AWS resources (pure technical work)
+        if not dry_run_aws:
+            success = aws.delete_environment(self.aws_service_name, self.pr_number)
+            if not success:
+                raise Exception(f"Failed to delete AWS service: {self.aws_service_name}")
+
+        # No comments - PullRequest handles that!
+
+    def _build_docker_image(self) -> None:
+        """Build Docker image for this environment"""
+        import os
+        import platform
+        import subprocess
+
+        tag = f"apache/superset:pr-{self.pr_number}-{self.sha}-ci"
+
+        # Detect if running in CI environment
+        is_ci = bool(os.getenv("GITHUB_ACTIONS") or os.getenv("CI"))
+        
+        # Base command
+        cmd = [
+            "docker",
+            "buildx",
+            "build",
+            "--push",
+            "--platform",
+            "linux/amd64",
+            "--target",
+            "ci",
+            "--build-arg",
+            "INCLUDE_CHROMIUM=false",
+            "--build-arg",
+            "LOAD_EXAMPLES_DUCKDB=true",
+            "-t",
+            tag,
+            ".",
+        ]
+
+        # Add caching based on environment
+        if is_ci:
+            # Full registry caching in CI (Docker driver supports it)
+            cmd.extend([
+                "--cache-from",
+                "type=registry,ref=apache/superset-cache:3.10-slim-bookworm",
+                "--cache-to", 
+                "type=registry,mode=max,ref=apache/superset-cache:3.10-slim-bookworm",
+            ])
+            print("🐳 CI environment: Using full registry caching")
+        else:
+            # Local build: cache-from only (no cache export)
+            cmd.extend([
+                "--cache-from",
+                "type=registry,ref=apache/superset-cache:3.10-slim-bookworm",
+            ])
+            print("🐳 Local environment: Using cache-from only (no export)")
+
+        # Add --load only when building for native architecture or explicitly requested
+        # Intel Mac/Linux can load linux/amd64, Apple Silicon cannot
+        native_x86 = platform.machine() in ("x86_64", "AMD64")
+        force_load = os.getenv("DOCKER_LOAD", "false").lower() == "true"
+        
+        if native_x86 or force_load:
+            cmd.insert(-1, "--load")  # Insert before the "." argument
+            print("🐳 Will load image to local Docker daemon (native x86_64 platform)")
+        else:
+            print("🐳 Cross-platform build - pushing to registry only (no local load)")
+
+        print(f"🐳 Building Docker image: {tag}")
+
+        # Stream output in real-time
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            universal_newlines=True,
+        )
+
+        if process.stdout:
+            for line in process.stdout:
+                print(f"🐳 {line.rstrip()}")
+
+        return_code = process.wait(timeout=3600)
+        if return_code != 0:
+            raise Exception(f"Docker build failed with exit code: {return_code}")
+
+    @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(" ")
+            if len(parts) < 3:
+                continue
+
+            # Per-SHA format: 🎪 {sha} {emoji} {value}
+            if parts[1] == sha:  # This label is for our SHA
+                emoji = parts[2]
+                value = " ".join(parts[3:]) if len(parts) > 3 else ""
+
+                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
+
+        # 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)  # type: ignore[arg-type]
+
+        return None
+
+
+def short_sha(full_sha: str) -> str:
+    """Convert full SHA to short SHA (7 chars)"""
+    return full_sha[:7]

{superset_showtime-0.2.9.dist-info → superset_showtime-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superset-showtime
-Version: 0.2.9
+Version: 0.4.2
 Summary: 🎪 Apache Superset ephemeral environment management with circus tent emoji state tracking
 Project-URL: Homepage, https://github.com/apache/superset-showtime
 Project-URL: Documentation, https://superset-showtime.readthedocs.io/
@@ -49,6 +49,7 @@ Provides-Extra: azure
 Requires-Dist: azure-mgmt-containerinstance>=10.0.0; extra == 'azure'
 Requires-Dist: azure-storage-blob>=12.0.0; extra == 'azure'
 Provides-Extra: dev
+Requires-Dist: boto3-stubs[ec2,ecr,ecs]>=1.40.0; extra == 'dev'
 Requires-Dist: build>=1.0.0; extra == 'dev'
 Requires-Dist: mypy>=1.0.0; extra == 'dev'
 Requires-Dist: pre-commit>=3.0.0; extra == 'dev'
@@ -157,11 +158,11 @@ showtime labels                 # Complete label reference
 
 **Testing/development:**
 ```bash
-showtime start 1234 --dry-run-aws      # Test without AWS costs
-showtime test-lifecycle 1234           # Full workflow simulation
+showtime sync 1234 --dry-run-aws --dry-run-docker  # Test without costs
+showtime cleanup --dry-run --older-than 1h         # Test cleanup logic
 ```
 
-> **Dependency**: This CLI coordinates with Superset's existing GitHub Actions build infrastructure. It orchestrates environments but relies on Superset's build workflows for container creation.
+> **Architecture**: This CLI implements ACID-style atomic transactions with direct Docker integration. It handles complete environment lifecycle from Docker build to AWS deployment with race condition prevention.
 
 ## 🎪 Complete Label Reference
 
@@ -275,7 +276,14 @@ The CLI is primarily used by GitHub Actions, but available for debugging and adv
 ```bash
 pip install superset-showtime
 export GITHUB_TOKEN=your_token
-showtime --help  # See all available commands
+
+# Core commands:
+showtime sync PR_NUMBER              # Sync to desired state (main command)
+showtime start PR_NUMBER             # Create new environment
+showtime stop PR_NUMBER              # Delete environment
+showtime status PR_NUMBER            # Show current state
+showtime list                        # List all environments
+showtime cleanup --older-than 48h    # Clean up expired environments
 ```
 
 
@@ -286,11 +294,11 @@ showtime --help  # See all available commands
 
 **Test with real PRs safely:**
 ```bash
-# Test label management without AWS costs:
-showtime start YOUR_PR_NUMBER --dry-run-aws --aws-sleep 10
+# Test full workflow without costs:
+showtime sync YOUR_PR_NUMBER --dry-run-aws --dry-run-docker
 
-# Test full lifecycle:
-showtime test-lifecycle YOUR_PR_NUMBER --real-github
+# Test cleanup logic:
+showtime cleanup --dry-run --older-than 24h
 ```
 
 ### Development Setup

superset_showtime-0.4.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+showtime/__init__.py,sha256=jzoTTK9K3uRo5GuAPaej-89Ny35OFYmHBR3FTQ7MiVk,448
+showtime/__main__.py,sha256=EVaDaTX69yIhCzChg99vqvFSCN4ELstEt7Mpb9FMZX8,109
+showtime/cli.py,sha256=faFM6pe3gz49_1KrzUeri7dQffqz4WP92JmGxPaIOC0,25249
+showtime/core/__init__.py,sha256=54hbdFNGrzuNMBdraezfjT8Zi6g221pKlJ9mREnKwCw,34
+showtime/core/aws.py,sha256=REeZ6_1C9f6mBchBAGa1MeDJeZIwir4IJ92HLRcK5ok,32636
+showtime/core/emojis.py,sha256=MHEDuPIdfNiop4zbNLuviz3eY05QiftYSHHCVbkfKhw,2129
+showtime/core/github.py,sha256=uETvKDO2Yhpqg3fxLtrKaCuZR3b-1LVmgnf5aLcqrAQ,9988
+showtime/core/github_messages.py,sha256=MfgwCukrEsWWesMsuL8saciDgP4nS-gijzu8DXr-Alg,7450
+showtime/core/label_colors.py,sha256=efhbFnz_3nqEnEqmgyF6_hZbxtCu_fmb68BIIUpSsnk,3895
+showtime/core/pull_request.py,sha256=Yxc7Oy0dkvQQm3DbwUKbiCAW0wEivM8U2j5vSRwIDxE,20475
+showtime/core/show.py,sha256=BRMH_Z53UfK0VXAMHfzS0u7_s0h634VKTMzWMniRNsg,9759
+showtime/data/ecs-task-definition.json,sha256=0ZaE0FZ8IWduXd2RyscMhXeVgxyym6qtjH02CK9mXBI,2235
+superset_showtime-0.4.2.dist-info/METADATA,sha256=h_RweT3LG7UW7HLTx49Gv26ulSJUV2c-YVULpYm_gw8,12052
+superset_showtime-0.4.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+superset_showtime-0.4.2.dist-info/entry_points.txt,sha256=rDW7oZ57mqyBUS4N_3_R7bZNGVHB-104jwmY-hHC_ck,85
+superset_showtime-0.4.2.dist-info/RECORD,,

showtime/commands/__init__.py

@@ -1 +0,0 @@
-"""Showtime CLI commands"""

showtime/commands/start.py

@@ -1,40 +0,0 @@
-"""
-🎪 Start show command - Create ephemeral environments
-"""
-
-from dataclasses import dataclass
-from typing import Optional
-
-
-@dataclass
-class StartResult:
-    """Result of starting a show"""
-
-    success: bool
-    url: Optional[str] = None
-    error: Optional[str] = None
-
-
-def start_show(
-    pr_number: int, sha: Optional[str] = None, ttl: str = "24h", size: str = "standard"
-) -> StartResult:
-    """
-    Start the show! Create ephemeral environment for PR
-
-    Args:
-        pr_number: PR number to create environment for
-        sha: Specific commit SHA (default: latest)
-        ttl: Time to live (24h, 48h, 1w, close)
-        size: Environment size (standard, large)
-
-    Returns:
-        StartResult with success status and details
-    """
-    # TODO: Implement environment creation
-    # 1. Get latest SHA if not provided
-    # 2. Create circus labels
-    # 3. Build Docker image
-    # 4. Deploy to ECS
-    # 5. Update labels with running state
-
-    return StartResult(success=False, error="Not yet implemented")

showtime/core/circus.py

@@ -1,289 +0,0 @@
-"""
-🎪 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, built, deploying, 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
-
-    @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 ecs_service_name(self) -> str:
-        """Deterministic ECS service name with -service suffix: pr-{pr_number}-{sha}-service"""
-        return f"{self.aws_service_name}-service"
-
-    @property
-    def short_sha(self) -> str:
-        """7-character SHA for display (GitHub standard)"""
-        return self.sha[:7]
-
-    @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_built(self) -> bool:
-        """Check if environment is built (Docker complete, ready for deploy)"""
-        return self.status == "built"
-
-    @property
-    def is_deploying(self) -> bool:
-        """Check if environment is currently deploying to AWS"""
-        return self.status == "deploying"
-
-    @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}")
-
-        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
-
-        # 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()
-
-
-def parse_ttl_days(ttl_str: str) -> Optional[float]:
-    """Parse TTL string to days"""
-    import re
-
-    if ttl_str == "never":
-        return None  # Never expire
-
-    if ttl_str == "close":
-        return None  # Special handling needed
-
-    # Parse number + unit: 24h, 7d, 2w, etc.
-    match = re.match(r"(\d+(?:\.\d+)?)(h|d|w)", ttl_str.lower())
-    if not match:
-        return 2.0  # Default 2 days if invalid
-
-    value = float(match.group(1))
-    unit = match.group(2)
-
-    if unit == "h":
-        return value / 24.0  # Hours to days
-    elif unit == "d":
-        return value  # Already in days
-    elif unit == "w":
-        return value * 7.0  # Weeks to days
-
-    return 2.0  # Default
-
-
-def get_effective_ttl(pr) -> Optional[float]:
-    """Get effective TTL in days for a PR (handles multiple labels, conflicts)"""
-    ttl_labels = []
-
-    # Find all TTL labels for all shows
-    for show in pr.shows:
-        if show.ttl:
-            ttl_days = parse_ttl_days(show.ttl)
-            if ttl_days is None:  # "never" or "close"
-                if show.ttl == "never":
-                    return None  # Never expire takes precedence
-                # For "close", continue checking others
-            else:
-                ttl_labels.append(ttl_days)
-
-    if not ttl_labels:
-        return 2.0  # Default 2 days
-
-    # Use longest duration if multiple labels
-    return max(ttl_labels)
-
-
-def short_sha(full_sha: str) -> str:
-    """Truncate SHA to 7 characters for display (GitHub standard)"""
-    return full_sha[:7]