HTTP & Networking

{
  "cdns": ["https://cdn.jsdelivr.net/gh/TracingInsights"],
  "cdn_use_minification": false
}

{
  "cdns": [
    "https://cdn.jsdelivr.net/gh/TracingInsights",
    "https://your-custom-cdn.com/TracingInsights"
  ],
  "cdn_use_minification": true
}

from tif1.cdn import get_cdn_manager

cdn_manager = get_cdn_manager()

# Check available CDNs
sources = cdn_manager.get_sources()
for source in sources:
    print(f"{source.name}: enabled={source.enabled}, priority={source.priority}")

# Reset failure counts (useful after network recovery)
cdn_manager.reset()

{
  "timeout": 30,
  "max_retries": 3,
  "retry_backoff_factor": 2.0,
  "retry_jitter": true,
  "retry_jitter_max": 1.0,
  "max_retry_delay": 60.0,
  "circuit_breaker_threshold": 5,
  "circuit_breaker_timeout": 60,
  "max_workers": 20,
  "max_concurrent_requests": 20,
  "pool_connections": 256,
  "pool_maxsize": 512,
  "keepalive_timeout": 120,
  "keepalive_max_requests": 1000,
  "http_multiplexed": true,
  "http_disable_http3": false,
  "http_resolvers": ["standard", "doh://cloudflare", "doh://google"],
  "cdns": ["https://cdn.jsdelivr.net/gh/TracingInsights"],
  "cdn_use_minification": false,
  "pool_exhaustion_backoff_base": 0.5,
  "pool_exhaustion_backoff_max": 5.0,
  "pool_exhaustion_backoff_jitter": 0.5,
  "json_parse_workers": 0,
  "telemetry_prefetch_max_concurrent_requests": 128,
  "connection_stats_log_interval": 60.0
}

# Basic HTTP settings
export TIF1_TIMEOUT=30
export TIF1_MAX_RETRIES=3
export TIF1_MAX_WORKERS=20

# Retry strategy
export TIF1_RETRY_BACKOFF_FACTOR=2.0
export TIF1_RETRY_JITTER=true
export TIF1_RETRY_JITTER_MAX=1.0
export TIF1_MAX_RETRY_DELAY=60.0

# Circuit breaker
export TIF1_CIRCUIT_BREAKER_THRESHOLD=5
export TIF1_CIRCUIT_BREAKER_TIMEOUT=60

# Connection pooling
export TIF1_POOL_CONNECTIONS=256
export TIF1_POOL_MAXSIZE=512
export TIF1_KEEPALIVE_TIMEOUT=120
export TIF1_KEEPALIVE_MAX_REQUESTS=1000

# Concurrency
export TIF1_MAX_CONCURRENT_REQUESTS=20
export TIF1_TELEMETRY_PREFETCH_MAX_CONCURRENT_REQUESTS=128

# Protocol
export TIF1_HTTP_MULTIPLEXED=true
export TIF1_HTTP_DISABLE_HTTP3=false
export TIF1_HTTP_RESOLVERS="standard,doh://cloudflare,doh://google"

# CDN
export TIF1_CDNS="https://cdn.jsdelivr.net/gh/TracingInsights"
export TIF1_CDN_USE_MINIFICATION=false

# Pool exhaustion
export TIF1_POOL_EXHAUSTION_BACKOFF_BASE=0.5
export TIF1_POOL_EXHAUSTION_BACKOFF_MAX=5.0
export TIF1_POOL_EXHAUSTION_BACKOFF_JITTER=0.5

# Advanced
export TIF1_JSON_PARSE_WORKERS=0
export TIF1_CONNECTION_STATS_LOG_INTERVAL=60.0

{
  "max_retries": 0,
  "max_concurrent_requests": 128,
  "telemetry_prefetch_max_concurrent_requests": 256,
  "pool_connections": 512,
  "pool_maxsize": 2048
}

{
  "timeout": 60,
  "max_retries": 5,
  "max_concurrent_requests": 5,
  "telemetry_prefetch_max_concurrent_requests": 10,
  "retry_backoff_factor": 3.0
}

{
  "max_workers": 5,
  "max_concurrent_requests": 5,
  "telemetry_prefetch_max_concurrent_requests": 10,
  "pool_connections": 50,
  "pool_maxsize": 100,
  "json_parse_workers": 0
}

{
  "max_retries": 10,
  "retry_backoff_factor": 1.5,
  "max_retry_delay": 120.0,
  "circuit_breaker_threshold": 10,
  "circuit_breaker_timeout": 120,
  "cdns": [
    "https://cdn.jsdelivr.net/gh/TracingInsights",
    "https://backup-cdn.example.com/TracingInsights"
  ]
}

def get_session() -> Any  # Returns niquests.Session

{
  "http_resolvers": ["standard", "doh://cloudflare", "doh://google"]
}

export TIF1_HTTP_RESOLVERS="standard,doh://cloudflare,doh://google"

{
  "http_multiplexed": false
}

