Eindev APIui.eindev.ir ↗

"""
EinUI Liquid Glass Components API Client

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

import os
import requests
from typing import Optional, Any


class ParseClient:
    """Client for interacting with the EinUI Liquid Glass Components API."""

    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 = "768785e1-c914-4526-8800-26d8721f92dc"
        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 environment variable not set")

    def _call(self, endpoint: str, method: str = "POST", **params) -> dict[str, Any]:
        """
        Internal method to call the Parse API.

        Args:
            endpoint: API endpoint name
            method: HTTP method (GET or POST)
            **params: Query or body parameters

        Returns:
            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"}

        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_components(
        self, query: Optional[str] = None, category: Optional[str] = None
    ) -> dict[str, Any]:
        """
        Search and list liquid glass components from the EinUI registry.

        Args:
            query: Optional search text to filter components by name, title, or description
            category: Optional category filter to match against component name

        Returns:
            Dictionary containing total count and list of component objects
        """
        params = {}
        if query:
            params["query"] = query
        if category:
            params["category"] = category

        return self._call("search_components", method="GET", **params)

    def get_component(self, name: str) -> dict[str, Any]:
        """
        Get full details of a specific component including source code and metadata.

        Args:
            name: Component name from the registry (e.g., 'glass-card', 'glass-button')

        Returns:
            Dictionary containing component details, dependencies, and full source code
        """
        return self._call("get_component", method="GET", name=name)


def main():
    """Practical workflow example: Search for glass components and retrieve their full source code."""

    # Initialize the client
    client = ParseClient()

    print("=" * 70)
    print("EinUI Liquid Glass Components - Practical Usage Example")
    print("=" * 70)

    # Step 1: Search for all glass components
    print("\n[Step 1] Searching for glass components...")
    search_results = client.search_components(category="glass")

    total = search_results.get("total", 0)
    components = search_results.get("components", [])

    print(f"Found {total} glass components:")
    print("-" * 70)

    for idx, component in enumerate(components[:5], 1):  # Show first 5
        print(f"{idx}. {component['title']} (name: {component['name']})")
        print(f"   Description: {component['description']}")
        print(f"   Dependencies: {', '.join(component['dependencies']) if component['dependencies'] else 'None'}")
        print()

    # Step 2: If components found, get detailed source code for the first component
    if components:
        first_component = components[0]
        component_name = first_component["name"]

        print("\n[Step 2] Retrieving full details and source code...")
        print(f"Getting detailed information for '{component_name}'...")
        print("-" * 70)

        try:
            component_details = client.get_component(component_name)

            print(f"\nComponent: {component_details['title']}")
            print(f"Type: {component_details['type']}")
            print(f"Description: {component_details['description']}")

            if component_details.get("dependencies"):
                print(f"Dependencies: {', '.join(component_details['dependencies'])}")

            # Display source code information
            print(f"\nSource Files:")
            for file_obj in component_details.get("files", []):
                path = file_obj.get("path", "unknown")
                content_length = len(file_obj.get("content", ""))
                print(f"  - {path}")
                print(f"    Size: {content_length} characters")
                # Show first 200 chars of content as preview
                if content_length > 0:
                    preview = file_obj.get("content", "")[:200]
                    print(f"    Preview: {preview}...")

        except requests.RequestException as e:
            print(f"Error retrieving component details: {e}")

    # Step 3: Search by query to find components with specific functionality
    print("\n[Step 3] Searching for components with 'select' functionality...")
    print("-" * 70)

    select_results = client.search_components(query="select")
    select_components = select_results.get("components", [])

    if select_components:
        for component in select_components[:3]:
            print(f"- {component['title']} ({component['name']})")
            print(f"  {component['description']}\n")
    else:
        print("No components found with 'select' in their metadata.")

    print("\n" + "=" * 70)
    print("Workflow completed successfully!")
    print("=" * 70)


if __name__ == "__main__":
    main()