ordercloud-python 2026.4.1__py3-none-any.whl

ordercloud/__init__.py

@@ -0,0 +1,37 @@
+"""Idiomatic Python SDK for Sitecore OrderCloud.
+
+Quick start::
+
+    from ordercloud import OrderCloudClient
+
+    async with OrderCloudClient.create(
+        client_id="YOUR_CLIENT_ID",
+        client_secret="YOUR_CLIENT_SECRET",
+    ) as client:
+        products = await client.products.list()
+"""
+
+from importlib.metadata import version as _version
+
+from .client import OrderCloudClient
+from .config import OrderCloudConfig
+from .errors import AuthenticationError, OrderCloudError
+from .middleware import AfterResponse, BeforeRequest, RequestContext, ResponseContext
+from .resources.base import paginate
+from .sync_client import SyncOrderCloudClient, paginate_sync
+
+__version__ = _version("ordercloud-python")
+
+__all__ = [
+    "OrderCloudClient",
+    "SyncOrderCloudClient",
+    "OrderCloudConfig",
+    "OrderCloudError",
+    "AuthenticationError",
+    "BeforeRequest",
+    "AfterResponse",
+    "RequestContext",
+    "ResponseContext",
+    "paginate",
+    "paginate_sync",
+]

ordercloud/auth.py

@@ -0,0 +1,136 @@
+"""OAuth2 token management for OrderCloud API authentication."""
+
+import asyncio
+import time
+from typing import Any, Optional
+
+import httpx
+
+from .config import OrderCloudConfig
+
+__all__ = ["AccessToken", "TokenManager"]
+
+
+class AccessToken:
+    """An OAuth2 access token with expiry tracking.
+
+    Stores the token string, optional refresh token, and calculates an
+    absolute expiry timestamp with a 30-second safety buffer.
+
+    Args:
+        access_token: The bearer token string.
+        expires_in: Token lifetime in seconds (from the OAuth2 response).
+        refresh_token: Optional refresh token for token renewal.
+    """
+
+    def __init__(self, access_token: str, expires_in: int, refresh_token: str = "") -> None:
+        self.access_token = access_token
+        self.refresh_token = refresh_token
+        self._expires_at = time.time() + expires_in
+
+    @property
+    def is_expired(self) -> bool:
+        """Whether the token has expired (with a 30-second safety buffer)."""
+        return time.time() >= self._expires_at - 30
+
+    def __repr__(self) -> str:
+        return f"AccessToken(expired={self.is_expired})"
+
+
+class TokenManager:
+    """Handles OAuth2 token acquisition and automatic refresh.
+
+    Supports ``client_credentials`` and ``password`` grant types.
+    Tokens are cached and automatically refreshed when expired.
+    Thread-safe under concurrent async access via an internal lock.
+
+    Args:
+        config: The client configuration containing credentials and URLs.
+    """
+
+    def __init__(self, config: OrderCloudConfig) -> None:
+        self._config = config
+        self._token: Optional[AccessToken] = None
+        self._lock = asyncio.Lock()
+
+    @staticmethod
+    def _parse_token_response(body: dict[str, Any]) -> AccessToken:
+        """Parse an OAuth2 token response into an ``AccessToken``."""
+        return AccessToken(
+            access_token=body["access_token"],
+            expires_in=body.get("expires_in", 600),
+            refresh_token=body.get("refresh_token", ""),
+        )
+
+    async def get_token(self, client: httpx.AsyncClient) -> str:
+        """Return a valid access token, refreshing if needed.
+
+        If a refresh token is available, attempts refresh first.  On
+        failure, clears the stale token and falls back to a full
+        ``client_credentials`` authentication.
+
+        Args:
+            client: The HTTP client to use for token requests.
+
+        Returns:
+            A valid bearer token string.
+        """
+        async with self._lock:
+            if self._token is None or self._token.is_expired:
+                if self._token and self._token.refresh_token:
+                    try:
+                        await self._refresh(client)
+                    except httpx.HTTPStatusError:
+                        self._token = None
+                        await self._authenticate(client)
+                else:
+                    await self._authenticate(client)
+            assert self._token is not None
+            return self._token.access_token
+
+    async def _authenticate(self, client: httpx.AsyncClient) -> None:
+        """Authenticate via the ``client_credentials`` grant type."""
+        data = {
+            "grant_type": "client_credentials",
+            "client_id": self._config.client_id,
+            "client_secret": self._config.client_secret,
+            "scope": " ".join(self._config.scopes),
+        }
+        resp = await client.post(self._config.auth_url, data=data)
+        resp.raise_for_status()
+        self._token = self._parse_token_response(resp.json())
+
+    async def _refresh(self, client: httpx.AsyncClient) -> None:
+        """Refresh an existing token using the ``refresh_token`` grant type."""
+        assert self._token is not None
+        data = {
+            "grant_type": "refresh_token",
+            "client_id": self._config.client_id,
+            "refresh_token": self._token.refresh_token,
+        }
+        resp = await client.post(self._config.auth_url, data=data)
+        resp.raise_for_status()
+        self._token = self._parse_token_response(resp.json())
+
+    async def authenticate_password(
+        self, client: httpx.AsyncClient, username: str, password: str
+    ) -> None:
+        """Authenticate via the ``password`` grant type.
+
+        Args:
+            client: The HTTP client to use for the token request.
+            username: The buyer user's username.
+            password: The buyer user's password.
+        """
+        data: dict[str, str] = {
+            "grant_type": "password",
+            "client_id": self._config.client_id,
+            "username": username,
+            "password": password,
+            "scope": " ".join(self._config.scopes),
+        }
+        if self._config.client_secret:
+            data["client_secret"] = self._config.client_secret
+        resp = await client.post(self._config.auth_url, data=data)
+        resp.raise_for_status()
+        self._token = self._parse_token_response(resp.json())

