python-amazon-paapi 7.0.0__tar.gz → 7.1.0__tar.gz

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [7.1.0] - 2026-09-16
+
+### Added
+
+- `timeout` in `AmazonCreatorsApi` and `AsyncAmazonCreatorsApi` accepts a pair of `(connect, read)` seconds, bounding each leg of a request on its own, so a host resolving to several addresses cannot spend a read-sized timeout on every one of them
+
+### Changed
+
+- The default timeout is `(5, 25)` rather than `30`, five seconds to connect and twenty-five to read. It adds up to the thirty seconds that have always been documented and makes them true of the token request and of the async client too, where a single value was applied to each leg separately and allowed sixty. A response taking between twenty-five and thirty seconds now times out where it used to arrive
+
 ## [7.0.0] - 2026-09-04
 
 ### Added

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-amazon-paapi
-Version: 7.0.0
+Version: 7.1.0
 Summary: Amazon Creators API wrapper for Python
 Project-URL: Homepage, https://github.com/sergioteula/python-amazon-paapi
 Project-URL: Repository, https://github.com/sergioteula/python-amazon-paapi
@@ -260,8 +260,11 @@ The interval is kept per client and is safe to share between threads.
 
 ### Timeout
 
-Timeout value represents the number of seconds to wait for a response before failing,
-being the default value 30 seconds. Use `None` to wait indefinitely.
+Timeout value represents the number of seconds to wait for a response before failing.
+Use `None` to wait indefinitely.
+
+The default is `(5, 25)`: five seconds to establish the connection and twenty-five to
+read the response, thirty in total.
 
 ```python
 api = AmazonCreatorsApi(ID, SECRET, VERSION, TAG, COUNTRY, timeout=10)  # Fails after 10 seconds
@@ -270,6 +273,16 @@ api = AmazonCreatorsApi(ID, SECRET, VERSION, TAG, COUNTRY, timeout=0.5)  # Fails
 
 It applies to every API request, including the OAuth2 token refresh.
 
+A pair of `(connect, read)` seconds bounds each leg of the request on its own. This
+matters for a host resolving to several addresses: the connect leg is spent once per
+address, so a single value generous enough to read a slow response is also spent on
+every address that fails to answer.
+
+```python
+# Gives up on an unresponsive address after 1 second, and still reads for 10
+api = AmazonCreatorsApi(ID, SECRET, VERSION, TAG, COUNTRY, timeout=(1, 10))
+```
+
 ### Retries
 
 Amazon asks clients to back off and try again when it throttles a request or fails to

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/README.md

@@ -226,8 +226,11 @@ The interval is kept per client and is safe to share between threads.
 
 ### Timeout
 
-Timeout value represents the number of seconds to wait for a response before failing,
-being the default value 30 seconds. Use `None` to wait indefinitely.
+Timeout value represents the number of seconds to wait for a response before failing.
+Use `None` to wait indefinitely.
+
+The default is `(5, 25)`: five seconds to establish the connection and twenty-five to
+read the response, thirty in total.
 
 ```python
 api = AmazonCreatorsApi(ID, SECRET, VERSION, TAG, COUNTRY, timeout=10)  # Fails after 10 seconds
@@ -236,6 +239,16 @@ api = AmazonCreatorsApi(ID, SECRET, VERSION, TAG, COUNTRY, timeout=0.5)  # Fails
 
 It applies to every API request, including the OAuth2 token refresh.
 
+A pair of `(connect, read)` seconds bounds each leg of the request on its own. This
+matters for a host resolving to several addresses: the connect leg is spent once per
+address, so a single value generous enough to read a slow response is also spent on
+every address that fails to answer.
+
+```python
+# Gives up on an unresponsive address after 1 second, and still reads for 10
+api = AmazonCreatorsApi(ID, SECRET, VERSION, TAG, COUNTRY, timeout=(1, 10))
+```
+
 ### Retries
 
 Amazon asks clients to back off and try again when it throttles a request or fails to

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/amazon_creatorsapi/aio/api.py

@@ -87,6 +87,7 @@ from creatorsapi_python_sdk.models.search_items_resource import SearchItemsResou
 if TYPE_CHECKING:
     from types import TracebackType
 
