Packdraw APIpackdraw.com ↗

"""
PackDraw API Client
API for extracting packs, battles, and deals data from packdraw.com

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

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


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

    def __init__(self, api_key: Optional[str] = None):
        """
        Initialize the Parse API client.
        
        Args:
            api_key: Your Parse API key. If not provided, reads from PARSE_API_KEY env var.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "c968b6cc-8f9b-4b96-82c2-0fbe563fc024"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")
        
        if not self.api_key:
            raise ValueError("API key not provided and PARSE_API_KEY not set")

    def _call(self, endpoint: str, method: str = "POST", **params) -> Dict[str, Any]:
        """
        Make a request to the Parse API.
        
        Args:
            endpoint: The endpoint name to call
            method: HTTP method (GET or POST)
            **params: Parameters to pass to the endpoint
            
        Returns:
            Response data as dictionary
        """
        url = f"{self.base_url}/scraper/{self.scraper_id}/{endpoint}"
        headers = {
            "X-API-Key": self.api_key,
            "Content-Type": "application/json"
        }
        
        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()

    def get_packs(self, **filters) -> Dict[str, Any]:
        """
        Fetch available packs with filtering, sorting, and pagination.
        
        Args:
            **filters: Optional filters like sort, limit, offset
            
        Returns:
            Dictionary containing packs data
        """
        return self._call("get_packs", method="GET", **filters)

    def get_battle_details(self, battle_id: str) -> Dict[str, Any]:
        """
        Fetch full details for a specific battle by ID.
        
        Args:
            battle_id: The ID of the battle to fetch
            
        Returns:
            Dictionary containing battle details
        """
        return self._call("get_battle_details", method="GET", id=battle_id)

    def list_deals_products(self, **filters) -> Dict[str, Any]:
        """
        List products in the deals section.
        
        Args:
            **filters: Optional filters and pagination params
            
        Returns:
            Dictionary containing deals products
        """
        return self._call("list_deals_products", method="GET", **filters)

    def get_homepage(self) -> Dict[str, Any]:
        """
        Fetch homepage content including featured packs and battles.
        
        Returns:
            Dictionary containing homepage data
        """
        return self._call("get_homepage", method="GET")

    def get_top_opens(self, **params) -> Dict[str, Any]:
        """
        Fetch the top recent opens leaderboard.
        
        Args:
            **params: Optional pagination and filter params
            
        Returns:
            Dictionary containing top opens data
        """
        return self._call("get_top_opens", method="GET", **params)

    def get_live_opens(self, **params) -> Dict[str, Any]:
        """
        Fetch the live opens feed.
        
        Args:
            **params: Optional pagination and filter params
            
        Returns:
            Dictionary containing live opens data
        """
        return self._call("get_live_opens", method="GET", **params)


def main():
    """Practical workflow example showing real PackDraw API usage."""
    
    # Initialize the client
    client = ParseClient()
    
    print("=" * 60)
    print("PackDraw API - Practical Usage Example")
    print("=" * 60)
    
    # Step 1: Get homepage to see featured content
    print("\n[Step 1] Fetching homepage featured packs and battles...")
    homepage = client.get_homepage()
    
    featured_packs = homepage.get("featured_packs", [])
    featured_battles = homepage.get("featured_battles", [])
    
    print(f"✓ Found {len(featured_packs)} featured packs")
    print(f"✓ Found {len(featured_battles)} featured battles")
    
    if featured_packs:
        print(f"\nTop Featured Pack: {featured_packs[0].get('name', 'N/A')}")
    
    # Step 2: Get all available packs with pagination
    print("\n[Step 2] Fetching available packs...")
    packs_data = client.get_packs(limit=10)
    
    packs = packs_data.get("packs", [])
    print(f"✓ Retrieved {len(packs)} packs")
    
    # Step 3: Get details for featured battles
    print("\n[Step 3] Fetching details for featured battles...")
    if featured_battles:
        for i, battle in enumerate(featured_battles[:3], 1):
            battle_id = battle.get("id")
            if battle_id:
                battle_details = client.get_battle_details(battle_id)
                battle_name = battle_details.get("name", "Unknown")
                battle_type = battle_details.get("type", "N/A")
                prize_pool = battle_details.get("prize_pool", "N/A")
                print(f"  {i}. {battle_name}")
                print(f"     Type: {battle_type} | Prize Pool: {prize_pool}")
    
    # Step 4: Check live opens activity
    print("\n[Step 4] Fetching live opens feed...")
    live_opens = client.get_live_opens(limit=5)
    
    opens_list = live_opens.get("opens", [])
    print(f"✓ Retrieved {len(opens_list)} recent opens")
    
    if opens_list:
        for i, open_item in enumerate(opens_list[:3], 1):
            user = open_item.get("user", "Anonymous")
            pack_name = open_item.get("pack_name", "Unknown Pack")
            pull_value = open_item.get("pull_value", "N/A")
            print(f"  {i}. {user} opened {pack_name} - Value: {pull_value}")
    
    # Step 5: Get top opens leaderboard
    print("\n[Step 5] Fetching top opens leaderboard...")
    top_opens = client.get_top_opens(limit=5)
    
    leaderboard = top_opens.get("leaderboard", [])
    print(f"✓ Top {len(leaderboard)} openers:")
    
    for i, entry in enumerate(leaderboard[:5], 1):
        username = entry.get("username", "Unknown")
        total_opens = entry.get("total_opens", 0)
        total_value = entry.get("total_value", 0)
        print(f"  {i}. {username} - {total_opens} opens (${total_value})")
    
    # Step 6: Check deals section
    print("\n[Step 6] Fetching deals products...")
    deals = client.list_deals_products(limit=5)
    
    deals_products = deals.get("products", [])
    print(f"✓ Found {len(deals_products)} deal products")
    
    if deals_products:
        for product in deals_products[:3]:
            product_name = product.get("name", "Unknown")
            discount = product.get("discount", "N/A")
            price = product.get("price", "N/A")
            print(f"  • {product_name} - {discount}% off (${price})")
    
    print("\n" + "=" * 60)
    print("✓ Example workflow completed successfully!")
    print("=" * 60)


if __name__ == "__main__":
    main()