FastF1

https://docs.fastf1.dev/
Admin
FastF1 provides access to Formula 1 lap timing, car telemetry, position data, tyre information,...
Tokens:171,960
Snippets:1,271
Trust Score:5.5
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install FastF1 via pip

Source: https://docs.fastf1.dev/getting_started/installation.html

Standard installation method for Python environments.

```bash
pip install fastf1
```

--------------------------------

### Install development and documentation dependencies

Source: https://docs.fastf1.dev/contributing/devenv_setup.html

Install required packages for development, testing, and documentation building.

```bash
python -m pip install -r requirements/dev.txt
```

```bash
python -m pip install -r requirements/doc-build.txt
```

--------------------------------

### Client Start and Async Deprecation

Source: https://docs.fastf1.dev/_modules/fastf1/livetiming/client.html

Public methods to initiate the client and the deprecated async start method.

```python
[docs]
    def start(self):
        """Connect to the data stream and start writing the data to a file."""
        self.logger.info(f"Starting FastF1 live timing client "
                         f"[v{fastf1.__version__}]")
        self._run()
        try:
            self._supervise()
        except KeyboardInterrupt:
            self.logger.info("Exiting...")
            self._exit()

    async def async_start(self):
        """
        :meta private:
        """
        raise NotImplementedError(
            "This method is no longer provided because the SignalR client no "
            "longer uses asyncio! Please use `.start` instead."
        )
```

--------------------------------

### Install pre-commit hooks

Source: https://docs.fastf1.dev/contributing/devenv_setup.html

Install and configure pre-commit hooks to automate code style checks.

```bash
pip install pre-commit
pre-commit install
```

--------------------------------

### Install FastF1 in editable mode

Source: https://docs.fastf1.dev/contributing/devenv_setup.html

Install the package such that changes to the source code are immediately reflected in the environment.

```bash
python -m pip install -e .
```

--------------------------------

### Install FastF1 via conda

Source: https://docs.fastf1.dev/getting_started/installation.html

Installation method for users managing environments with conda.

```bash
conda install -c conda-forge fastf1
```

--------------------------------

### SignalRClient.start

Source: https://docs.fastf1.dev/api_reference/api_autogen/fastf1.livetiming.client.SignalRClient.html

Starts the connection to the data stream and begins writing to the file.

```APIDOC
## SignalRClient.start()

### Description
Connects to the live F1 data stream and begins writing the received data to the file specified during initialization.
```

--------------------------------

### Setup Matplotlib and Load Session

Source: https://docs.fastf1.dev/gen_modules/examples_gallery/general/plot_driver_styling.html

Initializes the FastF1 plotting environment and loads the race session data.

```python
from matplotlib import pyplot as plt

import fastf1
from fastf1 import plotting


# Enable Matplotlib patches for plotting timedelta values and load
# FastF1's dark color scheme
fastf1.plotting.setup_mpl(mpl_timedelta_support=True, color_scheme='fastf1')
```

```python
race = fastf1.get_session(2023, "Azerbaijan", 'R')
race.load()
```

--------------------------------

### FastF1 Core Module Imports and Setup

Source: https://docs.fastf1.dev/_modules/fastf1/core.html

Initial imports and deprecated attribute handling for the fastf1.core module.

```python
import collections
import re
import warnings
from collections.abc import (
    Callable,
    Iterable
)
from functools import cached_property
from typing import (
    Any,
    Literal,
    Optional,
    Union
)

import numpy as np
import pandas as pd

import fastf1
from fastf1 import _api as api
from fastf1 import (
    ergast,
    exceptions
)
from fastf1.internals.pandas_base import (
    BaseDataFrame,
    BaseSeries
)
from fastf1.livetiming.data import LiveTimingData
from fastf1.logger import (
    get_logger,
    soft_exceptions
)
from fastf1.utils import to_timedelta


# TODO: remove in v3.10
def __getattr__(name):
    if name in ("NoLapDataError",
                "DataNotLoadedError",
                "InvalidSessionError"):

        warnings.warn(f"Accessing `{name}` via `{__name__}` is deprecated. "
                      f"Use `fastf1.exceptions` instead.")

        return getattr(exceptions, name)

    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")


_logger = get_logger(__name__)
```

--------------------------------

### Initialize and start the SignalRClient

Source: https://docs.fastf1.dev/_downloads/1dfee3a290b9b94a083593b6e84f28ed/example_fastf1_signalrclient.ipynb

Configures logging to debug level and initializes the client to save data to a specified file.

```python
import logging

from fastf1.livetiming.client import SignalRClient


log = logging.getLogger()
log.setLevel(logging.DEBUG)

client = SignalRClient(filename="output.txt", debug=True)
client.start()
```

--------------------------------

### Search for events by name

Source: https://docs.fastf1.dev/_modules/fastf1/events.html

Examples of using get_event_by_name with fuzzy and exact matching.

```python
.get_event_by_name("british")
```

```python
.get_event_by_name("silverstone")
```

```python
.get_event_by_name("British Grand Prix",
                exact_match=True)
```

```python
.get_event_by_name("British", exact_match=True)
```

--------------------------------

### SignalRClient.async_start()

Source: https://docs.fastf1.dev/livetiming.html

Connects to the data stream and starts writing data when running inside an existing event loop.

```APIDOC
## SignalRClient.async_start()

### Description
Connect to the data stream and start writing the data to a file when running inside an existing event loop.
```

--------------------------------

### Load session and retrieve driver data

Source: https://docs.fastf1.dev/_sources/examples/index.rst.txt