ordercloud/client.py

@@ -0,0 +1,211 @@
+# GENERATED by tools/codegen — DO NOT EDIT
+# Source: ordercloud-openapi-v3.json
+"""OrderCloud API client with all resource accessors."""
+
+from __future__ import annotations
+
+from .auth import TokenManager
+from .config import OrderCloudConfig
+from .http import HttpClient
+from .middleware import AfterResponse, BeforeRequest
+from .resources.addresses import AddressesResource
+from .resources.admin_addresses import AdminAddressesResource
+from .resources.admin_user_groups import AdminUserGroupsResource
+from .resources.admin_users import AdminUsersResource
+from .resources.api_clients import ApiClientsResource
+from .resources.approval_rules import ApprovalRulesResource
+from .resources.bundle_line_items import BundleLineItemsResource
+from .resources.bundle_subscription_items import BundleSubscriptionItemsResource
+from .resources.bundles import BundlesResource
+from .resources.buyer_groups import BuyerGroupsResource
+from .resources.buyers import BuyersResource
+from .resources.cart import CartResource
+from .resources.catalogs import CatalogsResource
+from .resources.categories import CategoriesResource
+from .resources.cost_centers import CostCentersResource
+from .resources.credit_cards import CreditCardsResource
+from .resources.delivery_configurations import DeliveryConfigurationsResource
+from .resources.discounts import DiscountsResource
+from .resources.entity_syncs import EntitySyncsResource
+from .resources.error_configs import ErrorConfigsResource
+from .resources.forgotten_credentials import ForgottenCredentialsResource
+from .resources.group_orders import GroupOrdersResource
+from .resources.impersonation_configs import ImpersonationConfigsResource
+from .resources.incrementors import IncrementorsResource
+from .resources.integration_events import IntegrationEventsResource
+from .resources.inventory_integrations import InventoryIntegrationsResource
+from .resources.inventory_records import InventoryRecordsResource
+from .resources.line_items import LineItemsResource
+from .resources.locales import LocalesResource
+from .resources.me import MeResource
+from .resources.message_senders import MessageSendersResource
+from .resources.open_id_connects import OpenIdConnectsResource
+from .resources.order_returns import OrderReturnsResource
+from .resources.order_syncs import OrderSyncsResource
+from .resources.orders import OrdersResource
+from .resources.payments import PaymentsResource
+from .resources.price_schedules import PriceSchedulesResource
+from .resources.product_collections import ProductCollectionsResource
+from .resources.product_facets import ProductFacetsResource
+from .resources.product_syncs import ProductSyncsResource
+from .resources.products import ProductsResource
+from .resources.promotion_integrations import PromotionIntegrationsResource
+from .resources.promotions import PromotionsResource
+from .resources.security_profiles import SecurityProfilesResource
+from .resources.seller_approval_rules import SellerApprovalRulesResource
+from .resources.shipments import ShipmentsResource
+from .resources.specs import SpecsResource
+from .resources.spending_accounts import SpendingAccountsResource
+from .resources.subscription_integrations import SubscriptionIntegrationsResource
+from .resources.subscription_items import SubscriptionItemsResource
+from .resources.subscriptions import SubscriptionsResource
+from .resources.supplier_addresses import SupplierAddressesResource
+from .resources.supplier_user_groups import SupplierUserGroupsResource
+from .resources.supplier_users import SupplierUsersResource
+from .resources.suppliers import SuppliersResource
+from .resources.tracking_events import TrackingEventsResource
+from .resources.user_groups import UserGroupsResource
+from .resources.users import UsersResource
+from .resources.webhooks import WebhooksResource
+from .resources.xp_indices import XpIndicesResource
+
+__all__ = ["OrderCloudClient"]
+
+
+class OrderCloudClient:
+    """Async client for the OrderCloud API.
+
+    Provides access to all API resources as attributes.  Handles
+    authentication (OAuth2 client credentials or password grant) and
+    token lifecycle automatically.
+
+    Usage::
+
+        async with OrderCloudClient(config) as client:
+            products = await client.products.list()
+    """
+
+    def __init__(self, config: OrderCloudConfig) -> None:
+        self._config = config
+        self._token_manager = TokenManager(config)
+        self._http = HttpClient(config, self._token_manager)
+
+        # Resource accessors.
+        self.addresses = AddressesResource(self._http)
+        self.admin_addresses = AdminAddressesResource(self._http)
+        self.admin_user_groups = AdminUserGroupsResource(self._http)
+        self.admin_users = AdminUsersResource(self._http)
+        self.api_clients = ApiClientsResource(self._http)
+        self.approval_rules = ApprovalRulesResource(self._http)
+        self.bundle_line_items = BundleLineItemsResource(self._http)
+        self.bundle_subscription_items = BundleSubscriptionItemsResource(self._http)
+        self.bundles = BundlesResource(self._http)
+        self.buyer_groups = BuyerGroupsResource(self._http)
+        self.buyers = BuyersResource(self._http)
+        self.cart = CartResource(self._http)
+        self.catalogs = CatalogsResource(self._http)
+        self.categories = CategoriesResource(self._http)
+        self.cost_centers = CostCentersResource(self._http)
+        self.credit_cards = CreditCardsResource(self._http)
+        self.delivery_configurations = DeliveryConfigurationsResource(self._http)
+        self.discounts = DiscountsResource(self._http)
+        self.entity_syncs = EntitySyncsResource(self._http)
+        self.error_configs = ErrorConfigsResource(self._http)
+        self.forgotten_credentials = ForgottenCredentialsResource(self._http)
+        self.group_orders = GroupOrdersResource(self._http)
+        self.impersonation_configs = ImpersonationConfigsResource(self._http)
+        self.incrementors = IncrementorsResource(self._http)
+        self.integration_events = IntegrationEventsResource(self._http)
+        self.inventory_integrations = InventoryIntegrationsResource(self._http)
+        self.inventory_records = InventoryRecordsResource(self._http)
+        self.line_items = LineItemsResource(self._http)
+        self.locales = LocalesResource(self._http)
+        self.me = MeResource(self._http)
+        self.message_senders = MessageSendersResource(self._http)
+        self.open_id_connects = OpenIdConnectsResource(self._http)
+        self.order_returns = OrderReturnsResource(self._http)
+        self.order_syncs = OrderSyncsResource(self._http)
+        self.orders = OrdersResource(self._http)
+        self.payments = PaymentsResource(self._http)
+        self.price_schedules = PriceSchedulesResource(self._http)
+        self.product_collections = ProductCollectionsResource(self._http)
+        self.product_facets = ProductFacetsResource(self._http)
+        self.product_syncs = ProductSyncsResource(self._http)
+        self.products = ProductsResource(self._http)
+        self.promotion_integrations = PromotionIntegrationsResource(self._http)
+        self.promotions = PromotionsResource(self._http)
+        self.security_profiles = SecurityProfilesResource(self._http)
+        self.seller_approval_rules = SellerApprovalRulesResource(self._http)
+        self.shipments = ShipmentsResource(self._http)
+        self.specs = SpecsResource(self._http)
+        self.spending_accounts = SpendingAccountsResource(self._http)
+        self.subscription_integrations = SubscriptionIntegrationsResource(self._http)
+        self.subscription_items = SubscriptionItemsResource(self._http)
+        self.subscriptions = SubscriptionsResource(self._http)
+        self.supplier_addresses = SupplierAddressesResource(self._http)
+        self.supplier_user_groups = SupplierUserGroupsResource(self._http)
+        self.supplier_users = SupplierUsersResource(self._http)
+        self.suppliers = SuppliersResource(self._http)
+        self.tracking_events = TrackingEventsResource(self._http)
+        self.user_groups = UserGroupsResource(self._http)
+        self.users = UsersResource(self._http)
+        self.webhooks = WebhooksResource(self._http)
+        self.xp_indices = XpIndicesResource(self._http)
+
+    @classmethod
+    def create(
+        cls,
+        *,
+        client_id: str,
+        client_secret: str,
+        base_url: str = "https://api.ordercloud.io/v1",
+        auth_url: str = "https://auth.ordercloud.io/oauth/token",
+        scopes: list[str] | None = None,
+        timeout: float = 30.0,
+        max_retries: int = 0,
+        retry_backoff: float = 0.5,
+    ) -> OrderCloudClient:
+        """Create a client from individual parameters.
+
+        Args:
+            client_id: OAuth2 client ID.
+            client_secret: OAuth2 client secret.
+            base_url: API base URL (default: US production).
+            auth_url: OAuth2 token endpoint.
+            scopes: Requested scopes (default: ``["FullAccess"]``).
+            timeout: HTTP request timeout in seconds.
+            max_retries: Max retries on 429/5xx (0 = disabled).
+            retry_backoff: Base delay in seconds for exponential backoff.
+
+        Returns:
+            A configured ``OrderCloudClient`` instance.
+        """
+        config = OrderCloudConfig(
+            client_id=client_id,
+            client_secret=client_secret,
+            base_url=base_url,
+            auth_url=auth_url,
+            scopes=tuple(scopes) if scopes else ("FullAccess",),
+            timeout=timeout,
+            max_retries=max_retries,
+            retry_backoff=retry_backoff,
+        )
+        return cls(config)
+
+    def add_before_request(self, hook: "BeforeRequest") -> None:
+        """Register a hook called before each HTTP request."""
+        self._http.add_before_request(hook)
+
+    def add_after_response(self, hook: "AfterResponse") -> None:
+        """Register a hook called after each HTTP response."""
+        self._http.add_after_response(hook)
+
+    async def close(self) -> None:
+        """Close the underlying HTTP client."""
+        await self._http.close()
+
+    async def __aenter__(self) -> OrderCloudClient:
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        await self.close()

