import tif1

# Pandas is the default - no need to specify
session = tif1.get_session(2025, "Monaco Grand Prix", "Race")
laps = session.laps  # Returns pandas DataFrame

# Standard pandas operations work seamlessly
fastest = laps.nsmallest(5, "LapTime")
by_driver = laps.groupby("Driver")["LapTime"].mean()

# Rich pandas API available
verstappen = laps[laps["Driver"] == "VER"]
verstappen_stats = verstappen["LapTime"].describe()

# Pandas indexing and selection
lap_15 = laps[laps["LapNumber"] == 15]
columns_of_interest = laps[["Driver", "LapTime", "Compound", "TyreLife"]]

# Time-based operations (if timestamps available)
laps["LapTime_seconds"] = laps["LapTime"].dt.total_seconds()

# Chaining operations
result = (
    laps
    .query("Compound == 'SOFT'")
    .groupby("Driver")
    .agg({"LapTime": ["mean", "std", "count"]})
    .sort_values(("LapTime", "mean"))
)

# Install tif1 with polars support
pip install tif1 polars

# Or if you already have tif1 installed
pip install polars

# Verify installation
python -c "import polars as pl; print(pl.__version__)"

import tif1
import polars as pl

# Explicitly specify polars backend
session = tif1.get_session(
    2025,
    "Monaco Grand Prix",
    "Race",
    backend="polars"
)
laps = session.laps  # Returns polars DataFrame

# Polars operations (similar but more explicit than pandas)
fastest = laps.sort("LapTime").head(5)
by_driver = laps.group_by("Driver").agg(pl.col("LapTime").mean())

# Polars expression API (powerful and composable)
verstappen = laps.filter(pl.col("Driver") == "VER")
verstappen_stats = verstappen.select([
    pl.col("LapTime").mean().alias("avg_time"),
    pl.col("LapTime").std().alias("std_time"),
    pl.col("LapTime").min().alias("min_time"),
    pl.col("LapTime").max().alias("max_time"),
])

# Complex aggregations with expressions
result = (
    laps
    .filter(pl.col("Compound") == "SOFT")
    .group_by("Driver")
    .agg([
        pl.col("LapTime").mean().alias("mean_time"),
        pl.col("LapTime").std().alias("std_time"),
        pl.col("LapTime").count().alias("lap_count"),
        (pl.col("LapTime") < pl.col("LapTime").quantile(0.25)).sum().alias("fast_laps")
    ])
    .sort("mean_time")
)

# Window functions (running calculations)
laps_with_rolling = laps.with_columns([
    pl.col("LapTime").rolling_mean(window_size=3).over("Driver").alias("rolling_avg"),
    pl.col("LapTime").rank().over("Driver").alias("lap_rank")
])

# Load session, filter to one driver, compute statistics
session = get_session(2024, "Monaco", "Race", backend=backend)
driver_laps = session.laps[session.laps["Driver"] == "VER"]
stats = driver_laps.groupby("Compound").agg({"LapTime": ["mean", "std", "count"]})

# Load all 2024 races, compute fastest lap per driver per race
results = []
for event in get_events(2024):
    session = get_session(2024, event, "Race", backend=backend)
    fastest = session.get_fastest_laps(by_driver=True)
    results.append(fastest)
combined = concat(results)

# Load telemetry, compute speed statistics per corner
session = get_session(2024, "Spa", "Race", backend=backend)
telemetry = session.get_driver("VER").telemetry
corners = identify_corners(telemetry)  # Custom function
corner_stats = telemetry.groupby(corners).agg({"Speed": ["mean", "max", "std"]})

import pyarrow as pa
import polars as pl

# Pandas → Arrow → Polars (zero-copy when possible)
laps_pandas = session.laps  # pandas DataFrame
arrow_table = pa.Table.from_pandas(laps_pandas)
laps_polars = pl.from_arrow(arrow_table)

