experiments/prof_lap.py

#!/usr/bin/env python3
"""Profile the per-lap telemetry pipeline used by Rp.py / R.py.

Times each sub-step of FastF1's Lap.get_telemetry() for a sample of laps:
  get_pos_data / get_car_data (slices)
  add_driver_ahead (incl. calculate_driver_ahead internals)
  add_distance + add_relative_distance
  merge_channels(car vs drv_ahead)
  merge_channels(pos vs car)
  slice_by_lap(interpolate_edges=True)
"""
import logging
import os
import sys
import time

import fastf1
import numpy as np
import pandas as pd

logging.basicConfig(level=logging.ERROR)
logging.getLogger("fastf1").setLevel(logging.ERROR)


def t_per_driver(fn):
    v = 0.0
    n = 0
    for _ in range(3):
        t0 = time.perf_counter()
        fn()
        v += time.perf_counter() - t0
        n += 1
    return v / n


def main():
    year = 2026
    os.makedirs("cache", exist_ok=True)
    fastf1.Cache.enable_cache("cache")
    sessions = fastf1.get_session(year, "Austrian Grand Prix", "Race")
    sessions.load(telemetry=True, weather=False, messages=False)
    laps = sessions.laps

    drivers = sorted(laps["Driver"].dropna().unique())
    tot = 0
    n_laps = 0
    for drv in drivers[:8]:
        drv_laps = laps.pick_drivers(drv)
        for lap_no in drv_laps["LapNumber"].tolist()[:8]:
            sel = drv_laps[drv_laps["LapNumber"] == lap_no]
            if sel.empty:
                continue
            t0 = time.perf_counter()
            n_laps += 1

            t_slice = t_per_driver(lambda: None)
            t0 = time.perf_counter()
            pos = sel.get_pos_data(pad=1, pad_side="both")
            t_pos = time.perf_counter() - t0
            t0 = time.perf_counter()
            car = sel.get_car_data(pad=1, pad_side="both")
            t_car = time.perf_counter() - t0

            # driver ahead
            t0 = time.perf_counter()
            t_inner = 0.0
            drv_ahead = car.iloc[1:-1].add_driver_ahead().loc[:, ("DriverAhead", "DistanceToDriverAhead", "Date", "Time", "SessionTime")]
            t_da = time.perf_counter() - t0

            t0 = time.perf_counter()
            car2 = car.add_distance().add_relative_distance()
            t_dist = time.perf_counter() - t0

            t0 = time.perf_counter()
            car3 = car2.merge_channels(drv_ahead, frequency=None)
            t_m1 = time.perf_counter() - t0

            t0 = time.perf_counter()
            merged = pos.merge_channels(car3, frequency=None)
            t_m2 = time.perf_counter() - t0

            t0 = time.perf_counter()
            merged2 = merged.slice_by_lap(sel, interpolate_edges=True)
            t_slc = time.perf_counter() - t0

            lap_t = t_pos + t_car + t_da + t_dist + t_m1 + t_m2 + t_slc
            tot += lap_t
            print(f"{drv} lap {lap_no}: pos={t_pos*1e3:.1f}ms car={t_car*1e3:.1f}ms "
                  f"driver_ahead={t_da*1e3:.1f}ms dist={t_dist*1e3:.1f}ms "
                  f"merge1={t_m1*1e3:.1f}ms merge2={t_m2*1e3:.1f}ms slice={t_slc*1e3:.1f}ms "
                  f"TOTAL={lap_t*1e3:.1f}ms")
    print(f"\n{n_laps} sampled; avg per lap = {tot/n_laps*1e3:.1f}ms")


if __name__ == "__main__":
    main()