luml_api 0.1.0__py3-none-any.whl

luml_api/__init__.py

@@ -0,0 +1,51 @@
+__version__ = "0.1.0"
+__title__ = "luml-sdk"
+
+from luml_api._client import AsyncLumlClient, LumlClient
+from luml_api._exceptions import (
+    APIError,
+    APIResponseValidationError,
+    APIStatusError,
+    AuthenticationError,
+    BadRequestError,
+    ConflictError,
+    InternalServerError,
+    LumlAPIError,
+    NotFoundError,
+    PermissionDeniedError,
+    UnprocessableEntityError,
+)
+from luml_api._types import (
+    ArtifactSortBy,
+    ArtifactStatus,
+    ArtifactType,
+    CollectionSortBy,
+    CollectionType,
+    CollectionTypeFilter,
+    SortOrder,
+)
+
+__all__ = [
+    "__version__",
+    "__title__",
+    "LumlClient",
+    "AsyncLumlClient",
+    "LumlAPIError",
+    "APIError",
+    "APIResponseValidationError",
+    "APIStatusError",
+    "BadRequestError",
+    "AuthenticationError",
+    "PermissionDeniedError",
+    "NotFoundError",
+    "ConflictError",
+    "UnprocessableEntityError",
+    "InternalServerError",
+    "ArtifactSortBy",
+    "ArtifactStatus",
+    "ArtifactType",
+    "CollectionSortBy",
+    "CollectionType",
+    "CollectionTypeFilter",
+    "SortOrder",
+]

luml_api/_base_client.py