Basic example demonstrating how to load a specific F1 session and access driver information.

```python
>>> import fastf1
>>> session = fastf1.get_session(2019, 'Monza', 'Q')
>>> session.load(telemetry=False, laps=False, weather=False)
>>> vettel = session.get_driver('VET')
>>> print(f"Pronto {vettel['FirstName']}?")
Pronto Sebastian?
```

--------------------------------

### Configure FastF1 Cache

Source: https://docs.fastf1.dev/_modules/fastf1/req.html

Initialize the cache directory at the start of the script before calling other FastF1 functions.

```python
import fastf1
fastf1.Cache.enable_cache('path/to/cache')  # doctest: +SKIP
# change cache directory to an existing empty directory on your machine
session = fastf1.get_session(2021, 5, 'Q')
# ...
```

--------------------------------

### Retrieve Lap Weather Data

Source: https://docs.fastf1.dev/api_reference/api_autogen/fastf1.core.Lap.html

Example demonstrating how to load a session, select the fastest lap, and retrieve its associated weather data.

```python
>>> session = fastf1.get_session(2019, 'Monza', 'Q')
>>> session.load(telemetry=False)
>>> lap = session.laps.pick_fastest()
>>> lap['LapStartTime']
Timedelta('0 days 01:09:55.561000')
>>> lap.get_weather_data()
Time             0 days 01:10:15.292000
AirTemp                            23.0
Humidity                           51.9
Pressure                          992.4
Rainfall                          False
TrackTemp                          37.8
WindDirection                       166
WindSpeed                           0.8
Name: 70, dtype: object
```

--------------------------------

### Retrieve weather data for laps

Source: https://docs.fastf1.dev/api_reference/api_autogen/fastf1.core.Laps.html

Example of fetching weather data associated with a set of laps from a session.

```python
>>> session = fastf1.get_session(2019, 'Monza', 'Q')
>>> session.load(telemetry=False)
>>> weather_data = session.laps.get_weather_data()
>>> print(weather_data)
                     Time AirTemp  ... WindDirection WindSpeed
20 0 days 00:20:14.613000    22.5  ...           212       2.0
21 0 days 00:21:15.001000    22.5  ...           207       2.7
23 0 days 00:23:14.854000    22.7  ...           210       2.3
24 0 days 00:24:14.430000    23.2  ...           207       3.2
26 0 days 00:26:14.315000    23.6  ...           238       1.8
..                    ...     ...  ...           ...       ...
36 0 days 00:36:14.426000    23.0  ...           192       0.9
37 0 days 00:37:14.391000    23.3  ...           213       0.9
28 0 days 00:28:14.324000    23.5  ...           183       1.3
34 0 days 00:34:14.385000    23.0  ...           272       0.8
35 0 days 00:35:14.460000    23.2  ...           339       1.1

[275 rows x 8 columns]
```

--------------------------------

### Retrieve Session Objects

Source: https://docs.fastf1.dev/_modules/fastf1/events.html

Examples of using get_session to retrieve session objects by abbreviation, name, or index.

```python
>>> get_session(2021, 1, 'FP2')
```

```python
>>> get_session(2020, 'Austria', 'Qualifying')
```

```python
>>> get_session(2021, 5, 3)
```

--------------------------------

### Setup Matplotlib for FastF1

Source: https://docs.fastf1.dev/_modules/fastf1/plotting/_plotting.html

Configures Matplotlib with timedelta support via Timple and applies the FastF1 color scheme.

```python
def setup_mpl(
        mpl_timedelta_support: bool = True,
        color_scheme: str | None = None,
        *args, **kwargs  # for backwards compatibility, do not use in new code
):
```

--------------------------------

### Load events by name, country, or location

Source: https://docs.fastf1.dev/_sources/examples/basics.rst.txt

Examples of fuzzy matching for event names and loading sessions by location or country. Note that fuzzy matching may return unexpected results if the input is not specific enough.

```python
>>> event = fastf1.get_event(2021, 'French Grand Prix')
>>> event['EventName']
'French Grand Prix'
```

```python
>>> event = fastf1.get_event(2021, 'Spain')
>>> event['EventName']
'Spanish Grand Prix'
```

```python
>>> event = fastf1.get_event(2021, 'Emilian')
>>> event['EventName']
'Belgian Grand Prix'
```

```python
>>> event = fastf1.get_event(2021, 'Emilia Romagna')
>>> event['EventName']
'Emilia Romagna Grand Prix'
```

```python
>>> session = fastf1.get_session(2021, 'Silverstone', 'Q')
>>> session.event['EventName']
'British Grand Prix'
```

--------------------------------

### Build documentation as HTML

Source: https://docs.fastf1.dev/contributing/documenting_fastf1.html

Execute this command from the docs/ directory to generate the documentation in HTML format.

```bash
make html
```

--------------------------------

### View documentation in browser

Source: https://docs.fastf1.dev/contributing/documenting_fastf1.html

Execute this command from the docs/ directory to open the generated documentation homepage in your default web browser.

```bash
make show
```

--------------------------------

### Create a virtual environment

Source: https://docs.fastf1.dev/contributing/devenv_setup.html

Initialize a new Python virtual environment in a specified folder.

```bash
python -m venv <file folder location>
```

--------------------------------

### Calculate Session Start Date

Source: https://docs.fastf1.dev/_modules/fastf1/core.html

Determines the session start timestamp (t0_date) based on telemetry data offsets.