ordercloud/config.py

@@ -0,0 +1,42 @@
+"""OrderCloud client configuration."""
+
+from dataclasses import dataclass
+
+__all__ = ["OrderCloudConfig"]
+
+
+@dataclass(frozen=True)
+class OrderCloudConfig:
+    """Immutable configuration for an OrderCloud API client.
+
+    Attributes:
+        client_id: OAuth2 client ID for API access.
+        client_secret: OAuth2 client secret (empty for public clients).
+        base_url: OrderCloud API base URL (including ``/v1``).
+        auth_url: OAuth2 token endpoint URL.
+        scopes: OAuth2 scopes to request (converted to tuple for immutability).
+        timeout: HTTP request timeout in seconds.
+        max_retries: Maximum number of retries on 429/5xx responses (0 = disabled).
+        retry_backoff: Base delay in seconds for exponential backoff between retries.
+    """
+
+    client_id: str
+    client_secret: str = ""
+    base_url: str = "https://api.ordercloud.io/v1"
+    auth_url: str = "https://auth.ordercloud.io/oauth/token"
+    scopes: tuple[str, ...] = ("FullAccess",)
+    timeout: float = 30.0
+    max_retries: int = 0
+    retry_backoff: float = 0.5
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.scopes, tuple):
+            object.__setattr__(self, "scopes", tuple(self.scopes))
+
+    def __repr__(self) -> str:
+        return (
+            f"OrderCloudConfig(client_id={self.client_id!r}, "
+            f"client_secret='***', "
+            f"base_url={self.base_url!r}, "
+            f"auth_url={self.auth_url!r})"
+        )

