pip install requests pandas python-dotenv schedule

PANGOLIN_API_KEY=your_api_key_here
PANGOLIN_BASE_URL=https://api.pangolinfo.com/scrape

echo ".env" >> .gitignore

import os
import requests
from dotenv import load_dotenv
from typing import Dict, Optional

class PangolinClient:
    """Production-ready Pangolin API client"""

    def __init__(self):
        load_dotenv()
        self.api_key = os.getenv('PANGOLIN_API_KEY')
        self.base_url = os.getenv('PANGOLIN_BASE_URL')

        if not self.api_key:
            raise ValueError("API key not found in .env file")

    def get_product(self, asin: str, marketplace: str = 'US') -> Optional[Dict]:
        """Fetch product details from Amazon"""
        params = {
            'type': 'product',
            'asin': asin,
            'marketplace': marketplace,
            'parse': 'true',
            'api_key': self.api_key
        }

        try:
            response = requests.get(self.base_url, params=params, timeout=30)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"API request failed: {e}")
            return None

# Quick test
client = PangolinClient()
product = client.get_product('B08N5WRWNW')

if product:
    print(f"✓ Title: {product.get('title')}")
    print(f"✓ Price: ${product.get('price', {}).get('value')}")
    print(f"✓ Rating: {product.get('rating')}")

✓ Title: Apple AirPods Pro (2nd Generation)
✓ Price: $249.00
✓ Rating: 4.7

class PangolinAPIError(Exception):
    """Base exception for API errors"""
    pass

class AuthenticationError(PangolinAPIError):
    """Raised when API key is invalid"""
    pass

class RateLimitError(PangolinAPIError):
    """Raised when rate limit is exceeded"""
    pass

import time

class EnhancedPangolinClient(PangolinClient):
    """Client with automatic retry and exponential backoff"""

    def get_product(self, asin: str, marketplace: str = 'US', 
                   max_retries: int = 3) -> Optional[Dict]:
        """Fetch product with automatic retry"""

        for attempt in range(max_retries):
            try:
                params = {
                    'type': 'product',
                    'asin': asin,
                    'marketplace': marketplace,
                    'parse': 'true',
                    'api_key': self.api_key
                }

                response = requests.get(self.base_url, params=params, timeout=30)

                # Handle different status codes
                if response.status_code == 200:
                    return response.json()
                elif response.status_code == 401:
                    raise AuthenticationError("Invalid API key")
                elif response.status_code == 429:
                    wait_time = int(response.headers.get('Retry-After', 60))
                    print(f"Rate limited. Waiting {wait_time}s...")
                    time.sleep(wait_time)
                    continue
                else:
                    response.raise_for_status()

            except requests.exceptions.Timeout:
                if attempt < max_retries - 1:
                    wait_time = 2 ** attempt  # Exponential backoff
                    print(f"Timeout. Retry {attempt + 1}/{max_retries} in {wait_time}s...")
                    time.sleep(wait_time)
                else:
                    raise PangolinAPIError("Max retries exceeded")

        return None

import json
from datetime import datetime
from pathlib import Path