# Polars → Arrow → Pandas (zero-copy when possible)
laps_polars = session.laps  # polars DataFrame
arrow_table = laps_polars.to_arrow()
laps_pandas = arrow_table.to_pandas()

import tif1
import polars as pl
import matplotlib.pyplot as plt

# Use polars for heavy data processing
session = tif1.get_session(2024, "Spa", "Race", backend="polars")

# Process with polars (fast)
driver_stats = (
    session.laps
    .filter(pl.col("Compound") == "SOFT")
    .group_by("Driver")
    .agg([
        pl.col("LapTime").mean().alias("avg_time"),
        pl.col("LapTime").std().alias("std_time"),
        pl.col("LapTime").count().alias("lap_count")
    ])
    .sort("avg_time")
)

# Convert to pandas for plotting (matplotlib expects pandas)
driver_stats_pd = driver_stats.to_pandas()

# Plot with pandas/matplotlib
fig, ax = plt.subplots(figsize=(12, 6))
driver_stats_pd.plot(x="Driver", y="avg_time", kind="bar", ax=ax)
plt.show()

# Handle type preservation explicitly
laps_polars = pl.from_pandas(
    laps_pandas,
    schema_overrides={
        "Driver": pl.Categorical,
        "LapNumber": pl.Int32,
        "LapTime": pl.Duration(time_unit="ms")
    }
)

{
  "backend": "polars",
  "cache_enabled": true,
  "cache_dir": "/path/to/tif1-cache"
}

import tif1

# Uses polars automatically
session = tif1.get_session(2025, "Monaco", "Race")
print(type(session.laps))  # <class 'polars.dataframe.frame.DataFrame'>

import tif1

# Get config instance
config = tif1.get_config()

# Set backend
config.set("backend", "polars")

# Optionally save to config file
config.save()

# All subsequent calls use polars
session = tif1.get_session(2025, "Monaco", "Race")

import tif1

# Set default to polars
config = tif1.get_config()
config.set("backend", "polars")

# Most sessions use polars
session1 = tif1.get_session(2024, "Spa", "Race")  # Uses polars

# But you can override for specific sessions
session2 = tif1.get_session(2024, "Monaco", "Race", backend="pandas")  # Uses pandas

# Example showing precedence
import os
import tif1

# Config file says "polars"
config = tif1.get_config()
config.set("backend", "polars")

# Environment variable overrides config file
os.environ["TIF1_BACKEND"] = "pandas"

# Explicit parameter overrides everything
session = tif1.get_session(2024, "Monaco", "Race", backend="polars")
# Uses polars (explicit parameter wins)

# Create hierarchical index
laps_indexed = laps.set_index(["Driver", "LapNumber"])

# Access data with MultiIndex
verstappen_lap_10 = laps_indexed.loc[("VER", 10)]

# Aggregate at different levels
by_driver = laps_indexed.groupby(level="Driver").mean()

# Resample time series data
telemetry_resampled = telemetry.set_index("Time").resample("1S").mean()

# Time-based rolling windows
rolling_speed = telemetry.set_index("Time")["Speed"].rolling("5S").mean()

# Business day calculations
race_dates = pd.bdate_range("2024-01-01", "2024-12-31")

# Label-based indexing
verstappen = laps.loc[laps["Driver"] == "VER"]

# Position-based indexing
first_10_laps = laps.iloc[:10]

# Boolean indexing with loc
fast_verstappen = laps.loc[(laps["Driver"] == "VER") & (laps["LapTime"] < 85)]

# Seaborn for statistical visualization
import seaborn as sns
sns.violinplot(data=laps, x="Compound", y="LapTime")

# Scikit-learn for machine learning
from sklearn.ensemble import RandomForestRegressor
X = laps[["TyreLife", "TrackTemp", "AirTemp"]]
y = laps["LapTime"]
model = RandomForestRegressor().fit(X, y)

