amazon-subscriptions 1.0.1__py3-none-any.whl

amazon_subscriptions/parse/deliveries.py

@@ -0,0 +1,199 @@
+"""Parse the delivery cards of the landing page and the delivery pages."""
+
+import json
+import logging
+import re
+from datetime import date, datetime, timedelta, timezone
+from decimal import Decimal
+from urllib.parse import parse_qs, urlparse
+
+from bs4 import Tag
+
+from amazon_subscriptions import dates
+from amazon_subscriptions.exceptions import PageStructureError
+from amazon_subscriptions.locales.base import SubscriptionLocale
+from amazon_subscriptions.models import DeliveryItem, DiscountTier, ParseError, UpcomingDelivery
+from amazon_subscriptions.parse import selectors
+from amazon_subscriptions.parse.util import Html, attr_of, check_page, soup_of, text_of
+
+logger = logging.getLogger(__name__)
+
+
+def parse_delivery_cards(
+    html: Html, locale: SubscriptionLocale, page: str | None = None, fragment: bool = False
+) -> list[UpcomingDelivery]:
+    """Parse the delivery cards of the landing page, without items. Their ``url`` leads to the delivery page.
+
+    :param fragment: ``True`` for a fragment returned by the pagination of the deliveries widget. It is empty
+        (``<div></div>``) if there are no further deliveries, else it must have cards. The landing page must have the
+        widget, but may have no cards.
+    :raises PageStructureError: If the landing page has no deliveries widget, a fragment with content has no cards,
+        or a card has no date.
+    """
+    soup = soup_of(html)
+    check_page(soup, page)
+    cards = soup.select(selectors.DELIVERY_CARD)
+    if fragment and not cards and not soup.get_text(strip=True) and not soup.find(["img", "a", "span"]):
+        return []
+    if fragment and not cards:
+        raise PageStructureError(
+            f"No delivery cards found ({selectors.DELIVERY_CARD!r})", page, selector=selectors.DELIVERY_CARD
+        )
+    if not fragment and soup.select_one(selectors.DELIVERIES_WIDGET) is None:
+        raise PageStructureError(
+            f"No deliveries found ({selectors.DELIVERIES_WIDGET!r})", page, selector=selectors.DELIVERIES_WIDGET
+        )
+    return [_parse_card(card, locale, page) for card in cards]
+
+
+def parse_deliveries_next_url(html: Html) -> str | None:
+    """The URL of the next page of the deliveries widget, if there is one."""
+    return attr_of(soup_of(html).select_one(selectors.DELIVERIES_NEXT_PAGE), "data-next-url")
+
+
+def _parse_card(card: Tag, locale: SubscriptionLocale, page: str | None) -> UpcomingDelivery:
+    url = attr_of(card.select_one(selectors.DELIVERY_CARD_LINK), "href")
+    query = parse_qs(urlparse(url or "").query)
+    epoch_ms = _delivery_date_param(url)
+    arrival = deadline = None
+    for text in (text_of(tag) for tag in card.select("span")):
+        if text and text.startswith(locale.ARRIVAL_PREFIX):
+            arrival = locale.parse_date_parts(text)
+        elif text and text.startswith(locale.DEADLINE_PREFIX):
+            deadline = locale.parse_date_parts(text)
+    if arrival is None or not epoch_ms.isdigit():
+        raise PageStructureError(f"Delivery card without arrival date or link: {url!r}", page)
+
+    # The timestamp is only used to find the year of the rendered date.
+    reference = _date_of_epoch_ms(epoch_ms)
+    assert reference is not None
+    delivery_date = dates.resolve(arrival, lambda d, m: dates.nearest(d, m, reference))
+    if delivery_date is None:
+        raise PageStructureError(f"Delivery card with invalid arrival date: {url!r}", page)
+
+    images = len(card.select(selectors.DELIVERY_CARD_IMAGE))
+    more = re.sub(r"\D", "", text_of(card.select_one(selectors.DELIVERY_CARD_MORE_ITEMS)) or "")
+    return UpcomingDelivery(
+        date=delivery_date,
+        change_deadline=dates.resolve(deadline, lambda d, m: dates.last_on_or_before(d, m, delivery_date)),
+        discount_tier=DiscountTier(item_count=images + int(more or 0) if images else None),
+        currency=locale.currency,
+        delivery_bundle_id=next(iter(query.get("deliveryBundleId", [])), None),
+        url=url,
+    )
+
+
+def parse_delivery_page(html: Html, locale: SubscriptionLocale, page: str | None = None) -> UpcomingDelivery:
+    """Parse a delivery page with its items.
+
+    Items are not linked to subscriptions yet, see :func:`amazon_subscriptions.parse.matching.match_deliveries`.
+
+    If the page shows no delivery date, it is taken from the ``deliveryDate`` of the page URL ``page``, and the missing
+    date is noted in ``parse_errors`` of the delivery.
+
+    :raises PageStructureError: If neither the page nor its URL has a delivery date, or the page has no items.
+    """
+    soup = soup_of(html)
+    check_page(soup, page)
+    parse_errors = []
+    delivery_date = _parse_delivery_date(text_of(soup.select_one(selectors.DELIVERY_DATE)))
+    if delivery_date is None:
+        delivery_date = _date_of_epoch_ms(_delivery_date_param(page))
+        if delivery_date is None:
+            raise PageStructureError(
+                f"No delivery date found ({selectors.DELIVERY_DATE!r})", page, selector=selectors.DELIVERY_DATE
+            )
+        logger.debug(f"The delivery page shows no delivery date, so it was taken from its URL: {delivery_date}")
+        parse_errors.append(
+            ParseError(
+                url=page,
+                message="No delivery date found, it was taken from the URL",
+                selector=selectors.DELIVERY_DATE,
+            )
+        )
+
+    item_tags = soup.select(selectors.DELIVERY_ITEM)
+    if not item_tags:
+        raise PageStructureError(
+            f"No delivery items found ({selectors.DELIVERY_ITEM!r})", page, selector=selectors.DELIVERY_ITEM
+        )
+    items = [_parse_item(tag, locale) for tag in item_tags]
+
+    item_count = locale.parse_item_count(text_of(soup.select_one(selectors.DELIVERY_ITEM_COUNT)))
+    if item_count is not None and item_count != len(items):
+        logger.warning(f"Delivery of {delivery_date} states {item_count} items, but {len(items)} were found.")
+    savings_text = text_of(soup.select_one(selectors.DELIVERY_SAVINGS))
+    deadline = locale.parse_date_parts(text_of(soup.select_one(selectors.DELIVERY_EDIT_DEADLINE)))
+
+    prices = [item.price for item in items]
+    return UpcomingDelivery(
+        date=delivery_date,
+        change_deadline=dates.resolve(deadline, lambda d, m: dates.last_on_or_before(d, m, delivery_date)),
+        items=items,
+        discount_tier=DiscountTier(
+            item_count=item_count if item_count is not None else len(items),
+            max_discount_unlocked=(
+                locale.MAX_DISCOUNT_UNLOCKED_TEXT.lower() in savings_text.lower() if savings_text else None
+            ),
+            savings=locale.parse_savings(savings_text),
+        ),
+        total=sum((p for p in prices if p is not None), Decimal("0")) if None not in prices else None,
+        currency=locale.currency,
+        parse_errors=parse_errors,
+    )
+
+
+def _delivery_date_param(url: str | None) -> str:
+    """The ``deliveryDate`` of a delivery link, a timestamp in milliseconds, or ``""``."""
+    return (parse_qs(urlparse(url or "").query).get("deliveryDate") or [""])[0]
+
+
+def _date_of_epoch_ms(epoch_ms: str) -> date | None:
+    """The date of a timestamp in milliseconds that is midnight in the storefront's time zone.
+
+    The time zone is not needed: midnight at a UTC offset between -12 h (exclusive) and +12 h, which covers every
+    Amazon storefront, is between noon of the day before and noon of the day in UTC. So 12 hours later it is on
+    the day in UTC.
+    """
+    if not epoch_ms.isdigit():
+        return None
+    return (datetime.fromtimestamp(int(epoch_ms) / 1000, tz=timezone.utc) + timedelta(hours=12)).date()
+
+
+def _parse_delivery_date(text: str | None) -> date | None:
+    """The date of ``{"value":{"dateTime":"2026-10-01T00:00:00.000+02:00","zoneId":"Europe/Paris"}}``."""
+    try:
+        value = json.loads(text or "")["value"]["dateTime"]
+        # The local date of the storefront, not converted to UTC
+        return date.fromisoformat(value[:10])
+    except (ValueError, KeyError, TypeError):
+        logger.debug(f"Delivery date {text!r} was not recognized, so it was not parsed.")
+        return None
+
+
+def _item_container(tag: Tag) -> Tag:
+    """The largest element around an item tile that holds no other item, which also holds the item's alert."""
+    container = tag
+    while container.parent is not None and len(container.parent.select(selectors.DELIVERY_ITEM)) == 1:
+        container = container.parent
+    return container
+
+
+def _parse_item(tag: Tag, locale: SubscriptionLocale) -> DeliveryItem:
+    price_tag = tag.select_one(selectors.DELIVERY_ITEM_PRICE)
+    price_text = None
+    if price_tag is not None:
+        labelled = price_tag.select_one("[aria-label]")
+        price_text = attr_of(labelled, "aria-label") or text_of(price_tag, separator="")
+    alert = text_of(_item_container(tag).select_one(selectors.DELIVERY_ITEM_ALERT))
+    quantity_interval_text = text_of(tag.select_one(selectors.DELIVERY_ITEM_QUANTITY_INTERVAL))
+    quantity_interval = locale.parse_quantity_interval(quantity_interval_text)
+    return DeliveryItem(
+        title=text_of(tag.select_one(selectors.DELIVERY_ITEM_TITLE)) or "",
+        quantity=quantity_interval[0] if quantity_interval else None,
+        interval=quantity_interval[1] if quantity_interval else None,
+        price=locale.parse_amount(price_text),
+        discount_percent=locale.parse_discount_percent(text_of(tag.select_one(selectors.DELIVERY_ITEM_DISCOUNT))),
+        alert_text=alert,
+        substitute=bool(alert and locale.is_substitute_alert(alert)),
+    )