```python
    def _calculate_t0_date(self, *tel_data_sets: dict):
        """
        Calculate the date timestamp at which data for this session is
        starting.

        This does not mark the start of a race (or other sessions). This marks
        the start of the data which is sometimes far before.

        This function sets :attr:`self.t0_date` which is an internally
        required offset for some calculations.

        The current assumption is that the latest date which can be calculated
        is correct. (Based on the timestamp with the least delay.)

        Args:
            tel_data_sets: Dictionaries containing car telemetry data or
                position data
        """
        date_offset = None

        data = list()
        for tds in tel_data_sets:
            data.extend(list(tds.values()))

        for d in data:
            new_offset = max(d['Date'] - d['Time'])
            if date_offset is None or new_offset > date_offset:
                date_offset = new_offset

        if date_offset is None:
            self._t0_date = None
            _logger.warning("Failed to determine `Session.t0_date`!")
        else:
            self._t0_date = date_offset.round('ms')
```

--------------------------------

### Access session start time offset

Source: https://docs.fastf1.dev/_sources/time_explanation.rst.txt

Retrieves the timedelta representing the official session start relative to the session zero point.

```python
>>> session.session_start_time
datetime.timedelta(seconds=2008, microseconds=79000)
>>> str(session.session_start_time)
'0:33:28.079000'
```

--------------------------------

### get(name)

Source: https://docs.fastf1.dev/livetiming.html

Retrieves the data associated with a specific category name.

```APIDOC
## Method: get(name)

### Description
Returns the data for the specified category name. Data is loaded automatically on the first call.

### Parameters
- **name** (str) - Required - The name of the data category to retrieve.
```

--------------------------------

### Instantiate LiveTimingData with multiple files

Source: https://docs.fastf1.dev/_modules/fastf1/livetiming/data.html

Initialize the data object by passing one or more filenames. Files should be provided in chronological order.

```python
livedata = LiveTimingData('file1.txt', 'file2.txt', 'file3.txt')
```

--------------------------------

### Record live timing data via CLI

Source: https://docs.fastf1.dev/livetiming.html

Use the command line to save live timing data to a specified file.

```bash
python -m fastf1.livetiming save saved_data.txt
```

--------------------------------

### Get Circuit Information

Source: https://docs.fastf1.dev/_modules/fastf1/ergast/interface.html

Retrieves a list of circuits from the Ergast API.

```python
    def get_circuits(
            self,
            season: Literal['current'] | int | None = None,
            round: Literal['last'] | int | None = None,
            constructor: str | None = None,
            driver: str | None = None,
            grid_position: int | None = None,
            results_position: int | None = None,
            fastest_rank: int | None = None,
            status: str | None = None,
            result_type: Literal['pandas', 'raw'] | None = None,
            auto_cast: bool | None = None,
            limit: int | None = None,
            offset: int | None = None
    ) -> ErgastSimpleResponse | ErgastRawResponse:
        """Get a list of circuits.

        See: https://ergast.com/mrd/methods/circuits/

        .. ergast-api-map:: Circuits
            :describe-dataframe:
```

--------------------------------

### List FastF1 Live Timing Commands

Source: https://docs.fastf1.dev/api_reference/livetiming.html

Displays the available commands for the live timing module.

```bash
{save,extract}
  save          Save live timing data
  extract       Extract messages from saved debug-mode data
```

--------------------------------

### Example output

Source: https://docs.fastf1.dev/gen_modules/examples_gallery/plot_who_can_still_win_wdc.html

The resulting output showing the championship status for each driver.

```text
1: Oscar Piastri, Current points: 234.0, Theoretical max points: 434, Can win: Yes
2: Lando Norris, Current points: 226.0, Theoretical max points: 426, Can win: Yes
3: Max Verstappen, Current points: 165.0, Theoretical max points: 365, Can win: Yes
4: George Russell, Current points: 147.0, Theoretical max points: 347, Can win: Yes
5: Charles Leclerc, Current points: 119.0, Theoretical max points: 319, Can win: Yes
6: Lewis Hamilton, Current points: 103.0, Theoretical max points: 303, Can win: Yes
7: Andrea Kimi Antonelli, Current points: 63.0, Theoretical max points: 263, Can win: Yes
8: Alexander Albon, Current points: 46.0, Theoretical max points: 246, Can win: Yes
9: Nico Hülkenberg, Current points: 37.0, Theoretical max points: 237, Can win: Yes
10: Esteban Ocon, Current points: 23.0, Theoretical max points: 223, Can win: No
11: Isack Hadjar, Current points: 21.0, Theoretical max points: 221, Can win: No
12: Lance Stroll, Current points: 20.0, Theoretical max points: 220, Can win: No
13: Pierre Gasly, Current points: 19.0, Theoretical max points: 219, Can win: No
14: Fernando Alonso, Current points: 16.0, Theoretical max points: 216, Can win: No
15: Carlos Sainz, Current points: 13.0, Theoretical max points: 213, Can win: No
16: Liam Lawson, Current points: 12.0, Theoretical max points: 212, Can win: No
17: Yuki Tsunoda, Current points: 10.0, Theoretical max points: 210, Can win: No
18: Oliver Bearman, Current points: 6.0, Theoretical max points: 206, Can win: No
19: Gabriel Bortoleto, Current points: 4.0, Theoretical max points: 204, Can win: No
20: Franco Colapinto, Current points: 0.0, Theoretical max points: 200, Can win: No
21: Jack Doohan, Current points: 0.0, Theoretical max points: 200, Can win: No
```

--------------------------------

### Get Driver Numbers

Source: https://docs.fastf1.dev/_sources/gen_modules/examples_gallery/plot_strategy.rst.txt