# Statsmodels for statistical analysis
import statsmodels.api as sm
model = sm.OLS(y, sm.add_constant(X)).fit()
print(model.summary())

import polars as pl

# Create lazy frame (doesn't execute immediately)
laps_lazy = pl.scan_parquet("race_data.parquet")

# Build complex query (still not executed)
result_lazy = (
    laps_lazy
    .filter(pl.col("Driver") == "VER")
    .select(["LapNumber", "LapTime", "Compound"])
    .with_columns([
        (pl.col("LapTime") - pl.col("LapTime").mean()).alias("LapTime_delta")
    ])
    .sort("LapTime")
    .head(10)
)

# Execute optimized query
result = result_lazy.collect()

# View query plan
print(result_lazy.explain())

# Complex expressions in a single pass
result = laps.with_columns([
    # Conditional logic
    pl.when(pl.col("Compound") == "SOFT")
      .then(pl.col("LapTime") * 0.98)
      .otherwise(pl.col("LapTime"))
      .alias("adjusted_time"),

    # String operations
    pl.col("Driver").str.to_lowercase().alias("driver_lower"),

    # Mathematical operations
    (pl.col("Speed") * 1.60934).alias("speed_kph"),

    # Aggregations over windows
    pl.col("LapTime").mean().over("Driver").alias("driver_avg"),

    # Rank within groups
    pl.col("LapTime").rank().over("Driver").alias("lap_rank")
])

# Fast string processing (parallelized)
result = laps.with_columns([
    pl.col("Team").str.to_uppercase(),
    pl.col("Driver").str.replace("_", " "),
    pl.col("Team").str.contains("Red Bull").alias("is_red_bull"),
    pl.col("Driver").str.split("_").list.get(0).alias("first_name")
])

# Export to Arrow for interop with other tools
arrow_table = laps.to_arrow()

# Use with PyArrow compute functions
import pyarrow.compute as pc
filtered = arrow_table.filter(pc.field("LapTime") < 90)

# Use with DuckDB for SQL queries
import duckdb
result = duckdb.query("SELECT Driver, AVG(LapTime) FROM laps GROUP BY Driver").pl()

# Process data larger than RAM
result = (
    pl.scan_parquet("huge_telemetry_data.parquet")
    .filter(pl.col("Speed") > 300)
    .group_by("Driver")
    .agg(pl.col("Speed").mean())
    .collect(streaming=True)  # Process in chunks
)

# Without optimization: Read all data, then filter
laps = pl.read_parquet("race.parquet")
verstappen = laps.filter(pl.col("Driver") == "VER")

# With optimization: Filter while reading (much faster)
verstappen = (
    pl.scan_parquet("race.parquet")
    .filter(pl.col("Driver") == "VER")
    .collect()
)
# Only reads Verstappen's rows from disk!

# Without optimization: Read all columns, then select
laps = pl.read_parquet("race.parquet")  # Reads all 50+ columns
subset = laps.select(["Driver", "LapTime"])

# With optimization: Read only needed columns
subset = (
    pl.scan_parquet("race.parquet")
    .select(["Driver", "LapTime"])
    .collect()
)
# Only reads 2 columns from disk!

result = (
    laps_lazy
    .with_columns([
        (pl.col("LapTime").mean().over("Driver")).alias("driver_avg"),
        (pl.col("LapTime") - pl.col("LapTime").mean().over("Driver")).alias("delta")
    ])
    .collect()
)
# "LapTime.mean().over('Driver')" computed only once

result = (
    laps_lazy
    .filter(pl.col("Team").str.contains("Red Bull"))  # Expensive string op
    .filter(pl.col("LapNumber") > 10)  # Cheap numeric comparison
    .collect()
)
# Polars reorders: numeric filter first, then string filter

query = (
    pl.scan_parquet("race.parquet")
    .filter(pl.col("Driver") == "VER")
    .select(["LapNumber", "LapTime", "Compound"])
    .sort("LapTime")
    .head(10)
)