amazon_subscriptions/parse/detail.py

@@ -0,0 +1,27 @@
+"""Parse the detail sheet of a subscription, which the landing page opens for a subscription tile."""
+
+from dataclasses import dataclass
+from urllib.parse import parse_qs, urlparse
+
+from amazon_subscriptions.parse import selectors
+from amazon_subscriptions.parse.util import Html, attr_of, check_page, soup_of, text_of
+
+
+@dataclass(frozen=True)
+class BackupItem:
+    """The backup product of a subscription, sent if the subscribed product is not available."""
+
+    asin: str
+    title: str | None = None
+
+
+def parse_subscription_detail(html: Html, page: str | None = None) -> BackupItem | None:
+    """The backup product of a subscription's detail sheet, ``None`` if it has none."""
+    soup = soup_of(html)
+    check_page(soup, page)
+    link = soup.select_one(selectors.SUBSCRIPTION_DETAIL_BACKUP_LINK)
+    query = parse_qs(urlparse(attr_of(link, "href") or "").query)
+    asin = next(iter(query.get("ASIN", [])), None)
+    if link is None or not asin:
+        return None
+    return BackupItem(asin=asin, title=text_of(link.select_one(selectors.SUBSCRIPTION_DETAIL_BACKUP_TITLE)))

amazon_subscriptions/parse/matching.py

