Mercado Libre API vs Shopify API:
Operational Differences

# ── MELI auth — token rotation must be persisted ───────────────────────────
class MELIAuth:
    def get_token(self, seller_id: str) -> str:
        refresh = self.db.get_refresh_token(seller_id)  # read from DB
        resp    = requests.post("https://api.mercadolibre.com/oauth/token", data={
            "grant_type": "refresh_token",
            "refresh_token": refresh,
            "client_id": os.environ["MELI_APP_ID"],
            "client_secret": os.environ["MELI_SECRET"],
        })
        data = resp.json()
        # CRITICAL: persist the rotated refresh token BEFORE using the access token
        self.db.set_refresh_token(seller_id, data["refresh_token"])  # must not fail
        return data["access_token"]   # valid for 6 hours

# ── Shopify auth — static, no rotation, store once ─────────────────────────
class ShopifyAuth:
    def get_headers(self, shop: str) -> dict:
        token = os.environ[f"SHOPIFY_TOKEN_{shop.upper()}"]  # never expires
        return {
            "X-Shopify-Access-Token": token,
            "Content-Type": "application/json",
        }

# ── MELI: notification is minimal — must re-fetch the resource ─────────────
def handle_meli_notification(payload: dict):
    # 1. Validate x-signature
    validate_meli_sig(payload, request.headers.get("x-signature"))

    # 2. Dedup — MELI sends same notification 2–3 times
    notif_id = payload["_id"]
    if redis.get(f"meli:notif:{notif_id}"):
        return "ok", 200   # already processed
    redis.setex(f"meli:notif:{notif_id}", 86400, "1")  # 24h TTL

    # 3. Re-fetch the full resource — payload only has the URL
    resource_url = payload["resource"]   # e.g. "/orders/123456789"
    resource     = meli_get(resource_url)
    dispatch_meli_event.delay(payload["topic"], resource)
    return "ok", 200   # respond fast — MELI retries on any delay

# ── Shopify: full payload arrives — use it directly ─────────────────────────
def handle_shopify_webhook(topic: str, payload: dict):
    # 1. Validate X-Shopify-Hmac-Sha256
    validate_shopify_hmac(request.data, request.headers.get("X-Shopify-Hmac-Sha256"))

    # 2. Use payload directly — full order/product/inventory object already here
    # Idempotency still recommended but not mandatory for dedup
    order_id = payload.get("id")
    dispatch_shopify_event.delay(topic, payload)

import time, requests
from functools import wraps

def rate_limited_request(max_per_second: float):
    """Decorator that enforces a per-second call rate with exponential backoff on 429."""
    min_interval = 1.0 / max_per_second
    last_called   = [0.0]

    def decorator(fn):
        @wraps(fn)
        def wrapper(*args, **kwargs):
            elapsed = time.time() - last_called[0]
            wait    = min_interval - elapsed
            if wait > 0:
                time.sleep(wait)
            last_called[0] = time.time()

            # Exponential backoff on 429
            for attempt in range(5):
                resp = fn(*args, **kwargs)
                if resp.status_code != 429:
                    return resp
                # Shopify provides Retry-After; MELI doesn't — use exponential fallback
                retry_after = float(resp.headers.get("Retry-After", 2 ** attempt))
                time.sleep(retry_after)

            resp.raise_for_status()   # all retries exhausted
        return wrapper
    return decorator

# MELI: 10 req/s hard limit — no burst
@rate_limited_request(9)   # 9/s gives headroom
def meli_get(path, headers): return requests.get(f"https://api.mercadolibre.com{path}", headers=headers)

# Shopify: leaky bucket — burst to 40, refills at 2/s
@rate_limited_request(1.8)  # conservative, lets bucket stay healthy
def shopify_get(url, headers): return requests.get(url, headers=headers)

SAFETY_BUFFER   = 5   # shared across both channels — absorbs cross-channel lag
MELI_RESERVED   = 2   # extra buffer for MELI specifically (slower sync ack)

def push_inventory_both_channels(sku: str, odoo_wh_id: int,
                                   meli_item_id: str, meli_site_id: str,
                                   shopify_variant_id: int, shopify_location_id: int):
    """
    Reads authoritative stock from Odoo warehouse and pushes
    to both MELI and Shopify with appropriate buffers.
    Called on: Odoo stock move, any channel order, scheduled job.
    """
    models, uid = odoo_connect()

    # Get Odoo available qty (on_hand - reserved)
    quants = models.execute_kw(ODOO_DB, uid, ODOO_KEY,
        "stock.quant", "search_read",
        [[("product_id.default_code", "=", sku),
          ("location_id.usage", "=", "internal"),
          ("location_id.warehouse_id", "=", odoo_wh_id)]],
        {"fields": ["quantity", "reserved_quantity"]}
    )
    available = sum(q["quantity"] - q["reserved_quantity"] for q in quants)
    base_qty  = max(0, int(available) - SAFETY_BUFFER)

    # Push to MELI (extra buffer — slower confirmation loop)
    meli_qty = max(0, base_qty - MELI_RESERVED)
    meli_put(
        f"/items/{meli_item_id}",
        {"available_quantity": meli_qty},
        site_id=meli_site_id,
    )

    # Push to Shopify (exact base_qty — webhook ack is fast)
    requests.post(
        f"https://{SHOPIFY_SHOP}.myshopify.com/admin/api/2024-04/inventory_levels/set.json",
        headers=shopify_headers(),
        json={
            "location_id": shopify_location_id,
            "inventory_item_id": shopify_variant_id,
            "available": base_qty,
        }
    )