# View optimized plan
print(query.explain())

SLICE[offset: 0, len: 10]
  SORT BY [col("LapTime")]
    PROJECT */3 COLUMNS
      FILTER col("Driver") == "VER"
        Parquet SCAN race.parquet
        PROJECT */3 COLUMNS
        SELECTION: col("Driver") == "VER"

def process_race_data(race_file: str, output_file: str):
    """Extract, transform, load with lazy evaluation."""
    result = (
        pl.scan_parquet(race_file)
        # Extract: Read only needed columns
        .select(["Driver", "LapNumber", "LapTime", "Compound", "TyreLife"])
        # Transform: Clean and compute
        .filter(pl.col("LapTime").is_not_null())
        .with_columns([
            (pl.col("LapTime") - pl.col("LapTime").mean().over("Driver"))
            .alias("LapTime_delta"),
            (pl.col("TyreLife") / pl.col("TyreLife").max().over(["Driver", "Compound"]))
            .alias("TyreLife_pct")
        ])
        # Load: Write optimized result
        .collect()
    )
    result.write_parquet(output_file)

def aggregate_season(year: int):
    """Aggregate data across all races in a season."""
    race_files = [f"data/{year}/race_{i:02d}.parquet" for i in range(1, 25)]

    # Process each file lazily
    lazy_frames = [
        pl.scan_parquet(f)
        .filter(pl.col("LapTime").is_not_null())
        .group_by("Driver")
        .agg([
            pl.col("LapTime").mean().alias("avg_time"),
            pl.col("LapTime").count().alias("lap_count")
        ])
        for f in race_files
    ]

    # Concatenate and aggregate (still lazy)
    season_stats = (
        pl.concat(lazy_frames)
        .group_by("Driver")
        .agg([
            pl.col("avg_time").mean().alias("season_avg"),
            pl.col("lap_count").sum().alias("total_laps")
        ])
        .collect()
    )

    return season_stats

def analyze_huge_telemetry(telemetry_file: str):
    """Process telemetry data larger than RAM."""
    result = (
        pl.scan_parquet(telemetry_file)
        .filter(pl.col("Speed") > 300)
        .group_by(["Driver", "Corner"])
        .agg([
            pl.col("Speed").mean().alias("avg_speed"),
            pl.col("Speed").max().alias("max_speed"),
            pl.col("Throttle").mean().alias("avg_throttle")
        ])
        .collect(streaming=True)  # Process in chunks
    )
    return result

import tif1
import polars as pl

# Use polars for heavy lifting
session = tif1.get_session(2024, "Spa", "Race", backend="polars")

# Process with polars (fast)
driver_stats = (
    session.laps
    .filter(pl.col("Compound").is_in(["SOFT", "MEDIUM"]))
    .group_by(["Driver", "Compound"])
    .agg([
        pl.col("LapTime").mean().alias("avg_time"),
        pl.col("LapTime").std().alias("std_time"),
        pl.col("LapTime").count().alias("lap_count")
    ])
    .sort("avg_time")
)

# Convert to pandas for visualization
driver_stats_pd = driver_stats.to_pandas()

# Use pandas ecosystem for plotting
import seaborn as sns
import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(14, 8))
sns.barplot(data=driver_stats_pd, x="Driver", y="avg_time", hue="Compound", ax=ax)
plt.xticks(rotation=45)
plt.title("Average Lap Time by Driver and Compound")
plt.tight_layout()
plt.show()

import tif1
import polars as pl