class BestsellerMonitor:
    """Monitor Amazon bestseller rankings with change detection"""

    def __init__(self, client: PangolinClient, data_dir: str = './data'):
        self.client = client
        self.data_dir = Path(data_dir)
        self.data_dir.mkdir(exist_ok=True)
        self.history_file = self.data_dir / 'bestsellers_history.json'
        self.history = self._load_history()

    def _load_history(self) -> Dict:
        """Load historical ranking data"""
        if self.history_file.exists():
            with open(self.history_file, 'r') as f:
                return json.load(f)
        return {}

    def _save_history(self):
        """Save ranking data to disk"""
        with open(self.history_file, 'w') as f:
            json.dump(self.history, f, indent=2)

    def monitor_category(self, category: str, marketplace: str = 'US'):
        """Monitor a category and detect changes"""
        print(f"n📊 Monitoring {category} bestsellers...")

        # Fetch current rankings
        params = {
            'type': 'bestsellers',
            'category': category,
            'marketplace': marketplace,
            'parse': 'true',
            'api_key': self.client.api_key
        }

        response = requests.get(self.client.base_url, params=params)
        data = response.json()

        if not data or 'products' not in data:
            print("❌ Failed to fetch data")
            return

        # Build current ranking map
        current = {}
        for product in data['products']:
            asin = product.get('asin')
            current[asin] = {
                'rank': product.get('rank'),
                'title': product.get('title'),
                'price': product.get('price', {}).get('value'),
                'rating': product.get('rating'),
                'timestamp': datetime.now().isoformat()
            }

        # Analyze changes
        category_key = f"{marketplace}_{category}"
        if category_key in self.history:
            self._analyze_changes(category_key, current)

        # Update history
        self.history[category_key] = current
        self._save_history()

        print(f"✓ Tracked {len(current)} products")

    def _analyze_changes(self, category_key: str, current: Dict):
        """Detect and report ranking changes"""
        previous = self.history[category_key]

        # New products
        new_asins = set(current.keys()) - set(previous.keys())
        if new_asins:
            print(f"n🆕 {len(new_asins)} new products:")
            for asin in list(new_asins)[:5]:  # Show top 5
                p = current[asin]
                print(f"  #{p['rank']}: {p['title'][:50]}...")

        # Ranking changes
        big_movers = []
        for asin in set(current.keys()) & set(previous.keys()):
            old_rank = previous[asin]['rank']
            new_rank = current[asin]['rank']
            change = old_rank - new_rank

            if abs(change) >= 10:  # Moved 10+ positions
                big_movers.append({
                    'asin': asin,
                    'title': current[asin]['title'],
                    'old_rank': old_rank,
                    'new_rank': new_rank,
                    'change': change
                })

        if big_movers:
            print(f"n📈 {len(big_movers)} significant ranking changes:")
            for item in sorted(big_movers, key=lambda x: abs(x['change']), reverse=True)[:5]:
                direction = "↑" if item['change'] > 0 else "↓"
                print(f"  {direction} #{item['old_rank']}→#{item['new_rank']}: {item['title'][:50]}...")

# Usage
client = EnhancedPangolinClient()
monitor = BestsellerMonitor(client)

# Monitor kitchen category
monitor.monitor_category('kitchen')

📊 Monitoring kitchen bestsellers...

🆕 3 new products:
  #12: Ninja Air Fryer Pro 4-in-1...
  #28: KitchenAid Stand Mixer Classic...
  #45: Instant Pot Duo 7-in-1...

📈 5 significant ranking changes:
  ↑ #45→#12: Cuisinart Coffee Maker...
  ↓ #8→#23: Hamilton Beach Blender...
  ↑ #67→#34: OXO Good Grips Measuring Cups...

✓ Tracked 100 products

import schedule
import time

def daily_monitoring():
    """Run daily bestseller monitoring"""
    categories = ['kitchen', 'home', 'electronics']

    for category in categories:
        monitor.monitor_category(category)
        time.sleep(2)  # Be nice to the API

# Schedule daily at 9 AM
schedule.every().day.at("09:00").do(daily_monitoring)

# Run immediately once
daily_monitoring()

# Keep running
while True:
    schedule.run_pending()
    time.sleep(60)

import sqlite3
import pandas as pd