Retrieve the list of driver numbers participating in the session.

```Python
drivers = session.drivers
print(drivers)
```

--------------------------------

### Get Finishing Order

Source: https://docs.fastf1.dev/_downloads/5d66631092eaa2bacc03b4e024a19369/plot_laptimes_distribution.ipynb

Retrieve driver abbreviations in the order they finished the race.

```python
finishing_order = [race.get_driver(i)["Abbreviation"] for i in point_finishers]
print(finishing_order)
```

--------------------------------

### Initialize default cache

Source: https://docs.fastf1.dev/_modules/fastf1/req.html

Internal method to set up the default cache directory and enable caching if not already configured.

```python
@classmethod
def _enable_default_cache(cls):
    if not cls._CACHE_DIR and not cls._default_cache_enabled:
        cache_dir = None
        if "FASTF1_CACHE" in os.environ:
            cache_dir = os.environ.get("FASTF1_CACHE")
        else:
            cache_dir = cls._get_default_cache_path()

        if cache_dir is not None:
            # Ensure the default cache folder exists
            cache_dir = os.path.expandvars(cache_dir)
            cache_dir = os.path.expanduser(cache_dir)
            if not os.path.exists(cache_dir):
                try:
                    os.mkdir(cache_dir, mode=0o0700)
                except Exception as err:
                    _logger.error(f"Failed to create cache directory "
                                  f"{cache_dir}. Error {err}")
                    raise

            # Enable cache with default
            cls.enable_cache(cache_dir)
            _logger.warning(
                f"DEFAULT CACHE ENABLED! "
                f"({cls._convert_size(cls._get_size(cache_dir))}) "
                f"{cache_dir}"
            )
        else:
            # warn only once and only if cache is not enabled
            _logger.warning(
                "\n\nNO CACHE! Api caching has not been enabled! \n\t"
                "It is highly recommended to enable this feature for much "
                "faster data loading!\n\t"
                "Use `fastf1.Cache.enable_cache('path/to/cache/')`\n")

            cls._default_cache_enabled = True
```

--------------------------------

### Get Constructor Standings

Source: https://docs.fastf1.dev/_modules/fastf1/ergast/interface.html

Method to retrieve constructor standings for a specific season or round.

```python
    def get_constructor_standings(
            self,
            season: Literal['current'] | int | None = None,
            round: Literal['last'] | int | None = None,
            constructor: str | None = None,
            standings_position: int | None = None,
            result_type: Literal['pandas', 'raw'] | None = None,
            auto_cast: bool | None = None,
            limit: int | None = None,
            offset: int | None = None
    ) -> ErgastMultiResponse | ErgastRawResponse:
        """Get constructor standings at specific points of a season.

        See: https://ergast.com/mrd/methods/standings/

        .. ergast-api-map:: StandingsLists_Constructor
            :subcategory: ConstructorStandings
            :describe-dataframe:

        Args:
            season: select a season by its year (default: all, oldest first)
            round: select a round by its number (default: all)
            constructor: select a constructor by its constructor id
                (default: all)
            standings_position: select a result by position in the standings
                (default: all)
            result_type: Overwrites the default result type
            auto_cast: Overwrites the default value for ``auto_cast``
            limit: Overwrites the default value for ``limit``
            offset: An offset into the result set for response paging.
                Defaults to 0 if not set. See also "Response Paging",
                https://ergast.com/mrd/.

        Returns:
            :class:`~interface.ErgastMultiResponse` or
            :class:`~interface.ErgastRawResponse`, depending on the
            ``result_type`` parameter
        """
        selectors = {'season': season,
                     'round': round,
                     'constructor': constructor,
                     'standings_position': standings_position}
```

--------------------------------

### Get Finishing Order Abbreviations

Source: https://docs.fastf1.dev/_sources/gen_modules/examples_gallery/plot_laptimes_distribution.rst.txt

Retrieves the three-letter abbreviations for drivers in their finishing order.

```Python
finishing_order = [race.get_driver(i)["Abbreviation"] for i in point_finishers]
print(finishing_order)
```

```none
['PER', 'VER', 'LEC', 'ALO', 'SAI', 'HAM', 'STR', 'RUS', 'NOR', 'TSU']
```

--------------------------------

### SignalRClient.__init__

Source: https://docs.fastf1.dev/api_reference/api_autogen/fastf1.livetiming.client.SignalRClient.html

Initializes a new instance of the SignalRClient to capture live F1 timing data.

```APIDOC
## class fastf1.livetiming.client.SignalRClient(filename, filemode='w', debug=False, timeout=60, logger=None, no_auth=False)

### Description
Initializes the client for receiving and saving F1 timing data streamed over the SignalR protocol.

### Parameters
- **filename** (str) - Required - Filename (optionally with path) for the output file.
- **filemode** (str) - Optional - 'w' or 'a' to overwrite or append to the file.
- **debug** (bool) - Optional - If true, saves the complete SignalR message; otherwise, saves only the data.
- **timeout** (int) - Optional - Seconds to wait before exiting if no data is received. Set to 0 to disable.
- **logger** (Optional) - Optional - Custom logging instance.
- **no_auth** (bool) - Optional - If true, attempts to connect without authentication.
```

--------------------------------

### Initialize session and load data

Source: https://docs.fastf1.dev/_downloads/b33c3b8fbb5d3ffa240fe5c567fff5b6/plot_qualifying_results.ipynb

Sets up the Matplotlib environment for timedelta support and loads the specified qualifying session.

