Psel APIpsel.com ↗

"""
Parions Sport En Ligne API Client
Extract sports events, odds, and betting options from FDJ.
Get your API key from: https://parse.bot/settings
"""

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


class ParseClient:
    """Client for Parions Sport En Ligne API via Parse Bot."""

    def __init__(self, api_key: Optional[str] = None):
        """
        Initialize the Parse API client.
        
        Args:
            api_key: API key for Parse Bot. If not provided, reads from PARSE_API_KEY env var.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "cb45c7d4-f595-4c57-b39a-35101b53a751"
        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 an API call to the Parse Bot scraper.
        
        Args:
            endpoint: The endpoint name (e.g., 'get_sports')
            method: HTTP method ('GET' or 'POST')
            **params: Query/body parameters
            
        Returns:
            Parsed JSON response
            
        Raises:
            requests.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"
        }
        
        try:
            if method.upper() == "GET":
                response = requests.get(url, headers=headers, params=params, timeout=30)
            elif method.upper() == "POST":
                response = requests.post(url, headers=headers, json=params, timeout=30)
            else:
                raise ValueError(f"Unsupported HTTP method: {method}")
            
            response.raise_for_status()
            return response.json()
        except requests.RequestException as e:
            print(f"API Error: {e}")
            raise

    def get_sports(self) -> Dict[str, Any]:
        """
        Fetch list of available sports, categories, and competitions.
        
        Returns:
            Dictionary containing sports, categories, and competitions.
        """
        return self._call("get_sports", method="GET")

    def search_events(self, sport_id: Optional[str] = None, limit: Optional[int] = None) -> Dict[str, Any]:
        """
        Search for upcoming sports events.
        
        Args:
            sport_id: Optional sport ID to filter events (e.g., '240' for Football)
            limit: Optional maximum number of events to return
            
        Returns:
            Dictionary containing upcoming events with details and betting markets.
        """
        params = {}
        if sport_id:
            params["sport_id"] = sport_id
        if limit:
            params["limit"] = limit
        
        return self._call("search_events", method="GET", **params)

    def get_live_events(self, limit: Optional[int] = None) -> Dict[str, Any]:
        """
        Retrieve currently live sports events with their top betting markets.
        
        Args:
            limit: Optional maximum number of live events to return
            
        Returns:
            Dictionary containing live events and available betting markets.
        """
        params = {}
        if limit:
            params["limit"] = limit
        
        return self._call("get_live_events", method="GET", **params)


def main():
    """Demonstrate practical workflow with the API."""
    
    # Initialize the client
    client = ParseClient()
    
    print("=" * 70)
    print("PARIONS SPORT EN LIGNE - Sports Events & Betting Info")
    print("=" * 70)
    
    # Step 1: Fetch available sports and competitions
    print("\n[Step 1] Fetching available sports and competitions...")
    sports_data = client.get_sports()
    
    sports_list = []
    if sports_data.get("data"):
        data = sports_data["data"]
        
        if "sports" in data:
            sports_list = data["sports"]
            print(f"✓ Found {len(sports_list)} sports available:")
            
            # Display available sports with their IDs
            for sport in sports_list[:5]:
                print(f"  • {sport.get('title', 'Unknown')} (ID: {sport.get('id', 'N/A')})")
            
            if len(sports_list) > 5:
                print(f"  ... and {len(sports_list) - 5} more sports")
        
        if "competitions" in data:
            competitions = data["competitions"]
            print(f"\n✓ Found {len(competitions)} competitions across all sports")
    else:
        print("✗ No sports data available")
    
    # Step 2: Search for upcoming events in Football
    print("\n[Step 2] Searching for upcoming Football events...")
    football_id = "240"  # Football ID from the API spec
    events_data = client.search_events(sport_id=football_id, limit=10)
    
    if events_data.get("data") and "events" in events_data["data"]:
        events = events_data["data"]["events"]
        print(f"✓ Found {len(events)} upcoming Football events:")
        
        # Display event details and betting markets
        for i, event in enumerate(events[:3], 1):
            print(f"\n  {i}. {event.get('title', 'Unknown Event')}")
            print(f"     Start Time: {event.get('start_time', 'N/A')}")
            print(f"     League: {event.get('league', 'N/A')}")
            print(f"     Category: {event.get('category', 'N/A')}")
            
            # Show available betting markets
            if "markets" in event:
                markets = event["markets"]
                print(f"     Available Markets: {len(markets)}")
                
                for market in markets[:1]:  # Show first market
                    print(f"       • {market.get('desc', 'Market')} ({market.get('period', 'N/A')})")
                    
                    # Display outcomes and odds
                    if "outcomes" in market:
                        print(f"         Outcomes:")
                        for outcome in market["outcomes"]:
                            print(f"           - {outcome.get('desc', 'Unknown')}: {outcome.get('price', 'N/A')}")
        
        if len(events) > 3:
            print(f"\n  ... and {len(events) - 3} more Football events")
    else:
        print("✗ No Football events found")
    
    # Step 3: Get live events
    print("\n[Step 3] Fetching currently live events...")
    live_data = client.get_live_events(limit=5)
    
    if live_data.get("data") and "events" in live_data["data"]:
        live_events = live_data["data"]["events"]
        print(f"✓ Found {len(live_events)} live events:")
        
        for i, event in enumerate(live_events[:3], 1):
            print(f"\n  🔴 LIVE {i}. {event.get('title', 'Unknown')}")
            print(f"     Sport: {event.get('sport', 'N/A')}")
            print(f"     League: {event.get('league', 'N/A')}")
            print(f"     Start Time: {event.get('start_time', 'N/A')}")
            
            # Show top betting markets for live events
            if "markets" in event:
                markets = event["markets"]
                print(f"     Available Markets: {len(markets)}")
                
                for market in markets[:1]:  # Show first market
                    print(f"       • {market.get('desc', 'Market')} ({market.get('period', 'N/A')})")
                    
                    # Display outcomes and odds
                    if "outcomes" in market:
                        print(f"         Outcomes:")
                        for outcome in market["outcomes"]:
                            spread_info = f" (Spread: {outcome.get('spread', 0)})" if outcome.get('spread') else ""
                            print(f"           - {outcome.get('desc', 'Unknown')}: {outcome.get('price', 'N/A')}{spread_info}")
        
        if len(live_events) > 3:
            print(f"\n  ... and {len(live_events) - 3} more live events")
    else:
        print("✗ No live events currently available")
    
    # Step 4: Search events by different sport (Tennis)
    print("\n[Step 4] Searching for Tennis events...")
    tennis_id = "239"  # Tennis ID from the API spec
    tennis_events = client.search_events(sport_id=tennis_id, limit=5)
    
    if tennis_events.get("data") and "events" in tennis_events["data"]:
        events = tennis_events["data"]["events"]
        print(f"✓ Found {len(events)} upcoming Tennis events:")
        
        for event in events[:2]:
            print(f"  • {event.get('title', 'Unknown')}")
            print(f"    Category: {event.get('category', 'N/A')}")
            
            # Show if any markets have attractive odds
            if "markets" in event:
                for market in event["markets"]:
                    if "outcomes" in market:
                        best_odd = max(outcome.get('price', 0) for outcome in market["outcomes"])
                        print(f"    Best Odds Available: {best_odd}")
                        break
    else:
        print("✗ No Tennis events found")
    
    print("\n" + "=" * 70)
    print("Data retrieval complete!")
    print("=" * 70)


if __name__ == "__main__":
    main()