Páginas de perfil de pilotos com estatísticas de carreira

Apps de fãs, jogos de fantasy e sites de notícias precisam de uma página por piloto. Duas chamadas dão tudo para um cartão de perfil: o piloto e os totais de carreira.

As duas chamadas

GET /riders/93
GET /riders/93/career-stats

/riders/{rider_number} retorna o perfil:

{
  "rider_number": 93,
  "full_name": "Marc Márquez",
  "nationality": "Spain",
  "flag": "🇪🇸",
  "birth_date": "1993-02-17",
  "height_cm": 168,
  "weight_kg": 59,
  "team_name": "Gresini Racing MotoGP",
  "image_url": null
}

/riders/{rider_number}/career-stats retorna os totais:

{
  "rider_number": 93,
  "rider_name": "Marc Márquez",
  "total_wins": 44,
  "total_podiums": 66,
  "total_points": 1302,
  "world_titles": 2,
  "total_races": 118
}

Os totais de carreira são calculados a partir das temporadas disponíveis na API, não da carreira inteira do piloto. Rotule-os de acordo, por exemplo “Desde 2024”.

Busque os dois em paralelo

import os
from concurrent.futures import ThreadPoolExecutor
from dataclasses import dataclass
from datetime import date

import requests

HOST = "motogp-api-championship-data-statistics.p.rapidapi.com"
HEADERS = {"X-RapidAPI-Key": os.environ["RAPIDAPI_KEY"], "X-RapidAPI-Host": HOST}


def get(path: str) -> dict:
    res = requests.get(f"https://{HOST}{path}", headers=HEADERS, timeout=10)
    res.raise_for_status()
    return res.json()["data"]


@dataclass(frozen=True)
class RiderCard:
    number: int
    name: str
    flag: str
    team: str
    age: int
    wins: int
    podiums: int
    titles: int
    races: int

    @property
    def podium_rate(self) -> float:
        return self.podiums / self.races if self.races else 0.0


def age_on(birth: str, today: date) -> int:
    born = date.fromisoformat(birth)
    return today.year - born.year - ((today.month, today.day) < (born.month, born.day))


def rider_card(number: int) -> RiderCard:
    with ThreadPoolExecutor(max_workers=2) as pool:
        profile_f = pool.submit(get, f"/riders/{number}")
        stats_f = pool.submit(get, f"/riders/{number}/career-stats")
        profile, stats = profile_f.result(), stats_f.result()
    return RiderCard(
        number=profile["rider_number"],
        name=profile["full_name"],
        flag=profile["flag"],
        team=profile["team_name"],
        age=age_on(profile["birth_date"], date.today()),
        wins=stats["total_wins"],
        podiums=stats["total_podiums"],
        titles=stats["world_titles"],
        races=stats["total_races"],
    )


card = rider_card(93)
print(f"{card.flag} #{card.number} {card.name} — {card.team}, {card.age}")
print(f"{card.wins} wins, {card.podiums} podiums in {card.races} races ({card.podium_rate:.0%})")

Crie as páginas de índice

As páginas de perfil precisam de uma lista de onde partir:

Página	Endpoint
Grid desta temporada	GET /riders/seasons/{year}?category=MOTOGP
Pilotos por país	GET /riders/nationality/{nationality} (ex.: Italy)
Todos os pilotos do banco de dados	GET /riders?page=1&size=200

Use rider_number como slug da URL (/riders/93/); é o que os fãs pesquisam.

Trate dados ausentes

• image_url pode ser null. Mostre o número de corrida em um selo colorido em vez de uma imagem quebrada.
• Um número que não está em uso retorna 404 — renderize uma página de “piloto não encontrado” em vez de um erro.
• Pilotos às vezes mudam de número entre temporadas. Se você guarda favoritos, guarde o número junto com a temporada de onde ele veio.