TAB APItab.com.au ↗

"""
TAB Australia API Client
Horse racing data, sports betting odds, and account information from TAB.com.au

Get your API key from: https://parse.bot/settings
"""

import os
import requests
from typing import Optional, Any, Dict, List
from datetime import datetime


class ParseClient:
    """Client for interacting with the TAB Australia API via Parse."""

    def __init__(self, api_key: Optional[str] = None):
        """
        Initialize the Parse API client.

        Args:
            api_key: API key for authentication. If not provided, reads from PARSE_API_KEY env var.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "38bc6ea2-d123-477f-bf57-9b9312f634d8"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")
        self.session_id: Optional[str] = None
        self.encryption_key: Optional[str] = None

        if not self.api_key:
            raise ValueError("API key must be provided or set as PARSE_API_KEY environment variable")

    def _call(
        self,
        endpoint: str,
        method: str = "POST",
        **params
    ) -> Dict[str, Any]:
        """
        Make an API call to the Parse scraper.

        Args:
            endpoint: The endpoint name (e.g., "get_racing_meetings_by_date")
            method: HTTP method ("GET" or "POST")
            **params: Parameters to pass to the endpoint

        Returns:
            Response data as a dictionary

        Raises:
            requests.exceptions.RequestException: If the API call fails
        """
        url = f"{self.base_url}/scraper/{self.scraper_id}/{endpoint}"
        headers = {
            "X-API-Key": self.api_key,
            "Content-Type": "application/json"
        }

        # Add session info if available
        if self.session_id:
            params["sessionId"] = self.session_id
        if self.encryption_key:
            params["encryptionKey"] = self.encryption_key

        try:
            if method == "GET":
                response = requests.get(url, headers=headers, params=params)
            elif method == "POST":
                response = requests.post(url, headers=headers, json=params)
            else:
                raise ValueError(f"Unsupported HTTP method: {method}")

            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"API Error calling {endpoint}: {e}")
            raise

    def login(self, username: str, password: str) -> Dict[str, Any]:
        """
        Authenticate a user to obtain a session token.

        Args:
            username: Account username
            password: Account password

        Returns:
            Response containing accessToken and user info
        """
        response = self._call(
            "login",
            method="POST",
            username=username,
            password=password
        )

        # Store session info for subsequent calls
        if "accessToken" in response:
            self.session_id = response.get("accessToken")

        return response

    def get_racing_meetings_by_date(
        self,
        date: Optional[str] = None,
        jurisdiction: str = "NSW"
    ) -> List[Dict[str, Any]]:
        """
        Retrieve all racing meetings for a given date.

        Args:
            date: Date in YYYY-MM-DD format. Defaults to today.
            jurisdiction: State jurisdiction code (NSW, VIC, QLD, etc.)

        Returns:
            List of meeting objects
        """
        params = {"jurisdiction": jurisdiction}
        if date:
            params["date"] = date

        response = self._call(
            "get_racing_meetings_by_date",
            method="GET",
            **params
        )
        return response.get("meetings", [])

    def get_next_to_jump_races(self) -> List[Dict[str, Any]]:
        """
        Retrieve the next races to jump across all venues and race types.

        Returns:
            List of race objects with startTime and raceName
        """
        response = self._call(
            "get_next_to_jump_races",
            method="GET"
        )
        return response.get("races", [])

    def get_race_card(
        self,
        date: str,
        venue_code: str,
        venue: str,
        race_number: int,
        race_type: str
    ) -> Dict[str, Any]:
        """
        Retrieve full race card/details for a specific race.

        Args:
            date: Race date (YYYY-MM-DD)
            venue_code: Venue code
            venue: Venue name slug
            race_number: Race number
            race_type: Race type (thoroughbred, harness, greyhound)

        Returns:
            Race card with raceName and runners list
        """
        return self._call(
            "get_race_card",
            method="GET",
            date=date,
            venue_code=venue_code,
            venue=venue,
            race_number=race_number,
            race_type=race_type
        )

    def get_race_fixed_odds(
        self,
        date: str,
        venue_code: str,
        venue: str,
        race_number: int,
        race_type: str
    ) -> List[Dict[str, Any]]:
        """
        Retrieve current fixed odds for a specific race.

        Args:
            date: Race date (YYYY-MM-DD)
            venue_code: Venue code
            venue: Venue name slug
            race_number: Race number
            race_type: Race type

        Returns:
            List of fixed odds with runnerNumber, winPrice, and placePrice
        """
        response = self._call(
            "get_race_fixed_odds",
            method="GET",
            date=date,
            venue_code=venue_code,
            venue=venue,
            race_number=race_number,
            race_type=race_type
        )
        return response.get("fixedOdds", [])

    def get_race_results(
        self,
        date: str,
        venue_code: str,
        venue: str,
        race_number: int,
        race_type: str
    ) -> Dict[str, Any]:
        """
        Retrieve final results for a completed race.

        Args:
            date: Race date (YYYY-MM-DD)
            venue_code: Venue code
            venue: Venue name slug
            race_number: Race number
            race_type: Race type

        Returns:
            Results with finishing positions and dividends
        """
        return self._call(
            "get_race_results",
            method="GET",
            date=date,
            venue_code=venue_code,
            venue=venue,
            race_number=race_number,
            race_type=race_type
        )

    def get_account_balance(self) -> float:
        """
        Retrieve the authenticated user's account balance.
        Requires prior login.

        Returns:
            Available balance as a float
        """
        response = self._call(
            "get_account_balance",
            method="GET"
        )
        return response.get("availableBalance", 0.0)


if __name__ == "__main__":
    # Initialize client with API key from environment
    client = ParseClient()

    print("=" * 60)
    print("TAB Australia Racing API - Practical Workflow Example")
    print("=" * 60)

    # Step 1: Check upcoming races
    print("\n[1] Getting next races to jump...")
    next_races = client.get_next_to_jump_races()

    if next_races:
        upcoming_race = next_races[0]
        print(f"   Next race: {upcoming_race.get('raceName')} at {upcoming_race.get('startTime')}")

    # Step 2: Get today's meetings
    print("\n[2] Getting today's racing meetings (NSW)...")
    today = datetime.now().strftime("%Y-%m-%d")
    meetings = client.get_racing_meetings_by_date(date=today, jurisdiction="NSW")

    if meetings:
        print(f"   Found {len(meetings)} meetings:")
        for meeting in meetings[:3]:  # Show first 3
            print(f"   - {meeting.get('meetingName')} ({meeting.get('venueCode')})")

        # Step 3: Get race card for first meeting
        if meetings:
            first_meeting = meetings[0]
            venue_code = first_meeting.get("venueCode", "R")
            venue_slug = first_meeting.get("meetingName", "RANDWICK").lower()

            print(f"\n[3] Getting race card for Race 1 at {first_meeting.get('meetingName')}...")
            try:
                race_card = client.get_race_card(
                    date=today,
                    venue_code=venue_code,
                    venue=venue_slug,
                    race_number=1,
                    race_type="R"
                )

                race_name = race_card.get("raceName", "Race 1")
                runners = race_card.get("runners", [])
                print(f"   Race: {race_name}")
                print(f"   Runners ({len(runners)}):")
                for runner in runners[:5]:  # Show first 5 runners
                    print(f"     - #{runner.get('number')}: {runner.get('name')}")

                # Step 4: Get odds for this race
                print(f"\n[4] Getting fixed odds for Race 1...")
                odds = client.get_race_fixed_odds(
                    date=today,
                    venue_code=venue_code,
                    venue=venue_slug,
                    race_number=1,
                    race_type="R"
                )

                print(f"   Found {len(odds)} odds entries:")
                for odd in odds[:3]:  # Show first 3
                    runner_num = odd.get("runnerNumber")
                    win_price = odd.get("winPrice")
                    place_price = odd.get("placePrice")
                    print(f"     - Runner {runner_num}: Win ${win_price:.2f}, Place ${place_price:.2f}")

            except Exception as e:
                print(f"   (Unable to fetch detailed race info: {e})")

    # Step 5: Authentication flow (commented out without valid credentials)
    print("\n[5] Authentication Example (requires valid credentials):")
    print("   To access account balance, login with:")
    print("   >>> client.login(username='your_username', password='your_password')")
    print("   >>> balance = client.get_account_balance()")
    print("   >>> print(f'Account Balance: ${balance:.2f}')")

    print("\n" + "=" * 60)
    print("Workflow completed successfully!")
    print("=" * 60)