Update main.py

main.py

@@ -1,10 +1,769 @@
-from git import Repo
+# from git import Repo
+# import os
+
+# GITHUB_PAT = os.environ['GITHUB']
+
+# if not os.path.exists('repo_directory'):  
+#     # os.mkdir('repo_directory')
+#     Repo.clone_from(f'https://tracinginsights:{GITHUB_PAT}@github.com/TracingInsights/fastf1api.git', 'repo_directory'  )
+
+# from repo_directory.main import *
+
+
+import concurrent.futures
+import datetime
+import functools
+import math
 import os
+from io import BytesIO
+
+import fastf1
+import numpy as np
+import pandas as pd
+import requests
+import streamlit as st
+from fastapi import Depends, FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, HTMLResponse
+from fastf1.ergast import Ergast
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
+
+# from . import accelerations, database, models, utils
+
+import accelerations
+import database
+import models
+import utils
+FASTF1_CACHE_DIR = os.environ["FASTF1_CACHE_DIR"]
+
+fastf1.Cache.enable_cache(FASTF1_CACHE_DIR)
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+database.Base.metadata.create_all(bind=database.engine)
+
+
+def get_db():
+    try:
+        db = database.SessionLocal()
+        yield db
+    finally:
+        db.close()
+
+
+class RacePace(BaseModel):
+    year: int
+    event: str
+    session: str
+    Driver: str
+    LapTime: float
+    Diff: float
+    Team: str
+    fill: str
+
+
+# @functools.cache
+@app.get("/racepace/{year}/{event}/{session}", response_model=None)
+async def average_race_pace(
+    year: int, event: str | int, session: str, db: Session = Depends(get_db)
+) -> any:
+    race_pace_data = (
+        db.query(models.RacePace)
+        .filter_by(year=year, event=event, session=session)
+        .all()
+    )
+
+    if race_pace_data:
+        print("Fetching from Database")
+
+    if not race_pace_data:
+        print("Writing to Database")
+        f1session = fastf1.get_session(
+            year,
+            event,
+            session,
+            # backend="fastf1",
+            # force_ergast=False,
+        )
+        f1session.load(telemetry=False, weather=False, messages=False)
+        laps = f1session.laps
+
+        laps = laps.loc[laps.LapNumber > 1]
+        laps = laps.pick_track_status(
+            "1",
+        )
+        laps["LapTime"] = laps.Sector1Time + laps.Sector2Time + laps.Sector3Time
+
+        # convert LapTime to seconds
+        laps["LapTime"] = laps["LapTime"].apply(lambda x: x.total_seconds())
+
+        laps = laps.loc[laps.LapTime < laps.LapTime.min() * 1.07]
+
+        df = (
+            laps[["LapTime", "Driver"]].groupby("Driver").mean().reset_index(drop=False)
+        )
+        df = df.sort_values(by="LapTime").reset_index(drop=True)
+        df["LapTime"] = df["LapTime"].round(3)
+        df["Diff"] = (df["LapTime"] - df["LapTime"].min()).round(3)
+        teams = laps[["Driver", "Team"]].drop_duplicates().reset_index(drop=True)
+        # join teams and df
+        df = df.merge(teams, on="Driver", how="left")
+
+        car_colors = utils.team_colors(year)
+
+        df["fill"] = df["Team"].map(car_colors)
+
+        df_json = df.to_dict("records")
+
+        # save the data to the database
+        for record in df.to_dict("records"):
+            race_pace = models.RacePace(**record)
+            db.add(race_pace)
+
+        db.commit()
+
+        return {"racePace": df_json}
+
+    return {"racePace": [dict(race_pace) for race_pace in race_pace_data]}
+
+
+@functools.cache
+@app.get("/topspeed/{year}/{event}/{session}", response_model=None)
+async def top_speed(year: int, event: str | int, session: str) -> any:
+    f1session = fastf1.get_session(year, event, session)
+    f1session.load(telemetry=False, weather=False, messages=False)
+    laps = f1session.laps
+    team_colors = utils.team_colors(year)
+
+    fastest_speedtrap = (
+        laps[["SpeedI1", "SpeedI2", "SpeedST", "SpeedFL"]]
+        .idxmax(axis=1)
+        .value_counts()
+        .index[0]
+    )
+
+    speed_df = (
+        laps[[fastest_speedtrap, "Driver", "Compound", "Team"]]
+        .groupby("Driver")
+        .max()
+        .sort_values(fastest_speedtrap, ascending=False)
+        .reset_index()
+    )
+    # add team colors to dataframe
+    speed_df["fill"] = speed_df["Team"].apply(lambda x: team_colors[x])
+
+    # rename fastest speedtrap column to TopSpeed
+    speed_df.rename(columns={fastest_speedtrap: "TopSpeed"}, inplace=True)
+
+    # remove nan values in any column
+    speed_df = speed_df.dropna()
+
+    # Convert to int
+    speed_df["TopSpeed"] = speed_df["TopSpeed"].astype(int)
+
+    speed_dict = speed_df.to_dict(orient="records")
+
+    return {"topSpeed": speed_dict}
+
+
+@functools.cache
+@app.get("/overtakes/{year}/{event}", response_model=None)
+def get_overtakes(year: int, event: str) -> any:
+    def get_overtakes_df(year, event):
+        if year == 2023:
+            url = "https://docs.google.com/spreadsheets/d/1M4aepPJaIfdqE9oU3L-2CQqKIyubLXG4Q4cqWnyqxp4/export?format=csv"
+        if year == 2022:
+            url = "https://docs.google.com/spreadsheets/d/1cuS3B6hk4iQmMaRQoMTcogIInJpavnV7rKuEsiJnEbU/export?format=csv"
+        if year == 2021:
+            url = "https://docs.google.com/spreadsheets/d/1ANQnPVkefRmvzrmGvEqXoqQ4dBfgcI_R9FPg-0BcM34/export?format=csv"
+        if year == 2020:
+            url = "https://docs.google.com/spreadsheets/d/1eG9WTkXKzFT4NMh-WqHOMs5G0UuPGnb6wP4CnFD8uzY/export?format=csv"
+        if year == 2019:
+            url = "https://docs.google.com/spreadsheets/d/10nHg7BIs5ySh_dE9uuIz2lq-gRWcg02tIMr0EPgPvJs/export?format=csv"
+        if year == 2018:
+            url = "https://docs.google.com/spreadsheets/d/1MyAwQdczccdca_FAIiZKkqZNauNh3ts99JZ278S2OKc/export?format=csv"
+
+        response = requests.get(url, timeout=10)
+        df = pd.read_csv(BytesIO(response.content))
+        df = df[["Driver", event]]
+        # replace NaNs with 0s
+        df = df.fillna(0)
+        # convert numbers to ints
+        df[event] = df[event].astype(int)
+        # replace event with "overtakes"
+        df = df.rename(columns={event: "overtakes"})
+        return df
+
+    def get_overtaken_df(year, event):
+        if year == 2023:
+            url = "https://docs.google.com/spreadsheets/d/1wszzx694Ot-mvA5YrFCpy3or37xMgnC0XpE8uNnJLWk/export?format=csv"
+        if year == 2022:
+            url = "https://docs.google.com/spreadsheets/d/19_XFDD3BZDIQVkNE4bG6dwuKvMaO4g5HNaUARGaJwhE/export?format=csv"
+        if year == 2021:
+            url = "https://docs.google.com/spreadsheets/d/1dQBHnd3AXEPNH5I75cjbzAAzi9ipqGk3v9eZT9eYKS4/export?format=csv"
+        if year == 2020:
+            url = "https://docs.google.com/spreadsheets/d/1snyntPMxYH4_KHSRI96AwBoJQrPbX6OanJAcqbYyW-Y/export?format=csv"
+        if year == 2019:
+            url = "https://docs.google.com/spreadsheets/d/11FfFkXErJg7F22iVwJo9XfLFAWucMBVlzL1qUGWxM3s/export?format=csv"
+        if year == 2018:
+            url = "https://docs.google.com/spreadsheets/d/1XJXAEyRpRS_UwLHzEtN2PdIaFJYGWSN6ypYN8Ecwp9A/export?format=csv"
+
+        response = requests.get(url, timeout=10)
+        df = pd.read_csv(BytesIO(response.content))
+        df = df[["Driver", event]]
+        # replace NaNs with 0s
+        df = df.fillna(0)
+        # convert numbers to ints
+        df[event] = df[event].astype(int)
+        df = df.rename(columns={event: "overtaken"})
+        return df
+
+    overtakes = get_overtakes_df(year, event)
+    overtaken = get_overtaken_df(year, event)
+    df = overtakes.merge(overtaken, on="Driver")
+
+    # remove drivers with 0 overtakes and 0 overtaken
+    df = df[(df["overtakes"] != 0) | (df["overtaken"] != 0)]
+
+    # sort in the decreasing order of overtakes
+    df = df.sort_values(
+        by=["overtakes", "overtaken"], ascending=[False, True]
+    ).reset_index(drop=True)
+    # convert to dictionary
+    df_dict = df.to_dict(orient="records")
+
+    return {"overtakes": df_dict}
+
+
+@functools.cache
+@app.get("/fastest/{year}/{event}/{session}", response_model=None)
+async def fastest_lap(year: int, event: str | int, session: str) -> any:
+    f1session = fastf1.get_session(year, event, session)
+    f1session.load(telemetry=False, weather=False, messages=False)
+    laps = f1session.laps
+
+    drivers = pd.unique(laps["Driver"])
+
+    list_fastest_laps = list()
+
+    for drv in drivers:
+        drvs_fastest_lap = laps.pick_driver(drv).pick_fastest()
+        list_fastest_laps.append(drvs_fastest_lap)
+
+    df = (
+        fastf1.core.Laps(list_fastest_laps)
+        .sort_values(by="LapTime")
+        .reset_index(drop=True)
+    )
+
+    pole_lap = df.pick_fastest()
+    df["Diff"] = df["LapTime"] - pole_lap["LapTime"]
+
+    car_colors = utils.team_colors(year)
+
+    df["fill"] = df["Team"].map(car_colors)
+
+    # convert timedelta to float and round to 3 decimal places
+    df["Diff"] = df["Diff"].dt.total_seconds().round(3)
+    df = df[["Driver", "LapTime", "Diff", "Team", "fill"]]
+
+    # remove nan values in any column
+    df = df.dropna()
+
+    df_json = df.to_dict("records")
+
+    return {"fastest": df_json}
+
+
+# @st.cache_data
+
+
+@app.get("/wdc", response_model=None)
+async def driver_standings() -> any:
+    YEAR = 2023  # datetime.datetime.now().year
+    df = pd.DataFrame(
+        pd.read_html(f"https://www.formula1.com/en/results.html/{YEAR}/drivers.html")[0]
+    )
+    df = df[["Driver", "PTS", "Car"]]
+    # reverse the order
+    df = df.sort_values(by="PTS", ascending=True)
+
+    # in Driver column only keep the last 3 characters
+    df["Driver"] = df["Driver"].str[:-5]
+
+    # add colors to the dataframe
+    car_colors = utils.team_colors(YEAR)
+    df["fill"] = df["Car"].map(car_colors)
+
+    # remove rows where points is 0
+    df = df[df["PTS"] != 0]
+    df.reset_index(inplace=True, drop=True)
+    df.rename(columns={"PTS": "Points"}, inplace=True)
+
+    return {"WDC": df.to_dict("records")}
+
+
+# @st.cache_data
+
+
+@app.get("/", response_model=None)
+async def root():
+    return HTMLResponse(
+        content="""<iframe src="https://tracinginsights-f1-analysis.hf.space" frameborder="0" style="width:100%; height:100%;" scrolling="yes" allowfullscreen:"yes"></iframe>""",
+        status_code=200,
+    )
+
+
+# @st.cache_data
+
+
+@app.get("/years", response_model=None)
+async def years_available() -> any:
+    # make a list from 2018 to current year
+    current_year = datetime.datetime.now().year
+    years = list(range(2018, current_year + 1))
+    # reverse the list to get the latest year first
+    years.reverse()
+    years = [{"label": str(year), "value": year} for year in years]
+    return {"years": years}
+
+
+# format for events {"events":[{"label":"Saudi Arabian Grand Prix","value":2},{"label":"Bahrain Grand Prix","value":1},{"label":"Pre-Season Testing","value":"t1"}]}
+
+# @st.cache_data
+
+
+@app.get("/{year}", response_model=None)
+async def events_available(year: int) -> any:
+    # get events available for a given year
+    data = utils.LatestData(year)
+    events = data.get_events()
+    events = [{"label": event, "value": event} for i, event in enumerate(events)]
+    events.reverse()
+
+    return {"events": events}
+
+
+# format for sessions {"sessions":[{"label":"FP1","value":"FP1"},{"label":"FP2","value":"FP2"},{"label":"FP3","value":"FP3"},{"label":"Qualifying","value":"Q"},{"label":"Race","value":"R"}]}
+
+
+# @st.cache_data
+@functools.cache
+@app.get("/{year}/{event}", response_model=None)
+async def sessions_available(year: int, event: str | int) -> any:
+    # get sessions available for a given year and event
+    data = utils.LatestData(year)
+    sessions = data.get_sessions(event)
+    sessions = [{"label": session, "value": session} for session in sessions]
+
+    return {"sessions": sessions}
+
+
+# format for drivers {"drivers":[{"color":"#fff500","label":"RIC","value":"RIC"},{"color":"#ff8700","label":"NOR","value":"NOR"},{"color":"#c00000","label":"VET","value":"VET"},{"color":"#0082fa","label":"LAT","value":"LAT"},{"color":"#787878","label":"GRO","value":"GRO"},{"color":"#ffffff","label":"GAS","value":"GAS"},{"color":"#f596c8","label":"STR","value":"STR"},{"color":"#787878","label":"MAG","value":"MAG"},{"color":"#0600ef","label":"ALB","value":"ALB"},{"color":"#ffffff","label":"KVY","value":"KVY"},{"color":"#fff500","label":"OCO","value":"OCO"},{"color":"#0600ef","label":"VER","value":"VER"},{"color":"#00d2be","label":"HAM","value":"HAM"},{"color":"#ff8700","label":"SAI","value":"SAI"},{"color":"#00d2be","label":"BOT","value":"BOT"},{"color":"#960000","label":"GIO","value":"GIO"}]}
+
+# @st.cache_data
+
+
+@functools.cache
+@app.get("/strategy/{year}/{event}", response_model=None)
+async def get_strategy(year: int, event: str | int) -> any:
+    f1session = fastf1.get_session(year, event, "R")
+    f1session.load(telemetry=False, weather=False, messages=False)
+    laps = f1session.laps
+
+    drivers_list = pd.unique(laps["Driver"])
+
+    drivers = pd.DataFrame(drivers_list, columns=["Driver"])
+    drivers["FinishOrder"] = drivers.index + 1
+
+    # Get the LapNumber of the first lap of each stint
+    first_lap = (
+        laps[["Driver", "Stint", "Compound", "LapNumber"]]
+        .groupby(["Driver", "Stint", "Compound"])
+        .first()
+        .reset_index()
+    )
+    #  Add FinishOrder to first_lap
+    first_lap = pd.merge(first_lap, drivers, on="Driver")
+    # change LapNumber to LapStart
+    first_lap = first_lap.rename(columns={"LapNumber": "LapStart"})
+    # reduce the lapstart by 1
+    first_lap["LapStart"] = first_lap["LapStart"] - 1
+
+    # find the last lap of each stint
+    last_lap = (
+        laps[["Driver", "Stint", "Compound", "LapNumber"]]
+        .groupby(["Driver", "Stint", "Compound"])
+        .last()
+        .reset_index()
+    )
+    #  change LapNumber to LapEnd
+    last_lap = last_lap.rename(columns={"LapNumber": "LapEnd"})
+
+    # combine first_lap and last_lap
+    stint_laps = pd.merge(first_lap, last_lap, on=["Driver", "Stint", "Compound"])
+    #  to cover for outliers
+    stint_laps["fill"] = "white"
+
+    stint_laps["fill"] = stint_laps["Compound"].map(
+        {
+            "SOFT": "red",
+            "MEDIUM": "yellow",
+            "HARD": "white",
+            "INTERMEDIATE": "blue",
+            "WET": "green",
+        }
+    )
+
+    # sort by FinishOrder
+    stint_laps = stint_laps.sort_values(by=["FinishOrder"], ascending=[True])
+
+    stint_laps_dict = stint_laps.to_dict("records")
+
+    return {"strategy": stint_laps_dict}
+
+
+@functools.cache
+@app.get("/lapchart/{year}/{event}/{session}", response_model=None)
+async def lap_chart(
+    year: int,
+    event: str | int,
+    session: str,
+) -> any:
+    ergast = Ergast()
+
+    race_names_df = ergast.get_race_schedule(season=year, result_type="pandas")
+    event_number = race_names_df[race_names_df["raceName"] == event]["round"].values[0]
+    drivers_df = ergast.get_driver_info(
+        season=year, round=event_number, result_type="pandas"
+    )
+    laptimes_df = ergast.get_lap_times(
+        season=year, round=event_number, result_type="pandas", limit=2000
+    ).content[0]
+    laptimes_df = pd.merge(laptimes_df, drivers_df, how="left", on="driverId")
+
+    results_df = ergast.get_race_results(
+        season=year, round=event_number, result_type="pandas"
+    ).content[0]
+    results_df = results_df[["driverCode", "constructorName"]]
+
+    # merge results_df on laptime_df
+    laptimes_df = pd.merge(laptimes_df, results_df, how="left", on="driverCode")
+
+    team_colors = utils.team_colors(year)
+    # add team_colors to laptimes_df
+    laptimes_df["fill"] = laptimes_df["constructorName"].map(team_colors)
+
+    #  rename number as x and position as y
+    laptimes_df.rename(
+        columns={"number": "x", "position": "y", "driverCode": "id"}, inplace=True
+    )
+
+    lap_chart_data = []
+
+    for driver in laptimes_df["id"].unique():
+        data = laptimes_df[laptimes_df["id"] == driver]
+        fill = data["fill"].values[0]
+        data = data[["x", "y"]]
+        data_dict = data.to_dict(orient="records")
+        driver_dict = {"id": driver, "fill": fill, "data": data_dict}
+        # add this to all_data
+        lap_chart_data.append(driver_dict)
+
+    lap_chart_dict = {"lapChartData": lap_chart_data}
+
+    return lap_chart_dict
+
+
+@functools.cache
+@app.get("/{year}/{event}/{session}", response_model=None)
+async def session_drivers(year: int, event: str | int, session: str) -> any:
+    # get drivers available for a given year, event and session
+    f1session = fastf1.get_session(year, event, session)
+    f1session.load(telemetry=False, weather=False, messages=False)
+
+    laps = f1session.laps
+    team_colors = utils.team_colors(year)
+    # add team_colors dict to laps on Team column
+    laps["color"] = laps["Team"].map(team_colors)
+
+    unique_drivers = laps["Driver"].unique()
+
+    drivers = [
+        {
+            "color": laps[laps.Driver == driver].color.iloc[0],
+            "label": driver,
+            "value": driver,
+        }
+        for driver in unique_drivers
+    ]
+
+    return {"drivers": drivers}
+
+
+@functools.cache
+@app.get("/laps/{year}/{event}/{session}", response_model=None)
+async def get_driver_laps_data(year: int, event: str | int, session: str) -> any:
+    # get drivers available for a given year, event and session
+    f1session = fastf1.get_session(year, event, session)
+    f1session.load(telemetry=False, weather=False, messages=False)
+    laps = f1session.laps
+    team_colors = utils.team_colors(year)
+    # add team_colors dict to laps on Team column
+    laps["color"] = laps["Team"].map(team_colors)
+
+    # combine Driver and LapNumber as a new column
+    laps["label"] = (
+        laps["Driver"]
+        + "-"
+        + laps["LapNumber"].astype(int).astype(str)
+        + "-"
+        + str(year)
+        + "-"
+        + event
+        + "-"
+        + session
+    )
+    laps["value"] = (
+        laps["Driver"]
+        + "-"
+        + laps["LapNumber"].astype(int).astype(str)
+        + "-"
+        + str(year)
+        + "-"
+        + event
+        + "-"
+        + session
+    )
+
+    laps = laps[["value", "label", "color"]]
+
+    driver_laps_dict = laps.to_dict("records")
+
+    return {"laps": driver_laps_dict}
+
+
+# format for chartData {"chartData":[{"lapnumber":1},{
+# "VER":91.564,
+# "VER_compound":"SOFT",
+# "VER_compound_color":"#FF5733",
+# "lapnumber":2
+# },{"lapnumber":3},{"VER":90.494,"VER_compound":"SOFT","VER_compound_color":"#FF5733","lapnumber":4},{"lapnumber":5},{"VER":90.062,"VER_compound":"SOFT","VER_compound_color":"#FF5733","lapnumber":6},{"lapnumber":7},{"VER":89.815,"VER_compound":"SOFT","VER_compound_color":"#FF5733","lapnumber":8},{"VER":105.248,"VER_compound":"SOFT","VER_compound_color":"#FF5733","lapnumber":9},{"lapnumber":10},{"VER":89.79,"VER_compound":"SOFT","VER_compound_color":"#FF5733","lapnumber":11},{"VER":145.101,"VER_compound":"SOFT","VER_compound_color":"#FF5733","lapnumber":12},{"lapnumber":13},{"VER":89.662,"VER_compound":"SOFT","VER_compound_color":"#FF5733","lapnumber":14},{"lapnumber":15},{"VER":89.617,"VER_compound":"SOFT","VER_compound_color":"#FF5733","lapnumber":16},{"lapnumber":17},{"VER":140.717,"VER_compound":"SOFT","VER_compound_color":"#FF5733","lapnumber":18}]}
+
+# @st.cache_data
+
+
+@functools.cache
+@app.get("/{year}/{event}/{session}/{driver}", response_model=None)
+async def laps_data(year: int, event: str | int, session: str, driver: str) -> any:
+    # get drivers available for a given year, event and session
+    f1session = fastf1.get_session(year, event, session)
+    f1session.load(telemetry=False, weather=False, messages=False)
+    laps = f1session.laps
+    team_colors = utils.team_colors(year)
+    # add team_colors dict to laps on Team column
+
+    drivers = laps.Driver.unique()
+    # for each driver in drivers, get the Team column from laps and get the color from team_colors dict
+    drivers = [
+        {
+            "color": team_colors[laps[laps.Driver == driver].Team.iloc[0]],
+            "label": driver,
+            "value": driver,
+        }
+        for driver in drivers
+    ]
+
+    driver_laps = laps.pick_driver(driver)
+    driver_laps["LapTime"] = driver_laps["LapTime"].dt.total_seconds()
+    # remove rows where LapTime is null
+    driver_laps = driver_laps[driver_laps.LapTime.notnull()]
+    compound_colors = {
+        "SOFT": "#FF0000",
+        "MEDIUM": "#FFFF00",
+        "HARD": "#FFFFFF",
+        "INTERMEDIATE": "#00FF00",
+        "WET": "#088cd0",
+    }
+
+    driver_laps_data = []
+
+    for _, row in driver_laps.iterrows():
+        if row["LapTime"] > 0:
+            lap = {
+                f"{driver}": row["LapTime"],
+                f"{driver}_compound": row["Compound"],
+                f"{driver}_compound_color": compound_colors[row["Compound"]],
+                "lapnumber": row["LapNumber"],
+            }
+        else:
+            lap = {"lapnumber": row["LapNumber"]}
+
+        driver_laps_data.append(lap)
+
+    return {"chartData": driver_laps_data}
+
+
+@functools.cache
+@app.get("/laptimes/{year}/{event}/{session}/{driver}", response_model=None)
+async def get_laps_data(year: int, event: str | int, session: str, driver: str) -> any:
+    # get drivers available for a given year, event and session
+    f1session = fastf1.get_session(year, event, session)
+    f1session.load(telemetry=False, weather=False, messages=False)
+    laps = f1session.laps
+    team_colors = utils.team_colors(year)
+    # add team_colors dict to laps on Team column
+
+    drivers = laps.Driver.unique()
+    # for each driver in drivers, get the Team column from laps and get the color from team_colors dict
+    drivers = [
+        {
+            "color": team_colors[laps[laps.Driver == driver].Team.iloc[0]],
+            "label": driver,
+            "value": driver,
+        }
+        for driver in drivers
+    ]
+
+    driver_laps = laps.pick_driver(driver)
+    driver_laps["LapTime"] = driver_laps["LapTime"].dt.total_seconds()
+    driver_laps = driver_laps[["Driver", "LapTime", "LapNumber", "Compound"]]
+
+    # remove rows where LapTime is null
+    driver_laps = driver_laps[driver_laps.LapTime.notnull()]
+
+    driver_laps_dict = driver_laps.to_dict("records")
+
+    return {"chartData": driver_laps_dict}
+
+
+# @st.cache_data
+
+
+@functools.cache
+@app.get("/{year}/{event}/{session}/{driver}/{lap_number}", response_model=None)
+async def telemetry_data(
+    year: int, event: str | int, session: str, driver: str, lap_number: int
+) -> any:
+    f1session = fastf1.get_session(year, event, session)
+    f1session.load(telemetry=True, weather=False, messages=False)
+    laps = f1session.laps
+
+    driver_laps = laps.pick_driver(driver)
+    driver_laps["LapTime"] = driver_laps["LapTime"].dt.total_seconds()
+
+    # get the telemetry for lap_number
+    selected_lap = driver_laps[driver_laps.LapNumber == lap_number]
+
+    telemetry = selected_lap.get_telemetry()
+
+    lon_acc, lat_acc = accelerations.compute_accelerations(telemetry)
+    telemetry["lon_acc"] = lon_acc
+    telemetry["lat_acc"] = lat_acc
+
+    telemetry["Time"] = telemetry["Time"].dt.total_seconds()
+
+    laptime = selected_lap.LapTime.values[0]
+    data_key = f"{driver} - Lap {int(lap_number)} - {year} {session} [laptime]"
+
+    telemetry["DRS"] = telemetry["DRS"].apply(lambda x: 1 if x in [10, 12, 14] else 0)
+
+    brake_tel = []
+    drs_tel = []
+    gear_tel = []
+    rpm_tel = []
+    speed_tel = []
+    throttle_tel = []
+    time_tel = []
+    track_map = []
+    lon_acc_tel = []
+    lat_acc_tel = []
+
+    for _, row in telemetry.iterrows():
+        brake = {
+            "x": row["Distance"],
+            "y": row["Brake"],
+        }
+        brake_tel.append(brake)
+
+        drs = {
+            "x": row["Distance"],
+            "y": row["DRS"],
+        }
+        drs_tel.append(drs)
+
+        gear = {
+            "x": row["Distance"],
+            "y": row["nGear"],
+        }
+        gear_tel.append(gear)
+
+        rpm = {
+            "x": row["Distance"],
+            "y": row["RPM"],
+        }
+        rpm_tel.append(rpm)
+
+        speed = {
+            "x": row["Distance"],
+            "y": row["Speed"],
+        }
+        speed_tel.append(speed)
+
+        throttle = {
+            "x": row["Distance"],
+            "y": row["Throttle"],
+        }
+        throttle_tel.append(throttle)
+
+        time = {
+            "x": row["Distance"],
+            "y": row["Time"],
+        }
+        time_tel.append(time)
+
+        lon_acc = {
+            "x": row["Distance"],
+            "y": row["lon_acc"],
+        }
+        lon_acc_tel.append(lon_acc)
+
+        lat_acc = {
+            "x": row["Distance"],
+            "y": row["lat_acc"],
+        }
+        lat_acc_tel.append(lat_acc)
 
-GITHUB_PAT = os.environ['GITHUB']
+        track = {
+            "x": row["X"],
+            "y": row["Y"],
+        }
+        track_map.append(track)
 
-if not os.path.exists('repo_directory'):  
-    # os.mkdir('repo_directory')
-    Repo.clone_from(f'https://tracinginsights:{GITHUB_PAT}@github.com/TracingInsights/fastf1api.git', 'repo_directory'  )
+    telemetry_data = {
+        "telemetryData": {
+            "brake": brake_tel,
+            "dataKey": data_key,
+            "drs": drs_tel,
+            "gear": gear_tel,
+            "rpm": rpm_tel,
+            "speed": speed_tel,
+            "throttle": throttle_tel,
+            "time": time_tel,
+            "lon_acc": lon_acc_tel,
+            "lat_acc": lat_acc_tel,
+            "trackMap": track_map,
+        }
+    }
 
-from repo_directory.main import *
+    return telemetry_data