クラウドフレアチャレンジの解決方法：イーコマース在庫モニタリング

inventory_job = {
    "canonical_product_id": "catalog-7821",
    "gtin": "0099999999999",
    "variant": {
        "color": "black",
        "size": "M",
    },
    "market": "US",
    "destination_postal_code": "94107",
    "sources": [
        "merchant_inventory_feed",
        "marketplace_api",
        "authorized_product_page",
    ],
    "alert_on": ["OUT_OF_STOCK_TO_IN_STOCK"],
}

from dataclasses import dataclass, field
from datetime import datetime, timezone

@dataclass
class InventoryObservation:
    source: str
    canonical_product_id: str
    source_item_id: str | None
    gtin: str | None
    variant: dict[str, str]
    market: str
    seller_id: str | None
    availability: str
    quantity: int | None
    quantity_confidence: str
    delivery_method: str | None
    store_id: str | None
    source_url: str | None
    evidence: dict
    parser_version: str
    observed_at: str = field(
        default_factory=lambda: datetime.now(timezone.utc).isoformat()
    )

VALID_AVAILABILITY = {
    "IN_STOCK",
    "OUT_OF_STOCK",
    "PREORDER",
    "BACKORDER",
    "LIMITED",
    "UNKNOWN",
}

CHALLENGE_TITLES = {
    "just a moment...",
    "attention required!",
}

async def classify_page(page) -> str:
    title = (await page.title()).strip().lower()
    html = (await page.content()).lower()

    if title in CHALLENGE_TITLES:
        return "CLOUDFLARE_CHALLENGE"
    if "cf-chl-" in html or "challenge-platform" in html:
        return "CLOUDFLARE_CHALLENGE"
    if await page.locator('[data-product-id]').count():
        return "PRODUCT_PAGE"
    return "UNKNOWN_PAGE"

import os
from urllib.parse import urlparse

import capsolver

capsolver.api_key = os.environ["CAPSOLVER_API_KEY"]

SOURCE_POLICY = {
    "shop.example.com": {
        "proxy_profile": "inventory_us_west",
        "max_checks_per_hour": 4,
    }
}

PROXY_VAULT = {
    "inventory_us_west": os.environ["INVENTORY_PROXY_US_WEST"],
}


def approved_host(url: str) -> str:
    host = urlparse(url).hostname
    if host not in SOURCE_POLICY:
        raise PermissionError("Inventory source is not approved")
    return host


def solve_cloudflare_challenge(
    url: str,
    chrome_user_agent: str,
    fresh_html: str = "",
) -> dict:
    host = approved_host(url)
    profile = SOURCE_POLICY[host]["proxy_profile"]

    task = {
        "type": "AntiCloudflareTask",
        "websiteURL": url,
        "proxy": PROXY_VAULT[profile],
        "userAgent": chrome_user_agent,
    }
    if fresh_html:
        task["html"] = fresh_html

    solution = capsolver.solve(task)
    cookies = solution.get("cookies") or {}
    clearance = cookies.get("cf_clearance") or solution.get("token")
    if not clearance:
        raise RuntimeError("Challenge solution did not include clearance")

    return {
        "cookies": cookies,
        "user_agent": solution.get("userAgent") or chrome_user_agent,
        "proxy_profile": profile,
    }

from urllib.parse import urlparse

async def recover_inventory_page(browser, url: str):
    host = approved_host(url)
    profile = SOURCE_POLICY[host]["proxy_profile"]
    proxy = PROXY_VAULT[profile]

    bootstrap_context = await browser.new_context(
        proxy={"server": proxy},
    )
    bootstrap_page = await bootstrap_context.new_page()
    await bootstrap_page.goto(url, wait_until="domcontentloaded")

    state = await classify_page(bootstrap_page)
    if state != "CLOUDFLARE_CHALLENGE":
        return bootstrap_context, bootstrap_page, False

    user_agent = await bootstrap_page.evaluate("navigator.userAgent")
    html = await bootstrap_page.content()

    solution = solve_cloudflare_challenge(
        url=url,
        chrome_user_agent=user_agent,
        fresh_html=html,
    )

    await bootstrap_context.close()

    context = await browser.new_context(
        proxy={"server": proxy},
        user_agent=solution["user_agent"],
    )

    cookie_domain = urlparse(url).hostname
    await context.add_cookies([
        {
            "name": name,
            "value": value,
            "domain": cookie_domain,
            "path": "/",
            "secure": True,
            "httpOnly": True,
        }
        for name, value in solution["cookies"].items()
    ])

    page = await context.new_page()
    await page.goto(url, wait_until="domcontentloaded")
    return context, page, True

import json

SCHEMA_AVAILABILITY = {
    "https://schema.org/InStock": "IN_STOCK",
    "https://schema.org/OutOfStock": "OUT_OF_STOCK",
    "https://schema.org/PreOrder": "PREORDER",
    "https://schema.org/BackOrder": "BACKORDER",
    "InStock": "IN_STOCK",
    "OutOfStock": "OUT_OF_STOCK",
}

async def read_jsonld_offers(page) -> list[dict]:
    blocks = await page.locator(
        'script[type="application/ld+json"]'
    ).all_text_contents()

    offers = []
    for raw in blocks:
        try:
            data = json.loads(raw)
        except json.JSONDecodeError:
            continue

        nodes = data if isinstance(data, list) else [data]
        for node in nodes:
            if not isinstance(node, dict):
                continue
            offer = node.get("offers")
            if isinstance(offer, dict):
                offers.append(offer)
            elif isinstance(offer, list):
                offers.extend(x for x in offer if isinstance(x, dict))
    return offers

def normalize_offer_availability(offer: dict) -> tuple[str, int | None]:
    raw = str(offer.get("availability", ""))
    availability = SCHEMA_AVAILABILITY.get(raw, "UNKNOWN")

    inventory_level = offer.get("inventoryLevel")
    quantity = None
    if isinstance(inventory_level, dict):
        value = inventory_level.get("value")
        if isinstance(value, int) and value >= 0:
            quantity = value

    return availability, quantity

def inventory_transition(previous: str, current: str) -> str | None:
    if previous == current:
        return None
    if previous in {"OUT_OF_STOCK", "UNKNOWN"} and current == "IN_STOCK":
        return "RESTOCKED"
    if previous == "IN_STOCK" and current == "OUT_OF_STOCK":
        return "SOLD_OUT"
    return "STATUS_CHANGED"

def confirmed_transition(observations: list[InventoryObservation]) -> str | None:
    if len(observations) < 3:
        return None
    older, previous, current = observations[-3:]
    if previous.availability != current.availability:
        return None
    return inventory_transition(older.availability, current.availability)