```python
import matplotlib.pyplot as plt
import pandas as pd
from timple.timedelta import strftimedelta

import fastf1
import fastf1.plotting
from fastf1.core import Laps


# Enable Matplotlib patches for plotting timedelta values
fastf1.plotting.setup_mpl(mpl_timedelta_support=True, color_scheme=None)


session = fastf1.get_session(2021, 'Spanish Grand Prix', 'Q')
session.load()
```

--------------------------------

### Get Driver Standings

Source: https://docs.fastf1.dev/_modules/fastf1/ergast/interface.html

Method to retrieve driver standings for a specific season, round, or driver.

```python
    def get_driver_standings(
            self,
            season: Literal['current'] | int | None = None,
            round: Literal['last'] | int | None = None,
            driver: str | None = None,
            standings_position: int | None = None,
            result_type: Literal['pandas', 'raw'] | None = None,
            auto_cast: bool | None = None,
            limit: int | None = None,
            offset: int | None = None
    ) -> ErgastMultiResponse | ErgastRawResponse:
        """Get driver standings at specific points of a season.

        See: https://ergast.com/mrd/methods/standings/

        .. ergast-api-map:: StandingsLists_Driver
            :subcategory: DriverStandings
            :describe-dataframe:

        Args:
            season: select a season by its year (default: all, oldest first)
            round: select a round by its number (default: all)
            driver: select a driver by its driver id (default: all)
            standings_position: select a result by position in the standings
                (default: all)
            result_type: Overwrites the default result type
            auto_cast: Overwrites the default value for ``auto_cast``
            limit: Overwrites the default value for ``limit``
            offset: An offset into the result set for response paging.
                Defaults to 0 if not set. See also "Response Paging",
                https://ergast.com/mrd/.

        Returns:
            :class:`~interface.ErgastMultiResponse` or
            :class:`~interface.ErgastRawResponse`, depending on the
            ``result_type`` parameter
        """
        selectors = {'season': season,
                     'round': round,
                     'driver': driver,
                     'standings_position': standings_position}

        return self._build_default_result(endpoint='driverStandings',
                                          table='StandingsTable',
                                          category=API.StandingsLists_Driver,
                                          subcategory=API.DriverStandings,
                                          result_type=result_type,
                                          auto_cast=auto_cast,
                                          limit=limit,
                                          offset=offset,
                                          selectors=selectors)
```

--------------------------------

### Initialize Session Class

Source: https://docs.fastf1.dev/_modules/fastf1/core.html

Constructor for the Session class, setting up event references, session names, and API paths.

```python
def __init__(self, event, session_name, f1_api_support=False):
    self.event = event
    """:class:`~fastf1.events.Event`: Reference to the associated event
    object."""
    self.name = session_name
    """str: Name of this session, for example 'Qualifying', 'Race',
    'FP1', ..."""
    self.f1_api_support = f1_api_support
    """bool: The official F1 API supports this event and lap timing
    data and telemetry data are available."""
    self.date = self.event.get_session_date(session_name, utc=True)
    """pandas.Datetime: Date at which this session took place."""

    try:
        _api_date = self.event.get_session_date(session_name, utc=False)
    except ValueError:
        # not all backends provide local timestamps, use UTC then which
        # works in almost all cases
        _api_date = self.date
    self.api_path = api.make_path(
        self.event['EventName'],
        self.event['EventDate'].strftime('%Y-%m-%d'),
        self.name, _api_date.strftime('%Y-%m-%d')
    )
    """str: API base path for this session"""

    if self.date.year <= 2023:
        self._RACE_LIKE_SESSIONS = ('Race', 'Sprint', 'Sprint Qualifying')
        # in 2021, 'Sprint Qualifying' was used as the name for a race-like
        # session that set the grid for the main race
        self._QUALI_LIKE_SESSIONS = ('Qualifying', 'Sprint Shootout')
    else:
        self._RACE_LIKE_SESSIONS = ('Race', 'Sprint')
        self._QUALI_LIKE_SESSIONS = ('Qualifying', 'Sprint Qualifying')
        # starting from 2024, 'Sprint Qualifying' is the name for the
        # qualifying-like session that sets the grid for the Sprint
        # (previously, this was called 'Sprint Shootout')

    self._ergast = ergast.Ergast()

    self._session_info: dict

    self._session_status: pd.DataFrame
    self._race_control_messages: pd.DataFrame

    self._track_status: pd.DataFrame

    self._total_laps: int | None
    self._laps: Laps

    self._t0_date: pd.Timestamp | None
    self._session_start_time: pd.Timedelta | None

    self._car_data: dict
    self._pos_data: dict

    self._weather_data: pd.DataFrame
    self._results: SessionResults

    self._session_split_times: list | None = None
```

--------------------------------

### Get Constructor Information

Source: https://docs.fastf1.dev/_modules/fastf1/ergast/interface.html

Retrieves a list of constructors from the Ergast API with optional filtering parameters.

