CDN API

@dataclass
class CDNSource:
    name: str                    # Human-readable identifier
    base_url: str                # HTTPS base URL (e.g., "https://cdn.jsdelivr.net/gh/TracingInsights")
    priority: int = 0            # Priority level (lower = higher priority)
    enabled: bool = True         # Whether source is currently enabled
    use_minification: bool = False  # Enable JSON minification (.json → .min.json)

class CDNManager:
    sources: list[CDNSource]           # All configured sources (sorted by priority)
    _failure_counts: dict[str, int]    # Failure tracking per source
    _max_failures: int = 3             # Circuit breaker threshold

_cdn_manager = CDNManager()  # Module-level singleton

def get_cdn_manager() -> CDNManager:
    """Get global CDN manager instance."""
    return _cdn_manager

1. Application calls Session.load()
   ↓
2. Session requests data (e.g., laps.json) from HTTP layer
   ↓
3. HTTP layer calls cdn.try_sources(year, gp, session, path, fetch_func)
   ↓
4. CDN manager gets available sources via get_sources()
   - Filters out disabled sources (enabled=False)
   - Filters out failed sources (failure_count >= 3)
   - Returns sources sorted by priority
   ↓
5. For each source (in priority order):
   a. Format URL via source.format_url() (applies minification if enabled)
   b. Call fetch_func(url) to attempt HTTP request
   c. If successful:
      - Call mark_success(source_name) to reset failure count
      - Return fetched data (done!)
   d. If DataNotFoundError (404):
      - Re-raise immediately (data doesn't exist, no point trying other sources)
   e. If other error (network, timeout, 5xx):
      - Call mark_failure(source_name) to increment failure count
      - Log warning and try next source
   ↓
6. If all sources fail:
   - Raise NetworkError with details
   ↓
7. If any source succeeds:
   - Return data to Session
   - Session parses and caches data

import tif1

# CDN system works automatically - no configuration needed
session = tif1.get_session(2021, "Belgian Grand Prix", "Race")
session.load()  # CDN automatically handles data fetching with fallback

# That's it! The CDN manager:
# 1. Tries jsDelivr (default, priority 1)
# 2. Falls back to other sources if jsDelivr fails
# 3. Tracks health and disables failing sources
# 4. Automatically recovers when sources become healthy

from tif1.cdn import get_cdn_manager

# Get the global CDN manager singleton
cdn = get_cdn_manager()

# Check which sources are available
print(f"Available sources: {len(cdn.get_sources())}/{len(cdn.sources)}")
for source in cdn.get_sources():
    failures = cdn._failure_counts[source.name]
    print(f"  {source.name}:")
    print(f"    Priority: {source.priority}")
    print(f"    Health: {failures}/3 failures")
    print(f"    Minification: {'enabled' if source.use_minification else 'disabled'}")
    print(f"    URL: {source.base_url}")

from tif1.cdn import get_cdn_manager, CDNSource

cdn = get_cdn_manager()

# Add a regional CDN for better performance
regional_cdn = CDNSource(
    name="Europe CDN",
    base_url="https://eu.cdn.example.com/f1data",
    priority=1,  # Higher priority than default (tries first)
    enabled=True,
    use_minification=True
)
cdn.add_source(regional_cdn)

# Add a backup CDN with lower priority
backup_cdn = CDNSource(
    name="Backup CDN",
    base_url="https://backup.example.com/f1data",
    priority=3,  # Lower priority (tries last)
    enabled=True,
    use_minification=False
)
cdn.add_source(backup_cdn)

# Verify sources were added
print(f"Total sources: {len(cdn.sources)}")
for source in cdn.get_sources():
    print(f"  Priority {source.priority}: {source.name}")

import tif1

# Enable minification globally for all sources
config = tif1.get_config()
config.set("cdn_use_minification", True)
config.save()  # Persist to ~/.tif1rc

# Or enable per-source when adding custom CDNs
from tif1.cdn import get_cdn_manager, CDNSource

cdn = get_cdn_manager()
cdn.add_source(CDNSource(
    name="Fast CDN",
    base_url="https://fast.cdn.example.com/f1",
    priority=1,
    use_minification=True  # Only this source uses minification
))

from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()

# Check health status
def check_cdn_health():
    available = len(cdn.get_sources())
    total = len(cdn.sources)
    health_pct = (available / total * 100) if total > 0 else 0

    print(f"CDN Health: {health_pct:.1f}% ({available}/{total} sources available)")

    for source in cdn.sources:
        failures = cdn._failure_counts[source.name]
        status = "🟢 Healthy" if failures == 0 else f"🟡 {failures} failures"
        if failures >= 3:
            status = "🔴 Disabled"
        print(f"  {source.name}: {status}")

check_cdn_health()

# Reset all sources after network recovery
cdn.reset()
print("All CDN sources reset to healthy state")

{
  "cdns": [
    "https://cdn.jsdelivr.net/gh/TracingInsights",
    "https://eu.cdn.example.com/f1data",
    "https://backup.cdn.example.com/f1data"
  ],
  "cdn_use_minification": true
}

# Set CDN sources (comma-separated)
export TIF1_CDNS="https://cdn.jsdelivr.net/gh/TracingInsights,https://backup.cdn.example.com/f1"

# Enable minification
export TIF1_CDN_USE_MINIFICATION=true

# Run your application
python my_f1_app.py

def get_cdn_manager() -> CDNManager

from tif1.cdn import get_cdn_manager

# Get the singleton instance
cdn = get_cdn_manager()

# All calls return the same instance
cdn2 = get_cdn_manager()
assert cdn is cdn2  # True - same object reference

# Check active sources
active_sources = cdn.get_sources()
print(f"Active CDN sources: {len(active_sources)}")

# Inspect each source
for source in active_sources:
    print(f"\n{source.name}:")
    print(f"  URL: {source.base_url}")
    print(f"  Priority: {source.priority}")
    print(f"  Enabled: {source.enabled}")
    print(f"  Minification: {source.use_minification}")

from tif1.cdn import get_cdn_manager

def create_cdn_dashboard():
    """Create a comprehensive CDN health dashboard."""
    cdn = get_cdn_manager()

    print("=" * 70)
    print("CDN HEALTH DASHBOARD")
    print("=" * 70)

    # Overall statistics
    total_sources = len(cdn.sources)
    available_sources = len(cdn.get_sources())
    disabled_sources = total_sources - available_sources

    print(f"\nOverall Status:")
    print(f"  Total Sources: {total_sources}")
    print(f"  Available: {available_sources} ({available_sources/total_sources*100:.1f}%)")
    print(f"  Disabled: {disabled_sources}")

    # Per-source details
    print(f"\nSource Details:")
    print(f"{'Name':<20} {'Priority':<10} {'Failures':<10} {'Status':<15} {'Minification':<15}")
    print("-" * 70)

    for source in cdn.sources:
        failures = cdn._failure_counts[source.name]

        # Determine status
        if not source.enabled:
            status = "🔴 Disabled"
        elif failures >= cdn._max_failures:
            status = "🔴 Circuit Open"
        elif failures == 0:
            status = "🟢 Healthy"
        elif failures == 1:
            status = "🟡 Degraded"
        else:
            status = "🟠 Critical"

        minification = "✓ Enabled" if source.use_minification else "✗ Disabled"

        print(f"{source.name:<20} {source.priority:<10} {failures}/{cdn._max_failures:<7} {status:<15} {minification:<15}")

    print("=" * 70)

# Run dashboard
create_cdn_dashboard()

from tif1.cdn import get_cdn_manager

# Verify singleton behavior
cdn1 = get_cdn_manager()
cdn2 = get_cdn_manager()

# Same object reference
assert cdn1 is cdn2
print(f"Same instance: {cdn1 is cdn2}")  # True

# Modifications affect all references
cdn1.add_source(CDNSource(name="Test", base_url="https://test.com", priority=10))

# Both references see the change
print(f"cdn1 sources: {len(cdn1.sources)}")
print(f"cdn2 sources: {len(cdn2.sources)}")  # Same count

# Failure tracking is shared
cdn1.mark_failure("jsDelivr")
print(f"cdn1 failures: {cdn1._failure_counts['jsDelivr']}")
print(f"cdn2 failures: {cdn2._failure_counts['jsDelivr']}")  # Same count

import os

# Set CDN sources before importing tif1
os.environ["TIF1_CDNS"] = "https://cdn.jsdelivr.net/gh/TracingInsights,https://backup.cdn.com/f1"
os.environ["TIF1_CDN_USE_MINIFICATION"] = "true"

# Now import and use
from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()
print(f"Initialized with {len(cdn.sources)} sources")
for source in cdn.sources:
    print(f"  {source.name} (priority {source.priority})")

{
  "cdns": [
    "https://cdn.jsdelivr.net/gh/TracingInsights",
    "https://eu.cdn.example.com/f1data",
    "https://us.cdn.example.com/f1data"
  ],
  "cdn_use_minification": true
}

from tif1.cdn import get_cdn_manager

# Automatically loads from ~/.tif1rc
cdn = get_cdn_manager()

print(f"Loaded {len(cdn.sources)} sources from config:")
for source in cdn.sources:
    print(f"  Priority {source.priority}: {source.name}")
    print(f"    URL: {source.base_url}")
    print(f"    Minification: {source.use_minification}")

import os
from tif1.cdn import get_cdn_manager

# Mix of valid and invalid URLs
os.environ["TIF1_CDNS"] = ",".join([
    "https://cdn.jsdelivr.net/gh/TracingInsights",  # Valid
    "http://insecure.cdn.com/f1",                   # Invalid (HTTP)
    "https://raw.githubusercontent.com/user/repo",  # Invalid (blocked)
    "https://backup.cdn.com/f1",                    # Valid
    "not-a-url",                                    # Invalid (malformed)
])

cdn = get_cdn_manager()

# Only valid sources are loaded
print(f"Valid sources: {len(cdn.sources)}")  # 2 (jsDelivr and backup)
for source in cdn.sources:
    print(f"  {source.name}: {source.base_url}")

# Check logs for warnings about invalid URLs
# WARNING: Skipping invalid CDN URL: http://insecure.cdn.com/f1
# WARNING: Skipping unsupported CDN URL: https://raw.githubusercontent.com/user/repo

sources: list[CDNSource]

from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()

print(f"Total configured sources: {len(cdn.sources)}")
print(f"Available sources: {len(cdn.get_sources())}")
print()

for i, source in enumerate(cdn.sources, 1):
    status = "enabled" if source.enabled else "disabled"
    failures = cdn._failure_counts[source.name]
    circuit_status = "open (disabled)" if failures >= cdn._max_failures else "closed (active)"

    print(f"{i}. {source.name} ({status})")
    print(f"   URL: {source.base_url}")
    print(f"   Priority: {source.priority}")
    print(f"   Minification: {source.use_minification}")
    print(f"   Failures: {failures}/{cdn._max_failures}")
    print(f"   Circuit breaker: {circuit_status}")
    print()

from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()

# Get only enabled sources
enabled_sources = [s for s in cdn.sources if s.enabled]
print(f"Enabled sources: {len(enabled_sources)}")

# Get only sources with minification
minified_sources = [s for s in cdn.sources if s.use_minification]
print(f"Sources with minification: {len(minified_sources)}")

# Get sources by priority
high_priority = [s for s in cdn.sources if s.priority == 1]
print(f"High-priority sources: {len(high_priority)}")

# Get healthy sources (no failures)
healthy_sources = [s for s in cdn.sources if cdn._failure_counts[s.name] == 0]
print(f"Healthy sources: {len(healthy_sources)}")

_failure_counts: dict[str, int]

{
    "jsDelivr": 0,        # Healthy
    "Backup CDN": 2,      # Degraded (2 failures)
    "Regional CDN": 3,    # Disabled (circuit breaker open)
}

from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()

def monitor_failures():
    """Monitor failure counts for all sources."""
    print("CDN Failure Monitoring:")
    print(f"{'Source':<20} {'Failures':<10} {'Status':<15}")
    print("-" * 45)

    for source in cdn.sources:
        failures = cdn._failure_counts[source.name]

        if failures == 0:
            status = "🟢 Healthy"
        elif failures < cdn._max_failures:
            status = f"🟡 {failures} failures"
        else:
            status = "🔴 Disabled"

        print(f"{source.name:&lt;20} {failures}/{cdn._max_failures:&lt;7} {status:&lt;15}")

# Initial state
monitor_failures()

# Simulate some failures
cdn.mark_failure("jsDelivr")
cdn.mark_failure("jsDelivr")

print("\nAfter 2 failures:")
monitor_failures()

# Successful request resets
cdn.mark_success("jsDelivr")

print("\nAfter successful request:")
monitor_failures()

from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()

# Simulate failures
for i in range(2):
    cdn.mark_failure("jsDelivr")
    print(f"Failure {i+1}: count = {cdn._failure_counts['jsDelivr']}")

# Failure count persists across function calls
def check_health():
    cdn = get_cdn_manager()  # Same singleton instance
    return cdn._failure_counts["jsDelivr"]

print(f"Persistent count: {check_health()}")  # Still 2

# Reset to clear
cdn.reset()
print(f"After reset: {cdn._failure_counts['jsDelivr']}")  # 0

_max_failures: int = 3

from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()

# More lenient (tolerate more failures)
cdn._max_failures = 5

# More aggressive (disable faster)
cdn._max_failures = 2

# Disable circuit breaker (never auto-disable)
cdn._max_failures = float('inf')  # Not recommended

from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()

print(f"Circuit breaker threshold: {cdn._max_failures} failures\n")

# Simulate failures until circuit opens
for i in range(1, 5):
    cdn.mark_failure("jsDelivr")
    failures = cdn._failure_counts["jsDelivr"]
    available = any(s.name == "jsDelivr" for s in cdn.get_sources())

    print(f"Failure {i}:")
    print(f"  Count: {failures}/{cdn._max_failures}")
    print(f"  Available: {available}")

    if failures >= cdn._max_failures:
        print(f"  ⚠️  Circuit breaker OPEN - source disabled")
    print()

from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()

# Set more lenient threshold for unreliable networks
cdn._max_failures = 5

print(f"Custom threshold: {cdn._max_failures} failures")

# Now sources tolerate more failures before disabling
for i in range(6):
    cdn.mark_failure("jsDelivr")
    failures = cdn._failure_counts["jsDelivr"]
    available = any(s.name == "jsDelivr" for s in cdn.get_sources())

    if i == 4:
        print(f"After {i+1} failures: still available = {available}")  # True
    elif i == 5:
        print(f"After {i+1} failures: still available = {available}")  # False

def get_sources() -> list[CDNSource]

from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()

# Get available sources
sources = cdn.get_sources()

if not sources:
    print("⚠️  Warning: No CDN sources available!")
    print("All sources are either disabled or have exceeded failure threshold.")
else:
    print(f"✓ Available CDN sources: {len(sources)}/{len(cdn.sources)}")

    for i, source in enumerate(sources, 1):
        failures = cdn._failure_counts.get(source.name, 0)

        print(f"\n{i}. {source.name}")
        print(f"   Base URL: {source.base_url}")
        print(f"   Priority: {source.priority}")
        print(f"   Minification: {'✓ enabled' if source.use_minification else '✗ disabled'}")
        print(f"   Health: {failures}/{cdn._max_failures} failures")

from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()
sources = cdn.get_sources()

if sources:
    # First source is highest priority
    primary = sources[0]

    # Format URL for Belgian GP 2021 Race drivers
    url = primary.format_url(
        year=2021,
        gp="Belgian%20Grand%20Prix",
        session="Race",
        path="drivers.json"
    )

    print(f"Primary CDN: {primary.name}")
    print(f"URL: {url}")

    # If minification is enabled, URL will be:
    # https://cdn.jsdelivr.net/gh/TracingInsights/2021@main/Belgian%20Grand%20Prix/Race/drivers.min.json
else:
    print("No CDN sources available - cannot fetch data")

from tif1.cdn import get_cdn_manager
from datetime import datetime

def monitor_cdn_health():
    """Monitor CDN source health with detailed reporting."""
    cdn = get_cdn_manager()

    total_sources = len(cdn.sources)
    available_sources = cdn.get_sources()
    available_count = len(available_sources)

    print("=" * 70)
    print(f"CDN HEALTH REPORT - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print("=" * 70)

    # Overall health
    health_pct = (available_count / total_sources * 100) if total_sources > 0 else 0

    if health_pct == 100:
        health_status = "🟢 EXCELLENT"
    elif health_pct >= 75:
        health_status = "🟡 GOOD"
    elif health_pct >= 50:
        health_status = "🟠 DEGRADED"
    else:
        health_status = "🔴 CRITICAL"

    print(f"\nOverall Health: {health_status} ({health_pct:.1f}%)")
    print(f"Available Sources: {available_count}/{total_sources}")

    # Detailed source status
    print(f"\n{'Source':<20} {'Priority':<10} {'Failures':<12} {'Status':<15}")
    print("-" * 70)

    for source in cdn.sources:
        failures = cdn._failure_counts.get(source.name, 0)
        is_available = source in available_sources

        # Determine status
        if not source.enabled:
            status = "🔴 Disabled"
        elif failures >= cdn._max_failures:
            status = "🔴 Circuit Open"
        elif failures == 0:
            status = "🟢 Healthy"
        elif failures == 1:
            status = "🟡 Degraded"
        else:
            status = "🟠 Critical"

        failure_str = f"{failures}/{cdn._max_failures}"

        print(f"{source.name:<20} {source.priority:<10} {failure_str:<12} {status:<15}")

    print("=" * 70)

    # Recommendations
    if health_pct < 100:
        print("\n⚠️  RECOMMENDATIONS:")
        if available_count == 0:
            print("  • All sources are unavailable - call cdn.reset() to recover")
            print("  • Check network connectivity")
            print("  • Verify CDN URLs are accessible")
        elif health_pct < 50:
            print("  • Consider adding more backup CDN sources")
            print("  • Investigate why sources are failing")
            print("  • Call cdn.reset() if network issues have been resolved")

# Run monitoring
monitor_cdn_health()

from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()

# Get available sources
available = cdn.get_sources()

# Analyze by priority
priority_groups = {}
for source in available:
    priority_groups.setdefault(source.priority, []).append(source)

print("Sources grouped by priority:")
for priority in sorted(priority_groups.keys()):
    sources = priority_groups[priority]
    print(f"\nPriority {priority}: {len(sources)} source(s)")
    for source in sources:
        print(f"  • {source.name}")

# Check minification support
minified = [s for s in available if s.use_minification]
print(f"\nSources with minification: {len(minified)}/{len(available)}")

# Identify healthy sources (0 failures)
healthy = [s for s in available if cdn._failure_counts[s.name] == 0]
print(f"Perfectly healthy sources: {len(healthy)}/{len(available)}")

from tif1.cdn import get_cdn_manager
from tif1.exceptions import NetworkError

def safe_fetch_data(year, gp, session, path):
    """Safely fetch data with CDN availability check."""
    cdn = get_cdn_manager()
    sources = cdn.get_sources()

    if not sources:
        # No sources available - try recovery
        print("⚠️  No CDN sources available. Attempting recovery...")

        # Reset all sources to give them another chance
        cdn.reset()
        sources = cdn.get_sources()

        if not sources:
            # Still no sources - this is a configuration problem
            raise NetworkError(
                url=f"{year}/{gp}/{session}/{path}",
                status_code=None,
                message="No CDN sources configured or all sources are disabled"
            )

    # Proceed with fetch using available sources
    print(f"✓ {len(sources)} CDN source(s) available")
    # ... fetch logic here ...

# Usage
try:
    safe_fetch_data(2021, "Belgian%20Grand%20Prix", "Race", "drivers.json")
except NetworkError as e:
    print(f"Failed to fetch data: {e}")

def add_source(source: CDNSource) -> None

from tif1.cdn import get_cdn_manager, CDNSource

cdn = get_cdn_manager()

# Add a regional CDN for better performance in Asia
asia_cdn = CDNSource(
    name="Asia CDN",
    base_url="https://asia.cdn.example.com/f1data",
    priority=1,  # Higher priority than default (2)
    enabled=True,
    use_minification=True
)
cdn.add_source(asia_cdn)

# Add a backup CDN with lower priority
backup_cdn = CDNSource(
    name="Backup CDN",
    base_url="https://backup.cdn.example.com/f1data",
    priority=3,  # Lower priority - only used if others fail
    enabled=True,
    use_minification=False
)
cdn.add_source(backup_cdn)

# Verify sources were added
print(f"Total sources: {len(cdn.sources)}")
for source in cdn.get_sources():
    print(f"  Priority {source.priority}: {source.name}")

from tif1.cdn import get_cdn_manager, CDNSource
import socket

def add_regional_cdn():
    """Add region-specific CDN based on location."""
    cdn = get_cdn_manager()

    # Detect region (simplified example)
    hostname = socket.gethostname()

    if "eu" in hostname or "europe" in hostname:
        regional_cdn = CDNSource(
            name="Europe CDN",
            base_url="https://eu.cdn.example.com/f1data",
            priority=1,
            enabled=True,
            use_minification=True
        )
        cdn.add_source(regional_cdn)
        print("Added European CDN with priority 1")

    elif "us" in hostname or "america" in hostname:
        regional_cdn = CDNSource(
            name="US CDN",
            base_url="https://us.cdn.example.com/f1data",
            priority=1,
            enabled=True,
            use_minification=True
        )
        cdn.add_source(regional_cdn)
        print("Added US CDN with priority 1")

# Configure regional CDN before loading data
add_regional_cdn()

def mark_failure(source_name: str) -> None

from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()

# Simulate failures (normally done automatically by try_sources)
print("Simulating CDN failures...")

for i in range(1, 4):
    cdn.mark_failure("jsDelivr")
    failures = cdn._failure_counts["jsDelivr"]
    print(f"Failure {i}: jsDelivr has {failures} failures")

    # Check if still available
    available = any(s.name == "jsDelivr" for s in cdn.get_sources())
    print(f"  Still available: {available}")

# After 3 failures, source is excluded
print(f"\nAvailable sources: {[s.name for s in cdn.get_sources()]}")

from tif1.cdn import get_cdn_manager
import requests

cdn = get_cdn_manager()

def fetch_with_custom_error_handling(url: str) -> dict:
    """Fetch data with custom error classification."""
    try:
        response = requests.get(url, timeout=30)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.Timeout:
        # Timeout might be temporary - don't mark as failure
        print(f"Timeout on {url} - not marking as failure")
        raise
    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 404:
            # 404 means data doesn't exist - not a CDN failure
            print(f"404 on {url} - data not found")
            raise
        elif e.response.status_code >= 500:
            # Server error - mark as CDN failure
            print(f"Server error on {url} - marking as failure")
            # Extract CDN name from URL and mark failure
            # (In practice, try_sources handles this automatically)
            raise
        else:
            raise

def mark_success(source_name: str) -> None

from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()

# Simulate failure and recovery
print("Simulating CDN failure and recovery...")

# Fail the source 3 times
for i in range(3):
    cdn.mark_failure("jsDelivr")

print(f"After failures: {cdn._failure_counts['jsDelivr']} failures")
print(f"Available: {any(s.name == 'jsDelivr' for s in cdn.get_sources())}")

# Successful request resets the counter
cdn.mark_success("jsDelivr")

print(f"After success: {cdn._failure_counts['jsDelivr']} failures")
print(f"Available: {any(s.name == 'jsDelivr' for s in cdn.get_sources())}")

from tif1.cdn import get_cdn_manager
import time

cdn = get_cdn_manager()

def monitor_source_recovery(source_name: str):
    """Monitor a CDN source's recovery over time."""
    print(f"Monitoring {source_name} recovery...")

    # Initial state
    initial_failures = cdn._failure_counts.get(source_name, 0)
    print(f"Initial failures: {initial_failures}")

    # Simulate some failures
    for i in range(2):
        cdn.mark_failure(source_name)
        time.sleep(0.1)

    print(f"After failures: {cdn._failure_counts[source_name]}")

    # Simulate successful recovery
    cdn.mark_success(source_name)
    print(f"After recovery: {cdn._failure_counts[source_name]}")

    # Verify source is available
    available = any(s.name == source_name for s in cdn.get_sources())
    print(f"Source available: {available}")

monitor_source_recovery("jsDelivr")

def reset() -> None

from tif1.cdn import get_cdn_manager

cdn = get_cdn_manager()

# Simulate multiple source failures
print("Simulating widespread CDN failures...")
for source in cdn.sources:
    for _ in range(3):
        cdn.mark_failure(source.name)

print(f"Available sources after failures: {len(cdn.get_sources())}")

# Reset all sources
print("\nResetting all CDN sources...")
cdn.reset()

print(f"Available sources after reset: {len(cdn.get_sources())}")

# Verify all sources are healthy
for source in cdn.sources:
    failures = cdn._failure_counts[source.name]
    print(f"  {source.name}: {failures} failures")

from tif1.cdn import get_cdn_manager
import time
from datetime import datetime, timedelta

class CDNHealthManager:
    """Manages CDN health with automatic recovery."""

    def __init__(self):
        self.cdn = get_cdn_manager()
        self.last_reset = datetime.now()
        self.reset_interval = timedelta(hours=1)

    def check_and_reset_if_needed(self):
        """Reset CDN sources if enough time has passed."""
        now = datetime.now()

        if now - self.last_reset >= self.reset_interval:
            available = len(self.cdn.get_sources())
            total = len(self.cdn.sources)

            if available < total:
                print(f"Auto-resetting CDN sources ({available}/{total} available)")
                self.cdn.reset()
                self.last_reset = now
                return True

        return False

    def get_health_status(self) -> dict:
        """Get detailed health status of all CDN sources."""
        total = len(self.cdn.sources)
        available = len(self.cdn.get_sources())

        return {
            "total_sources": total,
            "available_sources": available,
            "health_percentage": (available / total * 100) if total > 0 else 0,
            "last_reset": self.last_reset.isoformat(),
            "sources": [
                {
                    "name": source.name,
                    "failures": self.cdn._failure_counts.get(source.name, 0),
                    "available": source.name in [s.name for s in self.cdn.get_sources()]
                }
                for source in self.cdn.sources
            ]
        }

# Usage
health_manager = CDNHealthManager()

# Check health before data fetching
health_manager.check_and_reset_if_needed()

# Get detailed status
status = health_manager.get_health_status()
print(f"CDN Health: {status['health_percentage']:.1f}%")
print(f"Available: {status['available_sources']}/{status['total_sources']}")

def try_sources(
    year: int,
    gp: str,
    session: str,
    path: str,
    fetch_func: Callable[[str], Any]
) -> Any

from tif1.cdn import get_cdn_manager
import requests

cdn = get_cdn_manager()

def fetch_json(url: str) -> dict:
    """Fetch JSON data from URL."""
    response = requests.get(url, timeout=30)
    response.raise_for_status()
    return response.json()

# Fetch 2021 Belgian Grand Prix Race drivers
try:
    data = cdn.try_sources(
        year=2021,
        gp="Belgian%20Grand%20Prix",
        session="Race",
        path="drivers.json",
        fetch_func=fetch_json
    )
    print(f"✓ Successfully fetched {len(data.get('drivers', []))} drivers")
except DataNotFoundError:
    print("✗ Drivers data not found for this session")
except NetworkError as e:
    print(f"✗ All CDN sources failed: {e}")

from tif1.cdn import get_cdn_manager
from tif1.exceptions import DataNotFoundError, NetworkError
import requests
import logging

# Enable debug logging to see which CDN is being tried
logging.basicConfig(level=logging.DEBUG)

cdn = get_cdn_manager()

def fetch_with_error_handling(url: str) -> dict:
    """Fetch JSON with proper error classification."""
    try:
        response = requests.get(url, timeout=30)

        if response.status_code == 404:
            # Data doesn't exist - raise DataNotFoundError
            raise DataNotFoundError(message=f"Resource not found: {url}")

        response.raise_for_status()
        return response.json()

    except requests.exceptions.Timeout:
        # Timeout - let CDN manager try next source
        raise NetworkError(url=url, message="Request timeout")
    except requests.exceptions.ConnectionError:
        # Connection failed - let CDN manager try next source
        raise NetworkError(url=url, message="Connection failed")

# Fetch data with comprehensive error handling
try:
    data = cdn.try_sources(
        year=2021,
        gp="Belgian%20Grand%20Prix",
        session="Race",
        path="laps.json",
        fetch_func=fetch_with_error_handling
    )

    print(f"✓ Fetched {len(data.get('laps', []))} laps")
    print(f"✓ Used CDN: {cdn.get_sources()[0].name}")

except DataNotFoundError as e:
    print(f"✗ Data not found: {e}")
    print("  This session may not have lap data available")

except NetworkError as e:
    print(f"✗ Network error: {e}")
    print("  All CDN sources failed - check network connectivity")

    # Show which sources failed
    for source in cdn.sources:
        failures = cdn._failure_counts[source.name]
        print(f"  {source.name}: {failures} failures")

from tif1.cdn import get_cdn_manager
from tif1.exceptions import DataNotFoundError, NetworkError
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

cdn = get_cdn_manager()

def create_fetch_func_with_retries():
    """Create a fetch function with built-in retries."""
    # Configure session with retries
    session = requests.Session()
    retries = Retry(
        total=3,
        backoff_factor=0.5,
        status_forcelist=[500, 502, 503, 504],
        allowed_methods=["GET"]
    )
    adapter = HTTPAdapter(max_retries=retries)
    session.mount("https://", adapter)

    def fetch(url: str) -> dict:
        response = session.get(url, timeout=30)

        if response.status_code == 404:
            raise DataNotFoundError(message=f"Not found: {url}")

        response.raise_for_status()
        return response.json()

    return fetch

# Use custom fetch function
fetch_func = create_fetch_func_with_retries()

data = cdn.try_sources(
    year=2021,
    gp="Belgian%20Grand%20Prix",
    session="Race",
    path="weather.json",
    fetch_func=fetch_func
)

print(f"✓ Fetched weather data: {len(data.get('weather', []))} entries")

from tif1.cdn import get_cdn_manager
from tif1.exceptions import DataNotFoundError, NetworkError
import requests
import logging

# Enable debug logging
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

cdn = get_cdn_manager()

def fetch_json(url: str) -> dict:
    response = requests.get(url, timeout=30)
    if response.status_code == 404:
        raise DataNotFoundError(message="Not found")
    response.raise_for_status()
    return response.json()

# Add multiple sources to see fallback
from tif1.cdn import CDNSource
cdn.add_source(CDNSource(
    name="Backup CDN",
    base_url="https://backup.example.com/f1",
    priority=2
))

print("Attempting fetch with fallback monitoring...\n")

try:
    data = cdn.try_sources(
        year=2021,
        gp="Belgian%20Grand%20Prix",
        session="Race",
        path="drivers.json",
        fetch_func=fetch_json
    )

    print(f"\n✓ Success! Fetched {len(data.get('drivers', []))} drivers")

    # Show which source succeeded
    for source in cdn.sources:
        failures = cdn._failure_counts[source.name]
        if failures == 0:
            print(f"✓ {source.name}: Healthy (used for fetch)")
        else:
            print(f"✗ {source.name}: {failures} failures")

except NetworkError as e:
    print(f"\n✗ All sources failed: {e}")

    # Detailed failure report
    print("\nFailure details:")
    for source in cdn.sources:
        failures = cdn._failure_counts[source.name]
        print(f"  {source.name}: {failures}/{cdn._max_failures} failures")

from tif1.cdn import get_cdn_manager
import asyncio
import aiohttp

cdn = get_cdn_manager()

async def async_fetch(url: str) -> dict:
    """Async fetch function for use with try_sources."""
    async with aiohttp.ClientSession() as session:
        async with session.get(url, timeout=30) as response:
            if response.status == 404:
                from tif1.exceptions import DataNotFoundError
                raise DataNotFoundError(message="Not found")

            response.raise_for_status()
            return await response.json()

# Wrap async function for use with try_sources
def sync_fetch(url: str) -> dict:
    """Synchronous wrapper for async fetch."""
    return asyncio.run(async_fetch(url))

# Use with try_sources
data = cdn.try_sources(
    year=2021,
    gp="Belgian%20Grand%20Prix",
    session="Race",
    path="telemetry.json",
    fetch_func=sync_fetch
)

print(f"✓ Fetched telemetry data")

from tif1.cdn import get_cdn_manager
from tif1.exceptions import DataNotFoundError
import requests
from typing import Any

cdn = get_cdn_manager()

class FetchProgress:
    """Track fetch progress across CDN sources."""

    def __init__(self):
        self.attempts = []

    def create_fetch_func(self):
        """Create fetch function that tracks progress."""
        def fetch(url: str) -> dict:
            attempt = {
                "url": url,
                "source": self._extract_source_name(url),
                "success": False,
                "error": None
            }

            try:
                response = requests.get(url, timeout=30)

                if response.status_code == 404:
                    attempt["error"] = "Not found (404)"
                    self.attempts.append(attempt)
                    raise DataNotFoundError(message="Not found")

                response.raise_for_status()
                attempt["success"] = True
                self.attempts.append(attempt)
                return response.json()

            except Exception as e:
                attempt["error"] = str(e)
                self.attempts.append(attempt)
                raise

        return fetch

    def _extract_source_name(self, url: str) -> str:
        """Extract CDN source name from URL."""
        if "jsdelivr" in url:
            return "jsDelivr"
        elif "backup" in url:
            return "Backup CDN"
        return "Unknown"

    def print_report(self):
        """Print fetch attempt report."""
        print("\nFetch Attempt Report:")
        print("=" * 60)

        for i, attempt in enumerate(self.attempts, 1):
            status = "✓ SUCCESS" if attempt["success"] else f"✗ FAILED: {attempt['error']}"
            print(f"\nAttempt {i}: {attempt['source']}")
            print(f"  Status: {status}")
            print(f"  URL: {attempt['url'][:80]}...")

# Usage
progress = FetchProgress()

try:
    data = cdn.try_sources(
        year=2021,
        gp="Belgian%20Grand%20Prix",
        session="Race",
        path="drivers.json",
        fetch_func=progress.create_fetch_func()
    )
    print(f"✓ Successfully fetched data")
finally:
    progress.print_report()

@dataclass
class CDNSource:
    name: str
    base_url: str
    priority: int = 0
    enabled: bool = True
    use_minification: bool = False

from tif1.cdn import CDNSource

# Primary source with minification
primary = CDNSource(
    name="jsDelivr",
    base_url="https://cdn.jsdelivr.net/gh/TracingInsights",
    priority=1,
    enabled=True,
    use_minification=True
)

def format_url(year: int, gp: str, session: str, path: str) -> str

{base_url}/{year}@main/{gp}/{session}/{path}

from tif1.cdn import CDNSource

# Without minification
source = CDNSource(
    name="jsDelivr",
    base_url="https://cdn.jsdelivr.net/gh/TracingInsights",
    use_minification=False
)

url = source.format_url(
    year=2021,
    gp="Belgian%20Grand%20Prix",
    session="Race",
    path="drivers.json"
)
# Result: https://cdn.jsdelivr.net/gh/TracingInsights/2021@main/Belgian%20Grand%20Prix/Race/drivers.json

# With minification
minified_source = CDNSource(
    name="jsDelivr",
    base_url="https://cdn.jsdelivr.net/gh/TracingInsights",
    use_minification=True
)

minified_url = minified_source.format_url(
    year=2021,
    gp="Belgian%20Grand%20Prix",
    session="Race",
    path="drivers.json"
)
# Result: https://cdn.jsdelivr.net/gh/TracingInsights/2021@main/Belgian%20Grand%20Prix/Race/drivers.min.json

import tif1

config = tif1.get_config()

# Set custom CDN sources
config.set("cdns", [
    "https://cdn.jsdelivr.net/gh/TracingInsights",
    "https://backup.cdn.com/f1data"
])

# Enable minification for bandwidth savings
config.set("cdn_use_minification", True)

# Save configuration
config.save()

from tif1.cdn import get_cdn_manager, CDNSource

# Get the global CDN manager
cdn = get_cdn_manager()

# Check available sources
print("Available CDN sources:")
for source in cdn.get_sources():
    print(f"  {source.name} (priority {source.priority})")

# Add a backup CDN source
backup = CDNSource(
    name="Backup CDN",
    base_url="https://backup.example.com/f1data",
    priority=2,
    enabled=True,
    use_minification=False
)
cdn.add_source(backup)

# Format URL for Belgian GP 2021 Race drivers data
primary_source = cdn.get_sources()[0]
url = primary_source.format_url(
    year=2021,
    gp="Belgian%20Grand%20Prix",
    session="Race",
    path="drivers.json"
)
print(f"\nFetching from: {url}")

# The CDN manager automatically handles fallback
# If jsDelivr fails, it tries the backup source
def fetch_data(url: str) -> dict:
    import requests
    response = requests.get(url, timeout=30)
    response.raise_for_status()
    return response.json()

try:
    data = cdn.try_sources(
        year=2021,
        gp="Belgian%20Grand%20Prix",
        session="Race",
        path="drivers.json",
        fetch_func=fetch_data
    )
    print(f"Successfully fetched data with {len(data.get('drivers', []))} drivers")
except Exception as e:
    print(f"All CDN sources failed: {e}")

# Check source health after fetch
print("\nCDN source health:")
for source in cdn.sources:
    failures = cdn._failure_counts.get(source.name, 0)
    status = "healthy" if failures < 3 else "disabled"
    print(f"  {source.name}: {failures} failures ({status})")