implemented architecture for LLM to dynamically create approprite API requests to OpenF1 server

openf1_registry.py

@@ -0,0 +1,208 @@
+from enum import Enum
+from dataclasses import dataclass
+from typing import Dict, Set, List, Optional
+
+class FilterType(Enum):
+    EQUALITY = "equality"       # exact match
+    COMPARISON = "comparison"   # >, <, >=, <=
+
+class DataType(Enum):
+    STRING = "string"
+    INTEGER = "integer"
+    DATETIME = "datetime"
+    BINARY = "binary"          # true/false filters
+
+@dataclass
+class FilterSpec:
+    """Specification for an API filter parameter"""
+    name: str
+    filter_type: FilterType
+    data_type: DataType
+    description: str = ""
+    allowed_values: Optional[List[str]] = None  # For equality filters with restricted values
+    
+    def get_query_examples(self) -> List[str]:
+        """Generate example query parameters for this filter"""
+        examples = []
+        
+        if self.data_type == DataType.BINARY:
+            examples = [f"{self.name}=true", f"{self.name}=false"]
+        
+        elif self.filter_type == FilterType.EQUALITY:
+            if self.allowed_values:
+                examples = [f"{self.name}={val}" for val in self.allowed_values[:2]]
+            elif self.data_type == DataType.STRING:
+                examples = [f"{self.name}=example_value"]
+            elif self.data_type == DataType.INTEGER:
+                examples = [f"{self.name}=42"]
+            elif self.data_type == DataType.DATETIME:
+                examples = [f"{self.name}=2024-01-01T00:00:00Z", f"{self.name}=2024-01-01T10:30:00Z"]
+        
+        elif self.filter_type == FilterType.COMPARISON:
+            if self.data_type == DataType.INTEGER:
+                examples = [f"{self.name}>=10", f"{self.name}<100"]
+            elif self.data_type == DataType.DATETIME:
+                examples = [f"{self.name}>=2024-01-01T00:00:00Z", f"{self.name}<2024-12-31T00:00:00Z"]
+            elif self.data_type == DataType.STRING:
+                examples = [f"{self.name}>M", f"{self.name}<Z"]  # alphabetical comparison
+        
+        return examples
+    
+    def help_text(self) -> str:
+        """Generate help text for this filter"""
+        text = f"Filter: {self.name}\n"
+        text += f"  Type: {self.filter_type.value} ({self.data_type.value})\n"
+        
+        if self.description:
+            text += f"  Description: {self.description}\n"
+        
+        if self.allowed_values:
+            text += f"  Allowed values: {', '.join(self.allowed_values)}\n"
+        
+        examples = self.get_query_examples()
+        if examples:
+            text += f"  Examples: {', '.join(examples)}"
+        
+        return text
+
+
+
+class APIEndpointRegistry:
+    """Registry for API endpoints and their supported filters"""
+    
+    def __init__(self, base_url: str = ""):
+        self.base_url = base_url
+        self.endpoints: Dict[str, Set[str]] = {}  # endpoint -> filter names
+        self.filters: Dict[str, FilterSpec] = {}  # global filter definitions
+    
+    def define_filter(
+        self, 
+        name: str, 
+        filter_type: FilterType, 
+        data_type: DataType,
+        description: str = "",
+        allowed_values: Optional[List[str]] = None
+    ) -> 'APIEndpointRegistry':
+        """Define a filter that can be used by endpoints"""
+        filter_spec = FilterSpec(name, filter_type, data_type, description, allowed_values)
+        self.filters[name] = filter_spec
+        return self
+    
+    def register_endpoint(self, endpoint: str, *filter_names: str) -> 'APIEndpointRegistry':
+        """Register an API endpoint with its supported filters"""
+
+        # Validate all filters exist
+        for filter_name in filter_names:
+            if filter_name not in self.filters:
+                raise ValueError(f"Filter '{filter_name}' not defined. Use define_filter() first.")
+        
+        # Store endpoint -> filters mapping
+        self.endpoints[endpoint] = set(filter_names)
+        
+        return self
+    
+
+
+
+
+    def get_endpoint_filters(self, endpoint: str) -> Dict[str, FilterSpec]:
+        """Get all filters supported by an endpoint"""
+        filter_names = self.endpoints.get(endpoint, set())
+        return {name: self.filters[name] for name in filter_names}
+        
+    def get_filter_help(self, filter_name: str) -> str:
+        """Get help text for a specific filter"""
+
+        if filter_name in self.filters:
+            return self.filters[filter_name].help_text()
+        return f"Filter '{filter_name}' not found."
+    
+    def get_endpoint_help(self, endpoint: str) -> str:
+        """Get help text for all filters supported by an endpoint"""
+
+        filters = self.get_endpoint_filters(endpoint)
+        if not filters:
+            return f"Endpoint '{endpoint}' has no registered filters."
+        
+        help_text = f"API Endpoint: {self.base_url}{endpoint}\n"
+        help_text += f"Supported filters ({len(filters)}):\n\n"
+        
+        for name, spec in sorted(filters.items()):
+            help_text += spec.help_text() + "\n\n"
+        
+        return help_text.strip()
+    
+    def list_all_endpoints(self) -> List[str]:
+        """Get list of all registered endpoints"""
+        return sorted(self.endpoints.keys())
+    
+    def list_all_filters(self) -> List[str]:
+        """Get list of all defined filters"""
+        return sorted(self.filters.keys())
+
+
+# Create registry with base URL
+f1_api = APIEndpointRegistry("https://api.openf1.org/v1/")
+
+# Define filters with their specifications
+f1_api.define_filter("date", FilterType.COMPARISON, DataType.DATETIME, "The UTC date and time, in ISO 8601 format.")
+f1_api.define_filter("driver_number", FilterType.EQUALITY, DataType.INTEGER, "The unique number assigned to an F1 driver")
+f1_api.define_filter("meeting_key", FilterType.EQUALITY, DataType.STRING, "The unique identifier for the meeting. Use 'latest' to identify the latest or current meeting.")
+f1_api.define_filter("session_key", FilterType.EQUALITY, DataType.STRING, "The unique identifier for the session. Use 'latest' to identify the latest or current session.")
+f1_api.define_filter("speed", FilterType.COMPARISON, DataType.INTEGER, "Velocity of the car in km/h.")
+f1_api.define_filter("country_code", FilterType.EQUALITY, DataType.STRING, "A code that uniquely identifies the country.")
+f1_api.define_filter("first_name", FilterType.EQUALITY, DataType.STRING, "The first name of the driver.")
+f1_api.define_filter("last_name", FilterType.EQUALITY, DataType.STRING, "The last name of the driver.")
+f1_api.define_filter("full_name", FilterType.EQUALITY, DataType.STRING, "The full name of the driver.")
+f1_api.define_filter("name_acronym", FilterType.EQUALITY, DataType.STRING, "Three-letter acronym of the driver's name.")
+f1_api.define_filter("team_name", FilterType.EQUALITY, DataType.STRING, "The name of the driver's team.")
+f1_api.define_filter("gap_to_leader", FilterType.COMPARISON, DataType.INTEGER, "The time gap to the race leader in seconds, +1 LAP if lapped, or null for the race leader.")
+f1_api.define_filter("interval", FilterType.COMPARISON, DataType.INTEGER, "The time gap to the car ahead in seconds, +1 LAP if lapped, or null for the race leader.")
+f1_api.define_filter("date_start", FilterType.COMPARISON, DataType.DATETIME, "The UTC starting date and time, in ISO 8601 format.")
+f1_api.define_filter("date_end", FilterType.COMPARISON, DataType.DATETIME, "The UTC ending date and time, in ISO 8601 format.")
+f1_api.define_filter("is_pit_out_lap", FilterType.EQUALITY, DataType.BINARY, "A boolean value indicating whether the lap is an out lap from the pit (true if it is, false otherwise).")
+f1_api.define_filter("lap_duration", FilterType.COMPARISON, DataType.INTEGER, "The total time taken, in seconds, to complete the entire lap.")
+f1_api.define_filter("lap_number", FilterType.EQUALITY, DataType.INTEGER, "The sequential number of the lap within the session (starts at 1).")
+f1_api.define_filter("circuit_key", FilterType.EQUALITY, DataType.STRING, "The unique identifier for the circuit where the event takes place.")
+f1_api.define_filter("circuit_short_name", FilterType.EQUALITY, DataType.STRING, "The short or common name of the circuit where the event takes place.")
+f1_api.define_filter("country_key", FilterType.EQUALITY, DataType.STRING, "The unique identifier for the country where the event takes place.")
+f1_api.define_filter("country_name", FilterType.EQUALITY, DataType.STRING, "The name of the country where the event takes place.")
+f1_api.define_filter("location", FilterType.EQUALITY, DataType.STRING, "The city or geographical location where the event takes place.")
+f1_api.define_filter("meeting_name", FilterType.EQUALITY, DataType.STRING, "The name of the meeting.")
+f1_api.define_filter("meeting_official_name", FilterType.EQUALITY, DataType.STRING, "The official name of the meeting.")
+f1_api.define_filter("year", FilterType.EQUALITY, DataType.INTEGER, "The year of the event.")
+f1_api.define_filter("pit_duration", FilterType.COMPARISON, DataType.INTEGER, "The time spent in the pit, from entering to leaving the pit lane, in seconds.")
+f1_api.define_filter("position", FilterType.EQUALITY, DataType.INTEGER, "Position of the driver (starts at 1).", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])
+f1_api.define_filter("category", FilterType.EQUALITY, DataType.STRING, "The category of the event (CarEvent, Drs, Flag, SafetyCar)", ["CarEvent", "Drs", "Flag", "SafetyCar"])
+f1_api.define_filter("flag", FilterType.EQUALITY, DataType.STRING, "The flag displayed to the drivers.", ["Green", "Yellow", "Red", "Black", "White", "Blue", "Checkered", "White"])
+f1_api.define_filter("message", FilterType.EQUALITY, DataType.STRING, "Description of the event or action.")
+f1_api.define_filter("session_name", FilterType.EQUALITY, DataType.STRING, "The name of the session (Practice 1, Qualifying, Race, ...).")
+f1_api.define_filter("session_type", FilterType.EQUALITY, DataType.STRING, "The type of the session (Practice, Qualifying, Race, ...).")
+f1_api.define_filter("compound", FilterType.EQUALITY, DataType.STRING, "The specific compound of tyre used during the stint (SOFT, MEDIUM, HARD, ...).", ["SOFT", "MEDIUM", "HARD", "INTERMEDIATE", "WET"])
+f1_api.define_filter("lap_end", FilterType.COMPARISON, DataType.INTEGER, "Number of the last completed lap in this stint.")
+f1_api.define_filter("lap_start", FilterType.COMPARISON, DataType.INTEGER, "Number of the initial lap in this stint (starts at 1).")
+f1_api.define_filter("stint_number", FilterType.EQUALITY, DataType.INTEGER, "The sequential number of the stint within the session (starts at 1).")
+f1_api.define_filter("tyre_age_at_start", FilterType.COMPARISON, DataType.INTEGER, "The age of the tyres at the start of the stint, in laps completed.")
+f1_api.define_filter("air_temperature", FilterType.COMPARISON, DataType.INTEGER, "Air temperature (°C).")
+f1_api.define_filter("humidity", FilterType.COMPARISON, DataType.INTEGER, "Humidity percentage.")
+f1_api.define_filter("pressure", FilterType.COMPARISON, DataType.INTEGER, "Air pressure (mbar).")
+f1_api.define_filter("rainfall", FilterType.COMPARISON, DataType.INTEGER, "Whether there is rainfall.")
+f1_api.define_filter("track_temperature", FilterType.COMPARISON, DataType.INTEGER, "Track temperature (°C).")
+f1_api.define_filter("wind_direction", FilterType.COMPARISON, DataType.INTEGER, "Wind direction (°), from 0° to 359°.")
+f1_api.define_filter("wind_speed", FilterType.COMPARISON, DataType.INTEGER, "Wind speed (m/s).")
+
+
+# Register API endpoints with their supported filters
+f1_api.register_endpoint("car_data", "date", "driver_number", "meeting_key", "session_key", "speed")
+f1_api.register_endpoint("drivers", "session_key", "meeting_key", "country_code", "driver_number", "first_name", "last_name", "full_name", "name_acronym", "team_name")
+f1_api.register_endpoint("intervals", "date", "driver_number", "meeting_key", "session_key", "gap_to_leader", "interval")
+f1_api.register_endpoint("laps", "date_start", "driver_number", "meeting_key", "session_key", "lap_duration", "lap_number", "is_pit_out_lap")
+f1_api.register_endpoint("location", "date", "driver_number", "meeting_key", "session_key")
+f1_api.register_endpoint("meetings", "circuit_key", "circuit_short_name", "country_code", "country_key", "country_name", "date_start", "location", "meeting_key", "meeting_name", "meeting_official_name", "year")
+f1_api.register_endpoint("pit", "date", "driver_number", "lap_number", "meeting_key", "session_key", "pit_duration")
+f1_api.register_endpoint("position", "date", "driver_number", "meeting_key", "session_key", "position")
+f1_api.register_endpoint("race_control", "category", "date", "driver_number", "meeting_key", "session_key", "flag", "message", "lap_number")
+f1_api.register_endpoint("sessions", "circuit_key", "circuit_short_name", "country_code", "country_key", "country_name", "date_start", "date_end", "location", "session_name", "session_type", "session_key", "meeting_key", "year")
+f1_api.register_endpoint("stints", "compound", "driver_number", "lap_end", "lap_start", "meeting_key", "session_key", "stint_number", "tyre_age_at_start")
+f1_api.register_endpoint("team_radio", "date", "driver_number", "meeting_key", "session_key")
+f1_api.register_endpoint("weather", "air_temperature", "date", "humidity", "pressure", "rainfall", "track_temperature", "wind_direction", "wind_speed", "meeting_key", "session_key")