```python
    def get_constructor_info(
            self,
            season: Literal['current'] | int | None = None,
            round: Literal['last'] | int | None = None,
            circuit: str | None = None,
            constructor: str | None = None,
            driver: str | None = None,
            grid_position: int | None = None,
            results_position: int | None = None,
            fastest_rank: int | None = None,
            status: str | None = None,
            result_type: Literal['pandas', 'raw'] | None = None,
            auto_cast: bool | None = None,
            limit: int | None = None,
            offset: int | None = None
    ) -> ErgastSimpleResponse | ErgastRawResponse:
        """Get a list of constructors.

        See: https://ergast.com/mrd/methods/constructors/

        .. ergast-api-map:: Constructors
            :describe-dataframe:

        Args:
            season: select a season by its year (default: all, oldest first)
            round: select a round by its number (default: all)
            circuit: select a circuit by its circuit id (default: all)
            constructor: select a constructor by its constructor id
                (default: all)
            driver: select a driver by its driver id (default: all)
            grid_position: select a grid position by its number (default: all)
            results_position: select a finishing result by its position
                (default: all)
            fastest_rank: select fastest by rank number (default: all)
            status: select by finishing status (default: all)
            result_type: Overwrites the default result type
            auto_cast: Overwrites the default value for ``auto_cast``
            limit: Overwrites the default value for ``limit``
            offset: An offset into the result set for response paging.
                Defaults to 0 if not set. See also "Response Paging",
                https://ergast.com/mrd/.

        Returns:
            :class:`~interface.ErgastSimpleResponse` or
            :class:`~interface.ErgastRawResponse`, depending on the
            ``result_type`` parameter
        """
        selectors = {'season': season,
                     'round': round,
                     'circuit': circuit,
                     'constructor': constructor,
                     'driver': driver,
                     'grid_position': grid_position,
                     'results_position': results_position,
                     'fastest_rank': fastest_rank,
                     'status': status}

        return self._build_default_result(endpoint="constructors",
                                          table='ConstructorTable',
                                          category=API.Constructors,
                                          subcategory=None,
                                          result_type=result_type,
                                          auto_cast=auto_cast,
                                          limit=limit,
                                          offset=offset,
                                          selectors=selectors)
```

--------------------------------

### Get Remaining Events

Source: https://docs.fastf1.dev/_modules/fastf1/events.html

Function to retrieve an EventSchedule object containing only events remaining in the season.

```python
def get_events_remaining(
        dt: datetime.datetime | None = None,
        *,
        include_testing: bool = True,
        backend: Literal['fastf1', 'f1timing', 'ergast'] | None = None,
        force_ergast: bool = False
) -> 'EventSchedule':
    """
    Create an :class:`~fastf1.events.EventSchedule` object for remaining
    season.

    Args:
        dt: Optional DateTime to get events after.

        include_testing: Include or exclude testing sessions from the
            event schedule.

        backend: select a specific backend as data source, options:

            - ``'fastf1'``: FastF1's own backend, full support for 2018 to now

            - ``'f1timing'``: uses data from the F1 live timing API, sessions
              for which no timing data is available are not listed
              (supports 2018 to now)

            - ``'ergast'``: uses data from Ergast, no local times are
              available, no information about availability of f1 timing data is
              available (supports 1950 to now)

            When no backend is specified, ``'fastf1'`` is used as a default and
            the other backends are used as a fallback in case the default
            is not available.

            For seasons older than 2018 ``'ergast'`` is always used.

        force_ergast: [Deprecated, use ``backend='ergast'``] Always use data
            from the ergast database to create the event schedule

    .. versionadded:: 2.3
    """
    if dt is None:
        dt = datetime.datetime.now(datetime.timezone.utc).replace(tzinfo=None)

    events = get_event_schedule(
        dt.year, include_testing=include_testing,
        force_ergast=force_ergast, backend=backend
    )

    if not include_testing:
        result = events.loc[events["Session5DateUtc"] >= dt]
        return result

    indexes_to_drop = []
    for idx, event in events.iterrows():
        if not event.is_testing():
            session_date = event["Session5DateUtc"]
        else:
            session_date = event["Session3DateUtc"]

        if session_date <= dt:
            indexes_to_drop.append(idx)

    result = events.drop(index=indexes_to_drop)
    return result
```

--------------------------------

### Accessing ErgastMultiResponse Data

Source: https://docs.fastf1.dev/_modules/fastf1/ergast/interface.html

Example demonstrating how to fetch and inspect multi-response data from the Ergast API.

```python
        >>> from fastf1.ergast import Ergast
        >>> ergast = Ergast(result_type='pandas', auto_cast=True)
        >>> result = ergast.get_race_results(season=2022)

        # The description shows that the result includes data from two
        # grand prix.
        >>> result.description
           season  round  ... locality       country
        0    2022      1  ...   Sakhir       Bahrain
        1    2022      2  ...   Jeddah  Saudi Arabia
        <BLANKLINE>
        [2 rows x 13 columns]

        # As expected, ``result.content`` contains two elements, one for each
        # row of the description
        >>> len(result.content)
        2

        # The first element contains all results from the first of the two
        # grand prix.
        >>> result.content[0]
            number  position  ... fastestLapAvgSpeedUnits  fastestLapAvgSpeed
        0       16         1  ...                     kph             206.018
        1       55         2  ...                     kph             203.501
        2       44         3  ...                     kph             202.469
        ...
        17      11        18  ...                     kph             202.762
        18       1        19  ...                     kph             204.140
        19      10        20  ...                     kph             200.189
        <BLANKLINE>
        [20 rows x 26 columns]

        # The second element is incomplete and only contains the first 10
        # positions of the second Grand Prix. This is because by default,
        # every query on Ergast is limited to 30 result values. You can
        # manually change this limit for each request though.
        >>> result.content[1]
           number  position  ... fastestLapAvgSpeedUnits  fastestLapAvgSpeed
        0       1         1  ...                     kph             242.191
        1      16         2  ...                     kph             242.556
        2       55         3  ...                     kph             241.841
        ...
        7      10         8  ...                     kph             237.796
        8      20         9  ...                     kph             239.562
        9      44        10  ...                     kph             239.001
        <BLANKLINE>
        [10 rows x 26 columns]
```

