Com APIadidas.com.sg ↗

"""
Adidas Singapore API - Parse Client
A Python client for searching products, getting details, checking availability, and reading reviews from adidas.com.sg
Get your API key from: https://parse.bot/settings
"""

import os
import requests
from typing import Any, Optional


class ParseClient:
    """Client for interacting with the Parse API for Adidas Singapore scraper."""

    def __init__(self, api_key: Optional[str] = None):
        """
        Initialize the Parse client.
        
        Args:
            api_key: API key for Parse API. If not provided, will use PARSE_API_KEY env var.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "6ea095e3-18de-4d6e-80fc-0f4dc1bee2b1"
        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 a request to the Parse API.
        
        Args:
            endpoint: The API endpoint name (e.g., 'search_products')
            method: HTTP method ('GET' or 'POST')
            **params: Parameters to pass to the endpoint
            
        Returns:
            Response data as a dictionary
        """
        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_products(
        self,
        query: str,
        start: int = 0,
        sort: Optional[str] = None,
        limit: int = 48,
        gender: Optional[str] = None,
        division: Optional[str] = None,
        brand: Optional[str] = None,
        sport: Optional[str] = None,
        color: Optional[str] = None
    ) -> dict[str, Any]:
        """
        Search for products by keyword with optional filtering and sorting.
        
        Args:
            query: Search keyword (e.g., 'shoes', 'ultraboost')
            start: Pagination offset (default 0, increment by 48)
            sort: Sort order (price-low-to-high, price-high-to-low, newest-to-oldest, top-sellers)
            limit: Max results per request (max 48)
            gender: Filter by gender (men, women, unisex, kids)
            division: Filter by division (shoes, clothing, accessories)
            brand: Filter by brand
            sport: Filter by sport
            color: Filter by color
            
        Returns:
            Dictionary containing products, pagination info, and available filters
        """
        params = {"query": query, "start": start, "limit": limit}
        if sort:
            params["sort"] = sort
        if gender:
            params["gender"] = gender
        if division:
            params["division"] = division
        if brand:
            params["brand"] = brand
        if sport:
            params["sport"] = sport
        if color:
            params["color"] = color
        
        return self._call("search_products", method="GET", **params)

    def product_detail(self, product_id: str) -> dict[str, Any]:
        """
        Get comprehensive product details including description, images, pricing, and sizing.
        
        Args:
            product_id: Product ID (e.g., 'B75806')
            
        Returns:
            Dictionary containing detailed product information
        """
        return self._call("product_detail", method="GET", product_id=product_id)

    def product_availability(self, product_id: str) -> dict[str, Any]:
        """
        Get real-time stock availability for a product by size.
        
        Args:
            product_id: Product ID (e.g., 'B75806')
            
        Returns:
            Dictionary containing availability status and variations by size
        """
        return self._call("product_availability", method="GET", product_id=product_id)

    def product_reviews(
        self,
        model_id: str,
        limit: int = 10,
        offset: int = 0,
        sort: str = "relevancy"
    ) -> dict[str, Any]:
        """
        Get product reviews by model ID.
        
        Args:
            model_id: Model ID (from product_detail's base_model_number)
            limit: Number of reviews per page
            offset: Pagination offset
            sort: Sort order (relevancy, newest, oldest, rating)
            
        Returns:
            Dictionary containing reviews and pagination info
        """
        return self._call(
            "product_reviews",
            method="GET",
            model_id=model_id,
            limit=limit,
            offset=offset,
            sort=sort
        )