export TIF1_HTTP_MULTIPLEXED=false

{
  "http_disable_http3": true
}

export TIF1_HTTP_DISABLE_HTTP3=true

from tif1.http_session import get_session

# Get shared session (thread-safe)
session = get_session()

# Make requests (connection automatically reused)
response1 = session.get("https://cdn.jsdelivr.net/gh/TracingInsights/2024@main/Bahrain/Race/drivers.json")
response2 = session.get("https://cdn.jsdelivr.net/gh/TracingInsights/2024@main/Bahrain/Race/laps_VER.json")

# Connections are automatically reused between requests
data1 = response1.json()
data2 = response2.json()

def close_session() -> None

from tif1.http_session import close_session
import atexit

# Automatic cleanup on program exit (already registered by default)
atexit.register(close_session)

# Manual cleanup (rarely needed)
close_session()

def get_connection_stats() -> dict[str, Any]

from tif1.http_session import get_connection_stats

# Fetch some data first
import tif1
session = tif1.get_session(2024, "Bahrain", "Race")
session.load()

# Check connection pool efficiency
stats = get_connection_stats()
print(f"Total requests: {stats['total_requests']}")
print(f"Connections reused: {stats['connections_reused']}")
print(f"Reuse rate: {stats['reuse_rate']:.1f}%")

# Example output:
# Total requests: 156
# Connections reused: 148
# Reuse rate: 94.9%

import logging
from tif1.http_session import get_connection_stats

logger = logging.getLogger(__name__)

def log_connection_efficiency():
    """Log connection pool efficiency for monitoring."""
    stats = get_connection_stats()

    if stats['reuse_rate'] < 70:
        logger.warning(
            f"Low connection reuse rate: {stats['reuse_rate']:.1f}% "
            f"({stats['connections_reused']}/{stats['total_requests']} requests)"
        )
    else:
        logger.info(
            f"Connection pool healthy: {stats['reuse_rate']:.1f}% reuse rate"
        )

def reset_connection_stats() -> None

from tif1.http_session import reset_connection_stats, get_connection_stats

# Reset stats before measurement
reset_connection_stats()

# Perform operations to measure
# ... fetch data ...

# Check stats for just this operation
stats = get_connection_stats()
print(f"Operation used {stats['total_requests']} requests")

async def fetch_json_async(
    year: int,
    gp: str,
    session: str,
    path: str,
    max_retries: int | None = None,
    timeout: int | None = None,
    *,
    use_cache: bool = True,
    write_cache: bool = True,
    validate_payload: bool = True
) -> dict[str, Any]

import asyncio
from tif1.async_fetch import fetch_json_async

async def load_drivers():
    """Load driver list for a session."""
    data = await fetch_json_async(
        2024, "Bahrain Grand Prix", "Race", "drivers.json"
    )

    print(f"Loaded {len(data['DriverNumber'])} drivers")
    for i, driver in enumerate(data['BroadcastName']):
        print(f"  {data['DriverNumber'][i]}: {driver} ({data['TeamName'][i]})")

asyncio.run(load_drivers())

import asyncio
from tif1.async_fetch import fetch_json_async

async def load_with_long_timeout():
    """Load data with extended timeout for slow connections."""
    data = await fetch_json_async(
        2024, "Bahrain Grand Prix", "Race", "laps_VER.json",
        timeout=60  # 60 second timeout instead of default 30
    )
    print(f"Loaded {len(data['LapNumber'])} laps")
    return data

asyncio.run(load_with_long_timeout())

import asyncio
from tif1.async_fetch import fetch_json_async

async def ultra_fast_load():
    """Load data with zero retries for fastest possible cold start."""
    data = await fetch_json_async(
        2024, "Bahrain Grand Prix", "Race", "drivers.json",
        max_retries=0  # Try each CDN once, no delays
    )
    return data

asyncio.run(ultra_fast_load())

import asyncio
from tif1.async_fetch import fetch_json_async

async def force_fresh_fetch():
    """Force fresh fetch from network, bypassing cache entirely."""
    data = await fetch_json_async(
        2024, "Bahrain Grand Prix", "Race", "drivers.json",
        use_cache=False,  # Skip cache read
        write_cache=False  # Don't write to cache
    )
    return data

asyncio.run(force_fresh_fetch())

import asyncio
from tif1.async_fetch import fetch_json_async

async def fast_load_no_validation():
    """Load data without validation for 10-15% performance improvement."""
    data = await fetch_json_async(
        2024, "Bahrain Grand Prix", "Race", "laps_VER.json",
        validate_payload=False  # Skip Pydantic validation
    )
    return data

asyncio.run(fast_load_no_validation())

import asyncio
from tif1.async_fetch import fetch_json_async
from tif1.exceptions import NetworkError, DataNotFoundError, InvalidDataError

