Ticketera APIshop.ticketera.com ↗

"""
Ticketera Empty Seats API Client

This module provides a client for interacting with the Ticketera Empty Seats API,
which allows you to search for events, get detailed event information, and check
available seats for performances in Puerto Rico.

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

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


class ParseClient:
    """Client for interacting with the Ticketera Empty Seats API via Parse."""

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

        Args:
            api_key: API key for authentication. If not provided, will use
                     PARSE_API_KEY environment variable.

        Raises:
            ValueError: If no API key is provided and PARSE_API_KEY is not set.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "c9047e7d-d98b-4ce1-a2c5-5afa9be87ee9"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")
        if not self.api_key:
            raise ValueError(
                "API key not provided. Set PARSE_API_KEY environment variable or pass api_key parameter."
            )

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

        Args:
            endpoint: The endpoint name (e.g., 'search_events')
            method: HTTP method ('GET' or 'POST')
            **params: Query parameters or request body parameters

        Returns:
            Parsed JSON response from the API

        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"}

        if method.upper() == "GET":
            response = requests.get(url, headers=headers, params=params)
        else:
            response = requests.post(url, headers=headers, json=params)

        response.raise_for_status()
        return response.json()

    def search_events(self, query: str) -> Dict[str, Any]:
        """
        Search for events on Ticketera by keyword.

        Args:
            query: Search keyword (e.g., 'basketball', 'concierto').
                   Use empty string for all events.

        Returns:
            Dictionary containing search results with event information
        """
        return self._call("search_events", method="GET", query=query)

    def get_event_details(
        self, event_slug: str, shop_domain: Optional[str] = None
    ) -> Dict[str, Any]:
        """
        Get detailed event information including seating and ticket details.

        Args:
            event_slug: Event slug from search results
            shop_domain: Shop domain hosting the event (auto-detected if not specified)

        Returns:
            Dictionary containing detailed event information
        """
        params = {"event_slug": event_slug}
        if shop_domain:
            params["shop_domain"] = shop_domain
        return self._call("get_event_details", method="GET", **params)

    def get_empty_seats(
        self, event_slug: str, shop_domain: Optional[str] = None
    ) -> Dict[str, Any]:
        """
        Get all empty (available) seats for a seated event.

        Args:
            event_slug: Event slug from search results
            shop_domain: Shop domain hosting the event (auto-detected if not specified)

        Returns:
            Dictionary containing available seats information
        """
        params = {"event_slug": event_slug}
        if shop_domain:
            params["shop_domain"] = shop_domain
        return self._call("get_empty_seats", method="GET", **params)


def main():
    """Demonstrate a practical workflow: search events and check seat availability."""
    client = ParseClient()

    print("=" * 70)
    print("TICKETERA EVENT AVAILABILITY CHECKER")
    print("=" * 70)

    # Step 1: Search for events
    search_query = "basketball"
    print(f"\n🔍 Searching for '{search_query}' events...\n")

    search_results = client.search_events(query=search_query)
    total_events = search_results.get("data", {}).get("total", 0)
    events = search_results.get("data", {}).get("results", [])

    print(f"Found {total_events} event(s)\n")

    if not events:
        print("No events found. Try a different search query.")
        return

    # Step 2: Process each event
    for idx, event in enumerate(events, 1):
        event_name = event.get("name", "Unknown Event")
        event_slug = event.get("event_slug")
        venue = event.get("venue", "Unknown Venue")
        category = event.get("category", "Unknown Category")
        date_html = event.get("date_html", "Date not available")
        ticket_url = event.get("ticket_url", "")

        print(f"\n{'─' * 70}")
        print(f"EVENT {idx}: {event_name}")
        print(f"{'─' * 70}")
        print(f"📍 Venue: {venue}")
        print(f"🏷️  Category: {category}")
        print(f"📅 Date: {date_html}")

        if not event_slug:
            print("⚠️  Event slug not available - skipping details")
            continue

        try:
            # Step 3: Get detailed event information
            print("\n📋 Fetching event details...")
            event_details = client.get_event_details(event_slug=event_slug)
            data = event_details.get("data", {})

            # Display event timing
            start_time = data.get("start", "N/A")
            end_time = data.get("end", "N/A")
            timezone = data.get("timezone", "N/A")
            print(f"   ⏰ Start: {start_time}")
            print(f"   ⏰ End: {end_time}")
            print(f"   🌍 Timezone: {timezone}")

            # Display location information
            location = data.get("location", {})
            if location and any(location.values()):
                print(f"\n   📌 Location:")
                if location.get("address"):
                    print(f"      Address: {location.get('address')}")
                if location.get("city"):
                    print(f"      City: {location.get('city')}")
                if location.get("country"):
                    print(f"      Country: {location.get('country')}")

            # Display seating categories
            categories = data.get("categories", [])
            if categories:
                print(f"\n   🪑 Seating Categories:")
                for cat in categories:
                    cat_name = cat.get("name", "Unknown")
                    total_seats = cat.get("total_seats", 0)
                    print(f"      - {cat_name}: {total_seats} seats")

            # Display available ticket types and prices
            tickets = data.get("tickets", [])
            if tickets:
                print(f"\n   🎫 Available Ticket Types:")
                for ticket in tickets:
                    ticket_name = ticket.get("name", "Unknown")
                    price = ticket.get("price", 0)
                    active = ticket.get("active", False)
                    status = "✓ Available" if active else "✗ Not Available"
                    print(f"      - {ticket_name}: ${price:.2f} ({status})")

            # Step 4: Get seat availability if event has seating
            seating_info = data.get("seating", {})
            if seating_info and seating_info.get("active"):
                print("\n📊 Checking seat availability...")
                empty_seats_data = client.get_empty_seats(event_slug=event_slug)
                seats_info = empty_seats_data.get("data", {})

                total_seats_map = seats_info.get("total_seats_in_map", 0)
                empty_seats_count = seats_info.get("empty_seats_count", 0)
                booked_seats_count = seats_info.get("booked_seats_count", 0)
                sold_out = seats_info.get("sold_out", False)

                occupancy_percent = (
                    (booked_seats_count / total_seats_map * 100)
                    if total_seats_map > 0
                    else 0
                )

                print(f"   Total Capacity: {total_seats_map} seats")
                print(
                    f"   Available: {empty_seats_count} seats ({100 - occupancy_percent:.1f}% free)"
                )
                print(f"   Booked: {booked_seats_count} seats ({occupancy_percent:.1f}% full)")

                if sold_out:
                    print(f"   ⛔ EVENT SOLD OUT")
                else:
                    # Show availability by section
                    section_summary = seats_info.get("section_summary", {})
                    if section_summary:
                        print(f"\n   🗂️  Availability by Section:")
                        for section, count in sorted(
                            section_summary.items(), key=lambda x: str(x[0])
                        ):
                            print(f"      Section {section}: {count} empty seats")

                    # Show sample of available seats
                    empty_seats = seats_info.get("empty_seats", [])
                    if empty_seats:
                        print(f"\n   📍 Sample Available Seats (first 5 of {len(empty_seats)}):")
                        for seat in empty_seats[:5]:
                            section = seat.get("section", "?")
                            row = seat.get("row", "?")
                            seat_num = seat.get("seat", "?")
                            category = seat.get("category", "?")
                            print(
                                f"      • Section {section}, Row {row}, Seat {seat_num} ({category})"
                            )
                        if len(empty_seats) > 5:
                            print(f"      ... and {len(empty_seats) - 5} more available seats")

                        if ticket_url:
                            print(f"\n   🔗 Get Tickets: {ticket_url}")
            else:
                print("   ℹ️  This event does not have assigned seating")

        except requests.exceptions.RequestException as e:
            print(f"   ❌ Error fetching event details: {e}")
        except Exception as e:
            print(f"   ❌ Unexpected error: {e}")

    print(f"\n{'=' * 70}")
    print("✅ Availability check complete!")
    print("=" * 70)


if __name__ == "__main__":
    main()