mpt-api-client 0.0.1__py3-none-any.whl

mpt_api_client/__init__.py

@@ -0,0 +1,4 @@
+from mpt_api_client.mpt_client import AsyncMPTClient, MPTClient
+from mpt_api_client.rql import RQLQuery
+
+__all__ = ["AsyncMPTClient", "MPTClient", "RQLQuery"]  # noqa: WPS410

mpt_api_client/exceptions.py

@@ -0,0 +1,69 @@
+import json
+from typing import override
+
+from httpx import HTTPStatusError
+
+
+class MPTError(Exception):
+    """Represents a generic MPT error."""
+
+
+class MPTHttpError(MPTError):
+    """Represents an HTTP error."""
+
+    def __init__(self, status_code: int, message: str, body: str):
+        self.status_code = status_code
+        self.body = body
+        super().__init__(f"HTTP {status_code}: {message}")
+
+
+class MPTAPIError(MPTHttpError):
+    """Represents an API error."""
+
+    def __init__(self, status_code: int, message: str, payload: dict[str, str]):
+        super().__init__(status_code, message, json.dumps(payload))
+        self.payload = payload
+        self.status: str | None = payload.get("status") or payload.get("statusCode")
+        self.title: str | None = payload.get("title") or payload.get("message")
+        self.detail: str | None = payload.get("detail") or message
+        self.trace_id: str | None = payload.get("traceId")
+        self.errors: str | None = payload.get("errors")
+
+    @override
+    def __str__(self) -> str:
+        base = f"{self.status} {self.title} - {self.detail} ({self.trace_id or 'no-trace-id'})"  # noqa: WPS221 WPS237
+
+        if self.errors:
+            return f"{base}\n{json.dumps(self.errors, indent=2)}"
+        return base
+
+    @override
+    def __repr__(self) -> str:
+        return str(self.payload)
+
+
+def transform_http_status_exception(http_status_exception: HTTPStatusError) -> MPTError:
+    """Transforms httpx exceptions into MPT exceptions.
+
+    Attempts to extract API related information from HTTPStatusError and
+    raises MPTAPIError or MPTHttpError.
+
+    Args:
+        http_status_exception: Native httpx exception
+
+    Returns:
+        MPTError
+    """
+    try:
+        return MPTAPIError(
+            status_code=http_status_exception.response.status_code,
+            message=http_status_exception.args[0],
+            payload=http_status_exception.response.json(),
+        )
+    except json.JSONDecodeError:
+        body = http_status_exception.response.content.decode()
+        return MPTHttpError(
+            status_code=http_status_exception.response.status_code,
+            message=http_status_exception.args[0],
+            body=body,
+        )

mpt_api_client/http/__init__.py

@@ -0,0 +1,11 @@
+from mpt_api_client.http.async_client import AsyncHTTPClient
+from mpt_api_client.http.async_service import AsyncService
+from mpt_api_client.http.client import HTTPClient
+from mpt_api_client.http.service import Service
+
+__all__ = [  # noqa: WPS410
+    "AsyncHTTPClient",
+    "AsyncService",
+    "HTTPClient",
+    "Service",
+]

mpt_api_client/http/async_client.py