openf1_tools.py

@@ -0,0 +1,169 @@
+import json
+from urllib.request import urlopen
+from openf1_registry import f1_api
+
+
+api_endpoints = {
+    "sessions": "sessions?",
+    "weather": "weather?",
+    "locations": "locations?",
+    "drivers": "drivers?",
+    "intervals": "intervals?",
+    "laps": "laps?",
+    "car_data": "car_data?",
+    "pit": "pit?",
+    "position": "position?",
+    "race_control": "race_control?",
+    "stints": "stints?",
+    "team_radio": "team_radio?",
+}
+
+
+### Essential tools ###
+
+def get_api_endpoint(endpoint: str) -> dict:
+    """
+    Retrieve the API endpoint URL and filter metadata for a given OpenF1 endpoint.
+
+    Args:
+        endpoint (str): The name of the OpenF1 API endpoint (e.g., 'sessions', 'laps').
+
+    Returns:
+        dict: A dictionary containing:
+            - status (str): 'success' if endpoint exists, 'error' otherwise
+            - api_string (str): The full API URL for the endpoint
+            - filter_metadata (dict): Available filters for the endpoint
+    """
+    try:
+        url = f1_api.base_url + api_endpoints.get(endpoint, None)
+        return {
+            "status": "success",
+            "api_string": url,
+            "filter_metadata": f1_api.get_endpoint_filters(endpoint)
+        }
+    except:
+        return {
+            "status": "error",
+            "api_string": f"Endpoint {endpoint} not found. Available endpoints: {f1_api.list_all_endpoints()}",
+            "filter_metadata": dict()
+        }
+
+def get_filter_string(filter_name: str, filter_value: str, operator: str = "=") -> str:
+    """
+    Create a filter string for OpenF1 API requests.
+
+    Args:
+        filter_name (str): The name of the filter to apply.
+        filter_value (str): The value to filter by.
+        operator (str, optional): The comparison operator. Defaults to "=".
+
+    Returns:
+        str: Formatted filter string that can be appended to an API request.
+    """
+    return f"{filter_name}{operator}{filter_value}&"
+
+def apply_filters(api_string: str, *filters: str) -> str:
+    """
+    Apply one or more filter strings to an API endpoint URL.
+
+    Args:
+        api_string (str): The base API endpoint URL.
+        *filters (str): Variable number of filter strings to apply.
+
+    Returns:
+        str: The complete API URL with all filters applied.
+    """
+    if filters:
+        for filter in filters:
+            api_string += filter
+    return api_string.rstrip("&") # Remove trailing & for last filter
+
+def send_request(api_string: str) -> dict:
+    """
+    Send an HTTP GET request to the specified API endpoint and return the JSON response.
+
+    Args:
+        api_string (str): The complete API URL to send the request to.
+
+    Returns:
+        dict: The JSON response parsed as a Python dictionary.
+
+    Raises:
+        Exception: If there's an error during the HTTP request or JSON parsing.
+    """
+    try: 
+        response = urlopen(api_string)
+        data = json.loads(response.read().decode('utf-8'))
+        return data
+    except Exception as e:
+        print(f"Error: {e}")
+        raise
+
+### LLM helper functions ###
+
+def get_api_endpoints() -> dict:
+    """
+    Retrieve a list of all available OpenF1 API endpoints.
+
+    Returns:
+        dict: A dictionary containing a single key 'endpoints' with a list of
+              available endpoint names as strings.
+    """
+    return {
+        "endpoints": f1_api.list_all_endpoints(),
+    }
+
+def get_endpoint_info(endpoint: str) -> dict:
+    """
+    Retrieve detailed information about a specific OpenF1 API endpoint.
+
+    Args:
+        endpoint (str): The name of the endpoint to get information about.
+
+    Returns:
+        dict: A dictionary containing:
+            - endpoint (str): The name of the endpoint
+            - endpoint_filters (list): Available filters for this endpoint
+            - endpoint_help (str): Help text describing the endpoint's purpose and usage
+    """
+    return {
+        "endpoint": endpoint,
+        "endpoint_filters": f1_api.get_endpoint_filters(endpoint),
+        "endpoint_help": f1_api.get_endpoint_help(endpoint)
+    }
+
+def get_filter_info(filter_name: str) -> dict:
+    """
+    Retrieve detailed information about a specific OpenF1 API filter.
+
+    Args:
+        filter_name (str): The name of the filter to get information about.
+
+    Returns:
+        dict: A dictionary containing:
+            - filter_name (str): The name of the filter
+            - filter_metadata (dict): Metadata about the filter, including
+                                   description, valid values, and usage examples
+    """
+    return {
+        "filter_name": filter_name,
+        "filter_metadata": f1_api.get_filter_help(filter_name)
+    }
+
+    
+
+
+
+if __name__ == "__main__":
+
+    from pprint import pprint
+    
+    data = get_api_endpoint("sessions")
+    pprint(data) 
+
+
+    pprint(get_endpoint_info("sessions"))
+
+
+    # response = send_request(data["api_string"])
+    # pprint(response)