@@ -0,0 +1,100 @@
+"""Link delivery items to subscriptions.
+
+Delivery pages show neither ASIN nor subscription id, and the product images differ from the ones of the
+subscription tiles. The only link is the title, which on delivery pages is often a shortened version of the
+subscription's title. So an item is matched to a subscription by, in this order:
+
+1. equal title,
+2. the item's title being the first words of the subscription's title,
+3. elimination: a backup product (see :attr:`DeliveryItem.substitute`) is matched to the only subscription due on
+   the delivery date that has no item yet, if quantity and interval are the same.
+
+Each step only matches if exactly one subscription qualifies. Items without a unique match keep
+``subscription_id=None``. Titles are never matched by similarity, since a wrong match is worse than none.
+"""
+
+import logging
+from collections.abc import Callable, Sequence
+
+from amazon_subscriptions.models import DeliveryItem, Subscription, SubscriptionStatus, UpcomingDelivery
+
+logger = logging.getLogger(__name__)
+
+
+def _words(title: str | None) -> list[str]:
+    return (title or "").rstrip(" .…").casefold().split()
+
+
+def titles_match(a: str | None, b: str | None) -> bool:
+    """``True`` if both titles are equal, or one is the first words of the other."""
+    shorter, longer = sorted((_words(a), _words(b)), key=len)
+    return bool(shorter) and longer[: len(shorter)] == shorter
+
+
+def _is_prefix(item: DeliveryItem, subscription: Subscription) -> bool:
+    item_words, subscription_words = _words(item.title), _words(subscription.title)
+    return 0 < len(item_words) < len(subscription_words) and subscription_words[: len(item_words)] == item_words
+
+
+def _is_equal(item: DeliveryItem, subscription: Subscription) -> bool:
+    return bool(_words(item.title)) and _words(item.title) == _words(subscription.title)
+
+
+def _link(item: DeliveryItem, subscription: Subscription) -> None:
+    item.subscription_id = subscription.subscription_id
+    item.asin = subscription.asin
+
+
+def match_delivery(delivery: UpcomingDelivery, subscriptions: Sequence[Subscription]) -> None:
+    """Link the items of a delivery to their subscriptions, see the module documentation."""
+    unmatched = list(subscriptions)
+    open_items = [item for item in delivery.items if item.subscription_id is None]
+
+    rule: Callable[[DeliveryItem, Subscription], bool]
+    for rule in (_is_equal, _is_prefix):
+        for item in list(open_items):
+            candidates = [s for s in unmatched if rule(item, s)]
+            if len(candidates) == 1:
+                _link(item, candidates[0])
+                unmatched.remove(candidates[0])
+                open_items.remove(item)
+            elif len(candidates) > 1:
+                logger.warning(f"Item {item.title!r} of {delivery.date} matches {len(candidates)} subscriptions.")
+
+    substitutes = [item for item in open_items if item.substitute]
+    due = [s for s in unmatched if s.next_delivery_date == delivery.date]
+    if len(substitutes) == 1 and len(due) == 1:
+        item, subscription = substitutes[0], due[0]
+        if (item.quantity, item.interval) == (subscription.quantity, subscription.interval):
+            _link(item, subscription)
+            open_items.remove(item)
+
+    for item in open_items:
+        logger.warning(f"Item {item.title!r} of {delivery.date} matches no subscription.")
+
+
+def apply_next_delivery(subscriptions: Sequence[Subscription], deliveries: Sequence[UpcomingDelivery]) -> None:
+    """Copy price and discount of each subscription's next delivery to the subscription.
+
+    A subscription whose next delivery sends a backup product gets the status ``unavailable`` and the item's alert as
+    status text, but no price, since the price is the one of the backup product.
+    """
+    by_id = {s.subscription_id: s for s in subscriptions}
+    for delivery in deliveries:
+        for item in delivery.items:
+            subscription = by_id.get(item.subscription_id or "")
+            if subscription is None or subscription.next_delivery_date != delivery.date:
+                continue
+            if item.substitute:
+                subscription.status = SubscriptionStatus.UNAVAILABLE
+                subscription.raw_status_text = item.alert_text
+                continue
+            subscription.subscription_price = item.price
+            subscription.discount_percent = item.discount_percent
+
+
+def match_deliveries(subscriptions: Sequence[Subscription], deliveries: Sequence[UpcomingDelivery]) -> None:
+    """Link the items of all deliveries to their subscriptions and copy the next delivery's data to them."""
+    for delivery in deliveries:
+        match_delivery(delivery, subscriptions)
+    apply_next_delivery(subscriptions, deliveries)