async def robust_fetch():
    """Fetch with comprehensive error handling."""
    try:
        data = await fetch_json_async(
            2024, "Bahrain Grand Prix", "Race", "laps_VER.json"
        )
        print(f"Success: {len(data['LapNumber'])} laps")
        return data

    except DataNotFoundError as e:
        print(f"Data not found: {e.year} {e.event} {e.session}")
        print("This session may not have been run yet or driver code is invalid")
        return None

    except NetworkError as e:
        print(f"Network error: {e.url}")
        print(f"Status code: {e.status_code}")
        print("Check your internet connection, CDN health, or try again later")
        return None

    except InvalidDataError as e:
        print(f"Invalid data: {e.reason}")
        print("Data may be corrupted, try clearing cache or check CDN status")
        return None

asyncio.run(robust_fetch())

async def fetch_multiple_async(
    requests: list[tuple[int, str, str, str]],
    *,
    use_cache: bool = True,
    write_cache: bool = True,
    validate_payload: bool = True,
    max_retries: int | None = None,
    timeout: int | None = None,
    max_concurrent_requests: int | None = None
) -> list[dict[str, Any] | None]

import asyncio
from tif1.async_fetch import fetch_multiple_async

async def load_multiple_drivers():
    """Load lap data for multiple drivers in parallel."""
    drivers = ["VER", "HAM", "LEC", "SAI", "NOR"]

    # Build requests for all drivers
    requests = [
        (2024, "Bahrain Grand Prix", "Race", f"laps_{driver}.json")
        for driver in drivers
    ]

    # Fetch all in parallel (default 20 concurrent)
    results = await fetch_multiple_async(requests)

    # Process results (None for failed requests)
    for driver, data in zip(drivers, results):
        if data:
            lap_count = len(data['LapNumber'])
            print(f"{driver}: {lap_count} laps")
        else:
            print(f"{driver}: Failed to load")

asyncio.run(load_multiple_drivers())

import asyncio
from tif1.async_fetch import fetch_multiple_async

async def prefetch_all_telemetry():
    """Prefetch telemetry for all drivers and laps with high concurrency."""
    drivers = ["VER", "HAM", "LEC", "SAI", "NOR"]
    laps = range(1, 58)  # 57 laps

    # Build requests for all driver/lap combinations (285 files)
    requests = [
        (2024, "Bahrain Grand Prix", "Race", f"telemetry_{driver}_{lap}.json")
        for driver in drivers
        for lap in laps
    ]

    print(f"Fetching {len(requests)} telemetry files...")

    # Fetch with high concurrency for speed (128 concurrent requests)
    results = await fetch_multiple_async(
        requests,
        max_concurrent_requests=128  # High concurrency for telemetry
    )

    # Count successes
    success_count = sum(1 for r in results if r is not None)
    print(f"Successfully loaded {success_count}/{len(requests)} files")
    print(f"Failed: {len(requests) - success_count} files")

asyncio.run(prefetch_all_telemetry())

import asyncio
from tif1.async_fetch import fetch_multiple_async

async def load_with_low_concurrency():
    """Load files with reduced concurrency for slow connections."""
    requests = [
        (2024, "Bahrain Grand Prix", "Race", f"laps_{driver}.json")
        for driver in ["VER", "HAM", "LEC", "SAI", "NOR"]
    ]

    # Limit to 5 concurrent requests for slow network
    results = await fetch_multiple_async(
        requests,
        max_concurrent_requests=5
    )

    return results

asyncio.run(load_with_low_concurrency())

import asyncio
from tif1.async_fetch import fetch_multiple_async

async def batch_process_large_dataset():
    """Process large dataset in manageable batches to control memory usage."""
    # Generate 500 requests (all telemetry for one driver)
    all_requests = [
        (2024, "Bahrain Grand Prix", "Race", f"telemetry_VER_{lap}.json")
        for lap in range(1, 501)
    ]

    batch_size = 50
    all_results = []

    # Process in batches of 50
    for i in range(0, len(all_requests), batch_size):
        batch = all_requests[i:i+batch_size]
        batch_num = i//batch_size + 1
        total_batches = (len(all_requests) + batch_size - 1) // batch_size

        print(f"Processing batch {batch_num}/{total_batches}")

        results = await fetch_multiple_async(
            batch,
            max_concurrent_requests=20
        )

        all_results.extend(results)

        # Optional: Add delay between batches to avoid rate limiting
        if i + batch_size < len(all_requests):
            await asyncio.sleep(1)

    success_count = sum(1 for r in all_results if r is not None)
    print(f"Total: {success_count}/{len(all_requests)} successful")

    return all_results

asyncio.run(batch_process_large_dataset())

import asyncio
from tif1.async_fetch import fetch_multiple_async

async def load_and_filter():
    """Load multiple files and filter out failures."""
    drivers = ["VER", "HAM", "LEC", "SAI", "NOR", "INVALID"]

    requests = [
        (2024, "Bahrain Grand Prix", "Race", f"laps_{driver}.json")
        for driver in drivers
    ]

    results = await fetch_multiple_async(requests)

    # Filter out None values (failed requests)
    successful = [
        (driver, data)
        for driver, data in zip(drivers, results)
        if data is not None
    ]

    print(f"Loaded {len(successful)}/{len(drivers)} drivers")

    for driver, data in successful:
        print(f"{driver}: {len(data['LapNumber'])} laps")

    return successful

