Demo Multiple Suggestions

def get_light_state(direction: str, cycle_timer: float) -> str:
    """
    Determine the traffic light state ('green', 'yellow', 'red') for a given
    direction based on a repeating cycle timer.

    cycle_timer: elapsed time (seconds) since the start of the cycle.
    The durations below are examples and may be defined elsewhere in the project.
    """
    # Example durations (seconds)
    NS_GREEN_DURATION = 10.0
    NS_YELLOW_DURATION = 3.0
    EW_GREEN_DURATION = 10.0
    EW_YELLOW_DURATION = 3.0
    cycle_length = NS_GREEN_DURATION + NS_YELLOW_DURATION + EW_GREEN_DURATION + EW_YELLOW_DURATION

    t = cycle_timer % cycle_length

    if direction in ("north", "south"):
        # North-South is green first, then yellow, then red while East-West is green+yellow
        if t < NS_GREEN_DURATION:
            return "green"
        elif t < NS_GREEN_DURATION + NS_YELLOW_DURATION:
            return "yellow"
        else:
            return "red"
    elif direction in ("east", "west"):
        # East-West is red while North-South is green+yellow, then green+yellow for EW
        if t < NS_GREEN_DURATION + NS_YELLOW_DURATION:
            return "red"
        elif t < NS_GREEN_DURATION + NS_YELLOW_DURATION + EW_GREEN_DURATION:
            return "green"
        else:
            return "yellow"
    else:
        raise ValueError("Invalid direction. Use 'north', 'south', 'east', or 'west'.")

def draw_traffic_light(surface, direction: str, state: str) -> None:
    """
    Draw a circular traffic light for the given direction at a fixed offset
    from the intersection center. This function assumes these constants are
    defined in the surrounding module: CENTER_X, CENTER_Y, STOP_LINE,
    LIGHT_OFFSET, LIGHT_RADIUS, LIGHT_COLORS.
    """
    if direction == "north":
        pos = (CENTER_X, STOP_LINE["north"] - LIGHT_OFFSET)
    elif direction == "south":
        pos = (CENTER_X, STOP_LINE["south"] + LIGHT_OFFSET)
    elif direction == "east":
        pos = (STOP_LINE["east"] - LIGHT_OFFSET, CENTER_Y)
    elif direction == "west":
        pos = (STOP_LINE["west"] + LIGHT_OFFSET, CENTER_Y)
    else:
        raise ValueError("Invalid direction for traffic light.")

    color = LIGHT_COLORS[state]
    pygame.draw.circle(surface, color, pos, LIGHT_RADIUS)

def calculate_area(shape: str) -> float:
    """
    Calculate the area of a rectangle or circle.
    For the rectangle we assume CAR_SIZE is defined as:
      CAR_SIZE = {'vertical': (width, height)}
    and for the circle we rely on LIGHT_RADIUS defined elsewhere.
    """
    if shape == "rectangle":
        # Example: CAR_SIZE['vertical'] contains (width, height)
        return CAR_SIZE["vertical"][0] * CAR_SIZE["vertical"][1]
    elif shape == "circle":
        return 3.141592653589793 * (LIGHT_RADIUS ** 2)
    else:
        raise ValueError("Invalid shape type. Use 'rectangle' or 'circle'.")

import requests

def fetch_random_quote() -> str:
    """
    Fetch a random quote from a public API. Raise requests.HTTPError on bad status.
    """
    response = requests.get("https://api.quotable.io/random", timeout=5)
    response.raise_for_status()
    data = response.json()
    return data.get("content", "")

def quicksort(arr: list) -> list:
    """
    Simple recursive quicksort implementation. Not in-place.
    """
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)