amazon_subscriptions/parse/product.py

@@ -0,0 +1,202 @@
+"""Parse the prices of a product page (/dp/<ASIN>), which the Subscribe & Save pages do not show.
+
+A product page shows prices of many products: other variants, sponsored products and recommendations. Prices are only
+read from blocks that belong to the product of the page (by its ASIN) and, for list prices, to the offer they are shown
+for.
+"""
+
+import logging
+import re
+from dataclasses import dataclass
+from decimal import Decimal
+
+from bs4 import BeautifulSoup, Tag
+
+from amazon_subscriptions.locales.base import SubscriptionLocale
+from amazon_subscriptions.models import AlternativeOffer, ListPriceSource, ListPriceType
+from amazon_subscriptions.parse import selectors
+from amazon_subscriptions.parse.util import Html, attr_of, check_page, soup_of, text_of
+
+logger = logging.getLogger(__name__)
+
+#: ASINs in the links of a comparison widget entry
+_LINK_ASIN_RE = re.compile(r"/(?:dp|gp/product|product-reviews)/([A-Z0-9]{10})\b|[?&]pd_rd_i=([A-Z0-9]{10})\b")
+_ITEM_ID_PREFIX = "amzn1.asin."
+_SELLER_ID_RE = re.compile(r"[?&]seller=([A-Z0-9]+)")
+
+
+@dataclass(frozen=True)
+class ProductPrices:
+    """The prices of a product page. All ``None`` if the product is not available."""
+
+    #: Price of a one-time purchase in the buybox.
+    price: Decimal | None = None
+    #: List price, if the page shows one for this product.
+    list_price: Decimal | None = None
+    #: What ``list_price`` is, by its label.
+    list_price_type: ListPriceType | None = None
+    #: The block ``list_price`` was read from.
+    list_price_source: ListPriceSource | None = None
+    #: Price per unit of measure of ``price``.
+    unit_price: Decimal | None = None
+    #: Unit of measure of ``unit_price``, e.g. ``l`` or ``count``.
+    unit_price_unit: str | None = None
+    #: The cheapest other offer of the product next to the buybox offer.
+    alternative_offer: AlternativeOffer | None = None
+
+
+@dataclass(frozen=True)
+class _ListPrice:
+    amount: Decimal
+    type: ListPriceType
+    source: ListPriceSource
+
+
+def parse_product_page(html: Html, locale: SubscriptionLocale, page: str | None = None) -> ProductPrices:
+    """The prices of the product of a product page: buybox price, list price, unit price and alternative offer."""
+    soup = soup_of(html)
+    check_page(soup, page)
+    offers = soup.select(selectors.PRODUCT_OFFER)
+    buybox = next((offer for offer in offers if not _is_alternative(offer, locale)), None)
+    price = _offer_price(buybox, locale)
+    if buybox is None or price is None:
+        availability = text_of(soup.select_one(selectors.PRODUCT_AVAILABILITY))
+        logger.debug(f"No price on the product page {page or ''}: {availability or 'no availability shown'}")
+        return ProductPrices()
+
+    asin = attr_of(buybox, "data-csa-c-asin")
+    alternatives = [offer for offer in offers if _is_alternative(offer, locale) and _is_of(offer, asin)]
+    unit_price = locale.parse_unit_price(text_of(buybox.select_one(selectors.PRODUCT_UNIT_PRICE)))
+    list_price = (
+        _display_list_price(soup, offers, buybox, locale, ListPriceSource.BUYBOX)
+        or _widget_list_price(soup, asin, locale)
+        or next(
+            (
+                found
+                for offer in alternatives
+                if (found := _display_list_price(soup, offers, offer, locale, ListPriceSource.ALTERNATIVE_OFFER))
+            ),
+            None,
+        )
+    )
+
+    return ProductPrices(
+        price=price,
+        list_price=list_price.amount if list_price else None,
+        list_price_type=list_price.type if list_price else None,
+        list_price_source=list_price.source if list_price else None,
+        unit_price=unit_price[0] if unit_price else None,
+        unit_price_unit=unit_price[1] if unit_price else None,
+        alternative_offer=_cheapest_alternative(alternatives, locale),
+    )
+
+
+def _offer_row(offer: Tag) -> Tag | None:
+    """The buybox accordion row of an offer, ``None`` if the page has no accordion."""
+    return offer.find_parent(id=re.compile(r"^newAccordionRow"))
+
+
+def _is_alternative(offer: Tag, locale: SubscriptionLocale) -> bool:
+    row = _offer_row(offer)
+    return row is not None and locale.is_alternative_offers_caption(
+        text_of(row.select_one(selectors.PRODUCT_OFFER_CAPTION))
+    )
+
+
+def _is_of(block: Tag, asin: str | None) -> bool:
+    """Whether a block of the page is one of the product ``asin``. Blocks without ASIN belong to the page."""
+    block_asin = attr_of(block, "data-csa-c-asin")
+    return block_asin is None or block_asin == asin
+
+
+def _offer_price(offer: Tag | None, locale: SubscriptionLocale) -> Decimal | None:
+    return locale.parse_amount(text_of(offer.select_one(selectors.PRODUCT_PRICE))) if offer else None
+
+
+def _display_list_price(
+    soup: BeautifulSoup, offers: list[Tag], offer: Tag, locale: SubscriptionLocale, source: ListPriceSource
+) -> _ListPrice | None:
+    """The list price in the price display of an offer. Of an alternative offer, only a recommended retail price.
+
+    The center column has one price display per offer, in the order of the offers, of which only the one of the
+    selected offer is visible. A display is only used if it shows the price of its offer.
+    """
+    displays = soup.select(selectors.PRODUCT_PRICE_DISPLAY)
+    if len(displays) != len(offers):
+        logger.debug(f"{len(displays)} price displays for {len(offers)} offers, so no list price is read from them.")
+        return None
+    # Tags compare equal by their content, so the offer is found by identity
+    display = displays[next(i for i, candidate in enumerate(offers) if candidate is offer)]
+    shown = locale.parse_amount(text_of(display.select_one(selectors.PRODUCT_DISPLAY_PRICE), separator=""))
+    price = _offer_price(offer, locale)
+    if shown != price or not _is_of(display, attr_of(offer, "data-csa-c-asin")):
+        logger.debug(f"The price display shows {shown} instead of the offer's {price}, so it is not used.")
+        return None
+    for basis in display.select(selectors.PRODUCT_BASIS_PRICE):
+        list_price_type = locale.list_price_type_of(text_of(basis.select_one(selectors.PRODUCT_BASIS_PRICE_LABEL)))
+        amount = locale.parse_amount(text_of(basis.select_one(selectors.PRODUCT_BASIS_PRICE_VALUE)))
+        if list_price_type is None or amount is None:
+            continue
+        if source is ListPriceSource.BUYBOX or list_price_type is ListPriceType.RRP:
+            return _ListPrice(amount, list_price_type, source)
+    return None
+
+
+def _widget_list_price(soup: BeautifulSoup, asin: str | None, locale: SubscriptionLocale) -> _ListPrice | None:
+    """The recommended retail price of the entry of the product itself in a comparison widget.
+
+    Only the recommended retail price is read: the entry may show another offer than the buybox, and other list
+    prices belong to that offer.
+    """
+    if asin is None:
+        return None
+    for label in soup.select(f"{selectors.PRODUCT_WIDGET} {selectors.PRODUCT_WIDGET_LABEL}"):
+        if not locale.is_this_item_label(text_of(label)):
+            continue
+        entry = label.find_parent(class_=selectors.PRODUCT_WIDGET_ENTRY)
+        if entry is None or _widget_entry_asins(label, entry) != {asin}:
+            continue
+        for strike in entry.select(selectors.PRODUCT_WIDGET_STRIKE_PRICE):
+            value = text_of(strike) or ""
+            if locale.list_price_type_of((text_of(strike.parent) or "").replace(value, "")) is ListPriceType.RRP:
+                amount = locale.parse_amount(value)
+                if amount is not None:
+                    return _ListPrice(amount, ListPriceType.RRP, ListPriceSource.WIDGET)
+    return None
+
+
+def _widget_entry_asins(label: Tag, entry: Tag) -> set[str]:
+    """The ASINs of a widget entry: of its item ID, or else of its links."""
+    for parent in label.parents:
+        item_id = attr_of(parent, "data-csa-c-item-id")
+        if item_id and item_id.startswith(_ITEM_ID_PREFIX):
+            return {item_id.removeprefix(_ITEM_ID_PREFIX)}
+        if attr_of(parent, "data-feature-name"):
+            break
+    return {
+        match.group(1) or match.group(2)
+        for link in entry.select("a[href]")
+        for match in _LINK_ASIN_RE.finditer(attr_of(link, "href") or "")
+    }
+
+
+def _cheapest_alternative(alternatives: list[Tag], locale: SubscriptionLocale) -> AlternativeOffer | None:
+    found = []
+    for offer in alternatives:
+        price = _offer_price(offer, locale)
+        if price is None:
+            continue
+        unit_price = locale.parse_unit_price(text_of(offer.select_one(selectors.PRODUCT_UNIT_PRICE)))
+        row = _offer_row(offer)
+        seller_link = row.select_one(selectors.PRODUCT_OFFER_SELLER_LINK) if row else None
+        seller_id = _SELLER_ID_RE.search(attr_of(seller_link, "href") or "")
+        found.append(
+            AlternativeOffer(
+                price=price,
+                unit_price=unit_price[0] if unit_price else None,
+                unit_price_unit=unit_price[1] if unit_price else None,
+                seller=text_of(row.select_one(selectors.PRODUCT_OFFER_SELLER)) if row else None,
+                seller_id=seller_id.group(1) if seller_id else None,
+            )
+        )
+    return min(found, key=lambda offer: offer.price, default=None)