class PriceTracker:
    """Track product prices with SQLite storage"""

    def __init__(self, client: PangolinClient, db_path: str = './data/prices.db'):
        self.client = client
        self.db_path = db_path
        self._init_database()

    def _init_database(self):
        """Create SQLite database and tables"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute('''
            CREATE TABLE IF NOT EXISTS price_history (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                asin TEXT NOT NULL,
                marketplace TEXT NOT NULL,
                price REAL,
                currency TEXT,
                in_stock BOOLEAN,
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        ''')

        cursor.execute('''
            CREATE INDEX IF NOT EXISTS idx_asin_time 
            ON price_history(asin, timestamp)
        ''')

        conn.commit()
        conn.close()

    def track_product(self, asin: str, marketplace: str = 'US') -> bool:
        """Record current price for a product"""
        product = self.client.get_product(asin, marketplace)

        if not product:
            return False

        price_info = product.get('price', {})
        availability = product.get('availability', '')

        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute('''
            INSERT INTO price_history (asin, marketplace, price, currency, in_stock)
            VALUES (?, ?, ?, ?, ?)
        ''', (
            asin,
            marketplace,
            price_info.get('value'),
            price_info.get('currency'),
            'in stock' in availability.lower()
        ))

        conn.commit()
        conn.close()

        return True

    def get_price_history(self, asin: str, days: int = 30) -> pd.DataFrame:
        """Get price history as DataFrame"""
        conn = sqlite3.connect(self.db_path)

        query = f'''
            SELECT timestamp, price, in_stock
            FROM price_history
            WHERE asin = ?
            AND timestamp >= datetime('now', '-{days} days')
            ORDER BY timestamp
        '''

        df = pd.read_sql_query(query, conn, params=(asin,))
        df['timestamp'] = pd.to_datetime(df['timestamp'])

        conn.close()
        return df

    def detect_price_drop(self, asin: str, threshold: float = 0.05) -> Optional[Dict]:
        """Detect if price dropped by threshold percentage"""
        df = self.get_price_history(asin, days=7)

        if len(df) < 2:
            return None

        current_price = df.iloc[-1]['price']
        previous_price = df.iloc[-2]['price']

        if pd.notna(current_price) and pd.notna(previous_price):
            change_rate = (current_price - previous_price) / previous_price

            if change_rate <= -threshold:  # Price dropped
                return {
                    'asin': asin,
                    'previous_price': previous_price,
                    'current_price': current_price,
                    'drop_percentage': abs(change_rate) * 100,
                    'savings': previous_price - current_price
                }

        return None

    def generate_alerts(self, asin_list: List[str]) -> List[Dict]:
        """Check all products for price drops"""
        alerts = []

        for asin in asin_list:
            alert = self.detect_price_drop(asin)
            if alert:
                alerts.append(alert)

        return alerts

# Usage
tracker = PriceTracker(client)

# Track competitors
competitors = ['B08N5WRWNW', 'B07XJ8C8F5', 'B09B8RWTK3']

for asin in competitors:
    if tracker.track_product(asin):
        print(f"✓ Tracked {asin}")

# Check for price drops
alerts = tracker.generate_alerts(competitors)

if alerts:
    print("n🚨 PRICE DROP ALERTS:")
    for alert in alerts:
        print(f"  {alert['asin']}: ${alert['previous_price']:.2f} → ${alert['current_price']:.2f}")
        print(f"  💰 Save ${alert['savings']:.2f} ({alert['drop_percentage']:.1f}% off)")

from concurrent.futures import ThreadPoolExecutor, as_completed

def batch_fetch_products(client: PangolinClient, asin_list: List[str], 
                        max_workers: int = 5) -> Dict[str, Dict]:
    """Fetch multiple products concurrently"""
    results = {}

    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        # Submit all tasks
        future_to_asin = {
            executor.submit(client.get_product, asin): asin 
            for asin in asin_list
        }

        # Collect results
        for future in as_completed(future_to_asin):
            asin = future_to_asin[future]
            try:
                data = future.result()
                if data:
                    results[asin] = data
                    print(f"✓ {asin}")
            except Exception as e:
                print(f"✗ {asin}: {e}")

    return results

# Fetch 100 products in parallel
asins = [f"B08N5WRWN{i}" for i in range(100)]
results = batch_fetch_products(client, asins, max_workers=10)

print(f"n✓ Fetched {len(results)}/100 products")

from datetime import datetime, timedelta

class CachedPangolinClient(PangolinClient):
    """Client with TTL-based caching"""

    def __init__(self, cache_ttl: int = 3600):
        super().__init__()
        self.cache = {}
        self.cache_ttl = cache_ttl

    def get_product(self, asin: str, marketplace: str = 'US', 
                   use_cache: bool = True) -> Optional[Dict]:
        """Get product with caching"""
        cache_key = f"{marketplace}_{asin}"

        # Check cache
        if use_cache and cache_key in self.cache:
            data, cached_time = self.cache[cache_key]
            if datetime.now() - cached_time < timedelta(seconds=self.cache_ttl):
                print(f"💾 Cache hit: {asin}")
                return data

        # Fetch from API
        data = super().get_product(asin, marketplace)

        # Update cache
        if data:
            self.cache[cache_key] = (data, datetime.now())

        return data

# Usage
cached_client = CachedPangolinClient(cache_ttl=1800)  # 30 min cache

# First call: API request
product1 = cached_client.get_product('B08N5WRWNW')

# Second call: from cache (instant)
product2 = cached_client.get_product('B08N5WRWNW')

FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["python", "main.py"]

# .env.production
PANGOLIN_API_KEY=prod_key_here
PANGOLIN_BASE_URL=https://api.pangolinfo.com/scrape
LOG_LEVEL=INFO
CACHE_TTL=1800
MAX_WORKERS=10

import logging

def setup_logger(name: str, level=logging.INFO):
    """Configure production logging"""
    logger = logging.getLogger(name)
    logger.setLevel(level)

    # File handler
    fh = logging.FileHandler('logs/app.log')
    fh.setLevel(level)

    # Console handler
    ch = logging.StreamHandler()
    ch.setLevel(level)

    # Formatter
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    )
    fh.setFormatter(formatter)
    ch.setFormatter(formatter)

    logger.addHandler(fh)
    logger.addHandler(ch)

    return logger

logger = setup_logger('pangolin_app')
logger.info("Application started")