shopware-api-client 1.0.101__py3-none-any.whl → 1.0.118__py3-none-any.whl

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,20 +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:
@@ -58,12 +84,15 @@ 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":
-        self.http_client
+        client = self.http_client
+        assert isinstance(client, httpx.AsyncClient), "http_client must be an instance of httpx.AsyncClient"
         return self
 
     async def __aexit__(self, *args: Any) -> None:
@@ -86,15 +115,13 @@ class ClientBase:
 
     @cached_property
     def http_client(self) -> httpx.AsyncClient:
-        return self._get_client()
+        return self._get_http_client()
 
-    def _get_client(self) -> httpx.AsyncClient:
-        # FIXME: rename _get_client -> _get_http_client to avoid confusion with ApiModelBase._get_client
-        #        (fix middleware usage of private method usage first)
+    def _get_http_client(self) -> httpx.AsyncClient:
         raise NotImplementedError()
 
     def _get_headers(self) -> dict[str, str]:
-        headers = {"Content-Type": "application/json", "Accept": "application/json"}
+        headers = {"Content-Type": APPLICATION_JSON, "Accept": APPLICATION_JSON}
 
         if self.language_id is not None:
             headers["sw-language-id"] = str(self.language_id)
@@ -111,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 1
+
+        if retry_header.isdigit():
+            return max(1, 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(1, 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://"):
@@ -126,35 +189,96 @@ class ClientBase:
         headers = self._get_headers()
         headers.update(kwargs.pop("headers", {}))
 
-        retry_wait_base = int(kwargs.pop("retriy_wait_base", 2))
+        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
 
-            if response.status_code >= 400:
+            # 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))
+
+                tasks = [
+                    self.cache.set(x_retry_remaining_cache_key, remaining_requests),
+                    self.cache.set(x_retry_limit_cache_key, x_retry_limit),
+                ]
+
+                if wait_time > 0:
+                    tasks.append(self.cache.set(x_retry_reset_cache_key, int(time()) + wait_time, wait_time))
+
+                await asyncio.gather(*tasks)
+
+                if got_lock:
+                    await self.cache.delete(x_retry_lock_cache_key)
+                    got_lock = False
+
+            if response.status_code == 429:
+                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:
                     errors: list = response.json().get("errors")
                     # ensure `errors` attribute is a list/tuple, fallback to from_response if not
                     if not isinstance(errors, (list, tuple)):
                         raise ValueError("`errors` attribute in json not a list/tuple!")
 
-                    error: SWAPIError | SWAPIErrorList = SWAPIError.from_errors(errors)
-                except (json.JSONDecodeError, ValueError):
+                    error: SWAPIError | SWAPIErrorList = SWAPIError.from_errors(errors, response)  # type: ignore
+                except ValueError:
                     error: SWAPIError | SWAPIErrorList = SWAPIError.from_response(response)  # type: ignore
 
                 if isinstance(error, SWAPIErrorList) and len(error.errors) == 1:
@@ -170,15 +294,15 @@ 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
-            else:
+                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:
                     setattr(response, "json_cached", response.json())
+                    return response
                 except json.JSONDecodeError:
                     # retries exhausted?
                     if retry_count >= retries:
@@ -190,11 +314,8 @@ class ClientBase:
                         )
                         raise exception
 
-                    # schedule retry
-                    await self.retry_sleep(retry_wait_base, retry_count)
-                    retry_count += 1
-                    continue
-
+                    retry_count = await self.sleep_and_increment(retry_wait_base, retry_count)
+            else:
                 return response
 
     async def get(self, relative_url: str, **kwargs: Any) -> httpx.Response:
@@ -402,6 +523,9 @@ class EndpointBase(Generic[ModelClass]):
         if not self.model_class.__pydantic_complete__:
             self.model_class.model_rebuild()
 
+        if name == getattr(self.model_class, "_identifier").get_default():
+            return name
+
         field = self.model_class.model_fields[name]
 
         if get_origin(field.annotation) in [ForeignRelation, ManyRelation]:
@@ -473,7 +597,7 @@ class EndpointBase(Generic[ModelClass]):
 
         return data
 
-    def _prase_data_single(self, reponse_dict: dict[str, Any]) -> dict[str, Any]:
+    def _parse_data_single(self, reponse_dict: dict[str, Any]) -> dict[str, Any]:
         return self._parse_data(reponse_dict)[0]
 
     async def all(self) -> list[ModelClass] | list[dict[str, Any]]:
@@ -495,7 +619,7 @@ class EndpointBase(Generic[ModelClass]):
 
     async def get(self, pk: str) -> ModelClass | dict[str, Any]:
         result = await self.client.get(f"{self.path}/{pk}")
-        result_data: dict[str, Any] = self._prase_data_single(result.json())
+        result_data: dict[str, Any] = self._parse_data_single(result.json())
 
         if self.raw:
             return result_data
@@ -515,7 +639,7 @@ class EndpointBase(Generic[ModelClass]):
         if result.status_code == 204:
             return None
 
-        result_data: dict[str, Any] = self._prase_data_single(result.json())
+        result_data: dict[str, Any] = self._parse_data_single(result.json())
 
         if self.raw:
             return result_data
@@ -545,7 +669,7 @@ class EndpointBase(Generic[ModelClass]):
         if result.status_code == 204:
             return None
 
-        result_data: dict[str, Any] = self._prase_data_single(result.json())
+        result_data: dict[str, Any] = self._parse_data_single(result.json())
 
         if self.raw:
             return result_data
@@ -575,7 +699,9 @@ class EndpointBase(Generic[ModelClass]):
         return self
 
     def only(self, **kwargs: list[str]) -> Self:
-        self._includes.update({self._serialize_field_name(field): data for field, data in kwargs.items()})
+        for field, data in kwargs.items():
+            self._includes[self._serialize_field_name(field)] = [self._serialize_field_name(d) for d in data]
+
         return self
 
     def filter(self, **kwargs: Any) -> Self:

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/client.py

@@ -19,7 +19,7 @@ class AdminClient(ClientBase, AdminEndpoints):
         self._client: httpx.AsyncClient | None = None
         self.init_endpoints(self)
 
-    def _get_client(self) -> httpx.AsyncClient:
+    def _get_http_client(self) -> httpx.AsyncClient:
         if self._client is None:
             self._client = httpx.AsyncClient(
                 event_hooks={"request": [self.log_request], "response": [self.log_response]}
@@ -180,7 +180,7 @@ class StoreClient(ClientBase, StoreEndpoints):
         self._client: httpx.AsyncClient | None = None
         self.init_endpoints(self)
 
-    def _get_client(self) -> httpx.AsyncClient:
+    def _get_http_client(self) -> httpx.AsyncClient:
         if self._client is None:
             self._client = httpx.AsyncClient(
                 event_hooks={"request": [self.log_request], "response": [self.log_response]},

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/endpoints/admin/__init__.py

@@ -4,6 +4,11 @@ if TYPE_CHECKING:
     from ...client import AdminClient
 
 from .commercial.b2b_components_role import B2bComponentsRole, B2bComponentsRoleEndpoint
+from .commercial.b2b_components_shopping_list import B2bComponentsShoppingList, B2bComponentsShoppingListEndpoint
+from .commercial.b2b_components_shopping_list_line_item import (
+    B2bComponentsShoppingListLineItem,
+    B2bComponentsShoppingListLineItemEndpoint,
+)
 from .commercial.b2b_employee import B2bEmployee, B2bEmployeeEndpoint
 from .commercial.dynamic_access import DynamicAccess, DynamicAccessEndpoint
 from .core.acl_role import AclRole, AclRoleEndpoint
@@ -111,6 +116,8 @@ __all__ = [
     "AdminEndpoints",
     "B2bComponentsRole",
     "B2bEmployee",
+    "B2bComponentsShoppingList",
+    "B2bComponentsShoppingListLineItem",
     "ApiInfo",
     "App",
     "AppScriptCondition",
@@ -269,6 +276,8 @@ class AdminEndpoints:
         self.b2b_employee = B2bEmployeeEndpoint(client)
         self.b2b_components_role = B2bComponentsRoleEndpoint(client)
         self.dynamic_access = DynamicAccessEndpoint(client)
+        self.b2b_components_shopping_list = B2bComponentsShoppingListEndpoint(client)
+        self.b2b_components_shopping_list_line_item = B2bComponentsShoppingListLineItemEndpoint(client)
 
         # Core
         self.acl_role = AclRoleEndpoint(client)

shopware_api_client/endpoints/admin/commercial/b2b_components_shopping_list.py

@@ -0,0 +1,42 @@
+
+
+from typing import Any
+
+from ....base import ApiModelBase, EndpointBase, EndpointClass
+from ...base_fields import Price
+from ...relations import ForeignRelation, ManyRelation
+
+
+class B2bComponentsShoppingListBase(ApiModelBase[EndpointClass]):
+    _identifier: str = "b2b_components_shopping_list"
+
+    name: str | None = None
+    active: bool | None = None
+    custom_fields: dict[str, Any] | None = None
+    price: Price | None = None
+    sales_channel_id: str | None = None
+    customer_id: str | None = None
+    employee_id: str | None = None
+
+
+class B2bComponentsShoppingListRelations:
+    sales_channel: ForeignRelation["SalesChannel"]
+    line_items: ManyRelation["B2bComponentsShoppingListLineItem"]
+    customer: ForeignRelation["Customer"]
+    employee: ForeignRelation["B2bEmployee"]
+
+
+class B2bComponentsShoppingList(B2bComponentsShoppingListBase["B2bComponentsShoppingListEndpoint"], B2bComponentsShoppingListRelations):
+    pass
+
+
+class B2bComponentsShoppingListEndpoint(EndpointBase[B2bComponentsShoppingList]):
+    name = "b2b_components_shopping_list"
+    path = "/b2b-components-shopping-list"
+    model_class = B2bComponentsShoppingList
+
+
+from ..core.customer import Customer  # noqa: E402
+from ..core.sales_channel import SalesChannel  # noqa: E402
+from .b2b_components_shopping_list_line_item import B2bComponentsShoppingListLineItem  # noqa: E402
+from .b2b_employee import B2bEmployee  # noqa: E402

shopware_api_client/endpoints/admin/commercial/b2b_components_shopping_list_line_item.py

@@ -0,0 +1,37 @@
+from typing import Any
+
+from ....base import ApiModelBase, EndpointBase, EndpointClass
+from ...base_fields import IdField
+from ...relations import ForeignRelation
+
+
+class B2bComponentsShoppingListLineItemBase(ApiModelBase[EndpointClass]):
+    _identifier: str = "b2b_components_shopping_list_line_item"
+    product_id: IdField
+    product_version_id: IdField | None = None
+    quantity: int
+    price: dict[str, Any] | None = None
+    custom_fields: dict[str, Any] | None = None
+    shopping_list_id: IdField
+
+
+class B2bComponentsShoppingListLineItemRelations:
+    shopping_list: ForeignRelation["B2bComponentsShoppingList"]
+    product: ForeignRelation["Product"]
+
+
+class B2bComponentsShoppingListLineItem(
+    B2bComponentsShoppingListLineItemBase["B2bComponentsShoppingListLineItemEndpoint"],
+    B2bComponentsShoppingListLineItemRelations,
+):
+    pass
+
+
+class B2bComponentsShoppingListLineItemEndpoint(EndpointBase[B2bComponentsShoppingListLineItem]):
+    name = "b2b_components_shopping_list_line_item"
+    path = "/b2b-components-shopping-list-line-item"
+    model_class = B2bComponentsShoppingListLineItem
+
+
+from ..core.product import Product  # noqa: E402
+from .b2b_components_shopping_list import B2bComponentsShoppingList  # noqa: E402

shopware_api_client/endpoints/admin/core/media.py

@@ -13,7 +13,7 @@ class MediaBase(ApiModelBase[EndpointClass]):
     user_id: IdField | None = None
     media_folder_id: IdField | None = Field(default=None)
     mime_type: str | None = Field(default=None)
-    file_extension: str | None = Field(default=None, exclude=True)
+    file_extension: str | None = Field(default=None)
     uploaded_at: AwareDatetime | None = Field(default=None, exclude=True)
     file_name: str | None = Field(default=None)
     file_size: int | None = Field(default=None, exclude=True)

shopware_api_client/endpoints/admin/core/media_thumbnail.py

@@ -1,6 +1,7 @@
+from datetime import UTC, datetime
 from typing import Any
 
-from pydantic import Field
+from pydantic import AwareDatetime, Field
 
 from ....base import ApiModelBase, EndpointBase, EndpointClass
 from ...base_fields import IdField
@@ -9,6 +10,7 @@ from ...relations import ForeignRelation
 
 class MediaThumbnailBase(ApiModelBase[EndpointClass]):
     _identifier = "media_thumbnail"
+    created_at: AwareDatetime | None = Field(default_factory=lambda: datetime.now(UTC), exclude=True)  # type: ignore
 
     media_id: IdField
     width: int = Field(default=0, exclude=True)

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:
@@ -43,6 +47,8 @@ class SWAPIError(SWAPIException):
         self.source = kwargs.get("source", {})
         self.meta = kwargs.get("meta", {})
         self.headers = kwargs.get("headers", {})
+        self.request = kwargs.get("request", None)
+        self.response = kwargs.get("response", None)
 
     def __str__(self) -> str:
         return f"Status: {self.status} {self.title} - {self.detail} - {self.source}"
@@ -83,10 +89,11 @@ class SWAPIError(SWAPIException):
                 return SWAPIError
 
     @classmethod
-    def from_errors(cls, errors: list[dict[str, Any]]) -> "SWAPIErrorList":
+    def from_errors(cls, errors: list[dict[str, Any]], response: Response) -> "SWAPIErrorList":
         errlist = []
 
         for error in errors:
+            error.update({"response": response, "request": response.request})
             exception_class = cls.get_exception_class(int(error["status"]))
             errlist.append(exception_class(**error))
 
@@ -95,11 +102,20 @@ class SWAPIError(SWAPIException):
     @classmethod
     def from_response(cls, response: Response) -> "SWAPIError":
         exception_class = cls.get_exception_class(response.status_code)
+
+        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,
             detail=response.text,
             headers=response.headers,
+            request=response._request,
+            response=response,
         )
 
 

{shopware_api_client-1.0.101.dist-info → shopware_api_client-1.0.118.dist-info}/METADATA

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: shopware-api-client
-Version: 1.0.101
+Version: 1.0.118
 Summary:  An api client for the Shopware API
 License: MIT
+License-File: LICENSE
 Keywords: shopware,api,client
 Author: GWS Gesellschaft für Warenwirtschafts-Systeme mbH
 Author-email: ebusiness@gws.ms
@@ -12,10 +13,13 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+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 +33,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 +160,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 +184,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.101.dist-info → shopware_api_client-1.0.118.dist-info}/RECORD

@@ -1,11 +1,14 @@
 shopware_api_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shopware_api_client/base.py,sha256=x4VIfvpDbyIaqCY60LEVCIIRm_YQZ8CVR0EIKtGCwZg,24977
-shopware_api_client/client.py,sha256=9b4Hvj6izHEMplus6--S2no0Sts61vg25HNIPEhJ7JQ,7573
-shopware_api_client/config.py,sha256=HStgfQcClpo_aqaTRDrqdTUjqSGPFkIMjrPwSruVnM8,1565
+shopware_api_client/base.py,sha256=pyGavZ4Z22mbn6WbZgaLOSVeu4ZwFOFdCZQa2O4e-Ms,30409
+shopware_api_client/cache.py,sha256=JtojK7yDfAM937rDoqJj_FpNFf3zsfueTSyUX_Gsk4w,4997
+shopware_api_client/client.py,sha256=vkTZ8WLIu0Q3_73gXvidkTSpMJlWsJUjFyhDY2f2ISM,7583
+shopware_api_client/config.py,sha256=6IzpkuoYsh0d5c0BR453n1ijQwxB74HDYx1L6dmlJwQ,1623
 shopware_api_client/endpoints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shopware_api_client/endpoints/admin/__init__.py,sha256=yfGXeIzGDoAIzVBp0zEGYMcWKoc-qrjMeot8HXOwfhA,17213
+shopware_api_client/endpoints/admin/__init__.py,sha256=-gRCCoyflh96K5XbBzVNSnhD2GKeNuSSpKQoJVeY-xQ,17744
 shopware_api_client/endpoints/admin/commercial/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shopware_api_client/endpoints/admin/commercial/b2b_components_role.py,sha256=gnqCh5s4j5ReBgBMrTrSBlUzJJ7nSiaNtlEXiIuHc30,977
+shopware_api_client/endpoints/admin/commercial/b2b_components_shopping_list.py,sha256=yOP9CEFQ7ZctbFUgsnXiwAXKu_Vt_WXE8uX_qzxHR18,1422
+shopware_api_client/endpoints/admin/commercial/b2b_components_shopping_list_line_item.py,sha256=tgy2Z4QX2zB-YHgjOOCzvbNoa5hP0S4YEhnisk1TnTE,1246
 shopware_api_client/endpoints/admin/commercial/b2b_employee.py,sha256=dzE9h6UFPI94ZXuENJvpQb6tBY8wk7-3WXu7QW_CT2I,1166
 shopware_api_client/endpoints/admin/commercial/dynamic_access.py,sha256=W-3WFyxiA_5ph3cbDaUeHIaiqSMiRNPJAAgbbQQIVUU,805
 shopware_api_client/endpoints/admin/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -40,11 +43,11 @@ shopware_api_client/endpoints/admin/core/landing_page.py,sha256=ohqquIPIECgHh1c5
 shopware_api_client/endpoints/admin/core/language.py,sha256=ZikBOB8ekS2zepjNuD55JiZ8UEstxNJDGZVyvMB88VY,1749
 shopware_api_client/endpoints/admin/core/locale.py,sha256=bXSHNF16VJJgwtge34vA_jOK23JmKxFarOeIS30kpQM,712
 shopware_api_client/endpoints/admin/core/main_category.py,sha256=KHk7MIrhh56A8IPreRnKvbl5za3710MoWYdmsZRaVsI,954
-shopware_api_client/endpoints/admin/core/media.py,sha256=GJYSML5WGTH_7GQIoEJkc7V54LzrbmCIK0OEmk5Xncc,4855
+shopware_api_client/endpoints/admin/core/media.py,sha256=dBQ1WHocbew4YOjUV0JdPqfa7H_8dmJZMfkSt5jlQNc,4841
 shopware_api_client/endpoints/admin/core/media_default_folder.py,sha256=WBVoJhKF1j20VhBdZs5fsp8FN3q_yS46TRXCsyOejpA,695
 shopware_api_client/endpoints/admin/core/media_folder.py,sha256=t18uurbPXtOZB7RR-pGQnF_IJ7UP0VAOABk0mHRypdg,1333
 shopware_api_client/endpoints/admin/core/media_folder_configuration.py,sha256=DabEuDxDMRcbYpLun--LVHxX6cg8NH0FP1xv4-t_a3Y,1114
-shopware_api_client/endpoints/admin/core/media_thumbnail.py,sha256=VFpp1BPXb_qQ7iwxyMX2pjeE9RK8bvfnf2oUl5v7PG0,989
+shopware_api_client/endpoints/admin/core/media_thumbnail.py,sha256=7X1nLKk9hnXwFDQvBF0CM_3JxTWFUM6hjs3eOXawHB4,1157
 shopware_api_client/endpoints/admin/core/media_thumbnail_size.py,sha256=Uw06yOFlhb-_H3VIxGiWgn--OmkysMancuOPu9A-NjU,800
 shopware_api_client/endpoints/admin/core/order.py,sha256=ly5EzLYWUyufixT7Uv_lZrhNtOxvNHJmMSgh9a_P7l4,3040
 shopware_api_client/endpoints/admin/core/order_address.py,sha256=BQXFwzKypu1xZWTed-sZxrvs2T9CrSPuYapynjAMO-A,1625
@@ -105,10 +108,10 @@ shopware_api_client/endpoints/store/__init__.py,sha256=LE_GL4jYVGrRdp6M1cPURI-UJ
 shopware_api_client/endpoints/store/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shopware_api_client/endpoints/store/core/address.py,sha256=Tm7ri-i0zhyt4LVEHaQy3xEvjapCCPRsYAp5lOCDOew,2774
 shopware_api_client/endpoints/store/core/cart.py,sha256=34eNwuv7H9WZUtJGf4TkTGHiGynDT6xeAt0gIl7V4KI,2584
-shopware_api_client/exceptions.py,sha256=AELVvzdjH0RABF0WgqQ-DbEuZB1k-5V8L_NkKZLV6tk,4459
+shopware_api_client/exceptions.py,sha256=sxQ1O_XSzmuEnuJkztnZ-zu-NCcOQ3kMWn_8M4j5YxA,4989
 shopware_api_client/logging.py,sha256=4QSTK1vcdBew4shvLG-fm-xDOlddhOZeyb5T9Og0fSA,251
 shopware_api_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shopware_api_client-1.0.101.dist-info/LICENSE,sha256=qTihFhbGE2ZJJ7Byc9hnEYBY33yDK2Jw87SpAm0IKUs,1107
-shopware_api_client-1.0.101.dist-info/METADATA,sha256=UwnWQIm54nwFGcGafokW5eaIX8VrAQCGqxpOztwyvC8,22659
-shopware_api_client-1.0.101.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-shopware_api_client-1.0.101.dist-info/RECORD,,
+shopware_api_client-1.0.118.dist-info/METADATA,sha256=ixCVUBkvzftJkGWBOvA4hL4Q0hhj_G6NBE-BZbNxPkA,24450
+shopware_api_client-1.0.118.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+shopware_api_client-1.0.118.dist-info/licenses/LICENSE,sha256=qTihFhbGE2ZJJ7Byc9hnEYBY33yDK2Jw87SpAm0IKUs,1107
+shopware_api_client-1.0.118.dist-info/RECORD,,

{shopware_api_client-1.0.101.dist-info → shopware_api_client-1.0.118.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any