main.py

# 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)

        track = {
            "x": row["X"],
            "y": row["Y"],
        }
        track_map.append(track)

    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,
        }
    }

    return telemetry_data