--------------------------------

### Initialize and use FastF1 logging

Source: https://docs.fastf1.dev/contributing/contributing.html

Use the project's logging utility to provide debug and info messages. Ensure the logger is initialized once per module using the current module name.

```python
# set up the logger once (!)
logger = get_logger(__name__)

# code
logger.info('Here is some information')
logger.debug('Here is some more detailed information')
# more code
```

--------------------------------

### Access session start date

Source: https://docs.fastf1.dev/_sources/time_explanation.rst.txt

Retrieves the absolute date and time corresponding to the session zero point.

```python
>>> session.t0_date
Timestamp('2020-09-06 12:40:00.196000')
```

--------------------------------

### setup_mpl(mpl_timedelta_support=True, color_scheme=None)

Source: https://docs.fastf1.dev/_modules/fastf1/plotting/_plotting.html

Configures matplotlib settings for FastF1. This function enables timedelta support and applies the FastF1 color scheme if requested.

```APIDOC
## setup_mpl(mpl_timedelta_support=True, color_scheme=None)

### Description
Configures matplotlib for use with FastF1. This is highly recommended for plotting lap times, sector times, and other timedelta-based data.

### Parameters
- **mpl_timedelta_support** (bool) - Optional - Enables patching of matplotlib functions to support plotting timedelta values using the 'Timple' package. Defaults to True.
- **color_scheme** (str | None) - Optional - Sets the FastF1 color scheme. Valid values are 'fastf1' or None. Defaults to None.
```

--------------------------------

### fastf1.plotting.setup_mpl

Source: https://docs.fastf1.dev/_sources/plotting.rst.txt

Enables extended support for Matplotlib and Seaborn to improve plotting capabilities for FastF1 data.

```APIDOC
## setup_mpl()

### Description
Configures Matplotlib to better support FastF1 plotting requirements. It is recommended to call this function before creating plots.
```

--------------------------------

### Clone the repository

Source: https://docs.fastf1.dev/contributing/contributing.html

Use this command to create a local copy of your forked repository.

```bash
git clone https://github.com/<YOUR GITHUB USERNAME>/Fast-F1.git
```

--------------------------------

### Obtain driver styles using built-in options

Source: https://docs.fastf1.dev/_modules/fastf1/plotting/_interface.html

Demonstrates retrieving styling dictionaries for specific drivers using default Matplotlib-compatible arguments like color and marker.

```python
>>> from fastf1 import get_session
>>> from fastf1.plotting import get_driver_style
>>> session = get_session(2023, 10, 'R')
>>> get_driver_style('ALO', ['color', 'marker'], session)
{'color': '#00665e', 'marker': 'x'}
>>> get_driver_style('STR', ['color', 'marker'], session)
{'color': '#00665e', 'marker': 'o'}
```

--------------------------------

### Load live timing data into FastF1

Source: https://docs.fastf1.dev/api_reference/livetiming.html

Loading recorded live timing data into a session object for analysis.

```python
import fastf1
from fastf1.livetiming.data import LiveTimingData

livedata = LiveTimingData('saved_data.txt')
session = fastf1.get_testing_session(2021, 1, 1)
session.load(livedata=livedata)
```

```python
livedata = LiveTimingData('saved_data_1.txt', 'saved_data_2.txt')
```

--------------------------------

### Align Laps Between Drivers

Source: https://docs.fastf1.dev/_modules/fastf1/_api.html

Aligns lap start and end times across drivers using the gap to the leader.

```python
@soft_exceptions("lap alignment",
                 "Failed to align laps between drivers!",
                 logger=_logger)
def _align_laps(laps_data, stream_data):
    # align lap start and end times between drivers based on Gap to leader
    if pd.isnull(stream_data['GapToLeader']).all():
        return  # no data to align on

    expected_gap = dict()
    delta = dict()
    n_laps = laps_data['NumberOfLaps'].max()

    for offset in range(0, n_laps):
        leader = None

        # drivers still running on this lap
        active_drivers = laps_data.loc[
            laps_data['NumberOfLaps'] == (offset + 1), 'Driver'
        ].unique()

        # drivers that pit in/out on this lap need to be skipped
        skip_drivers = laps_data.loc[
            (
                (laps_data['NumberOfLaps'] == (offset + 1)) &
                ((~pd.isnull(laps_data['PitInTime'])) |
                 (~pd.isnull(laps_data['PitOutTime'])))
            ), 'Driver'
        ].to_list()

        for drv in active_drivers:
            if drv in skip_drivers:
                continue

            gap_str = _get_gap_str_for_drv(drv, offset, laps_data, stream_data)
            if 'LAP' in gap_str:
                leader = drv
            elif drv not in delta.keys():
                eg = to_timedelta(gap_str)
                if eg is not None:
                    # cannot work with "+ 1 Lap" and similar
                    expected_gap[drv] = eg

        if leader is None:
            continue

        leader_time \
            = laps_data[laps_data['Driver'] == leader].iloc[offset]['Time']

        # if first alignment pass, set current leader as zero point
        # else get already calculated offset of current leader as zero point
        if leader not in delta:
            delta[leader] = datetime.timedelta(0)
        ref_zero = delta[leader]

        for drv in expected_gap.keys():
            if drv in delta:
                continue  # driver already has a delta, skip

            other_time \
                = laps_data[laps_data['Driver'] == drv].iloc[offset]['Time']
            is_gap = other_time - leader_time
            # expected_gap is taken from "gap to leader" values
            # is_gap is calculated from difference between when laps where set
            # after correcting for ref_zero, this yields out delta by which we
            # must shift the laps to align them
            delta[drv] = expected_gap[drv] - is_gap + ref_zero

        if len(active_drivers) <= len(delta):
            break

    unaligned_drivers = list(
        set(laps_data['Driver'].unique()) - set(delta.keys())
    )

    # realign all deltas: a positive delta means too early with reference to
    # our zero point; negative delta means too late
    # it's physically impossible for data to be too early, therefore, if any
    # delta is positive, our zero point is too late, and we need to shift all
    # deltas by the maximum delta to align them.
    max_delta = None
    for drv, value in delta.items():
        if (max_delta is None) or (value > max_delta):
            max_delta = value
```

