Apollo Pharmacy APIapollopharmacy.in ↗

"""
Apollo Pharmacy Medicine Search API Client

Search for medicines on Apollo Pharmacy with real-time pricing, availability,
and manufacturer information. Get your API key from: https://parse.bot/settings
"""

import os
import requests
from typing import Optional, Any
from dataclasses import dataclass


@dataclass
class Medicine:
    """Represents a medicine product from Apollo Pharmacy."""
    name: str
    sku: str
    price: float
    mrp: float
    discount_percentage: int
    manufacturer: Optional[str]
    availability: str
    pack_size: str
    is_prescription_required: bool
    tags: list


class ParseClient:
    """Client for Apollo Pharmacy Medicine Search API."""

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

        Args:
            api_key: API key for Parse API. If not provided, reads from PARSE_API_KEY env var.

        Raises:
            ValueError: If no API key is provided and PARSE_API_KEY is not set.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "1008a848-ec78-4d94-98ee-7458bbe7a770"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")

        if not self.api_key:
            raise ValueError(
                "API key not provided. Set PARSE_API_KEY environment variable "
                "or pass api_key parameter."
            )

    def _call(self, endpoint: str, method: str = "POST", **params) -> dict:
        """
        Make a request to the Parse API.

        Args:
            endpoint: API endpoint name (e.g., 'search_medicines')
            method: HTTP method ('GET' or 'POST')
            **params: Parameters to pass to the endpoint

        Returns:
            Response data as dictionary

        Raises:
            requests.RequestException: If 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_medicines(
        self, query: str, pincode: str = "110055"
    ) -> dict:
        """
        Search for medicines by name on Apollo Pharmacy.

        Args:
            query: Medicine name or keyword to search for (e.g., 'paracetamol', 'dolo 650')
            pincode: Indian PIN code for delivery availability check. Defaults to Delhi (110055)

        Returns:
            Dictionary containing search results with products list and metadata
        """
        return self._call(
            "search_medicines",
            method="GET",
            query=query,
            pincode=pincode,
        )

    def _parse_product(self, product_data: dict) -> Medicine:
        """Convert API product response to Medicine dataclass."""
        return Medicine(
            name=product_data.get("name", ""),
            sku=product_data.get("sku", ""),
            price=product_data.get("price", 0.0),
            mrp=product_data.get("mrp", 0.0),
            discount_percentage=product_data.get("discount_percentage", 0),
            manufacturer=product_data.get("manufacturer"),
            availability=product_data.get("availability", ""),
            pack_size=product_data.get("pack_size", ""),
            is_prescription_required=product_data.get("is_prescription_required", False),
            tags=product_data.get("tags", []),
        )


def main():
    """
    Practical workflow: Search for medicines and analyze pricing/availability.
    """
    # Initialize client
    client = ParseClient()

    # List of medicines to search for
    search_queries = ["paracetamol", "amoxicillin", "dolo"]
    pincode = "110055"  # Delhi

    all_medicines = []

    print("=" * 80)
    print("APOLLO PHARMACY MEDICINE SEARCH - PRICE COMPARISON")
    print("=" * 80)

    # Search for each medicine
    for query in search_queries:
        print(f"\n📋 Searching for: {query.upper()}")
        print("-" * 80)

        try:
            # Call API to search medicines
            result = client.search_medicines(query=query, pincode=pincode)

            total_results = result.get("total_results", 0)
            products = result.get("products", [])

            if not products:
                print(f"   ❌ No results found for '{query}'")
                continue

            print(f"   ✓ Found {total_results} results (showing top {len(products)})")

            # Process each product
            for idx, product_data in enumerate(products[:5], 1):  # Show top 5
                medicine = client._parse_product(product_data)
                all_medicines.append(medicine)

                # Calculate savings
                savings = medicine.mrp - medicine.price
                savings_percent = medicine.discount_percentage

                # Availability indicator
                status_icon = "✓ In Stock" if medicine.availability == "in-stock" else "✗ Out of Stock"

                # Prescription indicator
                rx_indicator = " [Rx Required]" if medicine.is_prescription_required else ""

                print(f"\n   {idx}. {medicine.name}{rx_indicator}")
                print(f"      SKU: {medicine.sku}")
                print(f"      Price: ₹{medicine.price} | MRP: ₹{medicine.mrp} | Save: ₹{savings:.2f} ({savings_percent}%)")
                print(f"      Pack: {medicine.pack_size} | {status_icon}")
                if medicine.manufacturer:
                    print(f"      Manufacturer: {medicine.manufacturer}")
                if medicine.tags:
                    print(f"      Tags: {', '.join(medicine.tags)}")

        except requests.exceptions.RequestException as e:
            print(f"   ❌ API Error: {e}")
        except ValueError as e:
            print(f"   ❌ Error: {e}")

    # Summary analysis
    print("\n" + "=" * 80)
    print("SUMMARY & ANALYSIS")
    print("=" * 80)

    if all_medicines:
        # Find cheapest medicine
        cheapest = min(all_medicines, key=lambda m: m.price)
        print(f"\n💰 Cheapest Medicine: {cheapest.name} - ₹{cheapest.price}")

        # Find best discount
        best_discount = max(all_medicines, key=lambda m: m.discount_percentage)
        print(f"🎉 Best Discount: {best_discount.name} - {best_discount.discount_percentage}% off")

        # Count by availability
        in_stock = sum(1 for m in all_medicines if m.availability == "in-stock")
        out_of_stock = len(all_medicines) - in_stock
        print(f"\n📦 Availability: {in_stock} in-stock, {out_of_stock} out-of-stock")

        # Prescription requirement analysis
        rx_required = sum(1 for m in all_medicines if m.is_prescription_required)
        print(f"💊 Prescription Required: {rx_required} medicines")

        # Average pricing
        avg_price = sum(m.price for m in all_medicines) / len(all_medicines)
        avg_mrp = sum(m.mrp for m in all_medicines) / len(all_medicines)
        avg_savings = avg_mrp - avg_price
        print(f"\n📊 Average Pricing:")
        print(f"   - Average Price: ₹{avg_price:.2f}")
        print(f"   - Average MRP: ₹{avg_mrp:.2f}")
        print(f"   - Average Savings: ₹{avg_savings:.2f}")

    print("\n" + "=" * 80)


if __name__ == "__main__":
    main()