def main():
    """Find affordable running shoes, check real-time availability, and analyze customer reviews."""
    
    # Initialize the client
    client = ParseClient()
    
    print("\n" + "=" * 80)
    print("ADIDAS SINGAPORE - SMART SHOPPING ASSISTANT")
    print("=" * 80)
    
    # Step 1: Search for budget-friendly running shoes
    print("\n[STEP 1] Searching for affordable running shoes (under SGD $150)...\n")
    
    search_response = client.search_products(
        query="running shoes",
        sort="price-low-to-high",
        limit=6
    )
    
    products = search_response.get("data", {}).get("products", [])
    pagination = search_response.get("data", {}).get("pagination", {})
    
    print(f"✓ Found {pagination.get('total_results', 0)} total running shoes")
    print(f"✓ Displaying {len(products)} results on this page\n")
    
    # Display search results summary
    print("SEARCH RESULTS (Sorted by Price):")
    print("-" * 80)
    
    affordable_products = []
    for idx, product in enumerate(products, 1):
        price = product.get("price", 0)
        sale_price = product.get("sale_price", price)
        
        # Filter for affordable options
        if sale_price <= 150:
            affordable_products.append(product)
            discount = product.get("sale_percentage", "0%")
            rating = product.get("rating", 0)
            rating_count = product.get("rating_count", 0)
            
            print(f"{idx}. {product.get('name', 'N/A')}")
            print(f"   Price: SGD ${sale_price} (was ${price}) | Discount: {discount}")
            print(f"   Rating: ⭐ {rating}/5 ({rating_count} reviews)")
            print(f"   Product ID: {product.get('product_id', 'N/A')}\n")
    
    if not affordable_products:
        print("No affordable options found in current results. Adjusting search...\n")
        affordable_products = products[:3]
    
    # Step 2: Deep dive into top 2 affordable products
    print("\n" + "=" * 80)
    print("[STEP 2] DETAILED ANALYSIS OF TOP PRODUCTS")
    print("=" * 80)
    
    selected_products = affordable_products[:2]
    
    for product_idx, product in enumerate(selected_products, 1):
        product_id = product.get("product_id", "N/A")
        product_name = product.get("name", "Unknown")
        
        print(f"\n{'─' * 80}")
        print(f"PRODUCT {product_idx}: {product_name}")
        print(f"{'─' * 80}")
        
        # Fetch detailed product information
        print("\n📋 Fetching detailed information...")
        try:
            details_response = client.product_detail(product_id)
            details = details_response.get("data", {})
            
            brand = details.get("brand", "N/A")
            gender = details.get("gender", "N/A")
            
            print(f"  • Brand: {brand}")
            print(f"  • Gender: {gender}")
            
            # Display pricing details
            pricing = details.get("pricing", {})
            current_price = pricing.get("current_price", "N/A")
            standard_price = pricing.get("standard_price", "N/A")
            print(f"  • Current Price: SGD ${current_price} (Standard: SGD ${standard_price})")
            
            # Display product description
            description = details.get("description", {})
            if isinstance(description, dict):
                title = description.get("title", "")
                text = description.get("text", "")
                if text:
                    print(f"  • Description: {text[:120]}...")
            
            # Show available sizes
            sizes = details.get("sizes", [])
            if sizes:
                size_list = [s.get("size", "N/A") for s in sizes]
                print(f"  • Available Sizes: {', '.join(size_list[:8])}")
                if len(size_list) > 8:
                    print(f"    ... and {len(size_list) - 8} more sizes")
            
            # Check real-time stock availability
            print("\n📦 Checking real-time stock availability...")
            try:
                availability_response = client.product_availability(product_id)
                availability_data = availability_response.get("data", {})
                
                status = availability_data.get("availability_status", "UNKNOWN")
                variations = availability_data.get("variations", [])
                
                in_stock_count = sum(1 for v in variations if v.get("availability_status") == "IN_STOCK")
                out_of_stock_count = sum(1 for v in variations if v.get("availability_status") == "OUT_OF_STOCK")
                
                print(f"  • Overall Status: {status}")
                print(f"  • Stock Summary: {in_stock_count} sizes in stock, {out_of_stock_count} out of stock")
                
                # Show specific in-stock sizes with inventory count
                in_stock_items = [v for v in variations if v.get("availability_status") == "IN_STOCK"]
                if in_stock_items:
                    print(f"  • In-Stock Sizes (first 5):")
                    for size_var in in_stock_items[:5]:
                        size = size_var.get("size", "N/A")
                        count = size_var.get("availability", 0)
                        print(f"    ✓ Size {size}: {count} units available")
                    if len(in_stock_items) > 5:
                        print(f"    ... and {len(in_stock_items) - 5} more sizes in stock")
                
            except Exception as e:
                if "blocked" in str(e).lower() or "akamai" in str(e).lower():
                    print(f"  ⚠ Stock check temporarily blocked (Akamai protection)")
                else:
                    print(f"  ⚠ Could not fetch availability: {str(e)[:60]}")
            
            # Fetch and display customer reviews
            model_id = details.get("base_model_number")
            if model_id:
                print(f"\n⭐ Fetching customer reviews (Model ID: {model_id})...")
                try:
                    reviews_response = client.product_reviews(model_id, limit=3, sort="rating")
                    reviews_data = reviews_response.get("data", {})
                    
                    total_reviews = reviews_data.get("total_results", 0)
                    reviews = reviews_data.get("reviews", [])
                    
                    print(f"  • Total Reviews: {total_reviews}")
                    
                    if reviews:
                        print(f"  • Top Customer Reviews:")
                        for review in reviews:
                            rating = review.get("rating", 0)
                            stars = "⭐" * rating
                            title = review.get("title", "No title")
                            nickname = review.get("user_nickname", "Anonymous")
                            date = review.get("formatted_date", "N/A")
                            is_recommended = "✓ Recommended" if review.get("is_recommended") else "✗ Not recommended"
                            
                            print(f"\n    {stars} - \"{title}\" by {nickname} ({date})")
                            print(f"       {is_recommended}")
                
                except Exception as e:
                    print(f"  ⚠ Could not fetch reviews: {str(e)[:60]}")
            
        except Exception as e:
            print(f"  ✗ Error fetching product details: {str(e)[:80]}")
    
    # Step 3: Summary and recommendations
    print(f"\n{'=' * 80}")
    print("SHOPPING SUMMARY")
    print(f"{'=' * 80}\n")
    
    print("✓ Analysis complete! Here's what we found:\n")
    
    if affordable_products:
        best_price = min(affordable_products, key=lambda x: x.get("sale_price", float('inf')))
        best_rating = max(affordable_products, key=lambda x: x.get("rating", 0))
        
        print(f"💰 Best Price: {best_price.get('name')} - SGD ${best_price.get('sale_price')}")
        print(f"⭐ Best Rating: {best_rating.get('name')} - {best_rating.get('rating')}/5 ({best_rating.get('rating_count')} reviews)")
        print(f"\n📌 Recommendations:")
        print(f"   • Check size availability before adding to cart")
        print(f"   • Read customer reviews to understand fit and durability")
        print(f"   • Compare with similar products to ensure best value")
    
    print(f"\n{'=' * 80}\n")


if __name__ == "__main__":
    main()