Smyths Toys APIsmythstoys.com ↗

"""
Smythstoys API Client

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

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


class ParseClient:
    """Client for interacting with the Smythstoys 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, uses PARSE_API_KEY env var.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "053661b2-6234-4b41-97da-8dfcb7c7fb9c"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")

        if not self.api_key:
            raise ValueError("API key must be provided or set in 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., 'search_products')
            method: HTTP method ('GET' or 'POST')
            **params: Query/body parameters for the endpoint

        Returns:
            Parsed JSON response from the API

        Raises:
            requests.RequestException: If the API request 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)
            elif method.upper() == "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.RequestException as e:
            raise Exception(f"API request failed: {str(e)}")

    def search_products(
        self,
        query: str,
        locale: str = "uk",
        page: int = 0,
        page_size: int = 48
    ) -> Dict[str, Any]:
        """
        Search for products by keyword query across different locales.

        Args:
            query: Search keyword (required)
            locale: Region/Locale - one of: uk, ie, de, nl (default: uk)
            page: Current page number (default: 0)
            page_size: Number of results per page (default: 48)

        Returns:
            Dictionary containing 'products' array with matching products
        """
        return self._call(
            "search_products",
            method="GET",
            query=query,
            locale=locale,
            page=page,
            page_size=page_size
        )

    def get_product_details(
        self,
        product_code: str,
        locale: str = "uk"
    ) -> Dict[str, Any]:
        """
        Get detailed information for a specific product by its code.

        Args:
            product_code: Product SKU/Code (e.g., '123456') (required)
            locale: Region/Locale - one of: uk, ie, de, nl (default: uk)

        Returns:
            Dictionary containing product details including name, price, and stock info
        """
        return self._call(
            "get_product_details",
            method="GET",
            product_code=product_code,
            locale=locale
        )


def main():
    """Practical usage example: Search for products and fetch details for each result."""
    
    # Initialize the client
    client = ParseClient()

    # Search for LEGO products in the UK
    print("🔍 Searching for LEGO products in UK...\n")
    search_results = client.search_products(
        query="LEGO",
        locale="uk",
        page=0,
        page_size=5  # Limit to 5 results for this example
    )

    products = search_results.get("products", [])
    
    if not products:
        print("❌ No products found")
        return

    print(f"✅ Found {len(products)} products\n")

    # Fetch detailed information for each product
    print("=" * 70)
    print(f"{'Product Name':<40} {'Price':>12} {'Stock Status':>15}")
    print("=" * 70)

    for product in products:
        product_code = product.get("code")
        product_name = product.get("name", "Unknown")

        if not product_code:
            continue

        try:
            # Get detailed information
            details = client.get_product_details(
                product_code=product_code,
                locale="uk"
            )

            name = details.get("name", "Unknown")
            price_data = details.get("price", {})
            price_value = price_data.get("value", "N/A") if isinstance(price_data, dict) else "N/A"
            
            stock_data = details.get("stock", {})
            stock_status = stock_data.get("stockLevelStatus", "Unknown") if isinstance(stock_data, dict) else "Unknown"

            # Format price
            if isinstance(price_value, (int, float)):
                price_str = f"£{price_value:.2f}"
            else:
                price_str = str(price_value)

            # Print formatted row
            print(f"{name:<40} {price_str:>12} {stock_status:>15}")

        except Exception as e:
            print(f"{product_name:<40} {'Error':>12} {str(e)[:15]:>15}")

    print("=" * 70)
    print("\n✨ Product details fetched successfully!")


if __name__ == "__main__":
    main()