amazon-orders 4.9.1__tar.gz → 4.9.2__tar.gz

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/CHANGELOG.md

@@ -4,7 +4,22 @@ All notable changes to this project will be documented in this file.
 
 This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased](https://github.com/alexdlaird/amazon-orders/compare/4.9.1...HEAD)
+## [Unreleased](https://github.com/alexdlaird/amazon-orders/compare/4.9.2...HEAD)
+
+## [4.9.2](https://github.com/alexdlaird/amazon-orders/compare/4.9.1...4.9.2) - 2026-10-15
+
+### Added
+
+- `Constants.BROWSER_HEADERS`, `REGION_CURRENCY_OVERRIDES`, `ZERO_DECIMAL_CURRENCY_SYMBOLS`, `region_auth_cookie()`, and `region_currency_symbol()`, so a `constants_class` can override a browser's headers, or a site's auth cookie or currency symbol.
+
+### Deprecated
+
+- `AwsWafForm`'s `_solve_token()` and `_solve_visual_captcha()`, renamed to `solve_token()` and `solve_visual_captcha()`.
+
+### Fixed
+
+- Sign-in on Amazon sites other than `.com`, `.ca`, `.co.jp`, `.co.uk`, `.com.au`, `.de`, `.in`, and `.it` now checks for that site's own auth cookie.
+- Bug fixes and stability improvements.
 
 ## [4.9.1](https://github.com/alexdlaird/amazon-orders/compare/4.9.0...4.9.1) - 2026-10-14
 

{amazon_orders-4.9.1/amazon_orders.egg-info → amazon_orders-4.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amazon-orders
-Version: 4.9.1
+Version: 4.9.2
 Summary: A Python library (and CLI) for Amazon order history, line items, and transactions
 Author-email: Alex Laird <contact@alexlaird.com>
 Maintainer-email: Alex Laird <contact@alexlaird.com>
@@ -112,6 +112,7 @@ to interact with account data. [`get_order_history`](https://amazon-orders.readt
 and [`get_order`](https://amazon-orders.readthedocs.io/api.html#amazonorders.orders.AmazonOrders.get_order) are good places to start.
 
 ```python
+from amazonorders.constants import Constants
 from amazonorders.session import AmazonSession
 from amazonorders.orders import AmazonOrders
 
@@ -125,8 +126,8 @@ amazon_orders = AmazonOrders(amazon_session)
 orders = amazon_orders.get_order_history(year=2023)
 
 # Or use time filters for recent orders
-orders = amazon_orders.get_order_history(time_filter="last30")  # Last 30 days
-orders = amazon_orders.get_order_history(time_filter="months-3")  # Past 3 months
+orders = amazon_orders.get_order_history(time_filter=Constants.LAST_30_DAYS_TIME_FILTER)
+orders = amazon_orders.get_order_history(time_filter=Constants.LAST_3_MONTHS_TIME_FILTER)
 
 for order in orders:
     print(f"{order.order_number} - {order.grand_total}")
@@ -210,6 +211,9 @@ environment variables `amazon-orders` looks for are:
 
 Any other config value can be set the same way, as `AMAZON_<KEY>` (see [`AmazonOrdersConfig`](https://amazon-orders.readthedocs.io/api.html#amazonorders.conf.AmazonOrdersConfig)).
 
+A configured username also applies to `amazon-orders login --browser`: it's filled in and submitted for you, so the
+browser opens on Amazon's password or passkey step. The browser never fills in your password.
+
 ### Languages and Regions
 
 `amazon-orders` reads Amazon's pages in English. The `.com` site is validated nightly.
@@ -223,10 +227,10 @@ Any other config value can be set the same way, as `AMAZON_<KEY>` (see [`AmazonO
 
 ### AI Assistants
 
-To ask an AI assistant about your Amazon orders, use
-[`amazon-orders-mcp`](https://github.com/alexdlaird/amazon-orders-mcp#readme), an MCP server built on `amazon-orders`. It
-reuses the session `amazon-orders login --browser` saves, so it never sees your credentials. See its README for setup
-with Claude and other MCP clients.
+An AI assistant has two ways to use `amazon-orders`. One that runs commands uses the CLI or the library directly, just
+as shown above. Any MCP client gets the same as tools through
+[`amazon-orders-mcp`](https://github.com/alexdlaird/amazon-orders-mcp#readme), a server built on `amazon-orders` — see
+its README for setup.
 
 ## Documentation
 

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/README.md

@@ -36,6 +36,7 @@ to interact with account data. [`get_order_history`](https://amazon-orders.readt
 and [`get_order`](https://amazon-orders.readthedocs.io/api.html#amazonorders.orders.AmazonOrders.get_order) are good places to start.
 
 ```python
+from amazonorders.constants import Constants
 from amazonorders.session import AmazonSession
 from amazonorders.orders import AmazonOrders
 
@@ -49,8 +50,8 @@ amazon_orders = AmazonOrders(amazon_session)
 orders = amazon_orders.get_order_history(year=2023)
 
 # Or use time filters for recent orders
-orders = amazon_orders.get_order_history(time_filter="last30")  # Last 30 days
-orders = amazon_orders.get_order_history(time_filter="months-3")  # Past 3 months
+orders = amazon_orders.get_order_history(time_filter=Constants.LAST_30_DAYS_TIME_FILTER)
+orders = amazon_orders.get_order_history(time_filter=Constants.LAST_3_MONTHS_TIME_FILTER)
 
 for order in orders:
     print(f"{order.order_number} - {order.grand_total}")
@@ -134,6 +135,9 @@ environment variables `amazon-orders` looks for are:
 
 Any other config value can be set the same way, as `AMAZON_<KEY>` (see [`AmazonOrdersConfig`](https://amazon-orders.readthedocs.io/api.html#amazonorders.conf.AmazonOrdersConfig)).
 
+A configured username also applies to `amazon-orders login --browser`: it's filled in and submitted for you, so the
+browser opens on Amazon's password or passkey step. The browser never fills in your password.
+
 ### Languages and Regions
 
 `amazon-orders` reads Amazon's pages in English. The `.com` site is validated nightly.
@@ -147,10 +151,10 @@ Any other config value can be set the same way, as `AMAZON_<KEY>` (see [`AmazonO
 
 ### AI Assistants
 
-To ask an AI assistant about your Amazon orders, use
-[`amazon-orders-mcp`](https://github.com/alexdlaird/amazon-orders-mcp#readme), an MCP server built on `amazon-orders`. It
-reuses the session `amazon-orders login --browser` saves, so it never sees your credentials. See its README for setup
-with Claude and other MCP clients.
+An AI assistant has two ways to use `amazon-orders`. One that runs commands uses the CLI or the library directly, just
+as shown above. Any MCP client gets the same as tools through
+[`amazon-orders-mcp`](https://github.com/alexdlaird/amazon-orders-mcp#readme), a server built on `amazon-orders` — see
+its README for setup.
 
 ## Documentation
 

{amazon_orders-4.9.1 → amazon_orders-4.9.2/amazon_orders.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amazon-orders
-Version: 4.9.1
+Version: 4.9.2
 Summary: A Python library (and CLI) for Amazon order history, line items, and transactions
 Author-email: Alex Laird <contact@alexlaird.com>
 Maintainer-email: Alex Laird <contact@alexlaird.com>
@@ -112,6 +112,7 @@ to interact with account data. [`get_order_history`](https://amazon-orders.readt
 and [`get_order`](https://amazon-orders.readthedocs.io/api.html#amazonorders.orders.AmazonOrders.get_order) are good places to start.
 
 ```python
+from amazonorders.constants import Constants
 from amazonorders.session import AmazonSession
 from amazonorders.orders import AmazonOrders
 
@@ -125,8 +126,8 @@ amazon_orders = AmazonOrders(amazon_session)
 orders = amazon_orders.get_order_history(year=2023)
 
 # Or use time filters for recent orders
-orders = amazon_orders.get_order_history(time_filter="last30")  # Last 30 days
-orders = amazon_orders.get_order_history(time_filter="months-3")  # Past 3 months
+orders = amazon_orders.get_order_history(time_filter=Constants.LAST_30_DAYS_TIME_FILTER)
+orders = amazon_orders.get_order_history(time_filter=Constants.LAST_3_MONTHS_TIME_FILTER)
 
 for order in orders:
     print(f"{order.order_number} - {order.grand_total}")
@@ -210,6 +211,9 @@ environment variables `amazon-orders` looks for are:
 
 Any other config value can be set the same way, as `AMAZON_<KEY>` (see [`AmazonOrdersConfig`](https://amazon-orders.readthedocs.io/api.html#amazonorders.conf.AmazonOrdersConfig)).
 
+A configured username also applies to `amazon-orders login --browser`: it's filled in and submitted for you, so the
+browser opens on Amazon's password or passkey step. The browser never fills in your password.
+
 ### Languages and Regions
 
 `amazon-orders` reads Amazon's pages in English. The `.com` site is validated nightly.
@@ -223,10 +227,10 @@ Any other config value can be set the same way, as `AMAZON_<KEY>` (see [`AmazonO
 
 ### AI Assistants
 
-To ask an AI assistant about your Amazon orders, use
-[`amazon-orders-mcp`](https://github.com/alexdlaird/amazon-orders-mcp#readme), an MCP server built on `amazon-orders`. It
-reuses the session `amazon-orders login --browser` saves, so it never sees your credentials. See its README for setup
-with Claude and other MCP clients.
+An AI assistant has two ways to use `amazon-orders`. One that runs commands uses the CLI or the library directly, just
+as shown above. Any MCP client gets the same as tools through
+[`amazon-orders-mcp`](https://github.com/alexdlaird/amazon-orders-mcp#readme), a server built on `amazon-orders` — see
+its README for setup.
 
 ## Documentation
 

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/amazonorders/__init__.py

@@ -1,3 +1,3 @@
 __copyright__ = "Copyright (c) 2024-2025 Alex Laird"
 __license__ = "MIT"
-__version__ = "4.9.1"
+__version__ = "4.9.2"

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/amazonorders/cli.py

@@ -331,10 +331,10 @@ def history(ctx: Context,
         # Determine time filter
         time_filter = None
         if last_30_days:
-            time_filter = "last30"
+            time_filter = amazon_session.config.constants.LAST_30_DAYS_TIME_FILTER
             filter_description = "last 30 days"
         elif last_3_months:
-            time_filter = "months-3"
+            time_filter = amazon_session.config.constants.LAST_3_MONTHS_TIME_FILTER
             filter_description = "past 3 months"
         else:
             if year is None:

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/amazonorders/constants.py

@@ -5,7 +5,7 @@ import logging
 import os
 import re
 from datetime import date
-from typing import Dict, Optional, Union
+from typing import Dict, List, Optional, Union
 from urllib.parse import urlencode, urlparse
 
 from amazonorders import util
@@ -14,64 +14,6 @@ from amazonorders.region_data import REGION_SITES
 
 logger = logging.getLogger(__name__)
 
-#: Browser-specific header overrides applied on top of the class-level ``BASE_HEADERS``
-#: (which already reflects the Chromium fingerprint). A ``None`` value removes the key
-#: (used to strip headers absent in that engine). ``Accept-Language`` here is the browser
-#: default; domain-specific TLD overrides still apply on top via :func:`~Constants._apply_domain`.
-_BROWSER_PRESETS: Dict[str, Dict[str, Optional[str]]] = {
-    "chromium": {},  # BASE_HEADERS already reflects the Chromium fingerprint; no overrides needed.
-    "firefox": {
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        "Accept-Language": "en-US,en;q=0.5",
-        "Sec-Ch-Ua": None,
-        "Sec-Ch-Ua-Mobile": None,
-        "Sec-Ch-Ua-Platform": None,
-        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:146.0) Gecko/20100101 Firefox/146.0",
-    },
-    "webkit": {
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        "Accept-Encoding": "gzip, deflate",
-        "Priority": "u=0, i",
-        "Sec-Ch-Ua": None,
-        "Sec-Ch-Ua-Mobile": None,
-        "Sec-Ch-Ua-Platform": None,
-        "Sec-Fetch-User": None,
-        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.6 Safari/605.1.15",  # noqa: E501
-    },
-}
-
-#: ``CURRENCY_SYMBOL`` values for Amazon sites that their own pages don't give, or give wrong, keyed by the TLD
-#: suffix that follows ``amazon.``. These take precedence over the generated region data.
-_REGION_CURRENCY_OVERRIDES: Dict[str, str] = {}
-
-#: Currency symbols whose amounts are rendered without decimals (yen has no minor unit).
-_ZERO_DECIMAL_CURRENCY_SYMBOLS = ["¥", "￥"]
-
-#: The cookie that marks an authenticated session on regional Amazon sites, keyed by the TLD
-#: suffix that follows ``amazon.``. Applied only when ``COOKIES_SET_WHEN_AUTHENTICATED`` still
-#: has the default ``x-main``, so a ``constants_class`` override wins. Unknown TLDs keep the default.
-_REGION_AUTH_COOKIES = {
-    "ca": "x-acbca",
-    "co.jp": "x-acbjp",
-    "co.uk": "x-acbuk",
-    "com.au": "x-acbau",
-    "de": "x-acbde",
-    "in": "x-acbin",
-    "it": "x-acbit",
-}
-
-
-def _region_currency_symbol(tld: str) -> Optional[str]:
-    """
-    The currency symbol an Amazon site's prices are shown with: its ``_REGION_CURRENCY_OVERRIDES`` entry, if it has
-    one, otherwise its region data.
-
-    :param tld: The TLD suffix that follows ``amazon.`` (e.g. ``co.uk``).
-    :return: The currency symbol, or ``None`` if the site's isn't known.
-    """
-    site = REGION_SITES.get(tld)
-    return _REGION_CURRENCY_OVERRIDES.get(tld) or (site.currency_symbol if site else None)
-
 
 class Constants:
     """
@@ -129,6 +71,10 @@ class Constants:
     ORDER_FILTER_QUERY_PARAM = "orderFilter"
     HISTORY_PAGE_QUERY_PARAM = "page"
     HISTORY_START_INDEX_QUERY_PARAM = "startIndex"
+    ORDER_ID_QUERY_PARAM = "orderID"
+    LAST_30_DAYS_TIME_FILTER = "last30"
+    LAST_3_MONTHS_TIME_FILTER = "months-3"
+    YEAR_TIME_FILTER_PREFIX = "year-"
     ORDER_HISTORY_PAGE_SIZE = 10
     WHOLE_FOODS_DETAILS_ROUTES = ["/fopo/order-details", "/wholefoodsmarket/receipts/order/"]
     TRACKING_ROUTE = "/progress-tracker/package"
@@ -174,6 +120,27 @@ class Constants:
         "Upgrade-Insecure-Requests": "1",
         "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36",  # noqa: E501
     }
+    #: ``BASE_HEADERS`` changes for each ``browser`` that isn't Chromium-based. A ``None`` value removes the header.
+    BROWSER_HEADERS: Dict[str, Dict[str, Optional[str]]] = {
+        "firefox": {
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            "Accept-Language": "en-US,en;q=0.5",
+            "Sec-Ch-Ua": None,
+            "Sec-Ch-Ua-Mobile": None,
+            "Sec-Ch-Ua-Platform": None,
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:146.0) Gecko/20100101 Firefox/146.0",
+        },
+        "webkit": {
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            "Accept-Encoding": "gzip, deflate",
+            "Priority": "u=0, i",
+            "Sec-Ch-Ua": None,
+            "Sec-Ch-Ua-Mobile": None,
+            "Sec-Ch-Ua-Platform": None,
+            "Sec-Fetch-User": None,
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.6 Safari/605.1.15",  # noqa: E501
+        },
+    }
     #: Cookies sent with every request to the active Amazon domain, replacing any cookie of the same name Amazon
     #: set, for a site that picks something like its language from a cookie (e.g. ``{"lc-acbde": "de_DE"}`` for
     #: German pages on amazon.de). Left at its default, it's set to the English language cookie of the active site,
@@ -189,6 +156,7 @@ class Constants:
     JS_ROBOT_TEXT_REGEX = r"[.\s\S]*verify that you're not a robot[.\s\S]*Enable JavaScript[.\s\S]*"
     GOKU_PROPS_REGEX = r"window\.gokuProps\s*=\s*(\{.*?\});"
     ACIC_CHALLENGE_PATH = "/ax/aaut/verify/ap/challenge"
+    WAF_TOKEN_COOKIE = "aws-waf-token"
 
     ##########################################################################
     # Formats
@@ -198,6 +166,10 @@ class Constants:
     THOUSANDS_SEPARATOR = ","
     #: The symbol :func:`format_currency` renders. Each known Amazon site sets its own; this is the fallback.
     CURRENCY_SYMBOL = "$"
+    #: ``CURRENCY_SYMBOL`` for each site by the TLD that follows ``amazon.``, taking precedence over its region data.
+    REGION_CURRENCY_OVERRIDES: Dict[str, str] = {}
+    #: Currency symbols :func:`format_currency` renders without decimals.
+    ZERO_DECIMAL_CURRENCY_SYMBOLS: List[str] = ["¥", "￥"]
     CURRENCY_FORMAT = "{symbol}{amount}"
     CURRENCY_FREE_TEXT = "free"
     #: Order numbers by shape: ``111-…`` and digital ``D01-…`` IDs, older ``4000-…`` IDs (still listed on
@@ -213,18 +185,134 @@ class Constants:
             domain, browser = environment.get("domain"), environment.get("browser")
         if not domain:
             domain = self._deprecated_base_url()
-        self._apply_browser(browser or "chromium")
+        if browser:
+            self._apply_browser(browser)
         if domain:
             self._apply_domain(domain)
         self._apply_language_cookie(self._tld(self.BASE_URL))
 
-    @staticmethod
-    def _deprecated_base_url() -> Optional[str]:
-        base_url = os.environ.get("AMAZON_BASE_URL")
-        if base_url:
-            logger.warning("AMAZON_BASE_URL is deprecated and will be removed in the next major release. Use "
-                           "AMAZON_DOMAIN instead.")
-        return base_url
+    def format_currency(self,
+                        amount: float) -> str:
+        """
+        Format an amount for display, using ``CURRENCY_SYMBOL``, ``DECIMAL_SEPARATOR``,
+        ``THOUSANDS_SEPARATOR``, and the ``CURRENCY_FORMAT`` template (which places the
+        ``{symbol}`` and ``{amount}``, e.g. ``"{amount} {symbol}"`` renders ``1.234,56 €``). A
+        negative amount is prefixed with ``-``.
+
+        :param amount: The amount to format.
+        :return: The formatted amount.
+        """
+        decimals = 0 if self.CURRENCY_SYMBOL in self.ZERO_DECIMAL_CURRENCY_SYMBOLS else 2
+        integer, _, fraction = "{amount:,.{decimals}f}".format(amount=abs(amount), decimals=decimals).partition(".")
+        formatted_number = integer.replace(",", self.THOUSANDS_SEPARATOR)
+        if fraction:
+            formatted_number += f"{self.DECIMAL_SEPARATOR}{fraction}"
+        formatted_amt = self.CURRENCY_FORMAT.format(symbol=self.CURRENCY_SYMBOL, amount=formatted_number)
+        if round(amount, decimals) < 0:
+            return f"-{formatted_amt}"
+        return formatted_amt
+
+    def parse_currency(self,
+                       value: Union[str, int, float]) -> Union[int, float, None]:
+        """
+        Parse a currency amount as rendered on the page, stripping non-numeric values and returning it
+        as a primitive.
+
+        Strips any currency symbol (e.g. ``$``, ``€``, or the fullwidth ``￥`` used by amazon.co.jp) and
+        currency-code letters (e.g. ``CDN$``, ``AED``, or ``zł``), accepts accounting-style negatives in
+        parentheses (e.g. ``($1.99)``), and treats :attr:`CURRENCY_FREE_TEXT` as ``0.0``. Either decimal mark
+        is accepted: a trailing ``.`` or ``,`` followed by one or two digits is the decimal mark, and other
+        ``.``, ``,``, ``'``, and space separators group thousands (e.g. ``1,234.56``, ``1.234,56 €``, or
+        ``12,99 €``).
+
+        :param value: The currency to parse.
+        :return: The currency as a primitive, or ``None`` if it could not be parsed.
+        """
+        if isinstance(value, (int, float)):
+            return value
+
+        if not value:
+            return None
+
+        value = value.strip()
+
+        if value.casefold() == self.CURRENCY_FREE_TEXT.casefold():
+            return 0.0
+
+        if value.startswith("(") and value.endswith(")"):
+            value = "-" + value[1:-1]
+
+        value = util.strip_currency_text(value.replace("\u2212", "-"))
+        currency = util.to_type(util.to_decimal_point(value))
+
+        if isinstance(currency, str):
+            return None
+
+        return currency
+
+    def parse_date(self,
+                   value: Optional[str],
+                   fuzzy: bool = False) -> Optional[date]:
+        """
+        Parse a date as rendered on the page. Delegates to :func:`~amazonorders.util.to_date`.
+
+        :param value: The date string to parse.
+        :param fuzzy: Whether to ignore unknown tokens when parsing.
+        :return: The parsed ``date``, or ``None`` if it could not be parsed.
+        """
+        return util.to_date(value, fuzzy=fuzzy)
+
+    def parse_count(self,
+                    value: str,
+                    pattern: str = r"^\s*{count}") -> Optional[int]:
+        """
+        Parse a whole number as rendered on the page. Delegates to :func:`~amazonorders.util.to_count`.
+
+        :param value: The text containing the number.
+        :param pattern: A regex locating the number, with ``{count}`` marking where it appears. Defaults to a
+            number at the start of the text.
+        :return: The number, or ``None`` if ``pattern`` does not match.
+        """
+        return util.to_count(value, pattern)
+
+    def parse_order_number(self,
+                           value: str) -> Optional[str]:
+        """
+        Find an Order number, as matched by :attr:`ORDER_NUMBER_REGEX`, in text from the page.
+
+        :param value: The text containing the Order number.
+        :return: The Order number, or ``None`` if the text does not contain one.
+        """
+        match = re.search(self.ORDER_NUMBER_REGEX, value)
+        return match.group(0) if match else None
+
+    @classmethod
+    def region_auth_cookie(cls,
+                           tld: str) -> Optional[str]:
+        """
+        The cookie that marks an authenticated session on an Amazon site: its language cookie, with ``lc-`` swapped
+        for ``x-`` (e.g. ``lc-acbde`` and ``x-acbde``, or ``.com``'s ``lc-main`` and ``x-main``).
+
+        :param tld: The TLD suffix that follows ``amazon.`` (e.g. ``co.uk``).
+        :return: The cookie's name, or ``None`` if the site's isn't known.
+        """
+        site = REGION_SITES.get(tld)
+        if not site or not site.language_cookie or not site.language_cookie.startswith("lc-"):
+            return None
+        return f"x-{site.language_cookie[len('lc-'):]}"
+
+    @classmethod
+    def region_currency_symbol(cls,
+                               tld: str) -> Optional[str]:
+        """
+        The currency symbol an Amazon site's prices are shown with: its ``REGION_CURRENCY_OVERRIDES`` entry, if it
+        has one, otherwise its region data.
+
+        :param tld: The TLD suffix that follows ``amazon.`` (e.g. ``co.uk``).
+        :return: The currency symbol, or ``None`` if the site's isn't known.
+        """
+        site = REGION_SITES.get(tld)
+        return cls.REGION_CURRENCY_OVERRIDES.get(tld) or (site.currency_symbol if site else None)
 
     def _apply_browser(self,
                        browser: str) -> None:
@@ -232,14 +320,14 @@ class Constants:
         Apply browser-specific header overrides for the given browser engine. A header a subclass changed from
         the default keeps its value.
 
-        :param browser: The browser that signs in, e.g. ``"chrome"``, ``"msedge"``, ``"firefox"``. A browser without
-            headers here, like Chrome or Edge, is Chromium-based, so ``BASE_HEADERS`` is left unchanged.
+        :param browser: The browser that signs in, e.g. ``"chrome"``, ``"msedge"``, ``"firefox"``. A browser not in
+            ``BROWSER_HEADERS``, like Chrome or Edge, is Chromium-based, so ``BASE_HEADERS`` is left unchanged.
         """
-        preset = _BROWSER_PRESETS.get(browser)
-        if preset is None:
+        browser_headers = self.BROWSER_HEADERS.get(browser)
+        if browser_headers is None:
             return
         headers = dict(type(self).BASE_HEADERS)
-        for key, value in preset.items():
+        for key, value in browser_headers.items():
             if headers.get(key) != Constants.BASE_HEADERS.get(key):
                 continue
             if value is None:
@@ -294,13 +382,13 @@ class Constants:
             headers["Accept-Language"] = self._english_accept_language(site.english_locale, headers["Accept-Language"])
         self.BASE_HEADERS = headers
 
-        currency_symbol = _region_currency_symbol(tld)
+        currency_symbol = self.region_currency_symbol(tld)
         if currency_symbol and type(self).CURRENCY_SYMBOL == Constants.CURRENCY_SYMBOL:
             self.CURRENCY_SYMBOL = currency_symbol
 
-        if (tld in _REGION_AUTH_COOKIES and
-                type(self).COOKIES_SET_WHEN_AUTHENTICATED == Constants.COOKIES_SET_WHEN_AUTHENTICATED):
-            self.COOKIES_SET_WHEN_AUTHENTICATED = [_REGION_AUTH_COOKIES[tld]]
+        auth_cookie = self.region_auth_cookie(tld)
+        if auth_cookie and type(self).COOKIES_SET_WHEN_AUTHENTICATED == Constants.COOKIES_SET_WHEN_AUTHENTICATED:
+            self.COOKIES_SET_WHEN_AUTHENTICATED = [auth_cookie]
 
     def _apply_language_cookie(self,
                                tld: str) -> None:
@@ -344,97 +432,10 @@ class Constants:
             return f"https://{value}"
         return f"https://www.{value}"
 
-    def format_currency(self,
-                        amount: float) -> str:
-        """
-        Format an amount for display, using ``CURRENCY_SYMBOL``, ``DECIMAL_SEPARATOR``,
-        ``THOUSANDS_SEPARATOR``, and the ``CURRENCY_FORMAT`` template (which places the
-        ``{symbol}`` and ``{amount}``, e.g. ``"{amount} {symbol}"`` renders ``1.234,56 €``). A
-        negative amount is prefixed with ``-``.
-
-        :param amount: The amount to format.
-        :return: The formatted amount.
-        """
-        decimals = 0 if self.CURRENCY_SYMBOL in _ZERO_DECIMAL_CURRENCY_SYMBOLS else 2
-        integer, _, fraction = "{amount:,.{decimals}f}".format(amount=abs(amount), decimals=decimals).partition(".")
-        formatted_number = integer.replace(",", self.THOUSANDS_SEPARATOR)
-        if fraction:
-            formatted_number += f"{self.DECIMAL_SEPARATOR}{fraction}"
-        formatted_amt = self.CURRENCY_FORMAT.format(symbol=self.CURRENCY_SYMBOL, amount=formatted_number)
-        if round(amount, decimals) < 0:
-            return f"-{formatted_amt}"
-        return formatted_amt
-
-    def parse_currency(self,
-                       value: Union[str, int, float]) -> Union[int, float, None]:
-        """
-        Parse a currency amount as rendered on the page, stripping non-numeric values and returning it
-        as a primitive.
-
-        Strips any currency symbol (e.g. ``$``, ``€``, or the fullwidth ``￥`` used by amazon.co.jp) and
-        currency-code letters (e.g. ``CDN$``, ``AED``, or ``zł``), accepts accounting-style negatives in
-        parentheses (e.g. ``($1.99)``), and treats :attr:`CURRENCY_FREE_TEXT` as ``0.0``. Either decimal mark
-        is accepted: a trailing ``.`` or ``,`` followed by one or two digits is the decimal mark, and other
-        ``.``, ``,``, ``'``, and space separators group thousands (e.g. ``1,234.56``, ``1.234,56 €``, or
-        ``12,99 €``).
-
-        :param value: The currency to parse.
-        :return: The currency as a primitive, or ``None`` if it could not be parsed.
-        """
-        if isinstance(value, (int, float)):
-            return value
-
-        if not value:
-            return None
-
-        value = value.strip()
-
-        if value.casefold() == self.CURRENCY_FREE_TEXT.casefold():
-            return 0.0
-
-        if value.startswith("(") and value.endswith(")"):
-            value = "-" + value[1:-1]
-
-        value = util.strip_currency_text(value.replace("\u2212", "-"))
-        currency = util.to_type(util.to_decimal_point(value))
-
-        if isinstance(currency, str):
-            return None
-
-        return currency
-
-    def parse_date(self,
-                   value: Optional[str],
-                   fuzzy: bool = False) -> Optional[date]:
-        """
-        Parse a date as rendered on the page. Delegates to :func:`~amazonorders.util.to_date`.
-
-        :param value: The date string to parse.
-        :param fuzzy: Whether to ignore unknown tokens when parsing.
-        :return: The parsed ``date``, or ``None`` if it could not be parsed.
-        """
-        return util.to_date(value, fuzzy=fuzzy)
-
-    def parse_count(self,
-                    value: str,
-                    pattern: str = r"^\s*{count}") -> Optional[int]:
-        """
-        Parse a whole number as rendered on the page. Delegates to :func:`~amazonorders.util.to_count`.
-
-        :param value: The text containing the number.
-        :param pattern: A regex locating the number, with ``{count}`` marking where it appears. Defaults to a
-            number at the start of the text.
-        :return: The number, or ``None`` if ``pattern`` does not match.
-        """
-        return util.to_count(value, pattern)
-
-    def parse_order_number(self,
-                           value: str) -> Optional[str]:
-        """
-        Find an Order number, as matched by :attr:`ORDER_NUMBER_REGEX`, in text from the page.
-
-        :param value: The text containing the Order number.
-        :return: The Order number, or ``None`` if the text does not contain one.
-        """
-        match = re.search(self.ORDER_NUMBER_REGEX, value)
-        return match.group(0) if match else None
+    @staticmethod
+    def _deprecated_base_url() -> Optional[str]:
+        base_url = os.environ.get("AMAZON_BASE_URL")
+        if base_url:
+            logger.warning("AMAZON_BASE_URL is deprecated and will be removed in the next major release. Use "
+                           "AMAZON_DOMAIN instead.")
+        return base_url

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/amazonorders/contrib/browser/playwright.py

@@ -36,6 +36,7 @@ logger = logging.getLogger(__name__)
 BODY_TEXT_LENGTH_JS = "() => (document.body && document.body.innerText || '').length"
 SIGN_IN_POLL_INTERVAL_MS = 2000
 SIGN_IN_SETTLE_MS = 2000
+SIGN_IN_PREFILL_TIMEOUT_MS = 5000
 
 
 class PlaywrightBrowserLauncher:
@@ -488,7 +489,7 @@ class PlaywrightAcicForm(PlaywrightAuthForm):
             return False
 
         try:
-            token = waf_form._solve_token(page.url, goku, challenge_script)
+            token = waf_form.solve_token(page.url, goku, challenge_script)
         except AmazonOrdersWafSolverError:
             raise
         except Exception:
@@ -501,7 +502,7 @@ class PlaywrightAcicForm(PlaywrightAuthForm):
 
         domain = urlparse(page.url).netloc
         context.add_cookies([{
-            "name": "aws-waf-token",
+            "name": self.config.constants.WAF_TOKEN_COOKIE,
             "value": token,
             "domain": f".{domain}",
             "path": "/",
@@ -575,7 +576,7 @@ class PlaywrightAcicForm(PlaywrightAuthForm):
             return False
 
         try:
-            answer = waf_form._solve_visual_captcha(page.url, challenge_images, question)
+            answer = waf_form.solve_visual_captcha(page.url, challenge_images, question)
         except AmazonOrdersWafSolverError:
             raise
         except Exception:
@@ -825,6 +826,7 @@ class PlaywrightBrowserLogin:
                 context = browser.new_context(user_agent=constants.BASE_HEADERS.get("User-Agent"))
                 page = context.new_page()
                 page.goto(sign_in_url)
+                self._prefill_username(page)
 
                 message = ("Info: A browser window has opened. Sign in to Amazon there, and this will continue "
                            "once you're signed in.")
@@ -841,6 +843,28 @@ class PlaywrightBrowserLogin:
 
         self._verify_session()
 
+    def _prefill_username(self,
+                          page: Any) -> None:
+        """
+        Best effort: if a username is configured, fill it into Amazon's email field and submit it, so the browser
+        opens on the password or passkey step. Skipped silently when there's no username, the field is missing or
+        already filled, or anything about it fails, since the sign-in then continues by hand as usual.
+        """
+        username = self.amazon_session.username
+        if not username:
+            return
+
+        try:
+            email_input = page.locator(self.config.selectors.SIGN_IN_EMAIL_INPUT_SELECTOR).first
+            email_input.wait_for(state="visible", timeout=SIGN_IN_PREFILL_TIMEOUT_MS)
+            if email_input.input_value():
+                return
+
+            email_input.fill(username)
+            email_input.press("Enter")
+        except Exception as e:
+            logger.debug(f"Skipped pre-filling the username in the browser: {e}")
+
     def _require_display(self) -> None:
         if (not self.headless and sys.platform.startswith("linux") and
                 not (os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY"))):

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/amazonorders/contrib/waf/anticaptcha.py

@@ -20,10 +20,10 @@ class AntiCaptchaWafForm(AwsWafForm):
     API_KEY_ENV_VAR = "ANTICAPTCHA_API_KEY"
     PROVIDER_NAME = "Anti-Captcha"
 
-    def _solve_token(self,
-                     url: str,
-                     goku: Dict[str, Any],
-                     challenge_script: str) -> str:
+    def solve_token(self,
+                    url: str,
+                    goku: Dict[str, Any],
+                    challenge_script: str) -> str:
         """
         Solve the AWS WAF challenge via Anti-Captcha's ``AmazonTaskProxyless``
         task type and return the ``aws-waf-token`` cookie value.

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/amazonorders/contrib/waf/base.py

@@ -5,6 +5,7 @@ import json
 import logging
 import os
 import re
+import warnings
 from typing import Any, ClassVar, Dict, Optional, TYPE_CHECKING
 from urllib.parse import urlparse
 
@@ -25,7 +26,7 @@ logger = logging.getLogger(__name__)
 class AwsWafForm(AuthForm):
     """
     Shared base for AWS WAF JavaScript challenge solvers. Subclasses implement
-    :func:`_solve_token` to call a third-party solver and return the
+    :func:`solve_token` to call a third-party solver and return the
     ``aws-waf-token`` cookie value.
 
     This base class handles detection (the ``window.gokuProps`` blob plus the
@@ -101,7 +102,7 @@ class AwsWafForm(AuthForm):
     def submit(self,
                last_response: Response) -> AmazonSessionResponse:
         """
-        Hand the WAF challenge off to :func:`_solve_token`, set the resulting
+        Hand the WAF challenge off to :func:`solve_token`, set the resulting
         ``aws-waf-token`` cookie on the session, and re-fetch the challenged URL.
 
         :param last_response: The response that returned the WAF challenge page.
@@ -114,7 +115,7 @@ class AwsWafForm(AuthForm):
                 "Call AwsWafForm.select_form() first."
             )  # pragma: no cover
 
-        token = self._solve_token(last_response.url, self._goku, self._challenge_script)
+        token = self.solve_token(last_response.url, self._goku, self._challenge_script)
 
         # Always surface that a paid third-party service was used, regardless of debug mode.
         message = (
@@ -124,14 +125,14 @@ class AwsWafForm(AuthForm):
         self.amazon_session.io.echo(message)
 
         domain = urlparse(self.config.constants.BASE_URL).netloc
-        self.amazon_session.session.cookies.set("aws-waf-token", token, domain=domain)
+        self.amazon_session.session.cookies.set(self.config.constants.WAF_TOKEN_COOKIE, token, domain=domain)
 
         return self.amazon_session.get(last_response.url)
 
-    def _solve_token(self,
-                     url: str,
-                     goku: Dict[str, Any],
-                     challenge_script: str) -> str:
+    def solve_token(self,
+                    url: str,
+                    goku: Dict[str, Any],
+                    challenge_script: str) -> str:
         """
         Subclass hook. Call the third-party solver with the supplied challenge
         parameters and return the resulting ``aws-waf-token`` cookie value to be
@@ -145,12 +146,18 @@ class AwsWafForm(AuthForm):
         :return: The ``aws-waf-token`` cookie value.
         :raises NotImplementedError: if a subclass does not override this method.
         """
+        if type(self)._solve_token is not AwsWafForm._solve_token:
+            warnings.warn(f"{type(self).__name__} overrides _solve_token(), which is deprecated and "
+                          f"will be removed in the next major release. Override solve_token() instead.",
+                          DeprecationWarning, stacklevel=2)
+            return self._solve_token(url, goku, challenge_script)
+
         raise NotImplementedError
 
-    def _solve_visual_captcha(self,
-                              url: str,
-                              image_data: list,
-                              question: str) -> Optional[list]:
+    def solve_visual_captcha(self,
+                             url: str,
+                             image_data: list,
+                             question: str) -> Optional[list]:
         """
         Subclass hook. Solve a visual grid Puzzle (e.g. "Choose all the buckets")
         and return the indices of the correct grid cells.
@@ -161,4 +168,32 @@ class AwsWafForm(AuthForm):
         :return: A list of zero-based grid cell indices to select, or ``None`` if
             this solver does not support Puzzle classification.
         """
+        if type(self)._solve_visual_captcha is not AwsWafForm._solve_visual_captcha:
+            warnings.warn(f"{type(self).__name__} overrides _solve_visual_captcha(), which is deprecated and "
+                          f"will be removed in the next major release. Override solve_visual_captcha() instead.",
+                          DeprecationWarning, stacklevel=2)
+            return self._solve_visual_captcha(url, image_data, question)
+
         return None
+
+    def _solve_token(self,
+                     url: str,
+                     goku: Dict[str, Any],
+                     challenge_script: str) -> str:
+        """
+        Deprecated, and will be removed in the next major release. Use :func:`solve_token` instead.
+        """
+        warnings.warn("AwsWafForm._solve_token() is deprecated and will be removed in the next major release. Use "
+                      "solve_token() instead.", DeprecationWarning, stacklevel=2)
+        return self.solve_token(url, goku, challenge_script)
+
+    def _solve_visual_captcha(self,
+                              url: str,
+                              image_data: list,
+                              question: str) -> Optional[list]:
+        """
+        Deprecated, and will be removed in the next major release. Use :func:`solve_visual_captcha` instead.
+        """
+        warnings.warn("AwsWafForm._solve_visual_captcha() is deprecated and will be removed in the next major "
+                      "release. Use solve_visual_captcha() instead.", DeprecationWarning, stacklevel=2)
+        return self.solve_visual_captcha(url, image_data, question)

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/amazonorders/contrib/waf/capsolver.py

@@ -19,10 +19,10 @@ class CapSolverWafForm(AwsWafForm):
     API_KEY_ENV_VAR = "CAPSOLVER_API_KEY"
     PROVIDER_NAME = "CapSolver"
 
-    def _solve_token(self,
-                     url: str,
-                     goku: Dict[str, Any],
-                     challenge_script: str) -> str:
+    def solve_token(self,
+                    url: str,
+                    goku: Dict[str, Any],
+                    challenge_script: str) -> str:
         """
         Solve the AWS WAF challenge via CapSolver's ``AntiAwsWafTaskProxyLess``
         task type and return the ``aws-waf-token`` cookie value.
@@ -68,10 +68,10 @@ class CapSolverWafForm(AwsWafForm):
                 meta={"provider": self.PROVIDER_NAME, "provider_error": repr(solution)}
             ) from e
 
-    def _solve_visual_captcha(self,
-                              url: str,
-                              image_data: List[str],
-                              question: str) -> Optional[List[int]]:
+    def solve_visual_captcha(self,
+                             url: str,
+                             image_data: List[str],
+                             question: str) -> Optional[List[int]]:
         """
         Solve a visual grid Puzzle via CapSolver's ``AwsWafClassification`` task
         type and return the indices of the correct grid cells.

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/amazonorders/contrib/waf/twocaptcha.py

@@ -21,10 +21,10 @@ class TwoCaptchaWafForm(AwsWafForm):
     API_KEY_ENV_VAR = "TWOCAPTCHA_API_KEY"
     PROVIDER_NAME = "2Captcha"
 
-    def _solve_token(self,
-                     url: str,
-                     goku: Dict[str, Any],
-                     challenge_script: str) -> str:
+    def solve_token(self,
+                    url: str,
+                    goku: Dict[str, Any],
+                    challenge_script: str) -> str:
         """
         Solve the AWS WAF challenge via 2Captcha's ``amazon_waf`` method and
         return the ``aws-waf-token`` cookie value (extracted from the

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/amazonorders/entity/order.py

@@ -193,7 +193,8 @@ class Order(Parsable):
         value = self.simple_parse(self.config.selectors.FIELD_ORDER_DETAILS_LINK_SELECTOR, attr_name="href")
 
         if not value and self.order_number:
-            value = f"{self.config.constants.ORDER_DETAILS_URL}?orderID={self.order_number}"
+            constants = self.config.constants
+            value = f"{constants.ORDER_DETAILS_URL}?{constants.ORDER_ID_QUERY_PARAM}={self.order_number}"
 
         return value
 

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/amazonorders/entity/transaction.py

@@ -152,7 +152,8 @@ class Transaction(Parsable):
         if not self.order_number:
             return None
 
-        return f"{self.config.constants.ORDER_DETAILS_URL}?orderID={self.order_number}"
+        constants = self.config.constants
+        return f"{constants.ORDER_DETAILS_URL}?{constants.ORDER_ID_QUERY_PARAM}={self.order_number}"
 
     def _parse_payment_method_last_4(self) -> Optional[str]:
         if not self.payment_method:

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/amazonorders/forms.py

@@ -1,10 +1,11 @@
 __copyright__ = "Copyright (c) 2024-2025 Alex Laird"
 __license__ = "MIT"
 
+import importlib.util
 import re
 from abc import ABC
 from io import BytesIO
-from typing import Any, Dict, Optional, TYPE_CHECKING, Union
+from typing import Any, Dict, NoReturn, Optional, TYPE_CHECKING, Union
 from urllib.parse import urlparse
 
 import pyotp
@@ -226,8 +227,7 @@ class SignInForm(AuthForm):
             )  # pragma: no cover
 
         additional_attrs.update({self.solution_attr_key: self.amazon_session.username,
-                                 "password": self.amazon_session.password,
-                                 "rememberMe": "true"})
+                                 "password": self.amazon_session.password})
         self.data.update(additional_attrs)
 
 
@@ -260,8 +260,7 @@ class ClaimForm(AuthForm):
             )  # pragma: no cover
 
         additional_attrs.update({self.solution_attr_key: self.amazon_session.username,
-                                 "password": self.amazon_session.password,
-                                 "rememberMe": "true"})
+                                 "password": self.amazon_session.password})
         self.data.update(additional_attrs)
 
 
@@ -464,6 +463,21 @@ class CaptchaForm(AuthForm):
         self.data.update(additional_attrs)
 
 
+def _raise_js_challenge_error() -> NoReturn:
+    if importlib.util.find_spec("playwright"):
+        raise AmazonOrdersAuthError(
+            "Amazon returned a JavaScript-based authentication challenge. Add "
+            "amazonorders.contrib.browser.playwright.PlaywrightAcicForm, then "
+            "amazonorders.contrib.browser.playwright.PlaywrightJSAuthForm, to auth_forms_classes to handle this "
+            "automatically, or sign in with `amazon-orders login --browser`. "
+            "See https://amazon-orders.readthedocs.io/browser.html for details.")
+
+    raise AmazonOrdersAuthError(
+        "Amazon returned a JavaScript-based authentication challenge. Install the [browser] extra to "
+        "handle this automatically: `pip install amazon-orders[browser]`. "
+        "See https://amazon-orders.readthedocs.io/browser.html for details.")
+
+
 class AcicAuthBlocker(AuthForm):
     def __init__(self,
                  config: AmazonOrdersConfig) -> None:
@@ -473,10 +487,7 @@ class AcicAuthBlocker(AuthForm):
                     amazon_session: "AmazonSession",
                     parsed: Tag) -> bool:
         if parsed.find(id="aa-challenge-page-captcha-container"):
-            raise AmazonOrdersAuthError(
-                "Amazon returned a JavaScript-based authentication challenge. Install the [browser] extra to "
-                "handle this automatically: `pip install amazon-orders[browser]`. "
-                "See https://amazon-orders.readthedocs.io/browser.html for details.")
+            _raise_js_challenge_error()
 
         return False
 
@@ -496,9 +507,6 @@ class JSAuthBlocker(AuthForm):
             raise AmazonOrdersError("Must set a regex first.")  # pragma: no cover
 
         if re.search(self.regex, parsed.text):
-            raise AmazonOrdersAuthError(
-                "Amazon returned a JavaScript-based authentication challenge. Install the [browser] extra to "
-                "handle this automatically: `pip install amazon-orders[browser]`. "
-                "See https://amazon-orders.readthedocs.io/browser.html for details.")
+            _raise_js_challenge_error()
 
         return False

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/amazonorders/orders.py

@@ -112,7 +112,7 @@ class AmazonOrders:
         meta = {"index": clone.index} if clone else None
 
         order_details_response = self.amazon_session.get(
-            f"{self.config.constants.ORDER_DETAILS_URL}?orderID={order_id}")
+            f"{self.config.constants.ORDER_DETAILS_URL}?{self.config.constants.ORDER_ID_QUERY_PARAM}={order_id}")
         self.amazon_session.check_response(order_details_response, meta=meta)
 
         response_url = order_details_response.response.url
@@ -233,7 +233,7 @@ class AmazonOrders:
             raise AmazonOrdersError("Call AmazonSession.login() to authenticate first.")
 
         invoice_response = self.amazon_session.get(
-            f"{self.config.constants.ORDER_INVOICE_URL}?orderID={order_id}")
+            f"{self.config.constants.ORDER_INVOICE_URL}?{self.config.constants.ORDER_ID_QUERY_PARAM}={order_id}")
         self.amazon_session.check_response(invoice_response)
 
         response_url = invoice_response.response.url
@@ -353,8 +353,8 @@ class AmazonOrders:
 
         return PagedResults(orders, next_cursor)
 
-    @staticmethod
-    def _history_filter_value(year: Optional[int],
+    def _history_filter_value(self,
+                              year: Optional[int],
                               time_filter: Optional[str]) -> str:
         if time_filter and year:
             raise AmazonOrdersError("Only one of 'year' or 'time_filter' may be used at a time.")
@@ -362,18 +362,20 @@ class AmazonOrders:
         # Determine the filter value to use
         if time_filter:
             # Validate time_filter value
-            valid_filters = ["last30", "months-3"]
-            is_year_filter = time_filter.startswith("year-") and time_filter[5:].isdigit()
+            constants = self.config.constants
+            valid_filters = [constants.LAST_30_DAYS_TIME_FILTER, constants.LAST_3_MONTHS_TIME_FILTER]
+            year_prefix = constants.YEAR_TIME_FILTER_PREFIX
+            is_year_filter = time_filter.startswith(year_prefix) and time_filter[len(year_prefix):].isdigit()
             if time_filter not in valid_filters and not is_year_filter:
                 raise AmazonOrdersError(
                     f"Invalid time_filter '{time_filter}'. "
-                    f"Valid values are 'last30', 'months-3', or 'year-YYYY'."
+                    f"Valid values are '{valid_filters[0]}', '{valid_filters[1]}', or '{year_prefix}YYYY'."
                 )
             filter_value = time_filter
         else:
             if year is None:
                 year = datetime.date.today().year
-            filter_value = f"year-{year}"
+            filter_value = f"{self.config.constants.YEAR_TIME_FILTER_PREFIX}{year}"
 
         return filter_value
 

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/amazonorders/selectors.py

@@ -95,6 +95,7 @@ class Selectors:
     AWS_WAF_CHALLENGE_SCRIPT_SELECTOR = 'script[src*="awswaf.com"]'
 
     SIGN_IN_FORM_SELECTOR = "form[name='signIn']"
+    SIGN_IN_EMAIL_INPUT_SELECTOR = "input[name='email']"
     CLAIM_FORM_SELECTOR = "form[name='signIn'].auth-validate-form"
     INTENT_FORM_SELECTOR = "form#intent-confirmation-form"
     INTENT_MESSAGE_SELECTOR = "div#intent-confirmation-container"

{amazon_orders-4.9.1 → amazon_orders-4.9.2}/amazonorders/session.py

@@ -4,8 +4,9 @@ __license__ = "MIT"
 import json
 import logging
 import os
+import tempfile
 import time
-from typing import Any, List, Optional, Dict
+from typing import Any, Dict, List, Optional, Union
 from urllib.parse import urlencode, urlparse
 
 import requests
@@ -136,15 +137,23 @@ class AmazonSession:
         #: If :func:`login` has been executed and successfully logged in the session.
         self.is_authenticated: bool = False
         self._sign_in_required: bool = False
+        self._cookie_jar_mtime: Optional[float] = None
 
         with cookies_file_lock:
             os.makedirs(os.path.dirname(self.config.cookie_jar_path), exist_ok=True)
 
             if os.path.exists(self.config.cookie_jar_path):
                 with open(self.config.cookie_jar_path, "r", encoding="utf-8") as f:
-                    data = json.loads(f.read())
-                    cookies = requests.utils.cookiejar_from_dict(data)
-                    self.session.cookies.update(cookies)
+                    self._cookie_jar_mtime = os.fstat(f.fileno()).st_mtime
+                    self._load_cookie_jar_data(json.loads(f.read()))
+
+    @property
+    def cookie_jar_mtime(self) -> Optional[float]:
+        """
+        The modification time of the persisted cookie jar when this session last loaded or saved it, or ``None`` if
+        there was no jar then. If the file's modification time no longer matches, another process has saved it since.
+        """
+        return self._cookie_jar_mtime
 
     @staticmethod
     def default_auth_forms(config: AmazonOrdersConfig) -> List[AuthForm]:
@@ -176,14 +185,16 @@ class AmazonSession:
     def request(self,
                 method: str,
                 url: str,
-                persist_cookies: bool = False,
+                persist_cookies: Optional[bool] = None,
                 **kwargs: Any) -> AmazonSessionResponse:
         """
         Execute the request against Amazon with base headers, parsing and storing the response.
 
         :param method: The request method to execute.
         :param url: The URL to execute ``method`` on.
-        :param persist_cookies: If ``True``, cookies from the response will be persisted to a file.
+        :param persist_cookies: If ``True``, cookies from the response will be persisted to a file, and if ``False``,
+            they won't be. By default, they're persisted when the response changed them, unless another process has
+            saved the file since this session did, so a stale session can't overwrite a newer sign-in.
         :param kwargs: Remaining ``kwargs`` will be passed to :func:`requests.request`.
         :return: The response from the executed request.
         """
@@ -201,6 +212,7 @@ class AmazonSession:
             kwargs.setdefault("timeout", self.config.request_timeout)
 
         self._set_request_cookies()
+        cookie_jar_data = self._cookie_jar_data()
 
         try:
             response = self.session.request(method, url, **kwargs)
@@ -213,10 +225,11 @@ class AmazonSession:
         amazon_session_response = AmazonSessionResponse(response,
                                                         self.config.bs4_parser)
 
+        if persist_cookies is None:
+            persist_cookies = self._cookie_jar_data() != cookie_jar_data and self._cookie_jar_unchanged_on_disk()
         if persist_cookies:
-            cookies = dict_from_cookiejar(self.session.cookies)
             with cookies_file_lock:
-                self._write_cookie_jar(cookies)
+                self._write_cookie_jar()
 
         if self.debug:
             url_str = ""
@@ -346,22 +359,48 @@ class AmazonSession:
         self.session.close()
         self.session = self._create_session()
 
-        # Ensure authentication cookies are unset, since we can get inconsistent persistence behavior otherwise
         with cookies_file_lock:
-            cookies = dict_from_cookiejar(self.session.cookies)
-            for cookie in self.config.constants.COOKIES_SET_WHEN_AUTHENTICATED:
-                cookies.pop(cookie, None)
-            self._write_cookie_jar(cookies)
+            self._write_cookie_jar()
 
         self.is_authenticated = False
         self._sign_in_required = False
 
-    def _write_cookie_jar(self,
-                          cookies: Dict[str, str]) -> None:
-        file_descriptor = os.open(self.config.cookie_jar_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
-        with os.fdopen(file_descriptor, "w", encoding="utf-8") as f:
-            f.write(json.dumps(cookies))
-        os.chmod(self.config.cookie_jar_path, 0o600)
+    def _cookie_jar_data(self) -> List[Dict[str, Any]]:
+        return [{"name": cookie.name, "value": cookie.value, "domain": cookie.domain, "path": cookie.path,
+                 "secure": cookie.secure, "expires": cookie.expires} for cookie in self.session.cookies]
+
+    def _load_cookie_jar_data(self,
+                              data: Union[Dict[str, str], List[Dict[str, Any]]]) -> None:
+        if isinstance(data, dict):
+            domain = "." + (urlparse(self.config.constants.BASE_URL).hostname or "").removeprefix("www.")
+            data = [{"name": name, "value": value, "domain": domain} for name, value in data.items()]
+
+        for cookie in data:
+            self.session.cookies.set(cookie["name"], cookie["value"], domain=cookie.get("domain", ""),
+                                     path=cookie.get("path", "/"), secure=cookie.get("secure", False),
+                                     expires=cookie.get("expires"))
+
+    def _write_cookie_jar(self) -> None:
+        file_descriptor, temp_path = tempfile.mkstemp(dir=os.path.dirname(self.config.cookie_jar_path),
+                                                      prefix=".cookies-", suffix=".tmp")
+        try:
+            with os.fdopen(file_descriptor, "w", encoding="utf-8") as f:
+                f.write(json.dumps(self._cookie_jar_data()))
+            os.chmod(temp_path, 0o600)
+            os.replace(temp_path, self.config.cookie_jar_path)
+        except BaseException:
+            os.remove(temp_path)
+            raise
+        self._cookie_jar_mtime = self._read_cookie_jar_mtime()
+
+    def _read_cookie_jar_mtime(self) -> Optional[float]:
+        try:
+            return os.path.getmtime(self.config.cookie_jar_path)
+        except OSError:
+            return None
+
+    def _cookie_jar_unchanged_on_disk(self) -> bool:
+        return self._read_cookie_jar_mtime() == self._cookie_jar_mtime
 
     def build_response_error(self,
                              response: Response) -> str: