DriveArabia APIdrivearabia.com ↗

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

A comprehensive client for searching and analyzing car inventory from DriveArabia.com,
including make/model browsing, vehicle search with filters, and detailed specifications.
"""

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


class ParseClient:
    """Client for interacting with the DriveArabia API via Parse."""

    def __init__(self, api_key: Optional[str] = None):
        """
        Initialize the Parse API client.

        Args:
            api_key: API key for Parse Bot. If not provided, reads from PARSE_API_KEY env var.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "93e063b6-7250-466e-9a6b-1de12619db39"
        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 endpoint name (e.g., 'get_makes')
            method: HTTP method ('GET' or 'POST')
            **params: Query/body parameters

        Returns:
            JSON response from the API
        """
        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_makes(self) -> List[Dict[str, Any]]:
        """
        List all available car makes/brands.

        Returns:
            List of car makes with id and English name
        """
        result = self._call("get_makes", method="GET")
        return result.get("data", [])

    def get_models_by_make(self, make_id: int) -> List[Dict[str, Any]]:
        """
        List all car models for a specific make.

        Args:
            make_id: The internal ID of the car make

        Returns:
            List of car models for the given make
        """
        result = self._call("get_models_by_make", method="GET", make_id=str(make_id))
        return result.get("data", [])

    def search_cars(
        self,
        country: str = "uae",
        body_type: Optional[str] = None,
        page: int = 1
    ) -> Dict[str, Any]:
        """
        Search for cars with optional filters.

        Args:
            country: Country code (e.g., 'uae', 'ksa')
            body_type: Filter by body type (e.g., 'Sedan', 'SUV')
            page: Page number for pagination

        Returns:
            Dictionary with 'cars' list and 'page' info
        """
        params = {
            "country": country,
            "page": str(page)
        }
        if body_type:
            params["body_type"] = body_type

        response = self._call("search_cars", method="GET", **params)
        return response.get("data", {})

    def get_car_detail(self, url: str) -> Dict[str, Any]:
        """
        Get full details for a specific car.

        Args:
            url: The car detail page URL (from search_cars)

        Returns:
            Dictionary with model details, specs, trims, pros, overview, etc.
        """
        response = self._call("get_car_detail", method="GET", url=url)
        return response.get("data", {})

    def get_body_types(self) -> List[str]:
        """
        List all available body types.

        Returns:
            List of body type strings
        """
        result = self._call("get_body_types", method="GET")
        return result.get("data", {}).get("body_types", [])


if __name__ == "__main__":
    client = ParseClient()

    print("\n" + "=" * 70)
    print("🚗 DriveArabia Vehicle Research Workflow")
    print("=" * 70)

    # Step 1: Get available body types and display options
    print("\n📋 Step 1: Fetching available body types...")
    body_types = client.get_body_types()
    print(f"   ✓ Found {len(body_types)} body types: {', '.join(body_types)}")

    # Step 2: Search for SUVs and Sedans in UAE
    search_params = [
        ("SUV", "uae"),
        ("Sedan", "uae")
    ]

    all_results = {}

    for body_type, country in search_params:
        print(f"\n🔍 Step 2: Searching for {body_type}s in {country.upper()}...")
        search_result = client.search_cars(country=country, body_type=body_type, page=1)
        cars = search_result.get("cars", [])
        print(f"   ✓ Found {len(cars)} {body_type}s on page {search_result.get('page', '1')}")

        if cars:
            all_results[body_type] = cars
            # Display first 3 cars from this category
            for i, car in enumerate(cars[:3], 1):
                name = car.get("name", "Unknown")
                price = car.get("price", "N/A")
                print(f"     {i}. {name:30} - {price}")

    # Step 3: Get detailed information for selected vehicles
    print("\n📊 Step 3: Analyzing detailed specifications...")

    for body_type, cars in all_results.items():
        print(f"\n   {body_type} Analysis:")
        print("   " + "-" * 50)

        for i, car in enumerate(cars[:2], 1):  # Analyze first 2 per category
            car_name = car.get("name", "Unknown")
            car_url = car.get("url")
            car_price = car.get("price", "N/A")

            print(f"\n     Vehicle {i}: {car_name}")
            print(f"     Price: {car_price}")

            if car_url:
                try:
                    details = client.get_car_detail(car_url)

                    # Extract key information
                    brand = details.get("brand", "N/A")
                    model = details.get("model", "N/A")
                    year = details.get("year", "N/A")
                    overview = details.get("overview", "No overview available")
                    specs = details.get("specs", {})
                    trims = details.get("trims", [])
                    pros = details.get("pros", [])
                    cons = details.get("cons", [])
                    reliability = details.get("reliability", {})

                    # Display parsed information
                    print(f"     Brand: {brand} | Model: {model} | Year: {year}")

                    # Overview (truncated)
                    if overview:
                        print(f"     Overview: {overview[:85]}...")

                    # Key specs
                    if specs:
                        print(f"     Key Specs:")
                        for spec_key, spec_value in list(specs.items())[:4]:
                            print(f"       • {spec_key}: {spec_value}")

                    # Trims and pricing
                    if trims:
                        print(f"     Available Trims: {len(trims)}")
                        for trim in trims[:2]:
                            trim_name = trim.get("name", "Unknown")
                            trim_price = trim.get("price", "N/A")
                            print(f"       • {trim_name}: {trim_price}")

                    # Pros and cons
                    if pros or cons:
                        print(f"     Pros: {', '.join(pros[:2]) if pros else 'N/A'}")
                        print(f"     Cons: {', '.join(cons[:2]) if cons else 'N/A'}")

                    # Reliability score
                    if reliability.get("score"):
                        print(f"     Reliability Score: {reliability.get('score')}/5")

                except Exception as e:
                    print(f"     ⚠ Error fetching details: {e}")

    # Step 4: Compare makes and their models
    print("\n\n🏭 Step 4: Exploring car makes and their models...")
    print("   " + "-" * 50)

    makes = client.get_makes()
    popular_makes = ["Toyota", "Honda", "BMW", "Mercedes-Benz", "Nissan"]

    for make_name in popular_makes:
        make_obj = next((m for m in makes if m.get("car_make_en") == make_name), None)
        if make_obj:
            make_id = make_obj.get("id")
            models = client.get_models_by_make(make_id)
            print(f"\n   {make_name}: {len(models)} models available")
            if models:
                sample_models = [m.get("car_model_en") for m in models[:3]]
                print(f"     Sample models: {', '.join(sample_models)}")

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