+    from amazon_creatorsapi.core.constants import TimeoutValue
     from amazon_creatorsapi.core.marketplaces import CountryCode
     from creatorsapi_python_sdk.models.availability import Availability
     from creatorsapi_python_sdk.models.condition import Condition
@@ -168,8 +169,9 @@ class AsyncAmazonCreatorsApi:
         country: Country code (e.g., "ES", "US"). Used to determine marketplace.
         marketplace: Marketplace URL (e.g., "www.amazon.es"). Overrides country.
         throttling: Wait time in seconds between API calls. Defaults to 1 second.
-        timeout: Request timeout in seconds, or None to wait indefinitely.
-            Defaults to 30 seconds.
+        timeout: Request timeout in seconds, a pair of ``(connect, read)``
+            seconds bounding each leg on its own, or None to wait
+            indefinitely. Defaults to 5 seconds to connect and 25 to read.
         retries: Extra attempts for the failures that Amazon asks to retry,
             waiting longer before every attempt. Defaults to 3.
         host: Base URL of the API. Defaults to the Amazon Creators API.
@@ -196,7 +198,7 @@ class AsyncAmazonCreatorsApi:
         country: CountryCode | None = None,
         marketplace: str | None = None,
         throttling: float = DEFAULT_THROTTLING,
-        timeout: float | None = DEFAULT_TIMEOUT,
+        timeout: TimeoutValue | None = DEFAULT_TIMEOUT,
         retries: int = DEFAULT_RETRIES,
         host: str = DEFAULT_HOST,
         auth_endpoint: str | None = None,

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/amazon_creatorsapi/aio/auth.py

