shopware-api-client 1.0.107__tar.gz → 1.0.109__tar.gz

{shopware_api_client-1.0.107 → shopware_api_client-1.0.109}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: shopware-api-client
-Version: 1.0.107
+Version: 1.0.109
 Summary:  An api client for the Shopware API
 License: MIT
 Keywords: shopware,api,client
@@ -12,10 +12,12 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: redis
 Requires-Dist: httpx (>=0.26,<0.27)
 Requires-Dist: httpx-auth (>=0.21,<0.22)
 Requires-Dist: pydantic (>=2.6,<3.0)
 Requires-Dist: pytest-random-order (>=1.1.1,<2.0.0)
+Requires-Dist: redis (>5.0,<7.0) ; extra == "redis"
 Project-URL: Bugtracker, https://github.com/GWS-mbH/shopware-api-client/issues
 Project-URL: Changelog, https://github.com/GWS-mbH/shopware-api-client
 Project-URL: Documentation, https://github.com/GWS-mbH/shopware-api-client/wiki
@@ -29,8 +31,13 @@ A Django-ORM like, Python 3.12, async Shopware 6 admin and store-front API clien
 
 ## Installation
 
+```sh
 pip install shopware-api-client
 
+# If you want to use the redis cache
+pip install shopware-api-client[redis]
+```
+
 ## Usage
 
 There are two kinds of clients provided by this library. The `client.AdminClient` for the Admin API and the
@@ -151,7 +158,7 @@ await client.ce_blog.all()
 
 # Pydantic Model for the custom entity ce_blog
 CeBlog = client.ce_blog.model_class
-``` 
+```
 Since custom entities are completely dynamic no autocompletion in IDE is available. However there are some pydantic validations added for the field-types of the custom entity. Relations are currently not supported, but everything else should work as expected.
 
 ### client.StoreClient