asyncio.run(load_and_filter())

import asyncio
from tif1.async_fetch import fetch_multiple_async

async def load_with_progress():
    """Load files with progress tracking."""
    drivers = ["VER", "HAM", "LEC", "SAI", "NOR"]
    laps = range(1, 58)

    requests = [
        (2024, "Bahrain Grand Prix", "Race", f"telemetry_{driver}_{lap}.json")
        for driver in drivers
        for lap in laps
    ]

    print(f"Starting fetch of {len(requests)} files...")
    start_time = asyncio.get_event_loop().time()

    results = await fetch_multiple_async(
        requests,
        max_concurrent_requests=128
    )

    elapsed = asyncio.get_event_loop().time() - start_time
    success_count = sum(1 for r in results if r is not None)

    print(f"Completed in {elapsed:.2f}s")
    print(f"Success rate: {success_count/len(requests)*100:.1f}%")
    print(f"Throughput: {len(requests)/elapsed:.1f} files/sec")

    return results

asyncio.run(load_with_progress())

import asyncio
from tif1.async_fetch import fetch_multiple_async

async def load_multiple_drivers():
    requests = [
        (2021, "Belgian Grand Prix", "Race", "laps_VER.json"),
        (2021, "Belgian Grand Prix", "Race", "laps_HAM.json"),
        (2021, "Belgian Grand Prix", "Race", "laps_LEC.json"),
    ]

    results = await fetch_multiple_async(requests)

    for i, data in enumerate(results):
        if data:
            print(f"Driver {i+1}: {len(data['LapNumber'])} laps")

asyncio.run(load_multiple_drivers())

async def fetch_with_rate_limit(
    coro_func,
    *args,
    semaphore: asyncio.Semaphore | None = None,
    **kwargs
)

import asyncio
from tif1.async_fetch import fetch_with_rate_limit, fetch_json_async

async def fetch_with_custom_limit():
    semaphore = asyncio.Semaphore(5)
    result = await fetch_with_rate_limit(
        fetch_json_async, 2021, "Belgian Grand Prix", "Race", "drivers.json",
        semaphore=semaphore
    )
    print(f"Fetched {len(result)} drivers")

asyncio.run(fetch_with_custom_limit())

def close_session() -> None

from tif1.async_fetch import close_session
import atexit

atexit.register(close_session)

def cleanup_resources() -> None

from tif1.async_fetch import cleanup_resources

# At program exit
cleanup_resources()

import asyncio
from tif1.async_fetch import fetch_multiple_async

async def load_all_telemetry():
    requests = [...]  # 100+ (year, gp, session, path) tuples

    # Limit to 5 concurrent requests
    results = await fetch_multiple_async(requests, max_concurrent_requests=5)
    return results

from tif1 import get_config

config = get_config()
config.set("pool_connections", 512)  # Explicit pool size
config.set("pool_maxsize", 2048)     # Max pool size for bursts
config.set("keepalive_timeout", 120) # Keep-alive timeout in seconds

Attempt 1: Immediate (CDN 1)
Attempt 1 failed: Try CDN 2, CDN 3...
Attempt 2: Wait ~2 seconds, retry all CDNs
Attempt 3: Wait ~4 seconds, retry all CDNs
Attempt 4: Fail with NetworkError

import asyncio
from tif1.async_fetch import fetch_multiple_async

async def load_session_parallel():
    """Load all driver lap data in parallel."""
    drivers = ["VER", "HAM", "LEC", "SAI", "NOR"]

    # Build requests for all drivers
    requests = [
        (2021, "Belgian Grand Prix", "Race", f"laps_{driver}.json")
        for driver in drivers
    ]

    # Fetch all in parallel
    results = await fetch_multiple_async(requests, max_concurrent_requests=10)

    for driver, data in zip(drivers, results):
        if data:
            print(f"{driver}: {len(data['LapNumber'])} laps")

asyncio.run(load_session_parallel())

import asyncio
from tif1.async_fetch import fetch_json_async
from tif1.exceptions import NetworkError, DataNotFoundError

async def fetch_with_custom_timeout():
    """Fetch with custom timeout and error handling."""
    try:
        # Use 60 second timeout for slow connections
        data = await fetch_json_async(
            2021, "Belgian Grand Prix", "Race", "laps_VER.json",
            timeout=60
        )
        print(f"Success: {len(data['LapNumber'])} laps")
    except DataNotFoundError as e:
        print(f"Data not found: {e.event} {e.session}")
    except NetworkError as e:
        print(f"Network error: {e.url}")

asyncio.run(fetch_with_custom_timeout())

import asyncio
from tif1.async_fetch import fetch_multiple_async

