Perekrestok APIperekrestok.ru ↗

"""
Perekrestok API Client for Parse.bot
Get your API key from: https://parse.bot/settings
"""

import os
import requests
from typing import Optional, Any


class ParseClient:
    """Client for interacting with Perekrestok API via Parse.bot"""
    
    def __init__(self, api_key: Optional[str] = None):
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "f0e630db-a315-4292-b46c-7acf011e1115"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")
        
        if not self.api_key:
            raise ValueError("API key is required. Set PARSE_API_KEY env variable or pass it directly.")
    
    def _call(self, endpoint: str, method: str = "POST", **params) -> dict[str, Any]:
        """Make API call to Parse.bot
        
        Args:
            endpoint: API endpoint name
            method: HTTP method (GET or POST)
            **params: Query/body parameters
            
        Returns:
            API response 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.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 get_categories(self, parent_id: Optional[int] = None) -> dict[str, Any]:
        """Get full category tree or children of a specific category
        
        Args:
            parent_id: Parent category ID (optional)
            
        Returns:
            Category tree data
        """
        params = {}
        if parent_id is not None:
            params["parent_id"] = parent_id
        return self._call("get_categories", method="GET", **params)
    
    def get_category_products(
        self,
        category_id: int,
        page: int = 1,
        per_page: int = 30
    ) -> dict[str, Any]:
        """Get paginated list of products in a category
        
        Args:
            category_id: Category ID (required)
            page: Page number
            per_page: Results per page
            
        Returns:
            Paginated products data
        """
        return self._call(
            "get_category_products",
            method="POST",
            category_id=category_id,
            page=page,
            per_page=per_page
        )
    
    def get_product_details(self, plu: str) -> dict[str, Any]:
        """Get full details for a specific product
        
        Args:
            plu: Product PLU code or ID
            
        Returns:
            Product details
        """
        return self._call("get_product_details", method="GET", plu=plu)
    
    def search_products(
        self,
        query: str,
        page: int = 1
    ) -> dict[str, Any]:
        """Search products by keyword
        
        Args:
            query: Search query
            page: Page number
            
        Returns:
            Search results
        """
        return self._call("search_products", method="GET", query=query, page=page)
    
    def get_product_reviews(
        self,
        plu: str,
        page: int = 1,
        per_page: int = 10
    ) -> dict[str, Any]:
        """Get user reviews for a product
        
        Args:
            plu: Product PLU code or ID
            page: Page number
            per_page: Results per page
            
        Returns:
            Product reviews
        """
        return self._call(
            "get_product_reviews",
            method="GET",
            plu=plu,
            page=page,
            per_page=per_page
        )


def main():
    """Practical workflow example: Search for products and get detailed information"""
    
    # Initialize client
    client = ParseClient()
    
    print("=" * 60)
    print("Perekrestok API Demo - Product Search & Details Workflow")
    print("=" * 60)
    
    # Step 1: Browse categories
    print("\n1. Fetching product categories...")
    try:
        categories_response = client.get_categories()
        if "content" in categories_response and "items" in categories_response["content"]:
            items = categories_response["content"]["items"]
            print(f"   Found {len(items)} categories")
            if items:
                first_cat = items[0]["category"]
                print(f"   Example: {first_cat['title']} (ID: {first_cat['id']})")
                
                # Step 2: Get products from first category
                category_id = first_cat["id"]
                print(f"\n2. Getting products from category '{first_cat['title']}'...")
                products_response = client.get_category_products(
                    category_id=category_id,
                    page=1,
                    per_page=5
                )
                
                if "content" in products_response and "items" in products_response["content"]:
                    products = products_response["content"]["items"]
                    print(f"   Retrieved {len(products)} products")
                    
                    if products:
                        # Step 3: Get details for each product
                        print("\n3. Getting detailed information for products...")
                        for idx, product in enumerate(products[:3], 1):
                            product_id = str(product.get("id", ""))
                            product_title = product.get("title", "Unknown")
                            price = product.get("priceTag", {}).get("price", "N/A")
                            
                            if product_id:
                                print(f"\n   Product {idx}: {product_title}")
                                print(f"   - ID: {product_id}")
                                print(f"   - Price: {price}")
                                
                                try:
                                    details = client.get_product_details(plu=product_id)
                                    if "content" in details:
                                        content = details["content"]
                                        weight = content.get("masterData", {}).get("weight", "N/A")
                                        print(f"   - Weight: {weight}g" if weight != "N/A" else f"   - Weight: {weight}")
                                        
                                        # Get reviews for this product
                                        try:
                                            reviews = client.get_product_reviews(plu=product_id, per_page=3)
                                            if "content" in reviews and "items" in reviews["content"]:
                                                review_items = reviews["content"]["items"]
                                                if review_items:
                                                    print(f"   - Reviews ({len(review_items)} shown):")
                                                    for review in review_items[:2]:
                                                        author = review.get("author", "Anonymous")
                                                        rating = review.get("rating", "N/A")
                                                        text = review.get("text", "No text")[:50]
                                                        print(f"     * {author} ({rating}★): {text}...")
                                        except Exception as e:
                                            print(f"   - Reviews: Error fetching ({str(e)[:30]}...)")
                                except Exception as e:
                                    print(f"   - Error fetching details: {str(e)[:50]}...")
    
    except Exception as e:
        print(f"Error during workflow: {e}")
    
    # Step 4: Search for a product
    print("\n4. Searching for 'milk' products...")
    try:
        search_response = client.search_products(query="milk", page=1)
        if "content" in search_response and "items" in search_response["content"]:
            results = search_response["content"]["items"]
            print(f"   Found {len(results)} results for 'milk'")
            if results:
                for idx, result in enumerate(results[:3], 1):
                    title = result.get("title", "Unknown")
                    product_id = str(result.get("id", ""))
                    print(f"   {idx}. {title} (ID: {product_id})")
    except Exception as e:
        print(f"Search error: {e}")
    
    print("\n" + "=" * 60)
    print("Demo complete!")
    print("=" * 60)


if __name__ == "__main__":
    main()