@@ -7,8 +7,9 @@ from __future__ import annotations
 
 import asyncio
 import time
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
+from amazon_creatorsapi.aio.timeouts import build_httpx_timeout
 from amazon_creatorsapi.core.constants import DEFAULT_TIMEOUT, HTTP_OK
 from amazon_creatorsapi.core.oauth import (
     COGNITO_SCOPE,
@@ -23,6 +24,9 @@ from amazon_creatorsapi.core.oauth import (
 )
 from amazon_creatorsapi.errors import AuthenticationError
 
+if TYPE_CHECKING:
+    from amazon_creatorsapi.core.constants import TimeoutValue
+
 try:
     import httpx
 except ImportError as exc:  # pragma: no cover
@@ -61,8 +65,10 @@ class AsyncOAuth2TokenManager:
         credential_secret: OAuth2 credential secret.
         version: API version (determines auth endpoint).
         auth_endpoint: Optional custom auth endpoint URL.
-        timeout: Token request timeout in seconds, or None to wait
-            indefinitely. Defaults to 30 seconds.
+        timeout: Token request timeout in seconds, a pair of
+            ``(connect, read)`` seconds bounding each leg on its own, or None
+            to wait indefinitely. Defaults to 5 seconds to connect and
+            25 to read.
 
     """
 
@@ -72,7 +78,7 @@ class AsyncOAuth2TokenManager:
         credential_secret: str,
         version: str,
         auth_endpoint: str | None = None,
-        timeout: float | None = DEFAULT_TIMEOUT,
+        timeout: TimeoutValue | None = DEFAULT_TIMEOUT,
     ) -> None:
         """Initialize the async OAuth2 token manager."""
         self._credential_id = credential_id
@@ -189,7 +195,9 @@ class AsyncOAuth2TokenManager:
         }
 
         try:
-            async with httpx.AsyncClient(timeout=self._timeout) as client:
+            async with httpx.AsyncClient(
+                timeout=build_httpx_timeout(self._timeout),
+            ) as client:
                 if self.is_lwa():
                     response = await client.post(
                         self._auth_endpoint,

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/amazon_creatorsapi/aio/client.py

@@ -12,11 +12,14 @@ from typing import TYPE_CHECKING, Any
 
 from typing_extensions import Self
 
+from amazon_creatorsapi.aio.timeouts import build_httpx_timeout
 from amazon_creatorsapi.core.constants import DEFAULT_TIMEOUT
 
 if TYPE_CHECKING:
     from types import TracebackType
 
+    from amazon_creatorsapi.core.constants import TimeoutValue
+
 try:
     import httpx
 except ImportError as exc:  # pragma: no cover
@@ -65,15 +68,16 @@ class AsyncHttpClient:
 
     Args:
         host: Base URL for API requests. Defaults to Amazon Creators API.
-        timeout: Request timeout in seconds, or None to wait indefinitely.
-            Defaults to 30.
+        timeout: Request timeout in seconds, a pair of ``(connect, read)``
+            seconds bounding each leg on its own, or None to wait
+            indefinitely. Defaults to 5 seconds to connect and 25 to read.
 
     """
 
     def __init__(
         self,
         host: str = DEFAULT_HOST,
-        timeout: float | None = DEFAULT_TIMEOUT,
+        timeout: TimeoutValue | None = DEFAULT_TIMEOUT,
     ) -> None:
         """Initialize the async HTTP client."""
         self._host = host
@@ -85,7 +89,7 @@ class AsyncHttpClient:
         """Enter async context manager, creating a persistent client."""
         self._client = httpx.AsyncClient(
             base_url=self._host,
-            timeout=self._timeout,
+            timeout=build_httpx_timeout(self._timeout),
             headers={"User-Agent": USER_AGENT},
         )
         self._owns_client = True
@@ -134,7 +138,7 @@ class AsyncHttpClient:
             # Create a new client for this request (standalone mode)
             async with httpx.AsyncClient(
                 base_url=self._host,
-                timeout=self._timeout,
+                timeout=build_httpx_timeout(self._timeout),
             ) as client:
                 response = await client.post(
                     path,

python_amazon_paapi-7.1.0/amazon_creatorsapi/aio/timeouts.py

@@ -0,0 +1,49 @@
+"""Conversion of the timeout values into the ones httpx understands.
+
+It lives here rather than next to the values themselves because httpx is an
+optional dependency, and the synchronous client must keep importing without
+it.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from amazon_creatorsapi.core.constants import TimeoutValue
+
+try:
+    import httpx
+except ImportError as exc:  # pragma: no cover
+    msg = (
+        "httpx is required for async support. "
+        "Install it with: pip install python-amazon-paapi[async]"
+    )
+    raise ImportError(msg) from exc
+
+
+def build_httpx_timeout(
+    timeout: TimeoutValue | None,
+) -> float | httpx.Timeout | None:
+    """Return the timeout to hand to httpx for a value the clients accept.
+
+    A pair is the only value httpx needs help with. Everything else is passed
+    through as it is, so httpx keeps reading it exactly as it did before pairs
+    were accepted.
+
+    Args:
+        timeout: Seconds for the whole request, ``(connect, read)`` seconds
+            per leg, or None to wait indefinitely.
+
+    Returns:
+        The seconds, the httpx timeout built from the pair, or None to wait
+        indefinitely.
+
+    """
+    if not isinstance(timeout, tuple):
+        return timeout
+    connect, read = timeout
+    # httpx reads a pair as (connect, read, write, pool) and leaves the two it
+    # does not find unbounded, which would drop a timeout that the single
+    # value form applies. The read value covers them instead.
+    return httpx.Timeout(connect=connect, read=read, write=read, pool=read)

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/amazon_creatorsapi/api.py

@@ -77,6 +77,7 @@ from creatorsapi_python_sdk.models.search_items_resource import SearchItemsResou
 if TYPE_CHECKING:
     from types import TracebackType
 
+    from amazon_creatorsapi.core.constants import TimeoutValue
     from amazon_creatorsapi.core.marketplaces import CountryCode
     from creatorsapi_python_sdk.models.availability import Availability
     from creatorsapi_python_sdk.models.browse_node import BrowseNode
@@ -109,8 +110,9 @@ class AmazonCreatorsApi:
         country: Country code (e.g., "ES", "US"). Used to determine marketplace.
         marketplace: Marketplace URL (e.g., "www.amazon.es"). Overrides country.
         throttling: Wait time in seconds between API calls. Defaults to 1 second.
-        timeout: Request timeout in seconds, or None to wait indefinitely.
-            Defaults to 30 seconds.
+        timeout: Request timeout in seconds, a pair of ``(connect, read)``
+            seconds bounding each leg on its own, or None to wait
+            indefinitely. Defaults to 5 seconds to connect and 25 to read.
         retries: Extra attempts for the failures that Amazon asks to retry,
             waiting longer before every attempt. Defaults to 3.
         host: Base URL of the API. Defaults to the Amazon Creators API.
@@ -151,7 +153,7 @@ class AmazonCreatorsApi:
         country: CountryCode | None = None,
         marketplace: str | None = None,
         throttling: float = DEFAULT_THROTTLING,
-        timeout: float | None = DEFAULT_TIMEOUT,
+        timeout: TimeoutValue | None = DEFAULT_TIMEOUT,
         retries: int = DEFAULT_RETRIES,
         host: str = DEFAULT_HOST,
         auth_endpoint: str | None = None,

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/amazon_creatorsapi/core/auth.py

@@ -14,6 +14,7 @@ from amazon_creatorsapi.errors import AuthenticationError
 from creatorsapi_python_sdk.auth.oauth2_token_manager import OAuth2TokenManager
 
 if TYPE_CHECKING:
+    from amazon_creatorsapi.core.constants import TimeoutValue
     from creatorsapi_python_sdk.auth.oauth2_config import OAuth2Config
 
 
@@ -28,12 +29,17 @@ class TimeoutOAuth2TokenManager(OAuth2TokenManager):
 
     Args:
         config: OAuth2 configuration with the credentials and the endpoint.
-        timeout: Token request timeout in seconds, or None to wait
-            indefinitely.
+        timeout: Token request timeout in seconds, a pair of
+            ``(connect, read)`` seconds bounding each leg on its own, or None
+            to wait indefinitely.
 
     """
 
-    def __init__(self, config: OAuth2Config, timeout: float | None) -> None:
+    def __init__(
+        self,
+        config: OAuth2Config,
+        timeout: TimeoutValue | None,
+    ) -> None:
         """Initialize the token manager with its timeout."""
         super().__init__(config)
         self._timeout = timeout

python_amazon_paapi-7.1.0/amazon_creatorsapi/core/constants.py

@@ -0,0 +1,35 @@
+"""Constants for the Amazon Creators API."""
+
+from __future__ import annotations
+
+from typing import Union
+
+TimeoutValue = Union[float, "tuple[float, float]"]
+"""Seconds for the whole request, or ``(connect, read)`` seconds per leg.
+
+The pair matters for a host that resolves to several addresses: the connect
+leg is spent once per address, so a single value generous enough to read a
+slow response is also spent on every address that fails to answer.
+"""
+
+DEFAULT_HOST = "https://creatorsapi.amazon"
+DEFAULT_THROTTLING = 1
+# Connect and read seconds, rather than one value covering both. The connect
+# leg is spent once per address the host resolves to, so a single value
+# generous enough to read a slow response is also spent on every address that
+# fails to answer: at 30 seconds, a host resolving to four addresses takes two
+# minutes to give up. The two add up to the 30 seconds this has always
+# documented, and a connection that takes longer than five seconds to
+# establish is not one that a longer wait rescues.
+DEFAULT_TIMEOUT = (5.0, 25.0)
+
+# Maximum amount of item identifiers accepted in a single request
+MAX_ITEMS_PER_REQUEST = 10
+
+# HTTP status codes
+HTTP_OK = 200
+HTTP_BAD_REQUEST = 400
+HTTP_UNAUTHORIZED = 401
+HTTP_FORBIDDEN = 403
+HTTP_NOT_FOUND = 404
+HTTP_TOO_MANY_REQUESTS = 429

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/amazon_creatorsapi/core/validation.py

@@ -10,6 +10,7 @@ from amazon_creatorsapi.core.marketplaces import MARKETPLACES
 from amazon_creatorsapi.errors import InvalidArgumentError
 
 if TYPE_CHECKING:
+    from amazon_creatorsapi.core.constants import TimeoutValue
     from amazon_creatorsapi.core.marketplaces import CountryCode
 
 RequestT = TypeVar("RequestT", bound=BaseModel)
@@ -44,21 +45,47 @@ def validate_and_get_marketplace(
     raise InvalidArgumentError(msg)
 
 
-def validate_timeout(timeout: float | None) -> float | None:
+def validate_timeout(timeout: TimeoutValue | None) -> TimeoutValue | None:
     """Validate the request timeout value.
 
     Args:
-        timeout: Request timeout in seconds, or None to wait indefinitely.
+        timeout: Request timeout in seconds, a pair of ``(connect, read)``
+            seconds bounding each leg on its own, or None to wait
+            indefinitely.
 
     Returns:
-        The timeout as a float, or None when disabled.
+        The timeout as a float, as a pair of floats, or None when disabled.
 
     Raises:
-        InvalidArgumentError: If the timeout is not greater than zero.
+        InvalidArgumentError: If a timeout is not greater than zero, or if a
+            pair does not hold exactly two of them.
 
     """
     if timeout is None:
         return None
+    if not isinstance(timeout, tuple):
+        return _validate_seconds(timeout)
+    try:
+        connect, read = timeout
+    except ValueError as error:
+        msg = f"Timeout must be a pair of (connect, read) seconds: {timeout!r}"
+        raise InvalidArgumentError(msg) from error
+    return _validate_seconds(connect), _validate_seconds(read)
+
+
+def _validate_seconds(timeout: float) -> float:
+    """Validate a number of seconds used as a timeout.
+
+    Args:
+        timeout: Timeout in seconds, whether on its own or one leg of a pair.
+
+    Returns:
+        The timeout as a float.
+
+    Raises:
+        InvalidArgumentError: If it is not a number greater than zero.
+
+    """
     try:
         value = float(timeout)
     except (TypeError, ValueError) as error:

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/docs/conf.py

@@ -23,7 +23,7 @@ copyright = "2026, Sergio Abad"
 author = "Sergio Abad"
 
 # The full version, including alpha/beta/rc tags
-release = "7.0.0"
+release = "7.1.0"
 
 
 # -- General configuration ---------------------------------------------------

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/docs/pages/migration-guide-7.md

@@ -18,7 +18,7 @@ the changes that look breaking and are not.
 | `search_items` needs a criterion | A search with only filters | Add `keywords` or any other criterion |
 | `get_items` raises when nothing is found | `if not items:` | Catch `ItemsNotFoundError`, or use `include_unavailable` |
 | `get_items` returns the requested order | Reading the response by position | Read it by position, or match by `asin` |
-| The synchronous client times out | Requests above 30 seconds | Pass `timeout` |
+| The synchronous client times out | Requests above 5 seconds to connect or 25 to read | Pass `timeout` |
 | Failed requests are retried | Handling a `429` yourself | Pass `retries=0` |
 | `get_asin` rejects a long identifier | Malformed URLs | Fix the URLs |
 | The version is validated on creation | An unsupported `version` | Use a supported one, or pass `auth_endpoint` |
@@ -156,8 +156,9 @@ every ten items, each one waiting for the configured `throttling`.
 
 ## Timeouts
 
-The synchronous client waited indefinitely for a response. It now uses the same 30
-second timeout that the asynchronous one already had:
+The synchronous client waited indefinitely for a response. It now uses the same default
+timeout as the asynchronous one, five seconds to establish the connection and
+twenty-five to read the response:
 
 ```python
 api = AmazonCreatorsApi(..., timeout=60)    # Wait up to a minute

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/docs/pages/usage-guide.md

@@ -258,8 +258,11 @@ so several threads sharing a client still make one request every `throttling` se
 
 ## Timeout
 
-Timeout value represents the number of seconds to wait for a response before failing,
-being the default value 30 seconds. Use `None` to wait indefinitely.
+Timeout value represents the number of seconds to wait for a response before failing.
+Use `None` to wait indefinitely.
+
+The default is `(5, 25)`: five seconds to establish the connection and twenty-five to
+read the response, thirty in total.
 
 ```python
 api = AmazonCreatorsApi(ID, SECRET, VERSION, TAG, COUNTRY, timeout=10)  # Fails after 10 seconds
@@ -268,6 +271,16 @@ api = AmazonCreatorsApi(ID, SECRET, VERSION, TAG, COUNTRY, timeout=0.5)  # Fails
 
 It applies to every API request, including the OAuth2 token refresh.
 
+A pair of `(connect, read)` seconds bounds each leg of the request on its own. This
+matters for a host resolving to several addresses: the connect leg is spent once per
+address, so a single value generous enough to read a slow response is also spent on
+every address that fails to answer.
+
+```python
+# Gives up on an unresponsive address after 1 second, and still reads for 10
+api = AmazonCreatorsApi(ID, SECRET, VERSION, TAG, COUNTRY, timeout=(1, 10))
+```
+
 ## Retries
 
 Amazon asks clients to back off and try again when it throttles a request or fails to

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-amazon-paapi"
-version = "7.0.0"
+version = "7.1.0"
 description = "Amazon Creators API wrapper for Python"
 readme = "README.md"
 requires-python = ">=3.9"

python_amazon_paapi-7.1.0/tests/amazon_creatorsapi/aio/timeouts_test.py

@@ -0,0 +1,37 @@
+"""Unit tests for the conversion of the timeouts into httpx timeouts."""
+
+from __future__ import annotations
+
+import unittest
+
+import httpx
+
+from amazon_creatorsapi.aio.timeouts import build_httpx_timeout
+
+
+class TestBuildHttpxTimeout(unittest.TestCase):
+    """Tests for build_httpx_timeout function."""
+
+    def test_none_waits_indefinitely(self) -> None:
+        """Test that None is passed through as no timeout."""
+        self.assertIsNone(build_httpx_timeout(None))
+
+    def test_seconds_are_passed_through(self) -> None:
+        """Test that a single value reaches httpx as it did before."""
+        self.assertEqual(build_httpx_timeout(5), 5)
+
+    def test_pair_bounds_every_leg(self) -> None:
+        """Test that a pair bounds each leg, leaving none of them unbounded.
+
+        Handed a pair of its own, httpx reads it as the first two of
+        (connect, read, write, pool) and leaves the write and the pool legs
+        unbounded, dropping a timeout that the single value form applies. The
+        read value covers them instead.
+        """
+        timeout = build_httpx_timeout((1, 5))
+
+        self.assertEqual(timeout, httpx.Timeout(connect=1, read=5, write=5, pool=5))
+        self.assertNotEqual(
+            timeout,
+            httpx.Timeout(connect=1, read=5, write=None, pool=None),
+        )

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/tests/amazon_creatorsapi/api_test.py

@@ -12,7 +12,7 @@ import urllib3
 
 from amazon_creatorsapi import AmazonCreatorsApi
 from amazon_creatorsapi.core.auth import TimeoutOAuth2TokenManager
-from amazon_creatorsapi.core.constants import DEFAULT_TIMEOUT
+from amazon_creatorsapi.core.constants import DEFAULT_TIMEOUT, TimeoutValue
 from amazon_creatorsapi.core.oauth import VERSION_ENDPOINTS
 from amazon_creatorsapi.errors import (
     AccessDeniedError,
@@ -1533,6 +1533,59 @@ class TestAmazonCreatorsApiItems(unittest.TestCase):
         self.assertEqual(token_manager._timeout, 12.0)
         self.assertEqual(api.timeout, 12.0)
 
+    @mock.patch("amazon_creatorsapi.api.ApiClient")
+    def test_timeout_accepts_a_pair(self, mock_client_class: MagicMock) -> None:
+        """Test that a pair reaches the SDK and the token request alike."""
+        mock_client = MagicMock()
+        mock_client_class.return_value = mock_client
+
+        api = self.build_api_with_timeouts(timeout=(1.0, 12.0))
+
+        self.assertEqual(api.timeout, (1.0, 12.0))
+        self.assertEqual(mock_client._token_manager._timeout, (1.0, 12.0))
+
+    @mock.patch("amazon_creatorsapi.api.ApiClient")
+    def test_invalid_pair_raises_library_error(
+        self,
+        mock_client_class: MagicMock,
+    ) -> None:
+        """Test that a pair is validated like a single value."""
+        mock_client_class.return_value = MagicMock()
+
+        with self.assertRaises(InvalidArgumentError):
+            self.build_api_with_timeouts(timeout=(0, 12.0))
+
+    @mock.patch("amazon_creatorsapi.api.ApiClient")
+    def test_default_timeout_bounds_connect_and_read_apart(
+        self,
+        mock_client_class: MagicMock,
+    ) -> None:
+        """Test that the default bounds each leg, and still adds up to 30.
+
+        A single value is spent on the connect leg once per address the host
+        resolves to, so the default splits the thirty seconds it has always
+        documented rather than applying them twice over.
+        """
+        mock_client_class.return_value = MagicMock()
+
+        api = self.build_api_with_timeouts()
+
+        self.assertEqual(api.timeout, (5.0, 25.0))
+
+    def build_api_with_timeouts(
+        self,
+        timeout: TimeoutValue | None = DEFAULT_TIMEOUT,
+    ) -> AmazonCreatorsApi:
+        """Build an API client with the given timeout."""
+        return AmazonCreatorsApi(
+            credential_id=self.credential_id,
+            credential_secret=self.credential_secret,
+            version=self.version,
+            tag=self.tag,
+            country=self.country,
+            timeout=timeout,
+        )
+
     @mock.patch("amazon_creatorsapi.api.DefaultApi")
     @mock.patch("amazon_creatorsapi.api.ApiClient")
     def test_get_items_without_items_raises_library_error(

{python_amazon_paapi-7.0.0 → python_amazon_paapi-7.1.0}/tests/amazon_creatorsapi/core/validation_test.py

@@ -66,6 +66,30 @@ class TestValidateTimeout(unittest.TestCase):
         with self.assertRaises(InvalidArgumentError):
             validate_timeout("slow")  # type: ignore[arg-type]
 
+    def test_returns_a_pair_of_floats(self) -> None:
+        """Test that a pair of connect and read timeouts is returned."""
+        self.assertEqual(validate_timeout((1, 5)), (1.0, 5.0))
+
+    def test_pair_of_the_wrong_length_is_rejected(self) -> None:
+        """Test that a tuple that is not a pair is rejected."""
+        for timeout in ((5,), (1, 5, 10)):
+            with self.subTest(timeout=timeout):
+                with self.assertRaises(InvalidArgumentError) as context:
+                    validate_timeout(timeout)  # type: ignore[arg-type]
+                self.assertIn("pair of (connect, read)", str(context.exception))
+
+    def test_pair_holding_zero_is_rejected(self) -> None:
+        """Test that neither leg of a pair may be zero."""
+        for timeout in ((0, 5), (1, 0)):
+            with self.subTest(timeout=timeout):
+                with self.assertRaises(InvalidArgumentError):
+                    validate_timeout(timeout)
+
+    def test_pair_holding_something_else_is_rejected(self) -> None:
+        """Test that a pair holding a value that is not a number is rejected."""
+        with self.assertRaises(InvalidArgumentError):
+            validate_timeout((1, "slow"))  # type: ignore[arg-type]
+
 
 class TestValidateRetries(unittest.TestCase):
     """Tests for validate_retries function."""

python_amazon_paapi-7.0.0/amazon_creatorsapi/core/constants.py

@@ -1,16 +0,0 @@
-"""Constants for the Amazon Creators API."""
-
-DEFAULT_HOST = "https://creatorsapi.amazon"
-DEFAULT_THROTTLING = 1
-DEFAULT_TIMEOUT = 30.0
-
-# Maximum amount of item identifiers accepted in a single request
-MAX_ITEMS_PER_REQUEST = 10
-
-# HTTP status codes
-HTTP_OK = 200
-HTTP_BAD_REQUEST = 400
-HTTP_UNAUTHORIZED = 401
-HTTP_FORBIDDEN = 403
-HTTP_NOT_FOUND = 404
-HTTP_TOO_MANY_REQUESTS = 429