@@ -0,0 +1,284 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+import httpx
+from httpx import URL
+
+from luml_api._exceptions import (
+    APIStatusError,
+    AuthenticationError,
+    BadRequestError,
+    ConflictError,
+    InternalServerError,
+    NotFoundError,
+    PermissionDeniedError,
+    UnprocessableEntityError,
+)
+
+
+class BaseClient(ABC):
+    def __init__(
+        self,
+        base_url: str | URL,
+        timeout: float = 30.0,
+    ) -> None:
+        self._base_url: URL = URL(base_url) if isinstance(base_url, str) else base_url
+        self._timeout: float = timeout
+
+    @property
+    def base_url(self) -> URL:
+        return self._base_url
+
+    @base_url.setter
+    def base_url(self, url: URL) -> None:
+        self._base_url = url
+
+    @property
+    def timeout(self) -> float:
+        return self._timeout
+
+    @timeout.setter
+    def timeout(self, timeout: float) -> None:
+        self._timeout = timeout
+
+    @property
+    def auth_headers(self) -> dict[str, str]:
+        return {}
+
+    @property
+    def default_headers(self) -> dict[str, str]:
+        return {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": "luml-sdk/0.1.0",
+            **self.auth_headers,
+        }
+
+    @staticmethod
+    def _make_status_error(
+        err_msg: str,
+        *,
+        body: object,
+        response: httpx.Response,
+    ) -> APIStatusError:
+        if response.status_code == 400:
+            return BadRequestError(err_msg, response=response, body=body)
+
+        if response.status_code == 401:
+            return AuthenticationError(err_msg, response=response, body=body)
+
+        if response.status_code == 403:
+            return PermissionDeniedError(err_msg, response=response, body=body)
+
+        if response.status_code == 404:
+            return NotFoundError(err_msg, response=response, body=body)
+
+        if response.status_code == 409:
+            return ConflictError(err_msg, response=response, body=body)
+
+        if response.status_code == 422:
+            return UnprocessableEntityError(err_msg, response=response, body=body)
+
+        if response.status_code >= 500:
+            return InternalServerError(err_msg, response=response, body=body)
+        return APIStatusError(err_msg, response=response, body=body)
+
+    @abstractmethod
+    def _process_response(self, response: httpx.Response) -> Any:  # noqa: ANN401
+        raise NotImplementedError()
+
+    @abstractmethod
+    def request(
+        self,
+        method: str,
+        url: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> Any:  # noqa: ANN401
+        raise NotImplementedError()
+
+    def get(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        raise NotImplementedError()
+
+    def post(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        raise NotImplementedError()
+
+    def patch(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        raise NotImplementedError()
+
+    def delete(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        raise NotImplementedError()
+
+    def put(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        raise NotImplementedError()
+
+    @staticmethod
+    def filter_none(data: dict[str, Any]) -> dict[str, Any]:  # noqa: ANN401
+        return {key: value for key, value in data.items() if value is not None}
+
+
+class SyncBaseClient(BaseClient):
+    _client: httpx.Client
+
+    def __init__(
+        self,
+        base_url: str | URL,
+        timeout: float = 30.0,
+    ) -> None:
+        self._client = httpx.Client(base_url=base_url, timeout=timeout)
+        super().__init__(base_url=base_url, timeout=timeout)
+
+    def _process_response(self, response: httpx.Response) -> dict | None:
+        if response.status_code >= 400:
+            try:
+                body = response.json()
+            except Exception:
+                body = response.text if response.content else None
+
+            error_detail = ""
+            if isinstance(body, dict) and "detail" in body:
+                error_detail = f": {body['detail']}"
+
+            raise self._make_status_error(
+                f"\nError response {response.status_code} "
+                f"while requesting {response.request.method} "
+                f"{response.url}\n{error_detail}",
+                body=body,
+                response=response,
+            )
+
+        if response.status_code == 204 or not response.content:
+            return None
+        try:
+            return response.json()
+        except Exception as e:
+            raise InternalServerError(
+                f"Failed to parse response from "
+                f"{response.request.method} {response.url}: {e}",
+                response=response,
+                body=response.text,
+            ) from e
+
+    def request(
+        self,
+        method: str,
+        url: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> Any:  # noqa: ANN401
+        final_headers = {**self.default_headers}
+        if headers:
+            final_headers.update(headers)
+
+        response = self._client.request(
+            method=method,
+            url=url,
+            headers=final_headers,
+            json=json,
+            params=params,
+            **kwargs,
+        )
+        return self._process_response(response)
+
+    def get(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        return self.request("GET", url, **kwargs)
+
+    def post(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        return self.request("POST", url, **kwargs)
+
+    def patch(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        return self.request("PATCH", url, **kwargs)
+
+    def delete(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        return self.request("DELETE", url, **kwargs)
+
+    def put(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        return self.request("PUT", url, **kwargs)
+
+
+class AsyncBaseClient(BaseClient):
+    _client: httpx.AsyncClient
+
+    def __init__(
+        self,
+        base_url: str | URL,
+        timeout: float = 30.0,
+    ) -> None:
+        self._client = httpx.AsyncClient(base_url=base_url, timeout=timeout)
+        super().__init__(base_url=base_url, timeout=timeout)
+
+    async def _process_response(self, response: httpx.Response) -> dict | None:
+        if response.status_code >= 400:
+            try:
+                body = response.json()
+            except Exception:
+                body = response.text if response.content else None
+
+            error_detail = ""
+            if isinstance(body, dict) and "detail" in body:
+                error_detail = f": {body['detail']}"
+
+            raise self._make_status_error(
+                f"\nError response {response.status_code} "
+                f"while requesting {response.request.method} "
+                f"{response.url}\n{error_detail}",
+                body=body,
+                response=response,
+            )
+
+        if response.status_code == 204 or not response.content:
+            return None
+        try:
+            return response.json()
+        except Exception as e:
+            raise InternalServerError(
+                f"Failed to parse response from "
+                f"{response.request.method} {response.url}: {e}",
+                response=response,
+                body=response.text,
+            ) from e
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> Any:  # noqa: ANN401
+        final_headers = {**self.default_headers}
+        if headers:
+            final_headers.update(headers)
+
+        response = await self._client.request(
+            method=method,
+            url=url,
+            headers=final_headers,
+            json=json,
+            params=params,
+            **kwargs,
+        )
+        return await self._process_response(response)
+
+    async def get(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        return await self.request("GET", url, **kwargs)
+
+    async def post(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        return await self.request("POST", url, **kwargs)
+
+    async def patch(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        return await self.request("PATCH", url, **kwargs)
+
+    async def delete(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        return await self.request("DELETE", url, **kwargs)
+
+    async def put(self, url: str, **kwargs) -> Any:  # noqa: ANN401
+        return await self.request("PUT", url, **kwargs)