def analyze_telemetry_efficiently(year: int, event: str, driver: str):
    """Analyze telemetry without loading everything into memory."""

    # Use polars for memory efficiency
    session = tif1.get_session(year, event, "Race", backend="polars")
    driver_obj = session.get_driver(driver)

    # Get telemetry (polars uses ~50% less memory)
    telemetry = driver_obj.telemetry

    # Process in chunks using lazy evaluation
    corner_analysis = (
        telemetry
        .lazy()  # Convert to lazy frame
        .with_columns([
            # Identify braking zones
            (pl.col("Brake") > 0).alias("is_braking"),
            # Identify acceleration zones
            (pl.col("Throttle") > 80).alias("is_accelerating"),
            # Speed categories
            pl.when(pl.col("Speed") > 300).then(pl.lit("high_speed"))
              .when(pl.col("Speed") > 200).then(pl.lit("medium_speed"))
              .otherwise(pl.lit("low_speed"))
              .alias("speed_category")
        ])
        .group_by("speed_category")
        .agg([
            pl.col("Speed").mean().alias("avg_speed"),
            pl.col("Throttle").mean().alias("avg_throttle"),
            pl.col("Brake").mean().alias("avg_brake"),
            pl.col("Speed").count().alias("sample_count")
        ])
        .collect()  # Execute optimized query
    )

    return corner_analysis

# Memory usage: ~220MB with polars vs ~450MB with pandas
result = analyze_telemetry_efficiently(2024, "Monaco", "VER")

import tif1
import polars as pl
from pathlib import Path

def process_season_incrementally(year: int, output_dir: Path):
    """Process each race and save results incrementally."""

    output_dir.mkdir(exist_ok=True)

    for event in tif1.get_events(year):
        print(f"Processing {event}...")

        # Load session with polars
        session = tif1.get_session(year, event, "Race", backend="polars")

        # Process and compute statistics
        stats = (
            session.laps
            .group_by("Driver")
            .agg([
                pl.col("LapTime").mean().alias("avg_time"),
                pl.col("LapTime").min().alias("best_time"),
                pl.col("LapTime").std().alias("consistency"),
                pl.col("LapTime").count().alias("laps_completed")
            ])
            .with_columns(pl.lit(event).alias("event"))
        )

        # Save to parquet (efficient format)
        output_file = output_dir / f"{event.replace(' ', '_')}.parquet"
        stats.write_parquet(output_file)

        # Memory is freed after each iteration

    # Later: combine all results lazily
    all_stats = pl.scan_parquet(output_dir / "*.parquet").collect()
    return all_stats

# Process entire season without memory issues
season_stats = process_season_incrementally(2024, Path("./race_stats"))

import polars as pl

# ❌ Inefficient: Multiple filters create intermediate DataFrames
result = laps.filter(pl.col("Driver") == "VER")
result = result.filter(pl.col("Compound") == "SOFT")
result = result.filter(pl.col("LapTime") < 85)

# ✅ Efficient: Single filter with combined condition
result = laps.filter(
    (pl.col("Driver") == "VER") &
    (pl.col("Compound") == "SOFT") &
    (pl.col("LapTime") < 85)
)

# ✅ Also efficient: Chained filters (polars optimizes automatically)
result = (
    laps
    .filter(pl.col("Driver") == "VER")
    .filter(pl.col("Compound") == "SOFT")
    .filter(pl.col("LapTime") < 85)
)

import tif1
import polars as pl
from functools import lru_cache

@lru_cache(maxsize=32)
def get_driver_statistics(year: int, event: str, driver: str):
    """Get driver statistics with caching."""
    session = tif1.get_session(year, event, "Race", backend="polars")
    driver_obj = session.get_driver(driver)

    stats = (
        driver_obj.laps
        .select([
            pl.col("LapTime").mean().alias("avg_time"),
            pl.col("LapTime").std().alias("std_time"),
            pl.col("LapTime").min().alias("best_time"),
            pl.col("LapTime").count().alias("lap_count")
        ])
    )

    return stats

# First call: computes and caches
stats1 = get_driver_statistics(2024, "Monaco", "VER")

# Second call: returns cached result (instant)
stats2 = get_driver_statistics(2024, "Monaco", "VER")

# Install polars
pip install polars

# Verify installation
python -c "import polars as pl; print(pl.__version__)"