ordercloud/errors.py

@@ -0,0 +1,47 @@
+"""OrderCloud API error types."""
+
+from dataclasses import dataclass
+from typing import Any, Optional
+
+__all__ = ["ApiError", "OrderCloudError", "AuthenticationError"]
+
+
+@dataclass
+class ApiError:
+    """A single error returned by the OrderCloud API.
+
+    Attributes:
+        error_code: Machine-readable error code (e.g. ``"NotFound"``).
+        message: Human-readable error description.
+        data: Optional structured data associated with the error.
+    """
+
+    error_code: str
+    message: str
+    data: Any = None
+
+
+class OrderCloudError(Exception):
+    """Raised when the OrderCloud API returns an error response.
+
+    Attributes:
+        status_code: The HTTP status code.
+        errors: List of individual API errors from the response body.
+        raw: The raw JSON response body, if available.
+    """
+
+    def __init__(
+        self,
+        status_code: int,
+        errors: list[ApiError],
+        raw: Optional[dict[str, Any]] = None,
+    ) -> None:
+        self.status_code = status_code
+        self.errors = errors
+        self.raw = raw
+        messages = "; ".join(e.message for e in errors)
+        super().__init__(f"OrderCloud {status_code}: {messages}")
+
+
+class AuthenticationError(OrderCloudError):
+    """Raised on 401/403 responses from the OrderCloud API."""