--------------------------------

### Manage F1TV Authentication via CLI

Source: https://docs.fastf1.dev/api_reference/accounts_auth.html

Use the command line to manually trigger authentication, check the current status, or clear stored credentials.

```bash
python -m fastf1 auth f1tv [--authenticate] [--clear] [--status]
```

--------------------------------

### Activate the virtual environment

Source: https://docs.fastf1.dev/contributing/devenv_setup.html

Activate the environment based on the operating system and shell.

```bash
source <file folder location>/bin/activate  # Linux/macOS
<file folder location>\Scripts\activate.bat  # Windows cmd.exe
<file folder location>\Scripts\Activate.ps1  # Windows PowerShell
```

--------------------------------

### Load session and telemetry data

Source: https://docs.fastf1.dev/_downloads/6c40f4dd715557c3d6b53e7f8c663286/plot_gear_shifts_on_track.ipynb

Initializes the FastF1 session and retrieves telemetry for the fastest lap.

```python
import matplotlib.pyplot as plt
import numpy as np
from matplotlib import colormaps
from matplotlib.collections import LineCollection

import fastf1


session = fastf1.get_session(2021, 'Austrian Grand Prix', 'Q')
session.load()

lap = session.laps.pick_fastest()
tel = lap.get_telemetry()
```

--------------------------------

### Fetch API Page

Source: https://docs.fastf1.dev/_modules/fastf1/_api.html

Performs a GET request to the Formula 1 live timing API with fallback support.

```python
[docs]
def fetch_page(path, name):
    """
    .. warning::
        :mod:`fastf1.api` will be considered private in future releases and
        potentially be removed or changed.

    Fetch data from the formula1 livetiming web api, given url base path and page name. An attempt
    to parse json or decode known messages is made.

    Args:
        path (str): api path base string (usually ``Session.api_path``)
        name (str): page name (see ``api.pages`` for all known pages)

    Returns:
        - dictionary if content was json
        - list of entries if jsonStream, where each entry again contains two elements: [timestamp, content]. Content is
          parsed with :func:`parse` and will usually be a dictionary created from json data.
        - None if request failed

    """
    page = pages[name]
    is_stream = 'jsonStream' in page
    is_z = '.z.' in page

    r = Cache.requests_get(base_url + path + pages[name], headers=headers)

    if r.status_code >= 400:
        _logger.debug(f"Falling back to livetiming mirror ({base_url_mirror})")
        r = Cache.requests_get(base_url_mirror + path + pages[name],
                               headers=headers)
```

--------------------------------

### Get Compound Mapping

Source: https://docs.fastf1.dev/_modules/fastf1/plotting/_interface.html

Returns a dictionary mapping tire compound names to their hexadecimal color codes for a session.

```python
def get_compound_mapping(session: Session) -> dict[str, str]:
    """
    Returns a dictionary that maps compound names to their associated
    colors. The colors are given as hexadecimal RGB color codes.

    Args:
        session: the session for which the data should be obtained

```

--------------------------------

### Retrieve Fastest Lap Time

Source: https://docs.fastf1.dev/_modules/fastf1/core.html

Example of loading a session and extracting the fastest lap time for a specific driver.

```python
session = fastf1.get_session(2019, 'Bahrain', 'Q')
session.load()
best_bottas = session.laps.pick_drivers('BOT').pick_fastest()

print(best_bottas['LapTime'])
# Timedelta('0 days 00:01:28.256000')
```

--------------------------------

### Initialize ErgastResultSeries

Source: https://docs.fastf1.dev/_modules/fastf1/ergast/interface.html

The constructor handles data initialization from either a raw response or a pre-processed dataset, ensuring mutual exclusivity between the two inputs.

```python
def __init__(self, data=None, *,
             category: dict | None = None,
             response: list | None = None,
             auto_cast: bool = True,
             **kwargs):
    if (data is not None) and (response is not None):
        raise ValueError(f"Cannot initialize {type(self)} with `data`"
                         f"and `response`.")
    if (data is None) and (response is not None):
        data = self._prepare_response(response, category, auto_cast)
    super().__init__(data, **kwargs)
```

--------------------------------

### Configure LineCollection

Source: https://docs.fastf1.dev/_downloads/6c40f4dd715557c3d6b53e7f8c663286/plot_gear_shifts_on_track.ipynb

Sets up the segmented colormap and normalizes the gear values for the LineCollection.

```python
cmap = colormaps['Paired']
lc_comp = LineCollection(segments, norm=plt.Normalize(1, cmap.N+1), cmap=cmap)
lc_comp.set_array(gear)
lc_comp.set_linewidth(4)
```

--------------------------------

### Access Lap Data

Source: https://docs.fastf1.dev/_modules/fastf1/core.html

Example usage for filtering lap data, such as finding the fastest lap for a specific driver.

```python
        import fastf1
```
Tokens:
Raw