# ❌ Pandas-specific (fails with polars)
result = laps.loc[laps["Driver"] == "VER"]

# ✅ Works with both
result = laps[laps["Driver"] == "VER"]

# ❌ Polars-specific (fails with pandas)
result = laps.filter(pl.col("Driver") == "VER")

# ✅ Backend-agnostic wrapper
def filter_driver(laps, driver, backend="pandas"):
    if backend == "polars":
        import polars as pl
        return laps.filter(pl.col("Driver") == driver)
    else:
        return laps[laps["Driver"] == driver]

# Option 1: Switch to polars (uses 50-70% less memory)
session = tif1.get_session(2024, "Monaco", "Race", backend="polars")

# Option 2: Process in chunks with pandas
def process_in_chunks(laps, chunk_size=10000):
    results = []
    for i in range(0, len(laps), chunk_size):
        chunk = laps.iloc[i:i+chunk_size]
        result = chunk.groupby("Driver")["LapTime"].mean()
        results.append(result)
    return pd.concat(results)

# Before (pandas, slow)
stats = laps.groupby("Driver").agg({
    "LapTime": ["mean", "std", "min", "max", "count"]
})
# Time: ~280ms

# After (polars, fast)
import polars as pl
stats = laps.group_by("Driver").agg([
    pl.col("LapTime").mean().alias("mean"),
    pl.col("LapTime").std().alias("std"),
    pl.col("LapTime").min().alias("min"),
    pl.col("LapTime").max().alias("max"),
    pl.col("LapTime").count().alias("count")
])
# Time: ~65ms

# ❌ Bad: Convert back and forth
session = tif1.get_session(2024, "Monaco", "Race", backend="polars")
laps_polars = session.laps
laps_pandas = laps_polars.to_pandas()  # Conversion 1
result_pandas = laps_pandas.groupby("Driver")["LapTime"].mean()
result_polars = pl.from_pandas(result_pandas)  # Conversion 2

# ✅ Good: Stay in one backend
session = tif1.get_session(2024, "Monaco", "Race", backend="polars")
laps = session.laps
result = laps.group_by("Driver").agg(pl.col("LapTime").mean())
# Convert once at the end if needed
result_pandas = result.to_pandas()

# ❌ Forgot to collect
result = (
    pl.scan_parquet("race.parquet")
    .filter(pl.col("Driver") == "VER")
)
print(result)  # Prints query plan, not data

# ✅ Collect to execute
result = (
    pl.scan_parquet("race.parquet")
    .filter(pl.col("Driver") == "VER")
    .collect()  # Execute and return DataFrame
)
print(result)  # Prints actual data

import seaborn as sns
import polars as pl

# Get data with polars
session = tif1.get_session(2024, "Monaco", "Race", backend="polars")
laps = session.laps

# Convert for seaborn (expects pandas)
laps_pd = laps.to_pandas()
sns.boxplot(data=laps_pd, x="Driver", y="LapTime")

# ❌ Problematic column name
laps["Lap Time"]  # Works in pandas, may fail in polars

# ✅ Better: Use underscores
laps["Lap_Time"]

# ✅ Or use proper selection
laps.select(pl.col("Lap Time"))  # Polars
laps[["Lap Time"]]  # Pandas

import time

# Profile pandas
start = time.time()
session_pd = tif1.get_session(2024, "Monaco", "Race", backend="pandas")
result_pd = session_pd.laps.groupby("Driver")["LapTime"].mean()
pandas_time = time.time() - start

# Profile polars
start = time.time()
session_pl = tif1.get_session(2024, "Monaco", "Race", backend="polars")
result_pl = session_pl.laps.group_by("Driver").agg(pl.col("LapTime").mean())
polars_time = time.time() - start

print(f"Pandas: {pandas_time:.3f}s")
print(f"Polars: {polars_time:.3f}s")
print(f"Speedup: {pandas_time/polars_time:.2f}x")