amazon_subscriptions/parse/selectors.py

@@ -0,0 +1,64 @@
+"""CSS selectors of the Subscribe & Save pages.
+
+Classes with hashes (e.g. ``_myd-hub-..._style_tile__1pKIG``) change with every deployment, so only ids, ``data-``
+attributes and stable class names are used.
+"""
+
+# Landing page (/auto-deliveries), and the fragments of its paginated subscriptions grid
+SUBSCRIPTIONS_WIDGET = "[data-acp-path*='subscriptions-card']"
+SUBSCRIPTIONS_GRID = "#subscriptionsDesktopGridLayout"
+SUBSCRIPTION_TILE = "[data-edit-url*='subscriptionId=']"
+SUBSCRIPTION_TILE_TITLE = ".a-truncate-full"
+SUBSCRIPTION_TILE_IMAGE = "img"
+SUBSCRIPTIONS_NEXT_PAGE = "[data-next-url*='/replenishment/subscriptions']"
+
+DELIVERIES_WIDGET = "[data-acp-path*='deliveries-card']"
+DELIVERY_CARD = ".hub-delivery-card"
+DELIVERY_CARD_LINK = "a[href*='deliveryDate=']"
+DELIVERY_CARD_IMAGE = "img"
+DELIVERY_CARD_MORE_ITEMS = "[class*='plusCount']"
+DELIVERIES_NEXT_PAGE = "[data-next-url*='/replenishment/fulfillment/deliveries']"
+
+# Delivery page (/auto-deliveries/?deliveryDate=...)
+DELIVERY_DATE = "[data-testid='ddp-atd-delivery-date']"
+DELIVERY_EDIT_DEADLINE = "[data-testid='delivery-edit-deadline-date-desktop']"
+DELIVERY_ITEM_COUNT = "[data-testid='delivery-item-count-desktop']"
+DELIVERY_SAVINGS = "[data-testid='savings-celebration-desktop']"
+DELIVERY_ITEM = "[data-testid='desktop-subscription-tile']"
+DELIVERY_ITEM_TITLE = "[data-testid='product-title']"
+DELIVERY_ITEM_QUANTITY_INTERVAL = "[data-testid='product-qty-frequency']"
+DELIVERY_ITEM_PRICE = "[data-testid='product-price']"
+DELIVERY_ITEM_DISCOUNT = "[data-testid='product-savings']"
+DELIVERY_ITEM_ALERT = "[data-testid='subscription-item-alert']"
+
+# Detail sheet of a subscription (/auto-deliveries/ajax/subscription/?subscriptionId=...)
+SUBSCRIPTION_DETAIL_BACKUP_LINK = "a[href*='/backupItem'][href*='ASIN=']"
+SUBSCRIPTION_DETAIL_BACKUP_TITLE = ".actionDetail"
+
+# Product page (/dp/<ASIN>). Each offer (buybox, alternative offers) is a row of the buybox accordion with the price of
+# a one-time purchase. The center column has one price display per row, in the same order, with the list price.
+PRODUCT_TITLE = "#productTitle"
+PRODUCT_AVAILABILITY = "#availability"
+PRODUCT_OFFER = "#corePrice_feature_div"
+PRODUCT_OFFER_CAPTION = "#newAccordionCaption_feature_div"
+# The seller name as the row shows it. Signed in, #sellerProfileTriggerId is a link labeled with a help text instead.
+PRODUCT_OFFER_SELLER = (
+    "[offer-display-feature-name='desktop-merchant-info-collapsed'] .offer-display-feature-text-message"
+)
+PRODUCT_OFFER_SELLER_LINK = "#sellerProfileTriggerId[href*='seller=']"
+PRODUCT_PRICE = ".apex-pricetopay-value .a-offscreen"
+PRODUCT_UNIT_PRICE = ".apex-priceperunit-accessibility-label"
+PRODUCT_PRICE_DISPLAY = "#corePriceDisplay_desktop_feature_div"
+PRODUCT_DISPLAY_PRICE = ".apex-pricetopay-value [aria-hidden]"
+PRODUCT_BASIS_PRICE = ".basisPrice"
+PRODUCT_BASIS_PRICE_LABEL = ".apex-basisprice-label"
+PRODUCT_BASIS_PRICE_VALUE = ".apex-basisprice-value .a-offscreen"
+# Comparison widgets (e.g. "Compare with similar items"), whose entry of the product itself is labeled
+PRODUCT_WIDGET = "[data-feature-name^='sims']"
+PRODUCT_WIDGET_LABEL = ".a-text-bold"
+PRODUCT_WIDGET_ENTRY = "a-cardui"
+PRODUCT_WIDGET_STRIKE_PRICE = ".a-text-strike"
+
+# Pages that are not the requested one
+CAPTCHA = ["form[action*='validateCaptcha']", "#captchacharacters", "img[src*='/captcha/']"]
+SIGN_IN = ["form[name='signIn']", "#ap_email", "#ap_password", "#auth-mfa-otpcode"]