async def batch_fetch_telemetry():
    """Fetch telemetry for multiple driver/lap combinations."""
    drivers = ["VER", "HAM", "LEC"]
    laps = [1, 2, 3, 4, 5]

    # Build requests for all combinations
    requests = [
        (2021, "Belgian Grand Prix", "Race", f"telemetry_{driver}_{lap}.json")
        for driver in drivers
        for lap in laps
    ]

    # Fetch in batches of 20
    batch_size = 20
    all_results = []

    for i in range(0, len(requests), batch_size):
        batch = requests[i:i+batch_size]
        results = await fetch_multiple_async(batch, max_concurrent_requests=10)
        all_results.extend(results)
        print(f"Processed batch {i//batch_size + 1}")

    return all_results

asyncio.run(batch_fetch_telemetry())

import asyncio
import atexit
from tif1.async_fetch import cleanup_resources, fetch_json_async

# Register cleanup on exit (automatic, but shown for clarity)
atexit.register(cleanup_resources)

async def main():
    """Main application with automatic cleanup."""
    data = await fetch_json_async(
        2021, "Belgian Grand Prix", "Race", "drivers.json"
    )
    print(f"Loaded {len(data)} drivers")

asyncio.run(main())
# cleanup_resources() called automatically on exit

import asyncio
from tif1 import get_config
from tif1.async_fetch import fetch_json_async

async def ultra_fast_fetch():
    """Disable retries for fastest possible cold start."""
    config = get_config()
    config.set("max_retries", 0)  # Try each CDN once, no delays

    data = await fetch_json_async(
        2021, "Belgian Grand Prix", "Race", "drivers.json"
    )
    print(f"Loaded {len(data)} drivers")

asyncio.run(ultra_fast_fetch())

data = await fetch_json_async(
    2021, "Belgian Grand Prix", "Race", "drivers.json",
    validate_payload=False
)

from tif1 import get_config
config = get_config()
config.set("max_retries", 0)

from tif1.http_session import get_connection_stats

stats = get_connection_stats()
print(f"Reuse rate: {stats['reuse_rate']:.1f}%")

from tif1.retry import get_circuit_breaker

cb = get_circuit_breaker()
print(f"Circuit breaker state: {cb.state}")

from tif1.async_fetch import cleanup_resources
cleanup_resources()

from tif1 import get_config
config = get_config()
config.set("json_parse_workers", 4)  # Use 4 worker processes

# Calculate optimal pool size
max_concurrent = max(
    config.get("max_concurrent_requests", 20),
    config.get("telemetry_prefetch_max_concurrent_requests", 128)
)

# Recommended sizing
pool_connections = max(256, max_concurrent)  # At least 256, or match concurrency
pool_maxsize = pool_connections * 4  # 4x for burst handling

from tif1.http_session import get_connection_stats
import time

def monitor_pool_health(duration_seconds=60):
    """Monitor connection pool health over time."""
    start_time = time.time()

    while time.time() - start_time < duration_seconds:
        stats = get_connection_stats()

        print(f"Time: {time.time() - start_time:.1f}s")
        print(f"  Total requests: {stats['total_requests']}")
        print(f"  Reuse rate: {stats['reuse_rate']:.1f}%")
        print(f"  Pools created: {stats['connections_created']}")

        # Alert on low reuse rate
        if stats['total_requests'] > 50 and stats['reuse_rate'] < 70:
            print("  ⚠️  WARNING: Low connection reuse rate!")
            print("     Consider increasing pool_connections or reducing concurrency")

        time.sleep(10)

# Run monitoring
monitor_pool_health(60)

from tif1 import get_config

config = get_config()

# Option 1: Increase pool size
config.set("pool_connections", 512)
config.set("pool_maxsize", 2048)

# Option 2: Reduce concurrency
config.set("max_concurrent_requests", 10)
config.set("telemetry_prefetch_max_concurrent_requests", 50)

# Option 3: Increase backoff tolerance
config.set("pool_exhaustion_backoff_max", 10.0)

import orjson

# Fast parsing with orjson
data = orjson.loads(response.content)

from tif1 import get_config

config = get_config()
config.set("json_parse_workers", 4)  # Use 4 worker processes

import time
import asyncio
from tif1.async_fetch import fetch_json_async
from tif1 import get_config

async def benchmark_json_parsing():
    """Benchmark JSON parsing strategies."""
    config = get_config()

    # Test 1: Thread pool (default)
    config.set("json_parse_workers", 0)
    start = time.time()
    data1 = await fetch_json_async(2024, "Bahrain", "Race", "laps_VER.json")
    thread_time = time.time() - start

    # Test 2: Process pool
    config.set("json_parse_workers", 4)
    start = time.time()
    data2 = await fetch_json_async(2024, "Bahrain", "Race", "laps_VER.json", use_cache=False)
    process_time = time.time() - start

    print(f"Thread pool: {thread_time:.3f}s")
    print(f"Process pool: {process_time:.3f}s")
    print(f"Speedup: {thread_time/process_time:.2f}x")

asyncio.run(benchmark_json_parsing())