@@ -0,0 +1,106 @@
+import os
+from typing import Any
+
+from httpx import (
+    AsyncClient,
+    AsyncHTTPTransport,
+    HTTPError,
+    HTTPStatusError,
+)
+
+from mpt_api_client.exceptions import MPTError, transform_http_status_exception
+from mpt_api_client.http.types import (
+    HeaderTypes,
+    QueryParam,
+    RequestFiles,
+    Response,
+)
+
+
+class AsyncHTTPClient:
+    """Async HTTP client for interacting with SoftwareOne Marketplace Platform API."""
+
+    def __init__(
+        self,
+        *,
+        base_url: str | None = None,
+        api_token: str | None = None,
+        timeout: float = 5.0,
+        retries: int = 5,
+    ):
+        api_token = api_token or os.getenv("MPT_TOKEN")
+        if not api_token:
+            raise ValueError(
+                "API token is required. "
+                "Set it up as env variable MPT_TOKEN or pass it as `api_token` "
+                "argument to MPTClient."
+            )
+
+        base_url = base_url or os.getenv("MPT_URL")
+        if not base_url:
+            raise ValueError(
+                "Base URL is required. "
+                "Set it up as env variable MPT_URL or pass it as `base_url` "
+                "argument to MPTClient."
+            )
+        base_headers = {
+            "User-Agent": "swo-marketplace-client/1.0",
+            "Authorization": f"Bearer {api_token}",
+            "Accept": "application/json",
+        }
+        self.httpx_client = AsyncClient(
+            base_url=base_url,
+            headers=base_headers,
+            timeout=timeout,
+            transport=AsyncHTTPTransport(retries=retries),
+        )
+
+    async def request(  # noqa: WPS211
+        self,
+        method: str,
+        url: str,
+        *,
+        files: RequestFiles | None = None,
+        json: Any | None = None,
+        query_params: QueryParam | None = None,
+        headers: HeaderTypes | None = None,
+    ) -> Response:
+        """Perform an HTTP request.
+
+        Args:
+            method: HTTP method.
+            url: URL to send the request to.
+            files: Request files.
+            json: Request JSON data.
+            query_params: Query parameters.
+            headers: Request headers.
+
+        Returns:
+            Response object.
+
+        Raises:
+            MPTError: If the request fails.
+            MPTApiError: If the response contains an error.
+            MPTHttpError: If the response contains an HTTP error.
+        """
+        try:
+            response = await self.httpx_client.request(
+                method,
+                url,
+                files=files,
+                json=json,
+                params=query_params,
+                headers=headers,
+            )
+        except HTTPError as err:
+            raise MPTError(f"HTTP Error: {err}") from err
+
+        try:
+            response.raise_for_status()
+        except HTTPStatusError as http_status_exception:
+            raise transform_http_status_exception(http_status_exception) from http_status_exception
+        return Response(
+            headers=dict(response.headers),
+            status_code=response.status_code,
+            content=response.content,
+        )

mpt_api_client/http/async_service.py