tools.py

@@ -1,243 +0,0 @@
-"""
-This module provides tools for interacting with Formula 1 data using the FastF1 library.
-
-Tools to implement
-- driver info
-- compare drivers
-"""
-
-import json
-import fastf1
-import gradio as gr
-import pandas as pd
-from PIL import Image
-from typing import Union
-from fastf1.core import Session
-
-# Local modules
-from utils import parser_utils, track_utils
-from utils.constants import (
-    AVAILABLE_SESSION_TYPES,
-    DRIVER_DETAILS
-)
-
-# Custom types
-gp = Union[str, int]
-session_type = Union[str, int, None]
-
-### FastF1 tools ###
-
-def get_session(year: int, round: gp, session_type: session_type) -> Session:
-    """Retrieve a specific Formula 1 session.
-    
-    Args:
-        year (int): The season year (e.g., 2024)
-        round (str | int): The race round number or name (e.g., 1 or 'Monaco')
-        session_type (str | int | None): Type of session (e.g., 'FP1', 'Q', 'R')
-        
-    Returns:
-        Session: A FastF1 Session object for the specified parameters
-        
-    Note:
-        If session_type is a string and not in AVAILABLE_SESSION_TYPES,
-        returns an error message string instead.
-    """
-
-    # Check if session type is valid
-    if isinstance(session_type, str):
-        if session_type.lower() not in AVAILABLE_SESSION_TYPES:
-            return f"Session type {session_type} is not available. Supported session types: {AVAILABLE_SESSION_TYPES}"
-
-    return fastf1.get_session(year, round, session_type)
-
-def get_season_calendar(year: int) -> str:
-    """Get the complete race calendar for a specific F1 season.
-    
-    Args:
-        year (int): The season year to get the calendar for
-        
-    Returns:
-        str: Formatted string containing the season calendar
-    """
-    season_calendar = fastf1.get_event_schedule(year)
-    return parser_utils.parse_season_calendar(season_calendar)
-
-def get_event_info(year: int, round: gp, format: str) -> str:
-    """Retrieve information about a specific Formula 1 event.
-    
-    Args:
-        year (int): The season year
-        round (str | int): The race round number or name
-        format (str): Output format ('human' for readable text, 'LLM' for structured data)
-        
-    Returns:
-        str: Formatted event information based on the specified format
-    """
-
-    event = fastf1.get_session(year, round, "race").event # Event object is the same for all sessions, so hardcode "race"
-    if format == "human":
-        data_interval = f"{event['Session1DateUtc'].date()} - {event['Session5DateUtc'].date()}"
-        event_string = f"Round {event['RoundNumber']} : {event['EventName']} - {event['Location']}, {event['Country']} ({data_interval})"
-        return event_string
-    elif format == "LLM":
-        return parser_utils.parse_event_info(event)
-
-
-def get_constructor_standings(year: int) -> str:
-    """Retrieve constructor championship standings for a given year.
-    
-    Args:
-        year (int): The season year
-        
-    Returns:
-        str: Constructor championship standings
-    """
-    pass
-
-def get_driver_standings(year: int) -> str:
-    """Retrieve driver championship standings for a given year.
-    
-    Args:
-        year (int): The season year
-        
-    Returns:
-        str: Driver championship standings
-    """
-    pass
-
-def driver_championship_standings(year: int, driver_name: str) -> str:
-    """Get the championship standing for a specific driver in a given year.
-    
-    Args:
-        year (int): The season year
-        driver_name (str): Full name of the driver (e.g., 'Lewis Hamilton')
-        
-    Returns:
-        str: Formatted string with driver's position, points, and wins
-    """
-
-    with open("assets/driver_abbreviations.json") as f:
-        driver_abbreviations = json.load(f)
-        driver_abbreviation = driver_abbreviations[driver_name]
-    ergast = fastf1.ergast.Ergast()
-    driver_standings = ergast.get_driver_standings(year).content[0]
-    driver_standing = driver_standings[["position", "points", "wins", "driverCode"]].reset_index(drop=True)
-    driver_standing = driver_standing[driver_standing["driverCode"] == driver_abbreviation]
-    suffix = "st" if driver_standing['position'].iloc[0] == 1 else "nd" if driver_standing['position'].iloc[0] == 2 else "rd" if driver_standing['position'].iloc[0] == 3 else "th"
-    standings_string = f"{driver_name} is {driver_standing['position'].iloc[0]}{suffix} with {driver_standing['points'].iloc[0]} points and {driver_standing['wins'].iloc[0]} wins"
-    return standings_string
-    
-def constructor_championship_standings(year: int, constructor_name: str) -> str:
-    """Get the championship standing for a specific constructor in a given year.
-    
-    Args:
-        year (int): The season year
-        constructor_name (str): Name of the constructor team (e.g., 'Mercedes')
-        
-    Returns:
-        str: Formatted string with constructor's position, points, and wins
-    """
-
-    team_mapping = {
-    "McLaren": "McLaren",
-    "Ferrari": "Ferrari",
-    "Red Bull Racing": "Red Bull",
-    "Mercedes": "Mercedes",
-    "Aston Martin": "Aston Martin",
-    "Alpine": "Alpine F1 Team",
-    "Haas": "Haas F1 Team",
-    "Racing Bulls": "RB F1 Team",
-    "Williams": "Williams",
-    "Kick Sauber": "Sauber"
-    }
-
-    ergast = fastf1.ergast.Ergast()
-    constructor_standings = ergast.get_constructor_standings(year).content[0]
-    constructor_standing = constructor_standings[["position", "points", "wins", "constructorName"]].reset_index(drop=True)
-    mapped_name = team_mapping[constructor_name]
-    constructor_standing = constructor_standing[constructor_standing["constructorName"] == mapped_name]
-    suffix = "st" if constructor_standing['position'].iloc[0] == 1 else "nd" if constructor_standing['position'].iloc[0] == 2 else "rd" if constructor_standing['position'].iloc[0] == 3 else "th"
-    standings_string = f"{constructor_name} are {constructor_standing['position'].iloc[0]}{suffix} with {constructor_standing['points'].iloc[0]} points and {constructor_standing['wins'].iloc[0]} wins"
-    return standings_string
-
-def track_visualization(year: int, round: gp, visualization_type: str, driver_name: str) -> Image.Image:
-    """Generate a visualization of the track with specified data.
-    
-    Args:
-        year (int): The season year
-        round (str | int): The race round number or name
-        visualization_type (str): Type of visualization ('speed', 'corners', or 'gear')
-        driver_name (str): Name of the driver for driver-specific visualizations
-        
-    Returns:
-        Image.Image: A PIL Image object containing the visualization
-    """
-
-    session = get_session(year, round, "race")
-    session.load()
-
-    if visualization_type == "speed":
-        return track_utils.create_track_speed_visualization(session, driver_name)
-    elif visualization_type == "corners":
-        return track_utils.create_track_corners_visualization(session)
-    elif visualization_type == "gear":
-        return track_utils.create_track_gear_visualization(session)
-
-def get_session_results(year: int, round: gp, session_type: session_type) -> pd.DataFrame:
-    """Retrieve and format the results of a specific session.
-    
-    Args:
-        year (int): The season year
-        round (str | int): The race round number or name
-        session_type (str | int | None): Type of session (e.g., 'Q', 'R', 'Sprint')
-        
-    Returns:
-        pd.DataFrame: DataFrame containing the session results
-        
-    Raises:
-        gr.Error: If the session type is not supported for the specified round
-    """
-
-    try:
-        session = get_session(year, round, session_type)
-        session.load(telemetry=False)
-        results = session.results
-    except ValueError as e:
-        raise gr.Error(f"Session type {session_type} is not supported for the specified round. This Grand Prix most likely did not include a sprint race/quali.")
-
-    df = results[["DriverNumber", "Abbreviation", "FullName", "Position", "GridPosition", "Points", "Status", "Q1", "Q2", "Q3"]]
-    df["Name"] = df.apply(lambda row: f"{row['FullName']} ({row['Abbreviation']} • {row['DriverNumber']})", axis=1)
-    df = df.drop(columns=["FullName", "Abbreviation", "DriverNumber"])
-    df = df.rename(columns={"Position": "Pos", "GridPosition": "Grid Pos"})
-
-    # Process results based on session type
-    if session_type in ["race", "sprint"]:
-        df = df[["Pos", "Name", "Points", "Grid Pos", "Status"]]
-    elif "qualifying" in session_type:
-        df[["Q1", "Q2", "Q3"]] = df[["Q1", "Q2", "Q3"]].apply(lambda x: x.dt.total_seconds().apply(lambda y: f"{int(y//60):02d}:{int(y%60):02d}.{int(y%1*1000):03d}" if pd.notna(y) else "-"))
-        df = df[["Pos", "Name", "Q1", "Q2", "Q3"]]
-    return df
-
-def get_driver_info(driver_name: str) -> str:
-    """Retrieve detailed information about a specific driver.
-    
-    Args:
-        driver_name (str): Full name of the driver (e.g., 'Max Verstappen')
-        
-    Returns:
-        str: Formatted string with driver's details including name, team, number,
-             nationality, and a brief summary
-    """
-    driver = DRIVER_DETAILS[driver_name]
-    driver_info_string = f"{driver_name} ({driver['birth_date']})\n{driver['team']} #{driver['number']}\n{driver['nationality']}\n\n{driver['summary']}"
-    return driver_info_string
-    
-### OpenF1 tools ###
-
-
-
-
-
-if __name__ == "__main__":
-    session = get_session(2024, 1, "fp1")
-    session.load()

utils/request_utils.py

@@ -1 +0,0 @@
-""" Utils file for handling OpenF1 requests """