| from __future__ import annotations |
|
|
| import json |
| from collections.abc import Iterable, Mapping, Sequence |
| from pathlib import Path |
| from typing import Any |
|
|
| from home_catalog import load_home_product_catalog |
| from search_catalog import search_home_catalog |
| from search_commerce import load_search_commerce_cards |
|
|
|
|
| EXPECTED_HOME_RAILS: tuple[tuple[str, str, int], ...] = ( |
| ("related-items", "Related to items you've viewed", 25), |
| ("best-sellers-home-kitchen", "Best Sellers in Home & Kitchen", 19), |
| ("top-sellers-toys", "Top Sellers in Toys for you", 26), |
| ( |
| "best-sellers-computers-accessories", |
| "Best Sellers in Computers & Accessories", |
| 17, |
| ), |
| ("best-sellers-books", "Best Sellers in Books", 26), |
| ("top-picks-singapore", "Top picks for Singapore", 28), |
| ( |
| "best-sellers-beauty-personal-care", |
| "Best Sellers in Beauty & Personal Care", |
| 16, |
| ), |
| ) |
|
|
| HOME_BROWSE_FIELDS = frozenset( |
| { |
| "asin", |
| "title", |
| "image_path", |
| "canonical_path", |
| "title_status", |
| "evidence_tier", |
| "evidence_class", |
| "placements", |
| } |
| ) |
|
|
| OFFER_DISPLAY_FIELDS = frozenset( |
| { |
| "asin", |
| "slug", |
| "canonical_path", |
| "title", |
| "brand", |
| "capacity", |
| "color", |
| "price_minor", |
| "list_price_minor", |
| "currency", |
| "rating", |
| "reviews", |
| "image_path", |
| "badge", |
| "evidence_class", |
| "source", |
| } |
| ) |
|
|
| DEPARTMENT_SLUGS_FIELD = "department_slugs" |
| INSTANT_POT_ASIN = "B00FLYWNYQ" |
| EXTERNAL_SSD_RANKING_ID = "external-ssd" |
| EXTERNAL_SSD_RANKING_TITLE = "Best Sellers in External Solid State Drives" |
| DEAL_MEMBERSHIP_FIELDS = frozenset( |
| { |
| "captured_discount_percent", |
| "deal_label", |
| "deals_evidence_key", |
| "discount_percent", |
| "limited_time_deal", |
| "themes", |
| } |
| ) |
|
|
|
|
| class BrowseBreadthError(ValueError): |
| pass |
|
|
|
|
| def _read_object(path: Path) -> dict[str, Any]: |
| try: |
| value = json.loads(path.read_text(encoding="utf-8")) |
| except (OSError, json.JSONDecodeError) as exc: |
| raise BrowseBreadthError(f"invalid breadth fixture {path.name}: {exc}") from exc |
| if not isinstance(value, dict): |
| raise BrowseBreadthError(f"breadth fixture {path.name} must be an object") |
| return value |
|
|
|
|
| def _home_browse_product(product: Mapping[str, Any]) -> dict[str, Any]: |
| """Return the sparse, source-backed fields safe for browse-only cards.""" |
|
|
| projected = { |
| field: product[field] |
| for field in HOME_BROWSE_FIELDS |
| if field in product |
| } |
| placements = projected.get("placements") |
| if isinstance(placements, list): |
| projected["placements"] = [dict(placement) for placement in placements] |
| return projected |
|
|
|
|
| def build_home_rail_sections( |
| catalog: Mapping[str, Mapping[str, Any]], |
| ) -> tuple[dict[str, Any], ...]: |
| """Group the 157 homepage products by their seven original source rails.""" |
|
|
| expected = {key: (title, count) for key, title, count in EXPECTED_HOME_RAILS} |
| grouped: dict[str, list[tuple[int, dict[str, Any]]]] = { |
| key: [] for key, _, _ in EXPECTED_HOME_RAILS |
| } |
| seen_asins: set[str] = set() |
|
|
| for product in catalog.values(): |
| asin = product.get("asin") |
| placements = product.get("placements") |
| if not isinstance(asin, str) or not isinstance(placements, list): |
| raise BrowseBreadthError("home products require an ASIN and placements") |
| if asin in seen_asins: |
| raise BrowseBreadthError(f"duplicate home product {asin}") |
| if len(placements) != 1 or not isinstance(placements[0], Mapping): |
| raise BrowseBreadthError( |
| f"home product {asin} must have exactly one original rail placement" |
| ) |
| placement = placements[0] |
| key = placement.get("railKey") |
| title = placement.get("railTitle") |
| ordinal = placement.get("ordinal") |
| if key not in grouped or not isinstance(ordinal, int): |
| raise BrowseBreadthError(f"home product {asin} has an unknown placement") |
| if title != expected[key][0]: |
| raise BrowseBreadthError(f"home rail {key} has an unexpected title") |
| seen_asins.add(asin) |
| grouped[key].append((ordinal, _home_browse_product(product))) |
|
|
| sections: list[dict[str, Any]] = [] |
| for key, title, expected_count in EXPECTED_HOME_RAILS: |
| products = tuple(product for _, product in sorted(grouped[key], key=lambda row: row[0])) |
| if len(products) != expected_count: |
| raise BrowseBreadthError( |
| f"home rail {key} expected {expected_count} products, found {len(products)}" |
| ) |
| sections.append( |
| { |
| "key": key, |
| "title": title, |
| "count": len(products), |
| "products": products, |
| } |
| ) |
|
|
| if len(seen_asins) != 157: |
| raise BrowseBreadthError( |
| f"home browse breadth expected 157 unique ASINs, found {len(seen_asins)}" |
| ) |
| return tuple(sections) |
|
|
|
|
| def _asins(products_or_asins: Iterable[Mapping[str, Any] | str]) -> set[str]: |
| values: set[str] = set() |
| for product in products_or_asins: |
| asin = product if isinstance(product, str) else product.get("asin") |
| if not isinstance(asin, str) or not asin: |
| raise BrowseBreadthError("offer exclusions require valid ASINs") |
| values.add(asin) |
| return values |
|
|
|
|
| def build_portable_ssd_supplement( |
| catalog: Mapping[str, Mapping[str, Any]], |
| frozen_products_or_asins: Iterable[Mapping[str, Any] | str], |
| ) -> tuple[dict[str, Any], ...]: |
| """Return browse-only homepage matches not already in the frozen nine.""" |
|
|
| frozen_asins = _asins(frozen_products_or_asins) |
| supplement = tuple( |
| _home_browse_product(product) |
| for product in search_home_catalog("portable ssd", catalog) |
| if product.get("asin") not in frozen_asins |
| ) |
| supplement_asins = [product.get("asin") for product in supplement] |
| if len(supplement_asins) != len(set(supplement_asins)): |
| raise BrowseBreadthError("portable SSD supplement contains duplicate ASINs") |
| return supplement |
|
|
|
|
| def _offer_display_product(product: Mapping[str, Any], source: str) -> dict[str, Any]: |
| asin = product.get("asin") |
| price_minor = product.get("price_minor") |
| currency = product.get("currency") |
| if not isinstance(asin, str) or not asin: |
| raise BrowseBreadthError("verified offers require an ASIN") |
| if isinstance(price_minor, bool) or not isinstance(price_minor, int) or price_minor < 0: |
| raise BrowseBreadthError(f"verified offer {asin} has an invalid price") |
| if currency != "USD": |
| raise BrowseBreadthError(f"verified offer {asin} is outside the USD baseline") |
|
|
| normalized = dict(product) |
| canonical_path = normalized.get("canonical_path") or normalized.get("canonicalPath") |
| if canonical_path is None: |
| slug = normalized.get("slug") |
| canonical_path = f"/{slug}/dp/{asin}" if isinstance(slug, str) and slug else f"/dp/{asin}" |
| normalized["canonical_path"] = canonical_path |
| normalized["source"] = source |
| return { |
| field: normalized[field] |
| for field in OFFER_DISPLAY_FIELDS |
| if field in normalized |
| } |
|
|
|
|
| def combine_verified_offer_display( |
| frozen_products: Sequence[Mapping[str, Any]], |
| direct_products: Sequence[Mapping[str, Any]], |
| ) -> tuple[dict[str, Any], ...]: |
| """Combine verified offers while letting newer direct evidence win by ASIN. |
| |
| The function never derives or adjusts a price. It only projects values from |
| the two evidence inputs, preserving frozen order and appending new direct |
| offers in their source order. |
| """ |
|
|
| offers: dict[str, dict[str, Any]] = {} |
| for product in frozen_products: |
| projected = _offer_display_product(product, "task-fixture") |
| asin = str(projected["asin"]) |
| if asin in offers: |
| raise BrowseBreadthError(f"duplicate frozen offer {asin}") |
| offers[asin] = projected |
| for product in direct_products: |
| projected = _offer_display_product(product, "direct-pdp") |
| offers[str(projected["asin"])] = projected |
| return tuple(offers.values()) |
|
|
|
|
| def build_department_commerce_supplements( |
| catalog: Mapping[str, Mapping[str, Any]], |
| frozen_fixture: Mapping[str, Any], |
| direct_fixture: Mapping[str, Any], |
| verified_offers: Sequence[Mapping[str, Any]], |
| ) -> tuple[dict[str, Any], ...]: |
| """Expose already-verified offers under their directly evidenced taxonomy. |
| |
| This is deliberately a search/category view rather than a catalog merge: |
| the 157 captured homepage cards retain their original rail membership, and |
| Deals continues to use its own explicit membership fixture. Existing rich |
| direct-PDP records win over sparse homepage duplicates; otherwise the exact |
| projected verified offer is used without deriving any commerce fact. |
| """ |
|
|
| ranking = frozen_fixture.get("ranking") |
| frozen_products = frozen_fixture.get("products") |
| direct_products = direct_fixture.get("products") |
| if ( |
| frozen_fixture.get("schema") != "amazon-clone.fixture.v1" |
| or not isinstance(ranking, Mapping) |
| or ranking.get("list_id") != EXTERNAL_SSD_RANKING_ID |
| or ranking.get("title") != EXTERNAL_SSD_RANKING_TITLE |
| or not isinstance(frozen_products, list) |
| or len(frozen_products) != 9 |
| ): |
| raise BrowseBreadthError("external SSD taxonomy evidence is invalid") |
| if ( |
| direct_fixture.get("schema") != "amazon-clone.home-pdp-evidence.v1" |
| or not isinstance(direct_products, list) |
| ): |
| raise BrowseBreadthError("direct PDP taxonomy evidence is invalid") |
|
|
| direct_by_asin = { |
| str(product.get("asin") or ""): product |
| for product in direct_products |
| if isinstance(product, Mapping) |
| } |
| instant_pot = direct_by_asin.get(INSTANT_POT_ASIN) |
| instant_detail = instant_pot.get("pdp") if isinstance(instant_pot, Mapping) else None |
| breadcrumb = ( |
| instant_detail.get("breadcrumb") |
| if isinstance(instant_detail, Mapping) |
| else None |
| ) |
| if ( |
| not isinstance(instant_detail, Mapping) |
| or instant_detail.get("page_category") != "Home & Kitchen" |
| or not isinstance(breadcrumb, list) |
| or not breadcrumb |
| or breadcrumb[0] != "Home & Kitchen" |
| ): |
| raise BrowseBreadthError("Instant Pot lacks direct Home & Kitchen taxonomy") |
|
|
| offer_by_asin: dict[str, Mapping[str, Any]] = {} |
| for offer in verified_offers: |
| asin = offer.get("asin") |
| if not isinstance(asin, str) or not asin or asin in offer_by_asin: |
| raise BrowseBreadthError("department commerce offers require unique ASINs") |
| offer_by_asin[asin] = offer |
|
|
| frozen_asins: list[str] = [] |
| for product in frozen_products: |
| asin = product.get("asin") if isinstance(product, Mapping) else None |
| if not isinstance(asin, str) or not asin or asin in frozen_asins: |
| raise BrowseBreadthError("external SSD fixture requires nine unique ASINs") |
| frozen_asins.append(asin) |
|
|
| assignments = ( |
| (INSTANT_POT_ASIN, "home-kitchen"), |
| *((asin, "computers") for asin in frozen_asins), |
| ) |
| supplements: list[dict[str, Any]] = [] |
| for asin, department_slug in assignments: |
| offer = offer_by_asin.get(asin) |
| if offer is None: |
| raise BrowseBreadthError(f"department commerce offer is missing: {asin}") |
| catalog_product = catalog.get(asin) |
| if ( |
| isinstance(catalog_product, Mapping) |
| and catalog_product.get("evidence_tier") == "pdp-direct" |
| ): |
| product = dict(catalog_product) |
| else: |
| product = dict(offer) |
|
|
| if ( |
| product.get("price_minor") != offer.get("price_minor") |
| or product.get("currency") != "USD" |
| or product.get("currency") != offer.get("currency") |
| or product.get("image_path") != offer.get("image_path") |
| or not isinstance(product.get("image_path"), str) |
| or not str(product["image_path"]).startswith("/static/") |
| ): |
| raise BrowseBreadthError( |
| f"department commerce offer changed verified facts: {asin}" |
| ) |
| if set(product).intersection(DEAL_MEMBERSHIP_FIELDS): |
| raise BrowseBreadthError( |
| f"department commerce offer contains Deals membership: {asin}" |
| ) |
| product[DEPARTMENT_SLUGS_FIELD] = (department_slug,) |
| supplements.append(product) |
|
|
| supplement_asins = [str(product["asin"]) for product in supplements] |
| if len(supplements) != 10 or len(supplement_asins) != len(set(supplement_asins)): |
| raise BrowseBreadthError("department commerce supplement must contain 10 offers") |
| return tuple(supplements) |
|
|
|
|
| def load_browse_breadth(fixture_root: Path) -> dict[str, Any]: |
| """Load all browse-breadth views from the immutable local evidence set.""" |
|
|
| root = fixture_root.resolve() |
| frozen = _read_object(root / "task-frozen-900136-v1.json") |
| direct = _read_object(root / "home-pdp-evidence.json") |
| region = frozen.get("region") |
| market = direct.get("marketContext") |
| if not isinstance(region, Mapping) or ( |
| region.get("delivery_country"), region.get("currency") |
| ) != ("Singapore", "USD"): |
| raise BrowseBreadthError("frozen offers are outside the Singapore/USD baseline") |
| if not isinstance(market, Mapping) or ( |
| market.get("deliveryCountry"), market.get("currency") |
| ) != ("Singapore", "USD"): |
| raise BrowseBreadthError("direct offers are outside the Singapore/USD baseline") |
| frozen_products = frozen.get("products") |
| direct_products = direct.get("products") |
| if not isinstance(frozen_products, list) or not isinstance(direct_products, list): |
| raise BrowseBreadthError("offer fixtures require product arrays") |
|
|
| catalog = load_home_product_catalog(root) |
| rail_sections = build_home_rail_sections(catalog) |
| supplement = build_portable_ssd_supplement(catalog, frozen_products) |
| offers = combine_verified_offer_display(frozen_products, direct_products) |
| department_supplements = build_department_commerce_supplements( |
| catalog, |
| frozen, |
| direct, |
| offers, |
| ) |
| search_commerce_cards = load_search_commerce_cards(root) |
| if len(supplement) != 27: |
| raise BrowseBreadthError( |
| f"portable SSD supplement expected 27 products, found {len(supplement)}" |
| ) |
| expected_offer_count = len( |
| { |
| str(product.get("asin") or "") |
| for product in (*frozen_products, *direct_products) |
| } |
| ) |
| if len(offers) != expected_offer_count: |
| raise BrowseBreadthError( |
| "verified offer union expected " |
| f"{expected_offer_count} products, found {len(offers)}" |
| ) |
| return { |
| "rail_sections": rail_sections, |
| "portable_ssd_supplement": supplement, |
| "verified_offers": offers, |
| "department_commerce_supplements": department_supplements, |
| "search_commerce_cards": search_commerce_cards, |
| } |
|
|
