Skip to content
TheChatArchiveThe Chat Archive
GLMGLM-5 / Pony Alpha· unknownHugging Face Frontier Reasoning Traces

Create a Python program to fetch and display live sports scores.

  1. User

    Create a Python program to fetch and display live sports scores.

  2. GLM Assistant

    The user wants a Python program to fetch and display live sports scores. There is no specific sport mentioned (e.g., NBA, NFL, Soccer). There is no specific API mentioned. There are no specific GUI requirements mentioned (CLI vs. GUI).

    Options:

    1. Web Scraping: Use BeautifulSoup to scrape ESPN or similar sites.
      • Pros: No API key needed immediately.
      • Cons: Fragile (HTML changes), against TOS of many sites, harder to handle live updates efficiently without rate limiting issues.
    2. Public API (Free/Trial): Use a dedicated sports API.
      • Examples: TheScore (rarely public), SportRadar, API-Football, Balldontlie (NBA), TheSportsDB.
      • Pros: Structured data, reliable.
      • Cons: Most require an API Key. I should choose one that is relatively easy to get or has a demo key/historical data that works without a user signing up immediately for the demonstration to work.
    3. GUI vs. CLI: A GUI looks much better for "displaying" scores. A CLI is simpler to code.
      • Decision: I will provide a CLI version for simplicity and robustness (easier to copy-paste), but I will use a nice library like rich or tabulate to make it look good. Or, I can write a simple Tkinter app.
      • Better Decision: Let's go with a CLI approach using a free API. It's the most practical for a generic "fetch scores" request.

    Choosing the API:

    • Balldontlie: Great for NBA, but requires a key now.
    • TheSportsDB: Good, free, but sometimes slow or limited on "live" data for free tiers.
    • API-NBA/Football: Require keys.
    • ESPN: ESPN has hidden/informal APIs that are often used for these types of scripts because they don't require keys. Specifically, their scoreboard API (http://site.api.espn.com/apis/site/v2/sports/basketball/nba/scoreboard).
      • Risk: It's an internal API, not documented for public use, so it might break.
      • Alternative: requests to a specific public API.

    Let's stick to a specific sport to make the example concrete, or offer a generic structure. NBA or Football (Soccer) are popular. Let's do NBA or NFL or Soccer. Actually, the ESPN core API is a very common target for Python scripts because it covers all sports and requires no key for basic score fetching.

    Plan:

    1. Use the requests library.
    2. Target the ESPN API (it's robust enough for a demo).
    3. Let the user choose a sport (NBA, NFL, Soccer, etc.).
    4. Parse the JSON.
    5. Display it nicely.

    Code Structure:

    1. Import requests and datetime.
    2. Define a base URL.
    3. Function to fetch scores.
    4. Loop to display.

    Refining the ESPN API usage: URL format: https://site.api.espn.com/apis/site/v2/sports/{sport}/{league}/scoreboard Examples:

    • NBA: basketball/nba
    • NFL: football/nfl
    • Soccer (English Premier League): soccer/eng.1

    Implementation Details:

    • Need to handle network errors.
    • Need to format the time/status (Quarter, Final, Halftime).
    • Display Team names and Scores.

    Constraint Checklist & Confidence Score:

    1. Fetch scores? Yes.
    2. Display scores? Yes.
    3. Live? (As live as the API allows, usually near real-time). Yes. Confidence Score: 5/5.

    Mental Sandbox Simulation:

    • User runs code.
    • Prompt asks "Which sport?".
    • Code hits ESPN.
    • Prints "Lakers vs Warriors 110 - 105 (Final)".
    • Looks good.

    I will provide a solution that uses the ESPN API because it is the most reliable way to get scores without forcing the user to sign up for a developer account (like RapidAPI) just to test the code. I will also add a disclaimer that this relies on an unofficial API endpoint.

    Code steps:

    1. import requests
    2. Define a dictionary mapping short names (nba, nfl) to ESPN URL slugs.
    3. Fetch data.
    4. Iterate through events.
    5. Extract competitions.
    6. Extract team names, scores, and status.
    7. Print.

    I'll also add tabulate if the user has it, but stick to standard formatting to ensure it runs without extra non-essential installs (besides requests).

    Let's write the code.

    Self-Correction during drafting: Should I add a "refresh" feature? Yes, a simple loop that refreshes every 60 seconds would be cool. But maybe just a simple fetch is safer to start. I'll add a simple loop with a sleep timer to demonstrate "live" updating.

    Final Polish: Make sure to handle the case where no games are scheduled today. The API returns an empty event list.

    Drafting the response:

    1. Prerequisites (Python, requests).
    2. The Code.
    3. Explanation of how it works.
    4. How to extend it (other sports).

    Let's stick to a CLI tool. It's the most versatile.

    Sport Keys for ESPN:

    • NBA: basketball/nba
    • NFL: football/nfl
    • MLB: baseball/mlb
    • Men's College Basketball: basketball/mens-college-basketball
    • Premier League: soccer/eng.1

    I will include a menu for these.

    One tricky part: The ESPN API date format. Usually, you don't need to specify the date to get "today's" games, but sometimes it helps. The root endpoint usually defaults to current/most recent scoreboard window.

    Let's proceed. To create a robust program that fetches live scores, the best approach is to use a data provider. For a Python demonstration, the easiest provider to use without cumbersome API key registration is ESPN, which provides public JSON endpoints for major sports (NBA, NFL, MLB, NHL, Soccer, etc.).

    Prerequisites

    You will need the requests library to fetch the data from the web. Install it via your terminal:

    pip install requests
    

    The Python Program

    This script uses the unofficial ESPN API to fetch live data. It allows you to select a sport and displays the scores, updating automatically every 30 seconds.

    import requests
    import time
    import os
    import sys
    
    # Configuration for ESPN Public API
    SPORTS_CONFIG = {
        "1": {"name": "NBA (Basketball)", "endpoint": "basketball", "league": "nba"},
        "2": {"name": "NFL (American Football)", "endpoint": "football", "league": "nfl"},
        "3": {"name": "MLB (Baseball)", "endpoint": "baseball", "league": "mlb"},
        "4": {"name": "NHL (Hockey)", "endpoint": "hockey", "league": "nhl"},
        "5": {"name": "English Premier League", "endpoint": "soccer", "league": "eng.1"},
    }
    
    def clear_screen():
        """Clears the console screen based on the operating system."""
        os.system('cls' if os.name == 'nt' else 'clear')
    
    def get_scores(sport_key):
        """Fetches live score data from the ESPN API."""
        config = SPORTS_CONFIG[sport_key]
        url = f"http://site.api.espn.com/apis/site/v2/sports/{config['endpoint']}/{config['league']}/scoreboard"
        
        try:
            response = requests.get(url, timeout=10)
            response.raise_for_status() # Raise error for bad status codes
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"Error fetching data: {e}")
            return None
    
    def display_scores(data):
        """Parses the JSON data and prints it in a readable format."""
        if not data or 'events' not in data:
            print("No games found or data unavailable.")
            return
    
        clear_screen()
        print(f"--- LIVE SCORES: {data['leagues'][0]['name']} ---")
        print(f"Updated: {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
    
        found_games = False
        
        for event in data['events']:
            status = event['status']['type']['shortDetail'] # e.g., "Final", "9:07 3rd Quarter"
            home_team = event['competitions'][0]['competitors'][1]['team']['abbreviation']
            away_team = event['competitions'][0]['competitors'][0]['team']['abbreviation']
            
            home_score = event['competitions'][0]['competitors'][1]['score']
            away_score = event['competitions'][0]['competitors'][0]['score']
    
            # Determine the winner for styling (optional)
            winner = ""
            if "Final" in status:
                if int(home_score) > int(away_score):
                    winner = "(W)"
            
            print(f"{away_team} vs {home_team}")
            print(f"  Score: {away_score} - {home_score} {winner}")
            print(f"  Status: {status}")
            print("-" * 40)
            found_games = True
    
        if not found_games:
            print("No scheduled games today.")
    
    def main():
        print("Welcome to the Live Sports Score Tracker")
        print("Please select a league:")
        
        for key, val in SPORTS_CONFIG.items():
            print(f"[{key}] {val['name']}")
        
        choice = input("\nEnter number: ").strip()
        
        if choice not in SPORTS_CONFIG:
            print("Invalid selection. Exiting.")
            sys.exit()
    
        print(f"\nFetching {SPORTS_CONFIG[choice]['name']} scores... (Press Ctrl+C to stop)")
        time.sleep(2)
    
        try:
            while True:
                data = get_scores(choice)
                display_scores(data)
                
                # Wait 30 seconds before refreshing
                print("\nNext update in 30 seconds...")
                time.sleep(30)
                
        except KeyboardInterrupt:
            print("\nExiting tracker. Goodbye!")
    
    if __name__ == "__main__":
        main()
    

    How It Works

    1. Endpoints: The script constructs a URL based on your selection (e.g., http://site.api.espn.com/apis/site/v2/sports/basketball/nba/scoreboard).
    2. Data Fetching: It uses requests.get() to retrieve the data in JSON format.
    3. Parsing: It loops through the events list in the JSON to find the teams, scores, and game status (e.g., "Top of 5th", "Final", "10:34 3rd Quarter").
    4. Live Loop: The while True loop combined with time.sleep(30) refreshes the data automatically every half-minute.

    Notes on Usage

    • No Games? If there are no games scheduled on the current day (off-season or no game days), the API will return an empty list. The script handles this gracefully by saying "No scheduled games today."
    • API Limitations: This uses an unofficial public interface. It is sufficient for personal hobby projects, but for a commercial application, you would need an official API key (like SportRadar or The Odds API).

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.