Bedshed APIbedshed.com.au ↗

"""
Bedshed Australia API Client
Search products, find stores, and get product details from Bedshed, Australia's mattress and bedroom furniture retailer.
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 Bedshed Australia 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, reads from PARSE_API_KEY env var.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "5d7a5752-14ef-4c9e-9284-4c5244dca15d"
        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 endpoint.
        
        Args:
            endpoint: The endpoint name (e.g., 'search_products')
            method: HTTP method ('GET' or 'POST')
            **params: Query/body parameters
            
        Returns:
            Response JSON as dictionary
            
        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"
        }
        
        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()

    def search_products(
        self,
        query: Optional[str] = None,
        category: Optional[str] = None,
        brand: Optional[str] = None,
        size: Optional[str] = None,
        product_type: Optional[str] = None,
        sorting: str = "featured",
        limit: int = 15,
        page: int = 1
    ) -> Dict[str, Any]:
        """Search and filter products from the Bedshed catalog.
        
        Args:
            query: Free-text search query (e.g., 'queen mattress')
            category: Product category filter
            brand: Brand filter
            size: Size filter
            product_type: Product type filter
            sorting: Sort order (featured, max_saving_percentage, name_asc, name_desc, highest_price, lowest_price, express_shipping, relevance)
            limit: Number of products per page
            page: Page number for pagination
            
        Returns:
            Dictionary containing products list, pagination info, and available filters
        """
        params = {
            "sorting": sorting,
            "limit": limit,
            "page": page
        }
        
        if query is not None:
            params["query"] = query
        if category is not None:
            params["category"] = category
        if brand is not None:
            params["brand"] = brand
        if size is not None:
            params["size"] = size
        if product_type is not None:
            params["product_type"] = product_type
        
        return self._call("search_products", method="GET", **params)

    def find_stores(
        self,
        postcode: Optional[str] = None,
        state: Optional[str] = None
    ) -> Dict[str, Any]:
        """Find Bedshed retail stores by Australian postcode or state.
        
        Args:
            postcode: Australian postcode to search near (e.g., '2000', '6000')
            state: Australian state abbreviation (WA, NSW, QLD, VIC, ACT)
            
        Returns:
            Dictionary containing stores list and total count
        """
        params = {}
        
        if postcode is not None:
            params["postcode"] = postcode
        if state is not None:
            params["state"] = state
        
        return self._call("find_stores", method="GET", **params)

    def get_product_details(self, sku: str) -> Dict[str, Any]:
        """Get detailed product information by SKU.
        
        Args:
            sku: Product SKU identifier (e.g., '50097', '50085')
            
        Returns:
            Dictionary containing detailed product information including pricing, sizes, and variants
        """
        return self._call("get_product_details", method="GET", sku=sku)


def main():
    """Practical workflow example: Find queen mattresses on sale and get nearby stores."""
    
    # Initialize client
    client = ParseClient()
    
    print("=" * 70)
    print("BEDSHED AUSTRALIA API - PRACTICAL WORKFLOW EXAMPLE")
    print("=" * 70)
    
    # Step 1: Search for queen mattresses on sale
    print("\n📍 Step 1: Searching for Queen-size mattresses sorted by savings...")
    search_results = client.search_products(
        query="mattress",
        size="Queen",
        sorting="max_saving_percentage",
        limit=5
    )
    
    print(f"Found {search_results['total']} queen mattresses total")
    print(f"Showing {len(search_results['products'])} results (page {search_results['current_page']} of {search_results['last_page']})")
    print(f"\nAvailable brands: {', '.join(search_results['available_filters']['brands'])}")
    
    # Step 2: Process search results and get details for top products
    print("\n" + "=" * 70)
    print("TOP MATTRESSES BY SAVINGS:")
    print("=" * 70)
    
    top_skus = []
    for idx, product in enumerate(search_results['products'], 1):
        print(f"\n{idx}. {product['brand']} - {product['name']}")
        print(f"   Price range: ${product['min_price']:,} - ${product['max_price']:,} AUD")
        print(f"   Saving: {product.get('saving_percentage', 'N/A')}%")
        print(f"   On Sale: {'✓ Yes' if product['is_on_sale'] else '✗ No'}")
        print(f"   Available in: {', '.join(product['sizes'])}")
        top_skus.append(product['sku'])
    
    # Step 3: Get detailed information for the top product
    if top_skus:
        print("\n" + "=" * 70)
        print("DETAILED PRODUCT INFO (Top Result):")
        print("=" * 70)
        
        details = client.get_product_details(sku=top_skus[0])
        print(f"\nProduct: {details['name']}")
        print(f"Brand: {details['brand']}")
        print(f"Type: {details['type']}")
        print(f"Description: {details['description'][:150]}...")
        print(f"Available Firmnesses: {', '.join(details.get('firmnesses', []))}")
        print(f"Express Shipping: {'✓ Yes' if details.get('express_shipping') else '✗ No'}")
    
    # Step 4: Find nearby stores (using postcode for Sydney area)
    print("\n" + "=" * 70)
    print("FIND NEARBY STORES (Sydney - Postcode 2000):")
    print("=" * 70)
    
    stores_result = client.find_stores(postcode="2000")
    print(f"\nFound {stores_result['total']} stores nearby")
    
    for idx, store in enumerate(stores_result['stores'], 1):
        print(f"\n{idx}. {store['title']}")
        print(f"   Address: {store['street_address']}, {store['suburb']} {store['postcode']}")
        print(f"   Distance: {store.get('distance', 'N/A')} km")
        print(f"   Phone: {store['phone']}")
        print(f"   Status: {'⚠️  Temporarily Closed' if store['temporarily_closed'] else '✓ Open'}")
        
        if store['opening_hours']:
            print(f"   Hours today: {store['opening_hours'][0]['open_time']} - {store['opening_hours'][0]['close_time']}")
    
    # Step 5: Search for a specific brand with filters
    print("\n" + "=" * 70)
    print("TEMPUR BRAND PRODUCTS:")
    print("=" * 70)
    
    tempur_search = client.search_products(
        brand="TEMPUR",
        product_type="Mattress",
        sorting="lowest_price",
        limit=3
    )
    
    print(f"\nFound {tempur_search['total']} TEMPUR mattresses")
    for product in tempur_search['products']:
        sale_tag = f" - 💰 {product['saving_percentage']}% OFF" if product['is_on_sale'] else ""
        print(f"  • {product['name']}: ${product['min_price']:,} - ${product['max_price']:,}{sale_tag}")
    
    print("\n" + "=" * 70)
    print("✅ Workflow complete!")
    print("=" * 70)


if __name__ == "__main__":
    main()