ordercloud/http.py

@@ -0,0 +1,218 @@
+"""Low-level HTTP client for the OrderCloud API."""
+
+import asyncio
+import logging
+from typing import Any, Optional
+
+import httpx
+
+from .auth import TokenManager
+from .config import OrderCloudConfig
+from .errors import ApiError, AuthenticationError, OrderCloudError
+from .middleware import AfterResponse, BeforeRequest, RequestContext, ResponseContext
+
+__all__ = ["HttpClient"]
+
+logger = logging.getLogger("ordercloud")
+
+_RETRYABLE_STATUSES = frozenset({429, 500, 502, 503, 504})
+
+
+class HttpClient:
+    """Async HTTP client with automatic authentication and error handling.
+
+    Wraps ``httpx.AsyncClient`` to inject bearer tokens, strip ``None``
+    query parameters, raise typed exceptions on error responses, and
+    optionally retry on transient failures (429, 5xx) with exponential
+    backoff.
+
+    Supports before-request and after-response middleware hooks for
+    custom header injection, logging, metrics, etc.
+
+    Args:
+        config: The client configuration.
+        token_manager: The token manager for acquiring bearer tokens.
+    """
+
+    def __init__(self, config: OrderCloudConfig, token_manager: TokenManager) -> None:
+        self._config = config
+        self._token_manager = token_manager
+        self._client = httpx.AsyncClient(timeout=config.timeout)
+        self._before_request: list[BeforeRequest] = []
+        self._after_response: list[AfterResponse] = []
+
+    def add_before_request(self, hook: BeforeRequest) -> None:
+        """Register a hook called before each HTTP request.
+
+        The hook receives a mutable ``RequestContext`` and can modify
+        headers, params, or the JSON body before the request is sent.
+        """
+        self._before_request.append(hook)
+
+    def add_after_response(self, hook: AfterResponse) -> None:
+        """Register a hook called after each HTTP response.
+
+        The hook receives a ``ResponseContext`` with the request details
+        and the response.  Called on every attempt, including retries.
+        """
+        self._after_response.append(hook)
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Optional[dict[str, Any]] = None,
+        json: Optional[dict[str, Any]] = None,
+    ) -> httpx.Response:
+        """Make an authenticated request to the OrderCloud API.
+
+        Args:
+            method: HTTP method (e.g. ``"GET"``, ``"POST"``).
+            path: API path relative to the base URL (e.g. ``"/products"``).
+            params: Query parameters (``None`` values are stripped).
+            json: JSON request body.
+
+        Returns:
+            The HTTP response.
+
+        Raises:
+            AuthenticationError: On 401 or 403 responses.
+            OrderCloudError: On any other 4xx/5xx response.
+        """
+        url = f"{self._config.base_url}{path}"
+
+        if params:
+            params = {k: v for k, v in params.items() if v is not None}
+
+        max_attempts = 1 + self._config.max_retries
+
+        for attempt in range(max_attempts):
+            token = await self._token_manager.get_token(self._client)
+            headers = {"Authorization": f"Bearer {token}"}
+
+            ctx = RequestContext(
+                method=method,
+                path=path,
+                url=url,
+                headers=dict(headers),
+                params=dict(params) if params else None,
+                json=dict(json) if json else None,
+            )
+
+            for hook in self._before_request:
+                await hook(ctx)
+
+            logger.debug("Request: %s %s", method, path)
+
+            resp = await self._client.request(
+                ctx.method,
+                ctx.url,
+                headers=ctx.headers,
+                params=ctx.params,
+                json=ctx.json,
+            )
+
+            logger.debug("Response: %s %s %d", method, path, resp.status_code)
+
+            resp_ctx = ResponseContext(request=ctx, response=resp, attempt=attempt)
+            for after_hook in self._after_response:
+                await after_hook(resp_ctx)
+
+            if resp.status_code < 400:
+                return resp
+
+            if resp.status_code in _RETRYABLE_STATUSES and attempt < max_attempts - 1:
+                delay = self._retry_delay(resp, attempt)
+                logger.warning(
+                    "Retry %d/%d: %s %s returned %d, waiting %.1fs",
+                    attempt + 1,
+                    self._config.max_retries,
+                    method,
+                    path,
+                    resp.status_code,
+                    delay,
+                )
+                await asyncio.sleep(delay)
+                continue
+
+            self._raise_error(resp)
+
+        # Unreachable — loop always returns or raises
+        raise AssertionError("unreachable")  # pragma: no cover
+
+    def _retry_delay(self, resp: httpx.Response, attempt: int) -> float:
+        """Calculate the delay before the next retry attempt.
+
+        Respects the ``Retry-After`` header if present, otherwise uses
+        exponential backoff: ``retry_backoff * 2^attempt``.
+        """
+        max_delay = 120.0
+        retry_after = resp.headers.get("Retry-After")
+        if retry_after:
+            try:
+                return min(float(retry_after), max_delay)
+            except ValueError:
+                pass
+        delay: float = self._config.retry_backoff * (2**attempt)
+        return min(delay, max_delay)
+
+    async def get(self, path: str, **params: Any) -> httpx.Response:
+        """Send a GET request."""
+        return await self.request("GET", path, params=params or None)
+
+    async def post(
+        self,
+        path: str,
+        json: Optional[dict[str, Any]] = None,
+        params: Optional[dict[str, Any]] = None,
+    ) -> httpx.Response:
+        """Send a POST request."""
+        return await self.request("POST", path, json=json, params=params)
+
+    async def put(
+        self,
+        path: str,
+        json: Optional[dict[str, Any]] = None,
+        params: Optional[dict[str, Any]] = None,
+    ) -> httpx.Response:
+        """Send a PUT request."""
+        return await self.request("PUT", path, json=json, params=params)
+
+    async def patch(
+        self,
+        path: str,
+        json: Optional[dict[str, Any]] = None,
+        params: Optional[dict[str, Any]] = None,
+    ) -> httpx.Response:
+        """Send a PATCH request."""
+        return await self.request("PATCH", path, json=json, params=params)
+
+    async def delete(self, path: str, **params: Any) -> httpx.Response:
+        """Send a DELETE request."""
+        return await self.request("DELETE", path, params=params or None)
+
+    async def close(self) -> None:
+        """Close the underlying HTTP client and release connections."""
+        await self._client.aclose()
+
+    @staticmethod
+    def _raise_error(resp: httpx.Response) -> None:
+        """Parse an error response and raise the appropriate exception."""
+        try:
+            body = resp.json()
+            errors = [
+                ApiError(
+                    error_code=e.get("ErrorCode", ""),
+                    message=e.get("Message", ""),
+                    data=e.get("Data"),
+                )
+                for e in body.get("Errors", [])
+            ]
+        except Exception:
+            errors = [ApiError(error_code="Unknown", message=resp.text)]
+            body = None
+
+        if resp.status_code in (401, 403):
+            raise AuthenticationError(resp.status_code, errors, raw=body)
+        raise OrderCloudError(resp.status_code, errors, raw=body)