from tif1 import get_config

config = get_config()
config.set("max_retries", 0)

export TIF1_MAX_RETRIES=0

# Normal mode (max_retries=3):
# Try CDN 1 → fail → wait 1s → retry CDN 1 → fail → wait 2s → retry CDN 1 → fail
# Try CDN 2 → fail → wait 1s → retry CDN 2 → fail → wait 2s → retry CDN 2 → fail
# Total: ~15 seconds of delays

# Zero-retry mode (max_retries=0):
# Try CDN 1 → fail → immediately try CDN 2 → fail → immediately try CDN 3
# Total: ~0 seconds of delays

import asyncio
from tif1.async_fetch import fetch_multiple_async
from tif1 import get_config

async def robust_zero_retry_fetch():
    """Fetch with zero-retry mode and handle failures gracefully."""
    config = get_config()
    config.set("max_retries", 0)

    requests = [
        (2024, "Bahrain", "Race", f"laps_{driver}.json")
        for driver in ["VER", "HAM", "LEC", "SAI", "NOR"]
    ]

    # First attempt with zero retries
    results = await fetch_multiple_async(requests)

    # Identify failures
    failed_indices = [i for i, r in enumerate(results) if r is None]

    if failed_indices:
        print(f"First attempt: {len(results) - len(failed_indices)}/{len(results)} succeeded")

        # Retry failures with normal retry logic
        config.set("max_retries", 3)
        failed_requests = [requests[i] for i in failed_indices]
        retry_results = await fetch_multiple_async(failed_requests)

        # Merge results
        for i, result in zip(failed_indices, retry_results):
            results[i] = result

        print(f"After retry: {sum(1 for r in results if r)}/{len(results)} succeeded")

    return results

asyncio.run(robust_zero_retry_fetch())

HTTP/1.1 (6 connections):
Connection 1: [Request 1] → [Response 1]
Connection 2: [Request 2] → [Response 2]
Connection 3: [Request 3] → [Response 3]
Connection 4: [Request 4] → [Response 4]
Connection 5: [Request 5] → [Response 5]
Connection 6: [Request 6] → [Response 6]

HTTP/2 (1 connection):
Connection 1: [Req 1][Req 2][Req 3][Req 4][Req 5][Req 6]
              [Res 1][Res 2][Res 3][Res 4][Res 5][Res 6]

from tif1.http_session import get_connection_stats
import asyncio
from tif1.async_fetch import fetch_multiple_async

async def measure_multiplexing():
    """Measure HTTP/2 multiplexing efficiency."""
    # Fetch 100 files
    requests = [
        (2024, "Bahrain", "Race", f"telemetry_VER_{lap}.json")
        for lap in range(1, 101)
    ]

    await fetch_multiple_async(requests, max_concurrent_requests=50)

    # Check connection stats
    stats = get_connection_stats()

    print(f"Total requests: {stats['total_requests']}")
    print(f"Connections created: {stats['connections_created']}")
    print(f"Requests per connection: {stats['total_requests'] / stats['connections_created']:.1f}")

    # With HTTP/2 multiplexing, you should see:
    # - 1-2 connections created (one per CDN host)
    # - 50-100 requests per connection
    # - 95%+ reuse rate

asyncio.run(measure_multiplexing())

MultiplexingError: non-multiplexed response after a redirect

from tif1 import get_config

config = get_config()
config.set("http_multiplexed", False)

CLOSED (normal operation)
  ↓ (5 consecutive failures)
OPEN (blocking requests)
  ↓ (60 seconds timeout)
HALF-OPEN (testing recovery)
  ↓ (success)        ↓ (failure)
CLOSED            OPEN

from tif1.retry import get_circuit_breaker
import time

def monitor_circuit_breaker(duration_seconds=60):
    """Monitor circuit breaker state over time."""
    cb = get_circuit_breaker()
    start_time = time.time()

    while time.time() - start_time < duration_seconds:
        print(f"Time: {time.time() - start_time:.1f}s")
        print(f"  State: {cb.state}")
        print(f"  Failures: {cb.failures}")

        if cb.state == "open":
            print("  ⚠️  Circuit breaker is OPEN - requests are blocked!")
            if cb.last_failure_time:
                elapsed = (time.time() - cb._last_failure_monotonic)
                remaining = cb.timeout - elapsed
                print(f"  Time until half-open: {remaining:.1f}s")

        time.sleep(5)

monitor_circuit_breaker(60)

from tif1.retry import get_circuit_breaker, reset_circuit_breaker

cb = get_circuit_breaker()

# Check state
if cb.state == "open":
    print("Circuit breaker is open, waiting for recovery...")

    # Option 1: Wait for automatic recovery
    import time
    time.sleep(cb.timeout)

    # Option 2: Force reset (use with caution!)
    reset_circuit_breaker()
    print("Circuit breaker reset")

from tif1 import get_config

config = get_config()