@@ -175,6 +182,39 @@ config = StoreConfig(url=SHOP_URL, access_key=STORE_API_ACCESS_KEY, context_toke
 
 This config can be used with the `StoreClient`, which works exactly like the `AdminClient`.
 
+### Redis Caching for Rate Limits
+
+Both the AdminClient and the StoreClient use a built-in rate limiter. Shopware's rate limits differ based on the endpoints, both for the [SaaS-](https://docs.shopware.com/en/en/shopware-6-en/saas/rate-limits) and the [on-premise-solution](https://developer.shopware.com/docs/guides/hosting/infrastructure/rate-limiter.html).
+
+To be able to respect the rate limit when sending requests from multiple clients, it is possible to use redis as a cache-backend for route-based rate-limit data. If redis is not used, each Client independently keeps track of the rate limit. Please note that the non-Redis cache is not thread-safe.
+
+To use redis, simply hand over a redis-client to the client config:
+```py
+import redis
+from shopware_api_client.config import AdminConfig, StoreConfig
+from shopware_api_client.client import AdminClient, StoreClient
+
+redis_client = redis.Redis()
+
+admin_config = AdminConfig(
+    url='',
+    client_id='...',
+    client_secre='...',
+    redis_client=redis_client,
+)
+admin_client = AdminClient(config=config)  # <- This client uses the redis client now
+
+store_config = StoreConfig(
+    url='',
+    access_key='',
+    context_token=''
+    redis_client=redis_client,
+)
+store_client = StoreClient(config=config)  # <- Works for store client as well (Only do this in safe environments)
+```
+
+__Note:__ Shopware currently enforces rate limits on a per–public‑IP basis. As a result, you should only share Redis‑backed rate‑limit caching among clients that originate from the same public IP address.
+
 ## EndpointBase
 The `base.EndpointBase` class should be used for creating new Endpoints. It provides some usefull functions to call
 the Shopware-API.

{shopware_api_client-1.0.107 → shopware_api_client-1.0.109}/README.md

@@ -4,8 +4,13 @@ A Django-ORM like, Python 3.12, async Shopware 6 admin and store-front API clien
 
 ## Installation
 
+```sh
 pip install shopware-api-client
 
+# If you want to use the redis cache
+pip install shopware-api-client[redis]
+```
+
 ## Usage
 
 There are two kinds of clients provided by this library. The `client.AdminClient` for the Admin API and the
@@ -126,7 +131,7 @@ await client.ce_blog.all()
 
 # Pydantic Model for the custom entity ce_blog
 CeBlog = client.ce_blog.model_class
-``` 
+```
 Since custom entities are completely dynamic no autocompletion in IDE is available. However there are some pydantic validations added for the field-types of the custom entity. Relations are currently not supported, but everything else should work as expected.
 
 ### client.StoreClient
@@ -150,6 +155,39 @@ config = StoreConfig(url=SHOP_URL, access_key=STORE_API_ACCESS_KEY, context_toke
 
 This config can be used with the `StoreClient`, which works exactly like the `AdminClient`.
 
+### Redis Caching for Rate Limits
+
+Both the AdminClient and the StoreClient use a built-in rate limiter. Shopware's rate limits differ based on the endpoints, both for the [SaaS-](https://docs.shopware.com/en/en/shopware-6-en/saas/rate-limits) and the [on-premise-solution](https://developer.shopware.com/docs/guides/hosting/infrastructure/rate-limiter.html).
+
+To be able to respect the rate limit when sending requests from multiple clients, it is possible to use redis as a cache-backend for route-based rate-limit data. If redis is not used, each Client independently keeps track of the rate limit. Please note that the non-Redis cache is not thread-safe.
+
+To use redis, simply hand over a redis-client to the client config:
+```py
+import redis
+from shopware_api_client.config import AdminConfig, StoreConfig
+from shopware_api_client.client import AdminClient, StoreClient
+
+redis_client = redis.Redis()
+
+admin_config = AdminConfig(
+    url='',
+    client_id='...',
+    client_secre='...',
+    redis_client=redis_client,
+)
+admin_client = AdminClient(config=config)  # <- This client uses the redis client now
+
+store_config = StoreConfig(
+    url='',
+    access_key='',
+    context_token=''
+    redis_client=redis_client,
+)
+store_client = StoreClient(config=config)  # <- Works for store client as well (Only do this in safe environments)
+```
+
+__Note:__ Shopware currently enforces rate limits on a per–public‑IP basis. As a result, you should only share Redis‑backed rate‑limit caching among clients that originate from the same public IP address.
+
 ## EndpointBase
 The `base.EndpointBase` class should be used for creating new Endpoints. It provides some usefull functions to call
 the Shopware-API.

{shopware_api_client-1.0.107 → shopware_api_client-1.0.109}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "shopware-api-client"
 description = " An api client for the Shopware API"
-version = "1.0.107"
+version = "1.0.109"
 license = "MIT"
 authors = ["GWS Gesellschaft für Warenwirtschafts-Systeme mbH <ebusiness@gws.ms>"]
 readme = "README.md"
@@ -25,6 +25,10 @@ httpx = "^0.26"
 httpx-auth = "^0.21"
 pydantic = "^2.6"
 pytest-random-order = "^1.1.1"
+redis = {version = ">5.0,<7.0", optional = true}
+
+[tool.poetry.extras]
+redis = ["redis"]
 
 [tool.poetry.group.dev.dependencies]
 mypy = "^1.8.0"
@@ -35,6 +39,8 @@ ruff = ">=0.5.0,<0.10"
 pytest-asyncio = ">=0.23.3,<0.26.0"
 pytest-recording = "^0.13.1"
 pytest-mock = "^3.14.0"
+redis = ">5.0,<7.0"
+fakeredis = {extras = ["lua"], version = "^2.30.1"}
 
 [build-system]
 requires = ["poetry-core"]
@@ -47,6 +53,11 @@ warn_unused_configs = true
 disallow_untyped_defs = true
 strict_optional = true
 
+[[tool.mypy.overrides]]
+# Redis stubs don't exist for redis >5.0
+module = "redis.asyncio"
+ignore_missing_imports = true
+
 [tool.pytest.ini_options]
 python_files = ["test_*.py", "*_test.py"]
 filterwarnings = ["ignore::DeprecationWarning"]

{shopware_api_client-1.0.107 → shopware_api_client-1.0.109}/src/shopware_api_client/base.py

@@ -1,8 +1,12 @@
 import asyncio
 import json
-from datetime import UTC, datetime
+from datetime import UTC, datetime, timezone
+from email.utils import parsedate_to_datetime
 from functools import cached_property
+from math import ceil
+from time import time
 from typing import (
+    TYPE_CHECKING,
     Any,
     AsyncGenerator,
     Callable,
@@ -29,6 +33,7 @@ from pydantic import (
 from pydantic.alias_generators import to_camel
 from pydantic.main import IncEx
 
+from .cache import DictCache, RedisCache
 from .endpoints.base_fields import IdField
 from .exceptions import (
     SWAPIDataValidationError,
@@ -37,22 +42,41 @@ from .exceptions import (
     SWAPIException,
     SWAPIGatewayTimeout,
     SWAPIInternalServerError,
+    SWAPIRetryException,
     SWAPIServiceUnavailable,
-    SWAPITooManyRequests,
     SWFilterException,
     SWNoClientProvided,
 )
 from .logging import logger
 
+if TYPE_CHECKING:
+    from redis.asyncio import Redis
+
 APPLICATION_JSON = "application/json"
 
 EndpointClass = TypeVar("EndpointClass", bound="EndpointBase[Any]")
 ModelClass = TypeVar("ModelClass", bound="ApiModelBase[Any]")
+RETRY_CACHE_KEY = "shopware-api-client:retry:{url}:{method}"
+HEADER_X_RATE_LIMIT_LIMIT = "X-Rate-Limit-Limit"
+HEADER_X_RATE_LIMIT_REMAINING = "X-Rate-Limit-Remaining"
+HEADER_X_RATE_LIMIT_RESET = "X-Rate-Limit-Reset"
 
 
 class ConfigBase:
-    def __init__(self, url: str):
+    def __init__(
+        self,
+        url: str,
+        retry_after_threshold: int = 60,
+        redis_client: "Redis | None" = None,
+        local_cache_cleanup_cycle_seconds: int = 10,
+    ) -> None:
         self.url = url.rstrip("/")
+        self.retry_after_threshold = retry_after_threshold
+        self.cache = (
+            RedisCache(redis_client)
+            if redis_client
+            else DictCache(cleanup_cycle_seconds=local_cache_cleanup_cycle_seconds)
+        )
 
 
 class ClientBase:
@@ -60,8 +84,10 @@ class ClientBase:
     raw: bool
     language_id: IdField | None = None
 
-    def __init__(self, config: ConfigBase, raw: bool = False):
+    def __init__(self, config: ConfigBase, raw: bool = False) -> None:
         self.api_url = config.url
+        self.retry_after_threshold = config.retry_after_threshold
+        self.cache = config.cache
         self.raw = raw
 
     async def __aenter__(self) -> "Self":
@@ -112,10 +138,46 @@ class ClientBase:
         client = self.http_client
         client.timeout = timeout  # type: ignore
 
-    async def retry_sleep(self, retry_wait_base: int, retry_count: int) -> None:
-        retry_sleep = retry_wait_base**retry_count
-        logger.debug(f"Try failed, retrying in {retry_sleep} seconds.")
-        await asyncio.sleep(retry_sleep)
+    async def sleep_and_increment(self, retry_wait_base: int, retry_count: int) -> int:
+        retry_count += 1
+        sleep_and_increment = retry_wait_base**retry_count
+        logger.debug(f"Try failed, retrying in {sleep_and_increment} seconds.")
+        await asyncio.sleep(sleep_and_increment)
+        return retry_count
+
+    def get_header_ts(self, header: str | None, fallback_time: float) -> float:
+        if header is None:
+            return fallback_time
+
+        server_dt = parsedate_to_datetime(header)
+        # ensure timezone-aware UTC
+        if server_dt.tzinfo is None:
+            server_dt = server_dt.replace(tzinfo=timezone.utc)
+
+        return server_dt.timestamp()
+
+    def parse_reset_time(self, headers: httpx.Headers) -> int:
+        """Determine reset wait time based on server time"""
+        server_ts = self.get_header_ts(headers.get("Date"), time())
+        reset_ts = float(headers.get(HEADER_X_RATE_LIMIT_RESET, "0"))
+        adjusted_time = reset_ts - server_ts
+
+        return max(0, ceil(adjusted_time))
+
+    def parse_retry_after(self, headers: httpx.Headers) -> int:
+        retry_header: str | None = headers.get("Retry-After")
+        if retry_header is None:
+            return 0
+
+        if retry_header.isdigit():
+            return int(retry_header)
+
+        current_time = time()
+        server_ts = self.get_header_ts(headers.get("Date"), current_time)
+        retry_ts = self.get_header_ts(retry_header, current_time)
+        adjusted_time = retry_ts - server_ts
+
+        return max(0, ceil(adjusted_time))
 
     async def _make_request(self, method: str, relative_url: str, **kwargs: Any) -> httpx.Response:
         if relative_url.startswith("http://") or relative_url.startswith("https://"):
@@ -127,29 +189,82 @@ class ClientBase:
         headers = self._get_headers()
         headers.update(kwargs.pop("headers", {}))
 
+        retry_after_threshold = int(kwargs.pop("retry_after_threshold", self.retry_after_threshold))
         retry_wait_base = int(kwargs.pop("retry_wait_base", 2))
         retries = int(kwargs.pop("retries", 0))
         retry_errors = tuple(
             kwargs.pop("retry_errors", [SWAPIInternalServerError, SWAPIServiceUnavailable, SWAPIGatewayTimeout])
         )
-        no_retry_errors = tuple(kwargs.pop("no_retry_errors", [SWAPITooManyRequests]))
+        no_retry_errors = tuple(kwargs.pop("no_retry_errors", []))
 
         kwargs.setdefault("follow_redirects", True)
 
+        key_base = RETRY_CACHE_KEY.format(
+            url=url.removeprefix("https://").removeprefix("http://"),
+            method=method,
+        )
+        x_retry_limit_cache_key = key_base + ":limit"
+        x_retry_remaining_cache_key = key_base + ":remaining"
+        x_retry_reset_cache_key = key_base + ":reset"
+        x_retry_lock_cache_key = key_base + ":lock"
+        got_lock = False
+
         retry_count = 0
         while True:
+            x_retry_remaining = await self.cache.get_and_decrement(x_retry_remaining_cache_key)
+            if x_retry_remaining is not None and x_retry_remaining <= 0 and not got_lock:
+                current_time = int(time())
+                reset_time = cast(int, await self.cache.get(x_retry_reset_cache_key)) or 0
+                wait_time = max(1, reset_time - current_time)
+
+                if wait_time > retry_after_threshold:
+                    raise SWAPIRetryException(
+                        f"Retry threshold exceeded for endpoint {url!r}. Threshold: {retry_after_threshold}s, Retry-After: {wait_time}s"
+                    )
+
+                await asyncio.sleep(wait_time)
+
+                got_lock = await self.cache.has_lock(x_retry_lock_cache_key, wait_time)
+                continue
+
             try:
                 response = await client.request(method, url, headers=headers, **kwargs)
             except httpx.RequestError as exc:
                 if retry_count >= retries:
                     raise SWAPIException(f"HTTP client exception ({exc.__class__.__name__}). Details: {str(exc)}")
-                await asyncio.sleep(2**retry_count)
-                retry_count += 1
+                retry_count = await self.sleep_and_increment(retry_wait_base, retry_count)
                 continue
+
+            # Set retry-cache if headers are present
+            if rl_limit := response.headers.get(HEADER_X_RATE_LIMIT_LIMIT):
+                x_retry_limit = int(rl_limit)
+                wait_time = self.parse_reset_time(response.headers)
+                remaining_requests = int(response.headers.get(HEADER_X_RATE_LIMIT_REMAINING))
+
+                await asyncio.gather(
+                    self.cache.set(x_retry_limit_cache_key, x_retry_limit),
+                    self.cache.set(x_retry_reset_cache_key, int(time()) + wait_time, wait_time),
+                    self.cache.set(x_retry_remaining_cache_key, remaining_requests),
+                )
+
+                if got_lock:
+                    await self.cache.delete(x_retry_lock_cache_key)
+                    got_lock = False
+
             if response.status_code == 429:
-                # directly raise 429
-                error: SWAPIError = SWAPIError.from_response(response)
-                raise error
+                retry_wait_time = self.parse_retry_after(response.headers)
+                if retry_wait_time > retry_after_threshold:
+                    error = SWAPIError.from_response(response)
+                    raise SWAPIRetryException(
+                        f"Retry threshold exceeded for endpoint {url!r}. Threshold: {retry_after_threshold}s, Retry-After: {retry_wait_time}s"
+                    ) from error
+
+                # If 429 is thrown, Retry-After == X-Rate-Limit-Reset
+                await asyncio.gather(
+                    self.cache.set(x_retry_reset_cache_key, int(time()) + retry_wait_time, retry_wait_time),
+                    asyncio.sleep(retry_wait_time),
+                )
+
             elif response.status_code >= 400:
                 # retry other failure codes
                 try:
@@ -159,7 +274,7 @@ class ClientBase:
                         raise ValueError("`errors` attribute in json not a list/tuple!")
 
                     error: SWAPIError | SWAPIErrorList = SWAPIError.from_errors(errors)  # type: ignore
-                except (json.JSONDecodeError, ValueError):
+                except ValueError:
                     error: SWAPIError | SWAPIErrorList = SWAPIError.from_response(response)  # type: ignore
 
                 if isinstance(error, SWAPIErrorList) and len(error.errors) == 1:
@@ -175,11 +290,10 @@ class ClientBase:
                 elif isinstance(error, no_retry_errors) or not isinstance(error, retry_errors):
                     raise error
 
-                if retry_count == retries:
+                if retry_count >= retries:
                     raise error
 
-                await self.retry_sleep(retry_wait_base, retry_count)
-                retry_count += 1
+                retry_count = await self.sleep_and_increment(retry_wait_base, retry_count)
             elif response.status_code == 200 and response.headers.get("Content-Type", "").startswith(APPLICATION_JSON):
                 # guard against "200 okay" responses with malformed json
                 try:
@@ -196,9 +310,7 @@ class ClientBase:
                         )
                         raise exception
 
-                    # schedule retry
-                    await self.retry_sleep(retry_wait_base, retry_count)
-                    retry_count += 1
+                    retry_count = await self.sleep_and_increment(retry_wait_base, retry_count)
             else:
                 return response
 

shopware_api_client-1.0.109/src/shopware_api_client/cache.py

@@ -0,0 +1,162 @@
+import json
+from abc import ABC, abstractmethod
+from collections import OrderedDict
+from time import time
+from typing import Any, Awaitable, NamedTuple, cast
+
+try:
+    from redis.asyncio import Redis
+
+    _has_redis = True
+except ModuleNotFoundError:
+    _has_redis = False
+
+
+class CacheBase(ABC):
+    @abstractmethod
+    async def get(self, key: str) -> Any | None:
+        ...
+
+    @abstractmethod
+    async def get_and_decrement(self, key: str) -> int | None:
+        ...
+
+    @abstractmethod
+    async def has_lock(self, key: str, ttl: int) -> bool:
+        ...
+
+    @abstractmethod
+    async def set(self, key: str, value: Any, ttl: int | None = None) -> None:
+        ...
+
+    @abstractmethod
+    async def delete(self, key: str) -> None:
+        ...
+
+    @staticmethod
+    def _json_encode(key: str, value: Any) -> str:
+        try:
+            return json.dumps(value)
+        except (TypeError, ValueError) as e:
+            raise ValueError(f"Value {value!r} for cache key {key!r} must be JSON-serializable: {e}") from e
+
+    @staticmethod
+    def _json_decode(raw_value: Any) -> Any | None:
+        if raw_value is None:
+            return None
+
+        try:
+            return json.loads(raw_value)
+        except json.JSONDecodeError:
+            # If write was broken, mimic missing key
+            return None
+
+
+class RedisCache(CacheBase):
+    _DECR_IF_EXISTS = """
+        if redis.call('EXISTS', KEYS[1]) == 1 then
+            return redis.call('DECR', KEYS[1])
+        else
+            return nil
+        end
+    """
+
+    def __init__(self, redis_client: "Redis") -> None:
+        if not _has_redis:
+            raise RuntimeError("Redis needs to be installed to use it as a cache.")
+
+        self.client = redis_client
+
+    async def get(self, key: str) -> Any | None:
+        value = await self.client.get(key)
+        return self._json_decode(value)
+
+    async def get_and_decrement(self, key: str) -> int | None:
+        return_value = await cast(Awaitable[int | None], self.client.eval(self._DECR_IF_EXISTS, 1, key))
+        return None if return_value is None else return_value + 1
+
+    async def has_lock(self, key: str, ttl: int) -> bool:
+        return await self.client.set(key, 1, ex=ttl, nx=True) or False
+
+    async def set(self, key: str, value: Any, ttl: int | None = None) -> None:
+        await self.client.set(name=key, value=self._json_encode(key, value), ex=ttl)
+
+    async def delete(self, key: str) -> None:
+        await self.client.delete(key)
+
+
+class DictCache(CacheBase):
+    class CacheValue(NamedTuple):
+        value: Any
+        expire_at: int | None
+
+    def __init__(self, cleanup_cycle_seconds: int) -> None:
+        self._cache: OrderedDict[str, DictCache.CacheValue] = OrderedDict()
+        self.cleanup_cycle_seconds = cleanup_cycle_seconds
+        self.next_cleanup: int = 0
+
+    async def get(self, key: str) -> Any | None:
+        self._cleanup_by_expiry()
+        entry = self._cache.get(key)
+
+        return self._json_decode(entry and entry.value)
+
+    async def get_and_decrement(self, key: str) -> int | None:
+        self._cleanup_by_expiry()
+        entry = self._cache.get(key)
+        if entry is None:
+            return None
+
+        decoded_value = self._json_decode(entry.value)
+        if not isinstance(decoded_value, int):
+            raise ValueError(f"Trying to decrement key {key!r}, but value {decoded_value!r} is not an int")
+
+        new_value = decoded_value - 1
+        self._cache[key] = DictCache.CacheValue(self._json_encode(key, new_value), entry.expire_at)
+
+        return decoded_value
+
+    async def has_lock(self, key: str, ttl: int) -> bool:
+        self._cleanup_by_expiry(False)
+        entry = self._cache.get(key)
+        if unlocked := entry is None:
+            self._cache[key] = DictCache.CacheValue(True, self.get_expiry(ttl))
+
+        return unlocked
+
+    async def set(self, key: str, value: Any, ttl: int | None = None) -> None:
+        self._cleanup_by_expiry()
+        cache_value = self._json_encode(key, value)
+
+        self._cache[key] = DictCache.CacheValue(cache_value, self.get_expiry(ttl))
+
+    async def delete(self, key: str) -> None:
+        self._cleanup_by_expiry()
+        self._cache.pop(key, None)
+
+    def get_expiry(self, ttl: int | None) -> int | None:
+        return int(time()) + ttl if ttl is not None else None
+
+    def _cleanup_by_expiry(self, do_wait: bool = True) -> None:
+        now = int(time())
+
+        if now < self.next_cleanup and do_wait:
+            return
+
+        initial_size = len(self._cache)
+        for _ in range(initial_size):
+            if not self._cache:
+                break
+
+            first_key, first_value = next(iter(self._cache.items()))
+
+            if first_value.expire_at is None:
+                self._cache.move_to_end(first_key)
+                continue
+
+            if first_value.expire_at > now:
+                break
+
+            self._cache.popitem(last=False)
+
+        self.next_cleanup = now + self.cleanup_cycle_seconds

{shopware_api_client-1.0.107 → shopware_api_client-1.0.109}/src/shopware_api_client/config.py

@@ -14,6 +14,7 @@ class AdminConfig(ConfigBase):
         client_secret: str | None = None,
         grant_type: str = "client_credentials",
         extra: dict[str, Any] | None = None,
+        **kwargs: Any,
     ) -> None:
         match grant_type:
             case "client_credentials":
@@ -27,7 +28,7 @@ class AdminConfig(ConfigBase):
             case _:
                 raise SWAPIConfigException("Invalid 'grant_type'. Must be one of: 'client_credentials', 'password'")
 
-        super().__init__(url=url)
+        super().__init__(url=url, **kwargs)
         self.username = username
         self.password = password
         self.client_id = client_id
@@ -37,7 +38,7 @@ class AdminConfig(ConfigBase):
 
 
 class StoreConfig(ConfigBase):
-    def __init__(self, url: str, access_key: str, context_token: str | None = None):
-        super().__init__(url=url)
+    def __init__(self, url: str, access_key: str, context_token: str | None = None, **kwargs: Any):
+        super().__init__(url=url, **kwargs)
         self.access_key = access_key
         self.context_token = context_token

{shopware_api_client-1.0.107 → shopware_api_client-1.0.109}/src/shopware_api_client/exceptions.py

@@ -24,6 +24,10 @@ class SWAPIConfigException(SWAPIException):
     pass
 
 
+class SWAPIRetryException(SWAPIException):
+    pass
+
+
 class SWAPIMethodNotAvailable(SWAPIConfigException):
     def __init__(self, msg: str | None = None, *args: list[Any], **kwargs: dict[Any, Any]) -> None:
         if not msg:
@@ -95,7 +99,13 @@ class SWAPIError(SWAPIException):
     @classmethod
     def from_response(cls, response: Response) -> "SWAPIError":
         exception_class = cls.get_exception_class(response.status_code)
-        response.headers["requested-url"] = str(response.request.url)
+
+        try:
+            response.headers["requested-url"] = str(response.request.url)
+        except RuntimeError:
+            # If the request URL is not available, we can ignore it.
+            pass
+
         return exception_class(
             status=response.status_code,
             title=response.reason_phrase,