@@ -0,0 +1,74 @@
+from urllib.parse import urljoin
+
+from mpt_api_client.http.async_client import AsyncHTTPClient
+from mpt_api_client.http.base_service import ServiceBase
+from mpt_api_client.http.types import QueryParam, Response
+from mpt_api_client.models import Model as BaseModel
+from mpt_api_client.models import ResourceData
+from mpt_api_client.models.collection import ResourceList
+
+
+class AsyncService[Model: BaseModel](ServiceBase[AsyncHTTPClient, Model]):  # noqa: WPS214
+    """Immutable Service for RESTful resource collections.
+
+    Examples:
+        active_orders_cc = order_collection.filter(RQLQuery(status="active"))
+        active_orders = active_orders_cc.order_by("created").iterate()
+        product_active_orders = active_orders_cc.filter(RQLQuery(product__id="PRD-1")).iterate()
+
+        new_order = order_collection.create(order_data)
+
+    """
+
+    async def _resource_do_request(  # noqa: WPS211
+        self,
+        resource_id: str,
+        method: str = "GET",
+        action: str | None = None,
+        json: ResourceData | ResourceList | None = None,
+        query_params: QueryParam | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Response:
+        """Perform an action on a specific resource using.
+
+        Request with action: `HTTP_METHOD /endpoint/{resource_id}/{action}`.
+        Request without action: `HTTP_METHOD /endpoint/{resource_id}`.
+
+        Args:
+            resource_id: The resource ID to operate on.
+            method: The HTTP method to use.
+            action: The action name to use.
+            json: The updated resource data.
+            query_params: Additional query parameters.
+            headers: Additional headers.
+
+        Raises:
+            HTTPError: If the action fails.
+        """
+        resource_url = urljoin(f"{self.path}/", resource_id)
+        url = urljoin(f"{resource_url}/", action) if action else resource_url
+        return await self.http_client.request(
+            method, url, json=json, query_params=query_params, headers=headers
+        )
+
+    async def _resource_action(
+        self,
+        resource_id: str,
+        method: str = "GET",
+        action: str | None = None,
+        json: ResourceData | ResourceList | None = None,
+        query_params: QueryParam | None = None,
+    ) -> Model:
+        """Perform an action on a specific resource using `HTTP_METHOD /endpoint/{resource_id}`.
+
+        Args:
+            resource_id: The resource ID to operate on.
+            method: The HTTP method to use.
+            action: The action name to use.
+            json: The updated resource data.
+            query_params: Additional query parameters.
+        """
+        response = await self._resource_do_request(
+            resource_id, method, action, json=json, query_params=query_params
+        )
+        return self._model_class.from_response(response)

mpt_api_client/http/base_service.py

@@ -0,0 +1,58 @@
+from typing import Any
+
+from mpt_api_client.http.query_state import QueryState
+from mpt_api_client.http.types import Response
+from mpt_api_client.models import Collection, Meta
+from mpt_api_client.models import Model as BaseModel
+
+
+class ServiceBase[Client, Model: BaseModel]:  # noqa: WPS214
+    """Service base with agnostic HTTP client."""
+
+    _endpoint: str
+    _model_class: type[Model]
+    _collection_key = "data"
+
+    def __init__(
+        self,
+        *,
+        http_client: Client,
+        query_state: QueryState | None = None,
+        endpoint_params: dict[str, str] | None = None,
+    ) -> None:
+        self.http_client = http_client
+        self.query_state = query_state or QueryState()
+        self.endpoint_params = endpoint_params or {}
+
+    @property
+    def path(self) -> str:
+        """Service endpoint URL."""
+        return self._endpoint.format(**self.endpoint_params)
+
+    def build_path(
+        self,
+        query_params: dict[str, Any] | None = None,
+    ) -> str:
+        """Builds the endpoint URL with all the query parameters.
+
+        Returns:
+            Complete URL with query parameters.
+        """
+        query = self.query_state.build(query_params)
+        return f"{self.path}?{query}" if query else self.path
+
+    @classmethod
+    def make_collection(cls, response: Response) -> Collection[Model]:
+        """Builds a collection from a response.
+
+        Args:
+            response: The response object.
+        """
+        meta = Meta.from_response(response)
+        return Collection(
+            resources=[
+                cls._model_class.new(resource, meta)
+                for resource in response.json().get(cls._collection_key)
+            ],
+            meta=meta,
+        )

mpt_api_client/http/client.py

@@ -0,0 +1,108 @@
+import os
+from typing import Any
+
+from httpx import (
+    Client,
+    HTTPError,
+    HTTPStatusError,
+    HTTPTransport,
+)
+
+from mpt_api_client.exceptions import (
+    MPTError,
+    transform_http_status_exception,
+)
+from mpt_api_client.http.types import (
+    HeaderTypes,
+    QueryParam,
+    RequestFiles,
+    Response,
+)
+
+
+class HTTPClient:
+    """Sync HTTP client for interacting with SoftwareOne Marketplace Platform API."""
+
+    def __init__(
+        self,
+        *,
+        base_url: str | None = None,
+        api_token: str | None = None,
+        timeout: float = 5.0,
+        retries: int = 5,
+    ):
+        api_token = api_token or os.getenv("MPT_TOKEN")
+        if not api_token:
+            raise ValueError(
+                "API token is required. "
+                "Set it up as env variable MPT_TOKEN or pass it as `api_token` "
+                "argument to MPTClient."
+            )
+
+        base_url = base_url or os.getenv("MPT_URL")
+        if not base_url:
+            raise ValueError(
+                "Base URL is required. "
+                "Set it up as env variable MPT_URL or pass it as `base_url` "
+                "argument to MPTClient."
+            )
+        base_headers = {
+            "User-Agent": "swo-marketplace-client/1.0",
+            "Authorization": f"Bearer {api_token}",
+        }
+        self.httpx_client = Client(
+            base_url=base_url,
+            headers=base_headers,
+            timeout=timeout,
+            transport=HTTPTransport(retries=retries),
+        )
+
+    def request(  # noqa: WPS211
+        self,
+        method: str,
+        url: str,
+        *,
+        files: RequestFiles | None = None,
+        json: Any | None = None,
+        query_params: QueryParam | None = None,
+        headers: HeaderTypes | None = None,
+    ) -> Response:
+        """Perform an HTTP request.
+
+        Args:
+            method: HTTP method.
+            url: URL to send the request to.
+            files: Request files.
+            json: Request JSON data.
+            query_params: Query parameters.
+            headers: Request headers.
+
+        Returns:
+            Response object.
+
+        Raises:
+            MPTError: If the request fails.
+            MPTApiError: If the response contains an error.
+            MPTHttpError: If the response contains an HTTP error.
+        """
+        try:
+            response = self.httpx_client.request(
+                method,
+                url,
+                files=files,
+                json=json,
+                params=query_params,
+                headers=headers,
+            )
+        except HTTPError as err:
+            raise MPTError(f"HTTP Error: {err}") from err
+
+        try:
+            response.raise_for_status()
+        except HTTPStatusError as http_status_exception:
+            raise transform_http_status_exception(http_status_exception) from http_status_exception
+        return Response(
+            headers=dict(response.headers),
+            status_code=response.status_code,
+            content=response.content,
+        )