# More tolerant (slower to open, longer recovery)
config.set("circuit_breaker_threshold", 10)  # 10 failures before opening
config.set("circuit_breaker_timeout", 120)   # 2 minutes recovery time

# Less tolerant (faster to open, shorter recovery)
config.set("circuit_breaker_threshold", 3)   # 3 failures before opening
config.set("circuit_breaker_timeout", 30)    # 30 seconds recovery time

import asyncio
import time
from tif1.http_session import get_connection_stats
from tif1.retry import get_circuit_breaker
from tif1.cdn import get_cdn_manager

async def performance_dashboard():
    """Real-time performance monitoring dashboard."""
    start_time = time.time()

    while True:
        elapsed = time.time() - start_time

        # Connection stats
        conn_stats = get_connection_stats()

        # Circuit breaker
        cb = get_circuit_breaker()

        # CDN health
        cdn_manager = get_cdn_manager()
        cdn_sources = cdn_manager.get_sources()

        # Clear screen (optional)
        print("\033[2J\033[H")  # ANSI escape codes

        print(f"=== tif1 Performance Dashboard (Runtime: {elapsed:.1f}s) ===\n")

        print("Connection Pool:")
        print(f"  Total requests: {conn_stats['total_requests']}")
        print(f"  Reuse rate: {conn_stats['reuse_rate']:.1f}%")
        print(f"  Pools created: {conn_stats['connections_created']}")

        if conn_stats['total_requests'] > 0:
            throughput = conn_stats['total_requests'] / elapsed
            print(f"  Throughput: {throughput:.1f} req/s")

        print(f"\nCircuit Breaker:")
        print(f"  State: {cb.state}")
        print(f"  Failures: {cb.failures}")

        print(f"\nCDN Health:")
        for source in cdn_sources:
            status = "✓" if source.enabled else "✗"
            print(f"  {status} {source.name} (priority: {source.priority})")

        await asyncio.sleep(1)

# Run dashboard
asyncio.run(performance_dashboard())

import asyncio
import time
from tif1.async_fetch import fetch_multiple_async

async def profile_fetch_operation():
    """Profile a fetch operation to identify bottlenecks."""
    requests = [
        (2024, "Bahrain", "Race", f"laps_{driver}.json")
        for driver in ["VER", "HAM", "LEC", "SAI", "NOR"]
    ]

    # Measure total time
    start = time.time()
    results = await fetch_multiple_async(requests, max_concurrent_requests=20)
    total_time = time.time() - start

    # Calculate metrics
    success_count = sum(1 for r in results if r is not None)
    throughput = len(requests) / total_time
    avg_time_per_request = total_time / len(requests)

    print(f"Profile Results:")
    print(f"  Total time: {total_time:.3f}s")
    print(f"  Requests: {len(requests)}")
    print(f"  Successes: {success_count}")
    print(f"  Failures: {len(requests) - success_count}")
    print(f"  Throughput: {throughput:.1f} req/s")
    print(f"  Avg time per request: {avg_time_per_request:.3f}s")

    # Connection stats
    from tif1.http_session import get_connection_stats
    stats = get_connection_stats()
    print(f"\nConnection Pool:")
    print(f"  Reuse rate: {stats['reuse_rate']:.1f}%")
    print(f"  Pools created: {stats['connections_created']}")

asyncio.run(profile_fetch_operation())

import logging
from tif1 import get_config
from tif1.http_session import get_connection_stats

# Enable debug logging to see request timing
logging.basicConfig(level=logging.DEBUG)

# Check timeout setting
config = get_config()
print(f"Timeout: {config.get('timeout')}s")
print(f"Max retries: {config.get('max_retries')}")
print(f"Backoff factor: {config.get('retry_backoff_factor')}")

# Check connection pool health
stats = get_connection_stats()
print(f"Connection reuse rate: {stats['reuse_rate']:.1f}%")

from tif1 import get_config

config = get_config()

# Solution 1: Increase timeout for slow connections
config.set("timeout", 60)

# Solution 2: Reduce retries for faster failure
config.set("max_retries", 1)

# Solution 3: Enable zero-retry mode for ultra-fast cold start
config.set("max_retries", 0)

# Solution 4: Increase concurrency for parallel operations
config.set("max_concurrent_requests", 50)
config.set("telemetry_prefetch_max_concurrent_requests", 128)

# Solution 5: Check if HTTP/2 multiplexing is enabled
if not config.get("http_multiplexed"):
    print("HTTP/2 multiplexing is disabled - consider enabling for better performance")
    config.set("http_multiplexed", True)

from tif1.retry import get_circuit_breaker
from tif1.cdn import get_cdn_manager
from tif1 import get_config

# Check circuit breaker state
cb = get_circuit_breaker()
print(f"Circuit breaker state: {cb.state}")
print(f"Failure count: {cb.failures}")

# Check CDN health
cdn_manager = get_cdn_manager()
sources = cdn_manager.get_sources()
print(f"Available CDNs: {len(sources)}")
for source in sources:
    print(f"  {source.name}: enabled={source.enabled}")

# Check DNS resolvers
config = get_config()
print(f"DNS resolvers: {config.get('http_resolvers')}")

from tif1.retry import reset_circuit_breaker
from tif1.cdn import get_cdn_manager
from tif1 import get_config

# Solution 1: Reset circuit breaker if it's open
cb = get_circuit_breaker()
if cb.state == "open":
    print("Circuit breaker is open, waiting for recovery...")
    import time
    time.sleep(cb.timeout)
    reset_circuit_breaker()
    print("Circuit breaker reset")

# Solution 2: Reset CDN failure counts
cdn_manager = get_cdn_manager()
cdn_manager.reset()
print("CDN failure counts reset")

# Solution 3: Add backup CDN sources
config = get_config()
config.set("cdns", [
    "https://cdn.jsdelivr.net/gh/TracingInsights",
    "https://backup-cdn.example.com/TracingInsights"
])

# Solution 4: Try different DNS resolvers
config.set("http_resolvers", ["doh://cloudflare", "doh://google", "standard"])

# Solution 5: Disable HTTP/3 if experiencing protocol issues
config.set("http_disable_http3", True)

from tif1 import get_config
from tif1.http_session import get_connection_stats

config = get_config()
print(f"Max concurrent requests: {config.get('max_concurrent_requests')}")
print(f"Telemetry prefetch concurrency: {config.get('telemetry_prefetch_max_concurrent_requests')}")

stats = get_connection_stats()
print(f"Total requests: {stats['total_requests']}")
print(f"Requests per second: {stats['total_requests'] / 60:.1f}")  # Assuming 60s runtime

import asyncio
from tif1.async_fetch import fetch_multiple_async
from tif1 import get_config

config = get_config()

# Solution 1: Reduce concurrent requests
config.set("max_concurrent_requests", 5)
config.set("telemetry_prefetch_max_concurrent_requests", 10)

# Solution 2: Add delays between batches
async def fetch_with_delays():
    requests = [...]  # Your requests
    batch_size = 10

    for i in range(0, len(requests), batch_size):
        batch = requests[i:i+batch_size]
        results = await fetch_multiple_async(batch, max_concurrent_requests=5)

        # Add delay between batches
        if i + batch_size < len(requests):
            await asyncio.sleep(2)  # 2 second delay

    return results

# Solution 3: Increase retry backoff to give CDN time to recover
config.set("retry_backoff_factor", 3.0)
config.set("max_retry_delay", 120.0)

import psutil
import os

# Check current memory usage
process = psutil.Process(os.getpid())
memory_mb = process.memory_info().rss / 1024 / 1024
print(f"Current memory usage: {memory_mb:.1f} MB")

from tif1 import get_config
config = get_config()
print(f"Max concurrent requests: {config.get('max_concurrent_requests')}")
print(f"Telemetry prefetch concurrency: {config.get('telemetry_prefetch_max_concurrent_requests')}")
print(f"JSON parse workers: {config.get('json_parse_workers')}")

import asyncio
from tif1.async_fetch import fetch_multiple_async
from tif1 import get_config

config = get_config()

# Solution 1: Reduce concurrency to limit memory usage
config.set("max_concurrent_requests", 5)
config.set("telemetry_prefetch_max_concurrent_requests", 10)

# Solution 2: Disable process pool JSON parsing
config.set("json_parse_workers", 0)

# Solution 3: Process in smaller batches and free memory
async def memory_efficient_fetch():
    all_requests = [...]  # Large list of requests
    batch_size = 10
    all_results = []

    for i in range(0, len(all_requests), batch_size):
        batch = all_requests[i:i+batch_size]
        results = await fetch_multiple_async(batch)

        # Process results immediately
        for result in results:
            if result:
                # Process data
                pass

        # Free memory
        del results

        # Optional: Force garbage collection
        import gc
        gc.collect()

    return all_results

# Solution 4: Reduce cache size
config.set("memory_cache_max_items", 256)
config.set("memory_telemetry_cache_max_items", 512)

from tif1 import get_config
from tif1.http_session import get_connection_stats

# Check pool configuration
config = get_config()
print(f"Pool connections: {config.get('pool_connections')}")
print(f"Pool maxsize: {config.get('pool_maxsize')}")
print(f"Max concurrent requests: {config.get('max_concurrent_requests')}")

# Check connection stats
stats = get_connection_stats()
print(f"Total requests: {stats['total_requests']}")
print(f"Reuse rate: {stats['reuse_rate']:.1f}%")
print(f"Pools created: {stats['connections_created']}")

# Calculate if pool is undersized
max_concurrent = max(
    config.get("max_concurrent_requests", 20),
    config.get("telemetry_prefetch_max_concurrent_requests", 128)
)
print(f"Max concurrent: {max_concurrent}")
print(f"Pool connections: {config.get('pool_connections', 256)}")

if config.get('pool_connections', 256) < max_concurrent:
    print("⚠️  WARNING: Pool is undersized for your concurrency!")